Ticket #2421: hidden.patch

File hidden.patch, 82.4 KB (added by Anduin Withers, 14 years ago)
  • mythplugins/mythdvd/mythdvd/main.cpp

     
    2626#include <mythtv/mythmedia.h>
    2727#include <mythtv/lcddevice.h>
    2828#include <mythtv/libmythui/myththemedmenu.h>
     29#include <mythtv/mythpluginapi.h>
    2930
    3031#include "settings.h"
    3132#include "dvdripbox.h"
     
    227228    }
    228229}
    229230
    230 extern "C" {
    231 int mythplugin_init(const char *libversion);
    232 int mythplugin_run(void);
    233 int mythplugin_config(void);
    234 }
    235 
    236231void handleDVDMedia(MythMediaDevice *)
    237232{
    238233    switch (gContext->GetNumSetting("DVDOnInsertDVD", 1))
  • mythplugins/mythdvd/mythdvd/mythdvd.pro

     
    2424macx {
    2525    QMAKE_LFLAGS += -flat_namespace -undefined suppress
    2626}
     27
     28use_hidesyms {
     29    QMAKE_CXXFLAGS += -fvisibility=hidden
     30}
  • mythplugins/mythvideo/mythvideo/main.cpp

     
    33#include <mythtv/mythcontext.h>
    44#include <mythtv/lcddevice.h>
    55#include <mythtv/libmythui/myththemedmenu.h>
     6#include <mythtv/mythpluginapi.h>
    67
    78#include "videomanager.h"
    89#include "videobrowser.h"
     
    282283    }
    283284}
    284285
    285 extern "C"
    286 {
    287     int mythplugin_init(const char *libversion);
    288     int mythplugin_run();
    289     int mythplugin_config();
    290     void mythplugin_destroy();
    291 }
    292 
    293286int mythplugin_init(const char *libversion)
    294287{
    295288    if (!gContext->TestPopupVersion("mythvideo", libversion,
  • mythplugins/mythvideo/mythvideo/mythvideo.pro

     
    3838    # need C99 flag for isnan() to work
    3939    DEFINES += _GLIBCPP_USE_C99
    4040}
     41
     42use_hidesyms {
     43    QMAKE_CXXFLAGS += -fvisibility=hidden
     44}
  • mythtv/configure

     
    7777  echo "  --disable-audio-arts     disable aRts audio support"
    7878  echo "  --disable-audio-jack     disable JACK audio support"
    7979  echo "  --enable-valgrind        disables timeouts for valgrind memory debugging"
     80  echo "  --enable-symbol-visibility  enables symbol visibility options"
    8081  # Don't print disable frontend/backend options, these
    8182  # cause breakage and people use them inappropriately. -- dtk
    8283  #echo "  --disable-frontend       disable frontend [breaks dependency checking, previews]"
     
    424425proc_opt="no"
    425426v4l="no"
    426427valgrind="no"
     428symbol_visibility="no"
    427429frontend="yes"
    428430backend="no"
    429431opengl="no"
     
    11761178  ;;
    11771179  --enable-valgrind) valgrind="yes"
    11781180  ;;
     1181  --enable-symbol-visibility) symbol_visibility="yes"
     1182  ;;
    11791183  --disable-valgrind) valgrind="no"
    11801184  ;;
    11811185  --enable-frontend) frontend="yes"
     
    22542258check_cflags -Wall
    22552259check_cflags -Wno-switch
    22562260
     2261# GCC version
     2262cat > $TMPC << EOF
     2263int main(int argc)
     2264{
     2265    int ret = 0;
     2266    if (argc == 1)
     2267    {
     2268        #if defined(__GNUC__)
     2269            ret = __GNUC__;
     2270        #endif
     2271    }
     2272    else
     2273    {
     2274        #if defined(__GNUC_MINOR__)
     2275            ret = __GNUC_MINOR__;
     2276        #endif
     2277    }
     2278
     2279    return ret;
     2280}
     2281EOF
     2282
     2283if $cc $CFLAGS $TMPC -o $TMPE ; then
     2284    $TMPE
     2285    GCC_MAJOR=$?
     2286    $TMPE "minor"
     2287    GCC_MINOR=$?
     2288fi
     2289
     2290if test x"$symbol_visibility" == x"yes"; then
     2291    if test x"$GCC_MAJOR" == x"4" ; then
     2292        check_cflags -fvisibility-inlines-hidden
     2293        ECXXFLAGS="$ECXXFLAGS -fvisibility-inlines-hidden"
     2294        CCONFIG="$CCONFIG use_hidesyms"
     2295    fi
     2296fi
     2297
    22572298# not all compilers support -Os
    22582299test "$optimize" = "small" && check_cflags -Os
    22592300
     
    34523493    echo "CONFIG_`echo $codec | tr a-z A-Z`=yes" >> $MYTH_CONFIG_MAK
    34533494done
    34543495
     3496if test x"$GCC_MAJOR" != x"" ; then
     3497  echo "GCC_MAJOR=$GCC_MAJOR" >> $MYTH_CONFIG_MAK
     3498fi
     3499
     3500if test x"$GCC_MINOR" != x"" ; then
     3501  echo "GCC_MINOR=$GCC_MINOR" >> $MYTH_CONFIG_MAK
     3502fi
     3503
    34553504diff $TMPH $MYTH_CONFIG_H >/dev/null 2>&1
    34563505if test $? -ne 0 ; then
    34573506  mv -f $TMPH $MYTH_CONFIG_H
  • mythtv/libs/libmythtv/remoteutil.h

     
    55#include <qstring.h>
    66using namespace std;
    77
     8#include "mythexp.h"
     9
    810class ProgramInfo;
    911class RemoteEncoder;
    1012
    1113/** \class FileSystemInfo
    1214 *  \brief Holds hostname, total space, and used space in kilobytes.
    1315 */
    14 class FileSystemInfo
     16class MPUBLIC FileSystemInfo
    1517{
    1618  public:
    1719    QString hostname;
     
    1921    long long usedSpaceKB;
    2022};
    2123
    22 vector<ProgramInfo *> *RemoteGetRecordedList(bool deltype);
    23 vector<FileSystemInfo> RemoteGetFreeSpace();
    24 bool RemoteGetLoad(float load[3]);
    25 bool RemoteGetUptime(time_t &uptime);
     24MPUBLIC vector<ProgramInfo *> *RemoteGetRecordedList(bool deltype);
     25MPUBLIC vector<FileSystemInfo> RemoteGetFreeSpace();
     26MPUBLIC bool RemoteGetLoad(float load[3]);
     27MPUBLIC bool RemoteGetUptime(time_t &uptime);
     28MPUBLIC
    2629bool RemoteGetMemStats(int &totalMB, int &freeMB, int &totalVM, int &freeVM);
    27 bool RemoteCheckFile(ProgramInfo *pginfo);
    28 void RemoteStopRecording(ProgramInfo *pginfo);
     30MPUBLIC bool RemoteCheckFile(ProgramInfo *pginfo);
     31MPUBLIC void RemoteStopRecording(ProgramInfo *pginfo);
     32MPUBLIC
    2933bool RemoteDeleteRecording(ProgramInfo *pginfo, bool forgetHistory,
    3034                           bool forceMetadataDelete = false);
     35MPUBLIC
    3136void RemoteGetAllScheduledRecordings(vector<ProgramInfo *> &scheduledlist);
     37MPUBLIC
    3238void RemoteGetAllExpiringRecordings(vector<ProgramInfo *> &expiringlist);
    33 int RemoteGetRecordingList(vector<ProgramInfo *> *reclist, QStringList &strList);
    34 vector<ProgramInfo *> *RemoteGetConflictList(ProgramInfo *pginfo);
    35 void RemoteSendMessage(const QString &message);
    36 RemoteEncoder *RemoteRequestRecorder(void);
    37 RemoteEncoder *RemoteRequestNextFreeRecorder(int curr);
     39MPUBLIC int RemoteGetRecordingList(vector<ProgramInfo *> *reclist,
     40                                   QStringList &strList);
     41MPUBLIC vector<ProgramInfo *> *RemoteGetConflictList(ProgramInfo *pginfo);
     42MPUBLIC void RemoteSendMessage(const QString &message);
     43MPUBLIC RemoteEncoder *RemoteRequestRecorder(void);
     44MPUBLIC RemoteEncoder *RemoteRequestNextFreeRecorder(int curr);
     45MPUBLIC
    3846RemoteEncoder *RemoteRequestFreeRecorderFromList(QStringList &qualifiedRecorders);
    39 RemoteEncoder *RemoteGetExistingRecorder(ProgramInfo *pginfo);
    40 RemoteEncoder *RemoteGetExistingRecorder(int recordernum);
    41 void RemoteGeneratePreviewPixmap(ProgramInfo *pginfo);
    42 QString RemoteGetPreviewLastModified(ProgramInfo *pginfo);
    43 void RemoteFillProginfo(ProgramInfo *pginfo, const QString &playbackhostname);
    44 int RemoteIsRecording(void);
    45 int RemoteGetRecordingMask(void);
    46 int RemoteGetFreeRecorderCount(void);
     47MPUBLIC RemoteEncoder *RemoteGetExistingRecorder(ProgramInfo *pginfo);
     48MPUBLIC RemoteEncoder *RemoteGetExistingRecorder(int recordernum);
     49MPUBLIC void RemoteGeneratePreviewPixmap(ProgramInfo *pginfo);
     50MPUBLIC QString RemoteGetPreviewLastModified(ProgramInfo *pginfo);
     51MPUBLIC void RemoteFillProginfo(ProgramInfo *pginfo,
     52                                const QString &playbackhostname);
     53MPUBLIC int RemoteIsRecording(void);
     54MPUBLIC int RemoteGetRecordingMask(void);
     55MPUBLIC int RemoteGetFreeRecorderCount(void);
    4756
    48 int RemoteCheckForRecording(ProgramInfo *pginfo);
    49 int RemoteGetRecordingStatus(ProgramInfo *pginfo, int overrecsecs,
    50                              int underrecsecs);
     57MPUBLIC int RemoteCheckForRecording(ProgramInfo *pginfo);
     58MPUBLIC int RemoteGetRecordingStatus(ProgramInfo *pginfo, int overrecsecs,
     59                                     int underrecsecs);
    5160
    5261#endif
  • mythtv/libs/libmythtv/proglist.h

     
    2525};
    2626
    2727
    28 class ProgLister : public MythDialog
     28class MPUBLIC ProgLister : public MythDialog
    2929{
    3030    Q_OBJECT
    3131
  • mythtv/libs/libmythtv/channelutil.h

     
    77#include <stdint.h>
    88#include <qstring.h>
    99
     10#include "mythexp.h"
     11
    1012class NetworkInformationTable;
    1113
    1214class DBChannel
     
    4446/** \class ChannelUtil
    4547 *  \brief Collection of helper utilities for channel DB use
    4648 */
    47 class ChannelUtil
     49class MPUBLIC ChannelUtil
    4850{
    4951  public:
    5052    // Multiplex Stuff
  • mythtv/libs/libmythtv/cardutil.h

     
    3333/** \class CardUtil
    3434 *  \brief Collection of helper utilities for capture card DB use
    3535 */
    36 class CardUtil
     36class MPUBLIC CardUtil
    3737{
    3838  public:
    3939    /// \brief all the different capture cards
  • mythtv/libs/libmythtv/livetvchain.h

     
    77#include <qmutex.h>
    88#include <qptrlist.h>
    99
     10#include "mythexp.h"
     11
    1012class ProgramInfo;
    1113class MythSocket;
    1214
    13 struct LiveTVChainEntry
     15struct MPUBLIC LiveTVChainEntry
    1416{
    1517    QString chanid;
    1618    QDateTime starttime;
     
    2224    QString inputname;
    2325};
    2426
    25 class LiveTVChain
     27class MPUBLIC LiveTVChain
    2628{
    2729  public:
    2830    LiveTVChain();
  • mythtv/libs/libmythtv/videosource.h

     
    444444    const CardInput& parent;
    445445};
    446446
    447 class CaptureCardEditor: public ListBoxSetting, public ConfigurationDialog {
     447class MPUBLIC CaptureCardEditor: public ListBoxSetting,
     448    public ConfigurationDialog {
    448449    Q_OBJECT
    449450public:
    450451    CaptureCardEditor() {
     
    465466protected:
    466467};
    467468
    468 class VideoSourceEditor: public ListBoxSetting, public ConfigurationDialog {
     469class MPUBLIC VideoSourceEditor: public ListBoxSetting,
     470    public ConfigurationDialog {
    469471    Q_OBJECT
    470472public:
    471473    VideoSourceEditor() {
     
    490492protected:
    491493};
    492494
    493 class CardInputEditor: public ListBoxSetting, public ConfigurationDialog {
     495class MPUBLIC CardInputEditor: public ListBoxSetting,
     496    public ConfigurationDialog {
    494497public:
    495498    CardInputEditor() {
    496499        setLabel(QObject::tr("Input connections"));
  • mythtv/libs/libmythtv/libmythtv.pro

     
    458458    DEFINES += USING_BACKEND
    459459}
    460460
     461use_hidesyms {
     462    QMAKE_CXXFLAGS += -fvisibility=hidden
     463}
     464
    461465# install headers required by mytharchive
    462466inc.path = $${PREFIX}/include/mythtv/libmythtv/
    463467inc.files = programinfo.h remoteutil.h recordingtypes.h
  • mythtv/libs/libmythtv/guidegrid.h

     
    2626#define MAX_DISPLAY_TIMES 30
    2727
    2828// Use this function to instantiate a guidegrid instance.
     29MPUBLIC
    2930bool RunProgramGuide(uint &startChanId, QString &startChanNum,
    3031                     bool thread = false, TV *player = NULL,
    3132                     bool allowsecondaryepg = true);
  • mythtv/libs/libmythtv/tv_play.h

     
    7171    kScheduledRecording
    7272};
    7373
    74 class TV : public QObject
     74class MPUBLIC TV : public QObject
    7575{
    7676    Q_OBJECT
    7777  public:
  • mythtv/libs/libmythtv/playgroup.h

     
    77
    88class ProgramInfo;
    99
    10 class PlayGroup: public ConfigurationWizard
     10class MPUBLIC PlayGroup: public ConfigurationWizard
    1111{
    1212 public:
    1313    PlayGroup(QString _name);
     
    2323    QString name;
    2424};
    2525
    26 class PlayGroupEditor: public ListBoxSetting, public ConfigurationDialog {
     26class MPUBLIC PlayGroupEditor: public ListBoxSetting, public ConfigurationDialog {
    2727    Q_OBJECT
    2828 public:
    2929    PlayGroupEditor(void);
  • mythtv/libs/libmythtv/dbcheck.h

     
    11#ifndef DBCHECK_H_
    22#define DBCHECK_H_
    33
     4#include "mythexp.h"
     5
    46// Call after initialing the main db connection.
    5 bool UpgradeTVDatabaseSchema(void);
     7MPUBLIC bool UpgradeTVDatabaseSchema(void);
    68
    79#endif
    810
  • mythtv/libs/libmythtv/progfind.h

     
    2525class QWidget;
    2626class TV;
    2727
    28 void RunProgramFind(bool thread = false, bool ggActive = false);
     28MPUBLIC void RunProgramFind(bool thread = false, bool ggActive = false);
    2929
    3030class ProgFinder : public MythDialog
    3131{
  • mythtv/libs/libmythtv/customedit.h

     
    1111class QLabel;
    1212class ProgramInfo;
    1313
    14 class CustomEdit : public MythDialog
     14class MPUBLIC CustomEdit : public MythDialog
    1515{
    1616    Q_OBJECT
    1717  public:
  • mythtv/libs/libmythtv/datadirect.h

     
    66#include <qxml.h>
    77#include <qmap.h>
    88
     9#include "mythexp.h"
     10
    911#include <vector>
    1012using namespace std;
    1113
     
    244246typedef vector<DataDirectLineupMap>        DDLineupChannels;
    245247typedef QMap<QString,DDLineupChannels>     DDLineupMap;   // lineupid ->
    246248
    247 class DataDirectProcessor
     249class MPUBLIC DataDirectProcessor
    248250{
    249251    friend class DDStructureParser;
    250252  public:
  • mythtv/libs/libmythtv/previouslist.h

     
    99#include "libmythtv/programinfo.h"
    1010
    1111
    12 class PreviousList : public MythDialog
     12class MPUBLIC PreviousList : public MythDialog
    1313{
    1414    Q_OBJECT
    1515
  • mythtv/libs/libmythtv/NuppelVideoRecorder.h

     
    3232#include "format.h"
    3333#include "cc608decoder.h"
    3434
     35#include "mythexp.h"
     36
    3537struct video_audio;
    3638struct VBIData;
    3739struct cc;
     
    4143class FilterManager;
    4244class FilterChain;
    4345
    44 class NuppelVideoRecorder : public RecorderBase, public CC608Reader
     46class MPUBLIC NuppelVideoRecorder : public RecorderBase, public CC608Reader
    4547{
    4648 public:
    4749    NuppelVideoRecorder(TVRec *rec, ChannelBase *channel);
  • mythtv/libs/libmythtv/profilegroup.h

     
    106106    Is_default* is_default;
    107107};
    108108
    109 class ProfileGroupEditor: public ListBoxSetting, public ConfigurationDialog {
     109class MPUBLIC ProfileGroupEditor: public ListBoxSetting,
     110    public ConfigurationDialog {
    110111    Q_OBJECT
    111112public:
    112113    ProfileGroupEditor() {};
  • mythtv/libs/libmythtv/channeleditor.h

     
    77
    88class SourceSetting;
    99class ChannelListSetting;
    10 class ChannelEditor: public VerticalConfigurationGroup,
     10class MPUBLIC ChannelEditor: public VerticalConfigurationGroup,
    1111                     public ConfigurationDialog {
    1212    Q_OBJECT
    1313public:
  • mythtv/libs/libmythtv/sourceutil.h

     
    55// Qt headers
    66#include <qstring.h>
    77
    8 class SourceUtil
     8#include "mythexp.h"
     9
     10class MPUBLIC SourceUtil
    911{
    1012  public:
    1113    static QString GetChannelSeparator(uint sourceid);
  • mythtv/libs/libmythtv/NuppelVideoPlayer.h

     
    2121#include "cc708decoder.h"
    2222#include "cc708window.h"
    2323
     24#include "mythexp.h"
     25
    2426extern "C" {
    2527#include "filter.h"
    2628}
     
    9799    kDisplayTeletextMenu        = 0x40,
    98100};
    99101
    100 class NuppelVideoPlayer : public CC608Reader, public CC708Reader
     102class MPUBLIC NuppelVideoPlayer : public CC608Reader, public CC708Reader
    101103{
    102104 public:
    103105    NuppelVideoPlayer(QString inUseID = "Unknown",
  • mythtv/libs/libmythtv/infostructs.h

     
    33
    44#include <qstring.h>
    55
     6#include "mythexp.h"
     7
    68class QPixmap;
    79
    8 class ChannelInfo
     10class MPUBLIC ChannelInfo
    911{
    1012 public:
    1113    ChannelInfo() {}
  • mythtv/libs/libmythtv/frequencytables.h

     
    2828#define VSB_16   8
    2929#endif // USING_DVB
    3030
     31#include "mythexp.h"
     32
    3133class FrequencyTable;
    3234class TransportScanItem;
    3335
     
    3941freq_table_list_t get_matching_freq_tables(
    4042    QString format, QString modulation, QString country);
    4143
    42 long long get_center_frequency(
     44MPUBLIC long long get_center_frequency(
    4345    QString format, QString modulation, QString country, int freqid);
    4446
    4547int get_closest_freqid(
  • mythtv/libs/libmythtv/recordingprofile.h

     
    4141class TranscodeLossless;
    4242class TranscodeFilters;
    4343
    44 class RecordingProfile: public ConfigurationWizard
     44class MPUBLIC RecordingProfile: public ConfigurationWizard
    4545{
    4646  Q_OBJECT
    4747  protected:
  • mythtv/libs/libmythtv/scheduledrecording.h

     
    5353class SRFindId;
    5454class SRParentId;
    5555
    56 class ScheduledRecording: public ConfigurationGroup, public ConfigurationDialog {
     56class MPUBLIC ScheduledRecording: public ConfigurationGroup,
     57    public ConfigurationDialog {
    5758    Q_OBJECT
    5859public:
    5960    ScheduledRecording();
  • mythtv/libs/libmythtv/recorderbase.h

     
    1010
    1111#include <pthread.h>
    1212
     13#include "mythexp.h"
     14
    1315class TVRec;
    1416class RingBuffer;
    1517class ProgramInfo;
     
    2729 *
    2830 *  \sa TVRec
    2931 */
    30 class RecorderBase
     32class MPUBLIC RecorderBase
    3133{
    3234  public:
    3335    RecorderBase(TVRec *rec);
  • mythtv/libs/libmythtv/mpeg/iso639.h

     
    66#include <qstring.h>
    77#include <qstringlist.h>
    88#include <vector>
     9#include "mythexp.h"
    910using namespace std;
    1011
    11 extern QMap<int, QString> _iso639_key_to_english_name;
     12extern MPUBLIC QMap<int, QString> _iso639_key_to_english_name;
    1213
    1314/** \file iso639.h
    1415 *  \brief ISO 639-1 and ISO 639-2 support functions
     
    3637QStringList iso639_get_language_list(void);
    3738vector<int> iso639_get_language_key_list(void);
    3839int         iso639_key_to_canonical_key(int iso639_2);
    39 QString     iso639_str2_to_str3(const QString &str2);
     40MPUBLIC QString     iso639_str2_to_str3(const QString &str2);
    4041
    4142static inline QString iso639_key_to_str3(int code)
    4243{
  • mythtv/libs/libmythtv/jobqueue.h

     
    9393    QString comment;
    9494} JobQueueEntry;
    9595
    96 class JobQueue : public QObject
     96class MPUBLIC JobQueue : public QObject
    9797{
    9898    Q_OBJECT
    9999  public:
  • mythtv/libs/libmythtv/remoteencoder.h

     
    55#include <qmutex.h>
    66#include <qmap.h>
    77
     8#include "mythexp.h"
     9
    810class ProgramInfo;
    911class MythSocket;
    1012
    11 class RemoteEncoder
     13class MPUBLIC RemoteEncoder
    1214{
    1315  public:
    1416    RemoteEncoder(int num, const QString &host, short port);
  • mythtv/libs/libmythtv/recordingtypes.h

     
    11#ifndef RECORDINGTYPES_H_
    22#define RECORDINGTYPES_H_
    33
     4#include "mythexp.h"
     5
    46enum RecordingType
    57{
    68    kNotRecording = 0,
     
    1618    kFindWeeklyRecord
    1719};
    1820
    19 int RecTypePriority(RecordingType rectype);
     21MPUBLIC int RecTypePriority(RecordingType rectype);
    2022
    2123enum RecordingDupInType
    2224{
  • mythtv/libs/libmythtv/fifowriter.h

     
    66#include <qmutex.h>
    77#include <qptrqueue.h>
    88
     9#include "mythexp.h"
     10
    911using namespace std;
    1012
    11 class FIFOWriter
     13class MPUBLIC FIFOWriter
    1214{
    1315  public:
    1416    FIFOWriter(int count, bool sync);
  • mythtv/libs/libmythtv/programinfo.h

     
    9393class ScheduledRecording;
    9494class QGridLayout;
    9595
    96 class ProgramInfo
     96class MPUBLIC ProgramInfo
    9797{
    9898  public:
    9999    // Constructors and bulk set methods.
     
    332332/** \class ProgramList
    333333 *  \brief QPtrList of ProgramInfo instances, with helper functions.
    334334 */
    335 class ProgramList: public QPtrList<ProgramInfo> {
     335class MPUBLIC ProgramList: public QPtrList<ProgramInfo> {
    336336 public:
    337337    ProgramList(bool autoDelete = true) {
    338338        setAutoDelete(autoDelete);
  • mythtv/libs/libmythtv/RingBuffer.h

     
    88#include <qmutex.h>
    99#include <pthread.h>
    1010#include "avcodec.h"
     11#include "mythexp.h"
    1112
    1213class RemoteFile;
    1314class RemoteEncoder;
     
    1516class DVDRingBufferPriv;
    1617class LiveTVChain;
    1718
    18 class RingBuffer
     19class MPUBLIC RingBuffer
    1920{
    2021  public:
    2122    RingBuffer(const QString &lfilename, bool write,
  • mythtv/libs/libmythtv/xbox.h

     
    44#include <qobject.h>
    55#include <qtimer.h>
    66
    7 class XBox : public QObject
     7#include "mythexp.h"
     8
     9class MPUBLIC XBox : public QObject
    810{
    911    Q_OBJECT
    1012  public:
  • mythtv/libs/libmythtv/previewgenerator.h

     
    1212
    1313class MythSocket;
    1414
    15 class PreviewGenerator : public QObject
     15class MPUBLIC PreviewGenerator : public QObject
    1616{
    1717    Q_OBJECT
    1818  public:
  • mythtv/libs/libmythtv/tv_rec.h

     
    132132};
    133133typedef MythDeque<TuningRequest> TuningQueue;
    134134
    135 class TVRec : public QObject
     135class MPUBLIC TVRec : public QObject
    136136{
    137137    friend class TuningRequest;
    138138    Q_OBJECT
  • mythtv/libs/libmyth/lirc.h

     
    88
    99#include "mythdialogs.h"
    1010
    11 class LircClient : public QObject
     11class MPUBLIC LircClient : public QObject
    1212{
    1313    Q_OBJECT
    1414  public:
  • mythtv/libs/libmyth/mythcdrom.cpp

     
    11#include "mythcdrom.h"
     2
     3#ifdef linux
     4#include "mythcdrom-linux.h"
     5#elif defined(__FreeBSD__)
     6#include "mythcdrom-freebsd.h"
     7#endif
     8
     9
    210#include <sys/stat.h>
    311
    412#include "mythconfig.h"
     
    2937MythCDROM* MythCDROM::get(QObject* par, const char* devicePath, bool SuperMount,
    3038                                 bool AllowEject) {
    3139#ifdef linux
    32     return new MythCDROMLinux(par, devicePath, SuperMount, AllowEject);
     40    return GetMythCDROMLinux(par, devicePath, SuperMount, AllowEject);
    3341#elif defined(__FreeBSD__)
    34     return new MythCDROMFreeBSD(par, devicePath, SuperMount, AllowEject);
     42    return GetMythCDROMFreeBSD(par, devicePath, SuperMount, AllowEject);
    3543#elif defined(CONFIG_DARWIN)
    3644    return new MythCDROM(par, devicePath, SuperMount, AllowEject);
    3745#else
  • mythtv/libs/libmyth/uitypes.h

     
    3434    QColor dropColor;
    3535};
    3636
    37 class LayerSet
     37class MPUBLIC LayerSet
    3838{
    3939  public:
    4040    LayerSet(const QString &name);
     
    8282    vector<UIType *> *allTypes;
    8383};
    8484
    85 class UIType : public QObject
     85class MPUBLIC UIType : public QObject
    8686{
    8787  Q_OBJECT
    8888
     
    154154    bool     hidden;        // Is this "widget" seen or hidden ?
    155155};
    156156
    157 class UIBarType : public UIType
     157class MPUBLIC UIBarType : public UIType
    158158{
    159159  public:
    160160    UIBarType(const QString &name, QString, int, QRect);
     
    222222    int alpha;
    223223};
    224224
    225 class UIGuideType : public UIType
     225class MPUBLIC UIGuideType : public UIType
    226226{
    227227  public:
    228228    UIGuideType(const QString &name, int order);
     
    339339    int prog_past_col;
    340340};
    341341
    342 class UIListType : public UIType
     342class MPUBLIC UIListType : public UIType
    343343{
    344344    Q_OBJECT
    345345
     
    439439    QMap<int, int> columnContext;
    440440};
    441441
    442 class UIImageType : public UIType
     442class MPUBLIC UIImageType : public UIType
    443443{
    444444    Q_OBJECT
    445445
     
    499499
    500500};
    501501
    502 class UIAnimatedImageType : public UIType
     502class MPUBLIC UIAnimatedImageType : public UIType
    503503{
    504504    Q_OBJECT
    505505
     
    559559    MythDialog* m_window;
    560560};
    561561
    562 class UIRepeatedImageType : public UIImageType
     562class MPUBLIC UIRepeatedImageType : public UIImageType
    563563{
    564564    Q_OBJECT
    565565
     
    591591};
    592592
    593593
    594 class UITextType : public UIType
     594class MPUBLIC UITextType : public UIType
    595595{
    596596  public:
    597597    UITextType(const QString &, fontProp *, const QString &, int,
     
    632632
    633633};
    634634
    635 class UIRichTextType : public UIType
     635class MPUBLIC UIRichTextType : public UIType
    636636{
    637637    Q_OBJECT
    638638
     
    718718        QPixmap  m_dnArrowSel;
    719719};
    720720
    721 class UIMultiTextType : public UITextType
     721class MPUBLIC UIMultiTextType : public UITextType
    722722{
    723723
    724724  Q_OBJECT
     
    775775
    776776};
    777777
    778 class UIRemoteEditType : public UIType
     778class MPUBLIC UIRemoteEditType : public UIType
    779779{
    780780    Q_OBJECT
    781781
     
    818818    MythThemedDialog* m_parentDialog;
    819819};
    820820
    821 class UIStatusBarType : public UIType
     821class MPUBLIC UIStatusBarType : public UIType
    822822{
    823823  public:
    824824    UIStatusBarType(QString &, QPoint, int);
     
    855855
    856856};
    857857
    858 class UIManagedTreeListType : public UIType
     858class MPUBLIC UIManagedTreeListType : public UIType
    859859{
    860860    Q_OBJECT
    861861
     
    984984    bool                    bIncSearchContains;
    985985};
    986986
    987 class UIPushButtonType : public UIType
     987class MPUBLIC UIPushButtonType : public UIType
    988988{
    989989    Q_OBJECT
    990990
     
    10171017
    10181018};
    10191019
    1020 class UITextButtonType : public UIType
     1020class MPUBLIC UITextButtonType : public UIType
    10211021{
    10221022    Q_OBJECT
    10231023
     
    10561056
    10571057
    10581058
    1059 class UICheckBoxType : public UIType
     1059class MPUBLIC UICheckBoxType : public UIType
    10601060{
    10611061    Q_OBJECT
    10621062
     
    11221122};
    11231123
    11241124
    1125 class UISelectorType : public UIPushButtonType
     1125class MPUBLIC UISelectorType : public UIPushButtonType
    11261126{
    11271127    Q_OBJECT
    11281128
     
    11711171
    11721172
    11731173
    1174 class UIBlackHoleType : public UIType
     1174class MPUBLIC UIBlackHoleType : public UIType
    11751175{
    11761176    Q_OBJECT
    11771177
     
    11931193    QRect area;
    11941194};
    11951195
    1196 class UIKeyType : public UIType
     1196class MPUBLIC UIKeyType : public UIType
    11971197{
    11981198    Q_OBJECT
    11991199
     
    12801280    QTimer  m_pushTimer;
    12811281};
    12821282
    1283 class UIKeyboardType : public UIType
     1283class MPUBLIC UIKeyboardType : public UIType
    12841284{
    12851285    Q_OBJECT
    12861286
  • mythtv/libs/libmyth/util.h

     
    77
    88#include <time.h>
    99
     10#include "mythexp.h"
     11
    1012#define MYTH_SYSTEM_DONT_BLOCK_LIRC          0x1 //< myth_system() flag to avoid blocking
    1113#define MYTH_SYSTEM_DONT_BLOCK_JOYSTICK_MENU 0x2 //< myth_system() flag to avoid blocking
    1214
     
    1517class QPainter;
    1618class QFont;
    1719
    18 class MythTimer
     20class MPUBLIC MythTimer
    1921{
    2022  public:
    2123    MythTimer() {}
     
    3638    QTime m_timer;
    3739};
    3840
    39 QDateTime mythCurrentDateTime();
     41MPUBLIC QDateTime mythCurrentDateTime();
    4042
    4143// This is necessary for GCC 3.3, which has llabs(long long)
    4244// but not abs(long long) or std::llabs(long long)
    43 inline  long long  absLongLong(long long  n)  { return n >= 0 ? n : -n; }
     45MPUBLIC inline long long absLongLong(long long  n) { return n >= 0 ? n : -n; }
    4446
    45 void encodeLongLong(QStringList &list, long long num);
    46 long long decodeLongLong(QStringList &list, uint offset);
    47 long long decodeLongLong(QStringList &list, QStringList::iterator &it);
     47MPUBLIC void encodeLongLong(QStringList &list, long long num);
     48MPUBLIC long long decodeLongLong(QStringList &list, uint offset);
     49MPUBLIC long long decodeLongLong(QStringList &list, QStringList::iterator &it);
    4850
    49 QRgb blendColors(QRgb source, QRgb add, int alpha);
     51MPUBLIC QRgb blendColors(QRgb source, QRgb add, int alpha);
    5052
    51 uint myth_system(const QString &command, int flags = 0);
     53MPUBLIC uint myth_system(const QString &command, int flags = 0);
    5254
    53 QString cutDownString(const QString &text, QFont *testFont, uint maxwidth);
     55MPUBLIC QString cutDownString(const QString &text, QFont *testFont, uint maxwidth);
    5456
    55 QDateTime MythUTCToLocal(const QDateTime &utc);
    56 int MythSecsTo(const QDateTime &from, const QDateTime &to);
     57MPUBLIC QDateTime MythUTCToLocal(const QDateTime &utc);
     58MPUBLIC int MythSecsTo(const QDateTime &from, const QDateTime &to);
    5759
    58 long long stringToLongLong(const QString &str);
    59 QString longLongToString(long long ll);
     60MPUBLIC long long stringToLongLong(const QString &str);
     61MPUBLIC QString longLongToString(long long ll);
    6062
    61 long long getDiskSpace(const QString&,long long&,long long&);
    62 bool getUptime(time_t &uptime);
    63 bool getMemStats(int &totalMB, int &freeMB, int &totalVM, int &freeVM);
     63MPUBLIC long long getDiskSpace(const QString&,long long&,long long&);
     64MPUBLIC bool getUptime(time_t &uptime);
     65MPUBLIC bool getMemStats(int &totalMB, int &freeMB, int &totalVM, int &freeVM);
    6466
    6567#endif // UTIL_H_
  • mythtv/libs/libmyth/mythcdrom-freebsd.h

     
     1#ifndef MYTHCDROM-FREEBSD_H_
     2#define MYTHCDROM-FREEBSD_H_
     3
     4class MythCDROM *GetMythCDROMFreeBSD(class QObject* par, const char* devicePath,
     5                                     bool SuperMount, bool AllowEject);
     6
     7#endif // MYTHCDROM-FREEBSD_H_
  • mythtv/libs/libmyth/mythcontext.h

     
    2020
    2121#include "mythobservable.h"
    2222#include "mythsocket.h"
     23#include "mythexp.h"
    2324
    2425using namespace std;
    2526
     
    9091
    9192/// This global variable is set at startup with the flags
    9293/// of the verbose messages we want to see.
    93 extern unsigned int print_verbose_messages;
    94 extern QString verboseString;
     94extern MPUBLIC unsigned int print_verbose_messages;
     95extern MPUBLIC QString verboseString;
    9596
    96 int parse_verbose_arg(QString arg);
     97MPUBLIC int parse_verbose_arg(QString arg);
    9798
    9899
    99100/// These are the database logging priorities used for filterig the logs.
     
    110111};
    111112
    112113/// Structure containing the basic Database parameters
    113 struct DatabaseParams
     114struct MPUBLIC DatabaseParams
    114115{
    115116    QString dbHostName;         ///< database server
    116117    QString dbUserName;         ///< DB user name
     
    173174#define ENO QString("\n\t\t\teno: ") + safe_eno_to_string(errno)
    174175
    175176/// Verbose helper function for ENO macro
    176 QString safe_eno_to_string(int errnum);
     177MPUBLIC QString safe_eno_to_string(int errnum);
    177178
    178179/** \class MythPrivRequest
    179180 *  \brief Container for requests that require privledge escalation.
     
    185186 *  \sa NuppelVideoPlayer::StartPlaying(void)
    186187 *  \sa MythContext:addPrivRequest(MythPrivRequest::Type, void*)
    187188 */
    188 class MythPrivRequest
     189class MPUBLIC MythPrivRequest
    189190{
    190191  public:
    191192    typedef enum { MythRealtime, MythExit, PrivEnd } Type;
     
    218219 *   It also contains support for database error printing, and
    219220 *   database message logging.
    220221 */
    221 class MythContext : public QObject, public MythObservable, public MythSocketCBs
     222class MPUBLIC MythContext : public QObject, public MythObservable,
     223    public MythSocketCBs
    222224{
    223225    Q_OBJECT
    224226  public:
     
    420422};
    421423
    422424/// This global variable contains the MythContext instance for the application
    423 extern MythContext *gContext;
     425extern MPUBLIC MythContext *gContext;
    424426
    425427/// This global variable is used to makes certain calls to avlib threadsafe.
    426 extern QMutex avcodeclock;
     428extern MPUBLIC QMutex avcodeclock;
    427429
    428430#endif
    429431
  • mythtv/libs/libmyth/mythmediamonitor.h

     
    1414
    1515class MediaMonitor;
    1616
    17 class MediaEvent : public QCustomEvent
     17class MPUBLIC MediaEvent : public QCustomEvent
    1818{
    1919  public:
    2020    MediaEvent(MediaStatus oldStatus, MythMediaDevice* pDevice)
     
    4343    unsigned long m_Interval;
    4444};
    4545
    46 class MediaMonitor : public QObject
     46class MPUBLIC MediaMonitor : public QObject
    4747{
    4848    Q_OBJECT
    4949    friend class MonitorThread;
  • mythtv/libs/libmyth/mythpluginapi.h

     
     1#ifndef MYTHPLUGINAPI_H_
     2#define MYTHPLUGINAPI_H_
     3
     4#include "mythexp.h"
     5#include "mythplugin.h" // for MythPluginType
     6
     7extern "C" {
     8    MPUBLIC int mythplugin_init(const char *);
     9    MPUBLIC int mythplugin_run();
     10    MPUBLIC int mythplugin_config();
     11    MPUBLIC MythPluginType mythplugin_type();
     12    MPUBLIC void mythplugin_destroy();
     13    MPUBLIC int mythplugin_setupMenu();
     14    MPUBLIC void mythplugin_drawMenu(QPainter *painter, int x, int y,
     15                                     int w, int h);
     16}
     17
     18#endif // MYTHPLUGINAPI_H_
  • mythtv/libs/libmyth/generictree.h

     
    66#include <qvaluelist.h>
    77#include <qptrlist.h>
    88
     9#include "mythexp.h"
     10
    911using namespace std;
    1012
    1113class SortableGenericTreeList;
    1214
    13 class GenericTree
     15class MPUBLIC GenericTree
    1416{
    1517    typedef QValueVector<int> IntVector;
    1618
  • mythtv/libs/libmyth/settings.h

     
    77#include <vector>
    88#include <map>
    99
     10#include "mythexp.h"
    1011#include "mythwidgets.h"
    1112#include "mythdialogs.h"
    1213#include "mythdbcon.h"
     
    1819class ConfigurationGroup;
    1920class QDir;
    2021
    21 class Configurable: virtual public QObject {
     22class MPUBLIC Configurable: virtual public QObject {
    2223    Q_OBJECT
    2324public:
    2425    Configurable():
     
    7172    bool visible;
    7273};
    7374
    74 class Setting: virtual public Configurable {
     75class MPUBLIC Setting: virtual public Configurable {
    7576    Q_OBJECT
    7677public:
    7778    Setting(): changed(false) {};
     
    105106    bool changed;
    106107};
    107108
    108 class ConfigurationGroup: virtual public Configurable
     109class MPUBLIC ConfigurationGroup: virtual public Configurable
    109110{
    110111    Q_OBJECT
    111112  public:
     
    151152    bool zeroSpace;
    152153};
    153154
    154 class VerticalConfigurationGroup : virtual public ConfigurationGroup
     155class MPUBLIC VerticalConfigurationGroup : virtual public ConfigurationGroup
    155156{
    156157  public:
    157158    VerticalConfigurationGroup(
     
    165166                                  const char* widgetName = NULL);
    166167};
    167168
    168 class HorizontalConfigurationGroup : virtual public ConfigurationGroup
     169class MPUBLIC HorizontalConfigurationGroup :
     170    virtual public ConfigurationGroup
    169171{
    170172  public:
    171173    HorizontalConfigurationGroup(
     
    179181                                  const char* widgetName = NULL);
    180182};
    181183
    182 class GridConfigurationGroup: virtual public ConfigurationGroup {
     184class MPUBLIC GridConfigurationGroup: virtual public ConfigurationGroup {
    183185 public:
    184186    GridConfigurationGroup(uint col,
    185187                           bool uselabel   = true,  bool useframe  = true,
     
    195197    uint columns;
    196198};
    197199
    198 class StackedConfigurationGroup: virtual public ConfigurationGroup {
     200class MPUBLIC StackedConfigurationGroup: virtual public ConfigurationGroup {
    199201    Q_OBJECT
    200202public:
    201203    StackedConfigurationGroup(bool uselabel = true) :
     
    222224    bool saveAll;
    223225};
    224226
    225 class ConfigurationDialogWidget: public MythDialog {
     227class MPUBLIC ConfigurationDialogWidget: public MythDialog {
    226228    Q_OBJECT
    227229public:
    228230    ConfigurationDialogWidget(MythMainWindow *parent,
     
    236238    void deleteButtonPressed();
    237239};
    238240
    239 class ConfigurationDialog: virtual public Configurable {
     241class MPUBLIC ConfigurationDialog: virtual public Configurable {
    240242public:
    241243    ConfigurationDialog() :
    242244        Configurable(), dialog(NULL) {};
     
    255257/** \class ConfigurationWizard
    256258 *  \brief A wizard is a group with one child per page.
    257259 */
    258 class ConfigurationWizard: public ConfigurationDialog,
     260class MPUBLIC ConfigurationWizard: public ConfigurationDialog,
    259261                           public ConfigurationGroup
    260262{
    261263  public:
     
    266268};
    267269
    268270// Read-only display of a setting
    269 class LabelSetting: virtual public Setting {
     271class MPUBLIC LabelSetting: virtual public Setting {
    270272protected:
    271273    LabelSetting() {};
    272274public:
     
    274276                                  const char* widgetName = 0);
    275277};
    276278
    277 class LineEditSetting: virtual public Setting {
     279class MPUBLIC LineEditSetting: virtual public Setting {
    278280protected:
    279281    LineEditSetting(bool readwrite = true) : edit(NULL) { rw = readwrite; };
    280282public:
     
    300302
    301303// TODO: set things up so that setting the value as a string emits
    302304// the int signal also
    303 class IntegerSetting: virtual public Setting {
     305class MPUBLIC IntegerSetting: virtual public Setting {
    304306    Q_OBJECT
    305307protected:
    306308    IntegerSetting() {};
     
    317319    void valueChanged(int newValue);
    318320};
    319321
    320 class BoundedIntegerSetting: public IntegerSetting {
     322class MPUBLIC BoundedIntegerSetting: public IntegerSetting {
    321323protected:
    322324    BoundedIntegerSetting(int _min, int _max, int _step) {
    323325        min=_min, max=_max, step=_step;
     
    328330    int step;
    329331};
    330332
    331 class SliderSetting: public BoundedIntegerSetting {
     333class MPUBLIC SliderSetting: public BoundedIntegerSetting {
    332334protected:
    333335    SliderSetting(int min, int max, int step):
    334336        BoundedIntegerSetting(min, max, step) {};
     
    337339                                  const char* widgetName = 0);
    338340};
    339341
    340 class SpinBoxSetting: public BoundedIntegerSetting {
     342class MPUBLIC SpinBoxSetting: public BoundedIntegerSetting {
    341343protected:
    342344    SpinBoxSetting(int min, int max, int step,
    343345                   bool allow_single_step = false,
     
    354356                                  const char* widgetName = 0);
    355357};
    356358
    357 class SelectSetting: virtual public Setting {
     359class MPUBLIC SelectSetting: virtual public Setting {
    358360    Q_OBJECT
    359361protected:
    360362    SelectSetting() { isSet = false; };
     
    404406    bool isSet;
    405407};
    406408
    407 class SelectLabelSetting: public LabelSetting, public SelectSetting {
     409class MPUBLIC SelectLabelSetting: public LabelSetting, public SelectSetting {
    408410protected:
    409411    SelectLabelSetting() {};
    410412
     
    413415                                  const char* widgetName = 0);
    414416};
    415417
    416 class ComboBoxSetting: public SelectSetting {
    417     Q_OBJECT;
     418class MPUBLIC ComboBoxSetting: public SelectSetting {
     419    Q_OBJECT
    418420
    419421protected:
    420422    ComboBoxSetting(bool _rw = false, int _step = 1) {
    421423        rw = _rw;
    422424        step = _step;
    423425        widget = NULL;
    424     };
     426    }
    425427
    426428public:
    427429    virtual void setValue(QString newValue);
     
    454456    int step;
    455457};
    456458
    457 class ListBoxSetting: public SelectSetting {
     459class MPUBLIC ListBoxSetting: public SelectSetting {
    458460    Q_OBJECT
    459461public:
    460462    ListBoxSetting(): widget(NULL), selectionMode(MythListBox::Single) { }
     
    489491    MythListBox::SelectionMode selectionMode;
    490492};
    491493
    492 class RadioSetting: public SelectSetting {
     494class MPUBLIC RadioSetting: public SelectSetting {
    493495public:
    494496    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    495497                                  const char* widgetName = 0);
    496498};
    497499
    498 class ImageSelectSetting: public SelectSetting {
     500class MPUBLIC ImageSelectSetting: public SelectSetting {
    499501    Q_OBJECT
    500502public:
    501503    virtual ~ImageSelectSetting();
     
    515517    float m_hmult, m_wmult;
    516518};
    517519
    518 class BooleanSetting: virtual public Setting {
     520class MPUBLIC BooleanSetting: virtual public Setting {
    519521    Q_OBJECT
    520522public:
    521523    bool boolValue(void) const {
     
    533535    void valueChanged(bool);
    534536};
    535537
    536 class CheckBoxSetting: public BooleanSetting {
     538class MPUBLIC CheckBoxSetting: public BooleanSetting {
    537539public:
    538540    CheckBoxSetting() : widget(NULL) {}
    539541    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
     
    544546};
    545547
    546548
    547 class TriggeredConfigurationGroup: virtual public ConfigurationGroup {
     549class MPUBLIC TriggeredConfigurationGroup :
     550    virtual public ConfigurationGroup
     551{
    548552    Q_OBJECT
    549553public:
    550554    TriggeredConfigurationGroup(bool uselabel = true) :
     
    569573    map<QString,Configurable*> triggerMap;
    570574};
    571575   
    572 class TabbedConfigurationGroup: virtual public ConfigurationGroup
     576class MPUBLIC TabbedConfigurationGroup: virtual public ConfigurationGroup
    573577{
    574578    Q_OBJECT
    575579
     
    583587                                  const char* widgetName = 0);
    584588};
    585589
    586 class PathSetting: public ComboBoxSetting {
     590class MPUBLIC PathSetting : public ComboBoxSetting
     591{
    587592public:
    588593    PathSetting(bool _mustexist):
    589594        ComboBoxSetting(true), mustexist(_mustexist) {
     
    601606    bool mustexist;
    602607};
    603608
    604 class HostnameSetting: virtual public Setting {
     609class MPUBLIC HostnameSetting: virtual public Setting {
    605610public:
    606611    HostnameSetting();
    607612};
    608613
    609 class ChannelSetting: virtual public SelectSetting {
     614class MPUBLIC ChannelSetting: virtual public SelectSetting {
    610615public:
    611616    ChannelSetting() {
    612617        setLabel("Channel");
     
    619624};
    620625
    621626class QDate;
    622 class DateSetting: virtual public Setting {
     627class MPUBLIC DateSetting: virtual public Setting {
    623628    Q_OBJECT
    624629public:
    625630    QDate dateValue(void) const;
     
    632637};
    633638
    634639class QTime;
    635 class TimeSetting: virtual public Setting {
     640class MPUBLIC TimeSetting: virtual public Setting {
    636641    Q_OBJECT
    637642public:
    638643    QTime timeValue(void) const;
     
    644649    void setValue(const QTime& newValue);
    645650};
    646651
    647 class DBStorage: virtual public Setting {
     652class MPUBLIC DBStorage: virtual public Setting {
    648653public:
    649654    DBStorage(QString _table, QString _column):
    650655        table(_table), column(_column) {};
     
    661666    QString column;
    662667};
    663668
    664 class SimpleDBStorage: public DBStorage {
     669class MPUBLIC SimpleDBStorage: public DBStorage {
    665670public:
    666671    SimpleDBStorage(QString table, QString column):
    667672        DBStorage(table, column) {};
     
    678683    virtual QString setClause(MSqlBindings& bindings);
    679684};
    680685
    681 class TransientStorage: virtual public Setting {
     686class MPUBLIC TransientStorage: virtual public Setting {
    682687public:
    683688    virtual void load() {  }
    684689    virtual void save() {  }
    685690    virtual void save(QString) {  }
    686691};
    687692
    688 class AutoIncrementStorage: virtual public IntegerSetting, public DBStorage {
     693class MPUBLIC AutoIncrementStorage: virtual public IntegerSetting,
     694    public DBStorage {
    689695public:
    690696    AutoIncrementStorage(QString table, QString column):
    691697        DBStorage(table, column) {
     
    697703    virtual void save(QString destination);
    698704};
    699705
    700 class ButtonSetting: virtual public Setting {
     706class MPUBLIC ButtonSetting: virtual public Setting {
    701707    Q_OBJECT
    702708public:
    703709    ButtonSetting(QString _name = "button") :
     
    719725    MythPushButton *button;
    720726};
    721727
    722 class TransButtonSetting: public ButtonSetting, public TransientStorage {
     728class MPUBLIC TransButtonSetting: public ButtonSetting, public TransientStorage
     729{
    723730public:
    724731    TransButtonSetting(QString name = "button") : ButtonSetting(name) {}
    725732};
    726733
    727 class ConfigPopupDialogWidget: public MythPopupBox {
     734class MPUBLIC ConfigPopupDialogWidget: public MythPopupBox {
    728735    Q_OBJECT
    729736public:
    730737    ConfigPopupDialogWidget(MythMainWindow* parent, const char* widgetName=0):
     
    735742    void reject() { MythPopupBox::reject(); };
    736743};
    737744
    738 class ConfigurationPopupDialog: virtual public Configurable {
     745class MPUBLIC ConfigurationPopupDialog: virtual public Configurable {
    739746    Q_OBJECT
    740747public:
    741748    ConfigurationPopupDialog() { dialog=NULL; };
     
    756763    ConfigPopupDialogWidget* dialog;
    757764};
    758765
    759 class ProgressSetting: virtual public IntegerSetting {
     766class MPUBLIC ProgressSetting: virtual public IntegerSetting {
    760767public:
    761768    ProgressSetting(int _totalSteps): totalSteps(_totalSteps) {};
    762769
     
    767774    int totalSteps;
    768775};
    769776
    770 class TransLabelSetting: public LabelSetting, public TransientStorage {
     777class MPUBLIC TransLabelSetting: public LabelSetting, public TransientStorage {
    771778public:
    772779    TransLabelSetting() {};
    773780};
    774781
    775 class TransCheckBoxSetting: public CheckBoxSetting, public TransientStorage {
     782class MPUBLIC TransCheckBoxSetting: public CheckBoxSetting,
     783    public TransientStorage
     784{
    776785public:
    777786    TransCheckBoxSetting() {};
    778787};
    779788
    780 class HostSetting: public SimpleDBStorage, virtual public Configurable {
     789class MPUBLIC HostSetting: public SimpleDBStorage,
     790    virtual public Configurable {
    781791public:
    782792    HostSetting(QString name):
    783793        SimpleDBStorage("settings", "data") {
     
    790800    virtual QString setClause(MSqlBindings& bindings);
    791801};
    792802
    793 class GlobalSetting: public SimpleDBStorage, virtual public Configurable {
     803class MPUBLIC GlobalSetting: public SimpleDBStorage,
     804    virtual public Configurable {
    794805public:
    795806    GlobalSetting(QString name):
    796807        SimpleDBStorage("settings", "data") {
     
    802813    virtual QString setClause(MSqlBindings& bindings);
    803814};
    804815
    805 class HostSlider: public SliderSetting, public HostSetting {
     816class MPUBLIC HostSlider: public SliderSetting, public HostSetting {
    806817  public:
    807818    HostSlider(const QString &name, int min, int max, int step) :
    808819        SliderSetting(min, max, step),
    809820        HostSetting(name) { }
    810821};
    811822
    812 class HostSpinBox: public SpinBoxSetting, public HostSetting {
     823class MPUBLIC HostSpinBox: public SpinBoxSetting, public HostSetting {
    813824  public:
    814825    HostSpinBox(const QString &name, int min, int max, int step,
    815826                  bool allow_single_step = false) :
     
    817828        HostSetting(name) { }
    818829};
    819830
    820 class HostCheckBox: public CheckBoxSetting, public HostSetting {
     831class MPUBLIC HostCheckBox: public CheckBoxSetting, public HostSetting {
    821832  public:
    822833    HostCheckBox(const QString &name) :
    823834        HostSetting(name) { }
    824835    virtual ~HostCheckBox() { ; }
    825836};
    826837
    827 class HostComboBox: public ComboBoxSetting, public HostSetting {
     838class MPUBLIC HostComboBox: public ComboBoxSetting, public HostSetting {
    828839  public:
    829840    HostComboBox(const QString &name, bool rw = false) :
    830841        ComboBoxSetting(rw),
     
    832843    virtual ~HostComboBox() { ; }
    833844};
    834845
    835 class HostRefreshRateComboBox: virtual public HostComboBox
     846class MPUBLIC HostRefreshRateComboBox: virtual public HostComboBox
    836847{
    837848    Q_OBJECT
    838849  public:
     
    845856    static const vector<short> GetRefreshRates(const QString &resolution);
    846857};
    847858
    848 class HostTimeBox: public ComboBoxSetting, public HostSetting {
     859class MPUBLIC HostTimeBox: public ComboBoxSetting, public HostSetting {
    849860  public:
    850861    HostTimeBox(const QString &name, const QString &defaultTime = "00:00",
    851862                const int interval = 1) :
     
    867878    }
    868879};
    869880
    870 class HostLineEdit: public LineEditSetting, public HostSetting {
     881class MPUBLIC HostLineEdit: public LineEditSetting, public HostSetting {
    871882  public:
    872883    HostLineEdit(const QString &name, bool rw = true) :
    873884        LineEditSetting(rw),
    874885        HostSetting(name) { }
    875886};
    876887
    877 class HostImageSelect: public ImageSelectSetting, public HostSetting {
     888class MPUBLIC HostImageSelect: public ImageSelectSetting, public HostSetting {
    878889  public:
    879890    HostImageSelect(const QString &name) :
    880891        HostSetting(name) { }
    881892};
    882893
    883 class GlobalSlider: public SliderSetting, public GlobalSetting {
     894class MPUBLIC GlobalSlider: public SliderSetting, public GlobalSetting {
    884895  public:
    885896    GlobalSlider(const QString &name, int min, int max, int step) :
    886897        SliderSetting(min, max, step),
    887898        GlobalSetting(name) { }
    888899};
    889900
    890 class GlobalSpinBox: public SpinBoxSetting, public GlobalSetting {
     901class MPUBLIC GlobalSpinBox: public SpinBoxSetting, public GlobalSetting {
    891902  public:
    892903    GlobalSpinBox(const QString &name, int min, int max, int step,
    893904                   bool allow_single_step = false) :
     
    895906        GlobalSetting(name) { }
    896907};
    897908
    898 class GlobalCheckBox: public CheckBoxSetting, public GlobalSetting {
     909class MPUBLIC GlobalCheckBox: public CheckBoxSetting, public GlobalSetting {
    899910  public:
    900911    GlobalCheckBox(const QString &name) :
    901912        GlobalSetting(name) { }
    902913};
    903914
    904 class GlobalComboBox: public ComboBoxSetting, public GlobalSetting {
     915class MPUBLIC GlobalComboBox: public ComboBoxSetting, public GlobalSetting {
    905916  public:
    906917    GlobalComboBox(const QString &name, bool rw = false) :
    907918        ComboBoxSetting(rw),
    908919        GlobalSetting(name) { }
    909920};
    910921
    911 class GlobalLineEdit: public LineEditSetting, public GlobalSetting {
     922class MPUBLIC GlobalLineEdit: public LineEditSetting, public GlobalSetting {
    912923  public:
    913924    GlobalLineEdit(const QString &name, bool rw = true) :
    914925        LineEditSetting(rw),
    915926        GlobalSetting(name) { }
    916927};
    917928
    918 class GlobalImageSelect: public ImageSelectSetting, public GlobalSetting {
     929class MPUBLIC GlobalImageSelect: public ImageSelectSetting, public GlobalSetting
     930{
    919931  public:
    920932    GlobalImageSelect(const QString &name) :
    921933        GlobalSetting(name) { }
    922934};
    923935
    924 class GlobalTimeBox: public ComboBoxSetting, public GlobalSetting {
     936class MPUBLIC GlobalTimeBox: public ComboBoxSetting, public GlobalSetting {
    925937  public:
    926938    GlobalTimeBox(const QString &name, const QString &defaultTime = "00:00",
    927939                  const int interval = 1) :
     
    946958/** \class JumpConfigurationWizard
    947959 *  \brief A jump wizard is a group with one child per page, and jump buttons
    948960 */
    949 class JumpConfigurationWizard : public ConfigurationWizard
     961class MPUBLIC JumpConfigurationWizard : public ConfigurationWizard
    950962{
    951963    Q_OBJECT
    952964
     
    960972    vector<QWidget*> childWidgets;
    961973};
    962974
    963 class JumpPane : public VerticalConfigurationGroup
     975class MPUBLIC JumpPane : public VerticalConfigurationGroup
    964976{
    965977    Q_OBJECT
    966978
  • mythtv/libs/libmyth/mythhdd.h

     
    33
    44#include "mythmedia.h"
    55
    6 class MythHDD : public MythMediaDevice
     6class MPUBLIC MythHDD : public MythMediaDevice
    77{
    88  public:
    99    MythHDD(QObject* par, const char* DevicePath,
  • mythtv/libs/libmyth/mythwizard.h

     
    4444class QHBoxLayout;
    4545class MythWizardPrivate;
    4646
    47 class Q_EXPORT MythWizard : public MythDialog
     47class MPUBLIC MythWizard : public MythDialog
    4848{
    4949    Q_OBJECT
    5050    Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
     
    116116    MythWizardPrivate *d;
    117117};
    118118
    119 class Q_EXPORT MythJumpWizard : public MythWizard
     119class MPUBLIC MythJumpWizard : public MythWizard
    120120{
    121121    Q_OBJECT
    122122
  • mythtv/libs/libmyth/mythcdrom-linux.h

     
     1#ifndef MYTHCDROM-LINUX_H_
     2#define MYTHCDROM-LINUX_H_
     3
     4class MythCDROM *GetMythCDROMLinux(class QObject* par, const char* devicePath,
     5                                   bool SuperMount, bool AllowEject);
     6
     7#endif // MYTHCDROM-LINUX_H_
  • mythtv/libs/libmyth/mythcdrom.h

     
    33
    44#include "mythmedia.h"
    55
    6 class MythCDROM : public MythMediaDevice
     6class MPUBLIC MythCDROM : public MythMediaDevice
    77{
    88    Q_OBJECT
    9   public:
    10     MythCDROM(QObject* par, const char* DevicePath, bool SuperMount, 
     9  protected:
     10    MythCDROM(QObject* par, const char* DevicePath, bool SuperMount,
    1111              bool AllowEject);
     12  public:
    1213    virtual ~MythCDROM() {};
    1314
    1415    virtual bool mediaChanged(void) { return false; }
     
    1920        return setStatus(MEDIASTAT_UNKNOWN, false);
    2021    }
    2122
    22     static MythCDROM* get(QObject* par, const char* devicePath, bool SuperMount,
    23                           bool AllowEject);
     23    static MythCDROM* get(QObject* par, const char* devicePath,
     24                                  bool SuperMount, bool AllowEject);
    2425
    2526  protected:
    2627    virtual void onDeviceMounted();
    2728};
    2829
    29 class MythCDROMLinux: public MythCDROM
    30 {
    31 public:
    32     MythCDROMLinux(QObject* par, const char* DevicePath, bool SuperMount,
    33                    bool AllowEject):
    34         MythCDROM(par, DevicePath, SuperMount, AllowEject) {
    35     }
    36 
    37     virtual MediaError testMedia(void);
    38     virtual bool mediaChanged(void);
    39     virtual bool checkOK(void);
    40     virtual MediaStatus checkMedia(void);
    41     virtual MediaError eject(bool open_close = true);
    42     virtual MediaError lock(void);
    43     virtual MediaError unlock(void);
    44 };
    45 
    46 
    47 class MythCDROMFreeBSD: public MythCDROM
    48 {
    49 public:
    50     MythCDROMFreeBSD(QObject* par, const char* DevicePath, bool SuperMount,
    51                      bool AllowEject):
    52         MythCDROM(par, DevicePath, SuperMount, AllowEject) {
    53     }
    54 
    55     virtual MediaError testMedia(void);
    56     virtual MediaError eject(bool open_close = true);
    57     virtual MediaError lock(void);
    58     virtual MediaError unlock(void);
    59 };
    60 
    6130#endif
  • mythtv/libs/libmyth/uilistbtntype.h

     
    2727class UIListBtnType;
    2828class UIListBtnTypeItem;
    2929
    30 class UIListGenericTree : public GenericTree
     30class MPUBLIC UIListGenericTree : public GenericTree
    3131{
    3232  public:
    3333    // will _not_ delete the image it's given, if any.
     
    6666    bool m_active;
    6767};
    6868
    69 class UIListTreeType : public UIType
     69class MPUBLIC UIListTreeType : public UIType
    7070{
    7171    Q_OBJECT
    7272  public:
     
    161161    bool    list_tree_active;
    162162};
    163163
    164 class UIListBtnType : public UIType
     164class MPUBLIC UIListBtnType : public UIType
    165165{
    166166    Q_OBJECT
    167167  public:
     
    294294    void itemSelected(UIListBtnTypeItem* item);
    295295};
    296296
    297 class UIListBtnTypeItem
     297class MPUBLIC UIListBtnTypeItem
    298298{
    299299
    300300  public:
  • mythtv/libs/libmyth/libmyth.pro

     
    2020HEADERS += langsettings.h audiooutputnull.h mythsocket.h
    2121HEADERS += DisplayResScreen.h util-x11.h mythdeque.h qmdcodec.h
    2222HEADERS += exitcodes.h virtualkeyboard.h mythobservable.h mythevent.h
     23HEADERS += mythexp.h mythpluginapi.h
    2324
    2425SOURCES += dialogbox.cpp lcddevice.cpp mythcontext.cpp mythwidgets.cpp
    2526SOURCES += oldsettings.cpp remotefile.cpp settings.cpp
     
    5859inc.files += visual.h volumebase.h output.h langsettings.h qmdcodec.h
    5960inc.files += exitcodes.h mythconfig.h mythconfig.mak virtualkeyboard.h
    6061inc.files += mythevent.h mythobservable.h mythsocket.h
     62inc.files += mythexp.h mythpluginapi.h
    6163
    6264using_oss {
    6365    DEFINES += USING_OSS
     
    101103
    102104linux {
    103105    SOURCES += mythcdrom-linux.cpp
     106    HEADERS += mythcdrom-linux.h
    104107}
    105108
    106109freebsd {
    107110    SOURCES += mythcdrom-freebsd.cpp
     111    HEADERS += mythcdrom-freebsd.h
    108112}
    109113
    110114INSTALLS += inc
     
    163167contains( TARGET_MMX, yes ) {
    164168    HEADERS += ../../libs/libavcodec/i386/mmx.h ../../libs/libavcodec/dsputil.h
    165169}
     170
     171use_hidesyms {
     172    QMAKE_CXXFLAGS += -fvisibility=hidden
     173}
  • mythtv/libs/libmyth/lcddevice.h

     
    1313#include <qmutex.h>
    1414
    1515#include "mythsocket.h"
     16#include "mythexp.h"
    1617
    1718enum CHECKED_STATE {CHECKED = 0, UNCHECKED, NOTCHECKABLE };
    1819
    19 class LCDMenuItem
     20class MPUBLIC LCDMenuItem
    2021{
    2122  public:
    2223    LCDMenuItem() {}
     
    5859
    5960enum TEXT_ALIGNMENT {ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTERED };
    6061
    61 class LCDTextItem
     62class MPUBLIC LCDTextItem
    6263{
    6364  public:
    6465    LCDTextItem() {}
     
    99100    bool itemScrollable;
    100101};
    101102
    102 class LCD : public QObject, public MythSocketCBs
     103class MPUBLIC LCD : public QObject, public MythSocketCBs
    103104{
    104105    Q_OBJECT
    105106
  • mythtv/libs/libmyth/xmlparse.h

     
    88#include <qlabel.h>
    99#include <qdom.h>
    1010
    11 class XMLParse
     11
     12class MPUBLIC XMLParse
    1213{
    1314  public:
    1415    XMLParse();
  • mythtv/libs/libmyth/mythcdrom-linux.cpp

     
    11#include "mythcdrom.h"
     2#include "mythcdrom-linux.h"
    23#include <sys/ioctl.h>                // ioctls
    34#include <linux/cdrom.h>        // old ioctls for cdrom
    45#include <errno.h>
     
    89
    910#define ASSUME_WANT_AUDIO 1
    1011
     12class MythCDROMLinux: public MythCDROM
     13{
     14public:
     15    MythCDROMLinux(QObject* par, const char* DevicePath, bool SuperMount,
     16                   bool AllowEject):
     17        MythCDROM(par, DevicePath, SuperMount, AllowEject) {
     18    }
     19
     20    virtual MediaError testMedia(void);
     21    virtual bool mediaChanged(void);
     22    virtual bool checkOK(void);
     23    virtual MediaStatus checkMedia(void);
     24    virtual MediaError eject(bool open_close = true);
     25    virtual MediaError lock(void);
     26    virtual MediaError unlock(void);
     27};
     28
     29MythCDROM *GetMythCDROMLinux(QObject* par, const char* devicePath,
     30                             bool SuperMount, bool AllowEject)
     31{
     32    return new MythCDROMLinux(par, devicePath, SuperMount, AllowEject);
     33}
     34
    1135MediaError MythCDROMLinux::eject(bool open_close)
    1236{
    1337    if (open_close)
  • mythtv/libs/libmyth/mythexp.h

     
     1#ifndef MYTHEXP_H_
     2#define MYTHEXP_H_
     3
     4#if (__GNUC__ >= 4)
     5#define MHIDDEN __attribute__((visibility("hidden")))
     6#define MPUBLIC __attribute__((visibility("default")))
     7#else
     8#define MHIDDEN
     9#define MPUBLIC
     10#endif
     11
     12#endif // MYTHEXP_H_
  • mythtv/libs/libmyth/output.h

     
    2222class Visual;
    2323}
    2424
    25 class OutputEvent : public MythEvent
     25class MPUBLIC OutputEvent : public MythEvent
    2626{
    2727public:
    2828    enum Type { Playing = (User + 200), Buffering, Info, Paused,
     
    7272};
    7373
    7474
    75 class OutputListeners : public MythObservable
     75class MPUBLIC OutputListeners : public MythObservable
    7676{
    7777public:
    7878    OutputListeners();
  • mythtv/libs/libmyth/mythplugin.h

     
    66#include <qmap.h>
    77#include <qptrlist.h>
    88
     9#include "mythexp.h"
     10
    911class QSqlDatabase;
    1012class MythContext;
    1113class QPainter;
     
    5860};
    5961
    6062// this should only be instantiated through MythContext.
    61 class MythPluginManager
     63class MPUBLIC MythPluginManager
    6264{
    6365  public:   
    6466    MythPluginManager();
  • mythtv/libs/libmyth/langsettings.h

     
    33
    44#include "settings.h"
    55
    6 class LanguageSettings {
     6class MPUBLIC LanguageSettings {
    77public:
    88    /// Load a QTranslator for the user's preferred
    99    /// language. The module_name indicates
  • mythtv/libs/libmyth/volumebase.h

     
    1414    MUTE_BOTH
    1515} kMuteState;
    1616
    17 class VolumeBase
     17class MPUBLIC VolumeBase
    1818{
    1919 public:
    2020    VolumeBase();   
  • mythtv/libs/libmyth/virtualkeyboard.h

     
    1515    VK_POSBOTTOMDIALOG
    1616};
    1717
    18 class VirtualKeyboard : public MythThemedDialog
     18class MPUBLIC VirtualKeyboard : public MythThemedDialog
    1919{
    2020    Q_OBJECT
    2121  public:
  • mythtv/libs/libmyth/DisplayResScreen.h

     
    77#include <vector>
    88#include <map>
    99#include <algorithm>
     10#include "mythexp.h"
    1011
    11 class DisplayResScreen
     12class MPUBLIC DisplayResScreen
    1213{
    1314  public:
    1415    // Constructors, initializers
  • mythtv/libs/libmyth/audiooutput.h

     
    1414    AUDIOOUTPUT_TELEPHONY
    1515} AudioOutputSource;
    1616
    17 class AudioOutput : public VolumeBase, public OutputListeners
     17class MPUBLIC AudioOutput : public VolumeBase, public OutputListeners
    1818{
    1919 public:
    2020    // opens one of the concrete subclasses
  • mythtv/libs/libmyth/mythevent.h

     
    1212    Any subclass of this that adds data to the event should override
    1313    the clone method. As example, see OutputEvent in output.h.
    1414 */
    15 class MythEvent : public QCustomEvent
     15class MPUBLIC MythEvent : public QCustomEvent
    1616{
    1717  public:
    1818    enum Type { MythEventMessage = (User + 1000) };
  • mythtv/libs/libmyth/mythdialogs.h

     
    1515#include <qthread.h>
    1616#include <qlayout.h>
    1717
     18#include "mythexp.h"
     19
    1820#include <vector>
    1921using namespace std;
    2022
     
    4749
    4850#include "libmythui/mythmainwindow.h"
    4951
    50 class MythDialog : public QFrame
     52class MPUBLIC MythDialog : public QFrame
    5153{
    5254    Q_OBJECT
    5355  public:
     
    9597    QFont defaultBigFont, defaultMediumFont, defaultSmallFont;
    9698};
    9799
    98 class MythPopupBox : public MythDialog
     100class MPUBLIC MythPopupBox : public MythDialog
    99101{
    100102    Q_OBJECT
    101103  public:
     
    167169    The dialog widget also updates the LCD display if present.
    168170
    169171*/
    170 class MythProgressDialog: public MythDialog
     172class MPUBLIC MythProgressDialog: public MythDialog
    171173{
    172174  public:
    173175    /** Create a progress bar dialog.
     
    210212
    211213    Ie. used by MythMusic when scanning the filesystem for musicfiles.
    212214 */
    213 class MythBusyDialog : public MythProgressDialog
     215class MPUBLIC MythBusyDialog : public MythProgressDialog
    214216{
    215217    Q_OBJECT
    216218  public:
     
    248250    QTimer *timer;
    249251};
    250252
    251 class MythThemedDialog : public MythDialog
     253class MPUBLIC MythThemedDialog : public MythDialog
    252254{
    253255    Q_OBJECT
    254256  public:
     
    329331    QRect redrawRect;
    330332};
    331333
    332 class MythPasswordDialog: public MythDialog
     334class MPUBLIC MythPasswordDialog: public MythDialog
    333335{
    334336  Q_OBJECT
    335337
     
    362364    bool                *success_flag;
    363365};
    364366
    365 class MythSearchDialog: public MythPopupBox
     367class MPUBLIC MythSearchDialog: public MythPopupBox
    366368{
    367369  Q_OBJECT
    368370
     
    395397    QButton             *cancel_button;
    396398};
    397399
    398 class MythImageFileDialog: public MythThemedDialog
     400class MPUBLIC MythImageFileDialog: public MythThemedDialog
    399401{
    400402    //
    401403    //  Simple little popup dialog (themeable)
     
    442444
    443445// ---------------------------------------------------------------------------
    444446
    445 class MythScrollDialog : public QScrollView
     447class MPUBLIC MythScrollDialog : public QScrollView
    446448{
    447449    Q_OBJECT
    448450   
  • mythtv/libs/libmyth/util-x11.h

     
    1010#include <X11/Xlib.h>
    1111#include <vector>
    1212
    13 Display *MythXOpenDisplay(void);
    14 int XJ_error_catcher(Display * d, XErrorEvent * xeev);
    15 void InstallXErrorHandler(Display *d);
    16 void PrintXErrors(Display *d, const std::vector<XErrorEvent>& events);
    17 std::vector<XErrorEvent> UninstallXErrorHandler(Display *d, bool printErrors = true);
     13#include "mythexp.h"
     14
     15MPUBLIC Display *MythXOpenDisplay(void);
     16MPUBLIC void InstallXErrorHandler(Display *d);
     17MPUBLIC void PrintXErrors(Display *d, const std::vector<XErrorEvent>& events);
     18MPUBLIC std::vector<XErrorEvent> UninstallXErrorHandler(Display *d, bool printErrors = true);
    1819#endif // USING_XV
    1920
    20 int GetNumberOfXineramaScreens();
     21MPUBLIC int GetNumberOfXineramaScreens();
    2122
    22 extern QMutex x11_lock;
     23MPUBLIC extern QMutex x11_lock;
    2324
    2425#define X11L x11_lock.lock()
    2526#define X11U x11_lock.unlock()
  • mythtv/libs/libmyth/xmlparse.cpp

     
    88#include "uilistbtntype.h"
    99#include "xmlparse.h"
    1010
    11 QMap<QString, fontProp> globalFontMap;
     11MPUBLIC QMap<QString, fontProp> globalFontMap;
    1212
    1313XMLParse::XMLParse(void)
    1414{
  • mythtv/libs/libmyth/mythdbcon.h

     
    1313#include "mythcontext.h"
    1414
    1515/// \brief QSqlDatabase wrapper, used by MSqlQuery. Do not use directly.
    16 class MSqlDatabase
     16class MPUBLIC MSqlDatabase
    1717{
    1818  friend class MDBManager;
    1919  friend class MSqlQuery;
     
    7070typedef QMap<QString, QVariant> MSqlBindings;
    7171
    7272/// \brief Add the entries in addfrom to the map in output
    73 void MSqlAddMoreBindings(MSqlBindings &output, MSqlBindings &addfrom);
     73MPUBLIC void MSqlAddMoreBindings(MSqlBindings &output, MSqlBindings &addfrom);
    7474
    7575/// \brief Given a partial query string and a bindings object, escape the string
    76 void MSqlEscapeAsAQuery(QString &query, MSqlBindings &bindings);
     76MPUBLIC void MSqlEscapeAsAQuery(QString &query, MSqlBindings &bindings);
    7777
    7878/** \brief QSqlQuery wrapper that fetches a DB connection from the connection pool.
    7979 *
     
    9494 *   will crash if closed and reopend - so we never close them and keep them in
    9595 *   a pool.
    9696 */
    97 class MSqlQuery : public QSqlQuery
     97class MPUBLIC MSqlQuery : public QSqlQuery
    9898{
    9999  public:
    100100    /// \brief Get DB connection from pool
  • mythtv/libs/libmyth/managedlist.h

     
    2323//
    2424// This is an abstract base class that defines the interface.
    2525//
    26 class ManagedListItem : public QObject
     26class MPUBLIC ManagedListItem : public QObject
    2727{
    2828    Q_OBJECT
    2929
     
    7979};
    8080
    8181
    82 class DialogDoneListItem : public ManagedListItem
     82class MPUBLIC DialogDoneListItem : public ManagedListItem
    8383{
    8484    Q_OBJECT
    8585    public:
     
    169169//
    170170// A list item that can contain more items.
    171171//
    172 class ManagedListGroup : public ManagedListItem
     172class MPUBLIC ManagedListGroup : public ManagedListItem
    173173{
    174174    Q_OBJECT
    175175
     
    231231// A specialized version of the ManagedListGroup that allows for swtiching the
    232232// values using left/right without having to pop up the list.
    233233//
    234 class SelectManagedListItem : public ManagedListGroup
     234class MPUBLIC SelectManagedListItem : public ManagedListGroup
    235235{
    236236    Q_OBJECT
    237237
     
    297297};
    298298
    299299
    300 class BoolManagedListItem : public SelectManagedListItem
     300class MPUBLIC BoolManagedListItem : public SelectManagedListItem
    301301{
    302302    Q_OBJECT
    303303    public:
     
    342342//
    343343// An IntegerManagedListItem with a minimum and maximum value.
    344344//
    345 class BoundedIntegerManagedListItem : public SelectManagedListItem
     345class MPUBLIC BoundedIntegerManagedListItem : public SelectManagedListItem
    346346{
    347347    Q_OBJECT
    348348
     
    425425};
    426426
    427427
    428 class ManagedListSetting: public SimpleDBStorage
     428class MPUBLIC ManagedListSetting: public SimpleDBStorage
    429429{
    430430    Q_OBJECT
    431431
     
    495495};
    496496
    497497
    498 class SelectManagedListSetting : public ManagedListSetting
     498class MPUBLIC SelectManagedListSetting : public ManagedListSetting
    499499{
    500500    protected:
    501501        SelectManagedListSetting(const QString& listName,  const QString& listText, ManagedListGroup* _group,
     
    550550};
    551551
    552552
    553 class BoolManagedListSetting : public ManagedListSetting
     553class MPUBLIC BoolManagedListSetting : public ManagedListSetting
    554554{
    555555    public:
    556556        BoolManagedListSetting(const QString& trueText, const QString& falseText, const QString& ItemName,
     
    571571};
    572572
    573573
    574 class IntegerManagedListSetting : public ManagedListSetting
     574class MPUBLIC IntegerManagedListSetting : public ManagedListSetting
    575575{
    576576    public:
    577577        IntegerManagedListSetting(int _bigStep, int _step, const QString& ItemName, QString _table,
     
    600600        IntegerManagedListItem* IntegerListItem;
    601601};
    602602
    603 class BoundedIntegerManagedListSetting : public ManagedListSetting
     603class MPUBLIC BoundedIntegerManagedListSetting : public ManagedListSetting
    604604{
    605605    public:
    606606        BoundedIntegerManagedListSetting(int _min, int _max, int _bigStep, int _step, const QString& ItemName,
     
    633633//
    634634// The ManagedList takes care of the heavy lifting when using a UIListType.
    635635//
    636 class ManagedList : public QObject
     636class MPUBLIC ManagedList : public QObject
    637637{
    638638    Q_OBJECT
    639639
  • mythtv/libs/libmyth/mythsocket.h

     
    66#include <qtimer.h>
    77#include <pthread.h>
    88#include <qptrlist.h>
     9#include "mythexp.h"
    910
    1011class QHostAddress;
    1112class MythSocket;
    1213
    13 class MythSocketCBs
     14class MPUBLIC MythSocketCBs
    1415{
    1516  public:
    1617    virtual ~MythSocketCBs() {}
     
    2021    virtual void connectionClosed(MythSocket*) = 0;
    2122};
    2223
    23 class MythSocket : public QSocketDevice
     24class MPUBLIC MythSocket : public QSocketDevice
    2425{
    2526  public:
    2627    MythSocket(int socket = -1, MythSocketCBs *cb = NULL);
  • mythtv/libs/libmyth/remotefile.h

     
    44#include <qstring.h>
    55#include <qmutex.h>
    66
     7#include "mythexp.h"
     8
    79class MythContext;
    810class MythSocket;
    911
    10 class RemoteFile
     12class MPUBLIC RemoteFile
    1113{
    1214  public:
    1315    RemoteFile(const QString &url, bool usereadahead = true, int retries = -1);
  • mythtv/libs/libmyth/oldsettings.h

     
    1212#include <qstring.h>
    1313#include <map>
    1414
     15#include "mythexp.h"
     16
    1517using namespace std;
    1618
    1719/**This class contains configuration information. 
     
    2022  */
    2123
    2224class QPixmap;
    23 class Settings {
     25class MPUBLIC Settings {
    2426public:
    2527        Settings(QString strSettingFile = "settings.txt");
    2628        ~Settings();
  • mythtv/libs/libmyth/dbsettings.h

     
    33
    44#include "settings.h"
    55
    6 class DatabaseSettings: virtual public ConfigurationWizard {
     6class MPUBLIC DatabaseSettings: virtual public ConfigurationWizard {
    77public:
    88    DatabaseSettings();
    99   
  • mythtv/libs/libmyth/dialogbox.h

     
    99class QButtonGroup;
    1010class QString;
    1111
    12 class DialogBox : public MythDialog
     12class MPUBLIC DialogBox : public MythDialog
    1313{
    1414    Q_OBJECT
    1515  public:
  • mythtv/libs/libmyth/mythwidgets.h

     
    2727
    2828#include "virtualkeyboard.h"
    2929
     30#include "mythexp.h"
    3031
    3132// These widgets follow these general navigation rules:
    3233//
     
    3637// - Space selects
    3738
    3839
    39 class MythComboBox: public QComboBox
     40class MPUBLIC MythComboBox: public QComboBox
    4041{
    4142    Q_OBJECT
    4243  public:
     
    6869    int step;
    6970};
    7071
    71 class MythSpinBox: public QSpinBox
     72class MPUBLIC MythSpinBox: public QSpinBox
    7273{
    7374    Q_OBJECT
    7475  public:
     
    9596    bool singlestep;
    9697};
    9798
    98 class MythSlider: public QSlider
     99class MPUBLIC MythSlider: public QSlider
    99100{
    100101    Q_OBJECT
    101102  public:
     
    117118};
    118119
    119120
    120 class MythLineEdit : public QLineEdit
     121class MPUBLIC MythLineEdit : public QLineEdit
    121122{
    122123    Q_OBJECT
    123124  public:
     
    163164};
    164165
    165166// A Line edit that does special things when you press number keys
    166 class MythRemoteLineEdit : public QTextEdit
     167class MPUBLIC MythRemoteLineEdit : public QTextEdit
    167168{
    168169    Q_OBJECT
    169170  public:
     
    243244    PopupPosition popupPosition;
    244245};
    245246
    246 class MythTable : public QTable
     247class MPUBLIC MythTable : public QTable
    247248{
    248249  public:
    249250    MythTable(QWidget *parent) : QTable(parent) { }
     
    251252    void keyPressEvent(QKeyEvent *e);
    252253};
    253254
    254 class MythButtonGroup : public QButtonGroup
     255class MPUBLIC MythButtonGroup : public QButtonGroup
    255256{
    256257  public:
    257258    MythButtonGroup(QWidget *parent = 0) : QButtonGroup(parent) { }
     
    259260    void moveFocus(int key);
    260261};
    261262
    262 class MythPushButton : public QPushButton
     263class MPUBLIC MythPushButton : public QPushButton
    263264{
    264265    Q_OBJECT
    265266  public:
     
    291292    QStringList keyPressActions;
    292293};
    293294
    294 class MythCheckBox: public QCheckBox
     295class MPUBLIC MythCheckBox: public QCheckBox
    295296{
    296297    Q_OBJECT
    297298  public:
     
    311312    QString helptext;
    312313};
    313314
    314 class MythRadioButton: public QRadioButton
     315class MPUBLIC MythRadioButton: public QRadioButton
    315316{
    316317    Q_OBJECT
    317318  public:
     
    331332    QString helptext;
    332333};
    333334
    334 class MythListView : public QListView
     335class MPUBLIC MythListView : public QListView
    335336{
    336337    Q_OBJECT
    337338  public:
     
    344345    void focusInEvent(QFocusEvent *e);
    345346};
    346347
    347 class MythListBox: public QListBox {
     348class MPUBLIC MythListBox: public QListBox {
    348349    Q_OBJECT
    349350  public:
    350351    MythListBox(QWidget* parent);
  • mythtv/libs/libmyth/mythcdrom-freebsd.cpp

     
    11#include "mythcdrom.h"
     2#include "mythcdrom-freebsd.h"
    23#include <errno.h>
    34#include <sys/ioctl.h>
    45#include <sys/cdio.h>
     
    78
    89#define ASSUME_WANT_AUDIO 1
    910
     11class MythCDROMFreeBSD: public MythCDROM
     12{
     13public:
     14    MythCDROMFreeBSD(QObject* par, const char* DevicePath, bool SuperMount,
     15                     bool AllowEject):
     16        MythCDROM(par, DevicePath, SuperMount, AllowEject) {
     17    }
     18
     19    virtual MediaError testMedia(void);
     20    virtual MediaError eject(bool open_close = true);
     21    virtual MediaError lock(void);
     22    virtual MediaError unlock(void);
     23};
     24
     25MythCDROM *GetMythCDROMFreeBSD(QObject* par, const char* devicePath,
     26                               bool SuperMount, bool AllowEject)
     27{
     28    return new MythCDROMFreeBSD(par, devicePath, SuperMount, AllowEject);
     29}
     30
    1031MediaError MythCDROMFreeBSD::eject(bool open_close)
    1132{
    1233    if (open_close)
  • mythtv/libs/libmyth/httpcomms.h

     
    66#include <qurl.h>
    77#include <qobject.h>
    88#include <qtimer.h>
     9#include "mythexp.h"
    910
    10 class HttpComms : public QObject
     11class MPUBLIC HttpComms : public QObject
    1112{
    1213    Q_OBJECT
    1314  public:
  • mythtv/libs/libmyth/DisplayRes.h

     
    77#include <vector>
    88#include <map>
    99#include "DisplayResScreen.h"
     10#include "mythexp.h"
    1011
    1112/** \class DisplayRes
    1213 *  \brief The DisplayRes module allows for the display resolution
     
    2324
    2425typedef enum { GUI = 0, VIDEO = 1, CUSTOM_GUI = 2, CUSTOM_VIDEO = 3 } tmode;
    2526
    26 class DisplayRes {
     27class MPUBLIC DisplayRes {
    2728  public:
    2829    /** \brief Factory method that returns a DisplayRes singleton */
    2930    static DisplayRes *GetDisplayRes(void);
     
    144145 *   class if needed, and returns a copy of vector returned by
    145146 *   GetVideoModes(void).
    146147 */
    147 const vector<DisplayResScreen> GetVideoModes(void);
     148MPUBLIC const vector<DisplayResScreen> GetVideoModes(void);
    148149
    149150#endif
  • mythtv/libs/libmyth/qmdcodec.h

     
    4040#include <qstring.h>
    4141#include <qiodevice.h>
    4242
     43#include "mythexp.h"
     44
    4345/**
    4446 * A wrapper class for the most commonly used encoding and
    4547 * decoding algorithms.  Currently there is support for encoding
     
    6870 * @author Dawit Alemayehu <adawit@kde.org>
    6971 * @author Rik Hemsley <rik@kde.org>
    7072 */
    71 class QCodecs
     73class MPUBLIC QCodecs
    7274{
    7375public:
    7476
     
    401403 * @author Dirk Mueller <mueller@kde.org>, Dawit Alemayehu <adawit@kde.org>
    402404 */
    403405
    404 class QMD5
     406class MPUBLIC QMD5
    405407{
    406408public:
    407409
  • mythtv/libs/libmyth/mythmedia.h

     
    55#include <qstring.h>
    66#include <qstringlist.h>
    77
     8#include "mythexp.h"
     9
    810typedef enum {
    911    MEDIASTAT_ERROR,
    1012    MEDIASTAT_UNKNOWN,
     
    3739typedef QMap<QString,uint> ext_cnt_t;
    3840typedef QMap<QString,uint> ext_to_media_t;
    3941
    40 class MythMediaDevice : public QObject
     42class MPUBLIC MythMediaDevice : public QObject
    4143{
    4244    Q_OBJECT
    4345 public:
  • mythtv/libs/libmyth/mythobservable.h

     
    22#define MYTHOBSERVABLE_H_
    33
    44#include <qptrlist.h>
     5#include "mythexp.h"
    56#include "mythevent.h"
    67
    78class QObject;
     
    3637    MythListenable just doesn't sound right, and fixing all the calls
    3738    to addListener was too big a patch.
    3839*/
    39 class MythObservable
     40class MPUBLIC MythObservable
    4041{
    4142  public:
    4243    MythObservable();