Ticket #2594: multiselect_mythtv_r11685.patch

File multiselect_mythtv_r11685.patch, 48.2 KB (added by mythtv@…, 13 years ago)

Patch refresh against head revision 11685 (also rolled in contents of “multiselect_mythtv_omitted_0.1.patch”)

  • libs/libmythtv/channeleditor.cpp

     
    246246    src->addChild(source);
    247247    src->addChild(del);
    248248
    249     sort->setValue(sort->getValueIndex(list->getSortMode()));
    250     source->setValue(source->getValueIndex(list->getSourceID()));
     249    sort->setCurrentValue(list->getSortMode());
     250    source->setCurrentValue(list->getSourceID());
    251251    hide->setValue(list->getHideMode());
    252252
    253253    addChild(sort);
  • libs/libmythtv/playgroup.cpp

     
    239239
    240240void PlayGroupEditor::doDelete(void)
    241241{
    242     QString name = getValue();
     242    QString name = getSelectionValues().first();
    243243    if (name.isEmpty() || name == "Default")
    244244        return;
    245245
     
    259259        if (!query.exec())
    260260            MythContext::DBError("PlayGroupEditor::doDelete", query);
    261261
    262         int lastIndex = getValueIndex(name);
     262        int lastIndex = getSelectionIndices().first();
    263263        lastValue = "";
    264264        load();
    265         setValue(lastIndex);
     265        setCurrent(lastIndex);
    266266    }
    267267
    268268    setFocus();
     
    282282
    283283    addSelection(tr("(Create new group)"), "");
    284284
    285     setValue(lastValue);
     285    setCurrentValue(lastValue);
    286286}
    287287
    288288int PlayGroupEditor::exec() {
  • libs/libmythtv/scanwizardhelpers.h

     
    721721
    722722    void SetDefaultFormat(QString d)
    723723    {
    724         int val = atsc_format->getValueIndex(d);
    725         atsc_format->setValue(val);
     724        atsc_format->setCurrentValue(d);
    726725    }
    727726
    728727  protected:
  • libs/libmythtv/videosource.cpp

     
    16371637
    16381638QString CardInput::getSourceName(void) const
    16391639{
    1640     return sourceid->getSelectionLabel();
     1640    return sourceid->getSelectionLabels().first();
    16411641}
    16421642
    16431643void CardInput::SetChildCardID(uint ccid)
     
    17711771    else
    17721772    {
    17731773        load(); // new
    1774         cardid->setValue(QString::number(_cardid));
     1774        cardid->setCurrentLabel(QString::number(_cardid));
    17751775        inputname->setValue(_inputname);
    17761776    }
    17771777}
  • libs/libmythtv/diseqcsettings.cpp

     
    5454
    5555    virtual void load(void)
    5656    {
    57         QString tmp = QString::number((uint) m_device.GetDeviceType());
    58         setValue(getValueIndex(tmp));
     57        setCurrentValue(QString::number((uint) m_device.GetDeviceType()));
    5958    }
    6059
    6160    virtual void save(void)
     
    154153
    155154    virtual void load(void)
    156155    {
    157         setValue(getValueIndex(QString::number((uint) m_switch.GetType())));
     156        setCurrentValue(QString::number((uint) m_switch.GetType()));
    158157    }
    159158
    160159    virtual void save(void)
     
    251250
    252251    virtual void load(void)
    253252    {
    254         setValue(getValueIndex(QString::number((uint)m_rotor.GetType())));
     253        setCurrentValue(QString::number((uint)m_rotor.GetType()));
    255254    }
    256255
    257256    virtual void save(void)
     
    394393
    395394void RotorPosMap::PopulateList(void)
    396395{
    397     int old_sel = getValueIndex(getValue());
     396    int old_sel = getSelectionIndices().first();
    398397    clearSelections();
    399398    uint num_pos = 64;
    400399    for (uint pos = 1; pos < num_pos; pos++)
     
    407406        addSelection(DeviceTree::tr("Position #%1 (%2)").arg(pos).arg(posval),
    408407                     QString::number(pos));
    409408    }
    410     setCurrentItem(old_sel);
     409    setCurrent(old_sel);
    411410}
    412411
    413412//////////////////////////////////////// RotorPosConfig
     
    556555
    557556    virtual void load(void)
    558557    {
    559         setValue(FindPreset(m_lnb));
     558        setCurrent(FindPreset(m_lnb));
    560559    }
    561560
    562561    virtual void save(void)
     
    590589
    591590    virtual void load(void)
    592591    {
    593         setValue(getValueIndex(QString::number((uint) m_lnb.GetType())));
     592        setCurrentValue(QString::number((uint) m_lnb.GetType()));
    594593    }
    595594
    596595    virtual void save(void)
     
    758757    }
    759758    else
    760759    {
    761         m_type->setValue(m_type->getValueIndex(
    762                              QString::number((uint)preset.type)));
     760        m_type->setCurrentValue(QString::number((uint)preset.type));
    763761        m_lof_switch->setValue(QString::number(preset.lof_sw / 1000));
    764762        m_lof_lo->setValue(QString::number(preset.lof_lo / 1000));
    765763        m_lof_hi->setValue(QString::number(preset.lof_hi / 1000));
     
    987985
    988986void DeviceTree::PopulateTree(void)
    989987{
    990     int old_sel = getValueIndex(getValue());
     988    int old_sel = getSelectionIndices().first();
    991989    clearSelections();
    992990    PopulateTree(m_tree.Root());
    993     setCurrentItem(old_sel);
     991    setCurrent(old_sel);
    994992}
    995993
    996994void DeviceTree::PopulateTree(DiSEqCDevDevice *node,
     
    10621060    virtual void load(void)
    10631061    {
    10641062        double value = m_settings.GetValue(m_node.GetDeviceID());
    1065         setValue((uint)value);
     1063        setCurrent((uint)value);
    10661064    }
    10671065
    10681066    virtual void save(void)
     
    11001098            addSelection(AngleToString(*it), QString::number(*it));
    11011099
    11021100        double angle = m_settings.GetValue(m_node.GetDeviceID());
    1103         setValue(getValueIndex(QString::number(angle)));
     1101        setCurrentValue(QString::number(angle));
    11041102    }
    11051103
    11061104    virtual void save(void)
  • libs/libmythtv/channelsettings.cpp

     
    6262        {
    6363            uint which = sourceid_to_index[default_sourceid];
    6464            if (which)
    65                 setValue(which);
     65                setCurrent(which);
    6666        }
    6767    };
    6868
  • libs/libmythtv/recordingprofile.cpp

     
    130130   MPEG2audBitrateL1(const RecordingProfile& parent):
    131131        CodecParam(parent, "mpeg2audbitratel1") {
    132132        setLabel(QObject::tr("Bitrate"));
    133        
     133
    134134        addSelection("32 kbps", "32");
    135135        addSelection("64 kbps", "64");
    136136        addSelection("96 kbps", "96");
     
    145145        addSelection("384 kbps", "384");
    146146        addSelection("416 kbps", "416");
    147147        addSelection("448 kbps", "448");
    148         setValue(13);
     148        setCurrent(13);
    149149        setHelpText(QObject::tr("Sets the audio bitrate"));
    150150    };
    151151};
     
    155155   MPEG2audBitrateL2(const RecordingProfile& parent):
    156156        CodecParam(parent, "mpeg2audbitratel2") {
    157157        setLabel(QObject::tr("Bitrate"));
    158        
     158
    159159        addSelection("32 kbps", "32");
    160160        addSelection("48 kbps", "48");
    161161        addSelection("56 kbps", "56");
     
    170170        addSelection("256 kbps", "256");
    171171        addSelection("320 kbps", "320");
    172172        addSelection("384 kbps", "384");
    173         setValue(13);
     173        setCurrent(13);
    174174        setHelpText(QObject::tr("Sets the audio bitrate"));
    175175    };
    176176};
     
    212212        audbr->setLabel("Layer II");
    213213        addTarget("Layer II", audbr);
    214214        audType->addSelection("Layer II");
    215         audType->setValue(1);
     215        audType->setCurrent(1);
    216216    };
    217217};
    218218
     
    228228        addSelection(QObject::tr("SAP Language"),  "1");
    229229        addSelection(QObject::tr("Dual"),          "2");
    230230
    231         setValue(0);
     231        setCurrent(0);
    232232        setHelpText(QObject::tr(
    233233                        "Chooses the language(s) to record when "
    234234                        "two languages are broadcast. Only Layer II "
     
    505505    MPEG2streamType(const RecordingProfile& parent):
    506506        CodecParam(parent, "mpeg2streamtype") {
    507507        setLabel(QObject::tr("Stream Type"));
    508        
     508
    509509        addSelection("MPEG-2 PS");
    510510        addSelection("MPEG-2 TS");
    511511        addSelection("MPEG-1 VCD");
     
    515515        addSelection("DVD");
    516516        addSelection("DVD-Special 1");
    517517        addSelection("DVD-Special 2");
    518         setValue(0);
     518        setCurrent(0);
    519519        setHelpText(QObject::tr("Sets the type of stream generated by "
    520520                    "your PVR."));
    521521    };
     
    526526    MPEG2aspectRatio(const RecordingProfile& parent):
    527527        CodecParam(parent, "mpeg2aspectratio") {
    528528        setLabel(QObject::tr("Aspect Ratio"));
    529        
     529
    530530        addSelection(QObject::tr("Square"), "Square");
    531531        addSelection("4:3");
    532532        addSelection("16:9");
    533533        addSelection("2.21:1");
    534         setValue(1);
     534        setCurrent(1);
    535535        setHelpText(QObject::tr("Sets the aspect ratio of stream generated "
    536536                    "by your PVR."));
    537537    };
     
    555555        addSelection("1");
    556556        addSelection("2");
    557557        addSelection("4");
    558         setValue(2);
     558        setCurrent(2);
    559559    };
    560560};
    561561
     
    567567        addSelection("1");
    568568        addSelection("2");
    569569        addSelection("4");
    570         setValue(2);
     570        setCurrent(2);
    571571    };
    572572};
    573573
     
    741741        addSelection(QObject::tr("Normal"),     "all");
    742742        addSelection(QObject::tr("TV Only"),    "tv");
    743743        addSelection(QObject::tr("Audio Only"), "audio");
    744         setValue(0);
     744        setCurrent(0);
    745745    };
    746746};
    747747
  • libs/libmythtv/scheduledrecording.cpp

     
    628628            case kChannelRecord:
    629629                label = QString("%1 on channel %2")
    630630                    .arg(sr.title->getValue())
    631                     .arg(sr.channel->getSelectionLabel());
     631                    .arg(sr.channel->getSelectionLabels().first());
    632632                break;
    633633            case kWeekslotRecord:
    634634                weekly = QDate(sr.startDate->dateValue()).toString("dddd")+"s ";
    635635            case kTimeslotRecord:
    636636                label = QString("%1 on channel %2 (%3%4 - %5)")
    637637                    .arg(sr.title->getValue())
    638                     .arg(sr.channel->getSelectionLabel())
     638                    .arg(sr.channel->getSelectionLabels().first())
    639639                    .arg(weekly)
    640640                    .arg(sr.startTime->timeValue().toString())
    641641                    .arg(sr.endTime->timeValue().toString());
     
    645645            case kDontRecord:
    646646                label = QString("%1 on channel %2 (%3 %4 - %5)")
    647647                    .arg(sr.title->getValue())
    648                     .arg(sr.channel->getSelectionLabel())
     648                    .arg(sr.channel->getSelectionLabels().first())
    649649                    .arg(sr.startDate->dateValue().toString())
    650650                    .arg(sr.startTime->timeValue().toString())
    651651                    .arg(sr.endTime->timeValue().toString());
     
    755755    title->setValue("");
    756756    subtitle->setValue("");
    757757    description->setValue("");
    758     channel->setValue("");
     758    channel->setCurrent(0);
     759    channel->setState(0, false);
    759760    station->setValue("");
    760761    QDate date = QDate::currentDate();
    761762    QTime time = QTime::currentTime();
     
    825826        title->setValue(proginfo->title);
    826827        subtitle->setValue(proginfo->subtitle);
    827828        description->setValue(proginfo->description);
    828         channel->setValue(proginfo->chanid);
     829        channel->setCurrentValue(proginfo->chanid);
    829830        station->setValue(proginfo->chansign);
    830831        startDate->setValue(proginfo->startts.date());
    831832        startTime->setValue(proginfo->startts.time());
  • libs/libmythtv/scanwizardhelpers.cpp

     
    184184
    185185    if (sourceid > -1)
    186186    {
    187         setValue(which);
     187        setCurrent(which);
    188188        setEnabled(false);
    189189    }
    190190}
     
    472472        parent, SLOT(captureCard(const QString&)));
    473473}
    474474
    475 LogList::LogList() : n(0)
     475LogList::LogList() : ListBoxSetting(MythListBox::NoSelection), n(0)
    476476{
    477     setSelectionMode(MythListBox::NoSelection);
    478477}
    479478
    480479void LogList::updateText(const QString& status)
    481480{
    482481    addSelection(status,QString::number(n));
    483     setCurrentItem(n);
     482    setCurrent(n);
    484483    n++;
    485484}
  • libs/libmyth/settings.cpp

     
    361361    triggerMap[triggerValue] = target;
    362362}
    363363
    364 void SelectSetting::addSelection(const QString& label, QString value, bool select) {
     364void SelectSetting::addSelection(const QString& label, QString value, bool state)
     365{
    365366    if (value == QString::null)
    366367        value = label;
    367    
    368     bool found = false;
    369     for(unsigned i = 0 ; i < values.size() ; ++i)
    370         if ((values[i] == value) &&
    371             (labels[i] == label)) {
    372             found = true;
    373             break;
    374         }
    375368
    376     if (!found)
     369    int index = labels.findIndex(label);
     370
     371    if (index == -1)
    377372    {
    378         labels.push_back(label);
    379         values.push_back(value);
    380    
    381         emit selectionAdded(label, value);
    382    
    383         if (select || !isSet)
    384             setValue(value);
     373        labels.append(label);
     374        values.append(value);
     375        states.append(state);
     376
     377        emit selectionAdded(label, value, state);
     378
     379        if (state)
     380        {
     381            selectionIndices.append(states.count() - 1);
     382            selectionLabels.append(label);
     383            selectionValues.append(value);
     384            updateValue();
     385        }
    385386    }
     387    else
     388    {
     389        setState(index, state);
     390    }
    386391}
    387392
    388393void SelectSetting::fillSelectionsFromDir(const QDir& dir, bool absPath) {
     
    400405             addSelection(fi->fileName());
    401406}
    402407
    403 void SelectSetting::clearSelections(void) {
     408void SelectSetting::clearSelections()
     409{
    404410    labels.clear();
    405411    values.clear();
    406     isSet = false;
     412    states.clear();
     413    selectionIndices.clear();
     414    selectionLabels.clear();
     415    selectionValues.clear();
     416    updateValue();
    407417    emit selectionsCleared();
    408418}
    409419
    410 void SelectSetting::setValue(const QString& newValue)  {
    411     bool found = false;
    412     for(unsigned i = 0 ; i < values.size() ; ++i)
    413         if (values[i] == newValue) {
    414             current = i;
    415             found = true;
    416             isSet = true;
    417             break;
     420void SelectSetting::setCurrent(uint which)
     421{
     422    if (which < labels.count())
     423    {
     424        for(uint i = 0 ; i < states.size() ; ++i)
     425            states[i] = false;
     426        selectionIndices.clear();
     427        selectionLabels.clear();
     428        selectionValues.clear();
     429        selectionIndices.append(which);
     430        selectionLabels.append(labels[which]);
     431        selectionValues.append(values[which]);
     432        states[which] = true;
     433        updateValue();
     434    }
     435    else
     436    {
     437        VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrent(%2) - invalid value")
     438                .arg(getName())
     439                .arg(which));
     440    }
     441}
     442
     443void SelectSetting::setCurrentLabel(const QString& label)
     444{
     445    int index = labels.findIndex(label);
     446
     447    if (index == -1)
     448    {
     449        if (expand)
     450        {
     451            for(uint j = 0 ; j < states.size() ; ++j)
     452                states[j] = false;
     453            selectionIndices.clear();
     454            selectionLabels.clear();
     455            selectionValues.clear();
     456
     457            addSelection(label, label, true);
    418458        }
    419     if (found)
    420         Setting::setValue(newValue);
     459        else
     460        {
     461            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrentLabel(%2) - invalid label")
     462                    .arg(getName())
     463                    .arg(label));
     464        }
     465    }
    421466    else
    422         addSelection(newValue, newValue, true);
     467    {
     468        setCurrent(index);
     469    }
    423470}
    424471
    425 void SelectSetting::setValue(int which)
     472void SelectSetting::setCurrentValue(const QString& value)
    426473{
    427     if ((unsigned)which > values.size()-1 || which < 0) {
    428         VERBOSE(VB_IMPORTANT,
    429                 "SelectSetting::setValue(): invalid index " << which);
    430         return;
     474    int index = values.findIndex(value);
     475
     476    if (index == -1)
     477    {
     478        if (expand)
     479        {
     480            for(uint j = 0 ; j < states.size() ; ++j)
     481                states[j] = false;
     482            selectionIndices.clear();
     483            selectionLabels.clear();
     484            selectionValues.clear();
     485
     486            addSelection(value, value, true);
     487        }
     488        else
     489        {
     490            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrent(%2) - invalid value")
     491                    .arg(getName())
     492                    .arg(value));
     493        }
    431494    }
    432     current = which;
    433     isSet = true;
    434     Setting::setValue(values[current]);
     495    else
     496    {
     497        setCurrent(index);
     498    }
    435499}
    436500
     501void SelectSetting::setState(uint which, bool state)
     502{
     503    if (which < labels.count())
     504    {
     505        if (states[which] != state)
     506        {
     507            states[which] = state;
     508            if (!states[which])
     509            {
     510                selectionIndices.remove(which);
     511                selectionLabels.remove(labels[which]);
     512                selectionValues.remove(values[which]);
     513            }
     514            else
     515            {
     516                selectionIndices.append(which);
     517                selectionLabels.append(labels[which]);
     518                selectionValues.append(values[which]);
     519            }
     520            updateValue();
     521        }
     522    }
     523    else
     524    {
     525        VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setState(%2, %3) - invalid value")
     526                .arg(getName())
     527                .arg(which)
     528                .arg(state));
     529    }
     530}
     531
     532void SelectSetting::setStateLabel(const QString& label, bool state)
     533{
     534    int index = labels.findIndex(label);
     535
     536    if (index == -1)
     537    {
     538        if (expand)
     539        {
     540            addSelection(label, label, true);
     541        }
     542        else
     543        {
     544            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setStateLabel(%2, %3) - invalid label")
     545                    .arg(getName())
     546                    .arg(label)
     547                    .arg(state));
     548        }
     549    }
     550    else
     551    {
     552        setState(index, state);
     553    }
     554}
     555
     556void SelectSetting::setStateValue(const QString& value, bool state)
     557{
     558    int index = values.findIndex(value);
     559
     560    if (index == -1)
     561    {
     562        if (expand)
     563        {
     564            addSelection(value, value, true);
     565        }
     566        else
     567        {
     568            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setStateValue(%2, %3) - invalid value")
     569                    .arg(getName())
     570                    .arg(value)
     571                    .arg(state));
     572        }
     573    }
     574    else
     575    {
     576        setState(index, state);
     577    }
     578}
     579
     580void SelectSetting::setValue(const QString& newValue)
     581{
     582    for(uint i = 0 ; i < states.size() ; ++i)
     583        states[i] = false;
     584    selectionIndices.clear();
     585    selectionLabels.clear();
     586    selectionValues.clear();
     587
     588    selectionValues = QStringList::split(';', newValue);
     589
     590    for (QStringList::iterator iter = selectionValues.begin(); iter != selectionValues.end(); iter++)
     591    {
     592        int index = values.findIndex(*iter);
     593
     594        if (index == -1)
     595        {
     596            if (expand)
     597            {
     598                labels.append(*iter);
     599                values.append(*iter);
     600                states.append(true);
     601
     602                emit selectionAdded(*iter, *iter, true);
     603
     604                selectionIndices.append(states.count() - 1);
     605                selectionLabels.append(*iter);
     606           }
     607            else
     608            {
     609                VERBOSE(VB_IMPORTANT,
     610                        "SelectSetting(" << getName() << ")::setValue(" << *iter << "): invalid value ");
     611                iter = selectionValues.erase(iter);
     612                iter--;
     613            }
     614        }
     615        else
     616        {
     617            selectionIndices.append(index);
     618            selectionLabels.append(labels[index]);
     619            states[index] = true;
     620        }
     621    }
     622
     623    updateValue();
     624}
     625
     626void SelectSetting::updateValue()
     627{
     628    QString newValue("");
     629    for (QStringList::const_iterator iter = selectionValues.begin(); iter != selectionValues.end(); iter++)
     630    {
     631        if (!newValue.isEmpty())
     632            newValue.append(';');
     633        newValue.append(*iter);
     634     }
     635     Setting::setValue(newValue);
     636     emit selectionChanged();
     637}
     638
    437639QWidget* LabelSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
    438640                                    const char* widgetName) {
    439641    (void)cg;
     
    635837    }
    636838
    637839    QLabel* value = new QLabel(widget);
    638     value->setText(labels[current]);
     840    value->setText(getValue());
    639841    value->setBackgroundOrigin(QWidget::WindowOrigin);
    640842
    641843    connect(this, SIGNAL(valueChanged(const QString&)),
     
    644846    return widget;
    645847}
    646848
     849ComboBoxSetting::ComboBoxSetting(bool _rw, int _step) :
     850    SelectSetting(_rw),
     851    rw(_rw),
     852    widget(NULL),
     853    step(_step)
     854{
     855    connect(this, SIGNAL(selectionAdded(const QString&, const QString&, bool)),
     856            this, SLOT(selectionAdded(const QString&, const QString&, bool)));
     857    connect(this, SIGNAL(selectionChanged()),
     858            this, SLOT(selectionChanged()));
     859}
     860
    647861QWidget* ComboBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
    648862                                       const char* widgetName) {
    649863    QHBox* box;
     
    672886    box->setStretchFactor(widget, 1);
    673887
    674888    for(unsigned int i = 0 ; i < labels.size() ; ++i)
     889    {
    675890        widget->insertItem(labels[i]);
     891        if (states[i])
     892            widget->setCurrentItem(i);
     893    }
    676894
    677     if (isSet)
    678         widget->setCurrentItem(current);
     895    setState(widget->currentItem(), true);
    679896
    680897    if (1 < step)
    681898        widget->setStep(step);
    682899
    683     if (rw)
    684         connect(widget, SIGNAL(highlighted(const QString &)),
    685                 this, SLOT(setValue(const QString &)));
    686     else
    687         connect(widget, SIGNAL(highlighted(int)),
    688                 this, SLOT(setValue(int)));
    689 
     900    connect(widget, SIGNAL(highlighted(const QString &)),
     901            this, SLOT(setCurrentLabel(const QString &)));
    690902    connect(widget, SIGNAL(destroyed()),
    691903            this, SLOT(widgetDestroyed()));
    692904    connect(this, SIGNAL(selectionsCleared()),
     
    719931    }
    720932}
    721933
    722 void ComboBoxSetting::setValue(QString newValue)
     934void ComboBoxSetting::selectionAdded(const QString& label, const QString&, bool)
    723935{
    724     if (!rw)
     936    if (widget)
    725937    {
    726         VERBOSE(VB_IMPORTANT, "ComboBoxSetting::setValue(QString): "
    727                 "BUG: attempted to set value of read-only ComboBox");
    728         return;
     938        widget->insertItem(label);
    729939    }
    730     Setting::setValue(newValue);
    731     if (widget)
    732         widget->setCurrentItem(current);
    733 };
     940}
    734941
    735 void ComboBoxSetting::setValue(int which)
     942void ComboBoxSetting::selectionChanged()
    736943{
    737944    if (widget)
    738         widget->setCurrentItem(which);
    739     SelectSetting::setValue(which);
    740 };
     945    {
     946        widget->setCurrentItem(getSelectionIndices().first());
     947    }
     948}
    741949
    742950void HostRefreshRateComboBox::ChangeResolution(const QString& resolution)
    743951{
    744952    clearSelections();
    745    
     953
    746954    const vector<short> list = GetRefreshRates(resolution);
    747955    addSelection(QObject::tr("Any"), "0");
    748956    int hz50 = -1, hz60 = -1;
    749957    for (uint i=0; i<list.size(); ++i)
    750     {       
     958    {
    751959        QString sel = QString::number(list[i]);
    752960        addSelection(sel+" Hz", sel);
    753961        hz50 = (50 == list[i]) ? i : hz50;
    754962        hz60 = (60 == list[i]) ? i : hz60;
    755963    }
    756    
    757     setValue(0);
     964
    758965    if ("640x480" == resolution || "720x480" == resolution)
    759         setValue(hz60+1);
    760     if ("640x576" == resolution || "720x576" == resolution)
    761         setValue(hz50+1);
    762    
     966        setCurrent(hz60 + 1);
     967    else if ("640x576" == resolution || "720x576" == resolution)
     968        setCurrent(hz50 + 1);
     969    else
     970        setCurrent(0);
     971
    763972    setEnabled(list.size());
    764973}
    765974
     
    8391048        QRadioButton* button = new QRadioButton(widget, NULL);
    8401049        button->setBackgroundOrigin(QWidget::WindowOrigin);
    8411050        button->setText(labels[i]);
    842         if (isSet && i == current)
     1051        if (states[i])
    8431052            button->setDown(true);
    8441053    }
    8451054
     1055    setState(widget->selectedId(), true);
     1056
    8461057    cg = cg;
    8471058
    8481059    return widget;
     
    11181329    save(table);
    11191330}
    11201331
    1121 void ListBoxSetting::setEnabled(bool b)
     1332
     1333ListBoxSetting::ListBoxSetting(MythListBox::SelectionMode mode) :
     1334    selectionMode(mode),
     1335    widget(NULL)
    11221336{
    1123     Configurable::setEnabled(b);
    1124     if (widget)
    1125         widget->setEnabled(b);
     1337    connect(this, SIGNAL(selectionAdded(const QString&, const QString&, bool)),
     1338            this, SLOT(selectionAdded(const QString&, const QString&, bool)));
     1339    connect(this, SIGNAL(selectionChanged()),
     1340            this, SLOT(selectionChanged()));
    11261341}
    11271342
    11281343QWidget* ListBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
     
    11391354
    11401355    widget = new MythListBox(box);
    11411356    widget->setBackgroundOrigin(QWidget::WindowOrigin);
     1357    widget->setSelectionMode(selectionMode);
    11421358    widget->setHelpText(getHelpText());
    11431359
    1144     for(unsigned int i = 0 ; i < labels.size() ; ++i) {
     1360    for(uint i = 0 ; i < labels.size() ; ++i) {
    11451361        widget->insertItem(labels[i]);
    1146         if (isSet && current == i)
    1147             widget->setCurrentItem(i);
     1362        widget->setSelected(i, states[i]);
    11481363    }
    11491364
    11501365    connect(widget, SIGNAL(destroyed()),
     
    11591374            this, SIGNAL(editButtonPressed(int)));
    11601375    connect(widget, SIGNAL(deleteButtonPressed(int)),
    11611376            this, SIGNAL(deleteButtonPressed(int)));
    1162     connect(this, SIGNAL(valueChanged(const QString&)),
    1163             widget, SLOT(setCurrentItem(const QString&)));
    1164     connect(widget, SIGNAL(highlighted(int)),
    1165             this, SLOT(setValueByIndex(int)));
     1377    connect(widget, SIGNAL(selectionChanged()),
     1378            this, SLOT(updateSelection()));
    11661379
    11671380    if (cg)
    11681381        connect(widget, SIGNAL(changeHelpText(QString)), cg,
    11691382                SIGNAL(changeHelpText(QString)));
    11701383
    11711384    widget->setFocus();
    1172     widget->setSelectionMode(selectionMode);
    11731385
    11741386    return box;
    11751387}
    11761388
    1177 void ListBoxSetting::setSelectionMode(MythListBox::SelectionMode mode)
     1389void ListBoxSetting::setEnabled(bool b)
    11781390{
    1179    selectionMode = mode;
    1180    if (widget)
    1181        widget->setSelectionMode(selectionMode);
     1391    Configurable::setEnabled(b);
     1392    if (widget)
     1393        widget->setEnabled(b);
    11821394}
    11831395
    1184 void ListBoxSetting::setValueByIndex(int index)
     1396void ListBoxSetting::selectionAdded(const QString& label, const QString&, bool)
    11851397{
    1186     if (((uint)index) < values.size())
    1187         setValue(values[index]);
     1398    if (widget)
     1399    {
     1400        widget->insertItem(label);
     1401    }
    11881402}
    11891403
    1190 void ImageSelectSetting::addImageSelection(const QString& label,
    1191                                            QImage* image,
    1192                                            QString value,
    1193                                            bool select) {
    1194     images.push_back(image);
    1195     addSelection(label, value, select);
     1404void ListBoxSetting::selectionChanged()
     1405{
     1406    if (widget)
     1407        for (uint i = 0; i < states[i]; ++i)
     1408            widget->setSelected(i, states[i]);
    11961409}
    11971410
    1198 ImageSelectSetting::~ImageSelectSetting() {
    1199     while (images.size() > 0) {
    1200         delete images.back();
    1201         images.pop_back();
    1202     }
     1411void ListBoxSetting::updateSelection()
     1412{
     1413    if (widget)
     1414        for (uint i = 0; i < widget->count(); ++i)
     1415            setState(i, widget->item(i)->isSelected());
    12031416}
    12041417
    1205 void ImageSelectSetting::imageSet(int num)
     1418
     1419ImageSelectSetting::ImageSelectSetting() :
     1420    imagelabel(NULL)
    12061421{
    1207     if (num >= (int)images.size())
    1208         return;
    1209 
    1210     if (!images[current])
    1211         return;
    1212 
    1213     QImage temp = *(images[current]);
    1214     temp = temp.smoothScale((int)(184 * m_hmult), (int)(138 * m_hmult),
    1215                             QImage::ScaleMin);
    1216 
    1217     QPixmap tmppix(temp);
    1218     imagelabel->setPixmap(tmppix);
     1422    images.setAutoDelete(true);
    12191423}
    12201424
    12211425QWidget* ImageSelectSetting::configWidget(ConfigurationGroup *cg,
     
    12261430
    12271431    gContext->GetScreenSettings(width, m_wmult, height, m_hmult);
    12281432
    1229     QHBox* box;
    1230     if (labelAboveWidget)
    1231     {
    1232         box = dynamic_cast<QHBox*>(new QVBox(parent, widgetName));
    1233         box->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    1234                                        QSizePolicy::Maximum));
    1235     }
    1236     else
    1237         box = new QHBox(parent, widgetName);
    1238 
     1433    QHBox* box = new QHBox(parent, widgetName);
    12391434    box->setBackgroundOrigin(QWidget::WindowOrigin);
     1435    box->setSpacing(100);
    12401436
    1241     if (getLabel() != "")
    1242     {
    1243         QLabel* label = new QLabel(box);
    1244         label->setText(getLabel() + ":");
    1245         label->setBackgroundOrigin(QWidget::WindowOrigin);
    1246     }
     1437    ComboBoxSetting::configWidget(cg, box);
    12471438
    1248     MythComboBox *widget = new MythComboBox(false, box);
    1249     widget->setBackgroundOrigin(QWidget::WindowOrigin);
    1250 
    1251     QLabel *testlabel = new QLabel(box);
    1252     testlabel->setText("  ");
    1253     testlabel->setBackgroundOrigin(QWidget::WindowOrigin);
    1254 
    12551439    imagelabel = new QLabel(box);
    12561440    imagelabel->setBackgroundOrigin(QWidget::WindowOrigin);
    12571441
    1258     for (unsigned int i = 0 ; i < images.size() ; ++i)
    1259         widget->insertItem(labels[i]);
     1442    selectionChanged();
    12601443
    1261     if (isSet)
    1262         widget->setCurrentItem(current);
    1263     else
    1264         current = 0;
     1444    connect(widget, SIGNAL(highlighted(int)), this, SLOT(imageSet(int)));
    12651445
    1266     if (images.size() != 0 && current < images.size() && images[current])
    1267     {
    1268         QImage temp = *(images[current]);
    1269         temp = temp.smoothScale((int)(184 * m_hmult), (int)(138 * m_hmult),
    1270                                 QImage::ScaleMin);
    1271  
    1272         QPixmap tmppix(temp);
    1273         imagelabel->setPixmap(tmppix);
     1446    return box;
     1447}
     1448
     1449void ImageSelectSetting::addSelection(const QString& label,
     1450                                      QImage* image,
     1451                                      QString value,
     1452                                      bool select)
     1453{
     1454    if (labels.find(label) == labels.end())
     1455    {
     1456        images.append(image);
     1457        SelectSetting::addSelection(label, value, select);
    12741458    }
    1275     else
     1459}
     1460
     1461void ImageSelectSetting::imageSet(int num)
     1462{
     1463    if (imagelabel)
    12761464    {
    12771465        QPixmap tmppix((int)(184 * m_hmult), (int)(138 * m_hmult));
    1278         tmppix.fill(black);
    12791466
     1467        if (num < (int)images.count() && images.at(num))
     1468            tmppix = images.at(num)->smoothScale((int)(184 * m_hmult),
     1469                                                 (int)(138 * m_hmult),
     1470                                                  QImage::ScaleMin);
     1471        else
     1472            tmppix.fill(black);
     1473
    12801474        imagelabel->setPixmap(tmppix);
    12811475    }
     1476}
    12821477
    1283     connect(widget, SIGNAL(highlighted(int)), this, SLOT(setValue(int)));
    1284     connect(widget, SIGNAL(highlighted(int)), this, SLOT(imageSet(int)));
     1478void ImageSelectSetting::selectionChanged()
     1479{
     1480    imageSet(getSelectionIndices().first());
     1481    ComboBoxSetting::selectionChanged();
     1482}
    12851483
    1286     connect(this, SIGNAL(selectionsCleared()),
    1287             widget, SLOT(clear()));
    12881484
    1289     if (cg)
    1290         connect(widget, SIGNAL(changeHelpText(QString)), cg,
    1291                 SIGNAL(changeHelpText(QString)));
    1292 
    1293     return box;
    1294 }
    1295 
    12961485HostnameSetting::HostnameSetting(void)  {
    12971486    setVisible(false);
    12981487   
  • libs/libmyth/dbsettings.cpp

     
    8181{
    8282    setLabel(QObject::tr("Database Configuration") + " 1/2");
    8383    setUseLabel(false);
    84    
     84
    8585    info = new TransLabelSetting();
    8686
    8787    MSqlQuery query(MSqlQuery::InitCon());
     
    9393                                   "Please verify your database settings "
    9494                                   "below."));
    9595    addChild(info);
    96    
     96
    9797    dbHostName = new TransLineEditSetting(true);
    9898    dbHostName->setLabel(QObject::tr("Host name"));
    9999    dbHostName->setHelpText(QObject::tr("The host name or IP address of "
     
    107107                                    "on, if it's not the default database "
    108108                                    "port."));
    109109    addChild(dbPort);
    110    
     110
    111111    dbName = new TransLineEditSetting(true);
    112112    dbName->setLabel(QObject::tr("Database"));
    113113    dbName->setHelpText(QObject::tr("The name of the database. "
     
    120120                                        "connecting to the database. "
    121121                                        "This information is required."));
    122122    addChild(dbUserName);
    123    
     123
    124124    dbPassword = new TransLineEditSetting(true);
    125125    dbPassword->setLabel(QObject::tr("Password"));
    126126    dbPassword->setHelpText(QObject::tr("The password to use while "
    127127                                        "connecting to the database. "
    128128                                        "This information is required."));
    129129    addChild(dbPassword);
    130    
     130
    131131    dbType = new TransComboBoxSetting(false);
    132132    dbType->setLabel(QObject::tr("Database type"));
    133133    dbType->addSelection(QObject::tr("MySQL"), "QMYSQL3");
    134134    //dbType->addSelection(QObject::tr("PostgreSQL"), "QPSQL7");
    135     dbType->setValue(0);
     135    dbType->setCurrent(0);
    136136    dbType->setHelpText(QObject::tr("The database implementation used "
    137137                                    "for your server."));
    138138    addChild(dbType);
     
    212212void MythDbSettings1::load()
    213213{
    214214    DatabaseParams params = gContext->GetDatabaseParams();
    215    
     215
    216216    if (params.dbHostName.isEmpty() ||
    217217        params.dbUserName.isEmpty() ||
    218218        params.dbPassword.isEmpty() ||
    219219        params.dbName.isEmpty())
    220220        info->setValue(info->getValue() + "\nRequired fields are marked "
    221221                                          "with an asterisk (*).");
    222    
     222
    223223    dbHostName->setValue(params.dbHostName);
    224224    if (params.dbHostName.isEmpty())
    225225        dbHostName->setLabel("* " + dbHostName->getLabel());
     
    236236    dbName->setValue(params.dbName);
    237237    if (params.dbName.isEmpty())
    238238        dbName->setLabel("* " + dbName->getLabel());
    239        
     239
    240240    if (params.dbType == "QMYSQL3")
    241         dbType->setValue(0);
     241        dbType->setCurrent(0);
    242242    else if (params.dbType == "QPSQL7")
    243         dbType->setValue(1);
     243        dbType->setCurrent(1);
    244244}
    245245
    246246void MythDbSettings2::load()
  • libs/libmyth/mythwidgets.cpp

     
    12421242void MythListBox::polish(void)
    12431243{
    12441244    QListBox::polish();
    1245    
     1245
    12461246    QPalette pal = palette();
    12471247    QColorGroup::ColorRole role = QColorGroup::Highlight;
    12481248    pal.setColor(QPalette::Active, role, pal.active().button());
    12491249    pal.setColor(QPalette::Inactive, role, pal.active().button());
    12501250    pal.setColor(QPalette::Disabled, role, pal.active().button());
    1251    
     1251
    12521252    setPalette(pal);
    12531253}
    12541254
     
    12871287                }
    12881288            }
    12891289            else
    1290             {   
     1290            {
    12911291                if (text(i).lower() == matchText.lower())
    12921292                {
    12931293                    setCurrentItem(i);
    12941294                    break;
    12951295                }
    1296             }       
     1296            }
    12971297        }
    1298     }           
     1298    }
    12991299}
    13001300
    13011301void MythListBox::keyPressEvent(QKeyEvent* e)
     
    13201320                        handled = true;
    13211321                        continue;
    13221322                    }
    1323                    
     1323
    13241324                    key = Key_Up;
    13251325                }
    13261326                else if (action == "DOWN")
     
    13321332                        handled = true;
    13331333                        continue;
    13341334                    }
    1335                    
     1335
    13361336                    key = Key_Down;
    13371337                }
    13381338                else if (action == "LEFT")
    13391339                {
    1340                     focusNextPrevChild(false);
     1340                    if (selectionMode() == Multi)
     1341                        toggleCurrentItem();
    13411342                    handled = true;
    13421343                    continue;
    13431344                }
    13441345                else if (action == "RIGHT")
    13451346                {
    1346                     focusNextPrevChild(true);
     1347                    if (selectionMode() == Multi)
     1348                        toggleCurrentItem();
    13471349                    handled = true;
    13481350                    continue;
    13491351                }
     
    13751377
    13761378void MythListBox::focusOutEvent(QFocusEvent *e)
    13771379{
     1380    if (selectionMode() == Single)
     1381        setSelected(currentItem(), false);
     1382
    13781383    QPalette pal = palette();
    13791384    QColorGroup::ColorRole role = QColorGroup::Highlight;
    13801385    pal.setColor(QPalette::Active, role, pal.active().button());
    13811386    pal.setColor(QPalette::Inactive, role, pal.active().button());
    13821387    pal.setColor(QPalette::Disabled, role, pal.active().button());
    1383    
     1388
    13841389    setPalette(pal);
    13851390    QListBox::focusOutEvent(e);
    13861391}
     
    13881393void MythListBox::focusInEvent(QFocusEvent *e)
    13891394{
    13901395    this->unsetPalette();
    1391    
     1396
    13921397    emit changeHelpText(helptext);
    13931398    QListBox::focusInEvent(e);
     1399
     1400    if (selectionMode() == Single)
     1401        setSelected(currentItem(), true);
    13941402}
    13951403
    13961404/* vim: set expandtab tabstop=4 shiftwidth=4: */
  • libs/libmyth/settings.h

     
    359359class MPUBLIC SelectSetting: virtual public Setting {
    360360    Q_OBJECT
    361361protected:
    362     SelectSetting() { isSet = false; };
     362    SelectSetting(bool _expand = false) : expand(_expand) { };
     363
    363364public:
    364365    virtual void addSelection(const QString& label,
    365                               QString value=QString::null,
    366                               bool select=false);
     366                              QString value = QString::null,
     367                              bool state = false);
    367368
    368     virtual void clearSelections(void);
     369    virtual const QValueList<uint> getSelectionIndices() const {return selectionIndices;}
     370    virtual const QStringList&     getSelectionLabels() const  {return selectionLabels;}
     371    virtual const QStringList&     getSelectionValues() const  {return selectionValues;}
    369372
     373    virtual void clearSelections();
     374
    370375    virtual void fillSelectionsFromDir(const QDir& dir, bool absPath=true);
    371376
    372377signals:
    373     void selectionAdded(const QString& label, QString value);
    374     void selectionsCleared(void);
     378    void selectionAdded(const QString& label, const QString& value, bool state);
     379    void selectionChanged();
     380    void selectionsCleared();
    375381
    376382public slots:
     383    virtual void setCurrent(uint which);
     384    virtual void setCurrentLabel(const QString& label);
     385    virtual void setCurrentValue(const QString& value);
     386    virtual void setState(uint which, bool state);
     387    virtual void setStateLabel(const QString& label, bool state);
     388    virtual void setStateValue(const QString& value, bool state);
    377389
     390private slots:
    378391    virtual void setValue(const QString& newValue);
    379     virtual void setValue(int which);
    380392
    381     virtual QString getSelectionLabel(void) const {
    382         if (!isSet)
    383             return QString::null;
    384         return labels[current];
    385     };
     393protected:
     394    virtual void updateValue();
    386395
    387     virtual int getValueIndex(QString value) {
    388         selectionList::iterator iter = values.begin();
    389         int ret = 0;
    390         while (iter != values.end()) {
    391             if (*iter == value) {
    392                 return ret;
    393             } else {
    394                 ret++;
    395                 iter++;
    396             }
    397         }
    398         return 0;
    399     };
    400 
    401396protected:
    402     typedef vector<QString> selectionList;
    403     selectionList labels;
    404     selectionList values;
    405     unsigned current;
    406     bool isSet;
     397    bool             expand;            // whether to expand selections via 'set' calls
     398    QStringList      labels;            // strings that are displayed
     399    QStringList      values;            // strings that are used internally
     400    QValueList<bool> states;            // states of possible selections
     401    QValueList<uint> selectionIndices;  // indices of currently selected items
     402    QStringList      selectionLabels;   // labels of currently selected items
     403    QStringList      selectionValues;   // values of currently selected items
    407404};
    408405
    409406class MPUBLIC SelectLabelSetting: public LabelSetting, public SelectSetting {
     
    419416    Q_OBJECT
    420417
    421418protected:
    422     ComboBoxSetting(bool _rw = false, int _step = 1) {
    423         rw = _rw;
    424         step = _step;
    425         widget = NULL;
    426     }
     419    ComboBoxSetting(bool _rw = false, int _step = 1);
    427420
    428421public:
    429     virtual void setValue(QString newValue);
    430     virtual void setValue(int which);
    431 
    432422    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    433423                                  const char* widgetName = 0);
    434424
     
    437427    virtual void setEnabled(bool b);
    438428    virtual void setVisible(bool b);
    439429
    440 public slots:
    441     void addSelection(const QString& label,
    442                       QString value=QString::null,
    443                       bool select=false) {
    444         if (widget != NULL)
    445             widget->insertItem(label);
    446         SelectSetting::addSelection(label, value, select);
    447     };
    448430protected slots:
     431    virtual void selectionAdded(const QString& label, const QString&, bool state);
     432    virtual void selectionChanged();
    449433    void widgetDestroyed() { widget=NULL; };
    450434
    451 private:
     435protected:
    452436    bool rw;
    453437    MythComboBox *widget;
    454 
    455 protected:
    456438    int step;
    457439};
    458440
    459441class MPUBLIC ListBoxSetting: public SelectSetting {
    460442    Q_OBJECT
     443
     444protected:
     445    ListBoxSetting(MythListBox::SelectionMode mode = MythListBox::Single);
     446
    461447public:
    462     ListBoxSetting(): widget(NULL), selectionMode(MythListBox::Single) { }
    463448    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    464449                                  const char* widgetName = 0);
    465450
    466451    void setFocus() { if (widget) widget->setFocus(); }
    467     void setSelectionMode(MythListBox::SelectionMode mode);
    468     void setCurrentItem(int i) { if (widget) widget->setCurrentItem(i); }
    469     void setCurrentItem(const QString& str)  { if (widget) widget->setCurrentItem(str); }
    470452
    471453    virtual void setEnabled(bool b);
    472454
     
    477459    void deleteButtonPressed(int);
    478460
    479461protected slots:
    480     void setValueByIndex(int index);
    481     void addSelection(const QString& label,
    482                       QString value=QString::null,
    483                       bool select=false) {
    484         SelectSetting::addSelection(label, value, select);
    485         if (widget != NULL)
    486             widget->insertItem(label);
    487     };
     462    virtual void selectionAdded(const QString& label, const QString&, bool state);
     463    virtual void selectionChanged();
     464    virtual void updateSelection();
    488465    void widgetDestroyed() { widget=NULL; };
     466
    489467protected:
    490     MythListBox* widget;
    491468    MythListBox::SelectionMode selectionMode;
     469    MythListBox* widget;
    492470};
    493471
    494472class MPUBLIC RadioSetting: public SelectSetting {
     
    497475                                  const char* widgetName = 0);
    498476};
    499477
    500 class MPUBLIC ImageSelectSetting: public SelectSetting {
     478class MPUBLIC ImageSelectSetting: public ComboBoxSetting {
    501479    Q_OBJECT
     480
     481protected:
     482    ImageSelectSetting();
     483
    502484public:
    503     virtual ~ImageSelectSetting();
    504485    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    505486                                  const char* widgetName = 0);
    506487
    507     virtual void addImageSelection(const QString& label,
    508                                    QImage* image,
    509                                    QString value=QString::null,
    510                                    bool select=false);
     488    virtual void addSelection(const QString& label,
     489                              QImage* image,
     490                              QString value = QString::null,
     491                              bool select = false);
     492private:
     493    virtual void addSelection(const QString&, QString, bool) {}
     494
    511495protected slots:
     496    virtual void selectionChanged();
    512497    void imageSet(int);
    513498
    514499protected:
    515     vector<QImage*> images;
    516     QLabel *imagelabel;
     500    QPtrList<QImage> images;
     501    QLabel* imagelabel;
    517502    float m_hmult, m_wmult;
    518503};
    519504
     
    918903        HostSetting(name) { }
    919904};
    920905
     906class MPUBLIC HostListBox: public ListBoxSetting, public HostSetting {
     907  public:
     908    HostListBox(const QString &name, MythListBox::SelectionMode mode = MythListBox::Single) :
     909        ListBoxSetting(mode),
     910        HostSetting(name) { }
     911};
     912
    921913class MPUBLIC HostImageSelect: public ImageSelectSetting, public HostSetting {
    922914  public:
    923915    HostImageSelect(const QString &name) :
  • libs/libmyth/mythwidgets.h

     
    356356    void focusInEvent(QFocusEvent *e);
    357357};
    358358
    359 class MPUBLIC MythListBox: public QListBox {
     359class MPUBLIC MythListBox: public QListBox
     360{
    360361    Q_OBJECT
    361362  public:
    362363    MythListBox(QWidget* parent);
  • programs/mythfrontend/globalsettings.cpp

     
    539539                                "shows to delete first.  LiveTV recordings "
    540540                                "will always expire before normal "
    541541                                "recordings."));
    542     bc->setValue(1);
     542    bc->setCurrent(1);
    543543    return bc;
    544544}
    545545
     
    698698    for (int i = 0; i < 4; i++)
    699699        gc->addSelection(str[i], QString::number(i));
    700700
    701     gc->setValue(1);
     701    gc->setCurrent(1);
    702702    gc->setHelpText(help);
    703703
    704704    return gc;
     
    14441444        gc->addSelection(QString::number(i), QString::number(i));
    14451445    gc->addSelection(QObject::tr("All"), QString::number(-1));
    14461446    gc->setLabel(QObject::tr("Xinerama screen"));
    1447     gc->setValue(0);
     1447    gc->setCurrent(0);
    14481448    gc->setHelpText(QObject::tr("Run on the specified screen or "
    14491449                    "spanning all screens."));
    14501450    return gc;
     
    16231623        DisplayResScreen dscr(w, h, -1, -1, -1.0, 0);
    16241624        short rate = -1;
    16251625        int i = DisplayResScreen::FindBestMatch(scr, dscr, rate);
    1626         gc->setValue((i >= 0) ? i : scr.size()-1);
     1626        gc->setCurrent((i >= 0) ? i : scr.size()-1);
    16271627    }
    16281628
    16291629    return gc;
     
    19231923            continue;
    19241924        }
    19251925
    1926         addImageSelection(theme->fileName(), previewImage);
     1926        addSelection(theme->fileName(), previewImage);
    19271927    }
    19281928
    1929     setValue("G.A.N.T.");
     1929    setCurrent(0);
    19301930}
    19311931
    19321932class StyleSetting: public HostComboBox {
     
    19671967    gc->addSelection(QObject::tr("callsign"), "<sign>");
    19681968    gc->addSelection(QObject::tr("name"), "<name>");
    19691969    gc->setHelpText(QObject::tr("Your preferred channel format."));
    1970     gc->setValue(1);
     1970    gc->setCurrent(1);
    19711971    return gc;
    19721972}
    19731973
     
    19811981    gc->addSelection(QObject::tr("callsign"), "<sign>");
    19821982    gc->addSelection(QObject::tr("name"), "<name>");
    19831983    gc->setHelpText(QObject::tr("Your preferred long channel format."));
    1984     gc->setValue(2);
     1984    gc->setCurrent(2);
    19851985    return gc;
    19861986}
    19871987
  • programs/mythfrontend/main.cpp

     
    505505        themename = themelist[rand() % themelist.size()];
    506506
    507507    ThemeSelector Theme;
    508     Theme.setValue(themename);
     508    Theme.setCurrentValue(themename);
    509509    Theme.save();
    510510
    511511    return themename;
  • programs/mythtv-setup/backendsettings.cpp

     
    227227    GlobalComboBox *gc = new GlobalComboBox("EITTimeOffset");
    228228    gc->setLabel(QObject::tr("Time offset for EIT listings"));
    229229    init_time_offsets(gc);
    230     gc->setValue(1);
     230    gc->setCurrent(1);
    231231    QString helptext = QObject::tr(
    232232        "Adjust the relative timezone of the EIT EPG data.  "
    233233        "'Auto' converts the EIT time to local time using your "