Ticket #10092: mythfrontendsetup-07-02-2012.2.diff

mythtv/programs/mythfrontend/main.cpp

@@ -1 @@
-#include <unistd.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <cerrno>
@@ -74 +73 @@
 #include "themechooser.h"
 #include "mythversion.h"
 #include "taskqueue.h"
+#include "standardsettings.h"
 
 // Video
 #include "cleanup.h"
@@ -138 +138 @@
 
             if (passwordValid)
             {
-                VideoGeneralSettings settings;
-                settings.exec();
+                MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
+                StandardSettingDialog *ssd = new StandardSettingDialog(mainStack, "videogeneralsettings");
+
+                if (ssd->Create())
+                {
+                    ssd->loadSettings(new VideoGeneralSettings());
+                    mainStack->AddScreen(ssd);
+                }
+                else
+                    delete ssd;
             }
             else
             {

mythtv/programs/mythfrontend/mythfrontend.pro

@@ -39 +39 @@
 HEADERS += videofilter.h                videolist.h
 HEADERS += videoplayersettings.h        videodlg.h
 HEADERS += videoglobalsettings.h        upnpscanner.h
-HEADERS += commandlineparser.h
+HEADERS += commandlineparser.h          standardsettings.h
 
 SOURCES += main.cpp playbackbox.cpp viewscheduled.cpp audiogeneralsettings.cpp
 SOURCES += globalsettings.cpp manualschedule.cpp programrecpriority.cpp
@@ -60 +60 @@
 SOURCES += videofilter.cpp              videolist.cpp
 SOURCES += videoplayersettings.cpp      videodlg.cpp
 SOURCES += videoglobalsettings.cpp      upnpscanner.cpp
-SOURCES += commandlineparser.cpp
+SOURCES += commandlineparser.cpp        standardsettings.cpp
 
 HEADERS += serviceHosts/frontendServiceHost.h
 HEADERS += services/frontend.h

new file mythtv/programs/mythfrontend/standardsettings.cpp

@@ +1 @@
+#include "standardsettings.h"
+#include <QCoreApplication>
+
+#include <mythcontext.h>
+#include <mythmainwindow.h>
+#include <mythdialogbox.h>
+#include <mythuispinbox.h>
+#include <mythuitext.h>
+#include <mythuibutton.h>
+#include "mythlogging.h"
+
+
+MythUIButtonListItem * NewConfigurable::createButton(MythUIButtonList * list)
+{
+    MythUIButtonListItem *item = new MythUIButtonListItem(list, label);
+    updateButton(item);
+    return item;
+}
+
+StandardSetting::StandardSetting(Storage *_storage) : 
+    NewConfigurable(_storage),
+    m_parent(0)
+{
+}
+
+StandardSetting::~StandardSetting()
+{   
+    QList<StandardSetting *>::const_iterator i;
+    for (i = m_children.constBegin(); i != m_children.constEnd(); ++i)
+        delete *i;
+    m_children.clear();
+
+    QMap<QString, QList<StandardSetting *> >::const_iterator iMap;
+    for (iMap = m_targets.constBegin(); iMap != m_targets.constEnd(); ++iMap)
+    {
+        for (i = (*iMap).constBegin(); i != (*iMap).constEnd(); ++i)
+            delete *i;
+    }
+    m_targets.clear();
+}
+
+void StandardSetting::setParent(StandardSetting *parent)
+{
+    m_parent = parent;
+}
+
+StandardSetting * StandardSetting::getParent()
+{
+    return m_parent;
+}
+
+void StandardSetting::addChild(StandardSetting *child)
+{
+    if (!child)return;
+    m_children.append(child);
+    child->setParent(this);
+}
+
+void StandardSetting::updateButton(MythUIButtonListItem *item)
+{
+    item->SetText(label);
+    item->SetText(settingValue,"value");
+    item->setDrawArrow (haveSubSettings());
+    item->SetData(qVariantFromValue(this));
+
+}
+
+void StandardSetting::addTargetedChild(const QString &value, StandardSetting * setting)
+{
+    m_targets[value].append(setting);
+    setting->setParent(this);
+}
+
+
+QList<StandardSetting *> *StandardSetting::getSubSettings()
+{
+    if (settingValue.isEmpty())
+        return &m_children;
+    else if (m_targets.contains(settingValue))
+        return &m_targets[settingValue];
+    return NULL;
+}
+
+bool StandardSetting::haveSubSettings()
+{
+    QList<StandardSetting *> * subSettings=getSubSettings();
+    return (subSettings!=NULL && subSettings->size()>0);
+}
+
+void StandardSetting::setValue(const QString &newValue)
+{
+    settingValue = newValue;
+    emit valueChanged(settingValue);
+}
+
+bool StandardSetting::haveChanged()
+{
+    if (m_haveChanged) return true;
+
+    //we check only the relevant children
+    QList<StandardSetting *> *children = getSubSettings();
+    if (children==NULL) return false;
+    QList<StandardSetting *>::const_iterator i;
+    bool haveChanged = false;
+    for (i = children->constBegin(); !haveChanged && i != children->constEnd(); ++i)
+        haveChanged=(*i)->haveChanged();
+
+    return haveChanged;
+}
+
+void StandardSetting::Load(void)
+{
+    m_haveChanged=false;
+
+    LoadChildren();
+}
+
+void StandardSetting::LoadChildren(void)
+{
+    QList<StandardSetting *>::const_iterator i;
+    for (i = m_children.constBegin(); i != m_children.constEnd(); ++i)
+        (*i)->Load();
+
+    QMap<QString, QList<StandardSetting *> >::const_iterator iMap;
+    for (iMap = m_targets.constBegin(); iMap != m_targets.constEnd(); ++iMap)
+    {
+        for (i = (*iMap).constBegin(); i != (*iMap).constEnd(); ++i)
+            (*i)->Load();
+    }
+    
+}
+void StandardSetting::Save(void)
+{
+    m_haveChanged=false;
+    SaveChildren();
+}
+
+void StandardSetting::SaveChildren(void)
+{
+    //we save only the relevant children
+    QList<StandardSetting *> *children = getSubSettings();
+    if (children==NULL) return;
+    QList<StandardSetting *>::const_iterator i;
+    for (i = children->constBegin(); i != children->constEnd(); ++i)
+        (*i)->Save();
+}
+
+/*******************************************************************************
+                            Group Setting
+********************************************************************************/
+GroupSetting::GroupSetting():
+    StandardSetting(this)
+{
+}
+
+bool GroupSetting::edit(MythScreenType * screen)
+{
+    DialogCompletionEvent *dce =
+            new DialogCompletionEvent("leveldown", 0, "", "");
+    QCoreApplication::postEvent(screen, dce);
+    return true;
+}
+
+
+/*******************************************************************************
+                            Text Setting
+********************************************************************************/
+
+MythUITextEditSetting::MythUITextEditSetting(Storage *_storage):
+    StandardSetting(_storage)
+{
+}
+
+bool MythUITextEditSetting::edit(MythScreenType * screen)
+{
+
+    MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
+
+    MythTextInputDialog *settingdialog =
+                                    new MythTextInputDialog(popupStack,
+                                    getLabel(),FilterNone, false,settingValue);
+
+    if (settingdialog->Create())
+    {
+        settingdialog->SetReturnEvent(screen, "editsetting");
+        popupStack->AddScreen(settingdialog);
+        return true;
+    }
+    return false;
+};
+
+void MythUITextEditSetting::resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item)
+{
+    if (settingValue!=dce->GetResultText())
+    {
+        setValue(dce->GetResultText());
+        m_haveChanged=true;
+        this->updateButton(item);
+    }
+}
+
+/*******************************************************************************
+                            ComboBoxSetting
+********************************************************************************/
+
+MythUIComboBoxSetting::MythUIComboBoxSetting(Storage *_storage):
+    StandardSetting(_storage)
+{
+}
+
+MythUIComboBoxSetting::~MythUIComboBoxSetting()
+{
+    m_labels.clear();
+    m_values.clear();
+}
+
+void MythUIComboBoxSetting::addSelection(const QString &label, QString value,
+                                 bool select)
+{
+    value = (value.isEmpty()) ? label : value;
+    m_labels.push_back(label);
+    m_values.push_back(value);
+
+    if (select || !m_isSet)
+    {
+        setValue(value);
+        if (!m_isSet) m_isSet = true;
+    } 
+}
+
+void MythUIComboBoxSetting::updateButton(MythUIButtonListItem *item)
+{
+    item->SetText(label);
+    int indexValue = m_values.indexOf(settingValue);
+    if (indexValue >=0)
+        item->SetText(m_labels.value(indexValue),"value");
+    else
+        item->SetText("","value");
+    item->setDrawArrow (haveSubSettings());
+    item->SetData(qVariantFromValue((StandardSetting*)this));
+
+}
+
+bool MythUIComboBoxSetting::edit(MythScreenType * screen)
+{
+    MythScreenStack *popupStack =
+                            GetMythMainWindow()->GetStack("popup stack");
+
+    MythDialogBox * m_menuPopup =
+            new MythDialogBox(getLabel(), popupStack, "optionmenu");
+
+    if (m_menuPopup->Create())
+        popupStack->AddScreen(m_menuPopup);
+
+    m_menuPopup->SetReturnEvent(screen, "editsetting");
+
+    for (int i = 0; i < m_labels.size() && m_values.size(); ++i)
+    {
+        QString value = m_values.at(i);
+        m_menuPopup->AddButton(m_labels.at(i),value,false,value==settingValue);
+    }
+
+    return true;
+}
+
+void MythUIComboBoxSetting::resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item)
+{
+    if (dce->GetResult()!=-1 && settingValue!=dce->GetData().toString())
+    {
+        setValue(dce->GetData().toString());
+        m_haveChanged=true;
+        updateButton(item);
+    }
+}
+
+/*******************************************************************************
+                           MythUICheckBoxSetting
+********************************************************************************/
+
+MythUICheckBoxSetting::MythUICheckBoxSetting(Storage *_storage):
+    StandardSetting(_storage)
+{
+}
+
+bool MythUICheckBoxSetting::boolValue()
+{
+    return settingValue=="1";
+}
+
+
+void MythUICheckBoxSetting::setValue(bool value)
+{
+    StandardSetting::setValue(value?"1":"0");
+}
+
+void MythUICheckBoxSetting::updateButton(MythUIButtonListItem *item)
+{
+    item->SetText(label);
+    item->setCheckable (true);
+    if (settingValue=="1")
+        item->setChecked(MythUIButtonListItem::FullChecked);
+    else
+        item->setChecked(MythUIButtonListItem::NotChecked);
+    item->setDrawArrow(haveSubSettings());
+    item->SetData(qVariantFromValue((StandardSetting*)this));
+
+}
+
+bool MythUICheckBoxSetting::edit(MythScreenType * screen)
+{
+    DialogCompletionEvent *dce =
+            new DialogCompletionEvent("editsetting", 0, "", "");
+    QCoreApplication::postEvent(screen, dce);
+    return true;
+
+}
+
+void MythUICheckBoxSetting::resultEdit(DialogCompletionEvent *dce, 
+    MythUIButtonListItem *item)
+{
+    setValue(!boolValue());
+    m_haveChanged=true;
+    updateButton(item);
+}
+
+/*******************************************************************************
+                           Standard setting dialog
+********************************************************************************/
+
+StandardSettingDialog::StandardSettingDialog(MythScreenStack *parent, const char *name) :
+    MythScreenType(parent, name),
+    m_buttonList(0),
+    m_title(0),
+    m_groupHelp(0),
+    m_selectedSettingHelp(0),
+    m_menuPopup(0),
+    m_settingsTree(0),
+    m_currentGroupSetting(0)
+{
+}
+
+StandardSettingDialog::~StandardSettingDialog()
+{
+    LOG(VB_GENERAL, LOG_ERR, "StandardSettingDialog::~StandardSettingDialog()");
+    if (m_settingsTree!=0)
+        m_settingsTree->deleteLater();
+}
+
+bool StandardSettingDialog::Create(void)
+{
+    if (!LoadWindowFromXML("standardsetting-ui.xml", "settingssetup", this))
+        return false;
+
+    bool error=false;
+    UIUtilE::Assign(this, m_title, "title",&error);
+    UIUtilW::Assign(this, m_groupHelp, "grouphelp",&error);
+    UIUtilE::Assign(this, m_buttonList,"settingslist",&error);
+
+    UIUtilW::Assign(this, m_selectedSettingHelp, "selectedsettinghelp");
+
+    connect(m_buttonList,SIGNAL(itemSelected(MythUIButtonListItem*)), 
+        this,SLOT(settingSelected(MythUIButtonListItem*)));
+    connect(m_buttonList,SIGNAL(itemClicked(MythUIButtonListItem*)), 
+        this,SLOT(settingClicked(MythUIButtonListItem*)));
+
+    if (error)
+    {
+        LOG(VB_GENERAL, LOG_ERR, "error.");
+        return false;
+    }
+    BuildFocusList();
+
+    return true;
+}
+
+void StandardSettingDialog::settingSelected(MythUIButtonListItem *item)
+{ 
+    if (!item)return;
+
+    StandardSetting * setting = qVariantValue<StandardSetting*>(item->GetData());
+    if (setting)
+    {
+        if (m_selectedSettingHelp)
+            m_selectedSettingHelp->SetText(setting->getHelpText());
+    }
+}
+
+void StandardSettingDialog::settingClicked(MythUIButtonListItem *item)
+{
+    StandardSetting* setting = item->GetData().value<StandardSetting*>();
+    if (setting)
+    {
+        setting->edit(this);
+    }
+}
+
+void StandardSettingDialog::customEvent(QEvent *event)
+{
+    if (event->type() == DialogCompletionEvent::kEventType)
+    {
+        DialogCompletionEvent *dce = (DialogCompletionEvent*)(event);
+        QString resultid  = dce->GetId();
+
+        if (resultid == "leveldown")
+        {
+            //a GroupSetting have been clicked
+            LevelDown();
+        }
+        else if (resultid == "editsetting")
+        {
+            MythUIButtonListItem * item = m_buttonList->GetItemCurrent();
+            if (item)
+            {
+                StandardSetting * ss = item->GetData().value<StandardSetting*>();
+                if (ss)
+                {
+                    ss->resultEdit(dce, item);
+                    ss->updateButton(item);
+                }
+            }
+        }
+        else if (resultid == "exit")
+        {
+            int buttonnum = dce->GetResult();
+            if (buttonnum == 0)
+            {
+                Save();
+                MythScreenType::Close();
+            }
+            else if (buttonnum == 1)
+                MythScreenType::Close();
+        }
+    }
+}
+
+void StandardSettingDialog::loadSettings(GroupSetting * groupSettings)
+{
+
+    m_settingsTree=groupSettings;
+    if (m_settingsTree)
+        m_settingsTree->Load();
+
+    setCurrentGroupSetting(m_settingsTree);
+}
+
+void StandardSettingDialog::setCurrentGroupSetting(StandardSetting * groupSettings, 
+        StandardSetting * selectedSetting )
+{
+    if (!groupSettings) return;
+
+    m_currentGroupSetting=groupSettings;
+    m_buttonList->Reset();
+
+    m_title->SetText(m_currentGroupSetting->getLabel());
+    if (m_groupHelp) m_groupHelp->SetText(m_currentGroupSetting->getHelpText());
+    if (!m_currentGroupSetting->haveSubSettings())return;
+    QList<StandardSetting *> * settings = m_currentGroupSetting->getSubSettings();
+    if (settings==NULL ) return;
+    QList<StandardSetting *>::const_iterator i;
+    MythUIButtonListItem *selectedItem=0;
+    for (i = settings->constBegin(); i != settings->constEnd(); ++i)
+    {
+        if (selectedSetting == (*i))
+            selectedItem =(*i)->createButton(m_buttonList);
+        else
+            (*i)->createButton(m_buttonList);
+    }
+    if (selectedItem)
+        m_buttonList->SetItemCurrent(selectedItem);
+    settingSelected(m_buttonList->GetItemCurrent());
+
+}
+
+void StandardSettingDialog::Save()
+{
+    if (m_settingsTree)
+        m_settingsTree->Save();
+}
+
+void StandardSettingDialog::LevelUp()
+{
+    if (!m_currentGroupSetting) return;
+    if (m_currentGroupSetting->getParent())
+    {
+        setCurrentGroupSetting(m_currentGroupSetting->getParent(),
+                    m_currentGroupSetting);
+    }
+}
+
+void StandardSettingDialog::LevelDown()
+{
+    MythUIButtonListItem * item = m_buttonList->GetItemCurrent();
+    if (item)
+    {
+        StandardSetting * ss = item->GetData().value<StandardSetting*>();
+        if (ss && ss->haveSubSettings())
+            setCurrentGroupSetting(ss);
+    }
+}
+
+void StandardSettingDialog::Close(void)
+{
+    if (m_settingsTree->haveChanged())
+    {
+        QString label = tr("Exit ?");
+
+        MythScreenStack *popupStack =
+                                GetMythMainWindow()->GetStack("popup stack");
+
+        MythDialogBox * m_menuPopup =
+                new MythDialogBox(label, popupStack, "exitmenu");
+
+        if (m_menuPopup->Create())
+            popupStack->AddScreen(m_menuPopup);
+
+        m_menuPopup->SetReturnEvent(this, "exit");
+
+        m_menuPopup->AddButton(tr("Save then Exit"));
+        m_menuPopup->AddButton(tr("Exit without saving changes"));
+        m_menuPopup->AddButton(tr("Cancel"));
+    }
+    else
+        MythScreenType::Close();
+}
+
+
+bool StandardSettingDialog::keyPressEvent(QKeyEvent *e)
+{
+    QStringList actions;
+    bool handled = m_buttonList->keyPressEvent(e);
+    if (handled) return true;
+    handled = GetMythMainWindow()->TranslateKeyPress("Global", e, actions);
+
+    for (int i = 0; i < actions.size() && !handled; i++)
+    {
+        QString action = actions[i];
+        handled = true;
+
+        if (action == "LEFT")
+        {
+            LevelUp();
+        }
+        else if (action == "RIGHT")
+            LevelDown();
+        else
+            handled = MythScreenType::keyPressEvent(e);
+    }
+
+    return handled;
+}
+
+
+
+
+

new file mythtv/programs/mythfrontend/standardsettings.h

@@ +1 @@
+#ifndef STANDARDSETTINGS_H_
+#define STANDARDSETTINGS_H_
+
+#include "mythuibuttonlist.h"
+#include <mythdialogbox.h>
+#include <mythuibuttontree.h>
+#include <mythgenerictree.h>
+#include <QMap>
+#include "settings.h"
+
+#include "mythlogging.h"
+
+class StandardSetting;
+
+class MPUBLIC NewConfigurable : public QObject
+{
+    Q_OBJECT
+
+  public:
+    MythUIButtonListItem * createButton(MythUIButtonList * list);
+
+    virtual void updateButton(MythUIButtonListItem *item)=0;
+/*
+    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
+                                  const char* widgetName = 0);
+    virtual void widgetInvalid(QObject*) { }*/
+
+    // A name for looking up the setting
+    void setName(QString str) {
+        configName = str;
+        if (label == QString::null)
+            setLabel(str);
+    };
+    QString getName(void) const { return configName; };
+    virtual StandardSetting* byName(const QString &name) = 0;
+
+    // A label displayed to the user
+    virtual void setLabel(QString str) { label = str; }
+    QString getLabel(void) const { return label; }
+
+    virtual void setHelpText(const QString &str)
+        { helptext = str; }
+    QString getHelpText(void) const { return helptext; }
+
+    void setVisible(bool b) { visible = b; };
+    bool isVisible(void) const { return visible; };
+
+    virtual void setEnabled(bool b) { enabled = b; }
+    bool isEnabled() { return enabled; }
+
+    Storage *GetStorage(void) { return storage; }
+
+  public slots:
+    /*virtual void enableOnSet(const QString &val);
+    virtual void enableOnUnset(const QString &val);
+    virtual void widgetDeleted(QObject *obj);*/
+
+  protected:
+    NewConfigurable(Storage *_storage) :
+        enabled(true), storage(_storage),
+        configName(""), label(""), helptext(""), visible(true) { }
+    virtual ~NewConfigurable() { }
+
+  protected:
+    bool enabled;
+    Storage *storage;
+    QString configName;
+    QString label;
+    QString helptext;
+    bool visible;
+};
+
+//Copy of Setting class
+class MPUBLIC StandardSetting : public NewConfigurable, public StorageUser
+{
+    Q_OBJECT
+
+  public:
+    // Gets
+    virtual QString getValue(void) const
+        {return settingValue;}
+
+    virtual void updateButton(MythUIButtonListItem *item);
+
+    // non-const Gets
+    virtual StandardSetting *byName(const QString &name)
+        { return (name == configName) ? this : NULL; }
+
+    // StorageUser
+    void SetDBValue(const QString &val) { setValue(val); }
+    QString GetDBValue(void) const { return getValue(); }
+
+    //added by xavier
+    //subsettings
+    void addChild(StandardSetting *child);
+    virtual QList<StandardSetting *> *getSubSettings();
+    virtual bool haveSubSettings();
+
+    StandardSetting * getParent();
+    virtual bool edit(MythScreenType * screen)=0;
+    virtual void resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item)=0;
+    //must be a better way
+    virtual void Load(void);
+    virtual void Save(void);
+
+
+    void addTargetedChild(const QString &value, StandardSetting * setting);
+    bool haveChanged();
+    //added by xavier end
+  public slots:
+    virtual void setValue(const QString &newValue);
+
+  signals:
+    void valueChanged(const QString&);
+
+  protected:
+    StandardSetting(Storage *_storage);
+    virtual ~StandardSetting();
+
+  protected:
+    void setParent(StandardSetting *parent);
+    QString settingValue;
+    void LoadChildren(void);
+    void SaveChildren(void);
+    bool m_haveChanged;
+  private:
+    //added by xavier
+    StandardSetting * m_parent;
+
+    QList<StandardSetting *> m_children;
+    QMap<QString, QList<StandardSetting *> > m_targets;
+    //added by xavier end
+};
+
+Q_DECLARE_METATYPE(StandardSetting *);
+
+
+
+
+
+class MPUBLIC MythUITextEditSetting : public StandardSetting
+{
+  public:
+    virtual void resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item);
+    virtual bool edit(MythScreenType * screen);
+  protected:
+    MythUITextEditSetting (Storage *_storage);
+    
+};
+
+class MPUBLIC HostTextEditSetting: public MythUITextEditSetting, public HostDBStorage
+{
+  public:
+    HostTextEditSetting(const QString &name) :
+        MythUITextEditSetting(this), HostDBStorage(this, name) { }
+
+    //Don't want to have to do that but cannont think of a work around
+    virtual void Load(){MythUITextEditSetting::Load();HostDBStorage::Load();}
+    virtual void Save(){MythUITextEditSetting::Save();HostDBStorage::Save();}
+};
+
+
+
+class MPUBLIC MythUIComboBoxSetting : public StandardSetting
+{
+  public:
+
+    virtual void resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item);
+    virtual bool edit(MythScreenType * screen);
+    void addSelection(const QString &label, QString value = QString::null, bool select = false);
+    virtual void updateButton(MythUIButtonListItem *item);
+  protected:
+    MythUIComboBoxSetting (Storage *_storage);
+    ~MythUIComboBoxSetting();
+  private:
+    QVector<QString> m_labels;
+    QVector<QString> m_values;
+    bool m_isSet;
+    
+};
+
+class MPUBLIC HostComboBoxSetting: public MythUIComboBoxSetting, public HostDBStorage
+{
+  public:
+    HostComboBoxSetting(const QString &name) :
+        MythUIComboBoxSetting(this), HostDBStorage(this, name) { }
+
+    //Don't want to have to do that but cannot think of a work around
+    virtual void Load(){MythUIComboBoxSetting::Load();HostDBStorage::Load();}
+    virtual void Save(){MythUIComboBoxSetting::Save();HostDBStorage::Save();}
+};
+
+
+
+class MPUBLIC MythUICheckBoxSetting : public StandardSetting
+{
+  public:
+    virtual void resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item);
+    virtual bool edit(MythScreenType * screen);
+    virtual void updateButton(MythUIButtonListItem *item);
+    void setValue(bool value);
+    bool boolValue();
+  protected:
+    MythUICheckBoxSetting (Storage *_storage);
+    
+};
+
+class MPUBLIC HostCheckBoxSetting: public MythUICheckBoxSetting, public HostDBStorage
+{
+  public:
+    HostCheckBoxSetting(const QString &name, bool rw = true) :
+        MythUICheckBoxSetting(this), HostDBStorage(this, name) { }
+};
+
+
+class GroupSetting : public StandardSetting, public Storage
+{
+  public:
+    GroupSetting();
+
+    virtual void Load(void){StandardSetting::Load();};
+    virtual void Save(void){StandardSetting::Save();};
+    virtual bool edit(MythScreenType * screen);
+    virtual void resultEdit(DialogCompletionEvent *dce, MythUIButtonListItem *item){};
+
+ private:
+
+};
+
+
+
+class StandardSettingDialog : public MythScreenType
+{
+    Q_OBJECT
+
+  public:
+
+    StandardSettingDialog(MythScreenStack *parent, const char *name);
+    virtual ~StandardSettingDialog();
+    bool Create(void);
+    void loadSettings(GroupSetting * groupSettings);
+    virtual void customEvent(QEvent *event);
+    virtual bool keyPressEvent(QKeyEvent *);
+  public slots:
+    void Close(void);
+  protected:
+
+    MythUIButtonList *m_buttonList;
+  private slots:
+    void settingSelected(MythUIButtonListItem *item);
+    void settingClicked(MythUIButtonListItem *item);
+  private:
+    void LevelUp();
+    void LevelDown();
+    void setCurrentGroupSetting(StandardSetting * groupSettings,StandardSetting * selectedSetting=0);
+    void Save();
+    MythUIText      *m_title;
+    MythUIText      *m_groupHelp;
+    MythUIText      *m_selectedSettingHelp;
+    MythDialogBox   *m_menuPopup;
+    GroupSetting    *m_settingsTree;
+    StandardSetting *m_currentGroupSetting;
+    bool m_loaded;
+};
+
+
+
+#endif

mythtv/programs/mythfrontend/videoglobalsettings.cpp

@@ -9 +9 @@
 #include "videodlg.h"
 #include "videoglobalsettings.h"
 
+#include "mythlogging.h"
+
 namespace
 {
 // General Settings
-HostComboBox *VideoDefaultParentalLevel()
+HostComboBoxSetting *VideoDefaultParentalLevel()
 {
-    HostComboBox *gc = new HostComboBox("VideoDefaultParentalLevel");
+    HostComboBoxSetting *gc = new HostComboBoxSetting("VideoDefaultParentalLevel");
     gc->setLabel(QObject::tr("Starting Parental Level"));
     gc->addSelection(QObject::tr("4 - Highest"),
                      QString::number(ParentalLevel::plHigh));
@@ -33 +35 @@
     QT_TRANSLATE_NOOP("QObject", "Setting this value to all numbers will make your life "
                 "much easier.");
 
-HostLineEdit *VideoAdminPassword()
+HostTextEditSetting *VideoAdminPassword()
 {
-    HostLineEdit *gc = new HostLineEdit("VideoAdminPassword");
+    HostTextEditSetting *gc = new HostTextEditSetting("VideoAdminPassword");
     gc->setLabel(QObject::tr("Parental Level 4 PIN"));
     gc->setHelpText(QString("%1 %2")
         .arg(QObject::tr("This PIN is used to enter Parental Control "
@@ -44 +46 @@
     return gc;
 }
 
-HostLineEdit *VideoAdminPasswordThree()
+HostTextEditSetting *VideoAdminPasswordThree()
 {
-    HostLineEdit *gc = new HostLineEdit("VideoAdminPasswordThree");
+    HostTextEditSetting *gc = new HostTextEditSetting("VideoAdminPasswordThree");
     gc->setLabel(QObject::tr("Parental Level 3 PIN"));
     gc->setHelpText(QString("%1 %2")
         .arg(QObject::tr("This PIN is used to enter Parental Control Level 3."))
@@ -54 +56 @@
     return gc;
 }
 
-HostLineEdit *VideoAdminPasswordTwo()
+HostTextEditSetting *VideoAdminPasswordTwo()
 {
-    HostLineEdit *gc = new HostLineEdit("VideoAdminPasswordTwo");
+    HostTextEditSetting *gc = new HostTextEditSetting("VideoAdminPasswordTwo");
     gc->setLabel(QObject::tr("Parental Level 2 PIN"));
     gc->setHelpText(QString("%1 %2")
         .arg(QObject::tr("This PIN is used to enter Parental Control Level 2."))
@@ -64 +66 @@
     return gc;
 }
 
-HostCheckBox *VideoAggressivePC()
+HostCheckBoxSetting *VideoAggressivePC()
 {
-    HostCheckBox *gc = new HostCheckBox("VideoAggressivePC");
+    HostCheckBoxSetting *gc = new HostCheckBoxSetting("VideoAggressivePC");
     gc->setLabel(QObject::tr("Aggressive Parental Control"));
     gc->setValue(false);
     gc->setHelpText(QObject::tr("If set, you will not be able to return "
@@ -76 +78 @@
     return gc;
 }
 
-HostLineEdit *VideoStartupDirectory()
+HostTextEditSetting *VideoStartupDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("VideoStartupDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("VideoStartupDir");
     gc->setLabel(QObject::tr("Directories that hold videos"));
     gc->setValue(DEFAULT_VIDEOSTARTUP_DIR);
     gc->setHelpText(QObject::tr("Multiple directories can be separated by ':'. "
@@ -87 +89 @@
     return gc;
 }
 
-HostLineEdit *VideoArtworkDirectory()
+HostTextEditSetting *VideoArtworkDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("VideoArtworkDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("VideoArtworkDir");
     gc->setLabel(QObject::tr("Directory that holds movie posters"));
     gc->setValue(GetConfDir() + "/Video/Artwork");
     gc->setHelpText(QObject::tr("This directory must exist, and the user "
@@ -98 +100 @@
     return gc;
 }
 
-HostLineEdit *VideoScreenshotDirectory()
+HostTextEditSetting *VideoScreenshotDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("mythvideo.screenshotDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("mythvideo.screenshotDir");
     gc->setLabel(QObject::tr("Directory that holds movie screenshots"));
     gc->setValue(GetConfDir() + "/Video/Screenshots");
     gc->setHelpText(QObject::tr("This directory must exist, and the user "
@@ -109 +111 @@
     return gc;
 }
 
-HostLineEdit *VideoBannerDirectory()
+HostTextEditSetting *VideoBannerDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("mythvideo.bannerDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("mythvideo.bannerDir");
     gc->setLabel(QObject::tr("Directory that holds movie/TV Banners"));
     gc->setValue(GetConfDir() + "/Video/Banners");
     gc->setHelpText(QObject::tr("This directory must exist, and the user "
@@ -120 +122 @@
     return gc;
 }
 
-HostLineEdit *VideoFanartDirectory()
+HostTextEditSetting *VideoFanartDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("mythvideo.fanartDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("mythvideo.fanartDir");
     gc->setLabel(QObject::tr("Directory that holds movie fanart"));
     gc->setValue(GetConfDir() + "/Video/Fanart");
     gc->setHelpText(QObject::tr("This directory must exist, and the user "
@@ -131 +133 @@
     return gc;
 }
 
-HostLineEdit *TrailerDirectory()
+HostTextEditSetting *TrailerDirectory()
 {
-    HostLineEdit *gc = new HostLineEdit("mythvideo.TrailersDir");
+    HostTextEditSetting *gc = new HostTextEditSetting("mythvideo.TrailersDir");
     gc->setLabel(QObject::tr("Directory that holds movie trailers"));
     gc->setValue(GetConfDir() + "/Video/Trailers");
     gc->setHelpText(QObject::tr("This directory must exist, and the user "
@@ -148 +150 @@
 
 // General Settings
 
-HostComboBox *SetOnInsertDVD()
+HostComboBoxSetting *SetOnInsertDVD()
 {
-    HostComboBox *gc = new HostComboBox("DVDOnInsertDVD");
+    HostComboBoxSetting *gc = new HostComboBoxSetting("DVDOnInsertDVD");
     gc->setLabel(QObject::tr("On DVD insertion"));
     gc->addSelection(QObject::tr("Display mythdvd menu"),"1");
     gc->addSelection(QObject::tr("Do nothing"),"0");
@@ -160 +162 @@
     return gc;
 }
 
-HostCheckBox *VideoTreeRemember()
+HostCheckBoxSetting *VideoTreeRemember()
 {
-    HostCheckBox *gc = new HostCheckBox("mythvideo.VideoTreeRemember");
+    HostCheckBoxSetting *gc = new HostCheckBoxSetting("mythvideo.VideoTreeRemember");
     gc->setLabel(QObject::tr("Video Tree remembers last selected position"));
     gc->setValue(false);
     gc->setHelpText(QObject::tr("If set, the current position in the Video "
@@ -170 +172 @@
     return gc;
 }
 
-struct ConfigPage
-{
-    typedef std::vector<ConfigurationGroup *> PageList;
-
-  protected:
-    ConfigPage(PageList &pl) : m_pl(pl)
-    {
-    }
-
-    void Add(ConfigurationGroup *page)
-    {
-        m_pl.push_back(page);
-    }
-
-  private:
-    ConfigPage(const ConfigPage &);
-    ConfigPage &operator=(const ConfigPage &);
-
-  private:
-    PageList &m_pl;
-};
-
-struct VConfigPage : public ConfigPage
-{
-    VConfigPage(PageList &pl, bool luselabel = true, bool luseframe  = true,
-                bool lzeroMargin = false, bool lzeroSpace = false) :
-        ConfigPage(pl)
-    {
-        m_vc_page = new VerticalConfigurationGroup(luselabel, luseframe,
-                                                   lzeroMargin, lzeroSpace);
-        Add(m_vc_page);
-    }
 
-    VerticalConfigurationGroup *operator->()
-    {
-        return m_vc_page;
-    }
 
-  private:
-    VerticalConfigurationGroup *m_vc_page;
-};
 
-class RatingsToPL : public TriggeredConfigurationGroup
+HostCheckBoxSetting *RatingsToPL()
 {
-  public:
-    RatingsToPL() : TriggeredConfigurationGroup(false)
+    HostCheckBoxSetting *r2pl =
+            new HostCheckBoxSetting("mythvideo.ParentalLevelFromRating");
+    r2pl->setLabel(QObject::tr("Enable automatic Parental Level from "
+                               "rating"));
+    r2pl->setValue(false);
+    r2pl->setHelpText(QObject::tr("If enabled, searches will automatically "
+                                  "set the Parental Level to the one "
+                                  "matching the rating below."));
+
+    typedef std::map<ParentalLevel::Level, QString> r2pl_map;
+    r2pl_map r2pl_defaults;
+    r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plLowest,
+            QObject::tr("G", "PL 1 default search string.")));
+    r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plLow,
+            QObject::tr("PG", "PL 2 default search string.")));
+    r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plMedium,
+            QObject::tr("PG-13", "PL3 default search string.")));
+    r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plHigh,
+            QObject::tr("R:NC-17", "PL4 default search string.")));
+
+    for (ParentalLevel pl(ParentalLevel::plLowest);
+         pl.GetLevel() <= ParentalLevel::plHigh && pl.good(); ++pl)
     {
-        HostCheckBox *r2pl =
-                new HostCheckBox("mythvideo.ParentalLevelFromRating");
-        r2pl->setLabel(QObject::tr("Enable automatic Parental Level from "
-                                   "rating"));
-        r2pl->setValue(false);
-        r2pl->setHelpText(QObject::tr("If enabled, searches will automatically "
-                                      "set the Parental Level to the one "
-                                      "matching the rating below."));
-        addChild(r2pl);
-        setTrigger(r2pl);
-
-        typedef std::map<ParentalLevel::Level, QString> r2pl_map;
-        r2pl_map r2pl_defaults;
-        r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plLowest,
-                tr("G", "PL 1 default search string.")));
-        r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plLow,
-                tr("PG", "PL 2 default search string.")));
-        r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plMedium,
-                tr("PG-13", "PL3 default search string.")));
-        r2pl_defaults.insert(r2pl_map::value_type(ParentalLevel::plHigh,
-                tr("R:NC-17", "PL4 default search string.")));
-
-        VerticalConfigurationGroup *vcg = new VerticalConfigurationGroup(true);
-
-        for (ParentalLevel pl(ParentalLevel::plLowest);
-             pl.GetLevel() <= ParentalLevel::plHigh && pl.good(); ++pl)
+        HostTextEditSetting *hle = new HostTextEditSetting(QString("mythvideo.AutoR2PL%1")
+                                             .arg(pl.GetLevel()));
+        hle->setLabel(QObject::tr("Level %1").arg(pl.GetLevel()));
+        hle->setHelpText(QObject::tr("Ratings containing these strings "
+                                     "(separated by :) will be assigned "
+                                     "to Parental Level %1.")
+                         .arg(pl.GetLevel()));
+
+        r2pl_map::const_iterator def_setting =
+                r2pl_defaults.find(pl.GetLevel());
+        if (def_setting != r2pl_defaults.end())
         {
-            HostLineEdit *hle = new HostLineEdit(QString("mythvideo.AutoR2PL%1")
-                                                 .arg(pl.GetLevel()));
-            hle->setLabel(QObject::tr("Level %1").arg(pl.GetLevel()));
-            hle->setHelpText(QObject::tr("Ratings containing these strings "
-                                         "(separated by :) will be assigned "
-                                         "to Parental Level %1.")
-                             .arg(pl.GetLevel()));
-
-            r2pl_map::const_iterator def_setting =
-                    r2pl_defaults.find(pl.GetLevel());
-            if (def_setting != r2pl_defaults.end())
-            {
-                hle->setValue(def_setting->second);
-            }
-
-            vcg->addChild(hle);
+            hle->setValue(def_setting->second);
         }
 
-        addTarget("0", new VerticalConfigurationGroup(true));
-        addTarget("1", vcg);
+        r2pl->addTargetedChild("1", hle);
     }
-};
 
-} // namespace
+    return r2pl;
+}
+
+}
 
 VideoGeneralSettings::VideoGeneralSettings()
+    :GroupSetting()
 {
-    ConfigPage::PageList pages;
-
-    VConfigPage page1(pages, false);
-    page1->addChild(VideoStartupDirectory());
-    page1->addChild(TrailerDirectory());
-    page1->addChild(VideoArtworkDirectory());
-    page1->addChild(VideoScreenshotDirectory());
-    page1->addChild(VideoBannerDirectory());
-    page1->addChild(VideoFanartDirectory());
-
-    VConfigPage page2(pages, false);
-    page2->addChild(SetOnInsertDVD());
-    page2->addChild(VideoTreeRemember());
-
-    // page 3
-    VerticalConfigurationGroup *pctrl =
-            new VerticalConfigurationGroup(true, false);
+    setLabel(QObject::tr("General settings"));
+
+    setHelpText(QObject::tr("TODO add a descrition for this group of settings"));
+    
+
+    addChild(VideoStartupDirectory());
+    addChild(TrailerDirectory());
+    addChild(VideoArtworkDirectory());
+    addChild(VideoScreenshotDirectory());
+    addChild(VideoBannerDirectory());
+    addChild(VideoFanartDirectory());
+
+    addChild(SetOnInsertDVD());
+    addChild(VideoTreeRemember());
+
+    GroupSetting *pctrl =
+            new GroupSetting();
     pctrl->setLabel(QObject::tr("Parental Control Settings"));
+
+    pctrl->setHelpText(QObject::tr("TODO add a description for this group of setting"));
     pctrl->addChild(VideoDefaultParentalLevel());
     pctrl->addChild(VideoAdminPassword());
     pctrl->addChild(VideoAdminPasswordThree());
     pctrl->addChild(VideoAdminPasswordTwo());
     pctrl->addChild(VideoAggressivePC());
-    VConfigPage page3(pages, false);
-    page3->addChild(pctrl);
 
-    VConfigPage page4(pages, false);
-    page4->addChild(new RatingsToPL());
+    addChild(pctrl);
+
+    addChild(RatingsToPL());
 
-    int page_num = 1;
-    for (ConfigPage::PageList::const_iterator p = pages.begin();
-         p != pages.end(); ++p, ++page_num)
-    {
-        (*p)->setLabel(QObject::tr("General Settings (%1/%2)").arg(page_num)
-                       .arg(pages.size()));
-        addChild(*p);
-    }
 }
+

mythtv/programs/mythfrontend/videoglobalsettings.h

@@ -3 +3 @@
 
 #include "settings.h"
 
-class VideoGeneralSettings : public ConfigurationWizard
+#include "standardsettings.h"
+
+class VideoGeneralSettings : public GroupSetting
 {
   public:
     VideoGeneralSettings();

new file mythtv/themes/default-wide/standardsetting-ui.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE mythuitheme SYSTEM "http://www.mythtv.org/schema/mythuitheme.dtd">
+
+<!-- theme.xml for the MythCenter theme - by Jeroen Brosens -->
+<mythuitheme>
+    <window name="settingssetup">
+
+        <textarea name="title" from="basetextarea">
+            <area>30,15,100%-30,30</area>
+            <font>baselarge</font>
+            <align>hcenter</align>
+        </textarea>
+
+        <shape name="GroupHelpBackground"> 
+            <area>15,80,100%-15,80</area> 
+            <type>roundbox</type> 
+            <cornerradius>10</cornerradius>
+            <fill color="#FFFFFF" alpha="30" />
+        </shape>
+
+        <!-- optionnal, display the help for the current group of settings -->
+        <textarea name="grouphelp" from="basetextarea">
+            <area>30,90-120,100%-30,60</area>
+            <font>basesmall</font>
+            <align>lefthcenter</align>
+            <multiline>yes</multiline>
+        </textarea>
+
+        <buttonlist name="settingslist"  from="basebuttonlist">
+            <area>100,200,100%-100,100%-160</area>
+            <layout>vertical</layout>
+            <spacing>4</spacing>
+            <wrapstyle>selection</wrapstyle>
+            <statetype name="buttonitem">
+                <area>0,0,100%,25</area>
+                <state name="active">
+                    <area>0,0,100%,30</area>
+                    <shape name="buttonbackground">
+                        <area>0,0,100%,100%</area>
+                        <fill style="gradient">
+                            <gradient start="#505050" end="#000000" alpha="200" direction="vertical"  />
+                        </fill>
+                    </shape>
+                    <textarea name="buttontext">
+                        <area>5,0,50%-10,30</area>
+                        <font>basesmall</font>
+                        <cutdown>yes</cutdown>
+                        <align>left,vcenter</align>
+                    </textarea>
+                    <textarea name="value">
+                        <area>50%+5,0,100%-40,30</area>
+                        <font>basesmall</font>
+                        <cutdown>yes</cutdown>
+                        <align>right,vcenter</align>
+                    </textarea>
+                    <imagetype name="buttonarrow">
+                        <position>100%-23,7</position>
+                        <filename>lb-arrow.png</filename>
+                    </imagetype>
+                </state>
+                <state name="selectedactive" from="active">
+                    <shape name="buttonbackground">
+                        <fill style="gradient">
+                            <gradient start="#52CA38" end="#349838" alpha="255" />
+                        </fill>
+                    </shape>
+                </state>
+                <state name="selectedinactive" from="active">
+                </state>
+            </statetype>
+        </buttonlist>
+
+        <shape name="HelpBackground"> 
+            <!--area>15,600,100%-30,100</area--> 
+            <area>15,100%-140,100%-15,80</area> 
+            <type>roundbox</type> 
+            <cornerradius>10</cornerradius>
+            <fill color="#000000" alpha="30" />
+        </shape> 
+
+        <!-- optionnal, display the help for the currently selected setting -->
+        <textarea name="selectedsettinghelp" from="basetextarea">
+            <area>30,100%-120,100%-30,60</area>
+            <font>basesmall</font>
+            <multiline>yes</multiline>
+        </textarea>
+    </window>
+</mythuitheme>