Kwave::MP3EncoderDialog Class Reference

#include <MP3EncoderDialog.h>

Inheritance diagram for Kwave::MP3EncoderDialog:

Collaboration diagram for Kwave::MP3EncoderDialog:

Public Slots
void	load ()
void	save ()

Public Member Functions
	MP3EncoderDialog (QWidget *parent)
virtual	~MP3EncoderDialog ()

Private Slots
void	selectProgram (int index)
void	switchToUserDefined ()
void	buttonClicked (QAbstractButton *button)
void	autoDetect ()
void	locatePath ()
void	browseFile ()
void	testSettings ()
void	encoderHelp ()
void	invokeHelp ()

Private Member Functions
QString	callWithParam (const QString &path, const QString &param)
QString	encoderVersion (const QString &path, const QString &param)
QString	searchPath (const QString &program)
void	updateEncoderInfo ()

Private Attributes
Kwave::MP3EncoderSettings	m_settings

Detailed Description

Definition at line 37 of file MP3EncoderDialog.h.

Constructor & Destructor Documentation

MP3EncoderDialog()

Kwave::MP3EncoderDialog::MP3EncoderDialog ( QWidget *  parent )

explicit

Constructor

Definition at line 254 of file MP3EncoderDialog.cpp.

References _, autoDetect(), browseFile(), buttonClicked(), Kwave::connect(), CONNECT, ELEMENTS_OF, encoderHelp(), encoderVersion(), invokeHelp(), Kwave::MP3EncoderSettings::load(), load(), locatePath(), Kwave::MP3EncoderSettings::m_info, Kwave::MP3EncoderSettings::m_name, m_settings, Kwave::MP3EncoderSettings::m_version, name, PRESET_NAME_USER_DEFINED, searchPath(), selectProgram(), and testSettings().

    :QDialog(parent), Ui::MP3EncoderDialogBase(),
     m_settings(g_predefined_settings[0])
{
    setupUi(this);
    setModal(true);

    // set up the combo box with all presets
    cbProgram->clear();
    for (unsigned int i = 0; i < ELEMENTS_OF(g_predefined_settings); i++) {
        QString name    = g_predefined_settings[i].m_name;
        QString path    = searchPath(g_predefined_settings[i].m_path);
        QString param   = g_predefined_settings[i].m_info.m_version;
        QString version = encoderVersion(path, param);
        if (version.length() >= name.length())
            cbProgram->addItem(version);
        else
            cbProgram->addItem(name);
    }
    cbProgram->addItem(PRESET_NAME_USER_DEFINED);

    // load the saved settings from the config file
    m_settings.load();
    load();

    // connect the combo box of the program selection
    connect(cbProgram, SIGNAL(activated(int)),
            this, SLOT(selectProgram(int)));

    // standard actions, reset / reset to defaults etc...
    connect(buttonBox, SIGNAL(clicked(QAbstractButton*)),
            this, SLOT(buttonClicked(QAbstractButton*)));
    connect(buttonBox_Help, SIGNAL(helpRequested()),
            this, SLOT(invokeHelp()));

    // auto-detect button
    connect(btDetect, SIGNAL(clicked()),      this, SLOT(autoDetect()));

    // locate file path button
    connect(btLocate, SIGNAL(clicked()),      this, SLOT(locatePath()));

    // search for program (file browser)
    connect(btSearch, SIGNAL(clicked()),      this, SLOT(browseFile()));

    // test setup
    connect(btTest, SIGNAL(clicked()),        this, SLOT(testSettings()));

    // builtin help of the encoder
    connect(btEncoderHelp, SIGNAL(clicked()), this, SLOT(encoderHelp()));

    // whenever a setting has been manally edited, check if that is a
    // user defined setting or a predefined set of parameters
    CONNECT(edPath);

    CONNECT(edRawFormat);
    CONNECT(edByteOrder);
    CONNECT(edSign);

    CONNECT(edSampleRate);
    CONNECT(edBitsPerSample);
    CONNECT(edMono);
    CONNECT(edStereo);

    CONNECT(edBitrateAvg);
    CONNECT(edBitrateMin);
    CONNECT(edBitrateMax);

    CONNECT(edEmphasisNone);
    CONNECT(edEmphasis5015ms);
    CONNECT(edEmphasisCCIT_J17);

    CONNECT(edNoiseShaping);
    CONNECT(edCompatibility);

    CONNECT(edCopyright);
    CONNECT(edOriginal);
    CONNECT(edProtect);
    CONNECT(edPrepend);
    CONNECT(edAppend);

    CONNECT(edEncoderHelp);
    CONNECT(edVersionInfo);

    // set up all tool tips which contain a % character right here instead
    // of the ui file, as they they would trigger errors during
    // extraction (I18N_ARGUMENT_MISSING)
    edSampleRate->setToolTip(i18n(
        "sample rate in Hz (use %1 as placeholder)\n"
        "or kHz (use %2 as placeholder)",
        _("%1"), _("[%khz]")));
    edBitsPerSample->setToolTip(i18n(
        "bits per sample,\n"
        "use %1 as placeholder",
        _("%1")));
    edBitrateMin->setToolTip(i18n(
        "parameter for minimum bitrate in bits/sec\n"
        "(use %1 as placeholder)",
        _("%1")));
    edBitrateMax->setToolTip(i18n(
        "parameter for maximum bitrate in bits/sec\n"
        "(use %1 as placeholder)",
        _("%1")));
    edBitrateAvg->setToolTip(i18n(
        "parameter for average bitrate in bits/sec\n"
        "(use %1 as placeholder)",
        _("%1")));

    // set the focus onto the "OK" button
    buttonBox->button(QDialogButtonBox::Ok)->setFocus();
}

Here is the call graph for this function:

~MP3EncoderDialog()

Kwave::MP3EncoderDialog::~MP3EncoderDialog ( )

virtual

Destructor

Definition at line 366 of file MP3EncoderDialog.cpp.

{
}

Member Function Documentation

autoDetect

void Kwave::MP3EncoderDialog::autoDetect ( )

privateslot

auto-detect settings

Definition at line 562 of file MP3EncoderDialog.cpp.

References ELEMENTS_OF, locatePath(), searchPath(), and selectProgram().

Referenced by MP3EncoderDialog().

{
    for (unsigned i = 0; i < ELEMENTS_OF(g_predefined_settings); ++i) {
        QFile f(searchPath(g_predefined_settings[i].m_path));
        if (f.exists()) {
            // found it :)
            cbProgram->setCurrentIndex(i);
            selectProgram(i);
            locatePath();
            return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

browseFile

void Kwave::MP3EncoderDialog::browseFile ( )

privateslot

search for the program, file browser

Definition at line 588 of file MP3EncoderDialog.cpp.

References _, Kwave::FileDialog::OpenFile, and Kwave::FileDialog::setDirectory().

Referenced by MP3EncoderDialog().

{
    QString mask = _("*");
#ifdef EXECUTABLE_SUFFIX
    mask += QString(EXECUTABLE_SUFFIX);
#endif
    QPointer<Kwave::FileDialog> dlg = new(std::nothrow)
        Kwave::FileDialog(
            _("kfiledialog:///kwave_mp3_encoder"),
            Kwave::FileDialog::OpenFile,
            _(""), this,
            QUrl::fromLocalFile(_("file:/") + edPath->text().simplified()),
            mask
        );
    if (!dlg) return;
    dlg->setWindowTitle(i18n("Select MP3 Encoder"));
    dlg->setDirectory(_("/usr/bin/"));
    if (dlg->exec() == QDialog::Accepted)
        edPath->setText(dlg->selectedUrl().toLocalFile());
    delete dlg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buttonClicked

void Kwave::MP3EncoderDialog::buttonClicked ( QAbstractButton *  button )

privateslot

evaluates a click to one of the standard buttons

Definition at line 540 of file MP3EncoderDialog.cpp.

References load(), save(), and selectProgram().

Referenced by MP3EncoderDialog().

{
    if (!button || !buttonBox) return;
    switch (buttonBox->standardButton(button)) {
        case QDialogButtonBox::Ok:
            // save settings and accept
            save();
            break;
        case QDialogButtonBox::Reset:
            // reset to last saved state
            load();
            break;
        case QDialogButtonBox::RestoreDefaults:
            // reset to default settings == entry #0 in the combo box
            selectProgram(0);
            break;
        default:
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

callWithParam()

QString Kwave::MP3EncoderDialog::callWithParam ( const QString &  path, const QString &  param  )

private

Calls the program with one parameter and returns the output of stderr/stdout (combined) as a string

Parameters

path	the path of the program to call
param	a command line parameter

Returns

string with combined stdout/stderr

Definition at line 674 of file MP3EncoderDialog.cpp.

References DBG.

Referenced by encoderHelp(), and encoderVersion().

{
    QStringList params(param);

    // set hourglass cursor
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    QProcess process;
    process.setProcessChannelMode(QProcess::MergedChannels);
    process.start(path, params);
    process.waitForStarted();
    if (process.state() != QProcess::NotRunning) process.waitForFinished();

    QString text = QString::fromLocal8Bit(process.readAllStandardOutput());
    qDebug("stdout output: %s", DBG(text));

    // remove hourglass
    QApplication::restoreOverrideCursor();

    return text;
}

Here is the caller graph for this function:

encoderHelp

void Kwave::MP3EncoderDialog::encoderHelp ( )

privateslot

show help about the encoder

Definition at line 662 of file MP3EncoderDialog.cpp.

References callWithParam().

Referenced by MP3EncoderDialog().

{
    // show complete help
    QString program = edPath->text().simplified();
    QString param   = QString(edEncoderHelp->text()).simplified();

    QString text    = callWithParam(program, param);

    KMessageBox::information(this, text);
}

Here is the call graph for this function:

Here is the caller graph for this function:

encoderVersion()

QString Kwave::MP3EncoderDialog::encoderVersion ( const QString &  path, const QString &  param  )

private

Retrieves the title/name of an encoder by calling it once

Parameters

path	the path of the encoder program
param	the command line parameter to get the version

Returns

title of the encoder

Definition at line 698 of file MP3EncoderDialog.cpp.

References callWithParam().

Referenced by MP3EncoderDialog(), and updateEncoderInfo().

{
    QString text = callWithParam(path, param);

    QStringList lines = text.split(QLatin1Char('\n'));

    // take the first non-zero line
    while (lines.count() && !lines.first().simplified().length())
        lines.removeFirst();

    return (!lines.isEmpty()) ? lines.first().simplified() : QString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

invokeHelp

void Kwave::MP3EncoderDialog::invokeHelp ( )

privateslot

show the help page the manual

Definition at line 779 of file MP3EncoderDialog.cpp.

References _.

Referenced by MP3EncoderDialog().

{
    KHelpClient::invokeHelp(_("plugin_sect_codec_mp3"));
}

Here is the caller graph for this function:

load

void Kwave::MP3EncoderDialog::load ( )

slot

load all settings from the config file

Definition at line 371 of file MP3EncoderDialog.cpp.

References ELEMENTS_OF, LOAD, Kwave::MP3EncoderSettings::m_name, Kwave::MP3EncoderSettings::m_path, m_settings, Kwave::toInt(), and updateEncoderInfo().

Referenced by buttonClicked(), MP3EncoderDialog(), and selectProgram().

{
    // cbProgram
    unsigned int i = 0;
    bool use_preset = false;
    for (i = 0; i < ELEMENTS_OF(g_predefined_settings); i++) {
        if (g_predefined_settings[i].m_name == m_settings.m_name) {
            QString path = m_settings.m_path;
            m_settings = g_predefined_settings[i];
            m_settings.m_path = path;
            cbProgram->setCurrentIndex(i);
            use_preset = true;
            break;
        }
    }
    if ((!use_preset) && (cbProgram->currentIndex() != Kwave::toInt(i))) {
        // set the combo box to "user defined" and load the rest from the config
        cbProgram->setCurrentIndex(i);
    }

    // set all other dialog content according to the loaded settings
    LOAD(m_path,                           edPath);

    LOAD(m_input.m_raw_format,             edRawFormat);
    LOAD(m_input.m_byte_order,             edByteOrder);
    LOAD(m_input.m_signed,                 edSign);

    LOAD(m_format.m_sample_rate,           edSampleRate);
    LOAD(m_format.m_bits_per_sample,       edBitsPerSample);
    LOAD(m_format.m_channels.m_mono,       edMono);
    LOAD(m_format.m_channels.m_stereo,     edStereo);

    LOAD(m_quality.m_bitrate.m_avg,        edBitrateAvg);
    LOAD(m_quality.m_bitrate.m_min,        edBitrateMin);
    LOAD(m_quality.m_bitrate.m_max,        edBitrateMax);

    LOAD(m_encoding.m_emphasis.m_none,     edEmphasisNone);
    LOAD(m_encoding.m_emphasis.m_50_15ms,  edEmphasis5015ms);
    LOAD(m_encoding.m_emphasis.m_ccit_j17, edEmphasisCCIT_J17);

    LOAD(m_encoding.m_noise_shaping,       edNoiseShaping);
    LOAD(m_encoding.m_compatibility,       edCompatibility);

    LOAD(m_flags.m_copyright,              edCopyright);
    LOAD(m_flags.m_original,               edOriginal);
    LOAD(m_flags.m_protect,                edProtect);
    LOAD(m_flags.m_prepend,                edPrepend);
    LOAD(m_flags.m_append,                 edAppend);

    LOAD(m_info.m_help,                    edEncoderHelp);
    LOAD(m_info.m_version,                 edVersionInfo);

    updateEncoderInfo();
}

Here is the call graph for this function:

Here is the caller graph for this function:

locatePath

void Kwave::MP3EncoderDialog::locatePath ( )

privateslot

locate the full path of the file

Definition at line 577 of file MP3EncoderDialog.cpp.

References searchPath(), and updateEncoderInfo().

Referenced by autoDetect(), and MP3EncoderDialog().

{
    const QString prog_orig = edPath->text().simplified();
    const QString prog      = searchPath(prog_orig);
    if (prog != prog_orig) {
        edPath->setText(prog);
        updateEncoderInfo();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

save

void Kwave::MP3EncoderDialog::save ( )

slot

store all settings to a config file

Definition at line 427 of file MP3EncoderDialog.cpp.

References _, ELEMENTS_OF, Kwave::MP3EncoderSettings::m_name, m_settings, Kwave::MP3EncoderSettings::save(), SAVE, and Kwave::toInt().

Referenced by buttonClicked(), Kwave::MP3CodecPlugin::setup(), and testSettings().

{
    // get the content of the combo box
    int index = cbProgram->currentIndex();
    if (index < Kwave::toInt(ELEMENTS_OF(g_predefined_settings))) {
        m_settings.m_name = g_predefined_settings[index].m_name;
    } else {
        m_settings.m_name = _("*");
    }

    // fetch all settings from the dialog content
    SAVE(m_path,                           edPath);

    SAVE(m_input.m_raw_format,             edRawFormat);
    SAVE(m_input.m_byte_order,             edByteOrder);
    SAVE(m_input.m_signed,                 edSign);

    SAVE(m_format.m_sample_rate,           edSampleRate);
    SAVE(m_format.m_bits_per_sample,       edBitsPerSample);
    SAVE(m_format.m_channels.m_mono,       edMono);
    SAVE(m_format.m_channels.m_stereo,     edStereo);

    SAVE(m_quality.m_bitrate.m_avg,        edBitrateAvg);
    SAVE(m_quality.m_bitrate.m_min,        edBitrateMin);
    SAVE(m_quality.m_bitrate.m_max,        edBitrateMax);

    SAVE(m_encoding.m_emphasis.m_none,     edEmphasisNone);
    SAVE(m_encoding.m_emphasis.m_50_15ms,  edEmphasis5015ms);
    SAVE(m_encoding.m_emphasis.m_ccit_j17, edEmphasisCCIT_J17);

    SAVE(m_encoding.m_noise_shaping,       edNoiseShaping);
    SAVE(m_encoding.m_compatibility,       edCompatibility);

    SAVE(m_flags.m_copyright,              edCopyright);
    SAVE(m_flags.m_original,               edOriginal);
    SAVE(m_flags.m_protect,                edProtect);
    SAVE(m_flags.m_prepend,                edPrepend);
    SAVE(m_flags.m_append,                 edAppend);

    SAVE(m_info.m_help,                    edEncoderHelp);
    SAVE(m_info.m_version,                 edVersionInfo);

    m_settings.save();
}

Here is the call graph for this function:

Here is the caller graph for this function:

searchPath()

QString Kwave::MP3EncoderDialog::searchPath ( const QString &  program )

private

Search for an encoder in the system PATH

Parameters

program

name of the program

Returns

full path where it can be found, or the value of the parameter "program" if not found

Definition at line 713 of file MP3EncoderDialog.cpp.

References _, and DBG.

Referenced by autoDetect(), locatePath(), MP3EncoderDialog(), and updateEncoderInfo().

{
    const QFile::Permissions executable =
        (QFile::ExeOwner | QFile::ExeUser | QFile::ExeGroup | QFile::ExeOther);
#ifdef Q_OS_WIN
    const QLatin1Char separator = QLatin1Char(';');
#else
    const QLatin1Char separator = QLatin1Char(':');
#endif
    QStringList path =
        _(qgetenv("PATH")).split(separator, QString::SkipEmptyParts);

    QFileInfo f(program);
    QString d = f.path();
    if (d.length()) path.prepend(d);

    foreach (const QString &dir, path) {
        QString p = dir;
        if (!p.endsWith(QDir::separator()))
            p += QDir::separator();
        p += f.fileName();

        QFile file(p);
        qDebug("testing '%s'", DBG(p));
        if (file.exists() && (file.permissions() & executable)) {
            // found it :)
            return p;
        }
    }

    return program;
}

Here is the caller graph for this function:

selectProgram

void Kwave::MP3EncoderDialog::selectProgram ( int  index )

privateslot

called when the selection of the program has changed

Definition at line 473 of file MP3EncoderDialog.cpp.

References ELEMENTS_OF, load(), m_settings, and Kwave::toInt().

Referenced by autoDetect(), buttonClicked(), and MP3EncoderDialog().

{
    if (index < 0) return;
    if (index >= Kwave::toInt(ELEMENTS_OF(g_predefined_settings))) return;

    m_settings = g_predefined_settings[index];
    load();
}

Here is the call graph for this function:

Here is the caller graph for this function:

switchToUserDefined

void Kwave::MP3EncoderDialog::switchToUserDefined ( )

privateslot

called whenever an edit field has changed its value

Definition at line 483 of file MP3EncoderDialog.cpp.

References CHECK, ELEMENTS_OF, Kwave::MP3EncoderSettings::m_path, Kwave::toInt(), and updateEncoderInfo().

{
    int index = cbProgram->currentIndex();

    for (unsigned i = 0; i < ELEMENTS_OF(g_predefined_settings); i++) {
        const Kwave::MP3EncoderSettings &settings =
            g_predefined_settings[i];
        bool match = true;

        match &= bool(edPath->text().simplified().contains(settings.m_path,
            Qt::CaseInsensitive));

        CHECK(m_input.m_raw_format,             edRawFormat);
        CHECK(m_input.m_byte_order,             edByteOrder);
        CHECK(m_input.m_signed,                 edSign);

        CHECK(m_format.m_sample_rate,           edSampleRate);
        CHECK(m_format.m_bits_per_sample,       edBitsPerSample);
        CHECK(m_format.m_channels.m_mono,       edMono);
        CHECK(m_format.m_channels.m_stereo,     edStereo);

        CHECK(m_quality.m_bitrate.m_avg,        edBitrateAvg);
        CHECK(m_quality.m_bitrate.m_min,        edBitrateMin);
        CHECK(m_quality.m_bitrate.m_max,        edBitrateMax);

        CHECK(m_encoding.m_emphasis.m_none,     edEmphasisNone);
        CHECK(m_encoding.m_emphasis.m_50_15ms,  edEmphasis5015ms);
        CHECK(m_encoding.m_emphasis.m_ccit_j17, edEmphasisCCIT_J17);

        CHECK(m_encoding.m_noise_shaping,       edNoiseShaping);
        CHECK(m_encoding.m_compatibility,       edCompatibility);

        CHECK(m_flags.m_copyright,              edCopyright);
        CHECK(m_flags.m_original,               edOriginal);
        CHECK(m_flags.m_protect,                edProtect);
        CHECK(m_flags.m_prepend,                edPrepend);
        CHECK(m_flags.m_append,                 edAppend);

        CHECK(m_info.m_help,                    edEncoderHelp);
        CHECK(m_info.m_version,                 edVersionInfo);

        if (match) {
            // found a match against known preset
            if (Kwave::toInt(i) != index) {
                cbProgram->setCurrentIndex(i);
                updateEncoderInfo();
            }
            return;
        }
    }

    // fallback: "user defined"
    cbProgram->setCurrentIndex(ELEMENTS_OF(g_predefined_settings));
    updateEncoderInfo();
}

Here is the call graph for this function:

testSettings

void Kwave::MP3EncoderDialog::testSettings ( )

privateslot

test the settings

Definition at line 611 of file MP3EncoderDialog.cpp.

References Kwave::MP3Encoder::encode(), Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_COPYRIGHTED, Kwave::INF_MPEG_EMPHASIS, Kwave::INF_ORIGINAL, Kwave::SignalManager::metaData(), Kwave::SignalManager::newSignal(), Kwave::MetaDataList::replace(), save(), Kwave::FileInfo::set(), and Kwave::SinglePassForward.

Referenced by MP3EncoderDialog().

{
    const sample_index_t test_length = 128 * 1024; // 128k samples
    const double         sample_rate = 44100.0;
    const unsigned int   bits        = 16;
    const unsigned int   tracks      = 2;

    // save all data, so that the encoder can read it
    save();

    // us a dummy sink in memory
    QBuffer dst;

    // create some dummy audio data (stereo)
    Kwave::SignalManager manager(this);
    manager.newSignal(test_length, sample_rate, bits, tracks);
    Kwave::MetaDataList meta_data = manager.metaData();

    // add some dummy meta data, to cover all parameters of the encoder
    Kwave::FileInfo info(meta_data);
    info.set(Kwave::INF_BITRATE_NOMINAL, QVariant(128000));
    info.set(Kwave::INF_BITRATE_LOWER,   QVariant( 64000));
    info.set(Kwave::INF_BITRATE_UPPER,   QVariant(192000));
    info.set(Kwave::INF_MPEG_EMPHASIS,   QVariant(3));
    info.set(Kwave::INF_COPYRIGHTED,     QVariant(1));
    info.set(Kwave::INF_ORIGINAL,        QVariant(1));
    meta_data.replace(Kwave::MetaDataList(info));

    // create a multi track reader
    QList<unsigned int> track_list;
    track_list.append(0);
    track_list.append(1);
    sample_index_t first = 0;
    sample_index_t last  = test_length - 1;
    Kwave::MultiTrackReader src(Kwave::SinglePassForward,
        manager, track_list, first, last);

    // create an encoder
    MP3Encoder encoder;

    // pass the data through the encoder
    bool succeeded = encoder.encode(this, src, dst, meta_data);

    // check return code
    if (succeeded) {
        KMessageBox::information(this, i18n(
            "Congratulation, the test was successful!"));
    } // else: the plugin has already shown an error message
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateEncoderInfo()

void Kwave::MP3EncoderDialog::updateEncoderInfo ( )

private

updates the version info string of the current encoder

Definition at line 747 of file MP3EncoderDialog.cpp.

References ELEMENTS_OF, encoderVersion(), Kwave::MP3EncoderSettings::m_info, Kwave::MP3EncoderSettings::m_name, Kwave::MP3EncoderSettings::m_version, name, PRESET_NAME_USER_DEFINED, searchPath(), and Kwave::toInt().

Referenced by load(), locatePath(), and switchToUserDefined().

{
    int index = cbProgram->currentIndex();
    QString title;

    if (index >= Kwave::toInt(ELEMENTS_OF(g_predefined_settings))) {
        title = PRESET_NAME_USER_DEFINED;
    }

    // detect by using the currently selected path
    if (!title.length()) {
        // first try with user defined full path
        QString name    = g_predefined_settings[index].m_name;
        QString program = QFileInfo(edPath->text().simplified()).filePath();
        QString param   = edVersionInfo->text().simplified();
        QString version = encoderVersion(program, param);
        if (version.length() >= name.length()) {
            title = version;
        } else {
            // fallback: detect by using list of predefined settings
            QString p  = g_predefined_settings[index].m_info.m_version;
            program    = searchPath(g_predefined_settings[index].m_path);
            version    = encoderVersion(program, p);
            if (version.length() >= name.length())
                title = version;
        }
    }

    cbProgram->setItemText(index, title);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_settings

Kwave::MP3EncoderSettings Kwave::MP3EncoderDialog::m_settings

private

current encoder settings, complete struct

Definition at line 119 of file MP3EncoderDialog.h.

Referenced by load(), MP3EncoderDialog(), save(), and selectProgram().

---

The documentation for this class was generated from the following files:

• plugins/codec_mp3/MP3EncoderDialog.h
• plugins/codec_mp3/MP3EncoderDialog.cpp