summaryrefslogtreecommitdiffstats
path: root/abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp')
-rw-r--r--abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp1236
1 files changed, 1236 insertions, 0 deletions
diff --git a/abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp b/abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp
new file mode 100644
index 0000000..41c3cf8
--- /dev/null
+++ b/abs/core/mythinstall/MythVantage-app/mythinstall/settings.cpp
@@ -0,0 +1,1236 @@
+// C++ headers
+#include <algorithm>
+#include <cmath>
+using namespace std;
+
+// POSIX headers
+#include <unistd.h>
+
+// Qt widgets
+#include <QLineEdit>
+#include <QSlider>
+#include <QLCDNumber>
+#include <QButtonGroup>
+#include <QRadioButton>
+#include <QProgressBar>
+
+// Qt utils
+#include <QFile>
+#include <QDateTime>
+#include <QDir>
+
+// MythTV headers
+#define MYTHCONFIG
+#include "settings.h"
+#include "mythconfiggroups.h"
+#undef MYTHCONFIG
+
+#include "mythwidgets.h"
+#include "mythcontext.h"
+#include "mythdb.h"
+#include "mythlogging.h"
+//#include "DisplayRes.h"
+#include "mythuihelper.h"
+
+/** \class Configurable
+ * \brief Configurable is the root of all the database aware widgets.
+ *
+ * This is an abstract class and some methods must be implemented
+ * in children. byName(const &QString) is abstract. While
+ * configWidget(ConfigurationGroup *, QWidget*, const char*)
+ * has an implementation, all it does is print an error message
+ * and return a NULL pointer.
+ */
+
+QWidget* Configurable::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName)
+{
+ (void)cg;
+ (void)parent;
+ (void)widgetName;
+ LOG(VB_GENERAL, LOG_ALERT,
+ "BUG: Configurable is visible, but has no configWidget");
+ return NULL;
+}
+
+/** \brief This slot calls the virtual widgetInvalid(QObject*) method.
+ *
+ * This should not be needed, anyone calling configWidget() should
+ * also be calling widgetInvalid() directly before configWidget()
+ * is called again on the Configurable. If widgetInvalid() is not
+ * called directly before the Configurable's configWidget() is
+ * called the Configurable may not update properly on screen, but
+ * if this is connected to from the widget's destroyed(QObject*)
+ * signal this will prevent a segfault from occurring.
+ */
+void Configurable::widgetDeleted(QObject *obj)
+{
+ widgetInvalid(obj);
+}
+
+/** \fn Configurable::enableOnSet(const QString &val)
+ * \brief This slot allows you to enable this configurable when a
+ * binary configurable is set to true.
+ * \param val signal value, should be "0" to disable, other to disable.
+ */
+void Configurable::enableOnSet(const QString &val)
+{
+ setEnabled( val != "0" );
+}
+
+/** \fn Configurable::enableOnUnset(const QString &val)
+ * \brief This slot allows you to enable this configurable when a
+ * binary configurable is set to false.
+ * \param val signal value, should be "0" to enable, other to disable.
+ */
+void Configurable::enableOnUnset(const QString &val)
+{
+ setEnabled( val == "0" );
+}
+
+QString Setting::getValue(void) const
+{
+ return settingValue;
+}
+
+void Setting::setValue(const QString &newValue)
+{
+ settingValue = newValue;
+ emit valueChanged(settingValue);
+}
+
+int SelectSetting::findSelection(const QString &label, QString value) const
+{
+ value = (value.isEmpty()) ? label : value;
+
+ for (uint i = 0; i < values.size(); i++)
+ {
+ if ((values[i] == value) && (labels[i] == label))
+ return i;
+ }
+
+ return -1;
+}
+
+void SelectSetting::addSelection(const QString &label, QString value,
+ bool select)
+{
+ value = (value.isEmpty()) ? label : value;
+
+ int found = findSelection(label, value);
+ if (found < 0)
+ {
+ labels.push_back(label);
+ values.push_back(value);
+ emit selectionAdded( label, value);
+ }
+
+ if (select || !isSet)
+ setValue(value);
+}
+
+bool SelectSetting::removeSelection(const QString &label, QString value)
+{
+ value = (value.isEmpty()) ? label : value;
+
+ int found = findSelection(label, value);
+ if (found < 0)
+ return false;
+
+ bool wasSet = isSet;
+ isSet = false;
+
+ labels.erase(labels.begin() + found);
+ values.erase(values.begin() + found);
+
+ isSet = wasSet && labels.size();
+ if (isSet)
+ {
+ current = (current > (uint)found) ? current - 1 : current;
+ current = min(current, (uint) (labels.size() - 1));
+ }
+
+ emit selectionRemoved(label, value);
+
+ return true;
+}
+
+void SelectSetting::fillSelectionsFromDir(const QDir& dir, bool absPath)
+{
+ QFileInfoList il = dir.entryInfoList();
+
+ for (QFileInfoList::Iterator it = il.begin();
+ it != il.end();
+ ++it )
+ {
+ QFileInfo &fi = *it;
+
+ if (absPath)
+ addSelection( fi.absoluteFilePath() );
+ else
+ addSelection( fi.fileName() );
+ }
+}
+
+void SelectSetting::clearSelections(void) {
+ labels.clear();
+ values.clear();
+ isSet = false;
+ emit selectionsCleared();
+}
+
+void SelectSetting::setValue(const QString &newValue)
+{
+ int found = getValueIndex(newValue);
+ if (found < 0)
+ {
+ addSelection(newValue, newValue, true);
+ }
+ else
+ {
+ current = found;
+ isSet = true;
+ Setting::setValue(newValue);
+ }
+}
+
+void SelectSetting::setValue(int which)
+{
+ if ((which >= ((int) values.size())) || (which < 0))
+ {
+ LOG(VB_GENERAL, LOG_ERR,
+ QString("SelectSetting::setValue(): invalid index: %1 size: %2")
+ .arg(which).arg(values.size()));
+ }
+ else
+ {
+ current = which;
+ isSet = true;
+ Setting::setValue(values[current]);
+ }
+}
+
+QString SelectSetting::getSelectionLabel(void) const
+{
+ if (!isSet || (current >= values.size()))
+ return QString::null;
+
+ return labels[current];
+}
+
+/** \fn SelectSetting::getValueIndex(QString)
+ * \brief Returns index of value in SelectSetting, or -1 if not found.
+ */
+int SelectSetting::getValueIndex(QString value)
+{
+ int ret = 0;
+
+ selectionList::const_iterator it = values.begin();
+ for (; it != values.end(); ++it, ++ret)
+ {
+ if (*it == value)
+ return ret;
+ }
+
+ return -1;
+}
+
+bool SelectSetting::ReplaceLabel(const QString &new_label, const QString &value)
+{
+ int i = getValueIndex(value);
+
+ if (i >= 0)
+ labels[i] = new_label;
+
+ return (i >= 0);
+}
+
+QWidget* LabelSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName) {
+ (void)cg;
+
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QHBoxLayout *layout = new QHBoxLayout();
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ MythLabel *value = new MythLabel();
+ value->setText(getValue());
+ layout->addWidget(value);
+
+ connect(this, SIGNAL(valueChanged(const QString&)),
+ value, SLOT(setText(const QString&)));
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+QWidget* LineEditSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char *widgetName)
+{
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QBoxLayout *layout = NULL;
+ if (labelAboveWidget)
+ {
+ layout = new QVBoxLayout();
+ widget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
+ QSizePolicy::Maximum));
+ }
+ else
+ layout = new QHBoxLayout();
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ bxwidget = widget;
+ connect(bxwidget, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ edit = new MythLineEdit(
+ settingValue, NULL,
+ QString(QString(widgetName) + "-edit").toLatin1().constData());
+ edit->setHelpText(getHelpText());
+ edit->setText( getValue() );
+ edit->setMinimumHeight(25);
+ layout->addWidget(edit);
+
+ connect(this, SIGNAL(valueChanged(const QString&)),
+ edit, SLOT(setText(const QString&)));
+ connect(edit, SIGNAL(textChanged(const QString&)),
+ this, SLOT(setValue(const QString&)));
+
+ if (cg)
+ connect(edit, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ setRW(rw);
+ SetPasswordEcho(password_echo);
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+void LineEditSetting::widgetInvalid(QObject *obj)
+{
+ if (bxwidget == obj)
+ {
+ bxwidget = NULL;
+ edit = NULL;
+ }
+}
+
+void LineEditSetting::setEnabled(bool b)
+{
+ Configurable::setEnabled(b);
+ if (edit)
+ edit->setEnabled(b);
+}
+
+void LineEditSetting::setVisible(bool b)
+{
+ Configurable::setVisible(b);
+ if (edit)
+ {
+ //QWidget *parent = edit->parentWidget();
+ if (b)
+ edit->show();
+ else
+ edit->hide();
+ }
+}
+
+void LineEditSetting::SetPasswordEcho(bool b)
+{
+ password_echo = b;
+ if (edit)
+ edit->setEchoMode(b ? QLineEdit::Password : QLineEdit::Normal);
+}
+
+void LineEditSetting::setHelpText(const QString &str)
+{
+ if (edit)
+ edit->setHelpText(str);
+ Setting::setHelpText(str);
+}
+
+void BoundedIntegerSetting::setValue(int newValue)
+{
+ newValue = std::max(std::min(newValue, max), min);
+ IntegerSetting::setValue(newValue);
+}
+
+QWidget* SliderSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName)
+{
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QBoxLayout *layout = NULL;
+ if (labelAboveWidget)
+ {
+ layout = new QVBoxLayout();
+ widget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
+ QSizePolicy::Maximum));
+ }
+ else
+ layout = new QHBoxLayout();
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setObjectName(QString(widgetName) + "-label");
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ MythSlider *slider = new MythSlider(
+ NULL, QString(QString(widgetName) + "-slider").toLatin1().constData());
+ slider->setHelpText(getHelpText());
+ slider->setMinimum(min);
+ slider->setMaximum(max);
+ slider->setOrientation( Qt::Horizontal );
+ slider->setSingleStep(step);
+ slider->setValue(intValue());
+ layout->addWidget(slider);
+
+ QLCDNumber *lcd = new QLCDNumber();
+ lcd->setObjectName(QString(QString(widgetName) + "-lcd")
+ .toLatin1().constData());
+ lcd->setMode(QLCDNumber::Dec);
+ lcd->setSegmentStyle(QLCDNumber::Flat);
+ lcd->display(intValue());
+ layout->addWidget(lcd);
+
+ connect(slider, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)));
+ connect(slider, SIGNAL(valueChanged(int)), this, SLOT(setValue(int)));
+ connect(this, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));
+
+ if (cg)
+ connect(slider, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+SpinBoxSetting::SpinBoxSetting(
+ Storage *_storage, int _min, int _max, int _step,
+ bool _allow_single_step, QString _special_value_text) :
+ BoundedIntegerSetting(_storage, _min, _max, _step),
+ bxwidget(NULL), spinbox(NULL), relayEnabled(true),
+ sstep(_allow_single_step), svtext("")
+{
+ if (!_special_value_text.isEmpty())
+ svtext = _special_value_text;
+
+ IntegerSetting *iset = (IntegerSetting *) this;
+ connect(iset, SIGNAL(valueChanged( int)),
+ this, SLOT( relayValueChanged(int)));
+}
+
+QWidget* SpinBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName)
+{
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QBoxLayout *layout = NULL;
+ if (labelAboveWidget)
+ {
+ layout = new QVBoxLayout();
+ widget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
+ QSizePolicy::Maximum));
+ }
+ else
+ layout = new QHBoxLayout();
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ bxwidget = widget;
+ connect(bxwidget, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ QString sbname = QString(widgetName) + "MythSpinBox";
+ spinbox = new MythSpinBox(NULL, sbname.toLatin1().constData(), sstep);
+ spinbox->setHelpText(getHelpText());
+ spinbox->setMinimum(min);
+ spinbox->setMaximum(max);
+ spinbox->setMinimumHeight(25);
+ layout->addWidget(spinbox);
+
+ // only set step size if greater than default (1), otherwise
+ // this will screw up the single-step/jump behavior of the MythSpinBox
+ if (1 < step)
+ spinbox->setSingleStep(step);
+ spinbox->setValue(intValue());
+ if (!svtext.isEmpty())
+ spinbox->setSpecialValueText(svtext);
+
+ connect(spinbox, SIGNAL(valueChanged(int)), this, SLOT(setValue(int)));
+
+ if (cg)
+ connect(spinbox, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+void SpinBoxSetting::widgetInvalid(QObject *obj)
+{
+ if (bxwidget == obj)
+ {
+ bxwidget = NULL;
+ spinbox = NULL;
+ }
+}
+
+void SpinBoxSetting::setValue(int newValue)
+{
+ newValue = std::max(std::min(newValue, max), min);
+ if (spinbox && (spinbox->value() != newValue))
+ {
+ //int old = intValue();
+ spinbox->setValue(newValue);
+ }
+ else if (intValue() != newValue)
+ {
+ BoundedIntegerSetting::setValue(newValue);
+ }
+}
+
+void SpinBoxSetting::setFocus(void)
+{
+ if (spinbox)
+ spinbox->setFocus();
+}
+
+void SpinBoxSetting::clearFocus(void)
+{
+ if (spinbox)
+ spinbox->clearFocus();
+}
+
+bool SpinBoxSetting::hasFocus(void) const
+{
+ if (spinbox)
+ return spinbox->hasFocus();
+
+ return false;
+}
+
+void SpinBoxSetting::relayValueChanged(int newValue)
+{
+ if (relayEnabled)
+ emit valueChanged(configName, newValue);
+}
+
+void SpinBoxSetting::setHelpText(const QString &str)
+{
+ if (spinbox)
+ spinbox->setHelpText(str);
+ BoundedIntegerSetting::setHelpText(str);
+}
+
+QWidget* SelectLabelSetting::configWidget(ConfigurationGroup *cg,
+ QWidget *parent,
+ const char *widgetName)
+{
+ (void)cg;
+
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QBoxLayout *layout = NULL;
+ if (labelAboveWidget)
+ {
+ layout = new QVBoxLayout();
+ widget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
+ QSizePolicy::Maximum));
+ }
+ else
+ layout = new QHBoxLayout();
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+
+ MythLabel *value = new MythLabel();
+ value->setText(labels[current]);
+ layout->addWidget(value);
+
+ connect(this, SIGNAL(valueChanged(const QString&)),
+ value, SLOT(setText(const QString&)));
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+QWidget* ComboBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName)
+{
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QBoxLayout *layout = NULL;
+ if (labelAboveWidget)
+ {
+ layout = new QVBoxLayout();
+ widget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
+ QSizePolicy::Maximum));
+ }
+ else
+ layout = new QHBoxLayout();
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ bxwidget = widget;
+ connect(bxwidget, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ cbwidget = new MythComboBox(rw);
+ cbwidget->setHelpText(getHelpText());
+
+ for(unsigned int i = 0 ; i < labels.size() ; ++i)
+ cbwidget->insertItem(labels[i]);
+
+ resetMaxCount(cbwidget->count());
+
+ if (isSet)
+ cbwidget->setCurrentIndex(current);
+
+ if (1 < step)
+ cbwidget->setStep(step);
+
+ connect(cbwidget, SIGNAL(highlighted(int)),
+ this, SLOT(setValue(int)));
+ connect(cbwidget, SIGNAL(activated(int)),
+ this, SLOT(setValue(int)));
+ connect(this, SIGNAL(selectionsCleared()),
+ cbwidget, SLOT(clear()));
+
+ if (rw)
+ connect(cbwidget, SIGNAL(editTextChanged(const QString &)),
+ this, SLOT(editTextChanged(const QString &)));
+
+ if (cg)
+ connect(cbwidget, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ cbwidget->setMinimumHeight(25);
+
+ layout->addWidget(cbwidget);
+ layout->setStretchFactor(cbwidget, 1);
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+void ComboBoxSetting::widgetInvalid(QObject *obj)
+{
+ if (bxwidget == obj)
+ {
+ bxwidget = NULL;
+ cbwidget = NULL;
+ }
+}
+
+void ComboBoxSetting::setEnabled(bool b)
+{
+ Configurable::setEnabled(b);
+ if (cbwidget)
+ cbwidget->setEnabled(b);
+}
+
+void ComboBoxSetting::setVisible(bool b)
+{
+ Configurable::setVisible(b);
+ if (cbwidget)
+ {
+ if (b)
+ cbwidget->show();
+ else
+ cbwidget->hide();
+ }
+}
+
+void ComboBoxSetting::setValue(const QString &newValue)
+{
+ for (uint i = 0; i < values.size(); i++)
+ {
+ if (values[i] == newValue)
+ {
+ setValue(i);
+ break;
+ }
+ }
+
+ if (rw)
+ {
+ Setting::setValue(newValue);
+ if (cbwidget)
+ cbwidget->setCurrentIndex(current);
+ }
+}
+
+void ComboBoxSetting::setValue(int which)
+{
+ if (cbwidget)
+ cbwidget->setCurrentIndex(which);
+ SelectSetting::setValue(which);
+}
+
+void ComboBoxSetting::addSelection(
+ const QString &label, QString value, bool select)
+{
+ if ((findSelection(label, value) < 0) && cbwidget)
+ {
+ resetMaxCount(cbwidget->count()+1);
+ cbwidget->insertItem(label);
+ }
+
+ SelectSetting::addSelection(label, value, select);
+
+ if (cbwidget && isSet)
+ cbwidget->setCurrentIndex(current);
+}
+
+bool ComboBoxSetting::removeSelection(const QString &label, QString value)
+{
+ SelectSetting::removeSelection(label, value);
+ if (!cbwidget)
+ return true;
+
+ for (uint i = 0; ((int) i) < cbwidget->count(); i++)
+ {
+ if (cbwidget->itemText(i) == label)
+ {
+ cbwidget->removeItem(i);
+ if (isSet)
+ cbwidget->setCurrentIndex(current);
+ resetMaxCount(cbwidget->count());
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void ComboBoxSetting::editTextChanged(const QString &newText)
+{
+ if (cbwidget)
+ {
+ for (uint i = 0; i < labels.size(); i++)
+ if (labels[i] == newText)
+ return;
+
+ if (labels.size() == static_cast<size_t>(cbwidget->maxCount()))
+ {
+ SelectSetting::removeSelection(labels[cbwidget->maxCount() - 1],
+ values[cbwidget->maxCount() - 1]);
+ cbwidget->setItemText(cbwidget->maxCount() - 1, newText);
+ }
+ else
+ {
+ cbwidget->insertItem(newText);
+ }
+
+ SelectSetting::addSelection(newText, newText, true);
+ cbwidget->setCurrentIndex(cbwidget->maxCount() - 1);
+ }
+}
+
+void ComboBoxSetting::setHelpText(const QString &str)
+{
+ if (cbwidget)
+ cbwidget->setHelpText(str);
+ SelectSetting::setHelpText(str);
+}
+
+void HostRefreshRateComboBox::ChangeResolution(const QString& resolution)
+{
+ clearSelections();
+
+ const vector<double> list = GetRefreshRates(resolution);
+ addSelection(QObject::tr("Auto"), "0");
+ int hz50 = -1, hz60 = -1;
+ for (uint i=0; i<list.size(); ++i)
+ {
+ QString sel = QString::number((double) list[i],'f', 3);
+ addSelection(sel+" Hz", sel);
+ hz50 = (fabs(50.0 - list[i]) < 0.01) ? i : hz50;
+ hz60 = (fabs(60.0 - list[i]) < 0.01) ? i : hz60;
+ }
+
+ setValue(0);
+ if ("640x480" == resolution || "720x480" == resolution)
+ setValue(hz60+1);
+ if ("640x576" == resolution || "720x576" == resolution)
+ setValue(hz50+1);
+
+ setEnabled(list.size());
+}
+
+const vector<double> HostRefreshRateComboBox::GetRefreshRates(const QString &res)
+{
+ QStringList slist = res.split("x");
+ int w = 0, h = 0;
+ bool ok0 = false, ok1 = false;
+ if (2 == slist.size())
+ {
+ w = slist[0].toInt(&ok0);
+ h = slist[1].toInt(&ok1);
+ }
+
+// DisplayRes *display_res = DisplayRes::GetDisplayRes();
+// if (display_res && ok0 && ok1)
+// return display_res->GetRefreshRates(w, h);
+
+ vector<double> list;
+ return list;
+}
+
+void PathSetting::addSelection(const QString& label,
+ QString value,
+ bool select) {
+ QString pathname = label;
+ if (value != QString::null)
+ pathname = value;
+
+ if (mustexist && !QFile(pathname).exists())
+ return;
+
+ ComboBoxSetting::addSelection(label, value, select);
+}
+
+QTime TimeSetting::timeValue(void) const {
+ return QTime::fromString(getValue(), Qt::ISODate);
+}
+
+void TimeSetting::setValue(const QTime& newValue) {
+ Setting::setValue(newValue.toString(Qt::ISODate));
+}
+
+QString DateSetting::getValue(void) const
+{
+ return settingValue;
+}
+
+QDate DateSetting::dateValue(void) const {
+ return QDate::fromString(getValue(), Qt::ISODate);
+}
+
+void DateSetting::setValue(const QDate& newValue) {
+ Setting::setValue(newValue.toString(Qt::ISODate));
+}
+
+void DateSetting::setValue(const QString &newValue)
+{
+ QDate date = QDate::fromString(newValue, Qt::ISODate);
+ if (date.isValid())
+ setValue(date);
+}
+
+void TimeSetting::setValue(const QString &newValue)
+{
+ QTime time = QTime::fromString(newValue, Qt::ISODate);
+ if (time.isValid())
+ setValue(time);
+}
+
+QWidget* CheckBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName) {
+ widget = new MythCheckBox(parent, widgetName);
+ connect(widget, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ widget->setHelpText(getHelpText());
+ widget->setText(getLabel());
+ widget->setChecked(boolValue());
+
+ connect(widget, SIGNAL(toggled(bool)),
+ this, SLOT(setValue(bool)));
+ connect(this, SIGNAL(valueChanged(bool)),
+ widget, SLOT(setChecked(bool)));
+
+ if (cg)
+ connect(widget, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ return widget;
+}
+
+void CheckBoxSetting::widgetInvalid(QObject *obj)
+{
+ widget = (widget == obj) ? NULL : widget;
+}
+
+void CheckBoxSetting::setVisible(bool b)
+{
+ BooleanSetting::setVisible(b);
+ if (widget)
+ {
+ if (b)
+ widget->show();
+ else
+ widget->hide();
+ }
+}
+
+void CheckBoxSetting::setLabel(QString str)
+{
+ // QT treats a single ampersand as special,
+ // we must double up ampersands to display them
+ str = str.replace(" & ", " && ");
+ BooleanSetting::setLabel(str);
+ if (widget)
+ widget->setText(str);
+}
+
+void CheckBoxSetting::setEnabled(bool fEnabled)
+{
+ BooleanSetting::setEnabled(fEnabled);
+ if (widget)
+ widget->setEnabled(fEnabled);
+}
+
+void CheckBoxSetting::setHelpText(const QString &str)
+{
+ if (widget)
+ widget->setHelpText(str);
+ BooleanSetting::setHelpText(str);
+}
+
+void AutoIncrementDBSetting::Save(QString table)
+{
+ if (intValue() == 0)
+ {
+ // Generate a new, unique ID
+ QString querystr = QString("INSERT INTO " + table + " ("
+ + GetColumnName() + ") VALUES (0);");
+
+ MSqlQuery query(MSqlQuery::InitCon());
+
+ if (!query.exec(querystr))
+ {
+ MythDB::DBError("inserting row", query);
+ return;
+ }
+ // XXX -- HACK BEGIN:
+ // lastInsertID fails with "QSqlQuery::value: not positioned on a valid record"
+ // if we get a invalid QVariant we workaround the problem by taking advantage
+ // of mysql always incrementing the auto increment pointer
+ // this breaks if someone modifies the auto increment pointer
+ //setValue(query.lastInsertId().toInt());
+
+ QVariant var = query.lastInsertId();
+
+ if (var.type())
+ setValue(var.toInt());
+ else
+ {
+ querystr = QString("SELECT MAX(" + GetColumnName() + ") FROM " + table + ";");
+ if (query.exec(querystr) && query.next())
+ {
+ int lii = query.value(0).toInt();
+ lii = lii ? lii : 1;
+ setValue(lii);
+ }
+ else
+ LOG(VB_GENERAL, LOG_EMERG,
+ "Can't determine the Id of the last insert "
+ "QSqlQuery.lastInsertId() failed, the workaround "
+ "failed too!");
+ }
+ // XXX -- HACK END:
+ }
+}
+
+void AutoIncrementDBSetting::Save(void)
+{
+ Save(GetTableName());
+}
+
+void ListBoxSetting::setEnabled(bool b)
+{
+ Configurable::setEnabled(b);
+ if (lbwidget)
+ lbwidget->setEnabled(b);
+}
+
+void ListBoxSetting::clearSelections(void)
+{
+ SelectSetting::clearSelections();
+ if (lbwidget)
+ lbwidget->clear();
+}
+
+void ListBoxSetting::addSelection(
+ const QString &label, QString value, bool select)
+{
+ SelectSetting::addSelection(label, value, select);
+ if (lbwidget)
+ {
+ lbwidget->insertItem(label);
+ //lbwidget->triggerUpdate(true);
+ }
+};
+
+bool ListBoxSetting::ReplaceLabel(
+ const QString &new_label, const QString &value)
+{
+ int i = getValueIndex(value);
+
+ if ((i >= 0) && SelectSetting::ReplaceLabel(label, value) && lbwidget)
+ {
+ lbwidget->changeItem(new_label, i);
+ return true;
+ }
+
+ return false;
+}
+
+QWidget* ListBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
+ const char* widgetName)
+{
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+
+ QVBoxLayout *layout = new QVBoxLayout();
+
+ if (getLabel() != "")
+ {
+ MythLabel *label = new MythLabel();
+ label->setText(getLabel());
+ layout->addWidget(label);
+ }
+
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ bxwidget = widget;
+ connect(bxwidget, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ lbwidget = new MythListBox(NULL);
+ lbwidget->setHelpText(getHelpText());
+ if (eventFilter)
+ lbwidget->installEventFilter(eventFilter);
+
+ for(unsigned int i = 0 ; i < labels.size() ; ++i) {
+ lbwidget->insertItem(labels[i]);
+ if (isSet && current == i)
+ lbwidget->setCurrentRow(i);
+ }
+
+ connect(this, SIGNAL(selectionsCleared()),
+ lbwidget, SLOT( clear()));
+ connect(this, SIGNAL(valueChanged(const QString&)),
+ lbwidget, SLOT( setCurrentItem(const QString&)));
+
+ connect(lbwidget, SIGNAL(accepted(int)),
+ this, SIGNAL(accepted(int)));
+ connect(lbwidget, SIGNAL(menuButtonPressed(int)),
+ this, SIGNAL(menuButtonPressed(int)));
+ connect(lbwidget, SIGNAL(editButtonPressed(int)),
+ this, SIGNAL(editButtonPressed(int)));
+ connect(lbwidget, SIGNAL(deleteButtonPressed(int)),
+ this, SIGNAL(deleteButtonPressed(int)));
+
+ connect(lbwidget, SIGNAL(highlighted(int)),
+ this, SLOT( setValueByIndex(int)));
+
+ if (cg)
+ connect(lbwidget, SIGNAL(changeHelpText(QString)), cg,
+ SIGNAL(changeHelpText(QString)));
+
+ lbwidget->setFocus();
+ lbwidget->setSelectionMode(selectionMode);
+ layout->addWidget(lbwidget);
+
+ widget->setLayout(layout);
+
+ return widget;
+}
+
+void ListBoxSetting::widgetInvalid(QObject *obj)
+{
+ if (bxwidget == obj)
+ {
+ bxwidget = NULL;
+ lbwidget = NULL;
+ }
+}
+
+void ListBoxSetting::setSelectionMode(MythListBox::SelectionMode mode)
+{
+ selectionMode = mode;
+ if (lbwidget)
+ lbwidget->setSelectionMode(selectionMode);
+}
+
+void ListBoxSetting::setValueByIndex(int index)
+{
+ if (((uint)index) < values.size())
+ setValue(values[index]);
+}
+
+void ListBoxSetting::setHelpText(const QString &str)
+{
+ if (lbwidget)
+ lbwidget->setHelpText(str);
+ SelectSetting::setHelpText(str);
+}
+
+HostnameSetting::HostnameSetting(Storage *storage) : Setting(storage)
+{
+ setVisible(false);
+
+ setValue(gCoreContext->GetHostName());
+}
+
+void ChannelSetting::fillSelections(SelectSetting* setting) {
+
+ // this should go somewhere else, in something that knows about
+ // channels and how they're stored in the database. We're just a
+ // selector.
+
+ MSqlQuery query(MSqlQuery::InitCon());
+ query.prepare("SELECT name, chanid FROM channel;");
+ if (query.exec() && query.isActive() && query.size() > 0)
+ while (query.next())
+ setting->addSelection(query.value(0).toString(),
+ QString::number(query.value(1).toInt()));
+}
+
+QWidget* ButtonSetting::configWidget(ConfigurationGroup* cg, QWidget* parent,
+ const char* widgetName)
+{
+ (void) cg;
+ button = new MythPushButton(parent, widgetName);
+ connect(button, SIGNAL(destroyed(QObject*)),
+ this, SLOT(widgetDeleted(QObject*)));
+
+ button->setText(getLabel());
+ button->setHelpText(getHelpText());
+
+ connect(button, SIGNAL(pressed()), this, SIGNAL(pressed()));
+ connect(button, SIGNAL(pressed()), this, SLOT(SendPressedString()));
+
+ if (cg)
+ connect(button, SIGNAL(changeHelpText(QString)),
+ cg, SIGNAL(changeHelpText(QString)));
+
+ return button;
+}
+
+void ButtonSetting::widgetInvalid(QObject *obj)
+{
+ button = (button == obj) ? NULL : button;
+}
+
+void ButtonSetting::SendPressedString(void)
+{
+ emit pressed(name);
+}
+
+void ButtonSetting::setEnabled(bool fEnabled)
+{
+ Configurable::setEnabled(fEnabled);
+ if (button)
+ button->setEnabled(fEnabled);
+}
+
+void ButtonSetting::setLabel(QString str)
+{
+ if (button)
+ button->setText(str);
+ Setting::setLabel(str);
+}
+
+void ButtonSetting::setHelpText(const QString &str)
+{
+ if (button)
+ button->setHelpText(str);
+ Setting::setHelpText(str);
+}
+
+QWidget* ProgressSetting::configWidget(ConfigurationGroup* cg, QWidget* parent,
+ const char* widgetName) {
+ (void)cg;
+ QWidget *widget = new QWidget(parent);
+ widget->setObjectName(widgetName);
+ QBoxLayout *layout = new QHBoxLayout();
+ layout->setContentsMargins(0,0,0,0);
+ layout->setSpacing(0);
+
+ if (getLabel() != "")
+ {
+ MythLabel* label = new MythLabel();
+ label->setObjectName(QString(widgetName) + "_label");
+ label->setText(getLabel() + ": ");
+ layout->addWidget(label);
+ }
+
+ QProgressBar *progress = new QProgressBar(NULL);
+ progress->setObjectName(widgetName);
+ progress->setRange(0,totalSteps);
+ layout->addWidget(progress);
+
+ connect(this, SIGNAL(valueChanged(int)), progress, SLOT(setValue(int)));
+ progress->setValue(intValue());
+
+ widget->setLayout(layout);
+
+ return widget;
+}