Ticket #6310: mythtv-svn-qt4.diff

File mythtv-svn-qt4.diff, 180.5 KB (added by crap@…, 12 years ago)

Mythtv patch to compile with Qt4

  • i18n/i18n.pro

     
    1717INSTALLS += trans
    1818
    1919SOURCES += dummy.c
     20QT += xml network  sql opengl qt3support

  • themes/themes.pro

     
    2020
    2121# Input
    2222SOURCES += dummy.c
     23QT += xml network  sql opengl qt3support

  • libs/libmythtv/dtvconfparserhelpers.h

     
    3232#ifndef _DTVCONFPARSERHELPERS_H_
    3333#define _DTVCONFPARSERHELPERS_H_
    3434
    35 #include <qstring.h>
     35#include <QString>
    3636
    3737// The following are a set of helper classes to allow easy translation
    3838// between the different string representations of various tuning params.

  • libs/libmythtv/linuxavcinfo.h

     
    1111#include <libavc1394/rom1394.h>
    1212
    1313// Qt headers
    14 #include <qmap.h>
     14#include <QMap>
    1515
    1616// MythTV headers
    1717#include "avcinfo.h"

  • libs/libmythtv/customedit.cpp

     
    1 #include <qlayout.h>
    2 #include <qpushbutton.h>
    3 #include <qlabel.h>
    4 #include <qcursor.h>
    5 #include <qdatetime.h>
    6 #include <qapplication.h>
    7 #include <qimage.h>
    8 #include <qpainter.h>
    9 #include <qsqldatabase.h>
     1#include <QLayout>
     2#include <QPushButton>
     3#include <QLabel>
     4#include <QCursor>
     5#include <QDateTime>
     6#include <QApplication>
     7#include <QImage>
     8#include <QPainter>
     9#include <QSqlDatabase>
     10#include <Q3HBoxLayout>
     11#include <Q3VBoxLayout>
    1012
    1113#include <unistd.h>
    1214
    … …  
    4749    exSuffix = QString(" (%1)").arg(tr("stored example"));
    4850    addString = tr("Add");
    4951
    50     QVBoxLayout *vbox = new QVBoxLayout();
     52    Q3VBoxLayout *vbox = new Q3VBoxLayout();
    5153    vbox->setMargin((int)(20 * wmult));
    5254    setLayout(vbox);
    5355
    5456    // Edit selection
    55     QHBoxLayout *edit_hbox = new QHBoxLayout();
     57    Q3HBoxLayout *edit_hbox = new Q3HBoxLayout();
    5658    edit_hbox->setMargin((int)(10 * wmult));
    5759
    5860    QString message = tr("Edit Rule") + ": ";
    … …  
    100102    vbox->addWidget(edit_widget);
    101103
    102104    // Title edit box
    103     QHBoxLayout *title_hbox = new QHBoxLayout();
     105    Q3HBoxLayout *title_hbox = new Q3HBoxLayout();
    104106    title_hbox->setMargin((int)(10 * wmult));
    105107
    106108    message = tr("Rule Name") + ": ";
    … …  
    371373    vbox->addWidget(m_addButton);
    372374
    373375    // Subtitle edit box
    374     QHBoxLayout *subtitle_hbox = new QHBoxLayout();
     376    Q3HBoxLayout *subtitle_hbox = new Q3HBoxLayout();
    375377    subtitle_hbox->setMargin((int)(10 * wmult));
    376378
    377379    message = tr("Additional Tables") + ": ";
    … …  
    391393    vbox->addWidget(subtitle_widget);
    392394
    393395    // Bottom row buttons
    394     QHBoxLayout *buttons_hbox = new QHBoxLayout();
     396    Q3HBoxLayout *buttons_hbox = new Q3HBoxLayout();
    395397
    396398    //  Test Button
    397399    buttons_hbox->setMargin((int)(10 * wmult));

  • libs/libmythtv/channelscan/inputselectorsetting.cpp

     
    3333InputSelector::InputSelector(
    3434    uint _default_cardid, const QString &_default_inputname) :
    3535    ComboBoxSetting(this), sourceid(0), default_cardid(_default_cardid),
    36     default_inputname(Q3DeepCopy<QString>(_default_inputname))
     36    default_inputname(_default_inputname)
    3737{
    3838    setLabel(tr("Input"));
    3939}

  • libs/libmythtv/channelscan/scanmonitor.h

     
    3939
    4040class ChannelScanner;
    4141class SignalMonitorValue;
    42 class QString;
    4342
    4443class ScanMonitor :
    4544    public QObject,

  • libs/libmythtv/channelscan/scaninfo.h

     
    1010using namespace std;
    1111
    1212// Qt headers
    13 #include <qstring.h>
    14 #include <qdatetime.h>
     13#include <QString>
     14#include <QDateTime>
    1515
    1616// MythTV headers
    1717#include "dtvmultiplex.h"

  • libs/libmythtv/channelscan/channelscanner_cli.h

     
    3434#include <pthread.h>
    3535
    3636// Qt headers
    37 #include <qstring.h>
     37#include <QString>
    3838
    3939// MythTV headers
    4040#include "settings.h"

  • libs/libmythtv/channelscan/channelscan_sm.h

     
    3131#define SISCAN_H
    3232
    3333// Qt includes
    34 #include <qobject.h>
    35 #include <qstring.h>
    36 #include <qmap.h>
    37 #include <qmutex.h>
     34#include <QObject>
     35#include <QString>
     36#include <QMap>
     37#include <QMutex>
    3838#include <QList>
    39 #include <qdatetime.h>
     39#include <QDateTime>
    4040
    4141// MythTV includes
    4242#include "frequencytables.h"

  • libs/libmythtv/channelscan/channelimporter.cpp

     
    66 *
    77 */
    88
    9 // Qt headers
    10 #include <Q3DeepCopy>
    11 
    129// MythTV headers
    1310#include "mythdialogs.h"
    1411#include "mythdbcon.h"
    … …  
    2421{
    2522    if (str.isEmpty())
    2623        return "";
    27     return Q3DeepCopy<QString>(str);
     24    return str;
    2825}
    2926
    3027void ChannelImporter::Process(const ScanDTVTransportList &_transports)

  • libs/libmythtv/channelscan/scanmonitor.cpp

     
    3333#include "channelscanner.h"
    3434
    3535// Qt headers
    36 #include <qapplication.h>
    37 #include <Q3DeepCopy>
     36#include <QApplication>
    3837
    3938/// Percentage to set to after the transports have been scanned
    4039#define TRANSPORT_PCT 6
    … …  
    5150void post_event(QObject *dest, ScannerEvent::TYPE type, const QString &val)
    5251{
    5352    ScannerEvent *e = new ScannerEvent(type);
    54     e->strValue(Q3DeepCopy<QString>(val));
     53    e->strValue(val);
    5554    QApplication::postEvent(dest, e);
    5655}
    5756

  • libs/libmythtv/channelscan/scaninfo.cpp

     
    22#include <stdint.h>
    33
    44// Qt headers
    5 #include <qstring.h>
     5#include <QString>
    66
    77// MythTV headers
    88#include "scaninfo.h"

  • libs/libmythtv/channelscan/panedvbutilsimport.h

     
    3131#define _PANE_DVB_UTILS_IMPORT_H_
    3232
    3333// Qt headers
    34 #include <qstring.h>
    35 #include <qobject.h>
     34#include <QString>
     35#include <QObject>
    3636
    3737// MythTV headers
    3838#include "channelscanmiscsettings.h"

  • libs/libmythtv/channelscan/scanprogresspopup.h

     
    3131#define _SCAN_PROGRESS_POPUP_H_
    3232
    3333// Qt headesr
    34 #include <qwaitcondition.h>
     34#include <QWaitCondition>
    3535
    3636// MythTV headers
    3737#include "settings.h"

  • libs/libmythtv/channelscan/frequencytablesetting.cpp

     
    3030#include "frequencytablesetting.h"
    3131
    3232// Qt headers
    33 #include <qlocale.h>
     33#include <QLocale>
    3434
    3535ScanFrequencyTable::ScanFrequencyTable() : ComboBoxSetting(this)
    3636{

  • libs/libmythtv/channelscan/channelscan_sm.cpp

     
    3232#include <unistd.h>
    3333
    3434// Qt includes
    35 #include <qmutex.h>
     35#include <QMutex>
    3636
    3737// MythTV includes - General
    3838#include "channelscan_sm.h"
    … …  
    124124      sourceID(_sourceID),
    125125      signalTimeout(signal_timeout),
    126126      channelTimeout(channel_timeout),
    127       inputname(Q3DeepCopy<QString>(_inputname)),
     127      inputname(_inputname),
    128128      // State
    129129      scanning(false),
    130130      threadExit(false),
    … …  
    15421542            found = true;
    15431543            if (!channels[i].name.isEmpty())
    15441544            {
    1545                 service_name = Q3DeepCopy<QString>(channels[i].name);
    1546                 callsign     = Q3DeepCopy<QString>(channels[i].name);
     1545                service_name = channels[i].name;
     1546                callsign     = channels[i].name;
    15471547            }
    15481548        }
    15491549    }

  • libs/libmythtv/channelscan/channelscanner_gui.h

     
    3434#include <pthread.h>
    3535
    3636// Qt headers
    37 #include <qstring.h>
     37#include <QString>
    3838
    3939// MythTV headers
    4040#include "settings.h"

  • libs/libmythtv/dtvconfparser.cpp

     
    3131
    3232// Qt headers
    3333#include <QTextStream>
    34 #include <qfile.h>
     34#include <QFile>
    3535
    3636// MythTV headers
    3737#include "mythcontext.h"

  • libs/libmythtv/sr_items.cpp

     
    11#include "scheduledrecording.h"
    22#include "sr_items.h"
    3 #include <qlayout.h>
     3
     4#include <QLayout>
     5
    46#include "mythdialogs.h"
    57
    68
    7 
    89SRSchedOptionsGroup::SRSchedOptionsGroup(ScheduledRecording *_rec, ManagedList* _parentList,
    910                                         ManagedListGroup* _group, QObject* _parent)
    1011                   : ManagedListGroup( QObject::tr("Scheduling Options"), _group, _parentList,

  • libs/libmythtv/videoout_d3d.cpp

     
    1717#include "mmsystem.h"
    1818#include "tv.h"
    1919
    20 #include <qapplication.h>
     20#include <QApplication>
    2121
    2222#undef UNICODE
    2323

  • libs/libmythtv/dbchannelinfo.cpp

     
    22
    33// Qt headers
    44#include <QFile>
     5#include <QPixmap>
    56
    67// MythTV headers
    78#include "dbchannelinfo.h"

  • libs/libmythtv/tv.h

     
    11#ifndef TV_H
    22#define TV_H
    33
    4 #include <qstring.h>
     4#include <QString>
     5
    56#include "videoouttypes.h"
    67
    78/** \brief ChannelChangeDirection is an enumeration of possible channel

  • libs/libmythtv/dtvmultiplex.h

     
    1111#include <stdint.h>
    1212
    1313// Qt headers
    14 #include <qstring.h>
     14#include <QString>
    1515
    1616// MythTV headers
    1717#include "dtvconfparserhelpers.h"

  • libs/libmythtv/util-xv.cpp

     
    11// POSIX headers
    22#include <signal.h>
    33
     4// MythTH headers
     5#include "util-xv.h"
     6#include "util-x11.h"
     7
    48// C++ headers
    59#include <iostream>
    610#include <cstdlib>
    711using namespace std;
    812
    9 // MythTH headers
    10 #include "util-x11.h"
    11 #include "util-xv.h"
    12 
    1313// X11 headers
    1414#include <X11/Xatom.h>
    1515#include <X11/Xutil.h>

  • libs/libmythtv/eitcache.h

     
    99#include <stdint.h>
    1010
    1111// Qt headers
    12 #include <qmap.h>
    13 #include <qmutex.h>
    14 #include <qstring.h>
     12#include <QMap>
     13#include <QMutex>
     14#include <QString>
    1515
    1616#include "mythexp.h"
    1717

  • libs/libmythtv/cardutil.h

     
    1010using namespace std;
    1111
    1212// Qt headers
    13 #include <qstringlist.h>
    14 #include <qmap.h>
     13#include <QStringList>
     14#include <QMap>
    1515
    1616class InputInfo;
    1717class CardInput;

  • libs/libmythtv/playgroup.cpp

     
    11#include "mythcontext.h"
    22#include "mythdb.h"
    3 #include <qsqldatabase.h>
    4 #include <qcursor.h>
    5 #include <qlayout.h>
     3
     4#include <QSqlDatabase>
     5#include <QCursor>
     6#include <QLayout>
     7
    68#include <iostream>
     9
    710#include "playgroup.h"
    811#include "programinfo.h"
    912

  • libs/libmythtv/avcinfo.h

     
    88#include <stdint.h>
    99
    1010// Qt headers
    11 #include <qstring.h>
     11#include <QString>
    1212
    1313QString guid_to_string(uint64_t guid);
    1414uint64_t string_to_guid(const QString &guid);

  • libs/libmythtv/dbchannelinfo.h

     
    99using namespace std;
    1010
    1111// Qt headers
    12 #include <qstring.h>
    13 #include <qpixmap.h>
     12#include <QString>
     13#include <QPixmap>
    1414
    1515// MythTV headers
    1616#include "mythexp.h" // for MPUBLIC

  • libs/libmythtv/libmythtv.pro

     
    563563include ( ../libs-targetfix.pro )
    564564
    565565LIBS += $$LATE_LIBS
     566QT +=  opengl qt3support

  • libs/libmythtv/util-opengl.h

     
    2525#endif
    2626
    2727// Qt headers
    28 #include <qstring.h>
     28#include <QString>
    2929
    3030#ifndef GL_TEXTTURE0
    3131#define GL_TEXTURE0 0x84C0

  • libs/libmythtv/dvbrecorder.h

     
    1414using namespace std;
    1515
    1616// Qt includes
    17 #include <qmutex.h>
     17#include <QMutex>
    1818
    1919#include "dtvrecorder.h"
    2020#include "tspacket.h"

  • libs/libmythtv/guidegrid.h

     
    2424class ProgramInfo;
    2525class TimeInfo;
    2626class TV;
    27 class QTimer;
    28 class QWidget;
    2927
    3028#define MAX_DISPLAY_CHANS 12
    3129#define MAX_DISPLAY_TIMES 30

  • libs/libmythtv/dbox2epg.cpp

     
    44 *  Distributed as part of MythTV under GPL v2 and later.
    55 */
    66
    7 #include <qdatetime.h>
     7#include <QDateTime>
    88#include <QHttp>
    99
    1010#include "dbox2channel.h"

  • libs/libmythtv/osdtypes.h

     
    11#ifndef OSDDATATYPES_H_
    22#define OSDDATATYPES_H_
    33
    4 #include <qstring.h>
    5 #include <qrect.h>
    6 #include <qmap.h>
     4#include <QString>
     5#include <QRect>
     6#include <QMap>
    77#include <QKeyEvent>
     8#include <QObject>
     9#include <QRegExp>
     10#include <QColor>
     11
    812#include <vector>
    9 #include <qobject.h>
    10 #include <qregexp.h>
    1113#include <cmath>
    12 #include <qcolor.h>
    1314#include "cc708window.h"
    1415#include "osdimagecache.h"
    1516

  • libs/libmythtv/tv_play.h

     
    33#ifndef TVPLAY_H
    44#define TVPLAY_H
    55
    6 #include <qstring.h>
    7 #include <qmap.h>
    8 #include <qdatetime.h>
     6#include <pthread.h>
     7
     8#include <QString>
     9#include <QMap>
     10#include <QDateTime>
    911#include <QKeyEvent>
    1012#include <QEvent>
    11 #include <pthread.h>
    12 #include <qmutex.h>
    13 #include <qstringlist.h>
    14 #include <qregexp.h>
    15 #include <qwaitcondition.h>
     13#include <QTimerEvent>
     14#include <QMutex>
     15#include <QStringList>
     16#include <QRegExp>
     17#include <QWaitCondition>
    1618#include <QThread>
    1719#include <QReadWriteLock>
     20#include <QObject>
    1821
    1922#include "mythdeque.h"
    2023#include "tv.h"
    … …  
    2629#include "volumebase.h"
    2730#include "inputinfo.h"
    2831
    29 #include <qobject.h>
     32#include <vector>
    3033
    31 #include <vector>
    3234using namespace std;
    3335
    34 class QDateTime;
    3536class OSD;
    3637class RemoteEncoder;
    3738class NuppelVideoPlayer;

  • libs/libmythtv/eit.h

     
    55#include <vector>
    66using namespace std;
    77
    8 #include <qmap.h>
    9 #include <qstring.h>
    10 #include <qdatetime.h>
    11 #include <qstringlist.h>
     8#include <QMap>
     9#include <QString>
     10#include <QDateTime>
     11#include <QStringList>
    1212
    1313class MSqlQuery;
    1414

  • libs/libmythtv/scanwizardhelpers.h

     
    3636#include "compat.h"
    3737#include "settings.h"
    3838
    39 #include <qwaitcondition.h>
    40 #include <qevent.h>
     39#include <QWaitCondition>
     40#include <QEvent>
    4141
    4242class TransFreqTableSelector;
    4343class TransLabelSetting;

  • libs/libmythtv/dbox2recorder.h

     
    1616#include "dtvrecorder.h"
    1717
    1818class DBox2Channel;
    19 class QHttp;
    20 class QString;
    2119
    2220typedef struct stream_meta_
    2321{

  • libs/libmythtv/tvosdmenuentry.h

     
    11#ifndef TVOSDMENUENTRY_H_
    22#define TVOSDMENUENTRY_H_
    33
    4 #include <qstring.h>
    5 #include <qstringlist.h>
    6 #include <qmutex.h>
     4#include <QString>
     5#include <QStringList>
     6#include <QMutex>
    77#include <QVariant>
     8
    89#include "tv.h"
    910#include "mythexp.h"
    1011

  • libs/libmythtv/progfind.h

     
    2424#include "programlist.h"
    2525
    2626class ProgramInfo;
    27 class QWidget;
    2827class TV;
    2928
    3029MPUBLIC void RunProgramFind(bool thread = false, bool ggActive = false);

  • libs/libmythtv/diseqc.h

     
    1515using namespace std;
    1616
    1717// Qt headers
    18 #include <qmap.h>
    19 #include <qstring.h>
    20 #include <qmutex.h>
     18#include <QMap>
     19#include <QString>
     20#include <QMutex>
    2121
    2222class DTVMultiplex;
    2323

  • libs/libmythtv/dbox2epg.h

     
    1212#include <QThread>
    1313#include <QMap>
    1414
    15 class QString;
    16 class QDateTime;
    17 class QHttp;
    1815class DBox2Channel;
    1916class DBox2DBOptions;
    2017

  • libs/libmythtv/hdhrrecorder.h

     
    77#ifndef HDHOMERUNRECORDER_H_
    88#define HDHOMERUNRECORDER_H_
    99
    10 #include <qmutex.h>
     10#include <QMutex>
     11
    1112#include "dtvrecorder.h"
    1213#include "streamlisteners.h"
    1314#include "eitscanner.h"

  • libs/libmythtv/dbcheck.cpp

     
    11#include <iostream>
     2#include <QSqlError>
    23using namespace std;
    34
    45#include <QString>

  • libs/libmythtv/signalmonitor.h

     
    1313using namespace std;
    1414
    1515// Qt headers
    16 #include <qobject.h>
    17 #include <qmutex.h>
     16#include <QObject>
     17#include <QMutex>
    1818
    1919// MythTV headers
    2020#include "signalmonitorvalue.h"

  • libs/libmythtv/dvbtypes.cpp

     
    11// -*- Mode: c++ -*-
    22
    33// Qt headers
    4 #include <qstring.h>
     4#include <QString>
    55
    66// MythTV headers
    77#include "dvbtypes.h"

  • libs/libmythtv/progdetails.cpp

     
    11#include <iostream>
     2#include <QTextStream>
    23using namespace std;
    34
    45// qt

  • libs/libmythtv/openglvideo.h

     
    55#include <map>
    66using namespace std;
    77
    8 #include <qrect.h>
    9 #include <qmap.h>
     8#include <QRect>
     9#include <QMap>
    1010
    1111#include "videooutbase.h"
    1212#include "videoouttypes.h"

  • libs/libmythtv/cc708window.h

     
    77#include <vector>
    88using namespace std;
    99
    10 #include <qstring.h>
    11 #include <qmutex.h>
    12 #include <qcolor.h>
     10#include <QString>
     11#include <QMutex>
     12#include <QColor>
    1313
    1414class CC708CharacterAttribute
    1515{

  • libs/libmythtv/signalmonitorvalue.h

     
    33#define SIGNALMONITORVALUES_H
    44
    55#include <vector>
    6 #include <qstringlist.h>
     6
     7#include <QStringList>
     8
    79#include <mythcontext.h>
    810
    911class SignalMonitorValue

  • libs/libmythtv/dtvrecorder.h

     
    1212#include <vector>
    1313using namespace std;
    1414
    15 #include <qdatetime.h>
     15#include <QDateTime>
    1616
    1717#include "recorderbase.h"
    1818#include "H264Parser.h"
    1919
    2020class MPEGStreamData;
    2121class TSPacket;
    22 class QTime;
    2322
    2423class DTVRecorder: public RecorderBase
    2524{

  • libs/libmythtv/openglcontext.h

     
    66using namespace std;
    77
    88// Qt headers
    9 #include <qstring.h>
    10 #include <qrect.h>
     9#include <QString>
     10#include <QRect>
    1111
    1212// MythTV headers
    1313#ifdef USING_X11

  • libs/libmythtv/videoout_directfb.cpp

     
    1010
    1111// Linux headers
    1212#include <linux/fb.h>
     13#include <QEvent>
    1314extern "C" {
    1415#include <directfb.h>
    1516#include <directfb_version.h>
    … …  
    142143        if (DFB_OK != fberr)
    143144        {
    144145            VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to lock buffer" + ENOFB);
    145             fberr = bufferSurface->Release(bufferSurface);
     146            fberr = bufferSurface->ReleaseSource(bufferSurface);
    146147            if (DFB_OK != fberr)
    147148            {
    148149                VERBOSE(VB_IMPORTANT, LOC_ERR +
    … …  
    199200                            "Failed to unlock buffer" + ENOFB);
    200201                }
    201202
    202                 fberr = surf->Release(surf);
     203                fberr = surf->ReleaseSource(surf);
    203204                if (DFB_OK != fberr)
    204205                {
    205206                    VERBOSE(VB_IMPORTANT, LOC_ERR +
    … …  
    245246                        "Failed to unlock buffer" + ENOFB);
    246247            }
    247248
    248             fberr = surf->Release(surf);
     249            fberr = surf->ReleaseSource(surf);
    249250            if (DFB_OK != fberr)
    250251            {
    251252                VERBOSE(VB_IMPORTANT, LOC_ERR +
    … …  
    11431144    {
    11441145        VERBOSE(VB_IMPORTANT, LOC_WARN + "Failed to test config" + ENOFB);
    11451146
    1146         fberr = vodata->videoLayer->Release(vodata->videoLayer);
    1147         if (DFB_OK != fberr)
    1148         {
    1149             VERBOSE(VB_IMPORTANT, LOC_ERR +
    1150                     "Failed to release display layer" + ENOFB);
    1151         }
     1147        //fberr = vodata->videoLayer->Release(vodata->videoLayer);
     1148        //if (DFB_OK != fberr)
     1149        //{
     1150        //    VERBOSE(VB_IMPORTANT, LOC_ERR +
     1151        //            "Failed to release display layer" + ENOFB);
     1152        //}
    11521153
    11531154        return DFENUM_OK;
    11541155    }

  • libs/libmythtv/viewschdiff.h

     
    55
    66// C++ headers
    77#include <vector>
     8#include <QKeyEvent>
     9#include <QPaintEvent>
    810using namespace std;
    911
    1012// Qt headers
    … …  
    2729    ProgramInfo *after;
    2830};
    2931
    30 class QKeyEvent;
    31 class QPaintEvent;
    32 
    3332class MPUBLIC ViewScheduleDiff : public MythDialog
    3433{
    3534    Q_OBJECT

  • libs/libmythtv/channelbase.h

     
    44#define CHANNELBASE_H
    55
    66// Qt headers
    7 #include <qmap.h>
    8 #include <qstringlist.h>
     7#include <QMap>
     8#include <QStringList>
    99
    1010// MythTV headers
    1111#include "channelutil.h"

  • libs/libmythtv/dbox2channel.h

     
    1313#endif
    1414
    1515// Qt headers
    16 #include <qstring.h>
    17 #include <qmutex.h>
     16#include <QString>
     17#include <QMutex>
     18#include <QHttp>
    1819
    1920// MythTV headers
    2021#include "channelbase.h"
    … …  
    2324class DBox2Recorder;
    2425class DBox2Channel;
    2526class DBox2EPG;
    26 class Q3Http;
    2727
    2828class DBox2CRelay : public QObject
    2929{
    … …  
    8383    bool              m_recorderAlive;
    8484    DBox2Recorder    *m_recorder;
    8585
    86     Q3Http            *http;
    87     Q3Http            *httpChanger;
     86    QHttp            *http;
     87    QHttp            *httpChanger;
    8888    DBox2CRelay      *m_relay;
    8989
    9090    int               m_dbox2channelcount;

  • libs/libmythtv/siscan.cpp

     
    66#include <unistd.h>
    77
    88// Qt includes
    9 #include <qmutex.h>
     9#include <QMutex>
    1010
    1111// MythTV includes - General
    1212#include "siscan.h"

  • libs/libmythtv/ivtvdecoder.h

     
    11#ifndef IVTVDECODER_H_
    22#define IVTVDECODER_H_
    33
    4 #include <qstring.h>
    5 #include <qmap.h>
     4#include <QString>
     5#include <QMap>
    66
    77#include "programinfo.h"
    88#include "format.h"

  • libs/libmythtv/NuppelVideoRecorder.h

     
    2626using namespace std;
    2727
    2828// Qt headers
    29 #include <qstring.h>
    30 #include <qmap.h>
     29#include <QString>
     30#include <QMap>
    3131
    3232// MythTV headers
    3333#include "recorderbase.h"

  • libs/libmythtv/dtvconfparser.h

     
    4141using namespace std;
    4242
    4343// Qt headers
    44 #include <qstring.h>
     44#include <QString>
    4545
    4646// MythTV headers
    4747#include "dtvchannel.h"
    4848
    49 class QStringList;
    50 
    5149class DTVChannelInfo
    5250{
    5351  public:

  • libs/libmythtv/teletextdecoder.h

     
    33
    44#include <stdint.h>
    55
    6 #include <qwaitcondition.h>
    7 #include <qobject.h>
    8 #include <qmutex.h>
     6#include <QWaitCondition>
     7#include <QObject>
     8#include <QMutex>
    99
    1010class OSDType;
    1111

  • libs/libmythtv/osdsurface.h

     
    11#ifndef OSDSURFACE_H_
    22#define OSDSURFACE_H_
    33
    4 #include <qregion.h>
    5 #include <qmutex.h>
     4#include <QRegion>
     5#include <QMutex>
     6
    67#include "blend.h"
    78
    89#define MAX_NEG_CROP 1024

  • libs/libmythtv/eitcache.cpp

     
    66 */
    77
    88
    9 #include <qdatetime.h>
     9#include <QDateTime>
    1010
    1111#include "eitcache.h"
    1212#include "mythcontext.h"

  • libs/libmythtv/videoout_ivtv.h

     
    11#ifndef VIDEOOUT_IVTV_H_
    22#define VIDEOOUT_IVTV_H_
    33
    4 #include <qstring.h>
    5 #include <qmutex.h>
     4#include <QString>
     5#include <QMutex>
    66
    77#include "videooutbase.h"
    88

  • libs/libmythtv/util-xv.h

     
    33#ifndef _UTIL_XV_H_
    44#define _UTIL_XV_H_
    55
    6 #include <qmap.h>
     6#include <QMap>
    77
    88#include "videobuffers.h"
    99#include "exitcodes.h"

  • libs/libmythtv/cc708decoder.h

     
    66
    77#include <stdint.h>
    88
    9 #include <qstringlist.h>
     9#include <QStringList>
    1010
    1111#include "format.h"
    1212#include "compat.h"

  • libs/libmythtv/ttfont.h

     
    55#include FT_FREETYPE_H
    66#include FT_GLYPH_H
    77
    8 #include <qstring.h>
    9 #include <qmap.h>
    10 #include <qcolor.h>
     8#include <QString>
     9#include <QMap>
     10#include <QColor>
    1111
    1212#include "mythconfig.h"
    1313

  • libs/libmythtv/dummychannel.h

     
    66#ifndef DUMMYCHANNEL_H
    77#define DUMMYCHANNEL_H
    88
    9 #include <qstring.h>
     9#include <QString>
     10
    1011#include "tv_rec.h"
    1112#include "channelbase.h"
    1213

  • libs/libmythtv/dvbstreamhandler.h

     
    66#include <vector>
    77using namespace std;
    88
    9 #include <qmap.h>
    10 #include <qmutex.h>
     9#include <QMap>
     10#include <QMutex>
    1111
    1212#include "util.h"
    1313#include "DeviceReadBuffer.h"
    1414#include "mpegstreamdata.h"
    1515
    16 class QString;
    1716class DVBStreamHandler;
    1817class DTVSignalMonitor;
    1918class DVBChannel;

  • libs/libmythtv/playercontext.cpp

     
    11#include <math.h>
    2 #include <qtimer.h>
    3 #include <qpainter.h>
    42
     3#include <QTimer>
     4#include <QPainter>
     5
    56#include "playercontext.h"
    67#include "NuppelVideoPlayer.h"
    78#include "remoteencoder.h"

  • libs/libmythtv/sourceutil.h

     
    33#define _SOURCEUTIL_H_
    44
    55// Qt headers
    6 #include <qstring.h>
     6#include <QString>
    77
    88#include "mythexp.h"
    99

  • libs/libmythtv/dvbchannel.h

     
    88#ifndef DVBCHANNEL_H
    99#define DVBCHANNEL_H
    1010
    11 #include <qobject.h>
    12 #include <qstring.h>
    13 #include <qmap.h>
     11#include <QObject>
     12#include <QString>
     13#include <QMap>
    1414
    1515#include "mythcontext.h"
    1616#include "mythdbcon.h"

  • libs/libmythtv/NuppelVideoPlayer.h

     
    2121#include "cc708window.h"
    2222
    2323#include "mythexp.h"
     24#include <QKeyEvent>
    2425
    2526extern "C" {
    2627#include "filter.h"

  • libs/libmythtv/eithelper.h

     
    66#include <stdint.h>
    77
    88// Qt includes
    9 #include <qmutex.h>
    10 #include <qobject.h>
    11 #include <qstring.h>
     9#include <QMutex>
     10#include <QObject>
     11#include <QString>
    1212
    1313// MythTV includes
    1414#include "mythdeque.h"

  • libs/libmythtv/DeviceReadBuffer.h

     
    77#include <unistd.h>
    88#include <pthread.h>
    99
    10 #include <qmutex.h>
    11 #include <qwaitcondition.h>
    12 #include <qstring.h>
     10#include <QMutex>
     11#include <QWaitCondition>
     12#include <QString>
    1313
    1414#include "util.h"
    1515

  • libs/libmythtv/dtvchannel.h

     
    1515using namespace std;
    1616
    1717// Qt headers
    18 #include <qmutex.h>
    19 #include <qstring.h>
     18#include <QMutex>
     19#include <QString>
    2020
    2121// MythTV headers
    2222#include "channelbase.h"

  • libs/libmythtv/darwinavcinfo.h

     
    1616#include <IOKit/avc/IOFireWireAVCLib.h>
    1717
    1818// Qt headers
    19 #include <qmap.h>
     19#include <QMap>
    2020
    2121// MythTV headers
    2222#include "avcinfo.h"

  • libs/libmythtv/frequencytables.h

     
    88using namespace std;
    99
    1010// Qt includes
    11 #include <qmap.h>
    12 #include <qstring.h>
    13 #include <qmutex.h>
     11#include <QMap>
     12#include <QString>
     13#include <QMutex>
    1414#include <QList>
    1515
    1616// MythTV includes

  • libs/libmythtv/dvbcam.h

     
    44#include <deque>
    55using namespace std;
    66
    7 #include <qmutex.h>
     7#include <QMutex>
    88
    99#include "mpegtables.h"
    1010

  • libs/libmythtv/scheduledrecording.h

     
    11#ifndef SCHEDULEDRECORDING_H
    22#define SCHEDULEDRECORDING_H
    33
    4 #include <qpointer.h>
     4#include <QPointer>
    55
    66#include "settings.h"
    77#include "recordingtypes.h"
     8
    89#include <list>
    910
    10 
    1111using namespace std;
    1212
    1313class ProgramInfo;

  • libs/libmythtv/datadirect.cpp

     
    77// Qt headers
    88#include <QDir>
    99#include <QFileInfo>
     10#include <QTextStream>
    1011
    1112// MythTV headers
    1213#include "datadirect.h"

  • libs/libmythtv/recorderbase.h

     
    22#ifndef RECORDERBASE_H_
    33#define RECORDERBASE_H_
    44
    5 #include <qmutex.h>
    6 #include <qstring.h>
    7 #include <qmap.h>
    8 #include <qsqldatabase.h>
    9 #include <qwaitcondition.h>
     5#include <QMutex>
     6#include <QString>
     7#include <QMap>
     8#include <QSqlDatabase>
     9#include <QWaitCondition>
    1010
    1111#include <pthread.h>
    1212

  • libs/libmythtv/channelutil.cpp

     
    44#include <set>
    55using namespace std;
    66
    7 #include <qregexp.h>
    87#include <stdint.h>
    9 #include <qimage.h>
    10 #include <qfile.h>
    118
     9#include <QRegExp>
     10#include <QImage>
     11#include <QFile>
     12
    1213#include "channelutil.h"
    1314#include "mythdb.h"
    1415#include "dvbtables.h"

  • libs/libmythtv/mpeg/premieretables.h

     
    22#ifndef _PRIVATE_TABLES_H_
    33#define _PRIVATE_TABLES_H_
    44
    5 #include <qstring.h>
     5#include <QString>
     6
    67#include <stdint.h>  // uint32_t
     8
    79#include "mpegtables.h"
    810#include "dvbdescriptors.h"
    911

  • libs/libmythtv/mpeg/tsstats.h

     
    33#ifndef __TS_STATS__
    44#define __TS_STATS__
    55
    6 #include <qstring.h>
    7 #include <qmap.h>
     6#include <QString>
     7#include <QMap>
    88
    99/** \class TSStats
    1010 *  \brief Collects statistics on the number of TSPacket's seen on each PID.

  • libs/libmythtv/mpeg/premieredescriptors.h

     
    55#include <stdint.h>
    66#include <inttypes.h>
    77
    8 #include <qstring.h>
    9 #include <qdatetime.h>
     8#include <QString>
     9#include <QDateTime>
    1010
    1111#include "mpegdescriptors.h"
    1212

  • libs/libmythtv/mpeg/iso639.h

     
    22#ifndef _ISO_639_2_H_
    33#define _ISO_639_2_H_
    44
    5 #include <qmap.h>
    6 #include <qstring.h>
    7 #include <qstringlist.h>
     5#include <QMap>
     6#include <QString>
     7#include <QStringList>
     8
    89#include <vector>
     10
    911#include "mythexp.h"
     12
    1013using namespace std;
    1114
    1215extern MPUBLIC QMap<int, QString> _iso639_key_to_english_name;

  • libs/libmythtv/mpeg/freesat_huffman.h

     
    55#include <unistd.h>
    66
    77// Qt header
    8 #include <qstring.h>
     8#include <QString>
    99
    1010QString freesat_huffman_to_string(const unsigned char *compressed, uint size);
    1111

  • libs/libmythtv/mpeg/dvbdescriptors.h

     
    66#include <cassert>
    77#include <vector>
    88#include <map>
    9 #include <qmutex.h>
    10 #include <qstring.h>
     9
     10#include <QMutex>
     11#include <QString>
     12
    1113#include "mythcontext.h"
    1214#include "mpegdescriptors.h"
    1315#include "../programinfo.h" // for subtitle types and audio and video properties

  • libs/libmythtv/mpeg/mpegstreamdata.h

     
    66#include <vector>
    77using namespace std;
    88
    9 #include <qmap.h>
     9#include <QMap>
     10
    1011#include <stdint.h>  // uint64_t
     12
    1113#include "tspacket.h"
    1214#include "util.h"
    1315#include "streamlisteners.h"

  • libs/libmythtv/mpeg/atsc_huffman.h

     
    55#include <unistd.h>
    66
    77// Qt header
    8 #include <qstring.h>
     8#include <QString>
    99
    1010QString atsc_huffman1_to_string(const unsigned char *compressed,
    1111                                uint size, uint table);

  • libs/libmythtv/mpeg/dvbtables.h

     
    33#ifndef _DVB_TABLES_H_
    44#define _DVB_TABLES_H_
    55
    6 #include <qstring.h>
     6#include <QString>
     7
    78#include <stdint.h>  // uint32_t
     9
    810#include "mpegtables.h"
    911#include "dvbdescriptors.h"
    1012

  • libs/libmythtv/mpeg/dishdescriptors.h

     
    66#include <cassert>
    77
    88using namespace std;
    9 #include <qstring.h>
    109
     10#include <QString>
     11
    1112#include "mythcontext.h"
    1213#include "atscdescriptors.h"
    1314

  • libs/libmythtv/mpeg/freesat_huffman.cpp

     
    11#include "freesat_huffman.h"
    22
    3 #include <qstring.h>
     3#include <QString>
    44
    55struct fsattab {
    66    unsigned int value;

  • libs/libmythtv/inputinfo.h

     
    33#define _INPUTINFO_H_
    44
    55// Qt headers
    6 #include <qstringlist.h>
    7 #include <qmap.h>
     6#include <QStringList>
     7#include <QMap>
    88
    99// MythTV headers
    1010#include "channelutil.h" // for DBChanList

  • libs/libmythtv/infostructs.cpp

     
    1 #include <qdatetime.h>
    2 #include <qpixmap.h>
    3 #include <qimage.h>
    4 #include <qstring.h>
    5 #include <qfile.h>
    6 #include <qsqlquery.h>
    7 #include <qapplication.h>
     1#include <QDateTime>
     2#include <QPixmap>
     3#include <QImage>
     4#include <QString>
     5#include <QFile>
     6#include <QSqlQuery>
     7#include <QApplication>
    88
    99#include "infostructs.h"
    1010#include "mythcontext.h"

  • libs/libmythtv/jobqueue.h

     
    11#ifndef JOBQUEUE_H_
    22#define JOBQUEUE_H_
    33
    4 #include <qobject.h>
    5 #include <qmap.h>
    6 #include <qmutex.h>
    7 #include <qobject.h>
    8 #include <qsqldatabase.h>
     4#include <QObject>
     5#include <QMap>
     6#include <QMutex>
     7#include <QObject>
     8#include <QSqlDatabase>
    99#include <QEvent>
    10 #include <qwaitcondition.h>
     10#include <QWaitCondition>
     11
    1112#include <pthread.h>
    1213
    1314

  • libs/libmythtv/firewiresignalmonitor.h

     
    33#ifndef _FIREWIRESIGNALMONITOR_H_
    44#define _FIREWIRESIGNALMONITOR_H_
    55
    6 #include <qmap.h>
    7 #include <qmutex.h>
    8 #include <qdatetime.h>
     6#include <QMap>
     7#include <QMutex>
     8#include <QDateTime>
    99
    1010#include "dtvsignalmonitor.h"
    1111#include "firewiredevice.h"

  • libs/libmythtv/osd.h

     
    33
    44#include <deque>
    55#include <vector>
     6#include <ctime>
    67using namespace std;
    78
    8 #include <qstring.h>
    9 #include <qstringlist.h>
    10 #include <qrect.h>
    11 #include <qpoint.h>
     9#include <QString>
     10#include <QStringList>
     11#include <QRect>
     12#include <QPoint>
    1213#include <QKeyEvent>
    13 #include <ctime>
    14 #include <qmap.h>
    15 #include <qdom.h>
    16 #include <qmutex.h>
    17 #include <qobject.h>
    18 #include <qregexp.h>
     14#include <QMap>
     15#include <QMutex>
     16#include <QDomElement>
     17#include <QObject>
     18#include <QRegExp>
    1919
    2020// Mythtv Headers
    2121#include "themeinfo.h"
    … …  
    5050extern const char *kOSDDialogInfo;
    5151extern const char *kOSDDialogEditChannel;
    5252
    53 class QImage;
    5453class TTFFont;
    5554class OSDSet;
    5655class OSDTypeImage;
    … …  
    6059class TV;
    6160class UDPNotifyOSDSet;
    6261class OSDListTreeType;
    63 class QKeyEvent;
    6462class OSDGenericTree;
    6563class ccText;
    6664class CC708Service;

  • libs/libmythtv/dvbtypes.h

     
    4545  #define dvb_fe_params dvb_frontend_parameters
    4646#endif
    4747
    48 class QString;
    4948QString toString(fe_status);
    5049
    5150#endif // DVB_TYPES_H

  • libs/libmythtv/tv_play.cpp

     
    66#include <pthread.h>
    77
    88#include <algorithm>
     9#include <QTimerEvent>
     10#include <QResizeEvent>
     11
    912using namespace std;
    1013
    1114#include <QApplication>
    … …  
    1518#include <QDir>
    1619#include <QKeyEvent>
    1720#include <QEvent>
     21#include <QUdpSocket>
    1822
    1923#include "mythdb.h"
    2024#include "tv_play.h"

  • libs/libmythtv/videodisplayprofile.h

     
    66#include <vector>
    77using namespace std;
    88
    9 #include <qstringlist.h>
    10 #include <qmutex.h>
    11 #include <qsize.h>
    12 #include <qmap.h>
     9#include <QStringList>
     10#include <QMutex>
     11#include <QSize>
     12#include <QMap>
    1313
    1414#include "mythcontext.h"
    1515

  • libs/libmythtv/remoteencoder.h

     
    11#ifndef REMOTEENCODER_H_
    22#define REMOTEENCODER_H_
    33
    4 #include <qstringlist.h>
    5 #include <qmutex.h>
    6 #include <qmap.h>
     4#include <QStringList>
     5#include <QMutex>
     6#include <QMap>
    77
    88#include "mythexp.h"
    99#include "videoouttypes.h"

  • libs/libmythtv/videoout_directfb.h

     
    11#ifndef VIDEOOUT_DIRECTFB_H
    22#define VIDEOOUT_DIRECTFB_H
    33
    4 #include <qobject.h>
     4#include <QObject>
    55#include "videooutbase.h"
    66
    77class NuppelVideoPlayer;

  • libs/libmythtv/videoout_xv.h

     
    22#define VIDEOOUT_XV_H_
    33
    44#include <set>
    5 #include <qwindowdefs.h>
    65
    76#include "DisplayRes.h"
    87#include "videooutbase.h"

  • libs/libmythtv/siscan.h

     
    66#include <pthread.h>
    77
    88// Qt includes
    9 #include <qobject.h>
    10 #include <qstring.h>
    11 #include <qmap.h>
    12 #include <qmutex.h>
    13 #include <qdatetime.h>
     9#include <QObject>
     10#include <QString>
     11#include <QMap>
     12#include <QMutex>
     13#include <QDateTime>
    1414
    1515// MythTV includes
    1616#include "frequencytables.h"

  • libs/libmythtv/xvmctextures.h

     
    33#ifndef _XVMC_TEXTURES_H_
    44#define _XVMC_TEXTURES_H_
    55
    6 #include <qsize.h>
     6#include <QSize>
    77
    88class OSD;
    99

  • libs/libmythtv/dvbcam.cpp

     
    3333 *
    3434 */
    3535
    36 #include <qdatetime.h>
    37 #include <qvariant.h>
     36#include <QDateTime>
     37#include <QVariant>
    3838
    3939#include <iostream>
    4040#include <vector>

  • libs/libmythtv/profilegroup.cpp

     
    55#include "mythdb.h"
    66#include "mythuihelper.h"
    77#include "cardutil.h"
    8 #include <qsqldatabase.h>
    9 #include <qcursor.h>
    10 #include <qlayout.h>
     8
     9#include <QSqlDatabase>
     10#include <QCursor>
     11#include <QLayout>
     12#include <Q3VBoxLayout>
     13
    1114#include <iostream>
    1215
    1316QString ProfileGroupStorage::GetWhereClause(MSqlBindings &bindings) const
    … …  
    259262        float wmult = 0.0f, hmult  = 0.0f;
    260263        GetMythUI()->GetScreenSettings(width, wmult, height, hmult);
    261264
    262         QVBoxLayout *layout = new QVBoxLayout(dialog);
     265        Q3VBoxLayout *layout = new Q3VBoxLayout(dialog);
    263266        layout->setMargin((int)(20 * hmult));
    264267        layout->addWidget(listbox->configWidget(NULL, dialog));
    265268

  • libs/libmythtv/cc608decoder.h

     
    88#include <vector>
    99using namespace std;
    1010
    11 #include <qmutex.h>
    12 #include <qstringlist.h>
     11#include <QMutex>
     12#include <QStringList>
    1313
    1414#include "format.h"
    1515

  • libs/libmythtv/iptvchannel.h

     
    1010#include "dtvchannel.h"
    1111#include "iptvchannelinfo.h"
    1212
    13 #include <qmutex.h>
     13#include <QMutex>
    1414
    1515class IPTVFeederWrapper;
    1616

  • libs/libmythtv/XvMCSurfaceTypes.h

     
    55#ifdef USING_XVMC
    66
    77#include <QString>
     8#include <QEvent>
    89
    9 #include <qwindowdefs.h>
     10#include <X11/extensions/XvMC.h>
     11
    1012#include "mythcontext.h"
    11 #include <X11/extensions/XvMC.h>
    1213#include "util-x11.h"
    1314#include "fourcc.h"
    1415

  • libs/libmythtv/scanwizardscanner.h

     
    3636#include <pthread.h>
    3737
    3838// Qt headers
    39 #include <qstring.h>
     39#include <QString>
    4040#include <QEvent>
    4141
    4242// MythTV headers

  • libs/libmythtv/dvbstreamhandler.cpp

     
    1010#include <sys/ioctl.h>
    1111
    1212// Qt headers
    13 #include <qstring.h>
     13#include <QString>
    1414
    1515// MythTV headers
    1616#include "dvbstreamhandler.h"

  • libs/libmythtv/remoteutil.cpp

     
    1 #include <qfile.h>
    2 #include <qstringlist.h>
     1#include <QFile>
     2#include <QStringList>
     3
    34#include <unistd.h>
    45
    56#include "remoteutil.h"

  • libs/libmythtv/sr_items.h

     
    11#ifndef SR_ITEMS_H
    22#define SR_ITEMS_H
    3 #include <qsqldatabase.h>
     3
     4#include <QSqlDatabase>
     5
    46#include "mythcontext.h"
    57#include "mythdbcon.h"
    68#include "managedlist.h"

  • libs/libmythtv/RingBuffer.h

     
    33#ifndef RINGBUFFER
    44#define RINGBUFFER
    55
    6 #include <qstring.h>
    7 #include <qwaitcondition.h>
    8 #include <qmutex.h>
     6#include <QString>
     7#include <QWaitCondition>
     8#include <QMutex>
     9
    910#include <pthread.h>
    1011
    1112extern "C" {

  • libs/libmythtv/eitscanner.h

     
    33#define EITSCANNER_H
    44
    55// Qt includes
    6 #include <qmutex.h>
    7 #include <qobject.h>
    8 #include <qdatetime.h>
    9 #include <qstringlist.h>
    10 #include <qwaitcondition.h>
    11 #include <qthread.h>
     6#include <QMutex>
     7#include <QObject>
     8#include <QDateTime>
     9#include <QStringList>
     10#include <QWaitCondition>
     11#include <QThread>
    1212
    1313class TVRec;
    1414class ChannelBase;

  • libs/libmythtv/iptv/iptvfeeder.h

     
    77#ifndef _IPTV_FEEDER_H_
    88#define _IPTV_FEEDER_H_
    99
    10 class QString;
     10#include <QString>
     11
    1112class TSDataListener;
    1213
    1314/** \class IPTVFeeder

  • libs/libmythtv/iptv/iptvfeederwrapper.h

     
    1010#include <vector>
    1111using namespace std;
    1212
    13 #include <qmutex.h>
    14 #include <qstring.h>
     13#include <QMutex>
     14#include <QString>
    1515
    1616class IPTVFeeder;
    1717class TSDataListener;

  • libs/libmythtv/iptv/iptvmediasink.h

     
    1010#include <vector>
    1111using namespace std;
    1212
    13 #include <qmutex.h>
     13#include <QMutex>
    1414
    1515#include <MediaSink.hh>
    1616

  • libs/libmythtv/iptv/iptvchannelfetcher.h

     
    22#define _IPTVCHANNELFETCHER_H_
    33
    44// Qt headers
    5 #include <qobject.h>
    6 #include <qmutex.h>
    7 #include <qthread.h>
     5#include <QObject>
     6#include <QMutex>
     7#include <QThread>
    88
    99// MythTV headers
    1010#include "iptvchannelinfo.h"

  • libs/libmythtv/iptv/iptvfeederlive.h

     
    1212using namespace std;
    1313
    1414// Qt headers
    15 #include <qwaitcondition.h>
    16 #include <qmutex.h>
     15#include <QWaitCondition>
     16#include <QMutex>
    1717
    1818// Mythtv headers
    1919#include "iptvfeeder.h"
    2020
    21 class QString;
    2221class TSDataListener;
    2322class UsageEnvironment;
    2423

  • libs/libmythtv/iptv/iptvchannelinfo.h

     
    66#ifndef _IPTV_CHANNELINFO_H_
    77#define _IPTV_CHANNELINFO_H_
    88
    9 #include <qmap.h>
    10 #include <qstring.h>
     9#include <QMap>
     10#include <QString>
    1111
    1212class IPTVChannelInfo
    1313{

  • libs/libmythtv/programdata.h

     
    22#define _PROGRAMDATA_H_
    33
    44// Qt headers
    5 #include <qstring.h>
    6 #include <qdatetime.h>
     5#include <QString>
     6#include <QDateTime>
    77#include <QList>
    8 #include <qmap.h>
     8#include <QMap>
    99
    1010// MythTV headers
    1111#include "mythexp.h"

  • libs/libmythtv/transporteditor.h

     
    3232#ifndef _TRANSPORT_EDITOR_H_
    3333#define _TRANSPORT_EDITOR_H_
    3434
    35 #include <qobject.h>
     35#include <QObject>
     36
    3637#include "settings.h"
    3738
    3839class VideoSourceSelector;

  • libs/libmythtv/avformatdecoder.h

     
    11#ifndef AVFORMATDECODER_H_
    22#define AVFORMATDECODER_H_
    33
    4 #include <qstring.h>
    5 #include <qmap.h>
     4#include <QString>
     5#include <QMap>
    66#include <QList>
    77
    88#include "programinfo.h"

  • libs/libmythtv/tv_rec.cpp

     
    1111using namespace std;
    1212
    1313// Qt headers
    14 #include <qapplication.h>
    15 #include <qsqldatabase.h>
     14#include <QApplication>
     15#include <QSqlDatabase>
    1616
    1717// MythTV headers
    1818#include "mythconfig.h"

  • libs/libmythtv/xbox.h

     
    11#ifndef XBOX_H_
    22#define XBOX_H_
    33
    4 #include <qobject.h>
    5 #include <qtimer.h>
    6 #include <qstringlist.h>
     4#include <QObject>
     5#include <QTimer>
     6#include <QStringList>
    77
    88#include "mythexp.h"
    99

  • libs/libmythtv/videoout_dvdv.h

     
    66
    77#include "frame.h"
    88
    9 class QSize;
    109class AVCodecContext;
    1110struct DVDV_Private;
    1211struct AVCodecContext;

  • libs/libmythtv/previewgenerator.h

     
    44
    55#include <pthread.h>
    66
    7 #include <qstring.h>
    8 #include <qmutex.h>
     7#include <QString>
     8#include <QMutex>
    99
    1010#include "programinfo.h"
    1111#include "util.h"

  • libs/libmythtv/videooutbase.h

     
    1313#include <QString>
    1414#include <QPoint>
    1515#include <QMap>
    16 #include <qwindowdefs.h>
    1716
    1817#include "videobuffers.h"
    1918#include "mythcodecid.h"

  • libs/libmythtv/videoout_dvdv.mm

     
    1111#import <AGL/agl.h>
    1212#import <OpenGL/glext.h>
    1313
    14 #include <qmutex.h>
    15 #include <qstring.h>
    16 #include <q3ptrqueue.h>
    17 #include <qmap.h>
    18 #include <qsize.h>
     14#include <QMutex>
     15#include <QString>
     16#include <Q3PtrQueue>
     17#include <QMap>
     18#include <QSize>
    1919
    2020#include "libmyth/mythconfig.h"
    2121#include "libmyth/mythverbose.h"

  • libs/libmythtv/iptvrecorder.h

     
    88#ifndef _IPTV_RECORDER_H_
    99#define _IPTV_RECORDER_H_
    1010
    11 #include <qwaitcondition.h>
     11#include <QWaitCondition>
    1212
    1313#include "dtvrecorder.h"
    1414#include "streamlisteners.h"

  • libs/libmythtv/textsubtitleparser.cpp

     
    88#include <cstring>
    99#include <climits>
    1010#include <algorithm>
    11 #include <qtextcodec.h>
    1211
     12#include <QTextCodec>
     13
    1314#include "mythcontext.h"
    1415
    1516using std::lower_bound;

  • libs/libmythtv/ThreadedFileWriter.h

     
    33#define TFW_H_
    44
    55#include <pthread.h>
    6 #include <qmutex.h>
    7 #include <qwaitcondition.h>
    8 #include <qstring.h>
    96
     7#include <QMutex>
     8#include <QWaitCondition>
     9#include <QString>
     10
    1011class ThreadedFileWriter
    1112{
    1213  public:

  • libs/libmythtv/videobuffers.h

     
    66extern "C" {
    77#include "frame.h"
    88}
     9
     10#include <QMutex>
     11#include <QString>
     12#include <QWaitCondition>
     13#include <qwindowdefs.h>
     14
    915#include <vector>
    1016#include <map>
    11 #include <qmutex.h>
    12 #include <qstring.h>
    13 #include <qwaitcondition.h>
     17
    1418#include "mythdeque.h"
    1519
    16 #ifdef USING_XVMC
    17 #include <qwindowdefs.h>
    18 #endif // USING_XVMC
    19 
    2020#ifdef USING_VDPAU
    2121class VDPAUContext;
    2222#endif

  • libs/libmythtv/channelsettings.h

     
    11#ifndef CHANNELSETTINGS_H
    22#define CHANNELSETTINGS_H
    33
    4 #include <qwidget.h>
    5 #include <qsqldatabase.h>
     4#include <QWidget>
     5#include <QSqlDatabase>
    66
    77#include <cstdlib>
    88

  • libs/libmythtv/firewiredevice.h

     
    1212using namespace std;
    1313
    1414// Qt headers
    15 #include <qstring.h>
    16 #include <qmutex.h>
     15#include <QString>
     16#include <QMutex>
    1717
    1818// MythTV headers
    1919#include "streamlisteners.h"

  • libs/libmythtv/eitfixup.h

     
    55#ifndef EITFIXUP_H
    66#define EITFIXUP_H
    77
    8 #include <qregexp.h>
     8#include <QRegExp>
    99
    1010#include "eit.h"
    1111

  • libs/libmythtv/dbox2channel.cpp

     
    99using namespace std;
    1010
    1111// Qt headers
    12 #include <q3http.h>
     12#include <QHttp>
    1313
    1414// MythTV headers
    1515#include "mythverbose.h"
    … …  
    5050      m_channelListReady(false),     m_lastChannel("1"),
    5151      m_requestChannel(""),          m_epg(new DBox2EPG()),
    5252      m_recorderAlive(false),        m_recorder(NULL),
    53       http(new Q3Http()),             httpChanger(new Q3Http()),
     53      http(new QHttp()),             httpChanger(new QHttp()),
    5454      m_relay(new DBox2CRelay(this)),
    5555      m_dbox2channelcount(0)
    5656{
    … …  
    230230    // Request Channel list via http.
    231231    // Signal will be emmitted when list is ready.
    232232
    233     Q3HttpRequestHeader header("GET", "/control/channellist");
     233    QHttpRequestHeader header("GET", "/control/channellist");
    234234    header.setValue("Host", m_dbox2options->host);
    235235    http->setHost(m_dbox2options->host, m_dbox2options->httpport);
    236236    http->request(header);
    … …  
    300300    // Request channel change via http.
    301301    // Signal will be emmited when request is done.
    302302
    303     Q3HttpRequestHeader header("GET", requestString);
     303    QHttpRequestHeader header("GET", requestString);
    304304    header.setValue("Host", m_dbox2options->host);
    305305    httpChanger->setHost(m_dbox2options->host, m_dbox2options->httpport);
    306306    httpChanger->request(header);

  • libs/libmythtv/progfind.cpp

     
    77        By John Danner
    88*/
    99
    10 #include <qlabel.h>
    11 #include <qlayout.h>
    12 #include <qdatetime.h>
    13 #include <qtimer.h>
    14 #include <qapplication.h>
    15 #include <qsqldatabase.h>
    16 #include <qstringlist.h>
    17 #include <qcursor.h>
    18 #include <qregexp.h>
     10#include <QLabel>
     11#include <QLayout>
     12#include <QDateTime>
     13#include <QTimer>
     14#include <QApplication>
     15#include <QSqlDatabase>
     16#include <QStringList>
     17#include <QCursor>
     18#include <QRegExp>
    1919#include <QKeyEvent>
    2020#include <QEvent>
    2121#include <QPixmap>

  • libs/libmythtv/linuxfirewiredevice.cpp

     
    2828using namespace std;
    2929
    3030// Qt headers
    31 #include <qdatetime.h>
     31#include <QDateTime>
    3232
    3333// MythTV headers
    3434#include "linuxfirewiredevice.h"

  • libs/libmythtv/mhi.cpp

     
    11#include <unistd.h>
    22
    33#include <QRegion>
    4 #include <qbitarray.h>
    5 
     4#include <QBitArray>
    65#include <QVector>
    76
    87#include "mhi.h"

  • libs/libmythtv/inputgroupmap.h

     
    77using namespace std;
    88
    99// Qt headers
    10 #include <qmap.h>
     10#include <QMap>
    1111
    1212// MythTV headers
    1313#include "mythexp.h"

  • libs/libmythtv/hdhrchannel.h

     
    88#define HDHOMERUNCHANNEL_H
    99
    1010// Qt headers
    11 #include <qstring.h>
     11#include <QString>
    1212
    1313// MythTV headers
    1414#include "dtvchannel.h"

  • libs/libmythtv/udpnotify.h

     
    1313#include <QObject>
    1414#include <QMutex>
    1515#include <QMap>
     16#include <QUdpSocket>
     17#include <QDomElement>
    1618
    1719class TV;
    1820class OSD;
    1921class UDPNotifyOSDTypeText;
    20 class QByteArray;
    21 class QUdpSocket;
    22 class QDomElement;
    2322
    2423class UDPNotifyOSDSet
    2524{

  • libs/libmythtv/videoout_null.h

     
    11#ifndef VIDEOOUT_NULL_H_
    22#define VIDEOOUT_NULL_H_
    33
    4 #include <qmutex.h>
     4#include <QMutex>
    55
    66#include "videooutbase.h"
    77

  • libs/libmythhdhomerun/hdhomerun_os.h

     
    8686typedef unsigned __int16 uint16_t;
    8787typedef unsigned __int32 uint32_t;
    8888typedef unsigned __int64 uint64_t;
    89 typedef HANDLE pthread_t;
    90 typedef HANDLE pthread_mutex_t;
     89typedef Qt::HANDLE pthread_t;
     90typedef Qt::HANDLE pthread_mutex_t;
    9191
    9292#define socklen_t int
    9393#define close closesocket

  • libs/libmythhdhomerun/libmythhdhomerun.pro

     
    2222SOURCES += hdhomerun_video.c
    2323
    2424include ( ../libs-targetfix.pro )
     25QT += network  sql qt3support

  • libs/libmythsoundtouch/libmythsoundtouch.pro

     
    3939}
    4040
    4141include ( ../libs-targetfix.pro )
     42QT +=  qt3support

  • libs/libmythsamplerate/libmythsamplerate.pro

     
    2626INSTALLS += inc
    2727
    2828include ( ../libs-targetfix.pro )
     29QT +=  qt3support

  • libs/libmythlivemedia/libmythlivemedia.pro

     
    305305    SOURCES += liveMedia/WAVAudioFileSource.cpp
    306306}
    307307
    308 #The following line was inserted by qt3to4
    309308QT -= core gui
    310309
    311310include ( ../libs-targetfix.pro )
     311QT += network  sql qt3support

  • libs/libavutil/libavutil.pro

     
    5656}
    5757
    5858include ( ../libs-targetfix.pro )
     59QT +=  qt3support

  • libs/libavcodec/libavcodec.pro

     
    543543}
    544544
    545545include ( ../libs-targetfix.pro )
     546QT += xml network  sql opengl qt3support

  • libs/libmythmpeg2/libmythmpeg2.pro

     
    4242}
    4343
    4444include ( ../libs-targetfix.pro )
     45QT +=  qt3support

  • libs/libmythui/myththemedmenu.h

     
    55#include "mythuistatetype.h"
    66#include "mythuibuttonlist.h"
    77#include "xmlparsebase.h"
     8#include <QKeyEvent>
    89
    910class MythMainWindow;
    1011class MythThemedMenuState;
    1112
    12 class QKeyEvent;
    13 
    1413struct ThemedButton
    1514{
    1615    QString type;

  • libs/libmythui/mythvirtualkeyboard.cpp

     
    55#include <QKeyEvent>
    66#include <QDomDocument>
    77#include <QFile>
     8#include <QEvent>
    89
    910// myth
    1011#include "mythmainwindow.h"
    … …  
    437438
    438439                    if (m_parentEdit)
    439440                    {
    440                         QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, 0, Qt::NoModifier, c);
     441                        QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, 0, (Qt::KeyboardModifiers)Qt::NoModifier, c);
    441442                        m_parentEdit->keyPressEvent(event);
    442443                    }
    443444
    … …  
    457458
    458459        if (m_parentEdit)
    459460        {
    460             QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, 0, Qt::NoModifier, c);
     461            QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, 0, (Qt::KeyboardModifiers)Qt::NoModifier, c);
    461462            m_parentEdit->keyPressEvent(event);
    462463        }
    463464

  • libs/libmythui/mythuibutton.cpp

     
    11// QT
    22#include <QTimer>
    33#include <QDomDocument>
     4#include <QKeyEvent>
    45
    56// Myth headers
    67#include "mythverbose.h"

  • libs/libmythui/mythmainwindow.cpp

     
    1818#include <QEvent>
    1919
    2020#ifdef QWS
    21 #include <qwindowsystem_qws.h>
     21#include <QKeyEvent>
     22#include <QPixmap>
     23#include <QMouseEvent>
     24#include <QPaintEvent>
     25#include <QWheelEvent>
     26#include <QCloseEvent>
    2227#endif
    2328#ifdef Q_WS_MACX
    2429#include <HIToolbox/Menus.h>   // For GetMBarHeight()

  • libs/libmythui/mythmainwindow_internal.h

     
    22#define MYTHMAINWINDOW_INT
    33
    44#include <QWidget>
     5#include <QPaintEvent>
    56
    67class MythMainWindow;
    78class MythMainWindowPrivate;

  • libs/libmythui/mythdialogbox.h

     
    33
    44#include <QDir>
    55#include <QEvent>
     6#include <QKeyEvent>
    67
    78#include "mythscreentype.h"
    89#include "mythuitextedit.h"
    910
    10 class QString;
    11 class QStringList;
    12 class QTimer;
    13 
    1411class MythUIButtonListItem;
    1512class MythUIButtonList;
    1613class MythUIButton;

  • libs/libmythui/AppleRemoteListener.cpp

     
    11#include <QApplication>
    22#include <QKeySequence>
     3#include <QEvent>
    34#include "lircevent.h"
    45
    56#include "AppleRemoteListener.h"

  • libs/libmythui/mythimage.cpp

     
    44// QT headers
    55#include <QPainter>
    66#include <QMatrix>
     7#include <QPixmap>
    78
    89#include "mythimage.h"
    910#include "mythmainwindow.h"

  • libs/libmythui/mythgesture.h

     
    2626
    2727#include <sys/types.h>
    2828
    29 #include <qpoint.h>
    30 #include <qlist.h>
    31 #include <qevent.h>
     29#include <QPoint>
     30#include <QList>
     31#include <QEvent>
    3232
    3333const int MythGestureEventType = 24427;
    3434

  • libs/libmythui/mythprogressdialog.h

     
    22#define MYTHPROGRESSBOX_H_
    33
    44#include <QEvent>
     5#include <QKeyEvent>
    56
    67#include "mythscreentype.h"
    78#include "mythmainwindow.h"

  • libs/libmythui/mythuitextedit.h

     
    22#define MYTHUI_TEXTEDIT_H_
    33
    44#include <QString>
     5#include <QKeyEvent>
    56
    67#include "mythuitype.h"
    78#include "mythuitext.h"

  • libs/libmythui/mythpainter.h

     
    44#include <QString>
    55#include <QWidget>
    66
    7 class QRect;
    8 
    97//  #include "mythfontproperties.h"
    108
    119#include "compat.h"

  • libs/libmythui/mythpainter_qt.h

     
    66
    77#include "compat.h"
    88
    9 class QPainter;
    10 
    119class MythQtPainter : public MythPainter
    1210{
    1311  public:

  • libs/libmythui/mythmainwindow.h

     
    22#define MYTHMAINWINDOW_H_
    33
    44#include <QWidget>
     5#include <QEvent>
     6#include <QKeyEvent>
     7#include <QCloseEvent>
    58
    69#include "mythuitype.h"
    710#include "mythscreenstack.h"
    811
    9 class QEvent;
    10 
    1112class MythMediaDevice;
    1213
    1314#define REG_KEY(a, b, c, d) GetMythMainWindow()->RegisterKey(a, b, c, d)

  • libs/libmythui/util-x11.cpp

     
    44
    55#include "config.h" // for CONFIG_DARWIN
    66#include "mythverbose.h"
     7#include "mythuihelper.h"
    78
    89QMutex x11_lock;
    910
    … …  
    2021#endif // USING_X11
    2122
    2223#include <QMutex>
    23 #include "mythuihelper.h"
    2424
    2525#ifdef USING_X11
    2626std::map<Display*, XErrorVectorType>   error_map;

  • libs/libmythui/mythuitype.h

     
    66#include <QMap>
    77#include <QList>
    88#include <QFont>
     9#include <QKeyEvent>
     10#include <QEvent>
    911
    1012#include "xmlparsebase.h"
    1113#include "mythrect.h"
    … …  
    1618class FontMap;
    1719class MythFontProperties;
    1820
    19 class QEvent;
    20 class QKeyEvent;
    21 
    2221class MythUIText;
    2322class MythUIButton;
    2423class MythUIButtonList;

  • libs/libmythui/mythscreentype.h

     
    44#include "mythuitype.h"
    55#include "mythuitext.h"
    66#include "mythuiutils.h"
     7#include <QKeyEvent>
    78
    89class MythScreenStack;
    910

  • libs/libmythui/mythuibuttontree.h

     
    44#include "mythuitype.h"
    55#include "mythgenerictree.h"
    66#include "mythuibuttonlist.h"
     7#include <QKeyEvent>
    78
    89class MythUIButtonListItem;
    910

  • libs/libmythui/mythuibuttonlist.h

     
    44#include <QList>
    55#include <QString>
    66#include <QVariant>
     7#include <QKeyEvent>
    78
    89#include "mythuitype.h"
    910#include "mythuiimage.h"

  • libs/libmythui/mythscreentype.cpp

     
    11#include <cassert>
    22
    33#include <QDomDocument>
     4#include <QKeyEvent>
    45
    56#include "mythverbose.h"
    67

  • libs/libmythui/themeinfo.h

     
    33
    44#include <QString>
    55#include <QSize>
     6#include <QFileInfo>
    67
    78#include "mythexp.h"
    89
    … …  
    1314    THEME_MENU  = 0x04
    1415} ThemeType;
    1516
    16 class QFileInfo;
    17 
    1817class MPUBLIC ThemeInfo
    1918{
    2019

  • libs/libmythui/mythuihelper.h

     
    11#ifndef MYTHUIHELPERS_H_
    22#define MYTHUIHELPERS_H_
    33
     4#include <QPixmap>
    45#include <QString>
    56#include <QFont>
    67#include <QMutex>
    … …  
    910
    1011class MythUIHelperPrivate;
    1112class MythImage;
    12 class QImage;
    13 class QWidget;
    1413class Settings;
    15 class QPixmap;
    1614
    1715struct MPUBLIC MythUIMenuCallbacks
    1816{

  • libs/libmythui/mythuicheckbox.cpp

     
    66#include "mythgesture.h"
    77
    88#include "mythuicheckbox.h"
     9#include <QKeyEvent>
    910
    1011MythUICheckBox::MythUICheckBox(MythUIType *parent, const QString &name)
    1112            : MythUIType(parent, name)

  • libs/libmythui/mythuiwebbrowser.h

     
    77#include <QTime>
    88#include <QColor>
    99#include <QIcon>
     10#include <QKeyEvent>
    1011
    1112
    1213#ifdef USING_QTWEBKIT

  • libs/libmythui/mythuibuttontree.cpp

     
    11// Qt headers
    22#include <QDomDocument>
    33#include <QDomDocument>
     4#include <QKeyEvent>
    45
    56#include "mythverbose.h"
    67

  • libs/libmythui/mythuibuttonlist.cpp

     
    11// QT headers
    22#include <QDomDocument>
     3#include <QKeyEvent>
    34
    45// libmyth headers
    56#include "mythverbose.h"

  • libs/libmythui/mythdialogbox.cpp

     
    55#include <QString>
    66#include <QStringList>
    77#include <QTimer>
     8#include <QKeyEvent>
    89
    910#include "mythverbose.h"
    1011

  • libs/libmythui/mythvirtualkeyboard.h

     
    22#define MYTHUIVIRTUALKEYBOARD_H_
    33
    44#include "mythscreentype.h"
     5#include <QKeyEvent>
    56
    6 class QKeyEvent;
    7 
    87/// Preferred position to place virtual keyboard popup.
    98enum PopupPosition
    109{

  • libs/libmythui/mythuibutton.h

     
    22#define MYTHUI_BUTTON_H_
    33
    44#include <QString>
     5#include <QKeyEvent>
    56
    67#include "mythuitype.h"
    78#include "mythuistatetype.h"
    … …  
    6667
    6768    bool m_Pushed;
    6869    bool m_Lockable;
    69     class QTimer *m_clickTimer;
     70    QTimer *m_clickTimer;
    7071};
    7172
    7273#endif

  • libs/libmythui/mythgesture.cpp

     
    3232
    3333#include <QMutex>
    3434#include <QMap>
     35#include <QString>
    3536
    3637#include "mythgesture.h"
    3738

  • libs/libmythui/mythuiwebbrowser.cpp

     
    2121#include <QStyle>
    2222#include <QKeyEvent>
    2323#include <QDomDocument>
     24#include <QPixmap>
     25#include <QMouseEvent>
     26#include <QEvent>
    2427
    2528// myth
    2629#include "mythpainter.h"

  • libs/libmythui/libmythui.pro

     
    135135    }
    136136}
    137137
    138 #The following line was inserted by qt3to4
    139138QT += xml sql opengl network
    140139
    141140using_qtwebkit {
    … …  
    150149include ( ../libs-targetfix.pro )
    151150
    152151LIBS += $$LATE_LIBS
     152QT +=  qt3support

  • libs/libmythui/mythprogressdialog.cpp

     
    11// MythTV headers
    22#include "mythprogressdialog.h"
    33#include "mythverbose.h"
     4#include <QEvent>
     5#include <QKeyEvent>
    46
    57MythUIBusyDialog::MythUIBusyDialog(const QString &message,
    68                             MythScreenStack *parent, const char *name)

  • libs/libmythui/mythuicheckbox.h

     
    44// MythUI headers
    55#include "mythuitype.h"
    66#include "mythuistatetype.h"
     7#include <QKeyEvent>
    78
    89/** \class MythUICheckBox
    910 *

  • libs/libmythui/xmlparsebase.h

     
    22#define XMLPARSEBASE_H_
    33
    44#include <QString>
     5#include <QDomElement>
    56
    67#include "mythrect.h"
    78
    89class MythUIType;
    910class MythScreenType;
    10 class QDomElement;
    1111
    1212class MPUBLIC XMLParseBase
    1313{

  • libs/libavformat/libavformat.pro

     
    234234mingw:SOURCES -= audio.c
    235235
    236236include ( ../libs-targetfix.pro )
     237QT += xml network  sql opengl qt3support

  • libs/libmyth/settings.cpp

     
    11// C++ headers
    22#include <algorithm>
     3#include <Q3HBoxLayout>
     4#include <QPixmap>
     5#include <Q3VBoxLayout>
     6#include <Q3BoxLayout>
    37using namespace std;
    48
    59// POSIX headers
    … …  
    1014#include <QLabel>
    1115#include <QSlider>
    1216#include <QLCDNumber>
    13 #include <QButtonGroup>
     17#include <Q3ButtonGroup>
    1418#include <QRadioButton>
    1519#include <QProgressBar>
    1620
    … …  
    252256    QWidget *widget = new QWidget(parent);
    253257    widget->setObjectName(widgetName);
    254258
    255     QHBoxLayout *layout = new QHBoxLayout();
     259    Q3HBoxLayout *layout = new Q3HBoxLayout();
    256260
    257261    if (getLabel() != "")
    258262    {
    … …  
    279283    QWidget *widget = new QWidget(parent);
    280284    widget->setObjectName(widgetName);
    281285
    282     QBoxLayout *layout = NULL;
     286    Q3BoxLayout *layout = NULL;
    283287    if (labelAboveWidget)
    284288    {
    285         layout = new QVBoxLayout();
     289        layout = new Q3VBoxLayout();
    286290        widget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    287291                                          QSizePolicy::Maximum));
    288292    }
    289293    else
    290         layout = new QHBoxLayout();
     294        layout = new Q3HBoxLayout();
    291295
    292296    if (getLabel() != "")
    293297    {
    … …  
    379383    QWidget *widget = new QWidget(parent);
    380384    widget->setObjectName(widgetName);
    381385
    382     QBoxLayout *layout = NULL;
     386    Q3BoxLayout *layout = NULL;
    383387    if (labelAboveWidget)
    384388    {
    385         layout = new QVBoxLayout();
     389        layout = new Q3VBoxLayout();
    386390        widget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    387391                                          QSizePolicy::Maximum));
    388392    }
    389393    else
    390         layout = new QHBoxLayout();
     394        layout = new Q3HBoxLayout();
    391395
    392396    if (getLabel() != "")
    393397    {
    … …  
    449453    QWidget *widget = new QWidget(parent);
    450454    widget->setObjectName(widgetName);
    451455
    452     QBoxLayout *layout = NULL;
     456    Q3BoxLayout *layout = NULL;
    453457    if (labelAboveWidget)
    454458    {
    455         layout = new QVBoxLayout();
     459        layout = new Q3VBoxLayout();
    456460        widget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    457461                                          QSizePolicy::Maximum));
    458462    }
    459463    else
    460         layout = new QHBoxLayout();
     464        layout = new Q3HBoxLayout();
    461465
    462466    if (getLabel() != "")
    463467    {
    … …  
    561565    QWidget *widget = new QWidget(parent);
    562566    widget->setObjectName(widgetName);
    563567
    564     QBoxLayout *layout = NULL;
     568    Q3BoxLayout *layout = NULL;
    565569    if (labelAboveWidget)
    566570    {
    567         layout = new QVBoxLayout();
     571        layout = new Q3VBoxLayout();
    568572        widget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    569573                                          QSizePolicy::Maximum));
    570574    }
    571575    else
    572         layout = new QHBoxLayout();
     576        layout = new Q3HBoxLayout();
    573577
    574578    if (getLabel() != "")
    575579    {
    … …  
    597601    QWidget *widget = new QWidget(parent);
    598602    widget->setObjectName(widgetName);
    599603
    600     QBoxLayout *layout = NULL;
     604    Q3BoxLayout *layout = NULL;
    601605    if (labelAboveWidget)
    602606    {
    603         layout = new QVBoxLayout();
     607        layout = new Q3VBoxLayout();
    604608        widget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    605609                                          QSizePolicy::Maximum));
    606610    }
    607611    else
    608         layout = new QHBoxLayout();
     612        layout = new Q3HBoxLayout();
    609613
    610614    if (getLabel() != "")
    611615    {
    … …  
    837841QWidget *RadioSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
    838842                                    const char* widgetName)
    839843{
    840     QGroupBox* widget = new QGroupBox(parent);
     844    Q3GroupBox* widget = new Q3GroupBox(parent);
    841845    widget->setObjectName(widgetName);
    842846    widget->setTitle(getLabel());
    843847
    … …  
    990994    QWidget *widget = new QWidget(parent);
    991995    widget->setObjectName(widgetName);
    992996
    993     QVBoxLayout *layout = new QVBoxLayout();
     997    Q3VBoxLayout *layout = new Q3VBoxLayout();
    994998
    995999    if (getLabel() != "")
    9961000    {
    … …  
    11321136    bxwidget = new QWidget(parent);
    11331137    bxwidget->setObjectName(widgetName);
    11341138
    1135     QBoxLayout *layout = NULL;
     1139    Q3BoxLayout *layout = NULL;
    11361140    if (labelAboveWidget)
    11371141    {
    1138         layout = new QVBoxLayout();
     1142        layout = new Q3VBoxLayout();
    11391143        bxwidget->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    11401144                                            QSizePolicy::Maximum));
    11411145    }
    11421146    else
    1143         layout = new QHBoxLayout();
     1147        layout = new Q3HBoxLayout();
    11441148
    11451149    if (getLabel() != "")
    11461150    {
    … …  
    12921296    (void)cg;
    12931297    QWidget *widget = new QWidget(parent);
    12941298    widget->setObjectName(widgetName);
    1295     QBoxLayout *layout = new QHBoxLayout();
     1299    Q3BoxLayout *layout = new Q3HBoxLayout();
    12961300
    12971301    if (getLabel() != "")
    12981302    {

  • libs/libmyth/mythwizard.cpp

     
    4747
    4848#include <QStackedWidget>
    4949#include <QPushButton>
    50 #include <QBoxLayout>
    51 #include <QGroupBox>
     50#include <Q3BoxLayout>
     51#include <Q3GroupBox>
    5252#include <QLabel>
     53#include <Q3HBoxLayout>
     54#include <Q3Frame>
     55#include <QEvent>
     56#include <Q3VBoxLayout>
    5357
    5458#include "mythcontext.h"
    5559
    … …  
    7074        bool appropriate;
    7175    };
    7276
    73     QVBoxLayout * v;
     77    Q3VBoxLayout * v;
    7478    Page * current;
    7579    QStackedWidget * ws;
    7680    QList<Page*> pages;
    … …  
    8084    MythPushButton * finishButton;
    8185    MythPushButton * cancelButton;
    8286
    83     QGroupBox *helpgroup;
     87    Q3GroupBox *helpgroup;
    8488    QLabel *help;
    8589
    86     QFrame * hbar1, * hbar2;
     90    Q3Frame * hbar1, * hbar2;
    8791
    8892    Page * page( const QWidget * w )
    8993    {
    … …  
    422426    return d->cancelButton;
    423427}
    424428
    425 void MythWizard::layOutButtonRow( QHBoxLayout * layout )
     429void MythWizard::layOutButtonRow( Q3HBoxLayout * layout )
    426430{
    427431    bool hasEarlyFinish = FALSE;
    428432
    … …  
    433437        i--;
    434438    }
    435439
    436     QHBoxLayout *h = new QHBoxLayout();
    437     h->setSpacing(QBoxLayout::LeftToRight);
     440    Q3HBoxLayout *h = new Q3HBoxLayout();
     441    h->setSpacing(Q3BoxLayout::LeftToRight);
    438442    layout->addLayout( h );
    439443
    440444    h->addWidget( d->cancelButton );
    … …  
    479483    }
    480484}
    481485
    482 void MythWizard::layOutTitleRow( QHBoxLayout * layout, const QString & title )
     486void MythWizard::layOutTitleRow( Q3HBoxLayout * layout, const QString & title )
    483487{
    484488    d->title->setText( title );
    485489    layout->addWidget( d->title, 10 );
    … …  
    488492void MythWizard::layOut()
    489493{
    490494    delete d->v;
    491     d->v = new QVBoxLayout( this);
     495    d->v = new Q3VBoxLayout( this);
    492496    d->v->setMargin(6);
    493497    d->v->setSpacing(0);
    494498    d->v->setObjectName("top-level layout");
    495499
    496     QHBoxLayout * l;
    497     l = new QHBoxLayout();
     500    Q3HBoxLayout * l;
     501    l = new Q3HBoxLayout();
    498502    l->setMargin(6);
    499503    d->v->addLayout( l, 0 );
    500504    layOutTitleRow( l, d->current ? d->current->t : QString::null );
    501505
    502506    if ( ! d->hbar1 ) {
    503         d->hbar1 = new QFrame(this, 0);
     507        d->hbar1 = new Q3Frame(this, 0);
    504508        d->hbar1->setObjectName("MythWizard - hbar1");
    505         d->hbar1->setFrameStyle(QFrame::Sunken | QFrame::HLine);
     509        d->hbar1->setFrameStyle(Q3Frame::Sunken | Q3Frame::HLine);
    506510        d->hbar1->setFixedHeight( 12 );
    507511    }
    508512
    … …  
    512516
    513517    if (!d->helpgroup)
    514518    {
    515         d->helpgroup = new QGroupBox(this);
     519        d->helpgroup = new Q3GroupBox(this);
    516520        d->helpgroup->setObjectName("MythWizard -- help group box");
    517521
    518522        d->help = new QLabel(d->helpgroup);
    … …  
    525529        d->help->setMaximumHeight((int)(80 * hmult));
    526530        d->help->setMinimumHeight((int)(80 * hmult));
    527531   
    528         QVBoxLayout *helplayout = new QVBoxLayout(d->helpgroup);
     532        Q3VBoxLayout *helplayout = new Q3VBoxLayout(d->helpgroup);
    529533        helplayout->setMargin(10);
    530534        helplayout->addWidget(d->help);
    531535    }
    … …  
    537541    d->v->addWidget(d->helpgroup);
    538542
    539543    if ( ! d->hbar2 ) {
    540         d->hbar2 = new QFrame( this, 0 );
     544        d->hbar2 = new Q3Frame( this, 0 );
    541545        d->hbar2->setObjectName("MythWizard - hbar2");
    542         d->hbar2->setFrameStyle(QFrame::Sunken | QFrame::HLine);
     546        d->hbar2->setFrameStyle(Q3Frame::Sunken | Q3Frame::HLine);
    543547        d->hbar2->setFixedHeight( 12 );
    544548    }
    545549    d->v->addWidget( d->hbar2 );
    546550
    547     l = new QHBoxLayout();
     551    l = new Q3HBoxLayout();
    548552    l->setMargin(6);
    549553    d->v->addLayout( l );
    550554    layOutButtonRow( l );

  • libs/libmyth/mythcommandlineparser.cpp

     
    11#include <QFile>
     2#include <QTextStream>
    23
    34#include "mythcommandlineparser.h"
    45#include "exitcodes.h"

  • libs/libmyth/mythcdrom.cpp

     
    66#include "mythcdrom-freebsd.h"
    77#endif
    88
    9 #include <qdir.h>
    10 #include <qfileinfo.h>
     9#include <QDir>
     10#include <QFileInfo>
    1111
    1212#include "mythconfig.h"
    1313#include "mythverbose.h"

  • libs/libmyth/uitypes.h

     
    2525#undef LoadImage
    2626#endif
    2727
    28 class QFont;
    29 class QPainter;
    3028class UIType;
    3129class MythDialog;
    3230class MythThemedDialog;

  • libs/libmyth/virtualkeyboard_qt.cpp

     
    11#include <QPixmap>
    22#include <QImage>
    33#include <QApplication>
    4 #include <QFrame>
     4#include <Q3Frame>
    55#include <QKeyEvent>
    66
    77#include "virtualkeyboard_qt.h"
    … …  
    2323                    bool setsize)
    2424            : MythThemedDialog(parent, name, setsize)
    2525{
    26     setFrameStyle(QFrame::Panel | QFrame::Raised);
     26    setFrameStyle(Q3Frame::Panel | Q3Frame::Raised);
    2727    setLineWidth(1);
    2828    m_parentEdit = parentEdit;
    2929

  • libs/libmyth/mythmedia.cpp

     
    99#include <QDir>
    1010#include <QFileInfo>
    1111#include <QFileInfoList>
     12#include <QTextStream>
    1213
    1314// MythTV headers
    1415#include "mythmedia.h"

  • libs/libmyth/mythterminal.h

     
    88#include <QString>
    99#include <QProcess>
    1010#include <QMutex>
     11#include <QKeyEvent>
     12#include <QEvent>
    1113
    1214// MythTV headers
    1315#include "mythexp.h"

  • libs/libmyth/util.h

     
    44#include <algorithm>
    55using namespace std;
    66
    7 #include <qstringlist.h>
    8 #include <qdatetime.h>
    9 #include <qcolor.h>
     7#include <QStringList>
     8#include <QDateTime>
     9#include <QColor>
    1010#include <QPixmap>
     11#include <QFile>
    1112
    1213#include <stdint.h>
    1314#include <time.h>
    … …  
    1617#include "mythtimer.h"
    1718#include "mythsystem.h"
    1819
    19 class QPixmap;
    20 class QImage;
    21 class QPainter;
    22 class QFont;
    23 class QFile;
    24 
    2520MPUBLIC QDateTime mythCurrentDateTime();
    2621MPUBLIC int calc_utc_offset(void);
    2722MPUBLIC QString getTimeZoneID(void);

  • libs/libmyth/mythcontext.h

     
    11#ifndef MYTHCONTEXT_H_
    22#define MYTHCONTEXT_H_
    33
    4 #include <cerrno>
    5 #include <iostream>
    6 #include <sstream>
    7 #include <vector>
    8 
    94#include <QObject>
    105#include <QString>
    116#include <QMutex>
    127#include <QList>
     8#include <QKeyEvent>
    139
    14 #include <qevent.h>
     10#include <cerrno>
     11#include <iostream>
     12#include <sstream>
     13#include <vector>
    1514
    1615#include "mythexp.h"
    1716#include "mythobservable.h"
    … …  
    2120
    2221using namespace std;
    2322
    24 class QFont;
    25 
    2623class Settings;
    2724class MythMainWindow;
    2825class MythPluginManager;

  • libs/libmyth/mythmediamonitor.h

     
    22#define MYTH_MEDIA_MONITOR_H
    33
    44#include <QList>
    5 #include <qpointer.h>
    6 #include <qthread.h>
    7 #include <qstring.h>
     5#include <QPointer>
     6#include <QThread>
     7#include <QString>
    88#include <QStringList>
    99#include <QMutex>
    1010#include <QEvent>

  • libs/libmyth/langsettings.cpp

     
    1 #include <qapplication.h>
    2 #include <qsqldatabase.h>
     1#include <QApplication>
     2#include <QSqlDatabase>
    33#include <QTranslator>
    44
    55using namespace std;

  • libs/libmyth/volumebase.cpp

     
    1 #include <qstring.h>
     1#include <QString>
     2
    23#include <cstdio>
    34#include <cstdlib>
    45

  • libs/libmyth/settings.h

     
    99
    1010// Qt headers
    1111#include <QObject>
     12#include <QLabel>
     13#include <QDir>
    1214
    1315// MythTV headers
    1416#include "mythexp.h"
    … …  
    1719#include "mythdbcon.h"
    1820#include "mythstorage.h"
    1921
    20 class QWidget;
    2122class ConfigurationGroup;
    22 class QDir;
    2323class Setting;
    2424
    2525class MPUBLIC Configurable : public QObject
    … …  
    524524    };
    525525};
    526526
    527 class QDate;
    528527class MPUBLIC DateSetting : public Setting
    529528{
    530529    Q_OBJECT
    … …  
    540539    void setValue(const QDate& newValue);
    541540};
    542541
    543 class QTime;
    544542class MPUBLIC TimeSetting : public Setting
    545543{
    546544    Q_OBJECT

  • libs/libmyth/mythwizard.h

     
    4343
    4444#include <QEvent>
    4545#include <QKeyEvent>
     46#include <Q3HBoxLayout>
    4647
    4748class MythWizardPrivate;
    48 class QHBoxLayout;
    4949
    5050class MPUBLIC MythWizard : public MythDialog
    5151{
    … …  
    104104    void selected(const QString&);
    105105
    106106protected:
    107     virtual void layOutButtonRow(QHBoxLayout *);
    108     virtual void layOutTitleRow(QHBoxLayout *, const QString &);
     107    virtual void layOutButtonRow(Q3HBoxLayout *);
     108    virtual void layOutTitleRow(Q3HBoxLayout *, const QString &);
    109109
    110110    void setBackEnabled(bool);
    111111    void setNextEnabled(bool);

  • libs/libmyth/visual.h

     
    77#ifndef __visual_h
    88#define __visual_h
    99
    10 #include <qmutex.h>
     10#include <QMutex>
    1111
    1212class Decoder;
    1313class AudioOutput;

  • libs/libmyth/mythconfigdialogs.cpp

     
    77#include "mythuihelper.h"
    88
    99#include <QWidget>
    10 #include <QHBoxLayout>
     10#include <Q3HBoxLayout>
     11#include <QLabel>
     12#include <QKeyEvent>
     13#include <Q3VBoxLayout>
    1114
    1215static void clear_widgets(vector<Configurable*> &children,
    1316                          vector<QWidget*>      &childwidget)
    … …  
    5962        label->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    6063                                         QSizePolicy::Maximum));
    6164
    62         QHBoxLayout *layout = new QHBoxLayout;
     65        Q3HBoxLayout *layout = new Q3HBoxLayout;
    6366        layout->addWidget(label);
    6467
    6568        QWidget *box = new QWidget(dialog);
    … …  
    144147
    145148    GetMythUI()->GetScreenSettings(wmult, hmult);
    146149
    147     QVBoxLayout *layout = new QVBoxLayout(dialog);
     150    Q3VBoxLayout *layout = new Q3VBoxLayout(dialog);
    148151    layout->setSpacing((int)(20 * hmult));
    149152
    150153    ChildList::iterator it = cfgChildren.begin();

  • libs/libmyth/mythterminal.cpp

     
    2121// MythTV headers
    2222#include "mythterminal.h"
    2323#include "mythcontext.h"
     24#include <QEvent>
     25#include <QKeyEvent>
    2426
    2527MythTerminal::MythTerminal(QString _program, QStringList _arguments) :
    2628    lock(QMutex::Recursive), running(false),

  • libs/libmyth/util.cpp

     
    11// C++ headers
    22#include <iostream>
     3#include <QTextStream>
    34
    45using namespace std;
    56

  • libs/libmyth/mythdialogs.cpp

     
    11
    22#include <iostream>
    33#include <algorithm>
     4#include <Q3HBoxLayout>
     5#include <QEventLoop>
     6#include <Q3VBoxLayout>
    47using namespace std;
    58
    69#include <QCursor>
    … …  
    1316#include <QLabel>
    1417#include <QPixmap>
    1518#include <QKeyEvent>
    16 #include <QFrame>
     19#include <Q3Frame>
    1720#include <QPaintEvent>
    1821#include <QPainter>
    1922#include <QProgressBar>
    2023
    21 #ifdef QWS
    22 #include <qwindowsystem_qws.h>
    23 #endif
    24 
    2524#include "uitypes.h"
    2625#include "uilistbtntype.h"
    2726#include "xmlparse.h"
    … …  
    4140 */
    4241
    4342MythDialog::MythDialog(MythMainWindow *parent, const char *name, bool setsize)
    44     : QFrame(parent), rescode(kDialogCodeAccepted)
     43    : Q3Frame(parent), rescode(kDialogCodeAccepted)
    4544{
    4645    setObjectName(name);
    4746    if (!parent)
    … …  
    8483{
    8584    hide();
    8685    TeardownAll();
    87     QFrame::deleteLater();
     86    Q3Frame::deleteLater();
    8887}
    8988
    9089void MythDialog::TeardownAll(void)
    … …  
    266265
    267266    setLineWidth(3);
    268267    setMidLineWidth(3);
    269     setFrameShape(QFrame::Panel);
    270     setFrameShadow(QFrame::Raised);
     268    setFrameShape(Q3Frame::Panel);
     269    setFrameShadow(Q3Frame::Raised);
    271270    setPalette(parent->palette());
    272271    popupForegroundColor = palette().color(foregroundRole());
    273272    setFont(parent->font());
    … …  
    275274    hpadding = gContext->GetNumSetting("PopupHeightPadding", 120);
    276275    wpadding = gContext->GetNumSetting("PopupWidthPadding", 80);
    277276
    278     vbox = new QVBoxLayout(this);
     277    vbox = new Q3VBoxLayout(this);
    279278    vbox->setMargin((int)(10 * hmult));
    280279
    281280    setAutoFillBackground(true);
    … …  
    298297
    299298    setLineWidth(3);
    300299    setMidLineWidth(3);
    301     setFrameShape(QFrame::Panel);
    302     setFrameShadow(QFrame::Raised);
    303     setFrameStyle(QFrame::Box | QFrame::Plain);
     300    setFrameShape(Q3Frame::Panel);
     301    setFrameShadow(Q3Frame::Raised);
     302    setFrameStyle(Q3Frame::Box | Q3Frame::Plain);
    304303    setPalette(parent->palette());
    305304    setFont(parent->font());
    306305
    307306    hpadding = gContext->GetNumSetting("PopupHeightPadding", 120);
    308307    wpadding = gContext->GetNumSetting("PopupWidthPadding", 80);
    309308
    310     vbox = new QVBoxLayout(this);
     309    vbox = new Q3VBoxLayout(this);
    311310    vbox->setMargin((int)(10 * hmult));
    312311
    313312    if (!graphicPopup)
    … …  
    860859    msglabel = new QLabel();
    861860    msglabel->setText(message);
    862861
    863     QVBoxLayout *vlayout = new QVBoxLayout();
     862    Q3VBoxLayout *vlayout = new Q3VBoxLayout();
    864863    vlayout->addWidget(msglabel);
    865864
    866865    progress = new QProgressBar();
    867866    progress->setRange(0, totalSteps);
    868867
    869     QHBoxLayout *hlayout = new QHBoxLayout();
     868    Q3HBoxLayout *hlayout = new Q3HBoxLayout();
    870869    hlayout->addWidget(progress);
    871870
    872871    if (cancelButton && slot && target)
    … …  
    898897    hbox->setLayout(hlayout);
    899898    vlayout->addWidget(hbox);
    900899
    901     QFrame *vbox = new QFrame(this);
     900    Q3Frame *vbox = new Q3Frame(this);
    902901    vbox->setObjectName(objectName() + "_vbox");
    903902    vbox->setLineWidth(3);
    904903    vbox->setMidLineWidth(3);
    905     vbox->setFrameShape(QFrame::Panel);
    906     vbox->setFrameShadow(QFrame::Raised);
     904    vbox->setFrameShape(Q3Frame::Panel);
     905    vbox->setFrameShadow(Q3Frame::Raised);
    907906    vbox->setLayout(vlayout);
    908907
    909     QVBoxLayout *lay = new QVBoxLayout();
     908    Q3VBoxLayout *lay = new Q3VBoxLayout();
    910909    lay->addWidget(vbox);
    911910    setLayout(lay);
    912911
    … …  
    17331732    this->setGeometry((screenwidth - 250 ) / 2,
    17341733                      (screenheight - 50 ) / 2,
    17351734                      totalWidth,50);
    1736     QFrame *outside_border = new QFrame(this);
     1735    Q3Frame *outside_border = new Q3Frame(this);
    17371736    outside_border->setObjectName(objectName() + "_outside_border");
    17381737    outside_border->setGeometry(0,0,totalWidth,50);
    1739     outside_border->setFrameStyle(QFrame::Panel | QFrame::Raised );
     1738    outside_border->setFrameStyle(Q3Frame::Panel | Q3Frame::Raised );
    17401739    outside_border->setLineWidth(4);
    17411740
    17421741    QLabel *message_label = new QLabel(message, this);

  • libs/libmyth/libmyth.pro

     
    210210include ( ../libs-targetfix.pro )
    211211
    212212LIBS += $$LATE_LIBS
     213QT +=  opengl qt3support

  • libs/libmyth/mythmediamonitor.cpp

     
    55// C++ headers
    66#include <iostream>
    77#include <typeinfo>
     8#include <QEvent>
    89using namespace std;
    910
    1011// Qt headers

  • libs/libmyth/xmlparse.h

     
    33
    44#include "uitypes.h"
    55#include "mythcontext.h"
    6 #include <qimage.h>
    7 #include <qrect.h>
    8 #include <qlabel.h>
    9 #include <qdom.h>
    106
     7#include <QImage>
     8#include <QRect>
     9#include <QLabel>
     10#include <QDomNode>
     11
    1112class MythUIHelper;
    1213
    1314class MPUBLIC XMLParse

  • libs/libmyth/mythplugin.h

     
    44#include <QLibrary>
    55#include <QMap>
    66#include <QHash>
     7#include <QPainter>
    78
    89#include <vector>
    910using namespace std;
    1011
    1112#include "mythexp.h"
    1213
    13 class QSqlDatabase;
    1414class MythContext;
    15 class QPainter;
    1615
    1716typedef enum {
    1817    kPluginType_Module = 0,

  • libs/libmyth/output.h

     
    1818
    1919#include "mythobservable.h"
    2020
    21 class QObject;
    2221class Buffer;
    2322
    2423namespace MythTV {

  • libs/libmyth/volumebase.h

     
    44#include <iostream>
    55using namespace std;
    66
    7 #include <qstring.h>
     7#include <QString>
    88#include "mythcontext.h"
    99
    1010typedef enum {

  • libs/libmyth/dialogbox.cpp

     
    11#include <iostream>
     2#include <Q3VBoxLayout>
     3#include <QLabel>
    24using namespace std;
    35
    46#include "dialogbox.h"
    … …  
    1012#endif
    1113
    1214#include <QButtonGroup>
    13 #include <QBoxLayout>
     15#include <Q3BoxLayout>
    1416
    1517DialogBox::DialogBox(MythMainWindow *parent, const QString &text,
    1618                     const char *checkboxtext,
    … …  
    2123    maintext->setAlignment(Qt::AlignLeft | Qt::AlignTop);
    2224    maintext->setWordWrap(true);
    2325
    24     box = new QVBoxLayout(this);
     26    box = new Q3VBoxLayout(this);
    2527    box->setContentsMargins((int)(60 * wmult),(int)(60 * wmult),
    2628                           (int)(60 * wmult),(int)(60 * wmult));
    2729    box->setSpacing(0);

  • libs/libmyth/mythconfiggroups.h

     
    33#ifndef MYTH_CONFIG_GROUPS_H
    44#define MYTH_CONFIG_GROUPS_H
    55
    6 #include <QVBoxLayout>
    7 #include <QGroupBox>
     6#include <Q3VBoxLayout>
     7#include <Q3GroupBox>
     8#include <QStackedWidget>
    89
    910// MythTV headers
    1011#include "mythexp.h"
    … …  
    1415#include "settings.h"
    1516#undef MYTHCONFIG
    1617
    17 class QStackedWidget;
    18 
    1918class MPUBLIC ConfigurationGroup : public Setting, public Storage
    2019{
    2120    Q_OBJECT
    … …  
    9291
    9392  private:
    9493    vector<QWidget*>    childwidget;
    95     QGroupBox          *widget;
     94    Q3GroupBox          *widget;
    9695    ConfigurationGroup *confgrp;
    97     QVBoxLayout        *layout;
     96    Q3VBoxLayout        *layout;
    9897};
    9998
    10099class MPUBLIC HorizontalConfigurationGroup : public ConfigurationGroup

  • libs/libmyth/mythconfigdialogs.h

     
    66// Qt headers
    77#include <QObject>
    88#include <QString>
     9#include <QLabel>
     10#include <QKeyEvent>
    911
    1012// MythTV headers
    1113#include "mythexp.h"

  • libs/libmyth/mythhttphandler.h

     
    1010// Qt headers
    1111#include <QMutex>
    1212#include <QUrl>
     13#include <QHttpResponseHeader>
    1314
    1415typedef deque<QUrl> UrlQueue;
    1516
    16 class QHttp;
    17 class QHttpResponseHeader;
    1817class MythHttpPool;
    1918
    2019class MythHttpHandler : public QObject

  • libs/libmyth/dbutil.h

     
    11#ifndef DBUTIL_H_
    22#define DBUTIL_H_
    33
    4 #include <qstringlist.h>
    5 #include <qmap.h>
     4#include <QStringList>
     5#include <QMap>
    66
    77#include "mythexp.h"
    88#include "mythdbcon.h"

  • libs/libmyth/mythdialogs.h

     
    66#include <QLabel>
    77#include <QAbstractButton>
    88#include <QObject>
    9 #include <QFrame>
     9#include <Q3Frame>
    1010#include <QVector>
    1111#include <QList>
     12#include <QKeyEvent>
     13#include <QPixmap>
     14#include <Q3VBoxLayout>
     15#include <QPaintEvent>
     16#include <QProgressBar>
    1217
    1318#include "mythexp.h"
    1419
    … …  
    4045class MythListBox;
    4146struct fontProp;
    4247class MythMainWindow;
    43 class QVBoxLayout;
    44 class QProgressBar;
    4548
    4649#include "mythmainwindow.h"
    4750
    … …  
    7174inline bool operator!=(const QDialog::DialogCode &a, const DialogCode &b)
    7275{ return ((int)a) == ((int)b); }
    7376
    74 class MPUBLIC MythDialog : public QFrame
     77class MPUBLIC MythDialog : public Q3Frame
    7578{
    7679    Q_OBJECT
    7780
    … …  
    210213    void defaultButtonPressedHandler(void);
    211214
    212215  private:
    213     QVBoxLayout *vbox;
     216    Q3VBoxLayout *vbox;
    214217    QColor       popupForegroundColor;
    215218    int          hpadding, wpadding;
    216219    bool         arrowAccel;

  • libs/libmyth/backendselect.h

     
    22#define __BACKENDSELECT_H__
    33
    44#include <QListWidget>
     5#include <QEvent>
    56
    67#include "mythdialogs.h"
    78#include "upnpdevice.h"

  • libs/libmyth/uitypes.cpp

     
    33
    44// C++ headers
    55#include <algorithm>
     6#include <QPixmap>
     7#include <QKeyEvent>
     8#include <QEvent>
     9#include <QTextEdit>
    610using namespace std;
    711
    812// Qt headers

  • libs/libmyth/mythconfiggroups.cpp

     
    11#include <algorithm>
    22
    3 #include <QGroupBox>
     3#include <Q3GroupBox>
    44#include <QStackedWidget>
     5#include <Q3HBoxLayout>
     6#include <QGridLayout>
     7#include <Q3Frame>
     8#include <Q3VBoxLayout>
    59
    610#include "mythconfiggroups.h"
    711#include "mythcontext.h"
    … …  
    112116    QWidget            *parent,
    113117    const char         *widgetName)
    114118{
    115     layout = new QVBoxLayout();
     119    layout = new Q3VBoxLayout();
    116120    layout->setMargin(margin);
    117121    layout->setSpacing((space<0) ? margin : space);
    118122
    … …  
    137141    QWidget *widget = NULL;
    138142    if (uselabel)
    139143    {
    140         QGroupBox *groupbox = new QGroupBox(parent);
     144        Q3GroupBox *groupbox = new Q3GroupBox(parent);
    141145        groupbox->setObjectName(QString("VCG(%1)_groupbox").arg(widgetName));
    142146        groupbox->setTitle(getLabel());
    143147        widget = groupbox;
    144148    }
    145149    else if (useframe)
    146150    {
    147         QFrame *frame = new QFrame(parent);
    148         frame->setFrameStyle(QFrame::Box);
     151        Q3Frame *frame = new Q3Frame(parent);
     152        frame->setFrameStyle(Q3Frame::Box);
    149153        frame->setObjectName(QString("VCG(%1)_frame").arg(widgetName));
    150154        widget = frame;
    151155    }
    … …  
    228232    QWidget            *parent,
    229233    const char         *widgetName)
    230234{
    231     QHBoxLayout *layout = new QHBoxLayout();
     235    Q3HBoxLayout *layout = new Q3HBoxLayout();
    232236    layout->setMargin(margin);
    233237    layout->setSpacing((space<0) ? margin : space);
    234238
    … …  
    251255    QWidget *widget = NULL;
    252256    if (uselabel)
    253257    {
    254         QGroupBox *groupbox = new QGroupBox(parent);
     258        Q3GroupBox *groupbox = new Q3GroupBox(parent);
    255259        groupbox->setObjectName(QString("HCG(%1)_groupbox").arg(widgetName));
    256260        groupbox->setTitle(getLabel());
    257261        widget = groupbox;
    258262    }
    259263    else if (useframe)
    260264    {
    261         QFrame *frame = new QFrame(parent);
    262         frame->setFrameStyle(QFrame::Box);
     265        Q3Frame *frame = new Q3Frame(parent);
     266        frame->setFrameStyle(Q3Frame::Box);
    263267        frame->setObjectName(QString("HCG(%1)_frame").arg(widgetName));
    264268        widget = frame;
    265269    }
    … …  
    301305    QWidget *widget = NULL;
    302306    if (uselabel)
    303307    {
    304         QGroupBox *groupbox = new QGroupBox(parent);
     308        Q3GroupBox *groupbox = new Q3GroupBox(parent);
    305309        groupbox->setObjectName(QString("GCG(%1)_groupbox").arg(widgetName));
    306310        groupbox->setTitle(getLabel());
    307311        widget = groupbox;
    308312    }
    309313    else if (useframe)
    310314    {
    311         QFrame *frame = new QFrame(parent);
    312         frame->setFrameStyle(QFrame::Box);
     315        Q3Frame *frame = new Q3Frame(parent);
     316        frame->setFrameStyle(Q3Frame::Box);
    313317        frame->setObjectName(QString("GCG(%1)_frame").arg(widgetName));
    314318        widget = frame;
    315319    }

  • libs/libmyth/dialogbox.h

     
    33
    44#include <QObject>
    55#include <QCheckBox>
     6#include <Q3VBoxLayout>
     7#include <QButtonGroup>
    68
    79#include "mythdialogs.h"
    810#include "compat.h" // to undef DialogBox
    9 class QVBoxLayout;
    10 class QButtonGroup;
    1111
    1212class MPUBLIC DialogBox : public MythDialog
    1313{
    … …  
    2828    ~DialogBox() {} // use deleteLater() for thread safety
    2929
    3030  private:
    31     QVBoxLayout *box;
     31    Q3VBoxLayout *box;
    3232    QButtonGroup *buttongroup;
    3333
    3434    QCheckBox *checkbox;

  • libs/libmyth/virtualkeyboard_qt.h

     
    22#define VIRTUALKEYBOARDQT_H_
    33
    44#include "mythdialogs.h"
     5#include <QKeyEvent>
    56
    6 class QKeyEvent;
    7 
    87/// Preferred position to place virtual keyboard popup.
    98enum PopupPositionQt
    109{

  • libs/libmyth/dbutil.cpp

     
    88#include <QFile>
    99#include <QRegExp>
    1010#include <QDateTime>
     11#include <QProcess>
    1112
    1213#include "dbutil.h"
    1314#include "mythcontext.h"

  • libs/libmyth/mythcontext.cpp

     
    77#include <QDesktopWidget>
    88#include <QPainter>
    99#include <QDebug>
     10#include <QTextStream>
     11#include <QKeyEvent>
    1012
    1113#include <cmath>
    1214#include <queue>

  • libs/libmyth/backendselect.cpp

     
    1111#include "mythcontext.h"
    1212
    1313#include "mythxmlclient.h"
     14#include <Q3GridLayout>
     15#include <QLabel>
     16#include <QKeyEvent>
     17#include <QEvent>
    1418
    1519
    1620BackendSelect::BackendSelect(MythMainWindow *parent, DatabaseParams *params)
    … …  
    168172{
    169173    // Probably should all be members, and deleted by ~BackendSelect()
    170174    QLabel         *label;
    171     QGridLayout    *layout;
     175    Q3GridLayout    *layout;
    172176    MythPushButton *cancel;
    173177    MythPushButton *manual;
    174178    MythPushButton *OK;
    … …  
    188192#endif
    189193
    190194
    191     layout = new QGridLayout(this);
     195    layout = new Q3GridLayout(this);
    192196    layout->setContentsMargins(40,40,40,40);
    193197    layout->addWidget(label, 0, 1, 1, 3);
    194198    layout->addWidget(m_backends, 1, 0, 1, 5);

  • libs/libmythfreemheg/Engine.cpp

     
    2020*/
    2121
    2222#include <QStringList>
    23 #include <qregexp.h>
     23#include <QRegExp>
    2424
    2525#include "Engine.h"
    2626#include "ParseNode.h"

  • libs/libmythfreemheg/Groups.h

     
    2222
    2323#if !defined(GROUPCLASS_H)
    2424#define GROUPCLASS_H
    25 #include <qstring.h>
    26 #include <qdatetime.h>
     25#include <QString>
     26#include <QDateTime>
    2727#include <QList>
    2828
    2929#include "Root.h"

  • libs/libmythfreemheg/libmythfreemheg.pro

     
    2525LIBS += $$EXTRA_LIBS
    2626
    2727include ( ../libs-targetfix.pro )
     28QT += network  sql qt3support

  • libs/libmythfreemheg/Logging.h

     
    2222#if !defined(LOGGING_H)
    2323#define LOGGING_H
    2424
    25 #include <qglobal.h> // For Q_ASSERT
    26 #include <qstring.h> // For QString
     25#include <QtGlobal> // For Q_ASSERT
     26#include <QString> // For QString
    2727
    2828#include "freemheg.h" // For MHLogError
    2929

  • libs/libmythfreemheg/BaseClasses.h

     
    2727#include <malloc.h>
    2828#endif
    2929
    30 #include <qstring.h>
     30#include <QString>
    3131
    3232#include "Logging.h" // For MHASSERT
    3333

  • libs/libmythfreemheg/Link.h

     
    2828#include "Actions.h"
    2929#include "BaseActions.h"
    3030
    31 #include <qstring.h>
     31#include <QString>
    3232
    3333class MHParseNode;
    3434

  • libs/libmythfreemheg/TokenGroup.h

     
    3131#include "BaseActions.h"
    3232#include "Actions.h"
    3333
    34 #include <qpoint.h>
     34#include <QPoint>
    3535#include <QList>
    3636
    3737class MHEngine;

  • libs/libmythfreemheg/Visible.h

     
    2121
    2222#if !defined(VISIBLE_H)
    2323#define VISIBLE_H
    24 #include <qregion.h>
     24#include <QRegion>
    2525
    2626#include "Presentable.h"
    2727// Dependencies

  • libs/libmythfreemheg/Engine.h

     
    3030#include "Visible.h"
    3131#include "Actions.h"
    3232#include "Link.h"
    33 #include <qstring.h>
    34 #include <qrect.h>
    35 #include <qregion.h>
     33
     34#include <QString>
     35#include <QRect>
     36#include <QRegion>
    3637#include <QList>
    3738#include <QStack>
    3839#include <QQueue>

  • libs/libmythfreemheg/Ingredients.h

     
    2626#include "BaseClasses.h"
    2727#include "Actions.h"
    2828#include "BaseActions.h"
    29 #include <qstring.h>
    3029
     30#include <QString>
     31
    3132class MHParseNode;
    3233
    3334// Abstract class for ingredients of a scene or application.

  • libs/libmythfreemheg/freemheg.h

     
    2222#if !defined(FREEMHEG_H)
    2323#define FREEMHEG_H
    2424
    25 #include <qregion.h>
     25#include <QRegion>
     26
    2627#include <stdio.h>
    2728#include <stdlib.h>
    2829
    … …  
    6869{
    6970public:
    7071    MHRgba(int red, int green, int blue, int alpha):
    71       m_red(red), m_green(green), m_blue(blue), m_alpha(alpha) {};
     72      m_red(Qt::red), m_green(Qt::green), m_blue(Qt::blue), m_alpha(alpha) {};
    7273    MHRgba(): m_red(0), m_green(0), m_blue(0), m_alpha(0) {};
    7374    int red() const { return m_red; }
    7475    int green() const { return m_green; }

  • libs/libmythupnp/refcounted.h

     
    2424#ifndef __REFCOUNTED_H__
    2525#define __REFCOUNTED_H__
    2626
    27 #include <qmutex.h>
     27#include <QMutex>
    2828
    2929/////////////////////////////////////////////////////////////////////////////
    3030/////////////////////////////////////////////////////////////////////////////

  • libs/libmythupnp/soapclient.h

     
    2424#ifndef SOAPCLIENT_H_
    2525#define SOAPCLIENT_H_
    2626
    27 #include <qdom.h>
     27#include <QDomNode>
     28#include <QUrl>
    2829
    2930#include "httpcomms.h"
    3031#include "upnputil.h"

  • libs/libmythupnp/threadpool.h

     
    2525#define __THREADPOOL_H__
    2626
    2727#include <deque>
     28#include <QEvent>
    2829using namespace std;
    2930
    3031#include <QString>

  • libs/libmythupnp/taskqueue.cpp

     
    2323
    2424#include "taskqueue.h"
    2525#include <sys/time.h>
    26 #include <qdatetime.h>
    2726
     27#include <QDateTime>
     28
    2829#include <iostream>
    2930
    3031using std::cerr;

  • libs/libmythupnp/configuration.cpp

     
    2525
    2626#include <QDir>
    2727#include <QFile>
     28#include <QTextStream>
    2829
    2930#include "configuration.h"
    3031#include "mythverbose.h"  // for VERBOSE and GetConfDir()

  • libs/libmythupnp/upnpdevice.h

     
    2828
    2929#include <QDomDocument>
    3030#include <QUrl>
     31#include <QTextStream>
    3132
    3233#include "upnputil.h"
    3334#include "refcounted.h"
    … …  
    3940class UPnpDevice;
    4041class UPnpService;
    4142class UPnpIcon;
    42 class QTextStream;
    4343
    4444/////////////////////////////////////////////////////////////////////////////
    4545// Typedefs

  • libs/libmythupnp/ssdp.cpp

     
    2929#include "multicast.h"
    3030#include "broadcast.h"
    3131
    32 #include <qregexp.h>
     32#include <QRegExp>
     33#include <QTextStream>
     34#include <QStringList>
    3335
    3436#include <unistd.h>
    3537#include <stdlib.h>
    36 #include <qstringlist.h>
    3738#include <sys/time.h>
    3839
    3940/////////////////////////////////////////////////////////////////////////////

  • libs/libmythupnp/upnputil.cpp

     
    2727#include <cerrno>
    2828
    2929// Qt headers
    30 #include <quuid.h>
     30#include <QUuid>
    3131
    3232// MythTV headers
    3333#include "upnputil.h"

  • libs/libmythupnp/httprequest.cpp

     
    2727#include <QFileInfo>
    2828#include <QTextCodec>
    2929#include <QStringList>
     30#include <QUrl>
    3031
    3132#include "mythconfig.h"
    3233#if defined CONFIG_DARWIN || defined CONFIG_CYGWIN || defined(__FreeBSD__) || defined(USING_MINGW)

  • libs/libmythupnp/libmythupnp.pro

     
    6767    QMAKE_LFLAGS_SHLIB += -flat_namespace
    6868}
    6969
    70 #The following line was inserted by qt3to4
    7170QT += network xml sql
    7271
    7372include ( ../libs-targetfix.pro )
    7473
    7574LIBS += $$LATE_LIBS
     75QT +=  opengl qt3support

  • libs/libmythupnp/upnpmsrr.h

     
    11#ifndef UPnpMSRR_H_
    22#define UPnpMSRR_H_
    33
    4 #include <qdom.h>
    5 #include <qdatetime.h>
     4#include <QDomNode>
     5#include <QDateTime>
    66
    77#include "httpserver.h"
    88#include "eventing.h"

  • libs/libmythupnp/threadpool.cpp

     
    2222//////////////////////////////////////////////////////////////////////////////
    2323
    2424#include <QCoreApplication>
     25#include <QEvent>
    2526
    2627#include <algorithm>
    2728using namespace std;

  • libs/libmythupnp/soapclient.cpp

     
    2121//
    2222//////////////////////////////////////////////////////////////////////////////
    2323
    24 #include <qbuffer.h>
     24#include <QBuffer>
     25#include <QTextStream>
     26#include <QHttpRequestHeader>
    2527
    2628#include "soapclient.h"
    2729

  • libs/libmythupnp/upnpdevice.cpp

     
    2828#include <unistd.h>
    2929#include <cerrno>
    3030
    31 #include <qfile.h>
     31#include <QFile>
    3232#include <QTextStream>
    3333
    3434int DeviceLocation::g_nAllocated   = 0;       // Debugging only

  • libs/libmythupnp/mythxmlclient.h

     
    2424#ifndef MYTHXMLCLIENT_H_
    2525#define MYTHXMLCLIENT_H_
    2626
    27 #include <qdom.h>
    28 #include <qbuffer.h>
     27#include <QDomNode>
     28#include <QBuffer>
     29#include <QUrl>
    2930
    3031#include "httpcomms.h"
    3132

  • libs/libmythupnp/configuration.h

     
    2424#ifndef __CONFIGURATION_H__
    2525#define __CONFIGURATION_H__
    2626
    27 #include <qdom.h>
    28 #include <qstringlist.h>
     27#include <QDomNode>
     28#include <QStringList>
    2929
    3030class Configuration
    3131{

  • libs/libmythupnp/eventing.h

     
    2929#include <QUrl>
    3030#include <QUuid>
    3131#include <QMap>
     32#include <QTextStream>
    3233
    3334#include "upnpimpl.h"
    3435#include "upnputil.h"
    3536#include "httpserver.h"
    3637
    37 class QTextStream;
    38 
    3938//////////////////////////////////////////////////////////////////////////////
    4039//
    4140//////////////////////////////////////////////////////////////////////////////

  • libs/libmythupnp/upnpmsrr.cpp

     
    99#include "upnpmsrr.h"
    1010
    1111#include <math.h>
    12 #include <qregexp.h>
    1312
     13#include <QRegExp>
     14
    1415/////////////////////////////////////////////////////////////////////////////
    1516//
    1617/////////////////////////////////////////////////////////////////////////////

  • libs/libmythupnp/upnpcdsobjects.h

     
    2828#include <QString>
    2929#include <QList>
    3030#include <QMap>
     31#include <QTextStream>
    3132
    3233class CDSObject;
    33 class QTextStream;
    3434
    3535//////////////////////////////////////////////////////////////////////////////
    3636//

  • libs/libmythdvdnav/libmythdvdnav.pro

     
    5555mingw:DEFINES += STDC_HEADERS
    5656
    5757include ( ../libs-targetfix.pro )
     58QT +=  qt3support

  • libs/libmythfreesurround/freesurround.cpp

     
    2929#include <map>
    3030#include <math.h>
    3131
    32 #include <qstring.h>
    33 #include <qdatetime.h>
     32#include <QString>
     33#include <QDateTime>
    3434
    3535using namespace std;
    3636

  • libs/libmythfreesurround/libmythfreesurround.pro

     
    3030}
    3131
    3232include ( ../libs-targetfix.pro )
     33QT +=  qt3support

  • libs/libmythdb/oldsettings.cpp

     
    1212#include "oldsettings.h"
    1313#include "mythverbose.h"
    1414
    15 #include <qstring.h>
     15#include <QString>
     16#include <QDir>
     17
    1618#include <fstream>
    1719#include <cstdlib>
    1820#include <cstdio>
    … …  
    2325
    2426using namespace std;
    2527
    26 #include <qdir.h>
    27 
    2828Settings::Settings(QString strSettingsFile)
    2929{
    3030    if (strSettingsFile.length() == 0)

  • libs/libmythdb/msocketdevice_win.cpp

     
    4545#include "qwindowdefs.h"
    4646#include "qdatetime.h"
    4747
    48 #include <qcoreapplication.h>
     48#include <QCoreApplication>
    4949
    5050#include <string.h>
    5151

  • libs/libmythdb/decodeencode.h

     
    22#define DECODEENCODE_H_
    33
    44#include <algorithm>
     5
    56using namespace std;
    67
    7 #include <qstringlist.h>
     8#include <QStringList>
    89
    910// This is necessary for GCC 3.3, which has llabs(long long)
    1011// // but not abs(long long) or std::llabs(long long)

  • libs/libmythdb/httpcomms.cpp

     
    11#include <iostream>
    22
    3 #include <qfile.h>
    4 #include <qapplication.h>
    5 #include <qregexp.h>
     3#include <QFile>
     4#include <QApplication>
     5#include <QRegExp>
     6
    67#include <unistd.h>
    78
    89#include "mythverbose.h"

  • libs/libmythdb/mythobservable.cpp

     
    1 #include <qobject.h>
    2 #include <qapplication.h>
     1#include <QObject>
     2#include <QApplication>
    33
    44#include "mythobservable.h"
    55

  • libs/libmythdb/mythdb.cpp

     
    11#include <QMutex>
     2#include <QSqlQuery>
     3#include <QSqlError>
    24
    35#include "mythdb.h"
    46#include "mythdbcon.h"

  • libs/libmythdb/mythdbcon.h

     
    33
    44#include <iostream>
    55
    6 #include <qsqldatabase.h>
    7 #include <qvariant.h>
    8 #include <qsql.h>
    9 #include <qsqlquery.h>
    10 #include <qsemaphore.h>
    11 #include <qsqlerror.h>
    12 #include <qsqlfield.h>
     6#include <QSqlDatabase>
     7#include <QVariant>
     8#include <QSqlQuery>
     9#include <QSemaphore>
     10#include <QSqlError>
     11#include <QSqlField>
    1312#include <QRegExp>
    1413#include <QDateTime>
    1514#include <QMutex>

  • libs/libmythdb/mythsocket.h

     
    1212#include "mythexp.h"
    1313#include "msocketdevice.h"
    1414
    15 class QHostAddress;
    1615class MythSocket;
    1716
    1817class MPUBLIC MythSocketCBs
    … …  
    4948    QList<MythSocket*> m_readyread_dellist;
    5049    QList<MythSocket*> m_readyread_addlist;
    5150#ifdef USING_MINGW
    52     HANDLE readyreadevent;
     51    Qt::HANDLE readyreadevent;
    5352#else
    5453    int m_readyread_pipe[2];
    5554#endif

  • libs/libmythdb/remotefile.h

     
    11#ifndef REMOTEFILE_H_
    22#define REMOTEFILE_H_
    33
    4 #include <qstring.h>
    5 #include <qmutex.h>
     4#include <QString>
     5#include <QMutex>
    66
    77#include "mythexp.h"
    88

  • libs/libmythdb/oldsettings.h

     
    99
    1010#ifndef OLDSETTINGS_H
    1111#define OLDSETTINGS_H
    12 #include <qstring.h>
     12
     13#include <QString>
    1314#include <QPixmap>
     15
    1416#include <map>
    1517
    1618#include "mythexp.h"
    … …  
    2022  *@author Sean Ward
    2123  */
    2224
    23 class QPixmap;
    2425class MPUBLIC Settings {
    2526public:
    2627        Settings(QString strSettingFile = "settings.txt");

  • libs/libmythdb/httpcomms.h

     
    11#ifndef HTTPCOMMS_H_
    22#define HTTPCOMMS_H_
    33
    4 #include <qurl.h>
    5 #include <qobject.h>
     4#include <QUrl>
     5#include <QObject>
    66#include <QByteArray>
    77#include <QString>
    88#include <QTimer>
    99#include <QHttp>
     10#include <QHttpRequestHeader>
    1011
    1112#include "mythexp.h"
    1213

  • libs/libmythdb/qcodecs.h

     
    3838
    3939#include <mythexp.h>
    4040
    41 class QByteArray;
    42 class QIODevice;
    43 
    4441/**
    4542 * A wrapper class for the most commonly used encoding and
    4643 * decoding algorithms.  Currently there is support for encoding

  • libs/libmythdb/mythdbcon.cpp

     
    33
    44#include <QVector>
    55#include <QSqlDriver>
     6#include <QSqlQuery>
    67
    78#include "compat.h"
    89#include "mythdbcon.h"

  • libs/libmythdb/mythsocket.cpp

     
    1 #include <qapplication.h>
    2 #include <qstring.h>
    3 #include <unistd.h>
    4 #include <stdlib.h>
    5 
     1#include <QApplication>
     2#include <QString>
    63#include <QByteArray>
    74#include <QMutex>
    85#include <QHostInfo>
    96
     7#include <unistd.h>
     8#include <stdlib.h>
     9
    1010#include "mythtimer.h"
    1111#include "mythsocket.h"
    1212#include "mythverbose.h"
    … …  
    811811#ifdef USING_MINGW
    812812
    813813        int n = m_readyread_list.count() + 1;
    814         HANDLE *hEvents = new HANDLE[n];
    815         memset(hEvents, 0, sizeof(HANDLE) * n);
     814        Qt::HANDLE *hEvents = new Qt::HANDLE[n];
     815        memset(hEvents, 0, sizeof(Qt::HANDLE) * n);
    816816        unsigned *idx = new unsigned[n];
    817817        n = 0;
    818818
    … …  
    822822            if (sock->state() == MythSocket::Connected
    823823                && !sock->m_notifyread && !isLocked(sock->m_lock))
    824824            {
    825                 HANDLE hEvent = ::CreateEvent(NULL, false, false, NULL);
     825                Qt::HANDLE hEvent = ::CreateEvent(NULL, false, false, NULL);
    826826                if (!hEvent)
    827827                {
    828828                    VERBOSE(VB_IMPORTANT, "MythSocket: CreateEvent failed");

  • libs/libmythdb/mythobservable.h

     
    55#include "mythevent.h"
    66#include "mythexp.h"
    77
    8 class QObject;
    9 
    108/** \class MythObservable
    119    \brief Superclass for making an object have a set of listeners
    1210

  • libs/libmythdb/libmythdb.pro

     
    5656include ( ../libs-targetfix.pro )
    5757
    5858LIBS += $$LATE_LIBS
     59QT +=  qt3support

  • libs/libmythdb/mythdb.h

     
    22#define MYTHDB_H_
    33
    44#include <QString>
     5#include <QSqlQuery>
     6#include <QSqlError>
    57#include "mythexp.h"
    68#include "mythdbcon.h"
    79#include "mythdbparams.h"

  • programs/mythfrontend/manualschedule.h

     
    66
    77#include "mythscreentype.h"
    88
    9 class QTimer;
    109class ProgramInfo;
    1110
    1211class MythUIButton;

  • programs/mythfrontend/playbackbox.cpp

     
     1#include <QKeyEvent>
     2#include <QEvent>
    13
    24using namespace std;
    35

  • programs/mythfrontend/viewscheduled.h

     
    22#define VIEWSCHEDULED_H_
    33
    44#include <QDateTime>
     5#include <QEvent>
     6#include <QKeyEvent>
    57
    68#include "programlist.h"
    79

  • programs/mythfrontend/statusbox.h

     
    22#define STATUSBOX_H_
    33
    44#include <vector>
     5#include <QKeyEvent>
     6#include <QEvent>
    57using namespace std;
    68
    79#include "mythscreentype.h"

  • programs/mythfrontend/channelrecpriority.cpp

     
    22#include <iostream>
    33#include <algorithm>
    44#include <vector>
     5#include <QKeyEvent>
     6#include <QEvent>
    57using namespace std;
    68
    79#include "channelrecpriority.h"

  • programs/mythfrontend/mythappearance.h

     
    11#ifndef MYTHAPPEARANCE_H
    22#define MYTHAPPEARANCE_H
    33
    4 #include <qstringlist.h>
    5 #include <qstring.h>
     4#include <QStringList>
     5#include <QString>
     6#include <QEvent>
     7#include <QKeyEvent>
    68
    79#include "mythscreentype.h"
    810#include "mythuitext.h"

  • programs/mythfrontend/proglist.h

     
    44// Qt headers
    55#include <QDateTime>
    66#include <QKeyEvent>
     7#include <QEvent>
    78
    89// MythTV headers
    910#include "mythscreentype.h"

  • programs/mythfrontend/programrecpriority.h

     
    44#include "programinfo.h"
    55#include "scheduledrecording.h"
    66#include "mythscreentype.h"
     7#include <QKeyEvent>
    78
    8 class QDateTime;
    9 
    109class MythUIButtonList;
    1110class MythUIButtonListItem;
    1211class MythUIText;

  • programs/mythfrontend/mythcontrols.h

     
    2727// QT
    2828#include <QList>
    2929#include <QHash>
     30#include <QEvent>
     31#include <QKeyEvent>
    3032
    3133// MythUI
    3234#include <mythscreentype.h>

  • programs/mythfrontend/custompriority.cpp

     
    11#include <unistd.h>
    22#include <iostream>
     3#include <QSqlError>
    34using namespace std;
    45
    56#include "custompriority.h"

  • programs/mythfrontend/globalsettings.cpp

     
    1010// Qt headers
    1111#include <QApplication>
    1212#include <QEvent>
    13 #include <qnamespace.h>
     13#include <Qt>
    1414#include <QStyleFactory>
    1515#include <QFile>
    1616#include <QDialog>

  • programs/mythfrontend/mythfexml.h

     
    88#ifndef MYTHFEXML_H_
    99#define MYTHFEXML_H_
    1010
    11 #include <qdom.h>
    12 #include <qdatetime.h>
     11#include <QDomNode>
     12#include <QDateTime>
    1313
    1414#include "upnp.h"
    1515#include "eventing.h"

  • programs/mythfrontend/keygrabber.h

     
    66#include <mythscreentype.h>
    77
    88#include "mythscreentype.h"
     9#include <QKeyEvent>
    910
    1011class MythUIText;
    1112class MythUIButton;

  • programs/mythfrontend/viewscheduled.cpp

     
    11#include <stdlib.h>
    22
    33#include <iostream>
     4#include <QKeyEvent>
     5#include <QEvent>
    46using namespace std;
    57
    68#include <QDateTime>

  • programs/mythfrontend/statusbox.cpp

     
    55#include <stdlib.h>
    66
    77#include <iostream>
     8#include <QKeyEvent>
     9#include <QEvent>
    810using namespace std;
    911
    1012#include <QRegExp>

  • programs/mythfrontend/networkcontrol.h

     
    22#define NETWORKCONTROL_H_
    33
    44#include <deque>
     5#include <QEvent>
     6#include <QTextStream>
    57using namespace std;
    68
    79#include <pthread.h>
    … …  
    1214#include <QMutex>
    1315
    1416class MainServer;
    15 class QTextStream;
    1617
    1718// Locking order
    1819// clientLock -> ncLock

  • programs/mythfrontend/mythfrontend.pro

     
    6666using_jack:DEFINES += USING_JACK
    6767using_oss: DEFINES += USING_OSS
    6868macx:      DEFINES += USING_COREAUDIO
     69QT +=  qt3support

  • programs/mythfrontend/mythappearance.cpp

     
    11#define MYTHAPPEARANCE_CPP
    22
    33/* QT includes */
    4 #include <qnamespace.h>
     4#include <Qt>
    55#include <QStringList>
    66#include <QApplication>
    77#include <QDomNode>
    8 #include <QButtonGroup>
     8#include <Q3ButtonGroup>
    99#include <QImage>
    1010#include <QEvent>
    1111#include <QDir>
    1212#include <QString>
     13#include <QKeyEvent>
    1314
    1415/* MythTV includes */
    1516#include "mythcontext.h"

  • programs/mythfrontend/proglist.cpp

     
    22#include <map>
    33#include <vector>
    44#include <algorithm>
     5#include <QKeyEvent>
     6#include <QEvent>
    57using namespace std;
    68
    79// qt

  • programs/mythfrontend/programrecpriority.cpp

     
    11
    22#include <iostream>
    33#include <vector>
     4#include <QKeyEvent>
    45using namespace std;
    56
    67#include <QDateTime>

  • programs/mythfrontend/playbackbox.h

     
    66
    77// C++ headers
    88#include <vector>
     9#include <QKeyEvent>
     10#include <QEvent>
    911using namespace std;
    1012
    1113#include <QDateTime>
    … …  
    2123
    2224class NuppelVideoPlayer;
    2325class RingBuffer;
    24 class QTimer;
    2526class ProgramInfo;
    2627class PreviewGenerator;
    2728

  • programs/mythfrontend/mythcontrols.cpp

     
    3030#include <QStringList>
    3131#include <QApplication>
    3232#include <QKeyEvent>
     33#include <QEvent>
    3334
    3435// MythTV headers
    3536#include <mythcontext.h>

  • programs/mythfrontend/channelrecpriority.h

     
    44#include "mythscreentype.h"
    55
    66#include "programinfo.h"
     7#include <QKeyEvent>
     8#include <QEvent>
    79
    810class ChannelInfo;
    911

  • programs/mythfrontend/mediarenderer.h

     
    1111#ifndef __MEDIARENDERER_H__
    1212#define __MEDIARENDERER_H__
    1313
    14 #include <qobject.h>
    15 #include <qmutex.h>
     14#include <QObject>
     15#include <QMutex>
    1616
    1717#include "upnp.h"
    1818#include "upnpcmgr.h"

  • programs/mythfrontend/mythfexml.cpp

     
    1313
    1414#include "mythmainwindow.h"
    1515
    16 #include <qtextstream.h>
    17 #include <qdir.h>
    18 #include <qfile.h>
    19 #include <qregexp.h>
    20 #include <qbuffer.h>
     16#include <QTextStream>
     17#include <QDir>
     18#include <QFile>
     19#include <QRegExp>
     20#include <QBuffer>
     21
    2122#include <math.h>
    2223
    2324#include "../../config.h"

  • programs/mythfrontend/action.cpp

     
    2323 */
    2424
    2525// Qt headers
    26 #include <qkeysequence.h>
     26#include <QKeySequence>
    2727
    2828// MythControls headers
    2929#include "action.h"

  • programs/mythfrontend/keygrabber.cpp

     
    11// -*- Mode: c++ -*-
    22// Qt headers
    33#include <QString>
     4#include <QKeyEvent>
    45
    56// MythTV headers
    67#include <mythcontext.h>

  • programs/mythfrontend/mythosdmenueditor.cpp

     
    11#define MYTHOSDMENUEDITOR_CPP
    22
    33/* QT includes */
    4 #include <qnamespace.h>
    5 #include <qstringlist.h>
    6 #include <qapplication.h>
    7 #include <qdom.h>
    8 #include <qbuttongroup.h>
    9 #include <qimage.h>
    10 #include <qevent.h>
    11 #include <qdir.h>
    12 #include <qstring.h>
     4#include <Qt>
     5#include <QStringList>
     6#include <QApplication>
     7#include <QDomNode>
     8#include <Q3ButtonGroup>
     9#include <QImage>
     10#include <QEvent>
     11#include <QDir>
     12#include <QString>
    1313
    1414/* MythTV includes */
    1515#include "mythcontext.h"

  • programs/mythjobqueue/mythjobqueue.pro

     
    1414
    1515# Input
    1616SOURCES += main.cpp
     17QT += xml network  opengl qt3support

  • programs/mythtranscode/replex/replex.pro

     
    3434DEPENDPATH += ../../../libs/libavutil ../../../libs/libavformat ../../../libs/libsavcodec
    3535
    3636CONFIG  -= qt
     37QT += xml network  sql opengl qt3support

  • programs/mythtranscode/mythtranscode.pro

     
    2222INCLUDEPATH += replex
    2323INCLUDEPATH += ../../libs/libavcodec ../../libs/libavformat \
    2424               ../../libs/libavutil  ../../libs/ ../../libs/libmythmpeg2
     25QT +=  opengl

  • programs/mythtranscode/transcode.cpp

     
    88#include <ctime>
    99#include <math.h>
    1010
    11 #include <qstringlist.h>
    12 #include <qsqldatabase.h>
    13 #include <qmap.h>
    14 #include <qstringlist.h>
    15 #include <qregexp.h>
     11#include <QStringList>
     12#include <QSqlDatabase>
     13#include <QMap>
     14#include <QStringList>
     15#include <QRegExp>
    1616
    1717#include <iostream>
     18
    1819using namespace std;
    1920
    2021#include "osdtypes.h"

  • programs/mythtranscode/mpeg2fix.h

     
    2323#include <QStringList>
    2424#include <QDateTime>
    2525
    26 #include <q3ptrlist.h>
    27 #include <q3ptrqueue.h>
    28 #include <q3valuelist.h>
     26#include <Q3PtrList>
     27#include <Q3PtrQueue>
     28#include <Q3ValueList>
    2929
    3030#include "transcodedefs.h"
    3131
    … …  
    265265};
    266266
    267267#ifdef NO_MYTH
    268     #include <qdatetime.h>
     268    #include <QDateTime>
     269
    269270    #include <iostream>
    270271
    271272    using namespace std;

  • programs/mythcommflag/mythcommflag.pro

     
    4747
    4848SOURCES += main.cpp
    4949
    50 #The following line was inserted by qt3to4
    5150QT += xml sql
    52 
     51QT += network  opengl qt3support

  • programs/mythcommflag/CommDetectorFactory.h

     
    11#ifndef _COMMDETECTOR_FACTORY_H_
    22#define _COMMDETECTOR_FACTORY_H_
    33
     4#include <QDateTime>
     5
    46#include "channelutil.h"
    57
    68class CommDetectorBase;
    79class NuppelVideoPlayer;
    810class RemoteEncoder;
    9 class QDateTime;
    1011
    1112class CommDetectorFactory
    1213{

  • programs/mythcommflag/FrameAnalyzer.h

     
    1010/* Base class for commercial flagging video frame analyzers. */
    1111
    1212#include <limits.h>
    13 #include <qmap.h>
     13#include <QMap>
    1414
    1515/* 
    1616 * At least FreeBSD doesn't define LONG_LONG_MAX, but it does define 

  • programs/scripts/scripts.pro

     
    1212INSTALLS += installscripts
    1313
    1414SOURCES += dummy.c
     15QT += xml network  sql opengl qt3support

  • programs/mythbackend/playbacksock.h

     
    11#ifndef PLAYBACKSOCK_H_
    22#define PLAYBACKSOCK_H_
    33
    4 #include <qstring.h>
    5 #include <qmutex.h>
     4#include <QString>
     5#include <QMutex>
    66
    77#include "programinfo.h"
    88

  • programs/mythbackend/mainserver.h

     
    11#ifndef MAINSERVER_H_
    22#define MAINSERVER_H_
    33
    4 #include <qmap.h>
    5 #include <qtimer.h>
    6 #include <qmutex.h>
    7 #include <qdom.h>
     4#include <QMap>
     5#include <QTimer>
     6#include <QMutex>
     7#include <QDomNode>
    88#include <QEvent>
    99
    1010#include <vector>
     11
    1112using namespace std;
    1213
    1314#include "tv.h"
    … …  
    2122#include "mythdeque.h"
    2223
    2324class ProcessRequestThread;
    24 class QUrl;
    2525class MythServer;
    2626
    2727class MainServer : public QObject, public MythSocketCBs

  • programs/mythbackend/scheduler.h

     
    88using namespace std;
    99
    1010// Qt headers
    11 #include <qmutex.h>
    12 #include <qwaitcondition.h>
    13 #include <qmap.h>
    14 #include <qobject.h>
     11#include <QMutex>
     12#include <QWaitCondition>
     13#include <QMap>
     14#include <QObject>
    1515
    1616// MythTV headers
    1717#include "scheduledrecording.h"

  • programs/mythbackend/httpstatus.h

     
    1111#ifndef HTTPSTATUS_H_
    1212#define HTTPSTATUS_H_
    1313
    14 #include <qdom.h>
    15 #include <qdatetime.h>
     14#include <QDomNode>
     15#include <QDateTime>
     16#include <QTextStream>
    1617
    1718#include "httpserver.h"
    1819#include "mainserver.h"

  • programs/mythbackend/autoexpire.h

     
    99#include <vector>
    1010#include <set>
    1111
    12 #include <qmap.h>
    13 #include <qmutex.h>
    14 #include <qwaitcondition.h>
    15 #include <qobject.h>
     12#include <QMap>
     13#include <QMutex>
     14#include <QWaitCondition>
     15#include <QObject>
    1616
    1717using namespace std;
    1818class ProgramInfo;

  • programs/mythbackend/backendutil.h

     
    11#ifndef _BACKENDUTIL_H
    22#define _BACKENDUTIL_H
    33
    4 #include <qstringlist.h>
     4#include <QStringList>
    55
    66#include "libmythtv/remoteutil.h"
    77#include "encoderlink.h"

  • programs/mythbackend/encoderlink.h

     
    11#ifndef ENCODERLINK_H_
    22#define ENCODERLINK_H_
    33
    4 #include <qstring.h>
     4#include <QString>
    55
    66#include "tv.h"
    77#include "programinfo.h"

  • programs/mythbackend/playbacksock.cpp

     
    1 #include <qstringlist.h>
     1#include <QStringList>
    22
    33#include <iostream>
    44

  • programs/mythbackend/mythbackend.pro

     
    3636
    3737using_valgrind:DEFINES += USING_VALGRIND
    3838
     39QT +=  opengl qt3support

  • programs/mythbackend/mediaserver.h

     
    1111#ifndef __MEDIASERVER_H__
    1212#define __MEDIASERVER_H__
    1313
    14 #include <qobject.h>
    15 #include <qmutex.h>
     14#include <QObject>
     15#include <QMutex>
    1616
    1717#include "libmythupnp/upnp.h"
    1818

  • programs/mythbackend/upnpcdsmusic.cpp

     
    1010
    1111#include "upnpcdsmusic.h"
    1212#include "httprequest.h"
    13 #include <qfileinfo.h>
     13
     14#include <QFileInfo>
     15
    1416#include <limits.h>
     17
    1518#include "mythcontext.h"
    1619
    1720/*

  • programs/mythbackend/scheduler.cpp

     
    11#include <unistd.h>
    2 #include <qsqldatabase.h>
    3 #include <qsqlquery.h>
    4 #include <qregexp.h>
    5 #include <qstring.h>
    6 #include <qdatetime.h>
    72
     3#include <QSqlDatabase>
     4#include <QSqlQuery>
     5#include <QRegExp>
     6#include <QString>
     7#include <QDateTime>
     8
    89#include <iostream>
    910#include <algorithm>
     11
    1012using namespace std;
    1113
    1214#ifdef __linux__

  • programs/mythbackend/housekeeper.cpp

     
    11#include <unistd.h>
    22#include <sys/types.h>
    33#include <unistd.h>
    4 #include <qsqldatabase.h>
    5 #include <qsqlquery.h>
    6 #include <qstring.h>
    7 #include <qdatetime.h>
    8 #include <qstringlist.h>
    9 #include <qfileinfo.h>
    104
     5#include <QSqlDatabase>
     6#include <QSqlQuery>
     7#include <QString>
     8#include <QDateTime>
     9#include <QStringList>
     10#include <QFileInfo>
     11
    1112#include <iostream>
    1213#include <cstdlib>
     14
    1315using namespace std;
    1416
    1517#include "housekeeper.h"

  • programs/mythbackend/upnpmedia.cpp

     
    11#include "httprequest.h"
    2 #include <qfileinfo.h>
    3 #include <qregexp.h>
    4 #include <qurl.h>
    5 #include <qdir.h>
     2
     3#include <QFileInfo>
     4#include <QRegExp>
     5#include <QUrl>
     6#include <QDir>
     7
    68#include <limits.h>
    79#include <unistd.h>
     10
    811#include "util.h"
    912
    1013#include <cstdlib>

  • programs/mythbackend/autoexpire.cpp

     
    33#include <signal.h>
    44
    55
    6 #include <qregexp.h>
    7 #include <qstring.h>
    8 #include <qdatetime.h>
    9 #include <qfileinfo.h>
     6#include <QRegExp>
     7#include <QString>
     8#include <QDateTime>
     9#include <QFileInfo>
    1010
    1111#include <iostream>
    1212#include <algorithm>

  • programs/mythbackend/backendutil.cpp

     
    88#include <sys/vfs.h>
    99#endif
    1010
    11 #include <qdir.h>
    12 #include <qmutex.h>
    13 #include <qmap.h>
     11#include <QDir>
     12#include <QMutex>
     13#include <QMap>
    1414
    1515#include "backendutil.h"
    1616#include "remoteutil.h"

  • programs/mythbackend/filetransfer.h

     
    99using namespace std;
    1010
    1111// Qt headers
    12 #include <qstring.h>
    13 #include <qmutex.h>
    14 #include <qwaitcondition.h>
     12#include <QString>
     13#include <QMutex>
     14#include <QWaitCondition>
    1515
    1616class ProgramInfo;
    1717class RingBuffer;

  • programs/mythtv-setup/channeleditor.cpp

     
    1 #include <qsqldatabase.h>
     1#include <QSqlDatabase>
     2#include <QKeyEvent>
     3#include <QEvent>
     4#include <QApplication>
     5
    26#include "settings.h"
    37#include "mythcontext.h"
    48#include "mythdb.h"
    59#include "channeleditor.h"
    610
    7 #include <QApplication>
    8 
    911#include <mythdialogs.h>
    1012#include <mythwizard.h>
    1113

  • programs/mythtv-setup/channeleditor.h

     
    44#include "mythscreentype.h"
    55
    66#include "settings.h"
     7#include <QKeyEvent>
     8#include <QEvent>
    79
    810class MythUIButton;
    911class MythUIButtonList;

  • programs/mythtv-setup/importicons.cpp

     
    33#include <QBuffer>
    44#include <QDir>
    55#include <QFileInfo>
     6#include <QEvent>
    67
    78#include "mythcontext.h"
    89#include "mythdb.h"

  • programs/mythtv-setup/mythtv-setup.pro

     
    3636
    3737using_x11:DEFINES += USING_X11
    3838
     39QT +=  opengl qt3support

  • programs/mythtv-setup/importicons.h

     
    1515
    1616#include <QUrl>
    1717#include <QDir>
     18#include <QEvent>
    1819
    1920#include "mythscreentype.h"
    2021

  • programs/mythlcdserver/lcdserver.h

     
    77
    88*/
    99
    10 #include <qobject.h>
    11 #include <qstringlist.h>
     10#include <QObject>
     11#include <QStringList>
    1212
    1313#include "serversocket.h"
    1414#include "lcdprocclient.h"

  • programs/mythlcdserver/main.cpp

     
    1313
    1414#include <QApplication>
    1515#include <QFile>
    16 #include <q3textstream.h>
     16#include <QTextStream>
    1717
    1818#include "exitcodes.h"
    1919#include "mythcontext.h"

  • programs/mythlcdserver/serversocket.h

     
    1010
    1111*/
    1212
    13 #include <q3socket.h>
    14 #include <q3serversocket.h>
     13#include <Q3Socket>
     14#include <Q3ServerSocket>
    1515
    1616
    17 
    1817class LCDServerSocket : public Q3ServerSocket
    1918{
    2019

  • programs/mythlcdserver/lcdprocclient.cpp

     
    1111#include <stdlib.h>
    1212#include <cmath>
    1313
    14 #include <qapplication.h>
    15 #include <q3textstream.h>
     14#include <QApplication>
     15#include <QTextStream>
     16#include <Q3PtrList>
     17#include <QEvent>
    1618
    1719#include "lcdprocclient.h"
    1820#include "mythcontext.h"
    … …  
    158160
    159161    if (!connected)
    160162    {
    161         Q3TextStream os(socket);
     163        QTextStream os(socket);
    162164        socket->connectToHost(hostname, port);
    163165
    164166        while (--timeout && socket->state() != Q3Socket::Idle)
    … …  
    197199        return;
    198200    }
    199201
    200     Q3TextStream os(socket);
    201     os.setEncoding(Q3TextStream::Latin1);
     202    QTextStream os(socket);
     203    os.setEncoding(QTextStream::Latin1);
    202204
    203205    last_command = someText;
    204206

  • programs/mythlcdserver/lcdserver.cpp

     
    5656*/
    5757
    5858#include <stdlib.h>
    59 #include <qstringlist.h>
    60 #include <qregexp.h>
    61 #include <qdir.h>
    62 #include <qapplication.h>
     59
     60#include <QStringList>
     61#include <QRegExp>
     62#include <QDir>
     63#include <QApplication>
    6364#include <Q3PtrList>
    6465
    6566#include "util.h"

  • programs/mythlcdserver/mythlcdserver.pro

     
    1313
    1414SOURCES += main.cpp lcdserver.cpp serversocket.cpp lcdprocclient.cpp
    1515
    16 #The following line was inserted by qt3to4
    1716QT += network xml  sql opengl qt3support

  • programs/mythlcdserver/lcdprocclient.h

     
    11#ifndef LCDPROCCLIENT_H_
    22#define LCDPROCCLIENT_H_
    33
    4 #include <qobject.h>
    5 #include <qstringlist.h>
    6 #include <q3valuevector.h>
    7 #include <q3socket.h>
    8 #include <qtimer.h>
    9 #include <qdatetime.h>
     4#include <QObject>
     5#include <QStringList>
     6#include <Q3ValueVector>
     7#include <Q3Socket>
     8#include <QTimer>
     9#include <QDateTime>
    1010#include <QEvent>
    1111#include <Q3PtrList>
    1212

  • programs/mythtv/mythtv.pro

     
    2323}
    2424
    2525using_x11:DEFINES += USING_X11
     26QT +=  qt3support

  • programs/mythwelcome/welcomedialog.h

     
    33
    44// qt
    55#include <QDateTime>
     6#include <QEvent>
     7#include <QKeyEvent>
    68
    79// myth
    810#include "remoteutil.h"

  • programs/mythwelcome/mythwelcome.pro

     
    2121# Input
    2222HEADERS += welcomedialog.h welcomesettings.h
    2323SOURCES += main.cpp welcomedialog.cpp welcomesettings.cpp
     24QT += network  opengl qt3support

  • programs/mythwelcome/welcomedialog.cpp

     
    55#include <unistd.h>
    66
    77// qt
    8 #include <qapplication.h>
     8#include <QApplication>
    99#include <QKeyEvent>
    1010#include <QLabel>
    1111#include <QEvent>

  • programs/mythtvosd/mythtvosd.pro

     
    1818SOURCES += main.cpp
    1919
    2020mingw: LIBS += -lpthread -lwinmm -lws2_32
     21QT += xml  sql opengl qt3support

  • programs/mythtvosd/main.cpp

     
    99using namespace std;
    1010
    1111// Qt headers
    12 #include <qapplication.h>
     12#include <QApplication>
    1313#include <QUdpSocket>
    14 #include <qstring.h>
    15 #include <qfile.h>
    16 #include <qhostaddress.h>
     14#include <QString>
     15#include <QFile>
     16#include <QHostAddress>
    1717
    1818// MythTV headers
    1919#include "exitcodes.h"

  • programs/mythfilldatabase/filldata.cpp

     
    1111using namespace std;
    1212
    1313// Qt headers
    14 #include <qmap.h>
    15 #include <qdatetime.h>
    16 #include <qdir.h>
    17 #include <qfile.h>
     14#include <QMap>
     15#include <QDateTime>
     16#include <QDir>
     17#include <QFile>
    1818#include <QProcess>
    1919#include <QList>
    2020

  • programs/mythfilldatabase/icondata.cpp

     
    33#include <signal.h>
    44
    55// Qt headers
    6 #include <qdom.h>
    7 #include <qfile.h>
    8 #include <qfileinfo.h>
     6#include <QDomNode>
     7#include <QFile>
     8#include <QFileInfo>
     9#include <QTextStream>
    910
    1011#include <iostream>
    1112#include <cstdlib>

  • programs/mythfilldatabase/fillutil.cpp

     
    11// Qt headers
    2 #include <qfile.h>
    3 #include <qdir.h>
     2#include <QFile>
     3#include <QDir>
    44
    55// libmyth headers
    66#include "mythcontext.h"

  • programs/mythfilldatabase/filldata.h

     
    66using namespace std;
    77
    88// Qt headers
    9 #include <qstring.h>
     9#include <QString>
    1010
    1111// libmythtv headers
    1212#include "datadirect.h"

  • programs/mythfilldatabase/channeldata.h

     
    22#define _CHANNELDATA_H_
    33
    44// Qt headers
    5 #include <qstring.h>
     5#include <QString>
    66#include <QList>
    77
    88class ChanInfo

  • programs/mythfilldatabase/icondata.h

     
    11#ifndef _ICONMAP_H_
    22#define _ICONMAP_H_
    33
    4 class QString;
    5 class QFile;
    6 
    74class IconData
    85{
    96  public:

  • programs/mythfilldatabase/xmltvparser.cpp

     
    33#include <QStringList>
    44#include <QDateTime>
    55#include <QUrl>
     6#include <Q3Url>
    67#include <QDomDocument>
    78
    8 #include <q3url.h>
    9 
    109// C++ headers
    1110#include <iostream>
    1211#include <cstdlib>

  • programs/mythfilldatabase/fillutil.h

     
    55#include <cstdio>
    66
    77// Qt headers
    8 #include <qstring.h>
     8#include <QString>
    99
    10 class QFile;
    11 
    1210bool dash_open(QFile &file, const QString &filename,
    1311               int m, FILE *handle = NULL);
    1412

  • programs/mythfilldatabase/mythfilldatabase.pro

     
    2121SOURCES += icondata.cpp xmltvparser.cpp
    2222SOURCES += fillutil.cpp
    2323SOURCES += main.cpp
     24QT +=  opengl

  • programs/mythfilldatabase/xmltvparser.h

     
    88
    99class ProgInfo;
    1010class ChanInfo;
    11 class QUrl;
    12 class QDomElement;
    1311
    1412class XMLTVParser
    1513{

  • programs/mythshutdown/mythshutdown.pro

     
    1515# Input
    1616HEADERS +=
    1717SOURCES += main.cpp
     18QT += xml network  opengl qt3support

  • bindings/python/python.pro

     
    2020QMAKE_LINK=@-echo
    2121QMAKE_EXTRA_UNIX_TARGETS += python_build
    2222INSTALLS += python_install
     23QT += xml network  sql opengl qt3support

  • bindings/perl/perl.pro

     
    2626PRE_TARGETDEPS += perl_build
    2727QMAKE_EXTRA_UNIX_TARGETS += mythperlbindings mythperbindingsbuild phony perl_clean qmake_clean perl_install
    2828
     29QT += xml network  sql opengl qt3support

  • settings.pro

     
    11CONFIG += $$CCONFIG
    22
    3 #check QT major version
    4 contains(QT_MAJOR_VERSION, 3) {
    5         error("Not building against Qt4")
    6 }
     3QT += qt3support
    74
    85# Where binaries, includes and runtime assets are installed by 'make install'
    96isEmpty( PREFIX ) {

  • filters/linearblend/linearblend.pro

     
    55
    66# Input
    77SOURCES += filter_linearblend.c
     8QT += xml network  sql opengl qt3support

  • filters/quickdnr/quickdnr.pro

     
    55
    66# Input
    77SOURCES += filter_quickdnr.c
     8QT += xml network  sql opengl qt3support

  • filters/onefield/onefield.pro

     
    44
    55# Input
    66SOURCES += filter_onefield.c
     7QT += xml network  sql opengl qt3support

  • filters/bobdeint/bobdeint.pro

     
    44
    55# Input
    66SOURCES += filter_bobdeint.c
     7QT += xml network  sql opengl qt3support

  • filters/adjust/adjust.pro

     
    55
    66# Input
    77SOURCES += filter_adjust.c
     8QT += xml network  sql opengl qt3support

  • filters/yadif/yadif.pro

     
    1111}
    1212
    1313macx:debug:DEFINES -= MMX
     14QT += xml network  sql opengl qt3support

  • filters/force/force.pro

     
    44
    55# Input
    66SOURCES += filter_force.c
     7QT += xml network  sql opengl qt3support

  • filters/crop/crop.pro

     
    55
    66# Input
    77SOURCES += filter_crop.c
     8QT += xml network  sql opengl qt3support

  • filters/kerneldeint/kerneldeint.pro

     
    1010
    1111# Input
    1212SOURCES += filter_kerneldeint.c
     13QT += xml network  sql opengl qt3support

  • filters/ivtc/ivtc.pro

     
    55
    66# Input
    77SOURCES += pullup.c filter_ivtc.c
     8QT += xml network  sql opengl qt3support

  • filters/invert/invert.pro

     
    44
    55# Input
    66SOURCES += filter_invert.c
     7QT += xml network  sql opengl qt3support

  • filters/greedyhdeint/greedyhdeint.pro

     
    77SOURCES += filter_greedyhdeint.c color.c
    88
    99macx : QMAKE_LFLAGS += -read_only_relocs warning
     10QT += xml network  sql opengl qt3support

  • filters/denoise3d/denoise3d.pro

     
    55
    66# Input
    77SOURCES += filter_denoise3d.c
     8QT += xml network  sql opengl qt3support