Ticket #4264: ctxrestr.9.patch

mythtv/libs/libmythtv/dbsettings.cpp

@@ +1 @@
+#include "libmyth/mythcontext.h"
+#include "libmyth/mythdbcon.h"
+#include "dbsettings.h"
+#include <qfile.h>
+#include <qdir.h>
+
+class MythDbSettings1: public VerticalConfigurationGroup {
+public:
+    MythDbSettings1(const QString &DBhostOverride = QString::null);
+
+    void load();
+    void save();
+
+protected:
+    TransLabelSetting    *info;
+    TransLineEditSetting *dbHostName;
+    TransCheckBoxSetting *dbHostPing;
+    TransLineEditSetting *dbPort;
+    TransLineEditSetting *dbName;
+    TransLineEditSetting *dbUserName;
+    TransLineEditSetting *dbPassword;
+    TransComboBoxSetting *dbType;
+
+    QString              m_DBhostOverride;
+}; 
+
+class MythDbSettings2: public VerticalConfigurationGroup {
+public:
+    MythDbSettings2();
+
+    void load();
+    void save();
+
+protected:
+    TransCheckBoxSetting *localEnabled;
+    TransLineEditSetting *localHostName;
+    TransCheckBoxSetting *wolEnabled;
+    TransSpinBoxSetting  *wolReconnect;
+    TransSpinBoxSetting  *wolRetry;
+    TransLineEditSetting *wolCommand;
+}; 
+
+
+
+class LocalHostNameSettings : public TriggeredConfigurationGroup
+{
+  public:
+    LocalHostNameSettings(Setting *checkbox, ConfigurationGroup *group) :
+        TriggeredConfigurationGroup(false, false, false, false)
+    {
+        setLabel(QObject::tr("Use custom identifier for frontend preferences"));
+        addChild(checkbox);
+        setTrigger(checkbox);
+
+        addTarget("1", group);
+        addTarget("0", new VerticalConfigurationGroup(true));
+    }
+};
+
+class WOLsqlSettings : public TriggeredConfigurationGroup
+{
+  public:
+    WOLsqlSettings(Setting *checkbox, ConfigurationGroup *group) :
+        TriggeredConfigurationGroup(false, false, false, false)
+    {
+        setLabel(QObject::tr("Backend Server Wakeup settings"));
+
+        addChild(checkbox);
+        setTrigger(checkbox);
+
+        addTarget("1", group);
+        addTarget("0", new VerticalConfigurationGroup(true));
+    }
+};
+
+MythDbSettings1::MythDbSettings1(const QString &DbHostOverride) :
+    VerticalConfigurationGroup(false, true, false, false)
+{
+    m_DBhostOverride = DbHostOverride;
+
+    setLabel(QObject::tr("Database Configuration") + " 1/2");
+
+    info = new TransLabelSetting();
+
+    MSqlQuery query(MSqlQuery::InitCon());
+    if (query.isConnected())
+        info->setValue(QObject::tr("All database settings take effect when "
+                                   "you restart this program."));
+    else
+        info->setValue(QObject::tr("Myth could not connect to the database. "
+                                   "Please verify your database settings "
+                                   "below."));
+    addChild(info);
+
+    VerticalConfigurationGroup* dbServer = new VerticalConfigurationGroup();
+    dbServer->setLabel(QObject::tr("Database Server Settings"));
+    dbHostName = new TransLineEditSetting(true);
+    dbHostName->setLabel(QObject::tr("Hostname"));
+    dbHostName->setHelpText(QObject::tr("The host name or IP address of "
+                                        "the machine hosting the database. "
+                                        "This information is required."));
+    dbServer->addChild(dbHostName);
+
+    HorizontalConfigurationGroup* g =
+        new HorizontalConfigurationGroup(false, false);
+
+    dbHostPing = new TransCheckBoxSetting();
+    dbHostPing->setLabel(QObject::tr("Ping test server?"));
+    dbHostPing->setHelpText(QObject::tr("Test basic host connectivity using "
+                                        "the ping command. Turn off if your "
+                                        "host or network don't support ping "
+                                        "(ICMP ECHO) packets"));
+    g->addChild(dbHostPing);
+
+    // Some extra horizontal space:
+    TransLabelSetting *l = new TransLabelSetting();
+    l->setValue("                               ");
+    g->addChild(l);
+
+    dbServer->addChild(g);
+
+    dbPort = new TransLineEditSetting(true);
+    dbPort->setLabel(QObject::tr("Port"));
+    dbPort->setHelpText(QObject::tr("The port number the database is running "
+                                    "on.  Leave blank if using the default "
+                                    "port (3306)."));
+    g->addChild(dbPort);
+
+    dbName = new TransLineEditSetting(true);
+    dbName->setLabel(QObject::tr("Database name"));
+    dbName->setHelpText(QObject::tr("The name of the database. "
+                                    "This information is required."));
+    dbServer->addChild(dbName);
+
+    dbUserName = new TransLineEditSetting(true);
+    dbUserName->setLabel(QObject::tr("User"));
+    dbUserName->setHelpText(QObject::tr("The user name to use while "
+                                        "connecting to the database. "
+                                        "This information is required."));
+    dbServer->addChild(dbUserName);
+
+    dbPassword = new TransLineEditSetting(true);
+    dbPassword->setLabel(QObject::tr("Password"));
+    dbPassword->setHelpText(QObject::tr("The password to use while "
+                                        "connecting to the database. "
+                                        "This information is required."));
+    dbServer->addChild(dbPassword);
+
+    dbType = new TransComboBoxSetting(false);
+    dbType->setLabel(QObject::tr("Database type"));
+    dbType->addSelection(QObject::tr("MySQL"), "QMYSQL3");
+    dbType->setValue(0);
+    dbType->setHelpText(QObject::tr("The database implementation used "
+                                    "for your server."));
+    dbType->setEnabled(false);
+    //dbServer->addChild(dbType);
+
+    addChild(dbServer);
+
+}
+
+MythDbSettings2::MythDbSettings2(void) :
+    VerticalConfigurationGroup(false, true, false, false)
+{
+    setLabel(QObject::tr("Database Configuration") + " 2/2");
+
+    localEnabled = new TransCheckBoxSetting();
+    localEnabled->setLabel(QObject::tr("Use custom identifier for frontend "
+                                       "preferences"));
+    localEnabled->setHelpText(QObject::tr("If this frontend's host name "
+                                          "changes often, check this box "
+                                          "and provide a network-unique "
+                                          "name to identify it. "
+                                          "If unchecked, the frontend "
+                                          "machine's local host name will "
+                                          "be used to save preferences in "
+                                          "the database."));
+
+    localHostName = new TransLineEditSetting(true);
+    localHostName->setLabel(QObject::tr("Custom identifier"));
+    localHostName->setHelpText(QObject::tr("An identifier to use while "
+                                           "saving the settings for this "
+                                           "frontend."));
+
+    VerticalConfigurationGroup *group1 =
+        new VerticalConfigurationGroup(false);
+    group1->addChild(localHostName);
+
+    LocalHostNameSettings *sub3 =
+        new LocalHostNameSettings(localEnabled, group1);
+    addChild(sub3);
+
+    wolEnabled = new TransCheckBoxSetting();
+    wolEnabled->setLabel(QObject::tr("Enable Database Server Wakeup"));
+    wolEnabled->setHelpText(QObject::tr("If checked, the frontend will use "
+                                        "database wakeup parameters to "
+                                        "reconnect to the database server."));
+
+    wolReconnect = new TransSpinBoxSetting(0, 60, 1, true);
+    wolReconnect->setLabel(QObject::tr("Reconnect time"));
+    wolReconnect->setHelpText(QObject::tr("The time in seconds to wait for "
+                                          "the server to wake up."));
+
+    wolRetry = new TransSpinBoxSetting(1, 10, 1, true);
+    wolRetry->setLabel(QObject::tr("Retry attempts"));
+    wolRetry->setHelpText(QObject::tr("The number of retries to wake the "
+                                      "server before the frontend gives "
+                                      "up."));
+
+    wolCommand = new TransLineEditSetting(true);
+    wolCommand->setLabel(QObject::tr("Wake command"));
+    wolCommand->setHelpText(QObject::tr("The command executed on this "
+                                        "frontend to wake up the database "
+                                        "server (eg. sudo /etc/init.d/mysql "
+                                        "restart)."));
+
+    HorizontalConfigurationGroup *group2 =
+        new HorizontalConfigurationGroup(false, false);
+    group2->addChild(wolReconnect);
+    group2->addChild(wolRetry);
+
+    VerticalConfigurationGroup *group3 =
+        new VerticalConfigurationGroup(false);
+    group3->addChild(group2);
+    group3->addChild(wolCommand);
+
+    WOLsqlSettings *sub4 =
+        new WOLsqlSettings(wolEnabled, group3);
+    addChild(sub4);
+}
+
+void MythDbSettings1::load()
+{
+    if (gDBparams.dbName.isEmpty() || gDBparams.dbHostName.isEmpty()
+                                   || gDBparams.dbUserName.isEmpty()
+                                   || gDBparams.dbPassword.isEmpty())
+        info->setValue(info->getValue() + "\n" +
+                       QObject::tr("Required fields are"
+                                   " marked with an asterisk (*)."));
+
+    if (gDBparams.dbHostName.isEmpty())
+    {
+        dbHostName->setLabel("* " + dbHostName->getLabel());
+        dbHostName->setValue(m_DBhostOverride);
+    }
+    else
+        dbHostName->setValue(gDBparams.dbHostName);
+
+    dbHostPing->setValue(gDBparams.dbHostPing);
+
+    if (gDBparams.dbPort)
+        dbPort->setValue(QString::number(gDBparams.dbPort));
+
+    dbUserName->setValue(gDBparams.dbUserName);
+    if (gDBparams.dbUserName.isEmpty())
+        dbUserName->setLabel("* " + dbUserName->getLabel());
+    dbPassword->setValue(gDBparams.dbPassword);
+    if (gDBparams.dbPassword.isEmpty())
+        dbPassword->setLabel("* " + dbPassword->getLabel());
+    dbName->setValue(gDBparams.dbName);
+    if (gDBparams.dbName.isEmpty())
+        dbName->setLabel("* " + dbName->getLabel());
+
+    if (gDBparams.dbType == "QMYSQL3")
+        dbType->setValue(0);
+    else if (gDBparams.dbType == "QPSQL7")
+        dbType->setValue(1);
+}
+
+void MythDbSettings2::load()
+{
+    localEnabled->setValue(gDBparams.localEnabled);
+    localHostName->setValue(gDBparams.localHostName);
+
+    wolEnabled->setValue(gDBparams.wolEnabled);
+    wolReconnect->setValue(gDBparams.wolReconnect);
+    wolRetry->setValue(gDBparams.wolRetry);
+    wolCommand->setValue(gDBparams.wolCommand);
+}
+
+void MythDbSettings1::save()
+{
+    gDBparams.dbHostName    = dbHostName->getValue();
+    gDBparams.dbHostPing    = dbHostPing->boolValue();
+    gDBparams.dbPort        = dbPort->getValue().toInt();
+    gDBparams.dbUserName    = dbUserName->getValue();
+    gDBparams.dbPassword    = dbPassword->getValue();
+    gDBparams.dbName        = dbName->getValue();
+    gDBparams.dbType        = dbType->getValue();
+
+    gContext->SaveDatabaseParams(gDBparams);
+}
+
+void MythDbSettings2::save()
+{
+    gDBparams.localEnabled  = localEnabled->boolValue();
+    gDBparams.localHostName = localHostName->getValue();
+
+    gDBparams.wolEnabled    = wolEnabled->boolValue();
+    gDBparams.wolReconnect  = wolReconnect->intValue();
+    gDBparams.wolRetry      = wolRetry->intValue();
+    gDBparams.wolCommand    = wolCommand->getValue();
+
+    gContext->SaveDatabaseParams(gDBparams);
+}
+
+DatabaseSettings::DatabaseSettings(const QString &DBhostOverride)
+{
+    addChild(new MythDbSettings1(DBhostOverride));
+    addChild(new MythDbSettings2());
+}
+
+void DatabaseSettings::addDatabaseSettings(ConfigurationWizard *wizard)
+{
+    wizard->addChild(new MythDbSettings1());
+    wizard->addChild(new MythDbSettings2());
+}

mythtv/libs/libmythtv/libmythtv.pro

@@ -27 +27 @@
 DEPENDPATH  += ../libmythlivemedia/UsageEnvironment/include
 DEPENDPATH  += ../libmythlivemedia/UsageEnvironment
 
-LIBS += -L../libmyth -L../libavutil -L../libavcodec -L../libavformat 
+LIBS += -L../libmyth -L../libmythupnp -L../libmythui
+LIBS += -L../libavutil -L../libavcodec -L../libavformat 
 LIBS += -L../libmythmpeg2 -L../libmythdvdnav
 LIBS += -L../libmythfreemheg -L../libmythlivemedia
-LIBS += -lmyth-$${LIBVERSION} -lmythavutil-$${LIBVERSION}
+LIBS += -lmyth-$${LIBVERSION} -lmythupnp-$${LIBVERSION} -lmythui-$${LIBVERSION}
+LIBS += -lmythavutil-$${LIBVERSION}
 LIBS += -lmythavcodec-$${LIBVERSION} -lmythdvdnav-$${LIBVERSION}
 LIBS += -lmythavformat-$${LIBVERSION} -lmythmpeg2-$${LIBVERSION}
 LIBS += -lmythfreemheg-$${LIBVERSION} -lmythlivemedia-$${LIBVERSION}
 LIBS += $$EXTRA_LIBS
 
 TARGETDEPS += ../libmyth/libmyth-$${MYTH_SHLIB_EXT}
+TARGETDEPS += ../libmythupnp/libmythupnp-$${MYTH_SHLIB_EXT}
+TARGETDEPS += ../libmythui/libmythui-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../libavutil/libmythavutil-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../libavcodec/libmythavcodec-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../libavformat/libmythavformat-$${MYTH_SHLIB_EXT}
@@ -78 +82 @@
         # DVDUtils uses Objective-C++, activated by .mm suffix
         QMAKE_EXT_CPP += .mm
     }
-
-    # There is a dependence on some stuff in libmythui.
-    # It isn't built yet, so we have to ignore these for now:
-    QMAKE_LFLAGS_SHLIB += -flat_namespace -undefined warning
-    #LIBS += -lmythui-$${LIBVERSION} -L../libmythui
-
-    QMAKE_LFLAGS_SHLIB += -seg1addr 0xC9000000
 }
 
 cygwin:QMAKE_LFLAGS_SHLIB += -Wl,--noinhibit-exec
@@ -142 +139 @@
 HEADERS += channeleditor.h          channelsettings.h
 HEADERS += previewgenerator.h       transporteditor.h
 HEADERS += importicons.h
+HEADERS += backendselect.h          dbsettings.h
+HEADERS += mythcontextui.h
 
 SOURCES += programinfo.cpp          proglist.cpp
 SOURCES += storagegroup.cpp
@@ -165 +164 @@
 SOURCES += channeleditor.cpp        channelsettings.cpp
 SOURCES += previewgenerator.cpp     transporteditor.cpp
 SOURCES += importicons.cpp
+SOURCES += backendselect.cpp        dbsettings.cpp
+SOURCES += mythcontextui.cpp
 
 # DiSEqC
 HEADERS += diseqc.h                 diseqcsettings.h
@@ -521 +522 @@
     POST_TARGETDEPS += libmythui-bootstrap.a
 }
 
-# install headers required by mytharchive
+# install headers required by mytharchivehelper
 inc.path = $${PREFIX}/include/mythtv/libmythtv/
-inc.files = programinfo.h remoteutil.h recordingtypes.h
+inc.files = mythcontextui.h programinfo.h remoteutil.h recordingtypes.h
 
 INSTALLS += inc

mythtv/libs/libmythtv/backendselect.h

@@ +1 @@
+#ifndef __BACKENDSELECT_H__
+#define __BACKENDSELECT_H__
+
+//#include <qlistbox.h>
+
+#include "libmyth/mythdialogs.h"
+#include "libmyth/mythwidgets.h"
+#include "libmythupnp/upnpdevice.h"
+
+class ListBoxDevice : public QListBoxText
+{
+    public:
+
+        ListBoxDevice(QListBox *list, const QString &name, DeviceLocation *dev)
+            : QListBoxText(list, name)
+        {
+            if ((m_dev = dev) != NULL)
+                m_dev->AddRef();
+        }
+
+        virtual ~ListBoxDevice()
+        {
+            if (m_dev != NULL)
+                m_dev->Release();
+        }
+
+        DeviceLocation *m_dev;
+};
+
+typedef QMap< QString, ListBoxDevice *> ItemMap;
+
+
+class BackendSelect : public MythDialog 
+{
+    Q_OBJECT
+
+    public:
+                 BackendSelect(MythMainWindow *parent, DatabaseParams *params);
+        virtual ~BackendSelect();
+
+        void     customEvent(QCustomEvent *e);
+
+        QString  m_PIN;
+        QString  m_USN;
+
+
+    public slots:
+
+        void Accept    (void);   ///< Linked to the OK button
+        void Manual    (void);   ///< Linked to 'Configure Manually' button
+        void Search    (void);
+
+
+    protected:
+
+        void AddItem   (DeviceLocation *dev);
+        bool Connect   (DeviceLocation *dev);
+        void CreateUI  (void);
+        void FillListBox(void);
+        void RemoveItem(QString URN);
+
+        DatabaseParams *m_DBparams;
+        ItemMap         m_devices;
+        MythMainWindow *m_parent;
+        MythListBox    *m_backends;
+};
+
+#endif

mythtv/libs/libmythtv/mythcontextui.h

@@ +1 @@
+#ifndef __MYTHCONTEXTUI_H__
+#define __MYTHCONTEXTUI_H__
+
+#include <mythexp.h>
+#include <libmythui/mythmainwindow.h>
+#include <libmythupnp/upnp.h>
+
+class MythContextGUI;
+class MythContextTTY;
+
+///
+/// Some common implementation details for MythContextGUI and MythContextTTY
+///
+/// This would normally be hidden in mythcontextui.cpp, but having it here
+/// makes the class hierarchy simpler, and it is only programs/*/main.cpp
+/// that will be recompiled if this class's members are changed.
+ 
+class MHIDDEN MythContextUI : MythContext
+{
+    friend class MythContextGUI;
+    friend class MythContextTTY;
+
+  public:
+    MythContextUI(MythContextGUI *parent, const QString &binVersion);
+    ~MythContextUI();
+
+    int  PromptForSchemaUpgrade(const QString &dbver, const QString &current);
+
+
+  private:
+    const QString BinaryVersionError(void);
+          bool    FindDatabase(const bool prompt = false,
+                               const bool noPrompt = false);
+    const QString PluginVersionError(const QString &pluginName,
+                                     const QString &libMythVersion,
+                                     const QString &pluginVersion);
+
+    // These deal with mysql.txt
+    void LoadDatabaseSettings();
+    bool LoadSettingsFile();
+    bool PromptForDatabaseParams(const QString &error);
+
+    // These deal with config.xml and UPnP
+    bool InitUPnP(void);
+    void DeleteUPnP(void);
+    int  ChooseBackend(const QString &error);
+
+    int  UPnPautoconf(const int milliSeconds = 2000);
+    bool DefaultUPnP(QString &error);
+    bool UPnPconnect(const DeviceLocation *device, const QString &PIN);
+
+
+    void    BackupDBhostname (void) { m_DBhostCp = gDBparams.dbHostName; };
+    void    RestoreDBhostname(void) { gDBparams.dbHostName = m_DBhostCp; };
+    QString TestDBconnection (void);
+
+
+    QString           m_binVersion;  ///< Version of the the calling program
+    bool              m_disableLibPopup;
+    QString           m_DBhostCp;
+
+    bool              m_GUI;         ///< Is the parent a GUI context?
+    MythContextGUI   *m_parent;
+    MythMainWindow   *m_win;
+
+    // For UPnP autodiscovery:
+    HttpServer       *m_HTTP;
+    UPnp             *m_UPnP;
+    XmlConfiguration *m_XML;
+};
+
+/// GUI-based MythContext
+
+class MPUBLIC MythContextGUI : MythContextUI
+{
+  public:
+    MythContextGUI(const QString &binVersion);
+    ~MythContextGUI();
+
+    bool Init(UPnp *UPnPclient = NULL,
+              const bool promptForBackend = false,
+              const bool bypassAutoDiscovery = false);
+    bool TestPopupVersion(const QString &pluginName,
+                          const QString &libMythVersion,
+                          const QString &pluginVersion);
+    void SetDisableLibraryPopup(const bool check)
+         { m_disableLibPopup = check; };
+
+    void attachToWin(QWidget *child)   { m_win->attach(child); };
+    void detachFromWin(QWidget *child) { m_win->detach(child); };
+    int  NormalizeFontSize(const int pointSize)
+         { if (m_win) return m_win->NormalizeFontSize(pointSize); else puts("###################################### NormalizeFontSize() - Window is NULL"); return 1; }; 
+    bool TranslateKeyPress(const QString &context,
+                           QKeyEvent     *e,
+                           QStringList   &actions, bool allowJumps)
+         { return m_win->TranslateKeyPress(context, e, actions, allowJumps); }; 
+
+    MythMainWindow *CreateMainWindow(void);
+    MythMainWindow *TempMainWindow(bool languagePrompt = true);
+    void            EndTempWindow(void);
+};
+
+/// Non-GUI MythContext
+///
+/// The name is a misnomer. A program's output might not
+/// be in a terminal-connected shell (and thus !isatty())
+
+class MPUBLIC MythContextTTY : MythContextUI
+{
+  public:
+    MythContextTTY(const QString &binVersion);
+    ~MythContextTTY();
+
+    bool Init(UPnp *UPnPclient);
+
+    bool TestPopupVersion(const QString &,
+                          const QString &,
+                          const QString &)      { return false; }
+    void SetDisableLibraryPopup(const bool)     {};
+
+    void attachToWin(QWidget *child)            {};
+    void detachFromWin(QWidget *child)          {};
+    int  NormalizeFontSize(const int pointSize) { return pointSize; };
+    bool TranslateKeyPress(const QString &,
+                           QKeyEvent *,
+                           QStringList &, bool) { return false; }
+
+    MythMainWindow * CreateMainWindow(void)     { return NULL; };
+};
+
+// Prompt the user and get a value. Currently only used in a TTY context,
+// but putting them here allows them to be used directly by anything.
+
+MPUBLIC QString getResponse(const QString &query, const QString &def);
+MPUBLIC int     intResponse(const QString &query, const int      def);
+
+#endif

mythtv/libs/libmythtv/dbsettings.h

@@ +1 @@
+#ifndef DBSETTINGS_H
+#define DBSETTINGS_H
+
+#include "libmyth/mythconfigdialogs.h"
+
+class MPUBLIC DatabaseSettings: public ConfigurationWizard {
+public:
+    DatabaseSettings(const QString &DBhostOverride = QString::null);
+    
+    // This routine calls wizard->addChild() for each of
+    // the database configuration screens.  This allows
+    // the number of DB config screens to change.
+    static void addDatabaseSettings(ConfigurationWizard *wizard);
+};
+
+#endif

mythtv/libs/libmythtv/mythcontextui.cpp

@@ +1 @@
+#include <qdir.h>
+
+#include "backendselect.h"
+#include "dbsettings.h"
+#include "mythcontextui.h"
+
+#include "libmyth/dialogbox.h"
+#include "libmyth/langsettings.h"
+#include "libmyth/mythcontext.h"
+#include "libmyth/oldsettings.h"
+#include "libmyth/util.h"
+#include "libmythui/mythmainwindow.h"
+#include "libmythupnp/mythxmlclient.h"
+
+
+MythContextUI::MythContextUI(MythContextGUI *parent, const QString &binVersion)
+{
+    m_binVersion      = binVersion;
+    m_disableLibPopup = false;        // Only used in MythContextGui
+    m_GUI             = (bool)parent;
+    m_parent          = parent;       //  ,,   ,,  ,,       ,,
+    m_win             = NULL;         //  ,,   ,,  ,,       ,,
+
+    m_HTTP = NULL, m_UPnP = NULL, m_XML = NULL;
+
+    // Set this early, so that our Init code can use it
+    if (!gContext)
+        gContext = this;
+}
+
+MythContextUI::~MythContextUI()
+{
+    DeleteUPnP();
+};
+
+/**
+ * \brief   Try to prevent silent, automatic database upgrades
+ * \returns -1 to use the existing schema, 0 to exit, 1 to upgrade.
+ *
+ * The GUI prompts have no defaults, so that nothing dangerous
+ * will happen if the user hits return a few times.
+ * Hopefully this will force users to stop and think?
+ * Similarly, the shell command prompting requires an explicit "yes".
+ * Non-interactive shells default to old behaviour (upgrading)
+ */
+int MythContextUI::PromptForSchemaUpgrade(const QString &dbver,
+                                          const QString &current)
+{
+    bool    autoUpgrade = false;
+    bool    connections = false;  // Are (other) FE/BEs connected?
+    bool    expertMode  = false;  // Use existing schema? Multiple buttons?
+    QString message;
+    int     returnValue = MYTH_SCHEMA_UPGRADE;
+    bool    upgradable  = (dbver.toUInt() < current.toUInt());
+    QString warnOtherCl = QObject::tr("There are also other"
+                                      " clients using this database. "
+                                      "They should be shut down first.");
+
+
+    // No current DBSchemaVer? Empty database, so upgrade to create tables
+    if (dbver.isEmpty())
+    {
+        VERBOSE(VB_GENERAL, "No current database version. Auto upgrading");
+        return MYTH_SCHEMA_UPGRADE;
+    }
+
+
+    // Users and developers can choose to live dangerously,
+    // either to silently and automatically upgrade,
+    // or an expert option to allow use of existing:
+    switch (gContext->GetNumSetting("DBSchemaAutoUpgrade"))
+    {
+        case  1: autoUpgrade = true; break;
+        case -1: expertMode  = true; break;
+        default: break;
+    }
+
+
+    // FIXME: Don't know how to determine this
+    //if (getActiveConnections() > 1)
+    //    connections = true;
+
+
+    // Deal with the trivial case first (No user prompting required)
+    if (autoUpgrade && upgradable && !connections)
+        return MYTH_SCHEMA_UPGRADE;
+
+
+    // Build up strings used both in GUI and command shell contexts:
+    if (upgradable)
+    {
+        if (autoUpgrade && connections)
+        {
+            message = QObject::tr("Error: MythTV cannot upgrade the"
+                                  " schema of this datatase because"
+                                  " other clients are using it.\n\n"
+                                  "Please shut them down before upgrading.");
+            returnValue = MYTH_SCHEMA_ERROR;
+        }
+        else
+        {
+            message = QObject::tr("Warning: MythTV wants to upgrade"
+                                  " your database schema, from %1 to %2.");
+            if (expertMode)
+                message += "\n\n" +
+                           QObject::tr("You can try using the old schema,"
+                                       " but that may cause problems.");
+        }
+    }
+    else   // This client is too old
+    {
+        if (expertMode)
+            message = QObject::tr("Warning: MythTV database has newer"
+                                  " schema (%1) than expected (%2).");
+        else
+        {
+            message = QObject::tr("Error: MythTV database has newer"
+                                  " schema (%1) than expected (%2).");
+            returnValue = MYTH_SCHEMA_ERROR;
+        }
+    }
+
+    if (message.contains("%1"))
+        message = message.arg(dbver).arg(current);
+
+
+    if (m_GUI)
+    {
+        bool createdTempWindow = false;
+
+        if (!m_win)
+        {
+            m_parent->TempMainWindow();
+            createdTempWindow = true;
+        }
+
+        if (returnValue == MYTH_SCHEMA_ERROR)
+        {
+            MythPopupBox::showOkPopup(
+                m_win, "Database Upgrade Error",
+                message, QObject::tr("Exit"));
+        }
+        else
+        {
+            QStringList buttonNames;
+
+            buttonNames += QObject::tr("Exit");
+            buttonNames += QObject::tr("Upgrade");
+            if (expertMode)
+                buttonNames += QObject::tr("Use current schema");
+
+            DialogCode selected = MythPopupBox::ShowButtonPopup(
+                m_win, "Database Upgrade", message,
+                buttonNames, kDialogCodeButton0);
+
+            // The annoying extra confirmation:
+            if (kDialogCodeButton1 == selected)
+            {
+                message = QObject::tr("This cannot be un-done, so having a"
+                                      " database backup would be a good idea.");
+                if (connections)
+                    message += "\n\n" + warnOtherCl;
+
+                selected = MythPopupBox::ShowButtonPopup(
+                    m_win, "Database Upgrade", message,
+                    buttonNames, kDialogCodeButton0);
+            }
+
+            switch (selected)
+            {
+                case kDialogCodeRejected:
+                case kDialogCodeButton0:
+                    returnValue = MYTH_SCHEMA_EXIT;         break;
+                case kDialogCodeButton1:
+                    returnValue = MYTH_SCHEMA_UPGRADE;      break;
+                case kDialogCodeButton2:
+                    returnValue = MYTH_SCHEMA_USE_EXISTING; break;
+                default:
+                    returnValue = MYTH_SCHEMA_ERROR;
+            }
+        }
+
+        if (createdTempWindow)
+        {
+            m_parent->EndTempWindow();
+            RestoreDBhostname();
+        }
+
+        return returnValue;
+    }
+
+    // We are not in a GUI environment, so try to prompt the user in the shell
+
+    if (!isatty(fileno(stdin)) || !isatty(fileno(stdout)))
+    {
+        if (expertMode || !upgradable)
+        {
+            cout << "Console non-interactive. Using existing schema." << endl;
+            return MYTH_SCHEMA_USE_EXISTING;
+        }
+
+        cout << "Console is not interactive, cannot ask user about"
+             << " upgrading database schema." << endl << "Upgrading." << endl;
+        return MYTH_SCHEMA_UPGRADE;
+    }
+
+
+    QString resp;
+
+    cout << endl << message << endl << endl;
+
+    if (expertMode)
+    {
+        resp = getResponse("Would you like to use the existing schema?", "yes");
+        if (!resp || resp.left(1).lower() == "y")
+            return MYTH_SCHEMA_USE_EXISTING;
+    }
+
+    resp = getResponse("\nShall I upgrade this database?", "yes");
+    if (resp && resp.left(1).lower() != "y")
+        return MYTH_SCHEMA_EXIT;
+
+    if (connections)
+        cout << endl << warnOtherCl <<endl;
+
+    resp = getResponse("\nA database backup might be a good idea"
+                       "\nAre you sure you want to upgrade?", "no");
+    if (!resp || resp.left(1).lower() == "n")
+        return MYTH_SCHEMA_EXIT;
+
+    return MYTH_SCHEMA_UPGRADE;
+}
+
+
+
+/**
+ * Check the version passed from main.cpp with this library version.
+ */
+const QString MythContextUI::BinaryVersionError(void)
+{
+    if (m_binVersion == MYTH_BINARY_VERSION)
+        return QString::null;
+
+    QString err = "This app was compiled against libmyth version: %1"
+                  " but the library is version: %2\n"
+                  "You probably want to recompile everything,"
+                  " and do a 'make distclean' first.";
+    err = QObject::tr(err).arg(m_binVersion).arg(MYTH_BINARY_VERSION);
+
+    VERBOSE(VB_IMPORTANT, err);
+
+    return err;
+}
+
+
+/**
+ * Get database connection settings and test connectivity.
+ *
+ * Can use UPnP AutoDiscovery to locate backends, and get their DB settings.
+ * The user can force the AutoDiscovery chooser with the --prompt argument,
+ * and disable it by using the --disable-autodiscovery argument.
+ * There is also an autoconfigure function, which counts the backends,
+ * and if there is exactly one, uses it as above.
+ *
+ * Despite its name, the disable argument currently only disables the chooser.
+ * If set, autoconfigure will still be attempted in some situations.
+ */
+bool MythContextUI::FindDatabase(const bool prompt, const bool noPrompt)
+{
+    // The two bool. args actually form a Yes/Maybe/No (A tristate bool :-)
+    bool manualSelect = prompt && !noPrompt;
+
+    // In addition to the UI chooser, we can also try to autoconfigure
+    bool autoSelect = !manualSelect;
+
+    QString failure;
+
+
+    // 1. Load either mysql.txt, or use sensible "localhost" defaults:
+    LoadDatabaseSettings();
+
+
+    // 2. If the user isn't forcing up the chooser UI, look for a default
+    //    backend in config.xml, then test DB settings we've got so far:
+    if (!manualSelect)
+    {
+        // config.xml may contain a backend host UUID and PIN.
+        // If so, try to AutoDiscover UPnP server, and use its DB settings:
+
+        if (DefaultUPnP(failure))                // Probably a valid backend,
+            autoSelect = manualSelect = false;   // so disable any further UPnP
+        else
+            if (failure.length())
+                VERBOSE(VB_IMPORTANT, failure);
+
+        BackupDBhostname();
+        failure = TestDBconnection();
+        if (failure.isEmpty())
+            goto DBfound;
+        RestoreDBhostname();
+    }
+
+    VERBOSE(VB_GENERAL, "FindDatabase() - After looking up config.xml, DB now " + gDBparams.dbHostName);
+
+    // 3. Try to automatically find the single backend:
+    if (autoSelect)
+    {
+        int count = UPnPautoconf();
+
+        if (count == 0)
+            failure = "No UPnP backends found";
+
+        if (count == 1)
+        {
+            BackupDBhostname();
+            failure = TestDBconnection();
+            if (failure.isEmpty())
+                goto DBfound;
+            RestoreDBhostname();
+        }
+
+        if (count > 1 || count == -1)     // Multiple BEs, or needs PIN.
+            manualSelect = !noPrompt;     // If allowed, prompt user
+
+        VERBOSE(VB_GENERAL, "FindDatabase() - After UPnPautoconf(), DB now " + gDBparams.dbHostName);
+    }
+
+    if (!m_GUI)
+        manualSelect = false;  // no interactive command-line chooser yet
+
+
+
+    // Last, get the user to select a backend from a possible list:
+    if (manualSelect)
+    {
+        switch (ChooseBackend(QString::null))
+        {
+            case -1:    // User asked to configure database manually
+                if (PromptForDatabaseParams(""))
+                    break;
+                else
+                    goto NoDBfound;   // User cancelled - changed their mind?
+
+            case 0:   // User cancelled. Exit application
+                goto NoDBfound;
+
+            case 1:    // User selected a backend, so gDBparams
+                break; // should now contain the database details
+
+            default:
+                goto NoDBfound;
+        }
+        failure = TestDBconnection();
+        VERBOSE(VB_GENERAL, "FindDatabase() - After ChooseBackend(), DB now " + gDBparams.dbHostName);
+    }
+
+
+    // Queries the user for the DB info, using the command
+    // line or the GUI depending on the application.
+    while (failure.length())
+    {
+        VERBOSE(VB_IMPORTANT, failure);
+        if (( manualSelect && ChooseBackend(failure)) ||
+            (!manualSelect && PromptForDatabaseParams(failure)))
+        {
+            failure = TestDBconnection();
+            if (failure.length())
+                VERBOSE(VB_IMPORTANT, failure);
+        }
+        else
+            goto NoDBfound;
+    }
+
+DBfound:
+    VERBOSE(VB_GENERAL,
+            "FindDatabase() - Success! Using DB at " + gDBparams.dbHostName);
+    DeleteUPnP();
+    gContext->ResetDatabase();
+    if (!MSqlQuery::testDBConnection())
+    {
+        VERBOSE(VB_GENERAL, "FindDatabase() - After ResetDatabase(), DB now "
+                            + gDBparams.dbHostName);
+        return false;
+    }
+    DeleteUPnP();
+    return true;
+
+NoDBfound:
+    VERBOSE(VB_IMPORTANT, "FindDatabase() failed");
+    DeleteUPnP();
+    return false;
+}
+
+
+/**
+ * Check the compiled in version of a plugin against libmyth's version.
+ */
+const QString MythContextUI::PluginVersionError(const QString &name,
+                                                const QString &libversion,
+                                                const QString &pluginversion)
+{
+    if (libversion == pluginversion)
+        return QString::null;
+
+    QString err = "The " + name + " plugin was compiled against libmyth " +
+                  "version: " + pluginversion + ", but the installed " +
+                  "libmyth is at version: " + libversion + ".  You probably " +
+                  "want to recompile the " + name + " plugin after doing a " +
+                  "make distclean.";
+
+    VERBOSE(VB_IMPORTANT, err);
+
+    return err;
+}
+
+
+/**
+ * Load database and host settings from mysql.txt, or set some defaults
+ *
+ * \returns true if mysql.txt was parsed
+ */
+void MythContextUI::LoadDatabaseSettings(void)
+{
+    if (LoadSettingsFile())
+    {
+        if (gDBparams.dbHostName.isEmpty())
+        {
+            VERBOSE(VB_IMPORTANT,
+                    "DBHostName is not set in mysql.txt. Assuming localhost");
+            gDBparams.dbHostName = "localhost";
+        }
+        if (gDBparams.dbUserName.isEmpty())
+            VERBOSE(VB_IMPORTANT, "DBUserName is not set in mysql.txt");
+        if (gDBparams.dbPassword.isEmpty())
+            VERBOSE(VB_IMPORTANT, "DBPassword is not set in mysql.txt");
+        if (gDBparams.dbName.isEmpty())
+            VERBOSE(VB_IMPORTANT, "DBName is not set in mysql.txt");
+    }
+    else
+    {
+        VERBOSE(VB_GENERAL, "Unable to read configuration file mysql.txt");
+
+        gContext->DefaultDatabaseSettings();
+    }
+
+
+    QString hostname = gDBparams.localHostName;
+    if (hostname.isEmpty() || hostname == "my-unique-identifier-goes-here")
+    {
+        char localhostname[1024];
+
+        VERBOSE(VB_IMPORTANT, "Empty LocalHostName.");
+        if (gethostname(localhostname, 1024))
+        {
+            VERBOSE(VB_IMPORTANT,
+                    "LoadDBSettings() - could not determine host name." + ENO);
+            hostname = "localhost";
+        }
+        else
+            hostname = localhostname;
+    }
+
+    VERBOSE(VB_GENERAL, QString("Using localhost value of %1").arg(hostname));
+
+    gContext->SetHostName(hostname);
+}
+
+
+/**
+ * Load mysql.txt and parse its values into m_DBparams
+ */
+bool MythContextUI::LoadSettingsFile(void)
+{
+    Settings s;
+
+    if (!s.LoadSettingsFiles("mysql.txt", gContext->GetInstallPrefix()))
+        return false;
+    gDBparams.dbHostName    = s.GetSetting("DBHostName");
+    gDBparams.dbHostPing    = s.GetSetting("DBHostPing") != "no";
+    gDBparams.dbPort        = s.GetNumSetting("DBPort");
+    gDBparams.dbUserName    = s.GetSetting("DBUserName");
+    gDBparams.dbPassword    = s.GetSetting("DBPassword");
+    gDBparams.dbName        = s.GetSetting("DBName");
+    gDBparams.dbType        = s.GetSetting("DBType");
+
+    gDBparams.localHostName = s.GetSetting("LocalHostName");
+    gDBparams.localEnabled  = gDBparams.localHostName.length() > 0;
+
+    gDBparams.wolReconnect  = s.GetNumSetting("WOLsqlReconnectWaitTime");
+    gDBparams.wolEnabled    = gDBparams.wolReconnect > 0;
+
+    gDBparams.wolRetry      = s.GetNumSetting("WOLsqlConnectRetry");
+    gDBparams.wolCommand    = s.GetSetting("WOLsqlCommand");
+
+    return true;
+}
+
+
+/**
+ * Ask the user for DB host, user/password, port, et c.
+ *
+ * Since this is pure UI code, it should be moved into the parents?
+ */
+bool MythContextUI::PromptForDatabaseParams(const QString &error)
+{
+    bool accepted = false;
+    if (m_GUI)
+    {
+        BackupDBhostname();
+        m_parent->TempMainWindow();
+
+        // Tell the user what went wrong:
+        if (error.length())
+            MythPopupBox::showOkPopup(m_win, "DB connect failure", error);
+
+        // ask user for database parameters
+        DatabaseSettings settings(m_DBhostCp);
+        accepted = (settings.exec() == QDialog::Accepted);
+        if (!accepted)
+            VERBOSE(VB_IMPORTANT, "User cancelled database configuration");
+
+        m_parent->EndTempWindow();
+        RestoreDBhostname();
+    }
+    else
+    {
+        DatabaseParams params = gDBparams;
+        QString        response;
+
+        // give user chance to skip config
+        cout << endl << error << endl << endl;
+        response = getResponse("Would you like to configure the database "
+                               "connection now?",
+                               "yes");
+        if (!response || response.left(1).lower() != "y")
+            return false;
+
+        params.dbHostName = getResponse("Database host name:",
+                                        params.dbHostName);
+        response = getResponse("Should I test connectivity to this host "
+                               "using the ping command?", "yes");
+        params.dbHostPing = (!response || response.left(1).lower() != "y");
+
+        params.dbPort     = intResponse("Database non-default port:",
+                                        params.dbPort);
+        params.dbName     = getResponse("Database name:",
+                                        params.dbName);
+        params.dbUserName = getResponse("Database user name:",
+                                        params.dbUserName);
+        params.dbPassword = getResponse("Database password:",
+                                        params.dbPassword);
+
+        params.localHostName = getResponse("Unique identifier for this machine "
+                                           "(if empty, the local host name "
+                                           "will be used):",
+                                           params.localHostName);
+        params.localEnabled = !params.localHostName.isEmpty();
+
+        response = getResponse("Would you like to use Wake-On-LAN to retry "
+                               "database connections?",
+                               (params.wolEnabled ? "yes" : "no"));
+        if (response)
+            params.wolEnabled  = (response.left(1).lower() == "y");
+
+        if (params.wolEnabled)
+        {
+            params.wolReconnect = intResponse("Seconds to wait for "
+                                              "reconnection:",
+                                              params.wolReconnect);
+            params.wolRetry     = intResponse("Number of times to retry:",
+                                              params.wolRetry);
+            params.wolCommand   = getResponse("Command to use to wake server:",
+                                              params.wolCommand);
+        }
+
+        accepted = gContext->SaveDatabaseParams(params);
+    }
+    return accepted;
+}
+
+
+/**
+ * If the program doesn't provide a UPnP client, we setup one here
+ */
+bool MythContextUI::InitUPnP(void)
+{
+    if (m_UPnP)
+        return true;
+
+    VERBOSE(VB_UPNP, "Setting UPnP client for backend autodiscovery...");
+
+    if (!m_XML)
+        m_XML = new XmlConfiguration("");   // No file - use defaults only
+
+    m_UPnP = new UPnp();
+    m_UPnP->SetConfiguration(m_XML);
+
+    int port=6549;
+    m_HTTP = new HttpServer(port);
+
+    if (!m_HTTP->ok())
+    {
+        VERBOSE(VB_IMPORTANT, "MCP::InitUPnP() - HttpServer Create Error");
+        DeleteUPnP();
+        return false;
+    }
+
+    if (!m_UPnP->Initialize(port, m_HTTP))
+    {
+        VERBOSE(VB_IMPORTANT, "MCP::InitUPnP() - UPnp::Initialize() Error");
+        DeleteUPnP();
+        return false;
+    }
+
+    // Create a dummy device description
+    UPnpDevice   &device = UPnp::g_UPnpDeviceDesc.m_rootDevice;
+    device.m_sDeviceType = "urn:schemas-upnp-org:device:MythContextClient:1";
+
+    m_UPnP->Start();
+
+    return true;
+}
+
+
+/**
+ * Delete the local client to allow some other code to create another one
+ */
+void MythContextUI::DeleteUPnP(void)
+{
+    if (m_UPnP && !m_HTTP)  // Init was passed an existing UPnP
+        return;             // so let the caller delete it cleanly
+
+    if (m_UPnP)
+    {
+        // This takes a few seconds, so inform the user:
+        VERBOSE(VB_GENERAL, "Deleting UPnP client...");
+
+        delete m_UPnP;  // This also deletes m_XML
+        m_UPnP = NULL;
+        m_XML  = NULL;
+    }
+
+    if (m_HTTP)
+    {
+        delete m_HTTP;
+        m_HTTP = NULL;
+    }
+}
+
+
+/**
+ * Search for backends via UPnP, put up a UI for the user to choose one
+ */
+int MythContextUI::ChooseBackend(const QString &error)
+{
+    if (!InitUPnP())
+        return -1;
+
+    BackupDBhostname();
+    m_parent->TempMainWindow(false);
+
+    // Tell the user what went wrong:
+    if (error.length())
+        MythPopupBox::showOkPopup(m_win, "DB connect failure", error);
+
+    VERBOSE(VB_GENERAL, "Putting up the UPnP backend chooser");
+
+    BackendSelect *BEsel = new BackendSelect(m_win, &gDBparams);
+    switch (BEsel->exec())
+    {
+        case kDialogCodeRejected:
+            VERBOSE(VB_IMPORTANT, "User canceled database configuration");
+            return 0;
+
+        case kDialogCodeButton0:
+            VERBOSE(VB_IMPORTANT, "User requested Manual Config");
+            RestoreDBhostname();
+            return -1;
+    }
+    //BEsel->hide();
+    //BEsel->deleteLater();
+
+    QStringList buttons;
+    QString     message;
+
+    buttons += QObject::tr("Save database details");
+    buttons += QObject::tr("Save backend details");
+    buttons += QObject::tr("Don't Save");
+
+    message = QObject::tr("Save that backend or database as the default?");
+
+    DialogCode selected = MythPopupBox::ShowButtonPopup(m_win, "Save default",
+        message, buttons, kDialogCodeButton2);
+    switch (selected)
+    {
+        case kDialogCodeButton0:
+            gContext->SaveDatabaseParams(gDBparams);
+            // User prefers mysql.txt, so throw away UPnP backend details:
+            m_XML->SetValue(UPnp::kDefaultUSN, "");
+            m_XML->Save();
+            break;
+        case kDialogCodeButton1:
+            if (BEsel->m_PIN.length())
+                m_XML->SetValue(UPnp::kDefaultPIN, BEsel->m_PIN);
+            m_XML->SetValue(UPnp::kDefaultUSN, BEsel->m_USN);
+            m_XML->Save();
+            break;
+    }
+
+    delete BEsel;
+    m_parent->EndTempWindow();
+
+    return 1;
+}
+
+
+/**
+ * If there is only a single UPnP backend, use it.
+ *
+ * This does <i>not</i> prompt for PIN entry. If the backend requires one,
+ * it will fail, and the caller needs to put up a UI to ask for one.
+ */
+int MythContextUI::UPnPautoconf(const int milliSeconds)
+{
+    if (!InitUPnP())
+        return 0;
+
+    SSDPCacheEntries *backends = NULL;
+    int               count;
+    QString           LOC = "UPnPautoconf() - ";
+    QTime             timer;
+
+    m_UPnP->PerformSearch(UPnp::kBackendURI);
+    for (timer.start(); timer.elapsed() < milliSeconds; usleep(25000))
+    {
+        backends = m_UPnP->g_SSDPCache.Find(UPnp::kBackendURI);
+        if (backends)
+        {
+            backends->AddRef();
+            break;
+        }
+        putchar('.');
+    }
+    putchar('\n');
+
+    if (!backends)
+    {
+        VERBOSE(VB_GENERAL, LOC + "No UPnP backends found");
+        return 0;
+    }
+
+
+    // This could be tied to VB_UPNP?
+    //m_UPnP->g_SSDPCache.Dump();
+
+
+    count = backends->Count();
+    switch (count)
+    {
+        case 0:
+            VERBOSE(VB_IMPORTANT,
+                    LOC + "No UPnP backends found, but SSDP::Find() not NULL!");
+            break;
+        case 1:
+            VERBOSE(VB_GENERAL, LOC + "Found one UPnP backend");
+            break;
+        default:
+            VERBOSE(VB_GENERAL,
+                    (LOC + "More than one UPnP backend found (%1)").arg(count));
+    }
+
+    if (count != 1)
+    {
+        backends->Release();
+        return count;
+    }
+
+
+    // Get this backend's location:
+    backends->Lock();
+    DeviceLocation *BE = backends->GetEntryMap()->begin().data();
+    backends->Unlock();
+    backends->Release();
+
+    // We don't actually know the backend's access PIN, so this will
+    // only work for ones that have PIN access disabled (i.e. 0000)
+    if (UPnPconnect(BE, QString::null))
+        return 1;
+    return -1;   // Try to force chooser & PIN
+}
+
+
+/**
+ * Get the default backend from config.xml, use UPnP to find it.
+ *
+ * Sets a string if there any connection problems
+ */
+bool MythContextUI::DefaultUPnP(QString &error)
+{
+    XmlConfiguration *XML = new XmlConfiguration("config.xml");
+    QString           loc = "MCP::DefaultUPnP() - ";
+    QString           PIN = XML->GetValue(UPnp::kDefaultPIN, "");
+    QString           USN = XML->GetValue(UPnp::kDefaultUSN, "");
+
+    delete XML;
+
+    if (USN.isEmpty())
+    {
+        VERBOSE(VB_UPNP, loc + "No default UPnP backend");
+        return false;
+    }
+
+    VERBOSE(VB_UPNP, loc + "config.xml has default " +
+            QString("PIN '%1' and host USN: %2")
+            .arg(PIN).arg(USN));
+
+    if (!InitUPnP())
+    {
+        error = "UPnP is broken?";
+        return false;
+    }
+
+    m_UPnP->PerformSearch(UPnp::kBackendURI);
+    DeviceLocation *pDevLoc = m_UPnP->g_SSDPCache.Find(UPnp::kBackendURI, USN);
+    if (!pDevLoc)
+    {
+        error = "Cannot find default UPnP backend";
+        return false;
+
+    }
+
+    if (UPnPconnect(pDevLoc, PIN))
+        return true;
+
+    error = "Cannot connect to default backend via UPnP. Wrong saved PIN?";
+    return false;
+}
+
+
+/**
+ * Query a backend via UPnP for its database connection parameters
+ */
+bool MythContextUI::UPnPconnect(const DeviceLocation *backend,
+                                       const QString        &PIN)
+{
+    QString        error;
+    QString        LOC = "UPnPconnect() - ";
+    QString        URL = backend->m_sLocation;
+    MythXMLClient  XML(URL);
+
+    VERBOSE(VB_UPNP, LOC + QString("Trying host at %1").arg(URL));
+    switch (XML.GetConnectionInfo(PIN, &gDBparams, error))
+    {
+        case UPnPResult_Success:
+            break;
+
+        case UPnPResult_ActionNotAuthorized:
+            // The stored PIN is probably not correct.
+            // We could prompt for the PIN and try again, but that needs a UI.
+            // Easier to fail for now, and put up the full UI selector later
+            VERBOSE(VB_UPNP, LOC + error + ". Wrong PIN?");
+            return false;
+
+        default:
+            VERBOSE(VB_UPNP, LOC + error);
+            return false;
+    }
+
+    VERBOSE(VB_UPNP, LOC + "Got database hostname: " + gDBparams.dbHostName);
+
+    return true;
+}
+
+
+/**
+ * Some quick sanity checks before opening a database connection
+ */
+QString MythContextUI::TestDBconnection(void)
+{
+    BackupDBhostname();
+    return gContext->TestDBconnection();
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// 2 sub-classes of MythContext that differ only in whether they support a GUI
+//////////////////////////////////////////////////////////////////////////////
+
+MythContextGUI::MythContextGUI(const QString &binVersion) 
+              : MythContextUI(this, binVersion) {}
+
+MythContextTTY::MythContextTTY(const QString &binVersion) 
+              : MythContextUI(NULL, binVersion) {}
+
+MythContextGUI::~MythContextGUI(void) {}
+
+MythContextTTY::~MythContextTTY(void) {}
+
+bool MythContextGUI::Init(UPnp *UPnPclient,
+                          const bool promptForBackend, const bool noPrompt)
+{
+    if (UPnPclient)
+    {
+        m_UPnP = UPnPclient;
+        m_XML  = (XmlConfiguration *)UPnp::g_pConfig;
+    }
+
+    QString mismatch = BinaryVersionError();
+    if (mismatch.length())
+    {
+        MythPopupBox::showOkPopup(TempMainWindow(true),
+                                  "Library version error", mismatch);
+        EndTempWindow();
+        return false;
+    }
+
+    if (!FindDatabase(promptForBackend, noPrompt))
+        return false;
+
+    return gContext->Init(true);
+}
+
+bool MythContextTTY::Init(UPnp *UPnPclient)
+{
+    if (UPnPclient)
+    {
+        m_UPnP = UPnPclient;
+        m_XML  = (XmlConfiguration *)UPnp::g_pConfig;
+    }
+
+    if (BinaryVersionError().length())
+        return false;
+
+    if (!FindDatabase())
+        return false;
+
+    return gContext->Init(false);
+}
+
+
+MythMainWindow * MythContextGUI::CreateMainWindow(void)
+{
+    LoadQtConfig();
+
+    m_win = GetMythMainWindow();
+    m_win->Init();
+    SetMainWindow(m_win);
+
+    return m_win;
+}
+
+/**
+ * \brief Setup a minimal themed main window, and prompt for user's language.
+ *
+ * Used for warnings before the database is opened, or bootstrapping pages.
+ * After using the window, call EndTempWindow().
+ *
+ * \bug   Some of these settings (<i>e.g.</I> window size, theme)
+ *        seem to be used after the temp window is destroyed.
+ *
+ * \bug   The default theme here is blue, but as of [12377],
+ *        G.A.N.T is now meant to be the default?
+ *        A simple change to make, but Nigel prefers
+ *        "blue" for these initial screens and popups
+ */
+MythMainWindow * MythContextGUI::TempMainWindow(bool languagePrompt)
+{
+    if (m_win)
+        return m_win;
+
+    // We clear the hostname so MSqlQuery will fail, instead of long
+    // timeouts per DB value, or hundreds of lines of DB connect errors.
+    // We save the value for later possible editing in the DbSettings pages
+    if (gDBparams.dbHostName.length())
+    {
+        m_DBhostCp = gDBparams.dbHostName;
+        gDBparams.dbHostName = "";
+    }
+
+    gContext->SetSetting("Theme", "blue");
+#ifdef Q_WS_MACX
+    // Myth looks horrible in default Mac style for Qt
+    gContext->SetSetting("Style", "Windows");
+#endif
+    gContext->LoadQtConfig();
+
+    m_win = MythMainWindow::getMainWindow(false);
+    m_win->Init();
+    SetMainWindow(m_win);
+
+    if (languagePrompt)
+    {
+        // ask user for language settings
+        LanguageSettings::prompt();
+        LanguageSettings::load("mythfrontend");
+    }
+
+    return m_win;
+}
+
+void MythContextGUI::EndTempWindow(void)
+{
+    m_win = NULL;
+    SetMainWindow(NULL);
+    DestroyMythMainWindow();
+}
+
+bool MythContextGUI::TestPopupVersion(const QString &pluginName,
+                                      const QString &libMythVersion,
+                                      const QString &pluginVersion)
+{
+    QString warning = PluginVersionError(pluginName,
+                                         libMythVersion, pluginVersion);
+    if (warning.length())
+    {
+        if (!m_win)
+            m_parent->TempMainWindow(true);
+
+        warning = QObject::tr(warning);
+
+        if (m_win && !m_disableLibPopup)
+        {
+            DialogBox *dlg = new DialogBox(m_win, warning);
+            dlg->AddButton("OK");
+            dlg->exec();
+            dlg->deleteLater();
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+
+QString getResponse(const QString &query, const QString &def)
+{
+    cout << query;
+
+    if (def != "")
+        cout << " [" << def << "]  ";
+    else
+        cout << "  ";
+
+    if (!isatty(fileno(stdin)) || !isatty(fileno(stdout)))
+    {
+        cout << endl << "[console is not interactive, using default '"
+             << def  << "']" << endl;
+        return def;
+    }
+
+    char response[80];
+    cin.clear();
+    cin.getline(response, 80);
+    if (!cin.good())
+    {
+        cout << endl;
+        VERBOSE(VB_IMPORTANT, "Read from stdin failed");
+        return NULL;
+    }
+
+    QString qresponse = response;
+
+    if (qresponse == "")
+        qresponse = def;
+
+    return qresponse;
+}
+
+int intResponse(const QString &query, const int def)
+{
+    QString str_resp = getResponse(query, QString("%1").arg(def));
+    if (!str_resp)
+        return false;
+    bool ok;
+    int resp = str_resp.toInt(&ok);
+    return (ok ? resp : def);
+}

mythtv/libs/libmythtv/backendselect.cpp

@@ +1 @@
+/**
+ * \class BackendSelect
+ * \desc  Classes to Prompt user for a master backend.
+ *
+ * \author Originally based on masterselection.cpp/h by David Blain.
+ */
+
+#include "backendselect.h"
+
+#include "libmyth/mythdialogs.h"
+#include "libmythupnp/mythxmlclient.h"
+#include "libmythupnp/upnp.h"
+
+
+BackendSelect::BackendSelect(MythMainWindow *parent, DatabaseParams *params)
+             : MythDialog(parent, "BackEnd Selection", TRUE)
+{
+    m_parent   = parent;
+    m_DBparams = params;
+puts("Creating a backendSelect");
+    CreateUI();
+
+    UPnp::AddListener(this);
+
+    //Search();
+    FillListBox();
+
+    m_backends->setFocus();
+}
+
+BackendSelect::~BackendSelect()
+{
+    UPnp::RemoveListener(this);
+
+    ItemMap::iterator it;
+    for (it = m_devices.begin(); it != m_devices.end(); ++it)
+    {
+        ListBoxDevice *item = it.data();
+
+        if (item != NULL)
+            delete item;
+    }
+
+    m_devices.clear();
+}
+
+void BackendSelect::Accept(void)
+{
+    DeviceLocation *dev;
+    QListBoxItem   *selected = m_backends->selectedItem();
+
+    if (!selected)
+        return;
+
+    dev = ((ListBoxDevice *)selected)->m_dev;
+
+    if (!dev)
+        reject();
+
+    dev->AddRef();
+    if (Connect(dev))
+        accept();
+}
+
+void BackendSelect::AddItem(DeviceLocation *dev)
+{
+    if (!dev)
+        return;
+
+    QString USN = dev->m_sUSN;
+
+    // The devices' USN should be unique. Don't add if it is already there:
+    if (m_devices.find(USN) == m_devices.end())
+    {
+        ListBoxDevice *item;
+        QString        name;
+
+        if (print_verbose_messages & VB_UPNP)
+            name = dev->GetNameAndDetails(true);
+        else
+            name = dev->GetFriendlyName(true);
+
+        item = new ListBoxDevice(m_backends, name, dev);
+        m_devices.insert(USN, item);
+
+        // Pre-select at least one item:
+        if (m_backends->numRows() == 1)
+            m_backends->setSelected(0, true);
+    }
+
+    dev->Release();
+}
+
+/**
+ * Attempt UPnP connection to a backend device, get its DB details.
+ * Will loop until a valid PIN is entered.
+ */
+bool BackendSelect::Connect(DeviceLocation *dev)
+{
+    QString          error;
+    QString          message;
+    UPnPResultCode   stat;
+    MythXMLClient   *xml;
+
+    m_USN = dev->m_sUSN;
+    xml   = new MythXMLClient(dev->m_sLocation);
+    stat  = xml->GetConnectionInfo(m_PIN, m_DBparams, message);
+    error = dev->GetFriendlyName(true);
+    if (error == "<Unknown>")
+        error = dev->m_sLocation;
+    error += ". " + message;
+    dev->Release();
+
+    switch (stat)
+    {
+        case UPnPResult_Success:
+            VERBOSE(VB_UPNP, "Connect() - success. New hostname: "
+                             + m_DBparams->dbHostName);
+            return true;
+
+        case UPnPResult_HumanInterventionRequired:
+            VERBOSE(VB_UPNP, error);
+            MythPopupBox::showOkPopup(m_parent, "", QObject::tr(message));
+            break;
+
+        case UPnPResult_ActionNotAuthorized:
+            VERBOSE(VB_UPNP, "Access denied for " + error + ". Wrong PIN?");
+            message = "Please enter the backend access PIN";
+            do
+            {
+                m_PIN = MythPopupBox::showPasswordPopup(
+                    m_parent, "Backend PIN entry", QObject::tr(message));
+                stat = xml->GetConnectionInfo(m_PIN, m_DBparams, message);
+            }
+            while (stat == UPnPResult_ActionNotAuthorized);
+            if (stat == UPnPResult_Success)
+                return true;
+
+        default:
+            VERBOSE(VB_UPNP, "GetConnectionInfo() failed for " + error);
+            MythPopupBox::showOkPopup(m_parent, "", QObject::tr(message));
+    }
+
+    // Back to the list, so the user can choose a different backend:
+    m_backends->setFocus();
+    return false;
+}
+
+void BackendSelect::CreateUI(void)
+{
+    // Probably should all be members, and deleted by ~BackendSelect()
+    QLabel         *label;
+    QGridLayout    *layout;
+    MythPushButton *cancel;
+    MythPushButton *manual;
+    MythPushButton *OK;
+    //MythPushButton *search;   // I don't see the need for this?
+
+
+    label = new QLabel(QObject::tr("Please select default Myth Backend Server"), this);
+    label->setBackgroundOrigin(QWidget::WindowOrigin);
+
+    m_backends = new MythListBox(this);
+    OK         = new MythPushButton(QObject::tr("OK"), this);
+    cancel     = new MythPushButton(QObject::tr("Cancel"), this);
+    manual     = new MythPushButton(QObject::tr("Configure Manually"), this);
+    //search     = new MythPushButton(QObject::tr("Search"), this);
+
+
+    layout = new QGridLayout(this, 5, 5, 40);
+    layout->addMultiCellWidget(label, 0, 0, 1, 3);
+    layout->addMultiCellWidget(m_backends, 1, 1, 0, 4);
+
+    layout->addMultiCellWidget(manual, 4, 4, 0, 1);
+    //layout->addWidget(search, 4, 0);
+    //layout->addWidget(manual, 4, 1);
+    layout->addWidget(cancel, 4, 3);
+    layout->addWidget(OK    , 4, 4);
+
+
+    connect(m_backends, SIGNAL(accepted(int)), SLOT(Accept()));
+    //connect(search,     SIGNAL(clicked()),     SLOT(Search()));
+    connect(manual,     SIGNAL(clicked()),     SLOT(Manual()));
+    connect(cancel,     SIGNAL(clicked()),     SLOT(reject()));
+    connect(OK,         SIGNAL(clicked()),     SLOT(Accept()));
+}
+
+void BackendSelect::customEvent(QCustomEvent *e)
+{
+    if (MythEvent::MythEventMessage != ((MythEvent::Type)(e->type())))
+        return;
+
+
+    MythEvent *me      = (MythEvent *)e;
+    QString    message = me->Message();
+    QString    URI     = me->ExtraData(0);
+    QString    URN     = me->ExtraData(1);
+    QString    URL     = me->ExtraData(2);
+
+
+    VERBOSE(VB_UPNP, "BackendSelect::customEvent(" + message
+                     + ", " + URI + ", " + URN + ", " + URL + ")");
+
+    if (message.startsWith("SSDP_ADD") &&
+        URI.startsWith("urn:schemas-mythtv-org:device:MasterMediaServer:"))
+    {
+        DeviceLocation *devLoc = UPnp::g_SSDPCache.Find(URI, URN);
+
+        if (devLoc != NULL)
+        {
+            devLoc->AddRef();
+            AddItem(devLoc);
+        }
+        else
+            VERBOSE(VB_UPNP, "Can't add host - not in SSDP cache?");
+    }
+    else if (message.startsWith("SSDP_REMOVE"))
+    {
+        //-=>Note: This code will never get executed until
+        //         SSDPCache is changed to handle NotifyRemove correctly
+        RemoveItem(URN);
+    }
+}
+
+void BackendSelect::FillListBox(void)
+{
+    EntryMap::Iterator  it;
+    EntryMap            ourMap;
+    DeviceLocation     *pDevLoc;
+    
+
+    SSDPCacheEntries *pEntries = UPnp::g_SSDPCache.Find(UPnp::kBackendURI);
+
+    if (!pEntries)
+        return;
+
+    pEntries->AddRef();
+    pEntries->Lock();
+
+    EntryMap *pMap = pEntries->GetEntryMap();
+
+    for (it = pMap->begin(); it != pMap->end(); ++it)
+    {
+        pDevLoc = (DeviceLocation *)it.data();
+
+        if (!pDevLoc)
+            continue;
+
+        pDevLoc->AddRef();
+        ourMap.insert(pDevLoc->m_sUSN, pDevLoc);
+    }
+
+
+    pEntries->Unlock();
+    pEntries->Release();
+
+    for (it = ourMap.begin(); it != ourMap.end(); ++it)
+    {
+        pDevLoc = (DeviceLocation *)it.data();
+        AddItem(pDevLoc);
+        pDevLoc->Release();
+    }
+}
+
+void BackendSelect::Manual(void)
+{
+    done(kDialogCodeButton0);
+}
+
+void BackendSelect::RemoveItem(QString USN)
+{
+    ItemMap::iterator it = m_devices.find(USN);
+
+    if (it != m_devices.end())
+    {
+        ListBoxDevice *item = it.data();
+
+        if (item != NULL)
+            delete item;
+
+        m_devices.remove(it);
+    }
+}
+
+void BackendSelect::Search(void)
+{
+    UPnp::PerformSearch(UPnp::kBackendURI);
+}

mythtv/libs/libmythui/mythmainwindow.cpp

@@ -226 +226 @@
  *        If this is a temporary window, which is used to bootstrap
  *        the database, passing false prevents any database access.
  *
- * \sa    MythContextPrivate::TempMainWindow()
+ * \sa    MythContextGUI::TempMainWindow()
  */
 MythMainWindow *MythMainWindow::getMainWindow(const bool useDB)
 {

mythtv/libs/libmyth/mythdialogs.cpp

@@ -75 +75 @@
         gContext->ThemeWidget(this);
     }
 
-    parent->attach(this);
+    gContext->attachToWin(this);
     m_parent = parent;
 }
 
@@ -95 +95 @@
 {
     if (m_parent)
     {
-        m_parent->detach(this);
+        gContext->detachFromWin(this);
         m_parent = NULL;
     }
 }
@@ -214 +214 @@
     bool handled = false;
     QStringList actions;
 
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -509 +509 @@
 {
     bool handled = false;
     QStringList actions;
-    gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions);
+    gContext->TranslateKeyPress("qt", e, actions);
     for (unsigned int i = 0; i < actions.size() && !handled; i++)
     {
         QString action = actions[i];
@@ -890 +890 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -1708 +1708 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -1770 +1770 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -1990 +1990 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -2254 +2254 @@
     m_showRtArrow  = false;
     m_showLtArrow  = false;
     
-    m_parent->attach(this);
+    gContext->attachToWin(this);
 }
 
 MythScrollDialog::~MythScrollDialog()
 {
-    m_parent->detach(this);
+    gContext->detachFromWin(this);
     delete m_bgPixmap;
 
     if (m_upArrowPix)
@@ -2370 +2370 @@
     bool handled = false;
     QStringList actions;
 
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/dbsettings.cpp

@@ -1 @@
-#include "mythcontext.h"
-#include "mythdbcon.h"
-#include "dbsettings.h"
-#include <qfile.h>
-#include <qdir.h>
-
-class MythDbSettings1: public VerticalConfigurationGroup {
-public:
-    MythDbSettings1(const QString &DBhostOverride = QString::null);
-
-    void load();
-    void save();
-
-protected:
-    TransLabelSetting    *info;
-    TransLineEditSetting *dbHostName;
-    TransCheckBoxSetting *dbHostPing;
-    TransLineEditSetting *dbPort;
-    TransLineEditSetting *dbName;
-    TransLineEditSetting *dbUserName;
-    TransLineEditSetting *dbPassword;
-    TransComboBoxSetting *dbType;
-
-    QString              m_DBhostOverride;
-}; 
-
-class MythDbSettings2: public VerticalConfigurationGroup {
-public:
-    MythDbSettings2();
-
-    void load();
-    void save();
-
-protected:
-    TransCheckBoxSetting *localEnabled;
-    TransLineEditSetting *localHostName;
-    TransCheckBoxSetting *wolEnabled;
-    TransSpinBoxSetting  *wolReconnect;
-    TransSpinBoxSetting  *wolRetry;
-    TransLineEditSetting *wolCommand;
-}; 
-
-
-
-class LocalHostNameSettings : public TriggeredConfigurationGroup
-{
-  public:
-    LocalHostNameSettings(Setting *checkbox, ConfigurationGroup *group) :
-        TriggeredConfigurationGroup(false, false, false, false)
-    {
-        setLabel(QObject::tr("Use custom identifier for frontend preferences"));
-        addChild(checkbox);
-        setTrigger(checkbox);
-
-        addTarget("1", group);
-        addTarget("0", new VerticalConfigurationGroup(true));
-    }
-};
-
-class WOLsqlSettings : public TriggeredConfigurationGroup
-{
-  public:
-    WOLsqlSettings(Setting *checkbox, ConfigurationGroup *group) :
-        TriggeredConfigurationGroup(false, false, false, false)
-    {
-        setLabel(QObject::tr("Backend Server Wakeup settings"));
-
-        addChild(checkbox);
-        setTrigger(checkbox);
-
-        addTarget("1", group);
-        addTarget("0", new VerticalConfigurationGroup(true));
-    }
-};
-
-MythDbSettings1::MythDbSettings1(const QString &DbHostOverride) :
-    VerticalConfigurationGroup(false, true, false, false)
-{
-    m_DBhostOverride = DbHostOverride;
-
-    setLabel(QObject::tr("Database Configuration") + " 1/2");
-
-    info = new TransLabelSetting();
-
-    MSqlQuery query(MSqlQuery::InitCon());
-    if (query.isConnected())
-        info->setValue(QObject::tr("All database settings take effect when "
-                                   "you restart this program."));
-    else
-        info->setValue(QObject::tr("Myth could not connect to the database. "
-                                   "Please verify your database settings "
-                                   "below."));
-    addChild(info);
-
-    VerticalConfigurationGroup* dbServer = new VerticalConfigurationGroup();
-    dbServer->setLabel(QObject::tr("Database Server Settings"));
-    dbHostName = new TransLineEditSetting(true);
-    dbHostName->setLabel(QObject::tr("Hostname"));
-    dbHostName->setHelpText(QObject::tr("The host name or IP address of "
-                                        "the machine hosting the database. "
-                                        "This information is required."));
-    dbServer->addChild(dbHostName);
-
-    HorizontalConfigurationGroup* g =
-        new HorizontalConfigurationGroup(false, false);
-
-    dbHostPing = new TransCheckBoxSetting();
-    dbHostPing->setLabel(QObject::tr("Ping test server?"));
-    dbHostPing->setHelpText(QObject::tr("Test basic host connectivity using "
-                                        "the ping command. Turn off if your "
-                                        "host or network don't support ping "
-                                        "(ICMP ECHO) packets"));
-    g->addChild(dbHostPing);
-
-    // Some extra horizontal space:
-    TransLabelSetting *l = new TransLabelSetting();
-    l->setValue("                               ");
-    g->addChild(l);
-
-    dbServer->addChild(g);
-
-    dbPort = new TransLineEditSetting(true);
-    dbPort->setLabel(QObject::tr("Port"));
-    dbPort->setHelpText(QObject::tr("The port number the database is running "
-                                    "on.  Leave blank if using the default "
-                                    "port (3306)."));
-    g->addChild(dbPort);
-
-    dbName = new TransLineEditSetting(true);
-    dbName->setLabel(QObject::tr("Database name"));
-    dbName->setHelpText(QObject::tr("The name of the database. "
-                                    "This information is required."));
-    dbServer->addChild(dbName);
-
-    dbUserName = new TransLineEditSetting(true);
-    dbUserName->setLabel(QObject::tr("User"));
-    dbUserName->setHelpText(QObject::tr("The user name to use while "
-                                        "connecting to the database. "
-                                        "This information is required."));
-    dbServer->addChild(dbUserName);
-
-    dbPassword = new TransLineEditSetting(true);
-    dbPassword->setLabel(QObject::tr("Password"));
-    dbPassword->setHelpText(QObject::tr("The password to use while "
-                                        "connecting to the database. "
-                                        "This information is required."));
-    dbServer->addChild(dbPassword);
-
-    dbType = new TransComboBoxSetting(false);
-    dbType->setLabel(QObject::tr("Database type"));
-    dbType->addSelection(QObject::tr("MySQL"), "QMYSQL3");
-    dbType->setValue(0);
-    dbType->setHelpText(QObject::tr("The database implementation used "
-                                    "for your server."));
-    dbType->setEnabled(false);
-    //dbServer->addChild(dbType);
-
-    addChild(dbServer);
-
-}
-
-MythDbSettings2::MythDbSettings2(void) :
-    VerticalConfigurationGroup(false, true, false, false)
-{
-    setLabel(QObject::tr("Database Configuration") + " 2/2");
-
-    localEnabled = new TransCheckBoxSetting();
-    localEnabled->setLabel(QObject::tr("Use custom identifier for frontend "
-                                       "preferences"));
-    localEnabled->setHelpText(QObject::tr("If this frontend's host name "
-                                          "changes often, check this box "
-                                          "and provide a network-unique "
-                                          "name to identify it. "
-                                          "If unchecked, the frontend "
-                                          "machine's local host name will "
-                                          "be used to save preferences in "
-                                          "the database."));
-
-    localHostName = new TransLineEditSetting(true);
-    localHostName->setLabel(QObject::tr("Custom identifier"));
-    localHostName->setHelpText(QObject::tr("An identifier to use while "
-                                           "saving the settings for this "
-                                           "frontend."));
-
-    VerticalConfigurationGroup *group1 =
-        new VerticalConfigurationGroup(false);
-    group1->addChild(localHostName);
-
-    LocalHostNameSettings *sub3 =
-        new LocalHostNameSettings(localEnabled, group1);
-    addChild(sub3);
-
-    wolEnabled = new TransCheckBoxSetting();
-    wolEnabled->setLabel(QObject::tr("Enable Database Server Wakeup"));
-    wolEnabled->setHelpText(QObject::tr("If checked, the frontend will use "
-                                        "database wakeup parameters to "
-                                        "reconnect to the database server."));
-
-    wolReconnect = new TransSpinBoxSetting(0, 60, 1, true);
-    wolReconnect->setLabel(QObject::tr("Reconnect time"));
-    wolReconnect->setHelpText(QObject::tr("The time in seconds to wait for "
-                                          "the server to wake up."));
-
-    wolRetry = new TransSpinBoxSetting(1, 10, 1, true);
-    wolRetry->setLabel(QObject::tr("Retry attempts"));
-    wolRetry->setHelpText(QObject::tr("The number of retries to wake the "
-                                      "server before the frontend gives "
-                                      "up."));
-
-    wolCommand = new TransLineEditSetting(true);
-    wolCommand->setLabel(QObject::tr("Wake command"));
-    wolCommand->setHelpText(QObject::tr("The command executed on this "
-                                        "frontend to wake up the database "
-                                        "server (eg. sudo /etc/init.d/mysql "
-                                        "restart)."));
-
-    HorizontalConfigurationGroup *group2 =
-        new HorizontalConfigurationGroup(false, false);
-    group2->addChild(wolReconnect);
-    group2->addChild(wolRetry);
-
-    VerticalConfigurationGroup *group3 =
-        new VerticalConfigurationGroup(false);
-    group3->addChild(group2);
-    group3->addChild(wolCommand);
-
-    WOLsqlSettings *sub4 =
-        new WOLsqlSettings(wolEnabled, group3);
-    addChild(sub4);
-}
-
-void MythDbSettings1::load()
-{
-    DatabaseParams params = gContext->GetDatabaseParams();
-
-    if (params.dbHostName.isEmpty() ||
-        params.dbUserName.isEmpty() ||
-        params.dbPassword.isEmpty() ||
-        params.dbName.isEmpty())
-        info->setValue(info->getValue() + "\n" +
-                       QObject::tr("Required fields are"
-                                   " marked with an asterisk (*)."));
-
-    if (params.dbHostName.isEmpty())
-    {
-        dbHostName->setLabel("* " + dbHostName->getLabel());
-        dbHostName->setValue(m_DBhostOverride);
-    }
-    else
-        dbHostName->setValue(params.dbHostName);
-
-    dbHostPing->setValue(params.dbHostPing);
-
-    if (params.dbPort)
-        dbPort->setValue(QString::number(params.dbPort));
-
-    dbUserName->setValue(params.dbUserName);
-    if (params.dbUserName.isEmpty())
-        dbUserName->setLabel("* " + dbUserName->getLabel());
-    dbPassword->setValue(params.dbPassword);
-    if (params.dbPassword.isEmpty())
-        dbPassword->setLabel("* " + dbPassword->getLabel());
-    dbName->setValue(params.dbName);
-    if (params.dbName.isEmpty())
-        dbName->setLabel("* " + dbName->getLabel());
-
-    if (params.dbType == "QMYSQL3")
-        dbType->setValue(0);
-    else if (params.dbType == "QPSQL7")
-        dbType->setValue(1);
-}
-
-void MythDbSettings2::load()
-{
-    DatabaseParams params = gContext->GetDatabaseParams();
-
-    localEnabled->setValue(params.localEnabled);
-    localHostName->setValue(params.localHostName);
-
-    wolEnabled->setValue(params.wolEnabled);
-    wolReconnect->setValue(params.wolReconnect);
-    wolRetry->setValue(params.wolRetry);
-    wolCommand->setValue(params.wolCommand);
-}
-
-void MythDbSettings1::save()
-{
-    DatabaseParams params = gContext->GetDatabaseParams();
-
-    params.dbHostName    = dbHostName->getValue();
-    params.dbHostPing    = dbHostPing->boolValue();
-    params.dbPort        = dbPort->getValue().toInt();
-    params.dbUserName    = dbUserName->getValue();
-    params.dbPassword    = dbPassword->getValue();
-    params.dbName        = dbName->getValue();
-    params.dbType        = dbType->getValue();
-
-    gContext->SaveDatabaseParams(params);
-}
-
-void MythDbSettings2::save()
-{
-    DatabaseParams params = gContext->GetDatabaseParams();
-
-    params.localEnabled  = localEnabled->boolValue();
-    params.localHostName = localHostName->getValue();
-
-    params.wolEnabled    = wolEnabled->boolValue();
-    params.wolReconnect  = wolReconnect->intValue();
-    params.wolRetry      = wolRetry->intValue();
-    params.wolCommand    = wolCommand->getValue();
-
-    gContext->SaveDatabaseParams(params);
-}
-
-DatabaseSettings::DatabaseSettings(const QString &DBhostOverride)
-{
-    addChild(new MythDbSettings1(DBhostOverride));
-    addChild(new MythDbSettings2());
-}
-
-void DatabaseSettings::addDatabaseSettings(ConfigurationWizard *wizard)
-{
-    wizard->addChild(new MythDbSettings1());
-    wizard->addChild(new MythDbSettings2());
-}

mythtv/libs/libmyth/mythwidgets.cpp

@@ -66 +66 @@
     qt_delete(popup);
 
     popup = new VirtualKeyboard(gContext->GetMainWindow(), this);
-    gContext->GetMainWindow()->detach(popup);
+    gContext->detachFromWin(popup);
     popup->exec();
 
     qt_delete(popup);
@@ -78 +78 @@
     bool handled = false;
     QStringList actions;
     if ((!popup || !popup->isShown()) &&
-        (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions, !allowVirtualKeyboard)))
+        (gContext->TranslateKeyPress("qt", e, actions, !allowVirtualKeyboard)))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -189 +189 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -239 +239 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -305 +305 @@
 
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", (QKeyEvent *)e, 
-                                                     actions))
+    if (gContext->TranslateKeyPress("qt", (QKeyEvent *)e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -375 +374 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -467 +466 @@
     qt_delete(popup);
 
     popup = new VirtualKeyboard(gContext->GetMainWindow(), this);
-    gContext->GetMainWindow()->detach(popup);
+    gContext->detachFromWin(popup);
     popup->exec();
 
     qt_delete(popup);
@@ -478 +477 @@
     bool handled = false;
     QStringList actions;
     if ((!popup || !popup->isShown()) &&
-        gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions, false))
+        gContext->TranslateKeyPress("qt", e, actions, false))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -860 +859 @@
     QStringList actions;
 
     if ((!popup || !popup->isShown()) &&
-          gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions, false))
+          gContext->TranslateKeyPress("qt", e, actions, false))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -1124 +1123 @@
     qt_delete(popup);
 
     popup = new VirtualKeyboard(gContext->GetMainWindow(), this);
-    gContext->GetMainWindow()->detach(popup);
+    gContext->detachFromWin(popup);
     popup->exec();
 
     qt_delete(popup);
@@ -1157 +1156 @@
     int tmpRow = currentRow();
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", (QKeyEvent *)e,
-                                                     actions))
+    if (gContext->TranslateKeyPress("qt", (QKeyEvent *)e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {
@@ -1242 +1240 @@
     QStringList actions;
     keyPressActions.clear();
 
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", (QKeyEvent *)e,
-                                                     actions))
+    if (gContext->TranslateKeyPress("qt", (QKeyEvent *)e, actions))
     {
         keyPressActions = actions;
 
@@ -1369 +1366 @@
 
     bool handled = false;
     QStringList actions;
-    gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions);
+    gContext->TranslateKeyPress("qt", e, actions);
 
     for (unsigned int i = 0; i < actions.size() && !handled; i++)
     {
@@ -1490 +1487 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/xmlparse.cpp

@@ -286 +286 @@
     if (baseFont && !haveSize)
         size = baseFont->face.pointSize();
     else    
-        size = GetMythMainWindow()->NormalizeFontSize(size);
+        size = gContext->NormalizeFontSize(size);
     
     // If we don't have to, don't load the font.
     if (!haveFace && baseFont)

mythtv/libs/libmyth/uitypes.cpp

@@ -6000 +6000 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions, false))
+    if (gContext->TranslateKeyPress("qt", e, actions, false))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/dbsettings.h

@@ -1 @@
-#ifndef DBSETTINGS_H
-#define DBSETTINGS_H
-
-#include "mythconfigdialogs.h"
-
-class MPUBLIC DatabaseSettings: public ConfigurationWizard {
-public:
-    DatabaseSettings(const QString &DBhostOverride = QString::null);
-    
-    // This routine calls wizard->addChild() for each of
-    // the database configuration screens.  This allows
-    // the number of DB config screens to change.
-    static void addDatabaseSettings(ConfigurationWizard *wizard);
-};
-
-#endif

mythtv/libs/libmyth/mythcontext.cpp

@@ -27 +27 @@
 #include "mythplugin.h"
 #include "screensaver.h"
 #include "DisplayRes.h"
-#include "backendselect.h"
-#include "dbsettings.h"
 #include "langsettings.h"
 #include "mythdbcon.h"
 #include "util-x11.h"
@@ -36 +34 @@
 #include "themeinfo.h"
 
 #include "libmythui/mythmainwindow.h"
-#include "libmythupnp/mythxmlclient.h"
-#include "libmythupnp/upnp.h"
 
 #ifdef USING_MINGW
 #include <winsock2.h>
@@ -58 +54 @@
 const QString kPluginLibSuffix = ".so";
 #endif
 
-MythContext *gContext = NULL;
-QMutex MythContext::verbose_mutex(true);
-QString MythContext::x11_display = QString::null;
+MythContext    *gContext = NULL;
+DatabaseParams  gDBparams;
+QMutex          MythContext::verbose_mutex(true);
+QString         MythContext::x11_display = QString::null;
 
 unsigned int print_verbose_messages = VB_IMPORTANT | VB_GENERAL;
 QString verboseString = QString(" important general");
 
 QMutex avcodeclock(true);
 
-// Some common UPnP search and XML value strings
-const QString gBackendURI = "urn:schemas-mythtv-org:device:MasterMediaServer:1";
-const QString kDefaultPIN = "UPnP/MythFrontend/DefaultBackend/SecurityPin";
-const QString kDefaultUSN = "UPnP/MythFrontend/DefaultBackend/USN";
 
-
 int parse_verbose_arg(QString arg)
 {
     QString option;
@@ -180 +172 @@
     MythContextPrivate(MythContext *lparent);
    ~MythContextPrivate();
 
-    bool Init        (const bool gui,    UPnp *UPnPclient,
-                      const bool prompt, const bool noPrompt);
-    bool FindDatabase(const bool prompt, const bool noPrompt);
+    bool Init(const bool gui);
 
     bool IsWideMode() const {return (m_baseWidth == 1280);}
     void SetWideMode() {m_baseWidth = 1280; m_baseHeight = 720;}
     bool IsSquareMode() const {return (m_baseWidth == 800);}
     void SetSquareMode() {m_baseWidth = 800; m_baseHeight = 600;}
 
-    void TempMainWindow(bool languagePrompt = true);
-    void EndTempWindow(void);
-
     void GetScreenBounds(void);
     void StoreGUIsettings(void);
 
     void LoadLogSettings(void);
-    void LoadDatabaseSettings(void);
-    
-    bool LoadSettingsFile(void);
+
+    void DefaultDatabaseSettings(void);
     bool WriteSettingsFile(const DatabaseParams &params,
                            bool overwrite = false);
-    bool FindSettingsProbs(void);
 
-    QString getResponse(const QString &query, const QString &def);
-    int     intResponse(const QString &query, int def);
-    bool    PromptForDatabaseParams(const QString &error);
-    QString TestDBconnection(void);
-    void    ResetDatabase(void);
 
-    bool    InitUPnP(void);
-    void    DeleteUPnP(void);
-    int     ChooseBackend(const QString &error);
-    int     UPnPautoconf(const int milliSeconds = 2000);
-    bool    DefaultUPnP(QString &error);
-    bool    UPnPconnect(const DeviceLocation *device, const QString &PIN);
-
-
     MythContext *parent;
 
     Settings *m_settings;          ///< connection stuff, theme, button style
@@ -248 +220 @@
     QMutex  m_hostnamelock;      ///< Locking for thread-safe copying of:
     QString m_localhostname;     ///< hostname from mysql.txt or gethostname()
 
-    DatabaseParams  m_DBparams;  ///< Current database host & WOL details
-    QString         m_DBhostCp;  ///< dbHostName backup
-
-    UPnp             *m_UPnP;    ///< For automatic backend discover
-    XmlConfiguration *m_XML;
-    HttpServer       *m_HTTP;
-
     QMutex serverSockLock;
     bool attemptingToConnect;
 
@@ -284 +249 @@
     MythSocket *serverSock;
     MythSocket *eventSock;
 
-    bool disablelibrarypopup;
-
     MythPluginManager *pluginmanager;
 
     ScreenSaverControl *screensaver;
@@ -319 +282 @@
       m_xbase(0), m_ybase(0), m_height(0), m_width(0),
       m_baseWidth(800), m_baseHeight(600),
       m_localhostname(QString::null),
-      m_UPnP(NULL), m_XML(NULL), m_HTTP(NULL),
       serverSockLock(false),
       attemptingToConnect(false),
       language(""),
@@ -330 +292 @@
       themecachedir(QString::null),
       bigfontsize(0), mediumfontsize(0), smallfontsize(0),
       serverSock(NULL), eventSock(NULL),
-      disablelibrarypopup(false),
       pluginmanager(NULL),
       screensaver(NULL),
       m_logenable(-1), m_logmaxcount(-1), m_logprintlevel(-1),
@@ -375 +336 @@
 {
     imageCache.clear();
 
-    DeleteUPnP();
     if (m_settings)
         delete m_settings;
     if (m_qtThemeSettings)
@@ -389 +349 @@
 }
 
 /**
- * \brief Setup a minimal themed main window, and prompt for user's language.
- *
- * Used for warnings before the database is opened, or bootstrapping pages.
- * After using the window, call EndTempWindow().
- *
- * \bug   Some of these settings (<i>e.g.</I> window size, theme)
- *        seem to be used after the temp window is destroyed.
- *
- * \bug   The default theme here is blue, but as of [12377],
- *        G.A.N.T is now meant to be the default?
- *        A simple change to make, but Nigel prefers
- *        "blue" for these initial screens and popups
- */
-void MythContextPrivate::TempMainWindow(bool languagePrompt)
-{
-    if (mainWindow)
-        return;
-
-    // We clear the hostname so MSqlQuery will fail, instead of long
-    // timeouts per DB value, or hundreds of lines of DB connect errors.
-    // We save the value for later possible editing in the DbSettings pages
-    if (m_DBparams.dbHostName.length())
-    {
-        m_DBhostCp = m_DBparams.dbHostName;
-        m_DBparams.dbHostName = "";
-    }
-
-    m_settings->SetSetting("Theme", "blue");
-#ifdef Q_WS_MACX
-    // Myth looks horrible in default Mac style for Qt
-    m_settings->SetSetting("Style", "Windows");
-#endif
-    parent->LoadQtConfig();
-
-    MythMainWindow *mainWindow = MythMainWindow::getMainWindow(false);
-    mainWindow->Init();
-    parent->SetMainWindow(mainWindow);
-
-    if (languagePrompt)
-    {
-        // ask user for language settings
-        LanguageSettings::prompt();
-        LanguageSettings::load("mythfrontend");
-    }
-}
-
-void MythContextPrivate::EndTempWindow(void)
-{
-    parent->SetMainWindow(NULL);
-    DestroyMythMainWindow();
-}
-
-/**
  * \brief Get screen size from Qt, respecting for user's multiple screen prefs
  *
  * If the windowing system environment has multiple screens
@@ -520 +427 @@
     }
 }
 
-bool MythContextPrivate::Init(const bool gui, UPnp *UPnPclient,
-                              const bool promptForBackend, const bool noPrompt)
+bool MythContextPrivate::Init(const bool gui)
 {
     m_gui = gui;
-    if (UPnPclient)
-    {
-        m_UPnP = UPnPclient;
-        m_XML  = (XmlConfiguration *)UPnp::g_pConfig;
-    }
 
     // Creates screen saver control if we will have a GUI
     if (gui)
+    {
         screensaver = ScreenSaverControl::get();
 
-    // ---- database connection stuff ----
-
-    if (!FindDatabase(promptForBackend, noPrompt))
-        return false;
-
-    // ---- keep all DB-using stuff below this line ----
-
-    if (gui)
-    {
         GetScreenBounds();
         StoreGUIsettings();
     }
@@ -551 +444 @@
 }
 
 /**
- * Get database connection settings and test connectivity.
- *
- * Can use UPnP AutoDiscovery to locate backends, and get their DB settings.
- * The user can force the AutoDiscovery chooser with the --prompt argument,
- * and disable it by using the --disable-autodiscovery argument.
- * There is also an autoconfigure function, which counts the backends,
- * and if there is exactly one, uses it as above.
- *
- * Despite its name, the disable argument currently only disables the chooser.
- * If set, autoconfigure will still be attempted in some situations.
- */
-bool MythContextPrivate::FindDatabase(const bool prompt, const bool noPrompt)
-{
-    // The two bool. args actually form a Yes/Maybe/No (A tristate bool :-)
-    bool manualSelect = prompt && !noPrompt;
-
-    // In addition to the UI chooser, we can also try to autoconfigure
-    bool autoSelect = !manualSelect;
-
-    QString failure;
-
-
-    // 1. Load either mysql.txt, or use sensible "localhost" defaults:
-    LoadDatabaseSettings();
-
-
-    // 2. If the user isn't forcing up the chooser UI, look for a default
-    //    backend in config.xml, then test DB settings we've got so far:
-    if (!manualSelect)
-    {
-        // config.xml may contain a backend host UUID and PIN.
-        // If so, try to AutoDiscover UPnP server, and use its DB settings:
-
-        if (DefaultUPnP(failure))                // Probably a valid backend,
-            autoSelect = manualSelect = false;   // so disable any further UPnP
-        else
-            if (failure.length())
-                VERBOSE(VB_IMPORTANT, failure);
-
-        failure = TestDBconnection();
-        if (failure.isEmpty())
-            goto DBfound;
-    }
-
-
-    // 3. Try to automatically find the single backend:
-    if (autoSelect)
-    {
-        int count = UPnPautoconf();
-
-        if (count == 0)
-            failure = "No UPnP backends found";
-
-        if (count == 1)
-        {
-            failure = TestDBconnection();
-            if (failure.isEmpty())
-                goto DBfound;
-        }
-
-        if (count > 1 || count == -1)     // Multiple BEs, or needs PIN.
-            manualSelect = !noPrompt;     // If allowed, prompt user
-    }
-
-    if (!m_gui) 
-        manualSelect = false;  // no interactive command-line chooser yet
-
-
-
-    // Last, get the user to select a backend from a possible list:
-    if (manualSelect)
-    {
-        switch (ChooseBackend(QString::null)) 
-        { 
-            case -1:    // User asked to configure database manually 
-                if (PromptForDatabaseParams(""))
-                    break;
-                else
-                    goto NoDBfound;   // User cancelled - changed their mind?
-    
-            case 0:   // User cancelled. Exit application 
-                goto NoDBfound;
-
-            case 1:    // User selected a backend, so m_DBparams 
-                break; // should now contain the database details 
-
-            default:
-                goto NoDBfound;
-        }
-        failure = TestDBconnection();
-    }
-
-
-    // Queries the user for the DB info, using the command 
-    // line or the GUI depending on the application.
-    while (failure.length())
-    {
-        VERBOSE(VB_IMPORTANT, QString("%1").arg(failure));
-        if (( manualSelect && ChooseBackend(failure)) || 
-            (!manualSelect && PromptForDatabaseParams(failure)))
-        {
-            failure = TestDBconnection();
-            if (failure.length())
-                VERBOSE(VB_IMPORTANT, QString("%1").arg(failure));
-        }
-        else
-            goto NoDBfound;
-    }
-
-DBfound:
-    //VERBOSE(VB_GENERAL, "FindDatabase() - Success!");
-    ResetDatabase();
-    DeleteUPnP();
-    return true;
-
-NoDBfound:
-    //VERBOSE(VB_GENERAL, "FindDatabase() - failed");
-    DeleteUPnP();
-    return false;
-}
-
-/**
  * Apply any user overrides to the screen geometry
  */
 void MythContextPrivate::StoreGUIsettings()
@@ -744 +515 @@
     m_logprintlevel = parent->GetNumSetting("LogPrintLevel", LP_ERROR);
 }
 
-/**     
- * Load database and host settings from mysql.txt, or set some defaults
- *
- * \returns true if mysql.txt was parsed
- */
-void MythContextPrivate::LoadDatabaseSettings(void)
-{
-    if (!LoadSettingsFile())
-    {
-        VERBOSE(VB_IMPORTANT, "Unable to read configuration file mysql.txt");
-
-        // Sensible connection defaults.
-        m_DBparams.dbHostName    = "localhost";
-        m_DBparams.dbHostPing    = true;
-        m_DBparams.dbPort        = 0;
-        m_DBparams.dbUserName    = "mythtv";
-        m_DBparams.dbPassword    = "mythtv";
-        m_DBparams.dbName        = "mythconverg";
-        m_DBparams.dbType        = "QMYSQL3";
-        m_DBparams.localEnabled  = false;
-        m_DBparams.localHostName = "my-unique-identifier-goes-here";
-        m_DBparams.wolEnabled    = false;
-        m_DBparams.wolReconnect  = 0;
-        m_DBparams.wolRetry      = 5;
-        m_DBparams.wolCommand    = "echo 'WOLsqlServerCommand not set'";
-    }
-
-    // Even if we have loaded the settings file, it may be incomplete,
-    // so we check for missing values and warn user
-    FindSettingsProbs();
-
-    m_localhostname = m_DBparams.localHostName;
-    if (m_localhostname.isEmpty() ||
-        m_localhostname == "my-unique-identifier-goes-here")
-    {
-        char localhostname[1024];
-        if (gethostname(localhostname, 1024))
-        {
-            VERBOSE(VB_IMPORTANT,
-                    "MCP: Error, could not determine host name." + ENO);
-            localhostname[0] = '\0';
-        }
-        m_localhostname = localhostname;
-        VERBOSE(VB_IMPORTANT, "Empty LocalHostName.");
-    }
-
-    VERBOSE(VB_GENERAL, QString("Using localhost value of %1")
-            .arg(m_localhostname));
-}
-
-/**
- * Load mysql.txt and parse its values into m_DBparams
- */
-bool MythContextPrivate::LoadSettingsFile(void)
-{
-    if (!m_settings->LoadSettingsFiles("mysql.txt", m_installprefix))
-        return false;
-
-    m_DBparams.dbHostName = m_settings->GetSetting("DBHostName");
-    m_DBparams.dbHostPing = m_settings->GetSetting("DBHostPing") != "no";
-    m_DBparams.dbPort     = m_settings->GetNumSetting("DBPort");
-    m_DBparams.dbUserName = m_settings->GetSetting("DBUserName");
-    m_DBparams.dbPassword = m_settings->GetSetting("DBPassword");
-    m_DBparams.dbName     = m_settings->GetSetting("DBName");
-    m_DBparams.dbType     = m_settings->GetSetting("DBType");
-
-    m_DBparams.localHostName = m_settings->GetSetting("LocalHostName");
-    m_DBparams.localEnabled  = m_DBparams.localHostName.length() > 0;
-
-    m_DBparams.wolReconnect
-        = m_settings->GetNumSetting("WOLsqlReconnectWaitTime");
-    m_DBparams.wolEnabled = m_DBparams.wolReconnect > 0;
-
-    m_DBparams.wolRetry   = m_settings->GetNumSetting("WOLsqlConnectRetry");
-    m_DBparams.wolCommand = m_settings->GetSetting("WOLsqlCommand");
-
-    return true;
-}
-
 bool MythContextPrivate::WriteSettingsFile(const DatabaseParams &params,
                                            bool overwrite)
 {
@@ -926 +618 @@
     return true;
 }
 
-bool MythContextPrivate::FindSettingsProbs(void)
-{
-    bool problems = false;
-    
-    if (m_DBparams.dbHostName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBHostName is not set in mysql.txt");
-        VERBOSE(VB_IMPORTANT, "Assuming localhost");
-        m_DBparams.dbHostName = "localhost";
-    }
-    if (m_DBparams.dbUserName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBUserName is not set in mysql.txt");
-    }
-    if (m_DBparams.dbPassword.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBPassword is not set in mysql.txt");
-    }
-    if (m_DBparams.dbName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBName is not set in mysql.txt");
-    }
-    return problems;
-}
-
-QString MythContextPrivate::getResponse(const QString &query,
-                                        const QString &def)
-{
-    cout << query;
-
-    if (def != "")
-        cout << " [" << def << "]  ";
-    else
-        cout << "  ";
-
-    if (!isatty(fileno(stdin)) || !isatty(fileno(stdout)))
-    {
-        cout << endl << "[console is not interactive, using default '"
-             << def  << "']" << endl;
-        return def;
-    }
-
-    char response[80];
-    cin.clear();
-    cin.getline(response, 80);
-    if (!cin.good())
-    {
-        cout << endl;
-        VERBOSE(VB_IMPORTANT, "Read from stdin failed");
-        return NULL;
-    }
-
-    QString qresponse = response;
-
-    if (qresponse == "")
-        qresponse = def;
-
-    return qresponse;
-}
-
-int MythContextPrivate::intResponse(const QString &query, int def)
-{
-    QString str_resp = getResponse(query, QString("%1").arg(def));
-    if (!str_resp)
-        return false;
-    bool ok;
-    int resp = str_resp.toInt(&ok);
-    return (ok ? resp : def);
-}
-
-bool MythContextPrivate::PromptForDatabaseParams(const QString &error)
-{
-    bool accepted = false;
-    if (m_gui)
-    {
-        TempMainWindow();
-
-        // Tell the user what went wrong:
-        if (error.length())
-            MythPopupBox::showOkPopup(mainWindow, "DB connect failure", error);
-        
-        // ask user for database parameters
-        DatabaseSettings settings(m_DBhostCp);
-        accepted = (settings.exec() == QDialog::Accepted);
-        if (!accepted)
-            VERBOSE(VB_IMPORTANT, "User cancelled database configuration");
-
-        EndTempWindow();
-    }
-    else
-    {
-        DatabaseParams params = parent->GetDatabaseParams();
-        QString response;
-        
-        // give user chance to skip config
-        cout << endl << error << endl << endl;
-        response = getResponse("Would you like to configure the database "
-                               "connection now?",
-                               "yes");
-        if (!response || response.left(1).lower() != "y")
-            return false;
-        
-        params.dbHostName = getResponse("Database host name:",
-                                        params.dbHostName);
-        response = getResponse("Should I test connectivity to this host "
-                               "using the ping command?", "yes");
-        params.dbHostPing = (!response || response.left(1).lower() != "y");
-
-        params.dbPort     = intResponse("Database non-default port:",
-                                        params.dbPort);
-        params.dbName     = getResponse("Database name:",
-                                        params.dbName);
-        params.dbUserName = getResponse("Database user name:",
-                                        params.dbUserName);
-        params.dbPassword = getResponse("Database password:",
-                                        params.dbPassword);
-        
-        params.localHostName = getResponse("Unique identifier for this machine "
-                                           "(if empty, the local host name "
-                                           "will be used):",
-                                           params.localHostName);
-        params.localEnabled = !params.localHostName.isEmpty();
-        
-        response = getResponse("Would you like to use Wake-On-LAN to retry "
-                               "database connections?",
-                               (params.wolEnabled ? "yes" : "no"));
-        if (response)
-            params.wolEnabled  = (response.left(1).lower() == "y");
-
-        if (params.wolEnabled)
-        {
-            params.wolReconnect = intResponse("Seconds to wait for "
-                                              "reconnection:",
-                                              params.wolReconnect);
-            params.wolRetry     = intResponse("Number of times to retry:",
-                                              params.wolRetry);
-            params.wolCommand   = getResponse("Command to use to wake server:",
-                                              params.wolCommand);
-        }
-        
-        accepted = parent->SaveDatabaseParams(params);
-    }
-    return accepted;
-}
-
 /**
  * Some quick sanity checks before opening a database connection
  */
-QString MythContextPrivate::TestDBconnection(void)
+QString MythContext::TestDBconnection(void)
 {
-    bool    doPing = m_DBparams.dbHostPing;
+    bool    doPing = gDBparams.dbHostPing;
     QString err;
-    QString host   = m_DBparams.dbHostName;
-    int     port   = m_DBparams.dbPort;
+    QString host   = gDBparams.dbHostName;
+    int     port   = gDBparams.dbPort;
 
 
     // 1. Check the supplied host or IP address, to prevent the app
     //    appearing to hang if we cannot route to the machine:
 
     // No need to ping myself
-    if (host == "localhost" || host == "127.0.0.1" || host == m_localhostname)
+    if (host == "localhost" || host == "127.0.0.1" ||
+                               host == d->m_localhostname)
         doPing = false;
 
     // If WOL is setup, the backend might be sleeping:
-    if (doPing && m_DBparams.wolEnabled)
-        for (int attempt = 0; attempt < m_DBparams.wolRetry; ++attempt)
+    if (doPing && gDBparams.wolEnabled)
+        for (int attempt = 0; attempt < gDBparams.wolRetry; ++attempt)
         {
-            int wakeupTime = m_DBparams.wolReconnect;
+            int wakeupTime = gDBparams.wolReconnect;
 
             if (ping(host, wakeupTime))
             {
@@ -1107 +651 @@
 
             VERBOSE(VB_GENERAL, QString("Trying to wake up host %1, attempt %2")
                                 .arg(host).arg(attempt));
-            system(m_DBparams.wolCommand);
+            system(gDBparams.wolCommand);
 
             VERBOSE(VB_GENERAL,
                     QString("Waiting for %1 seconds").arg(wakeupTime));
-            sleep(m_DBparams.wolReconnect);
+            sleep(gDBparams.wolReconnect);
         }
 
     if (doPing)
@@ -1122 +666 @@
 
     if (doPing && !ping(host, 3))  // Fail after trying for 3 seconds
     {
-        // Save, to display in DatabaseSettings screens
-        m_DBhostCp = m_DBparams.dbHostName;
-
         // Cause MSqlQuery to fail, instead of minutes timeout per DB value
-        m_DBparams.dbHostName = "";
+        gDBparams.dbHostName = "";
 
         err = QObject::tr("Cannot find (ping) database host %1 on the network");
         return err.arg(host);
@@ -1162 +703 @@
  * Any cached settings also need to be cleared,
  * so that they can be re-read from the new database
  */
-void MythContextPrivate::ResetDatabase(void)
+void MythContext::ResetDatabase(void)
 {
-    m_dbmanager.CloseDatabases();
-    parent->ClearSettingsCache();
+    d->m_dbmanager.CloseDatabases();
+    ClearSettingsCache();
 }
 
 
-bool MythContextPrivate::InitUPnP(void)
+MythContext::MythContext() : QObject()
 {
-    if (m_UPnP)
-        return true;
-
-    VERBOSE(VB_UPNP, "Setting UPnP client for backend autodiscovery...");
-
-    if (!m_XML)
-        m_XML = new XmlConfiguration("");   // No file - use defaults only
-
-    m_UPnP = new UPnp();
-    m_UPnP->SetConfiguration(m_XML);
-
-    int port=6549;
-    m_HTTP = new HttpServer(port);
-
-    if (!m_HTTP->ok())
-    {
-        VERBOSE(VB_IMPORTANT, "MCP::InitUPnP() - HttpServer Create Error");
-        DeleteUPnP();
-        return false;
-    }
-
-    if (!m_UPnP->Initialize(port, m_HTTP))
-    {
-        VERBOSE(VB_IMPORTANT, "MCP::InitUPnP() - UPnp::Initialize() Error");
-        DeleteUPnP();
-        return false;
-    }
-
-    // Create a dummy device description
-    UPnpDevice   &device = UPnp::g_UPnpDeviceDesc.m_rootDevice;
-    device.m_sDeviceType = "urn:schemas-upnp-org:device:MythContextClient:1";
-
-    m_UPnP->Start();
-
-    return true;
-}
-
-void MythContextPrivate::DeleteUPnP(void)
-{
-    if (m_UPnP && !m_HTTP)  // Init was passed an existing UPnP
-        return;             // so let the caller delete it cleanly
-
-    if (m_UPnP)
-    {
-        // This takes a few seconds, so inform the user:
-        VERBOSE(VB_GENERAL, "Deleting UPnP client...");
-
-        delete m_UPnP;  // This also deletes m_XML
-        m_UPnP = NULL;
-        m_XML  = NULL;
-    }
-
-    if (m_HTTP)
-    {
-        delete m_HTTP;
-        m_HTTP = NULL;
-    }
-}
-
-/**
- * Search for backends via UPnP, put up a UI for the user to choose one
- */
-int MythContextPrivate::ChooseBackend(const QString &error)
-{ 
-    if (!InitUPnP())
-        return -1;
-
-    TempMainWindow(); 
- 
-    // Tell the user what went wrong:
-    if (error.length())
-        MythPopupBox::showOkPopup(mainWindow, "DB connect failure", error);
-
-    VERBOSE(VB_GENERAL, "Putting up the UPnP backend chooser"); 
-
-    BackendSelect *BEsel = new BackendSelect(mainWindow, &m_DBparams);
-    switch (BEsel->exec())
-    {
-        case kDialogCodeRejected:
-            VERBOSE(VB_IMPORTANT, "User canceled database configuration");
-            return 0;
-
-        case kDialogCodeButton0:
-            VERBOSE(VB_IMPORTANT, "User requested Manual Config");
-            return -1;
-    }
-    //BEsel->hide();
-    //BEsel->deleteLater();
-
-    QStringList buttons;
-    QString     message;
-
-    buttons += QObject::tr("Save database details");
-    buttons += QObject::tr("Save backend details");
-    buttons += QObject::tr("Don't Save");
-
-    message = QObject::tr("Save that backend or database as the default?");
-
-    DialogCode selected = MythPopupBox::ShowButtonPopup(
-        mainWindow, "Save default", message, buttons, kDialogCodeButton2);
-    switch (selected)
-    {
-        case kDialogCodeButton0:
-            WriteSettingsFile(m_DBparams, true);
-            // User prefers mysql.txt, so throw away default UPnP backend:
-            m_XML->SetValue(kDefaultUSN, "");
-            m_XML->Save();
-            break;
-        case kDialogCodeButton1:
-            if (BEsel->m_PIN.length())
-                m_XML->SetValue(kDefaultPIN, BEsel->m_PIN);
-            m_XML->SetValue(kDefaultUSN, BEsel->m_USN);
-            m_XML->Save();
-            break;
-    }
-
-    delete BEsel;
-    EndTempWindow(); 
-
-    return 1; 
-} 
-
-/**
- * If there is only a single UPnP backend, use it.
- *
- * This does <i>not</i> prompt for PIN entry. If the backend requires one,
- * it will fail, and the caller needs to put up a UI to ask for one.
- */
-int MythContextPrivate::UPnPautoconf(const int milliSeconds)
-{
-    if (!InitUPnP())
-        return 0;
-
-    SSDPCacheEntries *backends = NULL;
-    int               count;
-    QString           LOC = "UPnPautoconf() - ";
-    QTime             timer;
-
-    m_UPnP->PerformSearch(gBackendURI);
-    for (timer.start(); timer.elapsed() < milliSeconds; usleep(25000))
-    {
-        backends = m_UPnP->g_SSDPCache.Find(gBackendURI);
-        if (backends)
-        {
-            backends->AddRef();
-            break;
-        }
-        putchar('.');
-    }
-    putchar('\n');
-
-    if (!backends)
-    {
-        VERBOSE(VB_GENERAL, LOC + "No UPnP backends found");
-        return 0;
-    }
-
-
-    // This could be tied to VB_UPNP?
-    //m_UPnP->g_SSDPCache.Dump();
-
-
-    count = backends->Count();
-    switch (count)
-    {
-        case 0:
-            VERBOSE(VB_IMPORTANT,
-                    LOC + "No UPnP backends found, but SSDP::Find() not NULL!");
-            break;
-        case 1:
-            VERBOSE(VB_GENERAL, LOC + "Found one UPnP backend");
-            break;
-        default:
-            VERBOSE(VB_GENERAL,
-                    (LOC + "More than one UPnP backend found (%1)").arg(count));
-    }
-
-    if (count != 1)
-    {
-        backends->Release();
-        return count;
-    }
-
-
-    // Get this backend's location:
-    backends->Lock();
-    DeviceLocation *BE = backends->GetEntryMap()->begin().data();
-    backends->Unlock();
-    backends->Release();
-
-    // We don't actually know the backend's access PIN, so this will
-    // only work for ones that have PIN access disabled (i.e. 0000)
-    if (UPnPconnect(BE, QString::null))
-        return 1;
-    
-    return -1;   // Try to force chooser & PIN
-}
-
-/** 
- * Get the default backend from config.xml, use UPnP to find it. 
- *
- * Sets a string if there any connection problems
- */ 
-bool MythContextPrivate::DefaultUPnP(QString &error)
-{ 
-    XmlConfiguration *XML = new XmlConfiguration("config.xml");
-    QString           loc = "MCP::DefaultUPnP() - ";
-    QString           PIN = XML->GetValue(kDefaultPIN, "");
-    QString           USN = XML->GetValue(kDefaultUSN, "");
-
-    delete XML;
-
-    if (USN.isEmpty())
-    {
-        VERBOSE(VB_UPNP, loc + "No default UPnP backend");
-        return false;
-    }
-
-    VERBOSE(VB_UPNP, loc + "config.xml has default " +
-            QString("PIN '%1' and host USN: %2")
-            .arg(PIN).arg(USN));
-
-    if (!InitUPnP())
-    {
-        error = "UPnP is broken?";
-        return false;
-    }
-
-    m_UPnP->PerformSearch(gBackendURI);
-    DeviceLocation *pDevLoc = m_UPnP->g_SSDPCache.Find(gBackendURI, USN);
-    if (!pDevLoc) 
-    {
-        error = "Cannot find default UPnP backend";
-        return false;
-
-    }
-
-    if (UPnPconnect(pDevLoc, PIN))
-        return true;
-    
-    error = "Cannot connect to default backend via UPnP. Wrong saved PIN?";
-    return false;
-}
-
-/** 
- * Query a backend via UPnP for its database connection parameters
- */ 
-bool MythContextPrivate::UPnPconnect(const DeviceLocation *backend,
-                                     const QString        &PIN)
-{
-    QString        error; 
-    QString        LOC = "UPnPconnect() - ";
-    QString        URL = backend->m_sLocation;
-    MythXMLClient  XML(URL);
- 
-    VERBOSE(VB_UPNP, LOC + QString("Trying host at %1").arg(URL));
-    switch (XML.GetConnectionInfo(PIN, &m_DBparams, error))
-    {
-        case UPnPResult_Success:
-            break;
-
-        case UPnPResult_ActionNotAuthorized:
-            // The stored PIN is probably not correct.
-            // We could prompt for the PIN and try again, but that needs a UI. 
-            // Easier to fail for now, and put up the full UI selector later 
-            VERBOSE(VB_UPNP, LOC + error + ". Wrong PIN?");
-            return false;
-
-        default:
-            VERBOSE(VB_UPNP, LOC + error);
-            return false;
-    }
-
-    QString DBhost = m_DBparams.dbHostName;
-    VERBOSE(VB_UPNP, LOC + QString("Got database hostname: %1").arg(DBhost));
-
-    return true;
-}
-
-
-MythContext::MythContext(const QString &binversion)
-    : QObject(), d(NULL), app_binary_version(binversion)
-{
 #ifdef USING_MINGW
     static bool WSAStarted = false;
     if (!WSAStarted) {
@@ -1468 +726 @@
     d = new MythContextPrivate(this);
 }
 
-bool MythContext::Init(const bool gui, UPnp *UPnPclient,
-                       const bool promptForBackend,
-                       const bool disableAutoDiscovery)
+bool MythContext::Init(const bool gui)
 {
-    if (app_binary_version != MYTH_BINARY_VERSION)
-    {
-        QString warning =
-                QString("This app was compiled against libmyth version: %1"
-                "\n\t\t\tbut the library is version: %2"
-                "\n\t\t\tYou probably want to recompile everything, and do a"
-                "\n\t\t\t'make distclean' first.")
-                .arg(app_binary_version).arg(MYTH_BINARY_VERSION);
-
-        if (gui)
-        {
-            d->TempMainWindow(false);
-            MythPopupBox::showOkPopup(d->mainWindow,
-                                      "Library version error", warning);
-            d->EndTempWindow();
-        }
-        VERBOSE(VB_IMPORTANT, QString("%1").arg(warning));
-
+    if (!d->Init(gui))
         return false;
-    }
 
-    if (!d->Init(gui, UPnPclient, promptForBackend, disableAutoDiscovery))
-        return false;
-
     ActivateSettingsCache(true);
 
     return true;
@@ -1570 +805 @@
                         manageLock = true;
                         d->serverSockLock.unlock();
                     }
-                    MythPopupBox::showOkPopup(d->mainWindow, 
+                    MythPopupBox::showOkPopup(GetMainWindow(),
                                               "connection failure",
                                               tr("Could not connect to the "
                                                  "master backend server -- is "
@@ -1818 +1053 @@
     return tmp;
 }
 
+void MythContext::SetHostName(QString localHost)
+{
+    d->m_hostnamelock.lock();
+    d->m_localhostname = QDeepCopy<QString>(localHost);
+    d->m_hostnamelock.unlock();
+}
+
 QString MythContext::GetFilePrefix(void)
 {
     return GetSetting("RecordFilePrefix");
@@ -3207 +2449 @@
             VERBOSE(VB_IMPORTANT,
                     QString("Reconnection to backend server failed"));
             if (d->m_height && d->m_width)
-                MythPopupBox::showOkPopup(d->mainWindow, "connection failure",
+                MythPopupBox::showOkPopup(GetMainWindow(), "connection failure",
                              tr("The connection to the master backend "
                                 "server has gone away for some reason.. "
                                 "Is it running?"));
@@ -3279 +2521 @@
         if (d->m_height && d->m_width)
         {
             qApp->lock();
-            MythPopupBox::showOkPopup(d->mainWindow, 
+            MythPopupBox::showOkPopup(GetMainWindow(),
                                       "Connection failure",
                                       tr(QString("The server uses network "
                                                  "protocol version %1, "
@@ -3337 +2579 @@
 QFont MythContext::GetBigFont(void)
 {
     QFont font = QApplication::font();
-    font.setPointSize(GetMythMainWindow()->NormalizeFontSize(d->bigfontsize));
+    font.setPointSize(NormalizeFontSize(d->bigfontsize));
     font.setWeight(QFont::Bold);
 
     return font;
@@ -3346 +2588 @@
 QFont MythContext::GetMediumFont(void)
 {
     QFont font = QApplication::font();
-    font.setPointSize(GetMythMainWindow()->NormalizeFontSize(d->mediumfontsize));
+    font.setPointSize(NormalizeFontSize(d->mediumfontsize));
     font.setWeight(QFont::Bold);
 
     return font;
@@ -3355 +2597 @@
 QFont MythContext::GetSmallFont(void)
 {
     QFont font = QApplication::font();
-    font.setPointSize(GetMythMainWindow()->NormalizeFontSize(d->smallfontsize));
+    font.setPointSize(NormalizeFontSize(d->smallfontsize));
     font.setWeight(QFont::Bold);
 
     return font;
@@ -3397 +2639 @@
     return d->mainWindow;
 }
 
-/**
- * \brief   Try to prevent silent, automatic database upgrades
- * \returns -1 to use the existing schema, 0 to exit, 1 to upgrade.
- *
- * The GUI prompts have no defaults, so that nothing dangerous
- * will happen if the user hits return a few times.
- * Hopefully this will force users to stop and think?
- * Similarly, the shell command prompting requires an explicit "yes".
- * Non-interactive shells default to old behaviour (upgrading)
- */
-int MythContext::PromptForSchemaUpgrade(const QString &dbver,
-                                        const QString &current)
-{
-    bool    autoUpgrade = false;
-    bool    connections = false;  // Are (other) FE/BEs connected?
-    bool    expertMode  = false;  // Use existing schema? Multiple buttons?
-    QString message;
-    int     returnValue = MYTH_SCHEMA_UPGRADE;
-    bool    upgradable  = (dbver.toUInt() < current.toUInt());
-    QString warnOtherCl = tr("There are also other clients using this"
-                             " database. They should be shut down first.");
-
-
-    // No current DBSchemaVer? Empty database, so upgrade to create tables
-    if (dbver.isEmpty())
-    {
-        VERBOSE(VB_GENERAL, "No current database version. Auto upgrading");
-        return MYTH_SCHEMA_UPGRADE;
-    }
-
-
-    // Users and developers can choose to live dangerously,
-    // either to silently and automatically upgrade,
-    // or an expert option to allow use of existing:
-    switch (gContext->GetNumSetting("DBSchemaAutoUpgrade"))
-    {
-        case  1: autoUpgrade = true; break;
-        case -1: expertMode  = true; break;
-        default: break;
-    }
-
-
-    // FIXME: Don't know how to determine this
-    //if (getActiveConnections() > 1)
-    //    connections = true;
-
-
-    // Deal with the trivial case first (No user prompting required)
-    if (autoUpgrade && upgradable && !connections)
-        return MYTH_SCHEMA_UPGRADE;
-
-
-    // Build up strings used both in GUI and command shell contexts:
-    if (upgradable)
-    {
-        if (autoUpgrade && connections)
-        {
-            message = tr("Error: MythTV cannot upgrade the schema of this"
-                         " datatase because other clients are using it.\n\n"
-                         "Please shut them down before upgrading.");
-            returnValue = MYTH_SCHEMA_ERROR;
-        }
-        else
-        {
-            message = tr("Warning: MythTV wants to upgrade"
-                         " your database schema, from %1 to %2.");
-            if (expertMode)
-                message += "\n\n" +
-                           tr("You can try using the old schema,"
-                              " but that may cause problems.");
-        }
-    }
-    else   // This client is too old
-    {
-        if (expertMode)
-            message = tr("Warning: MythTV database has newer"
-                         " schema (%1) than expected (%2).");
-        else
-        {
-            message = tr("Error: MythTV database has newer"
-                         " schema (%1) than expected (%2).");
-            returnValue = MYTH_SCHEMA_ERROR;
-        }
-    }
-
-    if (message.contains("%1"))
-        message = message.arg(dbver).arg(current);
-
-
-    if (d->m_gui)
-    {
-        bool createdTempWindow = false;
-
-        if (!d->mainWindow)
-        {
-            d->TempMainWindow();
-            createdTempWindow = true;
-        }
-
-        if (returnValue == MYTH_SCHEMA_ERROR)
-        {
-            MythPopupBox::showOkPopup(
-                d->mainWindow, "Database Upgrade Error",
-                message, QObject::tr("Exit"));
-        }
-        else
-        {
-            QStringList buttonNames;
-
-            buttonNames += QObject::tr("Exit");
-            buttonNames += QObject::tr("Upgrade");
-            if (expertMode)
-                buttonNames += QObject::tr("Use current schema");
-
-            DialogCode selected = MythPopupBox::ShowButtonPopup(
-                d->mainWindow, "Database Upgrade", message,
-                buttonNames, kDialogCodeButton0);
-
-            // The annoying extra confirmation:
-            if (kDialogCodeButton1 == selected)
-            {
-                message = tr("This cannot be un-done, so having a"
-                             " database backup would be a good idea.");
-                if (connections)
-                    message += "\n\n" + warnOtherCl;
-
-                selected = MythPopupBox::ShowButtonPopup(
-                    d->mainWindow, "Database Upgrade", message,
-                    buttonNames, kDialogCodeButton0);
-            }
-
-            switch (selected)
-            {
-                case kDialogCodeRejected:
-                case kDialogCodeButton0:
-                    returnValue = MYTH_SCHEMA_EXIT;         break;
-                case kDialogCodeButton1:
-                    returnValue = MYTH_SCHEMA_UPGRADE;      break;
-                case kDialogCodeButton2:
-                    returnValue = MYTH_SCHEMA_USE_EXISTING; break;
-                default:
-                    returnValue = MYTH_SCHEMA_ERROR;
-            }
-        }
-
-        if (createdTempWindow)
-        {
-            d->EndTempWindow();
-            d->m_DBparams.dbHostName = d->m_DBhostCp;
-        }
-
-        return returnValue;
-    }
-
-    // We are not in a GUI environment, so try to prompt the user in the shell
-
-    if (!isatty(fileno(stdin)) || !isatty(fileno(stdout)))
-    {
-        if (expertMode)
-        {
-            cout << "Console non-interactive. Using existing schema." << endl;
-            return MYTH_SCHEMA_USE_EXISTING;
-        }
-
-        cout << "Console is not interactive, cannot ask user about"
-             << " upgrading database schema." << endl << "Upgrading." << endl;
-        return MYTH_SCHEMA_UPGRADE;
-    }
-
-
-    QString resp;
-
-    cout << endl << message << endl << endl;
-
-    if (expertMode)
-    {
-        resp = d->getResponse("Would you like to use the existing schema?",
-                              "yes");
-        if (!resp || resp.left(1).lower() == "y")
-            return MYTH_SCHEMA_USE_EXISTING;
-    }
-
-    resp = d->getResponse("\nShall I upgrade this database?", "yes");
-    if (resp && resp.left(1).lower() != "y")
-        return MYTH_SCHEMA_EXIT;
-
-    if (connections)
-        cout << endl << warnOtherCl <<endl;
-
-    resp = d->getResponse("\nA database backup might be a good idea"
-                          "\nAre you sure you want to upgrade?", "no");
-    if (!resp || resp.left(1).lower() == "n")
-        return MYTH_SCHEMA_EXIT;
-
-    return MYTH_SCHEMA_UPGRADE;
-}
-
-bool MythContext::TestPopupVersion(const QString &name, 
-                                   const QString &libversion,
-                                   const QString &pluginversion)
-{
-    if (libversion == pluginversion)
-        return true;
-
-    QString err = "The " + name + " plugin was compiled against libmyth " +
-                  "version: " + pluginversion + ", but the installed " +
-                  "libmyth is at version: " + libversion + ".  You probably " +
-                  "want to recompile the " + name + " plugin after doing a " +
-                  "make distclean.";
-
-    if (GetMainWindow() && !d->disablelibrarypopup)
-    {    
-        DialogBox *dlg = new DialogBox(gContext->GetMainWindow(), err);
-        dlg->AddButton("OK");
-        dlg->exec();
-        dlg->deleteLater();
-    }
-
-    return false;
-}
-
-void MythContext::SetDisableLibraryPopup(bool check)
-{
-    d->disablelibrarypopup = check;
-}
-
 void MythContext::SetPluginManager(MythPluginManager *pmanager)
 {
     d->pluginmanager = pmanager;
@@ -3806 +2822 @@
     return ret_val;
 }
 
-DatabaseParams MythContext::GetDatabaseParams(void)
+/**     
+ * Set database connection defaults
+ */
+void MythContext::DefaultDatabaseSettings(void)
 {
-    return d->m_DBparams;
+    gDBparams.dbHostName    = "localhost";
+    gDBparams.dbHostPing    = true;
+    gDBparams.dbPort        = 0;
+    gDBparams.dbUserName    = "mythtv";
+    gDBparams.dbPassword    = "mythtv";
+    gDBparams.dbName        = "mythconverg";
+    gDBparams.dbType        = "QMYSQL3";
+    gDBparams.localEnabled  = false;
+    gDBparams.localHostName = "my-unique-identifier-goes-here";
+    gDBparams.wolEnabled    = false;
+    gDBparams.wolReconnect  = 0;
+    gDBparams.wolRetry      = 5;
+    gDBparams.wolCommand    = "echo 'WOLsqlServerCommand not set'";
 }
 
+
 bool MythContext::SaveDatabaseParams(const DatabaseParams &params)
 {
     bool ret = true;
-    DatabaseParams cur_params = GetDatabaseParams();
     
     // only rewrite file if it has changed
-    if (params.dbHostName   != cur_params.dbHostName          || 
-        params.dbHostPing   != cur_params.dbHostPing          || 
-        params.dbPort       != cur_params.dbPort              || 
-        params.dbUserName   != cur_params.dbUserName          || 
-        params.dbPassword   != cur_params.dbPassword          || 
-        params.dbName       != cur_params.dbName              || 
-        params.dbType       != cur_params.dbType              || 
-        params.localEnabled != cur_params.localEnabled        || 
-        params.wolEnabled   != cur_params.wolEnabled          || 
+    if (params.dbHostName   != gDBparams.dbHostName          || 
+        params.dbHostPing   != gDBparams.dbHostPing          || 
+        params.dbPort       != gDBparams.dbPort              || 
+        params.dbUserName   != gDBparams.dbUserName          || 
+        params.dbPassword   != gDBparams.dbPassword          || 
+        params.dbName       != gDBparams.dbName              || 
+        params.dbType       != gDBparams.dbType              || 
+        params.localEnabled != gDBparams.localEnabled        || 
+        params.wolEnabled   != gDBparams.wolEnabled          || 
         (params.localEnabled && 
-         (params.localHostName != cur_params.localHostName))  || 
+         (params.localHostName != gDBparams.localHostName))  || 
         (params.wolEnabled && 
-         (params.wolReconnect  != cur_params.wolReconnect || 
-          params.wolRetry      != cur_params.wolRetry     || 
-          params.wolCommand    != cur_params.wolCommand)))
+         (params.wolReconnect  != gDBparams.wolReconnect || 
+          params.wolRetry      != gDBparams.wolRetry     || 
+          params.wolCommand    != gDBparams.wolCommand)))
     {
         ret = d->WriteSettingsFile(params, true);
         if (ret)
         {
             // Save the new settings:
-            d->m_DBparams = params;
+            gDBparams = params;
 
             // If database has changed, force its use:
-            d->ResetDatabase();
+            ResetDatabase();
         }
     }
     return ret;

mythtv/libs/libmyth/mythdbcon.cpp

@@ -59 +59 @@
     
     if (!m_db->isOpen())
     {
-        DatabaseParams dbparms = gContext->GetDatabaseParams();
-        m_db->setDatabaseName(dbparms.dbName);
-        m_db->setUserName(dbparms.dbUserName);
-        m_db->setPassword(dbparms.dbPassword);
-        m_db->setHostName(dbparms.dbHostName);
+        m_db->setDatabaseName(gDBparams.dbName);
+        m_db->setUserName(gDBparams.dbUserName);
+        m_db->setPassword(gDBparams.dbPassword);
+        m_db->setHostName(gDBparams.dbHostName);
 
-        if (!dbparms.dbHostName.length())  // Bootstrapping without a database?
+        if (!gDBparams.dbHostName.length())// Bootstrapping without a database?
         {
             connected = true;              // Pretend to be connected
             return true;                   // to reduce errors
         }
 
-        if (dbparms.dbPort)
-            m_db->setPort(dbparms.dbPort);
+        if (gDBparams.dbPort)
+            m_db->setPort(gDBparams.dbPort);
 
-        if (dbparms.dbPort && dbparms.dbHostName == "localhost")
+        if (gDBparams.dbPort && gDBparams.dbHostName == "localhost")
             m_db->setHostName("127.0.0.1");
 
         connected = m_db->open();
 
-        if (!connected && dbparms.wolEnabled)
+        if (!connected && gDBparams.wolEnabled)
         {
             int trycount = 0;
                 
-            while (!connected && trycount++ < dbparms.wolRetry)
+            while (!connected && trycount++ < gDBparams.wolRetry)
             {
                 VERBOSE(VB_GENERAL, QString(
                          "Using WOL to wakeup database server (Try %1 of %2)")
-                         .arg(trycount).arg(dbparms.wolRetry));
+                         .arg(trycount).arg(gDBparams.wolRetry));
 
-                system(dbparms.wolCommand);
-                sleep(dbparms.wolReconnect);
+                system(gDBparams.wolCommand);
+                sleep(gDBparams.wolReconnect);
                 connected = m_db->open();
             }
     
             if (!connected)
             {
-                VERBOSE(VB_IMPORTANT, "WOL failed, unable to connect to database!");
+                VERBOSE(VB_IMPORTANT,
+                        "WOL failed, unable to connect to database!");
             }
         }
         if (connected)

mythtv/libs/libmyth/mythwizard.cpp

@@ -539 +539 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/mythcontext.h

@@ -142 +142 @@
 {
     Q_OBJECT
   public:
-    MythContext(const QString &binversion);
+    MythContext();
     virtual ~MythContext();
 
-    bool Init(const bool gui = true,
-                    UPnp *UPnPclient = NULL,
-              const bool promptForBackend = false,
-              const bool bypassAutoDiscovery = false);
+    bool Init(const bool gui = true);
 
     QString GetMasterHostPrefix(void);
 
     QString GetHostName(void);
+    void    SetHostName(QString localHost);
 
     void ClearSettingsCache(QString myKey = "", QString newVal = "");
     void ActivateSettingsCache(bool activate = true);
@@ -229 +227 @@
     static void DBError(const QString &where, const QSqlQuery &query);
     static QString DBErrorMessage(const QSqlError& err);
 
-    DatabaseParams GetDatabaseParams(void);
+    void DefaultDatabaseSettings(void);
+    void ResetDatabase(void);
     bool SaveDatabaseParams(const DatabaseParams &params);
+    QString TestDBconnection(void);
     
     void LogEntry(const QString &module, int priority,
                   const QString &message, const QString &details);
@@ -282 +282 @@
     void SetMainWindow(MythMainWindow *mainwin);
     MythMainWindow *GetMainWindow(void);
 
-    int  PromptForSchemaUpgrade(const QString &dbver, const QString &current);
-    bool TestPopupVersion(const QString &name, const QString &libversion,
-                          const QString &pluginversion);
+    // These virtual methods are implemented by the MythContextGUI
+    // and MythContextTTY subclasses in libmythtv. Having them there
+    // simplifies the library dependencies (no cross-dependencies).
+    //
+    virtual int  PromptForSchemaUpgrade(const QString &dbver,
+                                        const QString &current) = 0;
+    virtual bool TestPopupVersion(const QString &pluginName, 
+                                  const QString &libMythVersion, 
+                                  const QString &pluginVersion) = 0;
 
-    void SetDisableLibraryPopup(bool check);
+    virtual void SetDisableLibraryPopup(bool check) = 0;
 
+    virtual void attachToWin(QWidget *child) = 0;
+    virtual void detachFromWin(QWidget *child) = 0;
+    virtual int  NormalizeFontSize(const int pointSize) = 0;
+    virtual bool TranslateKeyPress(const QString &context,
+                                   QKeyEvent     *e,
+                                   QStringList   &actions,
+                                   bool           allowJumps = true) = 0;
+
+    virtual MythMainWindow *CreateMainWindow(void) = 0;
+
+
     void SetPluginManager(MythPluginManager *pmanager);
     MythPluginManager *getPluginManager(void);
 
@@ -344 +361 @@
     void readyRead(MythSocket *sock);
     void connectionFailed(MythSocket *sock) { (void)sock; }
 
-    MythContextPrivate *d;
-    QString app_binary_version;
+    MythContextPrivate  *d;
 
-    QMutex locationLock;
+    QMutex               locationLock;
     QValueList <QString> currentLocation;
 };
 
+
 /// This global variable contains the MythContext instance for the application
 extern MPUBLIC MythContext *gContext;
 
+/// This global stores the context's current database host & WOL details
+extern MPUBLIC DatabaseParams gDBparams;
+
 /// This global variable is used to makes certain calls to avlib threadsafe.
 extern MPUBLIC QMutex avcodeclock;
 
@@ -366 +386 @@
     MYTH_SCHEMA_USE_EXISTING = 4
 };
 
-/// Service type for the backend's UPnP server
-extern MPUBLIC const QString gBackendURI;
-
 #endif
 
 /* vim: set expandtab tabstop=4 shiftwidth=4: */

mythtv/libs/libmyth/mythconfigdialogs.cpp

@@ -100 +100 @@
     bool handled = false;
     QStringList actions;
 
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions))
+    if (gContext->TranslateKeyPress("qt", e, actions))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/libmyth.pro

@@ -11 +11 @@
 
 # Input
 HEADERS += audiooutput.h audiooutputbase.h audiooutputnull.h
-HEADERS += backendselect.h dbsettings.h dialogbox.h
-HEADERS += DisplayRes.h DisplayResScreen.h exitcodes.h
+HEADERS += dialogbox.h DisplayRes.h DisplayResScreen.h exitcodes.h
 HEADERS += generictree.h httpcomms.h langsettings.h lcddevice.h
 HEADERS += managedlist.h mythconfigdialogs.h mythconfiggroups.h
 HEADERS += mythcontext.h mythdbcon.h mythdeque.h mythdialogs.h
@@ -27 +26 @@
 HEADERS += compat.h
 
 SOURCES += audiooutput.cpp audiooutputbase.cpp audiooutputnull.cpp
-SOURCES += backendselect.cpp dbsettings.cpp dialogbox.cpp
-SOURCES += DisplayRes.cpp DisplayResScreen.cpp
+SOURCES += dialogbox.cpp DisplayRes.cpp DisplayResScreen.cpp
 SOURCES += generictree.cpp httpcomms.cpp langsettings.cpp lcddevice.cpp
 SOURCES += managedlist.cpp mythconfigdialogs.cpp mythconfiggroups.cpp
 SOURCES += mythcontext.cpp mythdbcon.cpp mythdialogs.cpp
@@ -60 +58 @@
 inc.files += visual.h volumebase.h output.h langsettings.h qmdcodec.h
 inc.files += exitcodes.h mythconfig.h mythconfig.mak virtualkeyboard.h
 inc.files += mythevent.h mythobservable.h mythsocket.h
-inc.files += mythexp.h mythpluginapi.h compat.h
+inc.files += mythexp.h mythpluginapi.h compat.h mythverbose.h
 inc.files += mythstorage.h mythconfigdialogs.h mythconfiggroups.h
 
 using_oss {
@@ -121 +119 @@
     # Mac OS X Frameworks
     FWKS = ApplicationServices AudioUnit Carbon CoreAudio IOKit
 
+    darwin_da : FWKS += DiskArbitration
+
     # The following trick is tidier, and shortens the command line, but it
     # depends on the shell expanding Csh-style braces. Luckily, Bash & Zsh do.
     FC = $$join(FWKS,",","{","}")
 
     QMAKE_CXXFLAGS += -F/System/Library/Frameworks/$${FC}.framework/Frameworks
     LIBS           += -framework $$join(FWKS," -framework ")
-
-    # There is a dependence on some stuff in libmythui and libmythupnp.
-    # It isn't built yet, so we have to ignore these for now:
-    QMAKE_LFLAGS_SHLIB += -flat_namespace -undefined warning
-
-    QMAKE_LFLAGS_SHLIB += -seg1addr 0xC6000000
 }
 
 linux {

mythtv/libs/libmyth/backendselect.h

@@ -1 @@
-#ifndef __BACKENDSELECT_H__
-#define __BACKENDSELECT_H__
-
-#include "mythdialogs.h"
-#include "mythwidgets.h"
-
-#include "libmythupnp/upnpdevice.h"
-
-class ListBoxDevice : public QListBoxText
-{
-    public:
-
-        ListBoxDevice(QListBox *list, const QString &name, DeviceLocation *dev)
-            : QListBoxText(list, name)
-        {
-            if ((m_dev = dev) != NULL)
-                m_dev->AddRef();
-        }
-
-        virtual ~ListBoxDevice()
-        {
-            if (m_dev != NULL)
-                m_dev->Release();
-        }
-
-        DeviceLocation *m_dev;
-};
-
-typedef QMap< QString, ListBoxDevice *> ItemMap;
-
-
-class BackendSelect : public MythDialog 
-{
-    Q_OBJECT
-
-    public:
-                 BackendSelect(MythMainWindow *parent, DatabaseParams *params);
-        virtual ~BackendSelect();
-
-        void     customEvent(QCustomEvent *e);
-
-        QString  m_PIN;
-        QString  m_USN;
-
-
-    public slots:
-
-        void Accept    (void);   ///< Linked to the OK button
-        void Manual    (void);   ///< Linked to 'Configure Manually' button
-        //void Search    (void);
-
-
-    protected:
-
-        void AddItem    (DeviceLocation *dev);
-        bool Connect    (DeviceLocation *dev);
-        void CreateUI   (void);
-        void FillListBox(void);
-        void RemoveItem (QString URN);
-
-        DatabaseParams *m_DBparams;
-        ItemMap         m_devices;
-        MythMainWindow *m_parent;
-        MythListBox    *m_backends;
-};
-
-#endif

mythtv/libs/libmyth/virtualkeyboard.cpp

@@ -230 +230 @@
 {
     bool handled = false;
     QStringList actions;
-    if (gContext->GetMainWindow()->TranslateKeyPress("qt", e, actions, false))
+    if (gContext->TranslateKeyPress("qt", e, actions, false))
     {
         for (unsigned int i = 0; i < actions.size() && !handled; i++)
         {

mythtv/libs/libmyth/backendselect.cpp

@@ -1 @@
-/**
- * \class BackendSelect
- * \desc  Classes to Prompt user for a master backend.
- *
- * \author Originally based on masterselection.cpp/h by David Blain.
- */
-
-#include "backendselect.h"
-#include "mythdialogs.h"
-#include "mythconfigdialogs.h"
-
-#include "libmythupnp/mythxmlclient.h"
-
-
-BackendSelect::BackendSelect(MythMainWindow *parent, DatabaseParams *params)
-             : MythDialog(parent, "BackEnd Selection", TRUE)
-{
-    m_parent   = parent;
-    m_DBparams = params;
-
-    CreateUI();
-
-    UPnp::AddListener(this);
-
-    FillListBox();
-
-    m_backends->setFocus();
-}
-
-BackendSelect::~BackendSelect()
-{
-    UPnp::RemoveListener(this);
-
-    ItemMap::iterator it;
-    for (it = m_devices.begin(); it != m_devices.end(); ++it)
-    {
-        ListBoxDevice *item = it.data();
-
-        if (item != NULL)
-            delete item;
-    }
-
-    m_devices.clear();
-}
-
-void BackendSelect::Accept(void)
-{
-    DeviceLocation *dev;
-    QListBoxItem   *selected = m_backends->selectedItem();
-
-    if (!selected)
-        return;
-
-    dev = ((ListBoxDevice *)selected)->m_dev;
-
-    if (!dev)
-        reject();
-
-    dev->AddRef();
-    if (Connect(dev))
-        accept();
-}
-
-void BackendSelect::AddItem(DeviceLocation *dev)
-{
-    if (!dev)
-        return;
-
-    QString USN = dev->m_sUSN;
-
-    // The devices' USN should be unique. Don't add if it is already there:
-    if (m_devices.find(USN) == m_devices.end())
-    {
-        ListBoxDevice *item;
-        QString        name;
-
-        if (print_verbose_messages & VB_UPNP)
-            name = dev->GetNameAndDetails(true);
-        else
-            name = dev->GetFriendlyName(true);
-
-        item = new ListBoxDevice(m_backends, name, dev);
-        m_devices.insert(USN, item);
-
-        // Pre-select at least one item:
-        if (m_backends->numRows() == 1)
-            m_backends->setSelected(0, true);
-    }
-
-    dev->Release();
-}
-
-/**
- * Attempt UPnP connection to a backend device, get its DB details.
- * Will loop until a valid PIN is entered.
- */
-bool BackendSelect::Connect(DeviceLocation *dev)
-{
-    QString          error;
-    QString          message;
-    UPnPResultCode   stat;
-    MythXMLClient   *xml;
-
-    m_USN = dev->m_sUSN;
-    xml   = new MythXMLClient(dev->m_sLocation);
-    stat  = xml->GetConnectionInfo(m_PIN, m_DBparams, message);
-    error = dev->GetFriendlyName(true);
-    if (error == "<Unknown>")
-        error = dev->m_sLocation;
-    error += ". " + message;
-    dev->Release();
-
-    switch (stat)
-    {
-        case UPnPResult_Success:
-            VERBOSE(VB_UPNP, "Connect() - success. New hostname: "
-                             + m_DBparams->dbHostName);
-            return true;
-
-        case UPnPResult_HumanInterventionRequired:
-            VERBOSE(VB_UPNP, error);
-            MythPopupBox::showOkPopup(m_parent, "", tr(message));
-            break;
-
-        case UPnPResult_ActionNotAuthorized:
-            VERBOSE(VB_UPNP, "Access denied for " + error + ". Wrong PIN?");
-            message = "Please enter the backend access PIN";
-            do
-            {
-                m_PIN = MythPopupBox::showPasswordPopup(
-                    m_parent, "Backend PIN entry", tr(message));
-                stat = xml->GetConnectionInfo(m_PIN, m_DBparams, message);
-            }
-            while (stat == UPnPResult_ActionNotAuthorized);
-            if (stat == UPnPResult_Success)
-                return true;
-
-        default:
-            VERBOSE(VB_UPNP, "GetConnectionInfo() failed for " + error);
-            MythPopupBox::showOkPopup(m_parent, "", tr(message));
-    }
-
-    // Back to the list, so the user can choose a different backend:
-    m_backends->setFocus();
-    return false;
-}
-
-void BackendSelect::CreateUI(void)
-{
-    // Probably should all be members, and deleted by ~BackendSelect()
-    QLabel         *label;
-    QGridLayout    *layout;
-    MythPushButton *cancel;
-    MythPushButton *manual;
-    MythPushButton *OK;
-    //MythPushButton *search;   // I don't see the need for this?
-
-
-    label = new QLabel(tr("Please select default Myth Backend Server"), this);
-    label->setBackgroundOrigin(QWidget::WindowOrigin);
-
-    m_backends = new MythListBox(this);
-    OK         = new MythPushButton(tr("OK"), this);
-    cancel     = new MythPushButton(tr("Cancel"), this);
-    manual     = new MythPushButton(tr("Configure Manually"), this);
-    //search     = new MythPushButton(tr("Search"), this);
-
-
-    layout = new QGridLayout(this, 5, 5, 40);
-    layout->addMultiCellWidget(label, 0, 0, 1, 3);
-    layout->addMultiCellWidget(m_backends, 1, 1, 0, 4);
-
-    layout->addMultiCellWidget(manual, 4, 4, 0, 1);
-    //layout->addWidget(search, 4, 0);
-    //layout->addWidget(manual, 4, 1);
-    layout->addWidget(cancel, 4, 3);
-    layout->addWidget(OK    , 4, 4);
-
-
-    connect(m_backends, SIGNAL(accepted(int)), SLOT(Accept()));
-    //connect(search,     SIGNAL(clicked()),     SLOT(Search()));
-    connect(manual,     SIGNAL(clicked()),     SLOT(Manual()));
-    connect(cancel,     SIGNAL(clicked()),     SLOT(reject()));
-    connect(OK,         SIGNAL(clicked()),     SLOT(Accept()));
-}
-
-void BackendSelect::customEvent(QCustomEvent *e)
-{
-    if (MythEvent::MythEventMessage != ((MythEvent::Type)(e->type())))
-        return;
-
-
-    MythEvent *me      = (MythEvent *)e;
-    QString    message = me->Message();
-    QString    URI     = me->ExtraData(0);
-    QString    URN     = me->ExtraData(1);
-    QString    URL     = me->ExtraData(2);
-
-
-    VERBOSE(VB_UPNP, "BackendSelect::customEvent(" + message
-                     + ", " + URI + ", " + URN + ", " + URL + ")");
-
-    if (message.startsWith("SSDP_ADD") &&
-        URI.startsWith("urn:schemas-mythtv-org:device:MasterMediaServer:"))
-    {
-        DeviceLocation *devLoc = UPnp::g_SSDPCache.Find(URI, URN);
-
-        if (devLoc != NULL)
-        {
-            devLoc->AddRef();
-            AddItem(devLoc);
-        }
-    }
-    else if (message.startsWith("SSDP_REMOVE"))
-    {
-        //-=>Note: This code will never get executed until
-        //         SSDPCache is changed to handle NotifyRemove correctly
-        RemoveItem(URN);
-    }
-}
-
-void BackendSelect::FillListBox(void)
-{
-    EntryMap::Iterator  it;
-    EntryMap            ourMap;
-    DeviceLocation     *pDevLoc;
-    
-
-    SSDPCacheEntries *pEntries = UPnp::g_SSDPCache.Find(gBackendURI);
-
-    if (!pEntries)
-        return;
-
-    pEntries->AddRef();
-    pEntries->Lock();
-
-    EntryMap *pMap = pEntries->GetEntryMap();
-
-    for (it = pMap->begin(); it != pMap->end(); ++it)
-    {
-        pDevLoc = (DeviceLocation *)it.data();
-
-        if (!pDevLoc)
-            continue;
-
-        pDevLoc->AddRef();
-        ourMap.insert(pDevLoc->m_sUSN, pDevLoc);
-    }
-
-
-    pEntries->Unlock();
-    pEntries->Release();
-
-    for (it = ourMap.begin(); it != ourMap.end(); ++it)
-    {
-        pDevLoc = (DeviceLocation *)it.data();
-        AddItem(pDevLoc);
-        pDevLoc->Release();
-    }
-}
-
-void BackendSelect::Manual(void)
-{
-    done(kDialogCodeButton0);
-}
-
-void BackendSelect::RemoveItem(QString USN)
-{
-    ItemMap::iterator it = m_devices.find(USN);
-
-    if (it != m_devices.end())
-    {
-        ListBoxDevice *item = it.data();
-
-        if (item != NULL)
-            delete item;
-
-        m_devices.remove(it);
-    }
-}
-
-//void BackendSelect::Search(void)
-//{
-//    UPnp::PerformSearch(gBackendURI);
-//}

mythtv/libs/libmythupnp/upnp.cpp

@@ -17 +17 @@
 // Global/Class Static variables
 //////////////////////////////////////////////////////////////////////////////
 
+const QString UPnp::kBackendURI
+              = "urn:schemas-mythtv-org:device:MasterMediaServer:1";
+const QString UPnp::kDefaultPIN
+              = "UPnP/MythFrontend/DefaultBackend/SecurityPin";
+const QString UPnp::kDefaultUSN
+              = "UPnP/MythFrontend/DefaultBackend/USN";
+
+
 UPnpDeviceDesc   UPnp::g_UPnpDeviceDesc;
 TaskQueue       *UPnp::g_pTaskQueue     = NULL;
 SSDP            *UPnp::g_pSSDP          = NULL;

mythtv/libs/libmythupnp/libmythupnp.pro

@@ -46 +46 @@
     target.path = $${PREFIX}/bin
 }
 
-inc.path = $${PREFIX}/include/mythtv/upnp/
+inc.path = $${PREFIX}/include/mythtv/libmythupnp/
 
 inc.files  = httprequest.h upnp.h ssdp.h taskqueue.h bufferedsocketdevice.h
 inc.files += upnpdevice.h upnptasknotify.h upnptasksearch.h threadpool.h upnputil.h
 inc.files += httpserver.h httpstatus.h upnpcds.h upnpcdsobjects.h
 inc.files += eventing.h upnpcmgr.h upnptaskevent.h upnptaskcache.h ssdpcache.h
 inc.files += upnpimpl.h multicast.h broadcast.h configuration.h
-inc.files += soapclient.h mythxmlclient.h
+inc.files += soapclient.h mythxmlclient.h refcounted.h
 
 INSTALLS += inc
 
@@ -63 +63 @@
 freebsd:HEADERS += darwin-sendfile.h 
 freebsd:SOURCES += darwin-sendfile.c 
 
-macx {
-    HEADERS += darwin-sendfile.h
-    SOURCES += darwin-sendfile.c
-
-    # This lib depends on libmyth which depends on some stuff in libmythui.
-    # It isn't built yet, so we have to ignore these for now:
-    QMAKE_LFLAGS_SHLIB += -flat_namespace -undefined warning
-}
+macx:HEADERS += darwin-sendfile.h
+macx:SOURCES += darwin-sendfile.c

mythtv/libs/libmythupnp/upnp.h

@@ -99 +99 @@
         int                     m_nServicePort;
 
     public:
+        // Some common UPnP search and XML value strings:
 
+        /// Service type for the backend's UPnP server
+        static const QString    kBackendURI;
+
+        // PIN and Unique Service Name of the default backend.
+        // Stored in config.xml:
+        static const QString    kDefaultPIN;
+        static const QString    kDefaultUSN;
+
+
+
         static Configuration   *g_pConfig;
 
         static UPnpDeviceDesc   g_UPnpDeviceDesc;

mythtv/programs/mythuitest/main.cpp

@@ -5 +5 @@
 #include <cstdlib>
 using namespace std;
 
-#include "mythmainwindow.h"
-#include "mythuiimage.h"
-#include "mythscreenstack.h"
-#include "mythscreentype.h"
-#include "myththemebase.h"
+#include "libmythui/mythmainwindow.h"
+#include "libmythui/mythuiimage.h"
+#include "libmythui/mythscreenstack.h"
+#include "libmythui/mythscreentype.h"
+#include "libmythui/myththemebase.h"
+#include "libmythtv/mythcontextui.h"
 
-#include "mythcontext.h"
-
 #include "test1.h"
-#include "oldsettings.h"
+#include "libmyth/oldsettings.h"
 //#include "btnlisttest.h"
 
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
+    gContext = (MythContext *) new MythContextGUI(MYTH_BINARY_VERSION);
     gContext->Init();
 
     QString themename = gContext->GetSetting("Theme");

mythtv/programs/programs-libs.pro

@@ -10 +10 @@
 LIBS += -L../../libs/libmythupnp
 LIBS += -L../../libs/libmythlivemedia
 
-LIBS += -lmythtv-$$LIBVERSION -lmythavformat-$$LIBVERSION
+LIBS += -lmyth-$$LIBVERSION -lmythtv-$$LIBVERSION -lmythavformat-$$LIBVERSION
 LIBS += -lmythavutil-$$LIBVERSION -lmythavcodec-$$LIBVERSION 
 LIBS += -lmythfreemheg-$$LIBVERSION
+LIBS += -lmythui-$$LIBVERSION
 LIBS += -lmythupnp-$$LIBVERSION 
 LIBS += -lmythlivemedia-$$LIBVERSION
-LIBS += -lmyth-$$LIBVERSION -lmythui-$$LIBVERSION $$EXTRA_LIBS
+LIBS += -lmythui-$$LIBVERSION $$EXTRA_LIBS
 mingw {
     LIBS += -lpthread
     CONFIG += console

mythtv/programs/mythfrontend/globalsettings.cpp

@@ -22 +22 @@
 #include "libmyth/mythconfig.h"
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
-#include "libmyth/dbsettings.h"
+#include "libmythtv/dbsettings.h"
 #include "libmyth/langsettings.h"
 #include "libmythtv/mpeg/iso639.h"
 #include "playbackbox.h"

mythtv/programs/mythfrontend/main.cpp

@@ -51 +51 @@
 #include "lcddevice.h"
 #include "langsettings.h"
 
+#include "libmythtv/mythcontextui.h"
 #include "libmythui/myththemedmenu.h"
 #include "libmythui/myththemebase.h"
 #include "mediarenderer.h"
@@ -1067 +1068 @@
         MythContext::SetX11Display(display);
     }
 
-    gContext = new MythContext(MYTH_BINARY_VERSION);
+    MythContextGUI * context = new MythContextGUI(MYTH_BINARY_VERSION);
     g_pUPnp  = new MediaRenderer();
 
-    if (!gContext->Init(true, g_pUPnp, bPromptForBackend, bBypassAutoDiscovery))
+    if (!context->Init(g_pUPnp, bPromptForBackend, bBypassAutoDiscovery))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return FRONTEND_EXIT_NO_MYTHCONTEXT;
@@ -1326 +1327 @@
         return FRONTEND_EXIT_NO_THEME;
     }
 
-    gContext->LoadQtConfig();
+    MythMainWindow *mainWindow = gContext->CreateMainWindow();
 
-    MythMainWindow *mainWindow = GetMythMainWindow();
-    mainWindow->Init();
-    gContext->SetMainWindow(mainWindow);
-
     gContext->UpdateImageCache();
     themeBase = new MythThemeBase();
 

mythtv/programs/mythjobqueue/main.cpp

@@ -18 +18 @@
 #include "libmyth/mythcontext.h"
 #include "libmythtv/jobqueue.h"
 #include "libmyth/mythdbcon.h"
+#include "libmythtv/mythcontextui.h"
 
 using namespace std;
 
@@ -103 +104 @@
         ++argpos;
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY *context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return JOBQUEUE_EXIT_NO_MYTHCONTEXT;

mythtv/programs/mythtranscode/main.cpp

@@ -14 +14 @@
 #include <fstream>
 using namespace std;
 
-#include "exitcodes.h"
-#include "programinfo.h"
-#include "jobqueue.h"
-#include "mythcontext.h"
-#include "mythdbcon.h"
+#include "libmyth/exitcodes.h"
+#include "libmythtv/programinfo.h"
+#include "libmythtv/jobqueue.h"
+#include "libmyth/mythcontext.h"
+#include "libmyth/mythdbcon.h"
+#include "libmythtv/mythcontextui.h"
 #include "transcode.h"
 #include "mpeg2fix.h"
 
@@ -396 +397 @@
     }
 
     //  Load the context
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY *context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return TRANSCODE_EXIT_NO_MYTHCONTEXT;

mythtv/programs/mythcommflag/main.cpp

@@ -23 +23 @@
 #include "libmythtv/jobqueue.h"
 #include "libmythtv/remoteencoder.h"
 #include "libmyth/mythdbcon.h"
+#include "libmythtv/mythcontextui.h"
 
 #include "CommDetector.h"
 #include "CommDetectorBase.h"
@@ -922 +923 @@
         ++argpos;
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY * context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return COMMFLAG_EXIT_NO_MYTHCONTEXT;

mythtv/programs/mythbackend/mythxml.cpp

@@ -1476 +1476 @@
         return;
     }
 
-    DatabaseParams params = gContext->GetDatabaseParams();
+    DatabaseParams params = gDBparams;
 
     // Check for DBHostName of "localhost" and change to public name or IP 
 

mythtv/programs/mythbackend/main.cpp

@@ -41 +41 @@
 #include "libmythtv/jobqueue.h"
 #include "libmythtv/storagegroup.h"
 #include "libmythtv/previewgenerator.h"
+#include "libmythtv/mythcontextui.h"
 
 #include "mediaserver.h"
 #include "httpstatus.h"
@@ -741 +742 @@
         pidfs.close();
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY * context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return BACKEND_EXIT_NO_MYTHCONTEXT;

mythtv/programs/mythtv-setup/main.cpp

@@ -23 +23 @@
 #include "libmyth/dialogbox.h"
 #include "libmyth/exitcodes.h"
 #include "libmyth/util.h"
+#include "libmythtv/mythcontextui.h"
 #include "libmythui/myththemedmenu.h"
 #include "libmythui/myththemebase.h"
 
@@ -240 +241 @@
         MythContext::SetX11Display(display);
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-
-    if (!gContext->Init(true))
+    MythContextGUI *context = new MythContextGUI(MYTH_BINARY_VERSION);
+    if (!context->Init())
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return -1;
@@ -279 +278 @@
     UpgradeTVDatabaseSchema();
 
     gContext->SetSetting("Theme", "G.A.N.T");
-    gContext->LoadQtConfig();
 
     QString fileprefix = MythContext::GetConfDir();
 
@@ -287 +285 @@
     if (!dir.exists())
         dir.mkdir(fileprefix);
 
-    MythMainWindow *mainWindow = GetMythMainWindow();
-    mainWindow->Init();
-    gContext->SetMainWindow(mainWindow);
+    MythMainWindow *mainWindow = context->CreateMainWindow();
 
     gContext->UpdateImageCache();
     MythThemeBase *themeBase = new MythThemeBase();

mythtv/programs/mythlcdserver/main.cpp

@@ -16 +16 @@
 #include <fcntl.h>
 #include <signal.h>
 
-#include "exitcodes.h"
-#include "mythcontext.h"
-#include "mythdbcon.h"
-#include "tv_play.h"
+#include "libmyth/exitcodes.h"
+#include "libmyth/mythcontext.h"
+#include "libmyth/mythdbcon.h"
+#include "libmythtv/tv_play.h"
+#include "libmythtv/mythcontextui.h"
 #include "compat.h"
 
 #include "lcdserver.h"
@@ -229 +230 @@
     }
 
     //  Get the Myth context and db hooks
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY *context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "lcdserver: Could not initialize myth context. "
                         "Exiting.");

mythtv/programs/mythtv/main.cpp

@@ -6 +6 @@
 #include <qregexp.h>
 #include <qdir.h>
 
-#include "tv_play.h"
-#include "programinfo.h"
+#include "libmythtv/tv_play.h"
+#include "libmythtv/programinfo.h"
 
 #include "libmyth/exitcodes.h"
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
 #include "libmyth/mythdialogs.h"
 #include "libmyth/compat.h"
+#include "libmythtv/mythcontextui.h"
 
 #include <iostream>
 using namespace std;
@@ -200 +201 @@
         gContext->SetX11Display(display);
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init())
+    MythContextGUI *context = new MythContextGUI(MYTH_BINARY_VERSION);
+    if (!context->Init())
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return TV_EXIT_NO_MYTHCONTEXT;
@@ -249 +249 @@
         return TV_EXIT_NO_THEME;
     }
     
-    gContext->LoadQtConfig();
-
 #if defined(Q_OS_MACX)
     // Mac OS X doesn't define the AudioOutputDevice setting
 #else
@@ -263 +261 @@
     }
 #endif
 
-    MythMainWindow *mainWindow = GetMythMainWindow();
-    mainWindow->Init();
-    gContext->SetMainWindow(mainWindow);
+    context->CreateMainWindow();
 
     TV::InitKeys();
 

mythtv/programs/mythwelcome/main.cpp

@@ -14 +14 @@
 #include "libmyth/compat.h"
 
 #include "libmythtv/tv.h"
+#include "libmythtv/mythcontextui.h"
 
 #include "welcomedialog.h"
 #include "welcomesettings.h"
@@ -38 +39 @@
 
     QApplication a(argc, argv);
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
+    gContext = (MythContext *) new MythContextGUI(MYTH_BINARY_VERSION);
     if (!gContext->Init(false)) 
     {
         VERBOSE(VB_IMPORTANT, "mythwelcome: Could not initialize myth context. "
@@ -122 +122 @@
 
     LanguageSettings::load("mythfrontend");
 
-    gContext->LoadQtConfig();
+    MythMainWindow *mainWindow = gContext->CreateMainWindow();
 
-    MythMainWindow *mainWindow = GetMythMainWindow();
-    mainWindow->Init();
-    gContext->SetMainWindow(mainWindow);
-
     initKeys();
 
     if (bShowSettings)

mythtv/programs/mythfilldatabase/main.cpp

@@ -22 +22 @@
 // filldata headers
 #include "filldata.h"
 
+
+#include "libmythtv/mythcontextui.h"
+
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv, false);
@@ -471 +474 @@
         ++argpos;
     }
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY *context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
         return FILLDB_EXIT_NO_MYTHCONTEXT;

mythtv/programs/mythshutdown/main.cpp

@@ -7 +7 @@
 using namespace std;
 #include <unistd.h>
 
-#include <exitcodes.h>
-#include <mythcontext.h>
-#include <mythdbcon.h>
+#include "libmyth/exitcodes.h"
+#include "libmyth/mythcontext.h"
+#include "libmyth/mythdbcon.h"
 #include "libmythtv/programinfo.h"
 #include "libmythtv/jobqueue.h"
-#include "tv.h"
-#include "remoteutil.h"
-#include "compat.h"
+#include "libmythtv/tv.h"
+#include "libmythtv/remoteutil.h"
+#include "libmythtv/mythcontextui.h"
+#include "libmyth/compat.h"
 
 void setGlobalSetting(const QString &key, const QString &value)
 {
@@ -712 +713 @@
 
     QApplication a(argc, argv, false);
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY *context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(NULL))
     {
         cout << "mythshutdown: Could not initialize myth context. "
                 "Exiting." << endl;

mythplugins/programs-libs.pro

@@ -1 +1 @@
 INCLUDEPATH += $${PREFIX}/include/mythtv
 
 LIBS += -L$${PREFIX}/lib $$EXTRA_LIBS
-LIBS += -lmyth-$$LIBVERSION -lmythui-$$LIBVERSION -lmythupnp-$$LIBVERSION
 
+# To initialise the MythContext subclass, we now need all these libraries.
+LIBS += -lmythavcodec-$$LIBVERSION  -lmythavutil-$$LIBVERSION
+LIBS += -lmythavformat-$$LIBVERSION
+LIBS += -lmythfreemheg-$$LIBVERSION -lmythlivemedia-$$LIBVERSION
+LIBS += -lmythupnp-$$LIBVERSION     -lmythtv-$$LIBVERSION
+
 mac:using_firewire:using_backend:LIBS += -F$${CONFIG_MAC_AVC} -framework AVCVideoServices

mythplugins/mytharchive/mytharchivehelper/main.cpp

@@ -29 +29 @@
 #include <mythtv/exitcodes.h>
 #include <mythtv/mythdbcon.h>
 #include <mythtv/libmythtv/programinfo.h>
+#include <mythtv/libmythtv/mythcontextui.h>
 extern "C" {
 #include <mythtv/ffmpeg/avcodec.h>
 #include <mythtv/ffmpeg/avformat.h>
@@ -2249 +2250 @@
 
 int getDBParamters(QString outFile)
 {
-    DatabaseParams params = gContext->GetDatabaseParams();
+    DatabaseParams params = gDBparams;
 
     // save the db paramters to the file
     QFile f(outFile);
@@ -2353 +2354 @@
 
     QApplication a(argc, argv, false);
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+    MythContextTTY * context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(false))
     {
         cout << "mytharchivehelper: Could not initialize myth context. "
                 "Exiting." << endl;;

mythplugins/mythbrowser/mythbrowser/main.cpp

@@ -21 +21 @@
 #include "mythtv/mythcontext.h"
 #include "mythtv/mythdbcon.h"
 #include "mythtv/langsettings.h"
+#include "libmythtv/mythcontextui.h"
 
 
 static const char *version = "v0.32";
@@ -94 +95 @@
 
     KApplication a(argc,argv);
 
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(true))
+    gContext = (MythContext *) new MythContextGUI(MYTH_BINARY_VERSION);
+    if (!gContext->Init())
     {
         VERBOSE(VB_IMPORTANT, "MythBrowser: Could not initialize myth context. Exiting.");
         return FRONTEND_EXIT_NO_MYTHCONTEXT;
@@ -122 +122 @@
 
     LanguageSettings::load("mythbrowser");
 
-    gContext->LoadQtConfig();
+    MythMainWindow *mainWindow = gContext->CreateMainWindow();
+
     setupKeys();
 
-    MythMainWindow *mainWindow = GetMythMainWindow();
-    mainWindow->Init();
-    gContext->SetMainWindow(mainWindow);
-
     TabView *tabView = 
             new TabView(mainWindow, "mythbrowser", urls, zoom, width, height,
                         Qt::WStyle_Customize | Qt::WStyle_NoBorder);

mythplugins/mythvideo/mtd/main.cpp

@@ -20 +20 @@
 #include <mythtv/mythdbcon.h>
 #include <mythtv/langsettings.h>
 #include <mythtv/compat.h>
+#include <mythtv/libmythtv/mythcontextui.h>
 
 #include "../mythvideo/dbcheck.h"
 #include "mtd.h"
@@ -112 +113 @@
     //
     //  Get the Myth context and db hooks
     //    
-    
-    gContext = NULL;
-    gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
+
+    MythContextTTY * context = new MythContextTTY(MYTH_BINARY_VERSION);
+    if (!context->Init(false))
     {
         cerr << "Could not initialize myth context. Exiting." << endl;
         return FRONTEND_EXIT_NO_MYTHCONTEXT;