Ticket #2594: multiselect_mythtv_r11817.patch

File multiselect_mythtv_r11817.patch, 49.6 KB (added by mythtv@…, 13 years ago)

Patch refresh against head revision 11817

  • libs/libmythtv/channeleditor.cpp

     
    251251    src->addChild(source);
    252252    src->addChild(del);
    253253
    254     sort->setValue(sort->getValueIndex(list->getSortMode()));
    255     source->setValue(source->getValueIndex(list->getSourceID()));
     254    sort->setCurrentValue(list->getSortMode());
     255    source->setCurrentValue(list->getSourceID());
    256256    hide->setValue(list->getHideMode());
    257257
    258258    addChild(sort);
  • libs/libmythtv/playgroup.cpp

     
    254254
    255255void PlayGroupEditor::doDelete(void)
    256256{
    257     QString name = listbox->getValue();
     257    QString name = listbox->getSelectionValues().first();
     258
    258259    if (name.isEmpty() || name == "Default")
    259260        return;
    260261
     
    274275        if (!query.exec())
    275276            MythContext::DBError("PlayGroupEditor::doDelete", query);
    276277
    277         int lastIndex = listbox->getValueIndex(name);
     278        int lastIndex = listbox->getSelectionIndices().first();
    278279        lastValue = "";
    279280        load();
    280         listbox->setValue(lastIndex);
     281        listbox->setCurrent(lastIndex);
    281282    }
    282283
    283284    listbox->setFocus();
     
    298299
    299300    listbox->addSelection(tr("(Create new group)"), "");
    300301
    301     listbox->setValue(lastValue);
     302    listbox->setCurrentValue(lastValue);
    302303}
    303304
    304305int PlayGroupEditor::exec(void)
  • libs/libmythtv/scanwizardhelpers.h

     
    754754
    755755    void SetDefaultATSCFormat(const QString &d)
    756756    {
    757         int val = atsc_format->getValueIndex(d);
    758         atsc_format->setValue(val);
     757        atsc_format->setCurrentValue(d);
    759758    }
    760759
    761760  protected:
     
    812811
    813812    void SetDefaultATSCFormat(const QString &d)
    814813    {
    815         int val = atsc_format->getValueIndex(d);
    816         atsc_format->setValue(val);
     814        atsc_format->setCurrentValue(d);
    817815    }
    818816
    819817    void SetSourceID(uint sourceid)
     
    857855
    858856    void SetDefaultATSCFormat(const QString &d)
    859857    {
    860         int val = atsc_format->getValueIndex(d);
    861         atsc_format->setValue(val);
     858        atsc_format->setCurrentValue(d);
    862859    }
    863860
    864861  private:
  • libs/libmythtv/videosource.cpp

     
    9999
    100100    if (initial_sourceid)
    101101    {
    102         if (cnt)
    103             setValue(sel);
     102        setCurrent(sel);
    104103        setEnabled(false);
    105104    }
    106105}
     
    197196
    198197void TransFreqTableSelector::load(void)
    199198{
    200     int idx = getValueIndex(gContext->GetSetting("FreqTable"));
    201     if (idx >= 0)
    202         setValue(idx);
     199    setCurrentValue(gContext->GetSetting("FreqTable"));
    203200
    204201    if (!sourceid)
    205202        return;
     
    225222        if (!loaded_freq_table.isEmpty() &&
    226223            (loaded_freq_table.lower() != "default"))
    227224        {
    228             int idx = getValueIndex(loaded_freq_table);
    229             if (idx >= 0)
    230                 setValue(idx);
     225            setCurrentValue(loaded_freq_table);
    231226        }
    232227    }
    233228}
     
    18341829
    18351830QString CardInput::getSourceName(void) const
    18361831{
    1837     return sourceid->getSelectionLabel();
     1832    return sourceid->getSelectionLabels().first();
    18381833}
    18391834
    18401835void CardInput::SetChildCardID(uint ccid)
     
    19701965    else
    19711966    {
    19721967        cfgGrp->load(); // new
    1973         cardid->setValue(QString::number(_cardid));
     1968        cardid->setCurrentLabel(QString::number(_cardid));
    19741969        inputname->setValue(_inputname);
    19751970    }
    19761971}
  • libs/libmythtv/diseqcsettings.cpp

     
    5555
    5656    virtual void load(void)
    5757    {
    58         QString tmp = QString::number((uint) m_device.GetDeviceType());
    59         setValue(getValueIndex(tmp));
     58        setCurrentValue(QString::number((uint) m_device.GetDeviceType()));
    6059    }
    6160
    6261    virtual void save(void)
     
    163162
    164163    virtual void load(void)
    165164    {
    166         setValue(getValueIndex(QString::number((uint) m_switch.GetType())));
     165        setCurrentValue(QString::number((uint) m_switch.GetType()));
    167166    }
    168167
    169168    virtual void save(void)
     
    266265
    267266    virtual void load(void)
    268267    {
    269         setValue(getValueIndex(QString::number((uint)m_rotor.GetType())));
     268        setCurrentValue(QString::number((uint)m_rotor.GetType()));
    270269    }
    271270
    272271    virtual void save(void)
     
    418417
    419418void RotorPosMap::PopulateList(void)
    420419{
    421     int old_sel = getValueIndex(getValue());
     420    int old_sel = getSelectionIndices().first();
    422421    clearSelections();
    423422    uint num_pos = 64;
    424423    for (uint pos = 1; pos < num_pos; pos++)
     
    431430        addSelection(DeviceTree::tr("Position #%1 (%2)").arg(pos).arg(posval),
    432431                     QString::number(pos));
    433432    }
    434     setCurrentItem(old_sel);
     433    setCurrent(old_sel);
    435434}
    436435
    437436//////////////////////////////////////// RotorPosConfig
     
    583582
    584583    virtual void load(void)
    585584    {
    586         setValue(FindPreset(m_lnb));
     585        setCurrent(FindPreset(m_lnb));
    587586    }
    588587
    589588    virtual void save(void)
     
    621620
    622621    virtual void load(void)
    623622    {
    624         setValue(getValueIndex(QString::number((uint) m_lnb.GetType())));
     623        setCurrentValue(QString::number((uint) m_lnb.GetType()));
    625624    }
    626625
    627626    virtual void save(void)
     
    800799    }
    801800    else
    802801    {
    803         m_type->setValue(m_type->getValueIndex(
    804                              QString::number((uint)preset.type)));
     802        m_type->setCurrentValue(QString::number((uint)preset.type));
    805803        m_lof_switch->setValue(QString::number(preset.lof_sw / 1000));
    806804        m_lof_lo->setValue(QString::number(preset.lof_lo / 1000));
    807805        m_lof_hi->setValue(QString::number(preset.lof_hi / 1000));
     
    10301028
    10311029void DeviceTree::PopulateTree(void)
    10321030{
    1033     int old_sel = getValueIndex(getValue());
     1031    int old_sel = getSelectionIndices().first();
    10341032    clearSelections();
    10351033    PopulateTree(m_tree.Root());
    1036     setCurrentItem(old_sel);
     1034    setCurrent(old_sel);
    10371035}
    10381036
    10391037void DeviceTree::PopulateTree(DiSEqCDevDevice *node,
     
    11071105    virtual void load(void)
    11081106    {
    11091107        double value = m_settings.GetValue(m_node.GetDeviceID());
    1110         setValue((uint)value);
     1108        setCurrent((uint)value);
    11111109    }
    11121110
    11131111    virtual void save(void)
     
    11471145            addSelection(AngleToString(*it), QString::number(*it));
    11481146
    11491147        double angle = m_settings.GetValue(m_node.GetDeviceID());
    1150         setValue(getValueIndex(QString::number(angle)));
     1148        setCurrentValue(QString::number(angle));
    11511149    }
    11521150
    11531151    virtual void save(void)
  • libs/libmythtv/channelsettings.cpp

     
    6868        {
    6969            uint which = sourceid_to_index[default_sourceid];
    7070            if (which)
    71                 setValue(which);
     71                setCurrent(which);
    7272        }
    7373    }
    7474
  • libs/libmythtv/recordingprofile.cpp

     
    150150        CodecParamStorage(this, parent, "mpeg2audbitratel1")
    151151    {
    152152        setLabel(QObject::tr("Bitrate"));
    153        
     153
    154154        addSelection("32 kbps", "32");
    155155        addSelection("64 kbps", "64");
    156156        addSelection("96 kbps", "96");
     
    165165        addSelection("384 kbps", "384");
    166166        addSelection("416 kbps", "416");
    167167        addSelection("448 kbps", "448");
    168         setValue(13);
     168        setCurrent(13);
    169169        setHelpText(QObject::tr("Sets the audio bitrate"));
    170170    };
    171171};
     
    178178        CodecParamStorage(this, parent, "mpeg2audbitratel2")
    179179    {
    180180        setLabel(QObject::tr("Bitrate"));
    181        
     181
    182182        addSelection("32 kbps", "32");
    183183        addSelection("48 kbps", "48");
    184184        addSelection("56 kbps", "56");
     
    193193        addSelection("256 kbps", "256");
    194194        addSelection("320 kbps", "320");
    195195        addSelection("384 kbps", "384");
    196         setValue(13);
     196        setCurrent(13);
    197197        setHelpText(QObject::tr("Sets the audio bitrate"));
    198198    };
    199199};
     
    236236        audbr->setLabel("Layer II");
    237237        addTarget("Layer II", audbr);
    238238        audType->addSelection("Layer II");
    239         audType->setValue(1);
     239        audType->setCurrent(1);
    240240    };
    241241};
    242242
     
    252252        addSelection(QObject::tr("SAP Language"),  "1");
    253253        addSelection(QObject::tr("Dual"),          "2");
    254254
    255         setValue(0);
     255        setCurrent(0);
    256256        setHelpText(QObject::tr(
    257257                        "Chooses the language(s) to record when "
    258258                        "two languages are broadcast. Only Layer II "
     
    566566        CodecParamStorage(this, parent, "mpeg2streamtype")
    567567    {
    568568        setLabel(QObject::tr("Stream Type"));
    569        
     569
    570570        addSelection("MPEG-2 PS");
    571571        addSelection("MPEG-2 TS");
    572572        addSelection("MPEG-1 VCD");
     
    576576        addSelection("DVD");
    577577        addSelection("DVD-Special 1");
    578578        addSelection("DVD-Special 2");
    579         setValue(0);
     579        setCurrent(0);
    580580        setHelpText(QObject::tr("Sets the type of stream generated by "
    581581                    "your PVR."));
    582582    };
     
    590590        CodecParamStorage(this, parent, "mpeg2aspectratio")
    591591    {
    592592        setLabel(QObject::tr("Aspect Ratio"));
    593        
     593
    594594        addSelection(QObject::tr("Square"), "Square");
    595595        addSelection("4:3");
    596596        addSelection("16:9");
    597597        addSelection("2.21:1");
    598         setValue(1);
     598        setCurrent(1);
    599599        setHelpText(QObject::tr("Sets the aspect ratio of stream generated "
    600600                    "by your PVR."));
    601601    };
     
    625625        addSelection("1");
    626626        addSelection("2");
    627627        addSelection("4");
    628         setValue(2);
     628        setCurrent(2);
    629629    };
    630630};
    631631
     
    640640        addSelection("1");
    641641        addSelection("2");
    642642        addSelection("4");
    643         setValue(2);
     643        setCurrent(2);
    644644    };
    645645};
    646646
     
    821821        addSelection(QObject::tr("Normal"),     "all");
    822822        addSelection(QObject::tr("TV Only"),    "tv");
    823823        addSelection(QObject::tr("Audio Only"), "audio");
    824         setValue(0);
     824        setCurrent(0);
    825825    };
    826826};
    827827
  • libs/libmythtv/scheduledrecording.cpp

     
    630630            case kChannelRecord:
    631631                label = QString("%1 on channel %2")
    632632                    .arg(sr.title->getValue())
    633                     .arg(sr.channel->getSelectionLabel());
     633                    .arg(sr.channel->getSelectionLabels().first());
    634634                break;
    635635            case kWeekslotRecord:
    636636                weekly = QDate(sr.startDate->dateValue()).toString("dddd")+"s ";
    637637            case kTimeslotRecord:
    638638                label = QString("%1 on channel %2 (%3%4 - %5)")
    639639                    .arg(sr.title->getValue())
    640                     .arg(sr.channel->getSelectionLabel())
     640                    .arg(sr.channel->getSelectionLabels().first())
    641641                    .arg(weekly)
    642642                    .arg(sr.startTime->timeValue().toString())
    643643                    .arg(sr.endTime->timeValue().toString());
     
    647647            case kDontRecord:
    648648                label = QString("%1 on channel %2 (%3 %4 - %5)")
    649649                    .arg(sr.title->getValue())
    650                     .arg(sr.channel->getSelectionLabel())
     650                    .arg(sr.channel->getSelectionLabels().first())
    651651                    .arg(sr.startDate->dateValue().toString())
    652652                    .arg(sr.startTime->timeValue().toString())
    653653                    .arg(sr.endTime->timeValue().toString());
     
    794794    title->setValue("");
    795795    subtitle->setValue("");
    796796    description->setValue("");
    797     channel->setValue("");
     797    channel->setCurrent(0);
     798    channel->setState(0, false);
    798799    station->setValue("");
    799800    startDate->setValue(date);
    800801    startTime->setValue(time);
     
    860861        title->setValue(proginfo->title);
    861862        subtitle->setValue(proginfo->subtitle);
    862863        description->setValue(proginfo->description);
    863         channel->setValue(proginfo->chanid);
     864        channel->setCurrentValue(proginfo->chanid);
    864865        station->setValue(proginfo->chansign);
    865866        startDate->setValue(proginfo->startts.date());
    866867        startTime->setValue(proginfo->startts.time());
  • libs/libmythtv/scanwizardhelpers.cpp

     
    291291    }
    292292
    293293    if (cnt)
    294         setValue(which);
     294        setCurrent(which);
    295295}
    296296
    297297void InputSelector::SetSourceID(const QString &_sourceid)
     
    767767    return scanConfig->GetATSCFormat(dfl);
    768768}
    769769
    770 LogList::LogList() : ListBoxSetting(this), n(0)
     770LogList::LogList() : ListBoxSetting(this, MythListBox::NoSelection), n(0)
    771771{
    772     setSelectionMode(MythListBox::NoSelection);
    773772}
    774773
    775774void LogList::updateText(const QString& status)
    776775{
    777776    addSelection(status,QString::number(n));
    778     setCurrentItem(n);
    779     n++;
     777    setCurrent(n++);
    780778}
  • libs/libmyth/settings.cpp

     
    505505    return widget;
    506506}
    507507
    508 void SelectSetting::addSelection(const QString& label, QString value, bool select) {
     508void SelectSetting::addSelection(const QString& label, QString value, bool state)
     509{
    509510    if (value == QString::null)
    510511        value = label;
    511    
    512     bool found = false;
    513     for(unsigned i = 0 ; i < values.size() ; ++i)
    514         if ((values[i] == value) &&
    515             (labels[i] == label)) {
    516             found = true;
    517             break;
    518         }
    519512
    520     if (!found)
     513    int index = values.findIndex(value);
     514
     515    if (index == -1)
    521516    {
    522         labels.push_back(label);
    523         values.push_back(value);
    524    
    525         emit selectionAdded(label, value);
    526    
    527         if (select || !isSet)
    528             setValue(value);
     517        labels.append(label);
     518        values.append(value);
     519        states.append(state);
     520
     521        emit selectionAdded(label, value, state);
     522
     523        if (state)
     524        {
     525            selectionIndices.append(states.count() - 1);
     526            selectionLabels.append(label);
     527            selectionValues.append(value);
     528            updateValue();
     529        }
    529530    }
     531    else
     532    {
     533        setState(index, state);
     534    }
    530535}
    531536
    532537void SelectSetting::fillSelectionsFromDir(const QDir& dir, bool absPath) {
     
    544549             addSelection(fi->fileName());
    545550}
    546551
    547 void SelectSetting::clearSelections(void) {
     552void SelectSetting::clearSelections()
     553{
    548554    labels.clear();
    549555    values.clear();
    550     isSet = false;
     556    states.clear();
     557    selectionIndices.clear();
     558    selectionLabels.clear();
     559    selectionValues.clear();
     560    updateValue();
    551561    emit selectionsCleared();
    552562}
    553563
    554 void SelectSetting::setValue(const QString& newValue)  {
    555     bool found = false;
    556     for(unsigned i = 0 ; i < values.size() ; ++i)
    557         if (values[i] == newValue) {
    558             current = i;
    559             found = true;
    560             isSet = true;
    561             break;
     564void SelectSetting::setCurrent(uint which)
     565{
     566    if (which < labels.count())
     567    {
     568        for(uint i = 0 ; i < states.size() ; ++i)
     569            states[i] = false;
     570        selectionIndices.clear();
     571        selectionLabels.clear();
     572        selectionValues.clear();
     573        selectionIndices.append(which);
     574        selectionLabels.append(labels[which]);
     575        selectionValues.append(values[which]);
     576        states[which] = true;
     577        updateValue();
     578    }
     579    else
     580    {
     581        VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrent(%2) - invalid value")
     582                .arg(getName())
     583                .arg(which));
     584    }
     585}
     586
     587void SelectSetting::setCurrentLabel(const QString& label)
     588{
     589    int index = labels.findIndex(label);
     590
     591    if (index == -1)
     592    {
     593        if (expand)
     594        {
     595            for(uint j = 0 ; j < states.size() ; ++j)
     596                states[j] = false;
     597            selectionIndices.clear();
     598            selectionLabels.clear();
     599            selectionValues.clear();
     600
     601            addSelection(label, label, true);
    562602        }
    563     if (found)
    564         Setting::setValue(newValue);
     603        else
     604        {
     605            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrentLabel(%2) - invalid label")
     606                    .arg(getName())
     607                    .arg(label));
     608        }
     609    }
    565610    else
    566         addSelection(newValue, newValue, true);
     611    {
     612        setCurrent(index);
     613    }
    567614}
    568615
    569 void SelectSetting::setValue(int which)
     616void SelectSetting::setCurrentValue(const QString& value)
    570617{
    571     if ((unsigned)which > values.size()-1 || which < 0) {
    572         VERBOSE(VB_IMPORTANT,
    573                 "SelectSetting::setValue(): invalid index " << which);
    574         return;
     618    int index = values.findIndex(value);
     619
     620    if (index == -1)
     621    {
     622        if (expand)
     623        {
     624            for(uint j = 0 ; j < states.size() ; ++j)
     625                states[j] = false;
     626            selectionIndices.clear();
     627            selectionLabels.clear();
     628            selectionValues.clear();
     629
     630            addSelection(value, value, true);
     631        }
     632        else
     633        {
     634            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setCurrent(%2) - invalid value")
     635                    .arg(getName())
     636                    .arg(value));
     637        }
    575638    }
    576     current = which;
    577     isSet = true;
    578     Setting::setValue(values[current]);
     639    else
     640    {
     641        setCurrent(index);
     642    }
    579643}
    580644
     645void SelectSetting::setState(uint which, bool state)
     646{
     647    if (which < labels.count())
     648    {
     649        if (states[which] != state)
     650        {
     651            states[which] = state;
     652            if (!states[which])
     653            {
     654                selectionIndices.remove(which);
     655                selectionLabels.remove(labels[which]);
     656                selectionValues.remove(values[which]);
     657            }
     658            else
     659            {
     660                selectionIndices.append(which);
     661                selectionLabels.append(labels[which]);
     662                selectionValues.append(values[which]);
     663            }
     664            updateValue();
     665        }
     666    }
     667    else
     668    {
     669        VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setState(%2, %3) - invalid value")
     670                .arg(getName())
     671                .arg(which)
     672                .arg(state));
     673    }
     674}
     675
     676void SelectSetting::setStateLabel(const QString& label, bool state)
     677{
     678    int index = labels.findIndex(label);
     679
     680    if (index == -1)
     681    {
     682        if (expand)
     683        {
     684            addSelection(label, label, true);
     685        }
     686        else
     687        {
     688            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setStateLabel(%2, %3) - invalid label")
     689                    .arg(getName())
     690                    .arg(label)
     691                    .arg(state));
     692        }
     693    }
     694    else
     695    {
     696        setState(index, state);
     697    }
     698}
     699
     700void SelectSetting::setStateValue(const QString& value, bool state)
     701{
     702    int index = values.findIndex(value);
     703
     704    if (index == -1)
     705    {
     706        if (expand)
     707        {
     708            addSelection(value, value, true);
     709        }
     710        else
     711        {
     712            VERBOSE(VB_IMPORTANT, QString("SelectSetting(%1)::setStateValue(%2, %3) - invalid value")
     713                    .arg(getName())
     714                    .arg(value)
     715                    .arg(state));
     716        }
     717    }
     718    else
     719    {
     720        setState(index, state);
     721    }
     722}
     723
     724void SelectSetting::setValue(const QString& newValue)
     725{
     726    for(uint i = 0 ; i < states.size() ; ++i)
     727        states[i] = false;
     728    selectionIndices.clear();
     729    selectionLabels.clear();
     730    selectionValues.clear();
     731
     732    selectionValues = QStringList::split(';', newValue);
     733
     734    for (QStringList::iterator iter = selectionValues.begin(); iter != selectionValues.end(); iter++)
     735    {
     736        int index = values.findIndex(*iter);
     737
     738        if (index == -1)
     739        {
     740            if (expand)
     741            {
     742                labels.append(*iter);
     743                values.append(*iter);
     744                states.append(true);
     745
     746                emit selectionAdded(*iter, *iter, true);
     747
     748                selectionIndices.append(states.count() - 1);
     749                selectionLabels.append(*iter);
     750           }
     751            else
     752            {
     753                VERBOSE(VB_IMPORTANT,
     754                        "SelectSetting(" << getName() << ")::setValue(" << *iter << "): invalid value ");
     755                iter = selectionValues.erase(iter);
     756                iter--;
     757            }
     758        }
     759        else
     760        {
     761            selectionIndices.append(index);
     762            selectionLabels.append(labels[index]);
     763            states[index] = true;
     764        }
     765    }
     766
     767    updateValue();
     768}
     769
     770void SelectSetting::updateValue()
     771{
     772    QString newValue("");
     773    for (QStringList::const_iterator iter = selectionValues.begin(); iter != selectionValues.end(); iter++)
     774    {
     775        if (!newValue.isEmpty())
     776            newValue.append(';');
     777        newValue.append(*iter);
     778     }
     779     Setting::setValue(newValue);
     780     emit selectionChanged();
     781}
     782
    581783QWidget* LabelSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
    582784                                    const char* widgetName) {
    583785    (void)cg;
     
    779981    }
    780982
    781983    QLabel* value = new QLabel(widget);
    782     value->setText(labels[current]);
     984    value->setText(getValue());
    783985    value->setBackgroundOrigin(QWidget::WindowOrigin);
    784986
    785987    connect(this, SIGNAL(valueChanged(const QString&)),
     
    788990    return widget;
    789991}
    790992
     993ComboBoxSetting::ComboBoxSetting(Storage *_storage, bool _rw, int _step) :
     994    SelectSetting(_storage, _rw),
     995    rw(_rw),
     996    widget(NULL),
     997    step(_step)
     998{
     999    connect(this, SIGNAL(selectionAdded(const QString&, const QString&, bool)),
     1000            this, SLOT(selectionAdded(const QString&, const QString&, bool)));
     1001    connect(this, SIGNAL(selectionChanged()),
     1002            this, SLOT(selectionChanged()));
     1003}
     1004
    7911005QWidget* ComboBoxSetting::configWidget(ConfigurationGroup *cg, QWidget* parent,
    7921006                                       const char* widgetName) {
    7931007    QHBox* box;
     
    8161030    box->setStretchFactor(widget, 1);
    8171031
    8181032    for(unsigned int i = 0 ; i < labels.size() ; ++i)
     1033    {
    8191034        widget->insertItem(labels[i]);
     1035        if (states[i])
     1036            widget->setCurrentItem(i);
     1037    }
    8201038
    821     if (isSet)
    822         widget->setCurrentItem(current);
     1039    setState(widget->currentItem(), true);
    8231040
    8241041    if (1 < step)
    8251042        widget->setStep(step);
    8261043
    827     if (rw)
    828         connect(widget, SIGNAL(highlighted(const QString &)),
    829                 this, SLOT(setValue(const QString &)));
    830     else
    831         connect(widget, SIGNAL(highlighted(int)),
    832                 this, SLOT(setValue(int)));
    833 
     1044    connect(widget, SIGNAL(highlighted(const QString &)),
     1045            this, SLOT(setCurrentLabel(const QString &)));
    8341046    connect(widget, SIGNAL(destroyed()),
    8351047            this, SLOT(widgetDestroyed()));
    8361048    connect(this, SIGNAL(selectionsCleared()),
     
    8631075    }
    8641076}
    8651077
    866 void ComboBoxSetting::setValue(QString newValue)
     1078void ComboBoxSetting::selectionAdded(const QString& label, const QString&, bool)
    8671079{
    868     if (!rw)
     1080    if (widget)
    8691081    {
    870         VERBOSE(VB_IMPORTANT, "ComboBoxSetting::setValue(QString): "
    871                 "BUG: attempted to set value of read-only ComboBox");
    872         return;
     1082        widget->insertItem(label);
    8731083    }
    874     Setting::setValue(newValue);
    875     if (widget)
    876         widget->setCurrentItem(current);
    877 };
     1084}
    8781085
    879 void ComboBoxSetting::setValue(int which)
     1086void ComboBoxSetting::selectionChanged()
    8801087{
    8811088    if (widget)
    882         widget->setCurrentItem(which);
    883     SelectSetting::setValue(which);
    884 };
     1089    {
     1090        widget->setCurrentItem(getSelectionIndices().first());
     1091    }
     1092}
    8851093
    8861094void HostRefreshRateComboBox::ChangeResolution(const QString& resolution)
    8871095{
    8881096    clearSelections();
    889    
     1097
    8901098    const vector<short> list = GetRefreshRates(resolution);
    8911099    addSelection(QObject::tr("Any"), "0");
    8921100    int hz50 = -1, hz60 = -1;
    8931101    for (uint i=0; i<list.size(); ++i)
    894     {       
     1102    {
    8951103        QString sel = QString::number(list[i]);
    8961104        addSelection(sel+" Hz", sel);
    8971105        hz50 = (50 == list[i]) ? i : hz50;
    8981106        hz60 = (60 == list[i]) ? i : hz60;
    8991107    }
    900    
    901     setValue(0);
     1108
    9021109    if ("640x480" == resolution || "720x480" == resolution)
    903         setValue(hz60+1);
    904     if ("640x576" == resolution || "720x576" == resolution)
    905         setValue(hz50+1);
    906    
     1110        setCurrent(hz60 + 1);
     1111    else if ("640x576" == resolution || "720x576" == resolution)
     1112        setCurrent(hz50 + 1);
     1113    else
     1114        setCurrent(0);
     1115
    9071116    setEnabled(list.size());
    9081117}
    9091118
     
    9831192        QRadioButton* button = new QRadioButton(widget, NULL);
    9841193        button->setBackgroundOrigin(QWidget::WindowOrigin);
    9851194        button->setText(labels[i]);
    986         if (isSet && i == current)
     1195        if (states[i])
    9871196            button->setDown(true);
    9881197    }
    9891198
     1199    setState(widget->selectedId(), true);
     1200
    9901201    cg = cg;
    9911202
    9921203    return widget;
     
    12801491    save(table);
    12811492}
    12821493
    1283 void ListBoxSetting::setEnabled(bool b)
     1494
     1495ListBoxSetting::ListBoxSetting(Storage *_storage, MythListBox::SelectionMode mode) :
     1496    SelectSetting(_storage),
     1497    selectionMode(mode),
     1498    widget(NULL)
    12841499{
    1285     Configurable::setEnabled(b);
    1286     if (widget)
    1287         widget->setEnabled(b);
     1500    connect(this, SIGNAL(selectionAdded(const QString&, const QString&, bool)),
     1501            this, SLOT(selectionAdded(const QString&, const QString&, bool)));
     1502    connect(this, SIGNAL(selectionChanged()),
     1503            this, SLOT(selectionChanged()));
    12881504}
    12891505
    12901506void ListBoxSetting::addSelection(
     
    13091525
    13101526    widget = new MythListBox(box);
    13111527    widget->setBackgroundOrigin(QWidget::WindowOrigin);
     1528    widget->setSelectionMode(selectionMode);
    13121529    widget->setHelpText(getHelpText());
    13131530
    1314     for(unsigned int i = 0 ; i < labels.size() ; ++i) {
     1531    for(uint i = 0 ; i < labels.size() ; ++i) {
    13151532        widget->insertItem(labels[i]);
    1316         if (isSet && current == i)
    1317             widget->setCurrentItem(i);
     1533        widget->setSelected(i, states[i]);
    13181534    }
    13191535
    13201536    connect(widget, SIGNAL(destroyed()),
     
    13291545            this, SIGNAL(editButtonPressed(int)));
    13301546    connect(widget, SIGNAL(deleteButtonPressed(int)),
    13311547            this, SIGNAL(deleteButtonPressed(int)));
    1332     connect(this, SIGNAL(valueChanged(const QString&)),
    1333             widget, SLOT(setCurrentItem(const QString&)));
    1334     connect(widget, SIGNAL(highlighted(int)),
    1335             this, SLOT(setValueByIndex(int)));
     1548    connect(widget, SIGNAL(selectionChanged()),
     1549            this, SLOT(updateSelection()));
    13361550
    13371551    if (cg)
    13381552        connect(widget, SIGNAL(changeHelpText(QString)), cg,
    13391553                SIGNAL(changeHelpText(QString)));
    13401554
    13411555    widget->setFocus();
    1342     widget->setSelectionMode(selectionMode);
    13431556
    13441557    return box;
    13451558}
    13461559
    1347 void ListBoxSetting::setSelectionMode(MythListBox::SelectionMode mode)
     1560void ListBoxSetting::setEnabled(bool b)
    13481561{
    1349    selectionMode = mode;
    1350    if (widget)
    1351        widget->setSelectionMode(selectionMode);
     1562    Configurable::setEnabled(b);
     1563    if (widget)
     1564        widget->setEnabled(b);
    13521565}
    13531566
    1354 void ListBoxSetting::setValueByIndex(int index)
     1567void ListBoxSetting::selectionAdded(const QString& label, const QString&, bool)
    13551568{
    1356     if (((uint)index) < values.size())
    1357         setValue(values[index]);
     1569    if (widget)
     1570    {
     1571        widget->insertItem(label);
     1572    }
    13581573}
    13591574
    1360 void ImageSelectSetting::addImageSelection(const QString& label,
    1361                                            QImage* image,
    1362                                            QString value,
    1363                                            bool select) {
    1364     images.push_back(image);
    1365     addSelection(label, value, select);
     1575void ListBoxSetting::selectionChanged()
     1576{
     1577    if (widget)
     1578        for (uint i = 0; i < states[i]; ++i)
     1579            widget->setSelected(i, states[i]);
    13661580}
    13671581
    1368 ImageSelectSetting::~ImageSelectSetting() {
    1369     while (images.size() > 0) {
    1370         delete images.back();
    1371         images.pop_back();
    1372     }
     1582void ListBoxSetting::updateSelection()
     1583{
     1584    if (widget)
     1585        for (uint i = 0; i < widget->count(); ++i)
     1586            setState(i, widget->item(i)->isSelected());
    13731587}
    13741588
    1375 void ImageSelectSetting::imageSet(int num)
     1589
     1590ImageSelectSetting::ImageSelectSetting(Storage *_storage) :
     1591    ComboBoxSetting(_storage),
     1592    imagelabel(NULL)
    13761593{
    1377     if (num >= (int)images.size())
    1378         return;
    1379 
    1380     if (!images[current])
    1381         return;
    1382 
    1383     QImage temp = *(images[current]);
    1384     temp = temp.smoothScale((int)(184 * m_hmult), (int)(138 * m_hmult),
    1385                             QImage::ScaleMin);
    1386 
    1387     QPixmap tmppix(temp);
    1388     imagelabel->setPixmap(tmppix);
     1594    images.setAutoDelete(true);
    13891595}
    13901596
    13911597QWidget* ImageSelectSetting::configWidget(ConfigurationGroup *cg,
     
    13961602
    13971603    gContext->GetScreenSettings(width, m_wmult, height, m_hmult);
    13981604
    1399     QHBox* box;
    1400     if (labelAboveWidget)
    1401     {
    1402         box = dynamic_cast<QHBox*>(new QVBox(parent, widgetName));
    1403         box->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    1404                                        QSizePolicy::Maximum));
    1405     }
    1406     else
    1407         box = new QHBox(parent, widgetName);
    1408 
     1605    QHBox* box = new QHBox(parent, widgetName);
    14091606    box->setBackgroundOrigin(QWidget::WindowOrigin);
     1607    box->setSpacing(100);
    14101608
    1411     if (getLabel() != "")
    1412     {
    1413         QLabel* label = new QLabel(box);
    1414         label->setText(getLabel() + ":");
    1415         label->setBackgroundOrigin(QWidget::WindowOrigin);
    1416     }
     1609    ComboBoxSetting::configWidget(cg, box);
    14171610
    1418     MythComboBox *widget = new MythComboBox(false, box);
    1419     widget->setBackgroundOrigin(QWidget::WindowOrigin);
    1420 
    1421     QLabel *testlabel = new QLabel(box);
    1422     testlabel->setText("  ");
    1423     testlabel->setBackgroundOrigin(QWidget::WindowOrigin);
    1424 
    14251611    imagelabel = new QLabel(box);
    14261612    imagelabel->setBackgroundOrigin(QWidget::WindowOrigin);
    14271613
    1428     for (unsigned int i = 0 ; i < images.size() ; ++i)
    1429         widget->insertItem(labels[i]);
     1614    selectionChanged();
    14301615
    1431     if (isSet)
    1432         widget->setCurrentItem(current);
    1433     else
    1434         current = 0;
     1616    connect(widget, SIGNAL(highlighted(int)), this, SLOT(imageSet(int)));
    14351617
    1436     if (images.size() != 0 && current < images.size() && images[current])
    1437     {
    1438         QImage temp = *(images[current]);
    1439         temp = temp.smoothScale((int)(184 * m_hmult), (int)(138 * m_hmult),
    1440                                 QImage::ScaleMin);
    1441  
    1442         QPixmap tmppix(temp);
    1443         imagelabel->setPixmap(tmppix);
     1618    return box;
     1619}
     1620
     1621void ImageSelectSetting::addSelection(const QString& label,
     1622                                      QImage* image,
     1623                                      QString value,
     1624                                      bool select)
     1625{
     1626    if (labels.find(label) == labels.end())
     1627    {
     1628        images.append(image);
     1629        SelectSetting::addSelection(label, value, select);
    14441630    }
    1445     else
     1631}
     1632
     1633void ImageSelectSetting::imageSet(int num)
     1634{
     1635    if (imagelabel)
    14461636    {
    14471637        QPixmap tmppix((int)(184 * m_hmult), (int)(138 * m_hmult));
    1448         tmppix.fill(black);
    14491638
     1639        if (num < (int)images.count() && images.at(num))
     1640            tmppix = images.at(num)->smoothScale((int)(184 * m_hmult),
     1641                                                 (int)(138 * m_hmult),
     1642                                                  QImage::ScaleMin);
     1643        else
     1644            tmppix.fill(black);
     1645
    14501646        imagelabel->setPixmap(tmppix);
    14511647    }
     1648}
    14521649
    1453     connect(widget, SIGNAL(highlighted(int)), this, SLOT(setValue(int)));
    1454     connect(widget, SIGNAL(highlighted(int)), this, SLOT(imageSet(int)));
     1650void ImageSelectSetting::selectionChanged()
     1651{
     1652    imageSet(getSelectionIndices().first());
     1653    ComboBoxSetting::selectionChanged();
     1654}
    14551655
    1456     connect(this, SIGNAL(selectionsCleared()),
    1457             widget, SLOT(clear()));
    14581656
    1459     if (cg)
    1460         connect(widget, SIGNAL(changeHelpText(QString)), cg,
    1461                 SIGNAL(changeHelpText(QString)));
    1462 
    1463     return box;
    1464 }
    1465 
    14661657HostnameSetting::HostnameSetting(Storage *storage) : Setting(storage)
    14671658{
    14681659    setVisible(false);
  • libs/libmyth/dbsettings.cpp

     
    7474    VerticalConfigurationGroup(false, true, false, false)
    7575{
    7676    setLabel(QObject::tr("Database Configuration") + " 1/2");
    77    
     77
    7878    info = new TransLabelSetting();
    7979
    8080    MSqlQuery query(MSqlQuery::InitCon());
     
    8686                                   "Please verify your database settings "
    8787                                   "below."));
    8888    addChild(info);
    89    
     89
    9090    dbHostName = new TransLineEditSetting(true);
    9191    dbHostName->setLabel(QObject::tr("Host name"));
    9292    dbHostName->setHelpText(QObject::tr("The host name or IP address of "
     
    100100                                    "on, if it's not the default database "
    101101                                    "port."));
    102102    addChild(dbPort);
    103    
     103
    104104    dbName = new TransLineEditSetting(true);
    105105    dbName->setLabel(QObject::tr("Database"));
    106106    dbName->setHelpText(QObject::tr("The name of the database. "
     
    113113                                        "connecting to the database. "
    114114                                        "This information is required."));
    115115    addChild(dbUserName);
    116    
     116
    117117    dbPassword = new TransLineEditSetting(true);
    118118    dbPassword->setLabel(QObject::tr("Password"));
    119119    dbPassword->setHelpText(QObject::tr("The password to use while "
    120120                                        "connecting to the database. "
    121121                                        "This information is required."));
    122122    addChild(dbPassword);
    123    
     123
    124124    dbType = new TransComboBoxSetting(false);
    125125    dbType->setLabel(QObject::tr("Database type"));
    126126    dbType->addSelection(QObject::tr("MySQL"), "QMYSQL3");
    127127    //dbType->addSelection(QObject::tr("PostgreSQL"), "QPSQL7");
    128     dbType->setValue(0);
     128    dbType->setCurrent(0);
    129129    dbType->setHelpText(QObject::tr("The database implementation used "
    130130                                    "for your server."));
    131131    addChild(dbType);
     
    203203void MythDbSettings1::load()
    204204{
    205205    DatabaseParams params = gContext->GetDatabaseParams();
    206    
     206
    207207    if (params.dbHostName.isEmpty() ||
    208208        params.dbUserName.isEmpty() ||
    209209        params.dbPassword.isEmpty() ||
    210210        params.dbName.isEmpty())
    211211        info->setValue(info->getValue() + "\nRequired fields are marked "
    212212                                          "with an asterisk (*).");
    213    
     213
    214214    dbHostName->setValue(params.dbHostName);
    215215    if (params.dbHostName.isEmpty())
    216216        dbHostName->setLabel("* " + dbHostName->getLabel());
     
    227227    dbName->setValue(params.dbName);
    228228    if (params.dbName.isEmpty())
    229229        dbName->setLabel("* " + dbName->getLabel());
    230        
     230
    231231    if (params.dbType == "QMYSQL3")
    232         dbType->setValue(0);
     232        dbType->setCurrent(0);
    233233    else if (params.dbType == "QPSQL7")
    234         dbType->setValue(1);
     234        dbType->setCurrent(1);
    235235}
    236236
    237237void 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

     
    287287{
    288288    Q_OBJECT
    289289
    290   protected:
    291     SelectSetting(Storage *_storage) :
    292         Setting(_storage), current(0), isSet(false) { }
     290protected:
     291    SelectSetting(Storage *_storage, bool _expand = false) :
     292        Setting(_storage), expand(_expand) { };
    293293
    294   public:
     294public:
    295295    virtual void addSelection(const QString& label,
    296                               QString value=QString::null,
    297                               bool select=false);
     296                              QString value = QString::null,
     297                              bool state = false);
    298298
    299     virtual void clearSelections(void);
     299    virtual const QValueList<uint> getSelectionIndices() const {return selectionIndices;}
     300    virtual const QStringList&     getSelectionLabels() const  {return selectionLabels;}
     301    virtual const QStringList&     getSelectionValues() const  {return selectionValues;}
    300302
     303    virtual void clearSelections();
     304
    301305    virtual void fillSelectionsFromDir(const QDir& dir, bool absPath=true);
    302306
    303307signals:
    304     void selectionAdded(const QString& label, QString value);
    305     void selectionsCleared(void);
     308    void selectionAdded(const QString& label, const QString& value, bool state);
     309    void selectionChanged();
     310    void selectionsCleared();
    306311
    307312public slots:
     313    virtual void setCurrent(uint which);
     314    virtual void setCurrentLabel(const QString& label);
     315    virtual void setCurrentValue(const QString& value);
     316    virtual void setState(uint which, bool state);
     317    virtual void setStateLabel(const QString& label, bool state);
     318    virtual void setStateValue(const QString& value, bool state);
    308319
     320private slots:
    309321    virtual void setValue(const QString& newValue);
    310     virtual void setValue(int which);
    311322
    312     virtual QString getSelectionLabel(void) const {
    313         if (!isSet)
    314             return QString::null;
    315         return labels[current];
    316     };
     323protected:
     324    virtual void updateValue();
    317325
    318     virtual int getValueIndex(QString value) {
    319         selectionList::iterator iter = values.begin();
    320         int ret = 0;
    321         while (iter != values.end()) {
    322             if (*iter == value) {
    323                 return ret;
    324             } else {
    325                 ret++;
    326                 iter++;
    327             }
    328         }
    329         return 0;
    330     };
    331 
    332326protected:
    333     typedef vector<QString> selectionList;
    334     selectionList labels;
    335     selectionList values;
    336     unsigned current;
    337     bool isSet;
     327    bool             expand;            // whether to expand selections via 'set' calls
     328    QStringList      labels;            // strings that are displayed
     329    QStringList      values;            // strings that are used internally
     330    QValueList<bool> states;            // states of possible selections
     331    QValueList<uint> selectionIndices;  // indices of currently selected items
     332    QStringList      selectionLabels;   // labels of currently selected items
     333    QStringList      selectionValues;   // values of currently selected items
    338334};
    339335
    340336class MPUBLIC SelectLabelSetting : public SelectSetting
     
    350346class MPUBLIC ComboBoxSetting: public SelectSetting {
    351347    Q_OBJECT
    352348
    353 protected:
    354     ComboBoxSetting(Storage *_storage, bool _rw = false, int _step = 1) :
    355         SelectSetting(_storage), rw(_rw), widget(NULL), step(_step) { }
    356 
    357349public:
    358     virtual void setValue(QString newValue);
    359     virtual void setValue(int which);
     350    ComboBoxSetting(Storage *_storage, bool _rw = false, int _step = 1);
    360351
     352public:
    361353    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    362354                                  const char* widgetName = 0);
    363355
     
    366358    virtual void setEnabled(bool b);
    367359    virtual void setVisible(bool b);
    368360
    369 public slots:
    370     void addSelection(const QString& label,
    371                       QString value=QString::null,
    372                       bool select=false) {
    373         if (widget != NULL)
    374             widget->insertItem(label);
    375         SelectSetting::addSelection(label, value, select);
    376     };
    377361protected slots:
     362    virtual void selectionAdded(const QString& label, const QString&, bool state);
     363    virtual void selectionChanged();
    378364    void widgetDestroyed() { widget=NULL; };
    379365
    380 private:
     366protected:
    381367    bool rw;
    382368    MythComboBox *widget;
    383 
    384 protected:
    385369    int step;
    386370};
    387371
    388372class MPUBLIC ListBoxSetting: public SelectSetting {
    389373    Q_OBJECT
     374
    390375public:
    391     ListBoxSetting(Storage *_storage) :
    392         SelectSetting(_storage), widget(NULL),
    393         selectionMode(MythListBox::Single) { }
     376    ListBoxSetting(Storage *_storage, MythListBox::SelectionMode mode = MythListBox::Single);
    394377
     378public:
    395379    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    396380                                  const char* widgetName = 0);
    397381
    398382    void setFocus() { if (widget) widget->setFocus(); }
    399     void setSelectionMode(MythListBox::SelectionMode mode);
    400     void setCurrentItem(int i) { if (widget) widget->setCurrentItem(i); }
    401     void setCurrentItem(const QString& str)  { if (widget) widget->setCurrentItem(str); }
    402383
    403384    virtual void setEnabled(bool b);
    404385
     
    414395                      bool           select = false);
    415396
    416397protected slots:
    417     void setValueByIndex(int index);
     398    virtual void selectionAdded(const QString& label, const QString&, bool state);
     399    virtual void selectionChanged();
     400    virtual void updateSelection();
     401
    418402    void widgetDestroyed() { widget=NULL; };
     403
    419404protected:
    420     MythListBox* widget;
    421405    MythListBox::SelectionMode selectionMode;
     406    MythListBox* widget;
    422407};
    423408
    424409class MPUBLIC RadioSetting : public SelectSetting
     
    429414                                  const char* widgetName = 0);
    430415};
    431416
    432 class MPUBLIC ImageSelectSetting: public SelectSetting {
     417class MPUBLIC ImageSelectSetting: public ComboBoxSetting {
    433418    Q_OBJECT
     419
     420protected:
     421    ImageSelectSetting(Storage *_storage);
     422
    434423public:
    435     ImageSelectSetting(Storage *_storage) : SelectSetting(_storage) { }
    436     virtual ~ImageSelectSetting();
    437424    virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    438425                                  const char* widgetName = 0);
    439426
    440     virtual void addImageSelection(const QString& label,
    441                                    QImage* image,
    442                                    QString value=QString::null,
    443                                    bool select=false);
     427    virtual void addSelection(const QString& label,
     428                              QImage* image,
     429                              QString value = QString::null,
     430                              bool select = false);
     431private:
     432    virtual void addSelection(const QString&, QString, bool) {}
     433
    444434protected slots:
     435    virtual void selectionChanged();
    445436    void imageSet(int);
    446437
    447438protected:
    448     vector<QImage*> images;
    449     QLabel *imagelabel;
     439    QPtrList<QImage> images;
     440    QLabel* imagelabel;
    450441    float m_hmult, m_wmult;
    451442};
    452443
     
    738729        LineEditSetting(this, rw), HostDBStorage(this, name) { }
    739730};
    740731
     732class MPUBLIC HostListBox: public ListBoxSetting, public HostDBStorage
     733{
     734  public:
     735    HostListBox(const QString &name, MythListBox::SelectionMode mode = MythListBox::Single) :
     736        ListBoxSetting(this, mode), HostDBStorage(this, name) { }
     737};
     738
    741739class MPUBLIC HostImageSelect : public ImageSelectSetting, public HostDBStorage
    742740{
    743741  public:
  • 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

     
    541541                                "shows to delete first.  LiveTV recordings "
    542542                                "will always expire before normal "
    543543                                "recordings."));
    544     bc->setValue(1);
     544    bc->setCurrent(1);
    545545    return bc;
    546546}
    547547
     
    700700    for (int i = 0; i < 4; i++)
    701701        gc->addSelection(str[i], QString::number(i));
    702702
    703     gc->setValue(1);
     703    gc->setCurrent(1);
    704704    gc->setHelpText(help);
    705705
    706706    return gc;
     
    14461446        gc->addSelection(QString::number(i), QString::number(i));
    14471447    gc->addSelection(QObject::tr("All"), QString::number(-1));
    14481448    gc->setLabel(QObject::tr("Xinerama screen"));
    1449     gc->setValue(0);
     1449    gc->setCurrent(0);
    14501450    gc->setHelpText(QObject::tr("Run on the specified screen or "
    14511451                    "spanning all screens."));
    14521452    return gc;
     
    16251625        DisplayResScreen dscr(w, h, -1, -1, -1.0, 0);
    16261626        short rate = -1;
    16271627        int i = DisplayResScreen::FindBestMatch(scr, dscr, rate);
    1628         gc->setValue((i >= 0) ? i : scr.size()-1);
     1628        gc->setCurrent((i >= 0) ? i : scr.size()-1);
    16291629    }
    16301630
    16311631    return gc;
     
    19241924            continue;
    19251925        }
    19261926
    1927         addImageSelection(theme->fileName(), previewImage);
     1927        addSelection(theme->fileName(), previewImage);
    19281928    }
    19291929
    1930     setValue("G.A.N.T.");
     1930    setCurrent(0);
    19311931}
    19321932
    19331933class StyleSetting: public HostComboBox {
     
    19681968    gc->addSelection(QObject::tr("callsign"), "<sign>");
    19691969    gc->addSelection(QObject::tr("name"), "<name>");
    19701970    gc->setHelpText(QObject::tr("Your preferred channel format."));
    1971     gc->setValue(1);
     1971    gc->setCurrent(1);
    19721972    return gc;
    19731973}
    19741974
     
    19821982    gc->addSelection(QObject::tr("callsign"), "<sign>");
    19831983    gc->addSelection(QObject::tr("name"), "<name>");
    19841984    gc->setHelpText(QObject::tr("Your preferred long channel format."));
    1985     gc->setValue(2);
     1985    gc->setCurrent(2);
    19861986    return gc;
    19871987}
    19881988
  • programs/mythfrontend/main.cpp

     
    506506        themename = themelist[rand() % themelist.size()];
    507507
    508508    ThemeSelector Theme;
    509     Theme.setValue(themename);
     509    Theme.setCurrentValue(themename);
    510510    Theme.save();
    511511
    512512    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 "