Ticket #2909: 2909-v1.patch

File 2909-v1.patch, 21.5 KB (added by danielk, 14 years ago)

Possible fix

  • libs/libmythtv/scanwizardhelpers.h

     
    5050class STPane;
    5151class DVBUtilsImportPane;
    5252
    53 /// Max range of the ScanProgressPopup progress bar
    54 #define PROGRESS_MAX  1000
    55 
    5653class ScanSignalMeter: public ProgressSetting, public TransientStorage
    5754{
    5855  public:
     
    6360{
    6461    Q_OBJECT
    6562
    66   protected:
     63    friend class QObject; // quiet OSX gcc warning
     64
     65  public:
     66    ScanProgressPopup(bool lock, bool strength, bool snr);
     67    virtual void deleteLater(void);
     68
     69    virtual int exec(void);
     70
     71    void SetStatusSignalToNoise(int value);
     72    void SetStatusSignalStrength(int value);
     73    void SetStatusLock(int value);
     74    void SetScanProgress(double value)
     75        { progressBar->setValue((uint)(value * 65535));}
     76
     77    void SetStatusText(const QString &value);
     78    void SetStatusTitleText(const QString &value);
     79
     80  private slots:
     81    void Done(void);
     82
     83  private:
     84    ~ScanProgressPopup();
     85
     86    bool               done;
     87    QWaitCondition     wait;
     88
    6789    ScanSignalMeter   *ss;
    6890    ScanSignalMeter   *sn;
    6991    ScanSignalMeter   *progressBar;
    7092
    7193    TransLabelSetting *sl;
    7294    TransLabelSetting *sta;
    73 
    74   public:
    75     ScanProgressPopup(ScanWizardScanner *parent, bool signalmonitors = true);
    76     ~ScanProgressPopup();
    77     void exec(ScanWizardScanner *parent);
    78     void signalToNoise(int value);
    79     void signalStrength(int value);
    80     void dvbLock(int value);
    81     void status(const QString& value);
    82 
    83     void progress(int value) { progressBar->setValue(value);}
    84     void incrementProgress() { progress(progressBar->getValue().toInt()+1);}
    8595};
    8696
    8797class ScannerEvent : public QCustomEvent
     
    91101  public:
    92102    enum TYPE
    93103    {
    94         ServiceScanComplete,
    95         Update,
    96         TableLoaded,
    97         ServicePct,
    98         DVBSNR,
    99         DVBSignalStrength,
    100         DVBLock,
     104        ScanComplete,
     105        ScanShutdown,
     106        AppendTextToLog,
     107        SetStatusText,
     108        SetStatusTitleText,
     109        SetPercentComplete,
     110        SetStatusSignalToNoise,
     111        SetStatusSignalStrength,
     112        SetStatusSignalLock,
    101113    };
    102114
    103115    ScannerEvent(TYPE t) : QCustomEvent(t + QEvent::User) { ; }
  • libs/libmythtv/scanwizardscanner.cpp

     
    9595
    9696ScanWizardScanner::ScanWizardScanner(void)
    9797    : VerticalConfigurationGroup(false, true, false, false),
    98       log(new LogList()),
    99       channel(NULL),                popupProgress(NULL),
    100       scanner(NULL),                analogScanner(NULL),
    101       freeboxScanner(NULL),
    102       frequency(0),                 modulation("8vsb")
     98      log(new LogList()), channel(NULL), popupProgress(NULL),
     99      scanner(NULL), freeboxScanner(NULL), nVideoSource(0)
    103100{
    104101    init_statics();
    105102
     
    107104    addChild(log);
    108105}
    109106
     107ScanWizardScanner::~ScanWizardScanner()
     108{
     109    Teardown();
     110
     111    QMutexLocker locker(&popupLock);
     112    StopPopup();
     113}
     114
    110115void ScanWizardScanner::Teardown()
    111116{
    112117    // Join the thread and close the channel
     
    130135        freeboxScanner = NULL;
    131136    }
    132137#endif
    133 
    134     if (popupProgress)
    135     {
    136         delete popupProgress; // TODO we should use deleteLater...
    137         popupProgress = NULL;
    138     }
    139138}
    140139
    141140void ScanWizardScanner::customEvent(QCustomEvent *e)
    142141{
    143142    ScannerEvent *scanEvent = (ScannerEvent*) e;
    144     if ((popupProgress == NULL) &&
    145         (scanEvent->eventType() != ScannerEvent::Update))
     143
     144    switch (scanEvent->eventType())
    146145    {
    147         return;
     146        case ScannerEvent::ScanComplete:
     147        {
     148            QMutexLocker locker(&popupLock);
     149            if (popupProgress)
     150            {
     151                popupProgress->SetScanProgress(1.0);
     152                popupProgress->accept();
     153            }
     154        }
     155        break;
     156
     157        case ScannerEvent::ScanShutdown:
     158        {
     159            Teardown();
     160        }
     161        break;
     162
     163        case ScannerEvent::AppendTextToLog:
     164        {
     165            log->updateText(scanEvent->strValue());
     166        }
     167        break;
     168
     169        default:
     170            break;
    148171    }
    149172
     173    QMutexLocker locker(&popupLock);
     174    if (!popupProgress)
     175        return;
     176
    150177    switch (scanEvent->eventType())
    151178    {
    152         case ScannerEvent::ServiceScanComplete:
    153             popupProgress->progress(PROGRESS_MAX);
    154             Teardown();
     179        case ScannerEvent::SetStatusText:
     180            popupProgress->SetStatusText(scanEvent->strValue());
    155181            break;
    156         case ScannerEvent::Update:
    157             log->updateText(scanEvent->strValue());
     182        case ScannerEvent::SetStatusTitleText:
     183            popupProgress->SetStatusTitleText(scanEvent->strValue());
    158184            break;
    159         case ScannerEvent::TableLoaded:
    160             popupProgress->incrementProgress();
     185        case ScannerEvent::SetPercentComplete:
     186            popupProgress->SetScanProgress(scanEvent->intValue() * 0.01);
    161187            break;
    162         case ScannerEvent::ServicePct:
    163             popupProgress->progress(
    164                 (scanEvent->intValue() * PROGRESS_MAX) / 100);
     188        case ScannerEvent::SetStatusSignalLock:
     189            popupProgress->SetStatusLock(scanEvent->intValue());
    165190            break;
    166         case ScannerEvent::DVBLock:
    167             popupProgress->dvbLock(scanEvent->intValue());
     191        case ScannerEvent::SetStatusSignalToNoise:
     192            popupProgress->SetStatusSignalToNoise(scanEvent->intValue());
    168193            break;
    169         case ScannerEvent::DVBSNR:
    170             popupProgress->signalToNoise(scanEvent->intValue());
     194        case ScannerEvent::SetStatusSignalStrength:
     195            popupProgress->SetStatusSignalStrength(scanEvent->intValue());
    171196            break;
    172         case ScannerEvent::DVBSignalStrength:
    173             popupProgress->signalStrength(scanEvent->intValue());
     197        default:
    174198            break;
    175199    }
    176200}
    177201
    178202void ScanWizardScanner::scanComplete()
    179203{
    180     ScannerEvent::TYPE se = ScannerEvent::ServiceScanComplete;
     204    ScannerEvent::TYPE se = ScannerEvent::ScanComplete;
    181205    QApplication::postEvent(this, new ScannerEvent(se));
    182206}
    183207
    184208void ScanWizardScanner::transportScanComplete()
    185209{
    186210    scanner->ScanServicesSourceID(nVideoSource);
    187     ScannerEvent* e = new ScannerEvent(ScannerEvent::ServicePct);
     211    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetPercentComplete);
    188212    e->intValue(TRANSPORT_PCT);
    189213    QApplication::postEvent(this, e);
    190214}
    191215
    192216void ScanWizardScanner::serviceScanPctComplete(int pct)
    193217{
    194     ScannerEvent* e = new ScannerEvent(ScannerEvent::ServicePct);
     218    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetPercentComplete);
    195219    int tmp = TRANSPORT_PCT + ((100 - TRANSPORT_PCT) * pct)/100;
    196220    e->intValue(tmp);
    197221    QApplication::postEvent(this, e);
     
    201225{
    202226    if (str.isEmpty())
    203227        return;
    204     ScannerEvent* e = new ScannerEvent(ScannerEvent::Update);
     228    ScannerEvent* e = new ScannerEvent(ScannerEvent::AppendTextToLog);
    205229    e->strValue(str);
    206230    QApplication::postEvent(this, e);
    207231}
    208232
    209233void ScanWizardScanner::updateStatusText(const QString &str)
    210234{
    211     if (str.isEmpty())
    212         return;
    213     if (popupProgress)
    214         popupProgress->status(tr("Scanning")+" "+str);
     235    QString msg = tr("Scanning");
     236    if (!str.isEmpty())
     237        msg = QString("%1 %2").arg(msg).arg(str);
     238
     239    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetStatusText);
     240    e->strValue(msg);
     241    QApplication::postEvent(this, e);
    215242}
    216243
    217244void ScanWizardScanner::dvbLock(const SignalMonitorValue &val)
     
    231258
    232259void ScanWizardScanner::dvbLock(int locked)
    233260{
    234     ScannerEvent* e = new ScannerEvent(ScannerEvent::DVBLock);
     261    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetStatusSignalLock);
    235262    e->intValue(locked);
    236263    QApplication::postEvent(this, e);
    237264}
    238265
    239266void ScanWizardScanner::dvbSNR(int i)
    240267{
    241     ScannerEvent* e = new ScannerEvent(ScannerEvent::DVBSNR);
     268    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetStatusSignalToNoise);
    242269    e->intValue(i);
    243270    QApplication::postEvent(this, e);
    244271}
    245272
    246273void ScanWizardScanner::dvbSignalStrength(int i)
    247274{
    248     ScannerEvent* e = new ScannerEvent(ScannerEvent::DVBSignalStrength);
     275    ScannerEvent* e = new ScannerEvent(ScannerEvent::SetStatusSignalStrength);
    249276    e->intValue(i);
    250277    QApplication::postEvent(this, e);
    251278}
     
    283310    }
    284311
    285312    scanner->StartScanner();
     313    updateStatusText("");
    286314
    287     popupProgress->status(tr("Scanning"));
    288     popupProgress->progress( (TUNED_PCT * PROGRESS_MAX) / 100 );
    289 
    290315    bool ok = false;
    291316
    292317    if (do_delete_channels && (ScanTypeSetting::TransportScan == scantype))
     
    354379        ok = scanner->ScanServicesSourceID(sourceid);
    355380        if (ok)
    356381        {
    357             post_event(this, ScannerEvent::ServicePct,
    358                        TRANSPORT_PCT);
     382            serviceScanPctComplete(0);
    359383        }
    360384        else
    361385        {
     
    390414        }
    391415        if (ok)
    392416        {
    393             post_event(this, ScannerEvent::ServicePct,
    394                        TRANSPORT_PCT);
     417            serviceScanPctComplete(0);
    395418        }
    396419        else
    397420        {
     
    570593    }
    571594#endif // USING_DVB
    572595
    573     popupProgress = new ScanProgressPopup(this);
    574     popupProgress->progress(0);
    575     popupProgress->exec(this);
     596    MonitorProgress(monitor, monitor, dvbm);
    576597}
    577598
    578599void ScanWizardScanner::ImportM3U(uint cardid, const QString &inputname,
     
    581602#ifdef USING_IPTV
    582603    //Create an analog scan object
    583604    freeboxScanner = new IPTVChannelFetcher(cardid, inputname, sourceid);
    584     popupProgress  = new ScanProgressPopup(this, false);
    585605
    586606    connect(freeboxScanner, SIGNAL(ServiceScanComplete(void)),
    587607            this,           SLOT(  scanComplete(void)));
     
    590610    connect(freeboxScanner, SIGNAL(ServiceScanPercentComplete(int)),
    591611            this,           SLOT(  serviceScanPctComplete(int)));
    592612
    593     popupProgress->progress(0);
    594     popupProgress->exec(this);
     613    MonitorProgress(false, false, false);
    595614
    596615    if (!freeboxScanner->Scan())
    597616    {
    598617        MythPopupBox::showOkPopup(gContext->GetMainWindow(),
    599618                                  tr("ScanWizard"),
    600619                                  tr("Error starting scan"));
    601         Teardown();
    602620    }
    603621#endif // USING_IPTV
    604622}
     623
     624void *spawn_popup(void *tmp)
     625{
     626    ((ScanWizardScanner*)(tmp))->RunPopup();
     627    return NULL;
     628}
     629
     630void ScanWizardScanner::RunPopup(void)
     631{
     632    int ret = popupProgress->exec();
     633
     634    popupLock.lock();
     635    popupProgress->deleteLater();
     636    popupProgress = NULL;
     637    popupLock.unlock();
     638
     639    post_event(this, ScannerEvent::ScanShutdown, ret);
     640}
     641
     642void ScanWizardScanner::StopPopup(void)
     643{
     644    if (popupProgress)
     645    {
     646        popupProgress->reject();
     647        popupLock.unlock();
     648        pthread_join(popup_thread, NULL);
     649        popupLock.lock();
     650    }
     651}
     652
     653void ScanWizardScanner::MonitorProgress(bool lock, bool strength, bool snr)
     654{
     655    QMutexLocker locker(&popupLock);
     656    StopPopup();
     657    popupProgress = new ScanProgressPopup(lock, strength, snr);
     658    if (pthread_create(&popup_thread, NULL, spawn_popup, this) != 0)
     659    {
     660        popupProgress->deleteLater();
     661        popupProgress = NULL;
     662    }
     663}
  • libs/libmythtv/scanwizardscanner.h

     
    5858{
    5959    Q_OBJECT
    6060
     61    friend void *spawn_popup(void*);
     62
    6163  public:
    6264    ScanWizardScanner(void);
    6365    virtual void deleteLater(void)
     
    9698    void serviceScanPctComplete(int pct);
    9799
    98100  protected:
    99     ~ScanWizardScanner() { Teardown(); }
     101    ~ScanWizardScanner();
    100102    void Teardown(void);
    101103
    102104    void PreScanCommon(int scantype, uint parent_cardid, uint child_cardid,
     
    108110    void dvbSignalStrength(int);
    109111    void customEvent(QCustomEvent *e);
    110112
     113    void MonitorProgress(bool lock, bool strength, bool snr);
     114    void RunPopup(void);
     115    void StopPopup(void);
     116
    111117  public:
    112118    static QString kTitle;
    113119
    114120  private:
    115121    LogList           *log;
    116122    ChannelBase       *channel;
    117     ScanProgressPopup *popupProgress;
    118123
    119     SIScan            *scanner;
    120     AnalogScan        *analogScanner;
     124    ScanProgressPopup  *popupProgress;
     125    pthread_t           popup_thread;
     126    mutable QMutex      popupLock;
     127
     128    SIScan             *scanner;
    121129    IPTVChannelFetcher *freeboxScanner;
    122130
    123131    uint               nVideoSource;
    124132
    125     // tranport info
    126     uint               frequency;
    127     QString            modulation;
    128 
    129133    // dvb-utils imported channels
    130134    DTVChannelList channels;
    131135};
  • libs/libmythtv/scanwizardhelpers.cpp

     
    7878    return QString("(%1)").arg(cardTypes);
    7979}
    8080
    81 ScanProgressPopup::ScanProgressPopup(
    82     ScanWizardScanner *parent, bool signalmonitors) :
    83     ConfigurationPopupDialog()
     81ScanProgressPopup::ScanProgressPopup(bool lock, bool strength, bool snr) :
     82    ConfigurationPopupDialog(),
     83    done(false), ss(NULL), sn(NULL), progressBar(NULL), sl(NULL), sta(NULL)
    8484{
    8585    setLabel(tr("Scan Progress"));
    8686
    87     if (signalmonitors)
     87    addChild(sta = new TransLabelSetting());
     88    sta->setLabel(tr("Status"));
     89    sta->setValue(tr("Tuning"));
     90
     91    if (lock)
    8892    {
    89         VerticalConfigurationGroup *box = new VerticalConfigurationGroup();
    90         box->addChild(sta = new TransLabelSetting());
    91         box->addChild(sl = new TransLabelSetting());
    92         sta->setLabel(tr("Status"));
    93         sta->setValue(tr("Tuning"));
     93        addChild(sl = new TransLabelSetting());
    9494        sl->setValue("                                  "
    9595                     "                                  ");
    96         box->setUseFrame(false);
    97         addChild(box);
    9896    }
    9997
    100     addChild(progressBar = new ScanSignalMeter(PROGRESS_MAX));
    101     progressBar->setValue(0);
    102     progressBar->setLabel(tr("Scan"));
     98    if (strength)
     99    {
     100        addChild(ss = new ScanSignalMeter(65535));
     101        ss->setLabel(tr("Signal Strength"));
     102    }
    103103
    104     if (signalmonitors)
     104    if (snr)
    105105    {
    106         addChild(ss = new ScanSignalMeter(65535));
    107106        addChild(sn = new ScanSignalMeter(65535));
    108         ss->setLabel(tr("Signal Strength"));
    109107        sn->setLabel(tr("Signal/Noise"));
    110108    }
    111109
     110    addChild(progressBar = new ScanSignalMeter(65535));
     111    progressBar->setValue(0);
     112    progressBar->setLabel(tr("Scan"));
     113
     114
    112115    TransButtonSetting *cancel = new TransButtonSetting();
    113116    cancel->setLabel(tr("Cancel"));
    114117    addChild(cancel);
    115118
    116119    connect(cancel, SIGNAL(pressed(void)),
    117             parent, SLOT(  CancelScan(void)));
     120            this,   SLOT(  reject(void)));
    118121
    119122    //Seem to need to do this as the constructor doesn't seem enough
    120123    setUseLabel(false);
     
    126129    VERBOSE(VB_IMPORTANT, "~ScanProgressPopup()");
    127130}
    128131
    129 void ScanProgressPopup::signalToNoise(int value)
     132void ScanProgressPopup::SetStatusSignalToNoise(int value)
    130133{
    131     sn->setValue(value);
     134    if (sn)
     135        sn->setValue(value);
    132136}
    133137
    134 void ScanProgressPopup::signalStrength(int value)
     138void ScanProgressPopup::SetStatusSignalStrength(int value)
    135139{
    136     ss->setValue(value);
     140    if (ss)
     141        ss->setValue(value);
    137142}
    138143
    139 void ScanProgressPopup::dvbLock(int value)
     144void ScanProgressPopup::SetStatusLock(int value)
    140145{
    141     sl->setValue((value) ? tr("Locked") : tr("No Lock"));
     146    if (sl)
     147        sl->setValue((value) ? tr("Locked") : tr("No Lock"));
    142148}
    143149
    144 void ScanProgressPopup::status(const QString& value)
     150void ScanProgressPopup::SetStatusText(const QString &value)
    145151{
    146     sta->setValue(value);
     152    if (sta)
     153        sta->setValue(value);
    147154}
    148155
    149 void ScanProgressPopup::exec(ScanWizardScanner *parent)
     156void ScanProgressPopup::SetStatusTitleText(const QString &value)
    150157{
    151     dialog = (ConfigPopupDialogWidget*)
    152         dialogWidget(gContext->GetMainWindow(), "ScanProgressPopup");
    153     connect(dialog, SIGNAL(popupDone(void)),
    154             parent, SLOT(  CancelScan(void)));
    155     dialog->ShowPopup(this);
     158    QString msg = tr("Scan Progress") + QString(" %1").arg(value);
     159    setLabel(msg);
    156160}
    157161
     162void ScanProgressPopup::deleteLater(void)
     163{
     164    disconnect();
     165    if (dialog)
     166    {
     167        dialog->deleteLater();
     168        dialog = NULL;
     169    }
     170    ConfigurationPopupDialog::deleteLater();
     171}
     172
     173int ScanProgressPopup::exec(void)
     174{
     175    if (!dialog)
     176    {
     177        dialog = (ConfigPopupDialogWidget*)
     178            dialogWidget(gContext->GetMainWindow(),
     179                         "ConfigurationPopupDialog");
     180    }
     181    dialog->setResult(0);
     182
     183    done = false;
     184    dialog->ShowPopup(this, SLOT(Done(void)));
     185
     186    while (!done)
     187        wait.wait(100);
     188
     189    return dialog->result();
     190}
     191
     192void ScanProgressPopup::Done(void)
     193{
     194    done = true;
     195    wait.wakeAll();
     196}
     197
    158198void MultiplexSetting::load(void)
    159199{
    160200    clearSelections();
  • libs/libmyth/settings.cpp

     
    15471547    }
    15481548}
    15491549
     1550void ConfigurationPopupDialog::deleteLater(void)
     1551{
     1552    disconnect();
     1553    if (dialog)
     1554    {
     1555        dialog->disconnect();
     1556        dialog->deleteLater();
     1557        dialog = NULL;
     1558        label = NULL;
     1559    }
     1560    VerticalConfigurationGroup::deleteLater();
     1561}
     1562
    15501563MythDialog* ConfigurationPopupDialog::dialogWidget(MythMainWindow* parent,
    15511564                                                   const char* widgetName)
    15521565{
     
    15591572        box->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
    15601573                                       QSizePolicy::Maximum));
    15611574
    1562         QLabel* label = new QLabel(box);
     1575        label = new QLabel(box);
    15631576        label->setText(getLabel());
    15641577        label->setBackgroundOrigin(QWidget::WindowOrigin);
    15651578        label->setAlignment(Qt::AlignHCenter);
     
    15761589    return dialog;
    15771590}
    15781591
     1592void ConfigurationPopupDialog::setLabel(QString str)
     1593{
     1594    VerticalConfigurationGroup::setLabel(str);
     1595    if (label)
     1596        label->setText(str);
     1597}
     1598
    15791599int ConfigurationPopupDialog::exec(bool saveOnAccept)
    15801600{
    15811601    storage->load();
    1582 
    15831602    dialog = (ConfigPopupDialogWidget*)
    15841603        dialogWidget(gContext->GetMainWindow(), "ConfigurationPopupDialog");
    15851604    dialog->ShowPopup(this);
     
    15881607
    15891608    if ((QDialog::Accepted == ret) && saveOnAccept)
    15901609        storage->save();
    1591 
    15921610    return ret;
    15931611}
    15941612
  • libs/libmyth/mythdialogs.cpp

     
    447447        MythDialog::keyPressEvent(e);
    448448}
    449449
     450void MythPopupBox::accept(void)
     451{
     452    MythDialog::done(Accepted);
     453    emit popupDone();
     454}
     455
     456void MythPopupBox::reject(void)
     457{
     458    MythDialog::done(Rejected);
     459    emit popupDone();
     460}
     461
    450462int MythPopupBox::ExecPopup(QObject *target, const char *slot)
    451463{
    452464    if (!target)
  • libs/libmyth/mythcontext.h

     
    201201
    202202/// Update this whenever the plug-in API changes.
    203203/// Including changes in the libmythtv class methods used by plug-ins.
    204 #define MYTH_BINARY_VERSION "0.20.20070111-1"
     204#define MYTH_BINARY_VERSION "0.20.20070112-1"
    205205
    206206/** \brief Increment this whenever the MythTV network protocol changes.
    207207 *
  • libs/libmyth/settings.h

     
    10751075
    10761076  public:
    10771077    ConfigurationPopupDialog() :
    1078         VerticalConfigurationGroup(), dialog(NULL) { }
     1078        VerticalConfigurationGroup(), dialog(NULL), label(NULL) { }
    10791079
     1080    virtual void deleteLater(void);
     1081
    10801082    virtual MythDialog *dialogWidget(
    10811083        MythMainWindow *parent, const char* widgetName);
    10821084
    10831085    int exec(bool saveOnAccept = true);
    10841086
     1087    virtual void setLabel(QString str);
     1088
    10851089  public slots:
    10861090    void accept(void) { if (dialog) dialog->accept(); }
    10871091    void reject(void) { if (dialog) dialog->reject(); }
     
    10911095
    10921096  protected:
    10931097    /// You need to call deleteLater to delete QObject
    1094     virtual ~ConfigurationPopupDialog() { dialog->deleteLater(); }
     1098    virtual ~ConfigurationPopupDialog() { }
    10951099
    10961100  protected:
    1097     ConfigPopupDialogWidget* dialog;
     1101    ConfigPopupDialogWidget *dialog;
     1102    QLabel                  *label;
    10981103};
    10991104
    11001105///////////////////////////////////////////////////////////////////////////////
  • libs/libmyth/mythdialogs.h

     
    7070   
    7171    virtual bool onMediaEvent(MythMediaDevice * mediadevice);
    7272   
     73    void setResult(int r) { rescode = r; }
     74
    7375  signals:
    7476    void menuButtonPressed();
    7577
     
    8284    virtual void reject();
    8385
    8486  protected:
    85     void setResult(int r) { rescode = r; }
    8687    void keyPressEvent(QKeyEvent *e);
    8788
    8889    float wmult, hmult;
     
    139140
    140141    static bool showGetTextPopup(MythMainWindow *parent, QString title,
    141142                                 QString message, QString& text);
     143
     144    virtual void accept(void);
     145    virtual void reject(void);
     146
    142147  signals:
    143148    void popupDone();
    144149