Kwave::FileInfoDialog Class Reference

#include <FileInfoDialog.h>

Inheritance diagram for Kwave::FileInfoDialog:

Collaboration diagram for Kwave::FileInfoDialog:

Public Slots
virtual void	accept () Q_DECL_OVERRIDE

Public Member Functions
	FileInfoDialog (QWidget *parent, Kwave::FileInfo &info)
virtual	~FileInfoDialog () Q_DECL_OVERRIDE
Kwave::FileInfo &	info ()

Protected Member Functions
void	describeWidget (QWidget *widget, const QString &name, const QString &description)
void	initInfo (QLabel *label, QWidget *widget, Kwave::FileProperty property)
void	initInfoText (QLabel *label, QLineEdit *edit, Kwave::FileProperty property)

Private Slots
void	selectDate ()
void	setDateNow ()
void	tracksChanged (int tracks)
void	updateAvailableCompressions ()
void	compressionChanged ()
void	mpegLayerChanged ()
void	mpegCopyrightedChanged (bool checked)
void	mpegOriginalChanged (bool checked)
void	autoGenerateKeywords ()
void	invokeHelp ()

Private Member Functions
void	acceptEdit (Kwave::FileProperty property, QString value)
void	setupFileInfoTab ()
void	setupCompressionTab (KConfigGroup &cfg)
bool	isMpeg () const
void	setupMpegTab ()
void	setupContentTab ()
void	setupSourceTab ()
void	setupAuthorCopyrightTab ()
void	setupMiscellaneousTab ()

Private Attributes
Kwave::FileInfo	m_info

Detailed Description

Definition at line 33 of file FileInfoDialog.h.

Constructor & Destructor Documentation

FileInfoDialog()

Kwave::FileInfoDialog::FileInfoDialog	(	QWidget *	parent,
		Kwave::FileInfo &	info
	)

Constructor

Definition at line 67 of file FileInfoDialog.cpp.

References compressionChanged(), CONFIG_DEFAULT_SECTION, Kwave::connect(), invokeHelp(), mpegCopyrightedChanged(), mpegLayerChanged(), mpegOriginalChanged(), setupAuthorCopyrightTab(), setupCompressionTab(), setupContentTab(), setupFileInfoTab(), setupMiscellaneousTab(), setupMpegTab(), and setupSourceTab().

    :QDialog(parent), Ui::FileInfoDlg(), m_info(info)
{
    setupUi(this);

    connect(cbCompression, SIGNAL(currentIndexChanged(int)),
            this, SLOT(compressionChanged()));
    connect(cbMpegLayer, SIGNAL(currentIndexChanged(int)),
            this, SLOT(mpegLayerChanged()));
    connect(chkMpegCopyrighted, SIGNAL(clicked(bool)),
            this, SLOT(mpegCopyrightedChanged(bool)));
    connect(chkMpegOriginal, SIGNAL(clicked(bool)),
            this, SLOT(mpegOriginalChanged(bool)));
    connect(btHelp->button(QDialogButtonBox::Help), SIGNAL(clicked()),
            this,   SLOT(invokeHelp()));

    // open config for reading default settings
    KConfigGroup cfg = KSharedConfig::openConfig()->group(CONFIG_DEFAULT_SECTION);

    setupFileInfoTab();
    setupCompressionTab(cfg);
    setupMpegTab();
    setupContentTab();
    setupSourceTab();
    setupAuthorCopyrightTab();
    setupMiscellaneousTab();

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

Here is the call graph for this function:

~FileInfoDialog()

Kwave::FileInfoDialog::~FileInfoDialog ( )

virtual

Destructor

Definition at line 99 of file FileInfoDialog.cpp.

{
}

Member Function Documentation

accept

void Kwave::FileInfoDialog::accept ( )

virtualslot

applies the settings and closes the dialog (OK button)

Definition at line 937 of file FileInfoDialog.cpp.

References _, Kwave::CompressionWidget::ABR_MODE, acceptEdit(), CONFIG_DEFAULT_SECTION, Kwave::FileInfo::contains(), Kwave::FileInfo::dump(), Kwave::Compression::fromInt(), Kwave::Compression::hasABR(), Kwave::Compression::hasVBR(), Kwave::INF_ALBUM, Kwave::INF_ARCHIVAL, Kwave::INF_AUTHOR, Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_CD, Kwave::INF_CDS, Kwave::INF_COMMISSIONED, Kwave::INF_COMPRESSION, Kwave::INF_CONTACT, Kwave::INF_COPYRIGHT, Kwave::INF_COPYRIGHTED, Kwave::INF_CREATION_DATE, Kwave::INF_ENGINEER, Kwave::INF_GENRE, Kwave::INF_KEYWORDS, Kwave::INF_LICENSE, Kwave::INF_MIMETYPE, Kwave::INF_MPEG_EMPHASIS, Kwave::INF_MPEG_LAYER, Kwave::INF_MPEG_MODEEXT, Kwave::INF_NAME, Kwave::INF_ORGANIZATION, Kwave::INF_ORIGINAL, Kwave::INF_PRODUCT, Kwave::INF_SAMPLE_FORMAT, Kwave::INF_SOFTWARE, Kwave::INF_SOURCE, Kwave::INF_SOURCE_FORM, Kwave::INF_SUBJECT, Kwave::INF_TECHNICAN, Kwave::INF_TRACK, Kwave::INF_TRACKS, Kwave::INF_VBR_QUALITY, Kwave::INF_VERSION, isMpeg(), m_info, Kwave::Compression::NONE, Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), Kwave::FileInfo::setRate(), Kwave::toInt(), Kwave::FileInfo::tracks(), and Kwave::CompressionWidget::VBR_MODE.

Referenced by info().

{
    // save defaults for next time...
    KConfigGroup cfg = KSharedConfig::openConfig()->group(CONFIG_DEFAULT_SECTION);
    cfg.sync();
    {
        int nominal, upper, lower;
        compressionWidget->getABRrates(nominal, lower, upper);
        cfg.writeEntry("default_abr_nominal_bitrate", nominal);
        cfg.writeEntry("default_abr_upper_bitrate", upper);
        cfg.writeEntry("default_abr_lower_bitrate", lower);

        int quality = compressionWidget->baseQuality();
        cfg.writeEntry("default_vbr_quality", quality);
    }
    cfg.sync();

    qDebug("FileInfoDialog::accept()");
    m_info.dump();

    /* mime type */
    m_info.set(Kwave::INF_MIMETYPE, edFileFormat->text());

    /* bits per sample */
    m_info.setBits(sbResolution->value());

    /* sample rate */
    m_info.setRate(cbSampleRate->currentText().toDouble());

    /* sample format */
    Kwave::SampleFormat::Map sample_formats;
    int sample_format =
        cbSampleFormat->itemData(cbSampleFormat->currentIndex()).toInt();
    m_info.set(Kwave::INF_SAMPLE_FORMAT, QVariant(sample_format));

    /* compression */
    Kwave::Compression::Type compression = Kwave::Compression::fromInt(
        cbCompression->itemData(cbCompression->currentIndex()).toInt()
    );
    m_info.set(Kwave::INF_COMPRESSION,
        (compression != Kwave::Compression::NONE) ?
        QVariant(Kwave::Compression(compression).toInt()) :
        QVariant());

    /* MPEG layer */
    if (isMpeg()) {
        int layer = cbMpegLayer->currentIndex() + 1;
        m_info.set(Kwave::INF_MPEG_LAYER, layer);

        // only in "Joint Stereo" mode, then depends on Layer
        //
        // Layer I+II          |  Layer III
        //                     |  Intensity stereo MS Stereo
        //--------------------------------------------------
        // 0 - bands  4 to 31  |  off              off  -> 4
        // 1 - bands  8 to 31  |  on               off  -> 5
        // 2 - bands 12 to 31  |  off              on   -> 6
        // 3 - bands 16 to 31  |  on               on   -> 7
        if (m_info.tracks() < 2) {
            // mono -> no mode ext.
            m_info.set(Kwave::INF_MPEG_MODEEXT, QVariant());
        } else if (cbMpegModeExt->isEnabled()) {
            // Layer I+II
            int modeext = cbMpegModeExt->currentIndex();
            m_info.set(Kwave::INF_MPEG_MODEEXT, modeext);
        } else {
            // Layer III
            int modeext = 4;
            if (chkMpegIntensityStereo->isChecked()) modeext |= 1;
            if (chkMpegMSStereo->isChecked())        modeext |= 2;
            m_info.set(Kwave::INF_MPEG_MODEEXT, modeext);
        }

        int emphasis = 0;;
        switch (cbMpegEmphasis->currentIndex()) {
            case 1:  emphasis = 1; break; /* 1 -> 1 */
            case 2:  emphasis = 3; break; /* 2 -> 3 */
            case 0: /* FALLTHROUGH */
            default: emphasis = 0; break; /* 0 -> 0 */
        }
        m_info.set(Kwave::INF_MPEG_EMPHASIS, emphasis);

        bool copyrighted = chkMpegCopyrighted->isChecked();
        m_info.set(Kwave::INF_COPYRIGHTED, copyrighted);

        bool original = chkMpegOriginal->isChecked();
        m_info.set(Kwave::INF_ORIGINAL, original);
    } else {
        m_info.set(Kwave::INF_MPEG_MODEEXT,  QVariant());
        m_info.set(Kwave::INF_MPEG_EMPHASIS, QVariant());
        m_info.set(Kwave::INF_COPYRIGHTED,   QVariant());
        m_info.set(Kwave::INF_ORIGINAL,      QVariant());
    }

    /* bitrate in Ogg/Vorbis or MPEG mode */
    const Kwave::Compression comp(compression);
    if (comp.hasABR() || comp.hasVBR()) {
        Kwave::CompressionWidget::Mode mode = compressionWidget->mode();
        QVariant del;

        switch (mode) {
            case Kwave::CompressionWidget::ABR_MODE: {
                int nominal, upper, lower;
                compressionWidget->getABRrates(nominal, lower, upper);
                bool use_lowest  = compressionWidget->lowestEnabled();
                bool use_highest = compressionWidget->highestEnabled();

                m_info.set(Kwave::INF_BITRATE_NOMINAL, QVariant(nominal));
                m_info.set(Kwave::INF_BITRATE_LOWER,
                           (use_lowest) ? QVariant(lower) : del);
                m_info.set(Kwave::INF_BITRATE_UPPER,
                           (use_highest) ? QVariant(upper) : del);
                m_info.set(Kwave::INF_VBR_QUALITY, del);
                break;
            }
            case Kwave::CompressionWidget::VBR_MODE: {
                int quality = compressionWidget->baseQuality();

                m_info.set(Kwave::INF_BITRATE_NOMINAL, del);
                m_info.set(Kwave::INF_BITRATE_LOWER, del);
                m_info.set(Kwave::INF_BITRATE_UPPER, del);
                m_info.set(Kwave::INF_VBR_QUALITY, QVariant(quality));
                break;
            }
        }
    }

    /* name, subject, version, genre, title, author, organization,
       copyright */
    acceptEdit(Kwave::INF_NAME,         edName->text());
    acceptEdit(Kwave::INF_SUBJECT,      edSubject->text());
    acceptEdit(Kwave::INF_VERSION,      edVersion->text());
    acceptEdit(Kwave::INF_GENRE,        cbGenre->currentText());
    acceptEdit(Kwave::INF_AUTHOR,       edAuthor->text());
    acceptEdit(Kwave::INF_ORGANIZATION, edOrganization->text());
    acceptEdit(Kwave::INF_COPYRIGHT,    edCopyright->text());
    acceptEdit(Kwave::INF_LICENSE,      edLicense->text());

    /* date */
    QDate date = dateEdit->date();
    if ( (date != QDate::currentDate()) ||
        m_info.contains(Kwave::INF_CREATION_DATE) )
    {
        m_info.set(Kwave::INF_CREATION_DATE, QVariant(date).toString());
    }

    /* source, source form, album */
    acceptEdit(Kwave::INF_SOURCE,      edSource->text());
    acceptEdit(Kwave::INF_SOURCE_FORM, edSourceForm->text());
    acceptEdit(Kwave::INF_ALBUM,       edAlbum->text());

    /* CD and track */
    int cd     = sbCD->value();
    int cds    = sbCDs->value();
    int track  = sbTrack->value();
    int tracks = sbTracks->value();
    m_info.set(Kwave::INF_CD,     (cd     != 0) ? QVariant(cd)     : QVariant());
    m_info.set(Kwave::INF_CDS,    (cds    != 0) ? QVariant(cds)    : QVariant());
    m_info.set(Kwave::INF_TRACK,  (track  != 0) ? QVariant(track)  : QVariant());
    m_info.set(Kwave::INF_TRACKS, (tracks != 0) ? QVariant(tracks) : QVariant());

    /* product, archival, contact */
    acceptEdit(Kwave::INF_PRODUCT,     edProduct->text());
    acceptEdit(Kwave::INF_ARCHIVAL,    edArchival->text());
    acceptEdit(Kwave::INF_CONTACT,     edContact->text());

    /* software, engineer, technician, commissioned, ISRC, keywords */
    acceptEdit(Kwave::INF_SOFTWARE,    edSoftware->text());
    acceptEdit(Kwave::INF_ENGINEER,    edEngineer->text());
    acceptEdit(Kwave::INF_TECHNICAN,   edTechnican->text());
    acceptEdit(Kwave::INF_COMMISSIONED,edCommissioned->text());
//  acceptEdit(Kwave::INF_ISRC,        edISRC->text()); <- READ-ONLY

    // list of keywords
    acceptEdit(Kwave::INF_KEYWORDS,
        lstKeywords->keywords().join(_("; ")));

    qDebug("FileInfoDialog::accept() [done]");
    m_info.dump();

    QDialog::accept();
}

Here is the call graph for this function:

Here is the caller graph for this function:

acceptEdit()

void Kwave::FileInfoDialog::acceptEdit ( Kwave::FileProperty  property, QString  value  )

private

takes the content of an edit field or similar into the current info ore removes it if the text is zero-length

Definition at line 923 of file FileInfoDialog.cpp.

References Kwave::FileInfo::contains(), m_info, and Kwave::FileInfo::set().

Referenced by accept(), and info().

{
    value = value.simplified();
    if (!m_info.contains(property) && !value.length()) return;

    if (!value.length()) {
        m_info.set(property, QVariant());
    } else {
        m_info.set(property, value);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

autoGenerateKeywords

void Kwave::FileInfoDialog::autoGenerateKeywords ( )

privateslot

auto-generate the list of keywords

Definition at line 822 of file FileInfoDialog.cpp.

References _.

Referenced by info(), and setupMiscellaneousTab().

{
    // start with the current list
    QStringList list = lstKeywords->keywords();

    // name, subject, version, genre, author, organization,
    // copyright, license, source, source form, album,
    // product, archival, contact, software, technician, engineer,
    // commissioned, ISRC
    const QString space = _(" ");
    list += edName->text().split(space);
    list += edSubject->text().split(space);
    list += edVersion->text().split(space);
    list += cbGenre->currentText();
    list += edAuthor->text().split(space);
    list += edOrganization->text().split(space);
    list += edCopyright->text().split(space);
    list += edLicense->text().split(space);
    list += edSource->text().split(space);
    list += edSourceForm->text().split(space);
    list += edAlbum->text().split(space);
    list += edProduct->text().split(space);
    list += edArchival->text().split(space);
    list += edContact->text().split(space);
    list += edSoftware->text().split(space);
    list += edTechnican->text().split(space);
    list += edEngineer->text().split(space);
    list += edCommissioned->text().split(space);
    list += edISRC->text().split(space);

    // filter out all useless stuff
    QMutableStringListIterator it(list);
    while (it.hasNext()) {
        QString token = it.next();

        // remove punktation characters like '.', ',', '!' from start and end
        while (token.length()) {
            QString old_value = token;

            QChar c = token[token.length()-1];
            if (c.isPunct() || c.isMark() || c.isSpace())
                token = token.left(token.length()-1);
            if (!token.length()) break;

            c = token[0];
            if (c.isPunct() || c.isMark() || c.isSpace())
                token = token.right(token.length()-1);

            if (token == old_value) break; // no (more) change(s)
        }

        // remove empty entries
        if (!token.length()) {
            it.remove();
            continue;
        }

        // remove simple numbers and too short stuff
        bool ok = false;
        token.toInt(&ok);
        if ((ok) || (token.length() < 3)) {
            it.remove(); // number or less than 3 characters -> remove
            continue;
        }

        // remove duplicates that differ in case
        bool is_duplicate = false;
        QStringListIterator it2(list);
        while (it2.hasNext()) {
            QString token2 = it2.next();
            if (list.indexOf(token) == list.lastIndexOf(token2)) continue;
            if (token2.compare(token, Qt::CaseInsensitive) == 0) {
                // take the one with less uppercase characters
                unsigned int upper1 = 0;
                unsigned int upper2 = 0;
                for (int i=0; i < token.length(); ++i)
                    if (token[i].category() == QChar::Letter_Uppercase)
                        upper1++;
                for (int i=0; i < token2.length(); ++i)
                    if (token2[i].category() == QChar::Letter_Uppercase)
                        upper2++;
                if (upper2 < upper1) {
                    is_duplicate = true;
                    break;
                }
            }
        }
        if (is_duplicate) {
            it.remove();
            continue;
        }

        it.setValue(token);
    }
    // other stuff like empty strings and duplicates are handled in
    // the list itself, we don't need to take care of that here :)

    lstKeywords->setKeywords(list);
}

Here is the caller graph for this function:

compressionChanged

void Kwave::FileInfoDialog::compressionChanged ( )

privateslot

called when the compression mode has changed

Definition at line 651 of file FileInfoDialog.cpp.

References Kwave::CompressionWidget::ABR_MODE, Kwave::CodecBase::compressionTypes(), Kwave::FileInfo::contains(), Kwave::CodecManager::encoder(), Kwave::CodecManager::encodingMimeTypes(), Kwave::Compression::fromInt(), Kwave::FileInfo::get(), Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_UPPER, Kwave::INF_MIMETYPE, isMpeg(), m_info, Kwave::Compression::MPEG_LAYER_I, Kwave::Compression::MPEG_LAYER_II, Kwave::Compression::MPEG_LAYER_III, Kwave::toInt(), and Kwave::CompressionWidget::VBR_MODE.

Referenced by FileInfoDialog(), info(), and setupCompressionTab().

{
    if (!cbCompression || !edFileFormat) return;

    Kwave::Compression::Type compression =
        Kwave::Compression::fromInt(cbCompression->itemData(
        cbCompression->currentIndex()).toInt()
    );

    const Kwave::Compression comp(compression);
    const QString preferred_mime_type = comp.preferredMimeType();

    // selected compression -> mime type (edit field)

    if (preferred_mime_type.length()) {
        // if a compression implies a specific mime type -> select it
        edFileFormat->setText(preferred_mime_type);
    } else {
        // if mime type is given by file info -> keep it
        // otherwise select one by evaluating the compression <-> encoder
        QString file_mime_type = m_info.get(Kwave::INF_MIMETYPE).toString();
        if (!file_mime_type.length()) {
            // determine mime type from a matching encoder.
            // This should work for compression types that are supported by
            // only one single encoder which also supports only one single
            // mime type
            QStringList mime_types = Kwave::CodecManager::encodingMimeTypes();
            foreach (const QString &mime_type, mime_types) {
                Kwave::Encoder *encoder =
                    Kwave::CodecManager::encoder(mime_type);
                if (!encoder) continue;
                QList<Kwave::Compression::Type> comps =
                    encoder->compressionTypes();
                if (comps.contains(compression)) {
                    edFileFormat->setText(mime_type);
                    break;
                }
            }
        }
    }

    // if mpeg mode selected -> select mpeg layer
    int mpeg_layer = -1;
    switch (compression)
    {
        case Kwave::Compression::MPEG_LAYER_I:   mpeg_layer = 1; break;
        case Kwave::Compression::MPEG_LAYER_II:  mpeg_layer = 2; break;
        case Kwave::Compression::MPEG_LAYER_III: mpeg_layer = 3; break;
        default:                                                 break;
    }

    InfoTab->setTabEnabled(2, isMpeg());
    if ((mpeg_layer > 0) && (cbMpegLayer->currentIndex() != (mpeg_layer - 1)))
        cbMpegLayer->setCurrentIndex(mpeg_layer - 1);

    // enable/disable ABR/VBR controls, depending on mime type
    const bool abr = comp.hasABR();
    const bool lower = abr && m_info.contains(Kwave::INF_BITRATE_LOWER);
    const bool upper = abr && m_info.contains(Kwave::INF_BITRATE_UPPER);
    const bool vbr = comp.hasVBR();
    compressionWidget->enableABR(abr, lower, upper);
    compressionWidget->enableVBR(vbr);
    cbSampleFormat->setEnabled(!comp.sampleFormats().isEmpty());

    if (abr && !vbr)
        compressionWidget->setMode(Kwave::CompressionWidget::ABR_MODE);
    else if (!abr && vbr)
        compressionWidget->setMode(Kwave::CompressionWidget::VBR_MODE);

}

Here is the call graph for this function:

Here is the caller graph for this function:

describeWidget()

void Kwave::FileInfoDialog::describeWidget ( QWidget *  widget, const QString &  name, const QString &  description  )

protected

Sets the tooltip and "what's this" of a widget.

Parameters

widget	any QWidget derived widget
name	of the setting, normally equal to it's label
description	verbose descriptive text that says what can be set

Definition at line 104 of file FileInfoDialog.cpp.

References _.

Referenced by info(), initInfo(), and setupFileInfoTab().

{
    if (!widget) return;
    widget->setToolTip(description);
    widget->setWhatsThis(_("<b>") + name + _("</b><br>") + description);
}

Here is the caller graph for this function:

info()

Kwave::FileInfo& Kwave::FileInfoDialog::info ( )

inline

Returns the current file info

Definition at line 45 of file FileInfoDialog.h.

References accept(), acceptEdit(), autoGenerateKeywords(), compressionChanged(), describeWidget(), initInfo(), initInfoText(), invokeHelp(), isMpeg(), m_info, mpegCopyrightedChanged(), mpegLayerChanged(), mpegOriginalChanged(), name, selectDate(), setDateNow(), setupAuthorCopyrightTab(), setupCompressionTab(), setupContentTab(), setupFileInfoTab(), setupMiscellaneousTab(), setupMpegTab(), setupSourceTab(), tracksChanged(), and updateAvailableCompressions().

Referenced by Kwave::FileInfoPlugin::setup().

{ return m_info; }

Here is the call graph for this function:

Here is the caller graph for this function:

initInfo()

void Kwave::FileInfoDialog::initInfo ( QLabel *  label, QWidget *  widget, Kwave::FileProperty  property  )

protected

Sets the text of the label to the name of a file property and initializes the tool tip of the corresponding edit/display control.

Parameters

label	the label to be set
widget	the control to get the tool tip
property	the file property which it belongs to

Definition at line 114 of file FileInfoDialog.cpp.

References _, describeWidget(), Kwave::FileInfo::description(), m_info, Kwave::FileInfo::name(), and UTF8.

Referenced by info(), initInfoText(), setupCompressionTab(), setupContentTab(), setupFileInfoTab(), setupMpegTab(), and setupSourceTab().

{
    if (label) label->setText(i18n(UTF8(m_info.name(property))) + _(":"));
    if (widget) describeWidget(widget,
                               i18n(UTF8(m_info.name(property))),
                               i18n(UTF8(m_info.description(property))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

initInfoText()

void Kwave::FileInfoDialog::initInfoText ( QLabel *  label, QLineEdit *  edit, Kwave::FileProperty  property  )

protected

Same as initInfo, but works only for text edit controls and sets the current text

Definition at line 124 of file FileInfoDialog.cpp.

References Kwave::FileInfo::get(), initInfo(), and m_info.

Referenced by info(), setupAuthorCopyrightTab(), setupContentTab(), setupFileInfoTab(), setupMiscellaneousTab(), and setupSourceTab().

{
    initInfo(label, edit, property);
    if (edit) edit->setText(QVariant(m_info.get(property)).toString());
}

Here is the call graph for this function:

Here is the caller graph for this function:

invokeHelp

void Kwave::FileInfoDialog::invokeHelp ( )

privateslot

invoke the online help

Definition at line 1121 of file FileInfoDialog.cpp.

References _.

Referenced by FileInfoDialog(), and info().

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

Here is the caller graph for this function:

isMpeg()

bool Kwave::FileInfoDialog::isMpeg ( ) const

private

returns true if the current compression is MPEG I/II/III

Definition at line 723 of file FileInfoDialog.cpp.

References Kwave::Compression::MPEG_LAYER_I, Kwave::Compression::MPEG_LAYER_II, Kwave::Compression::MPEG_LAYER_III, and Kwave::toInt().

Referenced by accept(), compressionChanged(), info(), mpegLayerChanged(), and setupMpegTab().

{
    int compression = cbCompression->itemData(
        cbCompression->currentIndex()).toInt();
    switch (compression)
    {
        case Kwave::Compression::MPEG_LAYER_I:
        case Kwave::Compression::MPEG_LAYER_II:
        case Kwave::Compression::MPEG_LAYER_III:
            return true;
        default:
            return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mpegCopyrightedChanged

void Kwave::FileInfoDialog::mpegCopyrightedChanged ( bool  checked )

privateslot

called when the MPEG "copyrighted" check box has changed

Definition at line 810 of file FileInfoDialog.cpp.

Referenced by FileInfoDialog(), info(), and setupMpegTab().

{
    chkMpegCopyrighted->setText((checked) ? i18n("Yes") : i18n("No"));
}

Here is the caller graph for this function:

mpegLayerChanged

void Kwave::FileInfoDialog::mpegLayerChanged ( )

privateslot

called when the MPEG layer combo box has changed

Definition at line 739 of file FileInfoDialog.cpp.

References Kwave::FileInfo::contains(), Kwave::FileInfo::get(), Kwave::INF_MPEG_MODEEXT, isMpeg(), m_info, Kwave::Compression::MPEG_LAYER_I, Kwave::Compression::MPEG_LAYER_II, Kwave::Compression::MPEG_LAYER_III, Kwave::Compression::NONE, Kwave::toInt(), and Kwave::FileInfo::tracks().

Referenced by FileInfoDialog(), info(), and setupMpegTab().

{
    if (!cbMpegLayer || !isMpeg()) return;

    int layer = cbMpegLayer->currentIndex() + 1;
    int compression = Kwave::Compression::NONE;
    switch (layer) {
        case 1:
            compression = Kwave::Compression::MPEG_LAYER_I;
            break;
        case 2:
            compression = Kwave::Compression::MPEG_LAYER_II;
            break;
        case 3:
            compression = Kwave::Compression::MPEG_LAYER_III;
            break;
    }

    if (compression != Kwave::Compression::NONE) {
        int index = cbCompression->findData(compression);
        if (index >= 0) cbCompression->setCurrentIndex(index);
    }

    /* Mode extension */
    // only in "Joint Stereo" mode, then depends on Layer
    //
    // Layer I+II          |  Layer III
    //                     |  Intensity stereo MS Stereo
    //--------------------------------------------------
    // 0 - bands  4 to 31  |  off              off  -> 4
    // 1 - bands  8 to 31  |  on               off  -> 5
    // 2 - bands 12 to 31  |  off              on   -> 6
    // 3 - bands 16 to 31  |  on               on   -> 7
    if (m_info.tracks() < 2) {
        // mono
        cbMpegModeExt->setEnabled(false);
        cbMpegModeExt->setCurrentIndex(-1);

        chkMpegIntensityStereo->setEnabled(false);
        chkMpegIntensityStereo->setChecked(false);
        chkMpegMSStereo->setEnabled(false);
        chkMpegMSStereo->setChecked(false);
    } else if (cbMpegModeExt->isEnabled() && (layer >= 3)) {
        // switched from layer I or II to layer III
        cbMpegModeExt->setEnabled(false);

        int modeext = QVariant(m_info.get(Kwave::INF_MPEG_MODEEXT)).toInt();
        if ((modeext < 4) || (modeext > 7)) {
            modeext = 7; // default to MS stereo + Intensity stereo
            chkMpegIntensityStereo->setChecked(modeext & 0x01);
            chkMpegMSStereo->setChecked(modeext & 0x02);
        }

        chkMpegIntensityStereo->setEnabled(true);
        chkMpegMSStereo->setEnabled(true);
    } else if (!cbMpegModeExt->isEnabled() && (layer <= 2)) {
        // switched from layer III to layer I or II
        int modeext = (m_info.contains(Kwave::INF_MPEG_MODEEXT)) ?
            QVariant(m_info.get(Kwave::INF_MPEG_MODEEXT)).toInt() : -1;
        if ((modeext < 0) || (modeext > 3)) {
            modeext = 0; // default bands 4 to 31
            cbMpegModeExt->setCurrentIndex(modeext);
        }
        cbMpegModeExt->setEnabled(true);

        chkMpegIntensityStereo->setEnabled(false);
        chkMpegMSStereo->setEnabled(false);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mpegOriginalChanged

void Kwave::FileInfoDialog::mpegOriginalChanged ( bool  checked )

privateslot

called when the MPEG "original" check box has changed

Definition at line 816 of file FileInfoDialog.cpp.

Referenced by FileInfoDialog(), info(), and setupMpegTab().

{
    chkMpegOriginal->setText((checked) ? i18n("Yes") : i18n("No"));
}

Here is the caller graph for this function:

selectDate

void Kwave::FileInfoDialog::selectDate ( )

privateslot

select a date for the "creation date" setting

Definition at line 562 of file FileInfoDialog.cpp.

Referenced by info(), and setupContentTab().

{
    QDate date(dateEdit->date());
    Kwave::SelectDateDialog date_dialog(this, date);
    if (date_dialog.exec() == QDialog::Accepted) {
        date = date_dialog.date();
        dateEdit->setDate(date);
    }
}

Here is the caller graph for this function:

setDateNow

void Kwave::FileInfoDialog::setDateNow ( )

privateslot

sets the "creation date" to today

Definition at line 573 of file FileInfoDialog.cpp.

Referenced by info(), and setupContentTab().

{
    dateEdit->setDate(QDate::currentDate());
}

Here is the caller graph for this function:

setupAuthorCopyrightTab()

void Kwave::FileInfoDialog::setupAuthorCopyrightTab ( )

private

initialize the "Author/Copyright" tab

Definition at line 526 of file FileInfoDialog.cpp.

References Kwave::INF_ARCHIVAL, Kwave::INF_AUTHOR, Kwave::INF_CONTACT, Kwave::INF_COPYRIGHT, Kwave::INF_ISRC, Kwave::INF_LICENSE, Kwave::INF_ORGANIZATION, Kwave::INF_PRODUCT, and initInfoText().

Referenced by FileInfoDialog(), and info().

{
    /* author organization, copyright, license, ISRC */
    initInfoText(lblAuthor,       edAuthor,       Kwave::INF_AUTHOR);
    initInfoText(lblOrganization, edOrganization, Kwave::INF_ORGANIZATION);
    initInfoText(lblCopyright,    edCopyright,    Kwave::INF_COPYRIGHT);
    initInfoText(lblLicense,      edLicense,      Kwave::INF_LICENSE);
    initInfoText(lblISRC,         edISRC,         Kwave::INF_ISRC);

    /* product, archival, contact */
    initInfoText(lblProduct,  edProduct,  Kwave::INF_PRODUCT);
    initInfoText(lblArchival, edArchival, Kwave::INF_ARCHIVAL);
    initInfoText(lblContact,  edContact,  Kwave::INF_CONTACT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupCompressionTab()

void Kwave::FileInfoDialog::setupCompressionTab ( KConfigGroup &  cfg )

private

initialize the "Compression" tab

Definition at line 297 of file FileInfoDialog.cpp.

References Kwave::CompressionWidget::ABR_MODE, compressionChanged(), Kwave::FileInfo::contains(), Kwave::FileInfo::get(), Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_COMPRESSION, Kwave::INF_VBR_QUALITY, initInfo(), m_info, Kwave::toInt(), updateAvailableCompressions(), and Kwave::CompressionWidget::VBR_MODE.

Referenced by FileInfoDialog(), and info().

{

    /*
     * mime type @ file info -> available compressions
     * compression @ file info / available compressions -> selected compression
     * selected compression -> mime type (edit field)
     * mime type -> mpeg/ogg/flac mode
     * mgeg layer -> compression
     */

    /* compression */
    updateAvailableCompressions();
    initInfo(lblCompression, cbCompression, Kwave::INF_COMPRESSION);

    compressionWidget->init(m_info);
    compressionWidget->setMode(m_info.contains(Kwave::INF_VBR_QUALITY) ?
        Kwave::CompressionWidget::VBR_MODE :
        Kwave::CompressionWidget::ABR_MODE);

    // ABR bitrate settings
    int abr_bitrate = m_info.contains(Kwave::INF_BITRATE_NOMINAL) ?
                  QVariant(m_info.get(Kwave::INF_BITRATE_NOMINAL)).toInt() :
                  cfg.readEntry("default_abr_nominal_bitrate", -1);
    int min_bitrate = m_info.contains(Kwave::INF_BITRATE_LOWER) ?
                  QVariant(m_info.get(Kwave::INF_BITRATE_LOWER)).toInt() :
                  cfg.readEntry("default_abr_lower_bitrate",-1);
    int max_bitrate = m_info.contains(Kwave::INF_BITRATE_UPPER) ?
                  QVariant(m_info.get(Kwave::INF_BITRATE_UPPER)).toInt() :
                  cfg.readEntry("default_abr_upper_bitrate",-1);
    compressionWidget->setBitrates(abr_bitrate, min_bitrate, max_bitrate);

    // VBR base quality
    int quality = m_info.contains(Kwave::INF_VBR_QUALITY) ?
              QVariant(m_info.get(Kwave::INF_VBR_QUALITY)).toInt() :
              cfg.readEntry("default_vbr_quality", -1);
    compressionWidget->setQuality(quality);

    compressionChanged();

//    // this is not visible, not implemented yet...
//    InfoTab->setCurrentPage(5);
//    QWidget *page = InfoTab->currentPage();
//    InfoTab->removePage(page);
//    InfoTab->setCurrentPage(0);
//    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupContentTab()

void Kwave::FileInfoDialog::setupContentTab ( )

private

initializes the "Content" tab

Definition at line 443 of file FileInfoDialog.cpp.

References Kwave::GenreType::allTypes(), Kwave::connect(), Kwave::FileInfo::contains(), Kwave::FileInfo::get(), Kwave::GenreType::id(), Kwave::INF_CREATION_DATE, Kwave::INF_GENRE, Kwave::INF_NAME, Kwave::INF_SUBJECT, Kwave::INF_VERSION, initInfo(), initInfoText(), m_info, Kwave::GenreType::name(), selectDate(), and setDateNow().

Referenced by FileInfoDialog(), and info().

{
    /* name, subject, version, genre, title, author, organization,
       copyright, license */
    initInfoText(lblName,         edName,         Kwave::INF_NAME);
    initInfoText(lblSubject,      edSubject,      Kwave::INF_SUBJECT);
    initInfoText(lblVersion,      edVersion,      Kwave::INF_VERSION);

    // genre type
    cbGenre->addItems(Kwave::GenreType::allTypes());
    QString genre = m_info.get(Kwave::INF_GENRE).toString();
    int genre_id = Kwave::GenreType::id(genre);
    if (genre_id >= 0) {
        // well known genre type
        genre = Kwave::GenreType::name(genre_id, true);
    } else {
        // user defined genre type
        cbGenre->addItem(genre);
    }
    initInfo(lblGenre,            cbGenre,        Kwave::INF_GENRE);
    cbGenre->setCurrentIndex(cbGenre->findText(genre));

    /* date widget */
    initInfo(lblDate, dateEdit, Kwave::INF_CREATION_DATE);
    QDate date;
    QString date_str = QVariant(m_info.get(Kwave::INF_CREATION_DATE)).toString();
    if (m_info.contains(Kwave::INF_CREATION_DATE)) {
        if (date_str.length())
            date = QDate::fromString(date_str, Qt::ISODate);
    }
    if (!date.isValid()) {
        // fall back to "year only"
        int year = date_str.toInt();
        if ((year > 0) && (year <= 9999))
            date = QDate(year, 1, 1);
    }
    if (!date.isValid()) {
        // fall back to "now"
        date = QDate::currentDate();
    }

    dateEdit->setDate(date);
    connect(btSelectDate, SIGNAL(clicked()), this, SLOT(selectDate()));
    connect(btSelectDateNow, SIGNAL(clicked()), this, SLOT(setDateNow()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupFileInfoTab()

void Kwave::FileInfoDialog::setupFileInfoTab ( )

private

initializes the "File" tab

Definition at line 132 of file FileInfoDialog.cpp.

References _, Kwave::FileInfo::bits(), cmp(), Kwave::CodecBase::compressionTypes(), Kwave::connect(), Kwave::FileInfo::contains(), Kwave::TypesMap< IDX, DATA >::data(), DBG, describeWidget(), Kwave::TypesMap< IDX, DATA >::description(), Kwave::CodecManager::encoder(), Kwave::Compression::fromInt(), Kwave::FileInfo::get(), Kwave::INF_COMPRESSION, Kwave::INF_FILENAME, Kwave::INF_FILESIZE, Kwave::INF_MIMETYPE, Kwave::INF_SAMPLE_FORMAT, initInfo(), initInfoText(), Kwave::TypesMap< IDX, DATA >::keys(), Kwave::FileInfo::length(), m_info, Kwave::CodecManager::mimeTypeOf(), Kwave::ms2string(), Kwave::Compression::name(), Kwave::Compression::NONE, Kwave::Compression::preferredMimeType(), Kwave::FileInfo::rate(), Kwave::samples2string(), Kwave::FileInfo::set(), Kwave::SampleFormat::Signed, Kwave::CodecBase::supports(), Kwave::Compression::toInt(), Kwave::toInt(), Kwave::FileInfo::tracks(), and tracksChanged().

Referenced by FileInfoDialog(), and info().

{
    /* filename */
    initInfo(lblFileName, edFileName, Kwave::INF_FILENAME);
    QFileInfo fi(QVariant(m_info.get(Kwave::INF_FILENAME)).toString());
    QString file_name = fi.fileName();
    edFileName->setText(file_name);
    edFileName->setEnabled(file_name.length() != 0);

    /* mime type */
    QString mimetype = QVariant(m_info.get(Kwave::INF_MIMETYPE)).toString();
    if (!mimetype.length())
        mimetype = _("audio/x-wav"); // default mimetype

    qDebug("mimetype = %s", DBG(mimetype));

    /*
     * Check if the file name, mime type and compression match. If not,
     * we might be in the "SaveAs" mode and the compression belongs to
     * the old file name
     */
    if (file_name.length()) {
        QString mt = Kwave::CodecManager::mimeTypeOf(QUrl(file_name));
        Kwave::Encoder *encoder = Kwave::CodecManager::encoder(mt);
        if (encoder) {
            // encoder does not support the file's mime type -> switch
            if (!encoder->supports(mt)) {
                qDebug("switching mime type to '%s'", DBG(mt));
                m_info.set(Kwave::INF_MIMETYPE, mt);
                mimetype = mt;
            }

            // encoder does not support compression -> switch
            QList<Kwave::Compression::Type> comps = encoder->compressionTypes();
            Kwave::Compression::Type comp = Kwave::Compression::fromInt(
                QVariant(m_info.get(Kwave::INF_COMPRESSION)).toInt()
            );
            if (!comps.contains(comp)) {
                Kwave::Compression comp_old(comp);
                Kwave::Compression comp_new(!comps.isEmpty() ?
                    comps.last() : Kwave::Compression::NONE
                );
                qDebug("compression '%s' not supported: switch to '%s'",
                    DBG(comp_old.name()), DBG(comp_new.name()));
                m_info.set(Kwave::INF_COMPRESSION,
                    Kwave::Compression(comp).toInt());
            }

            // mime type does not match compression -> switch
            QList<Kwave::Compression::Type> comps_found;
            foreach (Kwave::Compression::Type c, comps) {
                Kwave::Compression cmp(c);
                if ((cmp.preferredMimeType() == mimetype) &&
                     comps.contains(c))
                {
                    comps_found.append(c);
                    break;
                }
            }
            if (!comps_found.isEmpty() && !comps_found.contains(comp)) {
                Kwave::Compression::Type cn =
                (comps_found.isEmpty() && !comps.isEmpty()) ?
                    comps.last() : comps_found.first();
                Kwave::Compression comp_old(comp);
                Kwave::Compression comp_new(cn);
                qDebug("mime type/compression mismatch: "
                       "switch from '%s' to '%s'",
                       DBG(comp_old.name()), DBG(comp_new.name()));
                m_info.set(Kwave::INF_COMPRESSION, comp_new.toInt());
            }
        }
    }
    edFileFormat->setText(mimetype);

    /* file size in bytes */
    initInfo(lblFileSize, edFileSize, Kwave::INF_FILESIZE);
    if (m_info.contains(Kwave::INF_FILESIZE)) {
        unsigned int size = QVariant(m_info.get(Kwave::INF_FILESIZE)).toUInt();
        QString dotted = QLocale().toString(size);
        if (size < 10*1024) {
            edFileSize->setText(i18n("%1 bytes", dotted));
        } else if (size < 10*1024*1024) {
            edFileSize->setText(i18n("%1 kB (%2 byte)",
                (size / 1024), dotted));
        } else {
            edFileSize->setText(i18n("%1 MB (%2 byte)",
                (size / (1024*1024)), dotted));
        }
    } else {
        edFileSize->setEnabled(false);
    }

    /* file format (from mime type) */

    // use mimetype instead
    initInfoText(lblFileFormat,   edFileFormat,   Kwave::INF_MIMETYPE);

    /* sample rate */
    lblSampleRate->setText(i18n("Sample rate:"));
    describeWidget(cbSampleRate, lblSampleRate->text().left(
        lblSampleRate->text().length() - 1),
        i18n("Here you can select one of the predefined\n"
             "well-known sample rates or you can enter\n"
             "any sample rate on your own."));
    cbSampleRate->setEditText(QString::number(m_info.rate()));

    /* bits per sample */
    lblResolution->setText(i18n("Resolution:"));
    describeWidget(sbResolution, lblResolution->text().left(
        lblResolution->text().length() - 1),
        i18n("Select a resolution in bits in which the file\n"
             "will be saved."));
    sbResolution->setValue(m_info.bits());

    /* number of tracks */
    lblChannels->setText(i18n("Tracks:"));
    describeWidget(sbChannels, lblChannels->text().left(
        lblChannels->text().length() - 1),
        i18n("Shows the number of tracks of the signal.\n"
             "You can add or delete tracks via the Edit menu."));
    sbChannels->setMaximum(m_info.tracks());
    sbChannels->setMinimum(m_info.tracks());
    sbChannels->setValue(m_info.tracks());
    connect(sbChannels, SIGNAL(valueChanged(int)),
            this, SLOT(tracksChanged(int)));
    tracksChanged(sbChannels->value());

    /* length of the signal */
    lblLength->setText(i18n("Length:"));
    describeWidget(txtLength, lblLength->text().left(
        lblLength->text().length() - 1),
        i18n("Shows the length of the file in samples\n"
             "and if possible as time."));
    sample_index_t samples = m_info.length();
    double rate = m_info.rate();
    if (!qFuzzyIsNull(rate)) {
        double ms = static_cast<double>(samples) * 1E3 / rate;
        txtLength->setText(i18n("%1 (%2 samples)",
            Kwave::ms2string(ms),
            Kwave::samples2string(samples)));
    } else {
        txtLength->setText(i18n("%1 samples",
            Kwave::samples2string(samples)));
    }

    /* sample format */
    initInfo(lblSampleFormat, cbSampleFormat, Kwave::INF_SAMPLE_FORMAT);
    cbSampleFormat->clear();
    Kwave::SampleFormat::Map sf;
    const QList<int> formats = sf.keys();
    foreach (const int &k, formats) {
        cbSampleFormat->addItem(
            sf.description(k, true),
            QVariant(Kwave::SampleFormat(sf.data(k)).toInt())
        );
    }

    int format = QVariant(m_info.get(Kwave::INF_SAMPLE_FORMAT)).toInt();
    if (format == 0)
        format = Kwave::SampleFormat::Signed; // default = signed int

    cbSampleFormat->setCurrentIndex(cbSampleFormat->findData(format));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupMiscellaneousTab()

void Kwave::FileInfoDialog::setupMiscellaneousTab ( )

private

initialize the "Miscellaneous" tab

Definition at line 542 of file FileInfoDialog.cpp.

References _, autoGenerateKeywords(), Kwave::connect(), Kwave::FileInfo::contains(), Kwave::FileInfo::description(), Kwave::FileInfo::get(), Kwave::INF_COMMISSIONED, Kwave::INF_KEYWORDS, initInfoText(), m_info, and Kwave::FileInfo::name().

Referenced by FileInfoDialog(), and info().

{
    /* commissioned */
    initInfoText(lblCommissioned, edCommissioned, Kwave::INF_COMMISSIONED);

    /* list of keywords */
    lblKeywords->setText(i18n(m_info.name(Kwave::INF_KEYWORDS).toLatin1()));
    lstKeywords->setWhatsThis(_("<b>") +
        i18n(m_info.name(Kwave::INF_KEYWORDS).toLatin1()) +
        _("</b><br>") + i18n(m_info.description(Kwave::INF_KEYWORDS).toLatin1()));
    if (m_info.contains(Kwave::INF_KEYWORDS)) {
        QString keywords = QVariant(m_info.get(Kwave::INF_KEYWORDS)).toString();
        lstKeywords->setKeywords(keywords.split(_(";")));
    }
    connect(lstKeywords, SIGNAL(autoGenerate()),
            this, SLOT(autoGenerateKeywords()));

}

Here is the call graph for this function:

Here is the caller graph for this function:

setupMpegTab()

void Kwave::FileInfoDialog::setupMpegTab ( )

private

initialize the "MPEG" tab

Definition at line 346 of file FileInfoDialog.cpp.

References Kwave::FileInfo::contains(), Kwave::FileInfo::get(), Kwave::INF_COPYRIGHTED, Kwave::INF_MPEG_EMPHASIS, Kwave::INF_MPEG_LAYER, Kwave::INF_MPEG_MODEEXT, Kwave::INF_MPEG_VERSION, Kwave::INF_ORIGINAL, initInfo(), isMpeg(), m_info, mpegCopyrightedChanged(), mpegLayerChanged(), mpegOriginalChanged(), Kwave::toInt(), and Kwave::FileInfo::tracks().

Referenced by FileInfoDialog(), and info().

{
    // the whole tab is only enabled in mpeg mode
    InfoTab->setTabEnabled(2, isMpeg());

    /* MPEG layer */
    initInfo(lblMpegLayer,   cbMpegLayer,    Kwave::INF_MPEG_LAYER);
    int layer = m_info.get(Kwave::INF_MPEG_LAYER).toInt();
    if ((layer < 1) || (layer > 3))
        layer = 3; // default = layer III
    cbMpegLayer->setCurrentIndex(layer - 1);

    /* MPEG version */
    initInfo(lblMpegVersion, cbMpegVersion,  Kwave::INF_MPEG_VERSION);
    int ver = Kwave::toInt(
        (2.0 * QVariant(m_info.get(Kwave::INF_MPEG_VERSION)).toDouble()));
    // 1, 2, 2.5 -> 2, 4, 5
    if ((ver < 1) || (ver > 5)) ver = 4; // default = version 2
    if (ver > 3) ver++; // 2, 4, 6
    ver >>= 1;          // 1, 2, 3
    ver--;              // 0, 1, 2
    if ((ver < 0) || (ver > 2)) ver = 1; // default = version 2
    cbMpegVersion->setCurrentIndex(ver);

    /* Mode extension */
    initInfo(lblMpegModeExt, cbMpegModeExt, Kwave::INF_MPEG_MODEEXT);
    // only in "Joint Stereo" mode, then depends on Layer
    //
    // Layer I+II          |  Layer III
    //                     |  Intensity stereo MS Stereo
    //--------------------------------------------------
    // 0 - bands  4 to 31  |  off              off  -> 4
    // 1 - bands  8 to 31  |  on               off  -> 5
    // 2 - bands 12 to 31  |  off              on   -> 6
    // 3 - bands 16 to 31  |  on               on   -> 7

    int modeext = -1;
    if (m_info.contains(Kwave::INF_MPEG_MODEEXT))
        modeext = QVariant(m_info.get(Kwave::INF_MPEG_MODEEXT)).toInt();
    if (modeext < 0) {
        // find some reasonable default
        if (m_info.tracks() < 2) {
            // mono -> -1
        } else if (layer < 3) {
            // Layer I or II -> 0
            modeext = 0;
        } else {
            // Layer III -> 7
            modeext = 7;
        }
    }

    if ((modeext >= 0) && (modeext <= 3)) {
        cbMpegModeExt->setEnabled(true);
        cbMpegModeExt->setCurrentIndex(modeext);
        chkMpegIntensityStereo->setEnabled(false);
        chkMpegMSStereo->setEnabled(false);
    } else if ((modeext >= 4) && (modeext <= 7)) {
        cbMpegModeExt->setEnabled(false);
        cbMpegModeExt->setCurrentIndex(-1);
        chkMpegIntensityStereo->setEnabled(true);
        chkMpegIntensityStereo->setChecked(modeext & 0x01);
        chkMpegMSStereo->setEnabled(true);
        chkMpegMSStereo->setChecked(modeext & 0x02);
    } else {
        cbMpegModeExt->setEnabled(false);
        cbMpegModeExt->setCurrentIndex(-1);
        chkMpegIntensityStereo->setEnabled(false);
        chkMpegMSStereo->setEnabled(false);
    }

    /* Emphasis */
    initInfo(lblMpegEmphasis, cbMpegEmphasis, Kwave::INF_MPEG_EMPHASIS);
    int emphasis = QVariant(m_info.get(Kwave::INF_MPEG_EMPHASIS)).toInt();
    switch (emphasis) {
        case 0:  cbMpegEmphasis->setCurrentIndex(0); break;
        case 1:  cbMpegEmphasis->setCurrentIndex(1); break;
        case 3:  cbMpegEmphasis->setCurrentIndex(2); break;
        default: cbMpegEmphasis->setEnabled(false);  break;
    }

    /* Copyrighted */
    initInfo(lblMpegCopyrighted, chkMpegCopyrighted, Kwave::INF_COPYRIGHTED);
    bool copyrighted = QVariant(m_info.get(Kwave::INF_COPYRIGHTED)).toBool();
    chkMpegCopyrighted->setChecked(copyrighted);
    mpegCopyrightedChanged(copyrighted);

    /* Original */
    initInfo(lblMpegOriginal, chkMpegOriginal, Kwave::INF_ORIGINAL);
    bool original = QVariant(m_info.get(Kwave::INF_ORIGINAL)).toBool();
    chkMpegOriginal->setChecked(original);
    mpegOriginalChanged(original);

    mpegLayerChanged();
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupSourceTab()

void Kwave::FileInfoDialog::setupSourceTab ( )

private

initialize the "Source" tab

Definition at line 490 of file FileInfoDialog.cpp.

References Kwave::FileInfo::contains(), Kwave::FileInfo::get(), Kwave::INF_ALBUM, Kwave::INF_CD, Kwave::INF_CDS, Kwave::INF_ENGINEER, Kwave::INF_SOFTWARE, Kwave::INF_SOURCE, Kwave::INF_SOURCE_FORM, Kwave::INF_TECHNICAN, Kwave::INF_TRACK, Kwave::INF_TRACKS, initInfo(), initInfoText(), m_info, and Kwave::toInt().

Referenced by FileInfoDialog(), and info().

{
    /* source, source form */
    initInfoText(lblSource,     edSource,     Kwave::INF_SOURCE);
    initInfoText(lblSourceForm, edSourceForm, Kwave::INF_SOURCE_FORM);

    /* Album, CD and track */
    initInfoText(lblAlbum,      edAlbum,      Kwave::INF_ALBUM);
    initInfo(lblCD, sbCD, Kwave::INF_CD);
    int cd = (m_info.contains(Kwave::INF_CD)) ?
        QVariant(m_info.get(Kwave::INF_CD)).toInt() : 0;
    sbCD->setValue(cd);

    initInfo(Q_NULLPTR, sbCDs, Kwave::INF_CDS);
    int cds = (m_info.contains(Kwave::INF_CDS)) ?
        QVariant(m_info.get(Kwave::INF_CDS)).toInt() : 0;
    sbCDs->setValue(cds);

    initInfo(lblTrack, sbTrack, Kwave::INF_TRACK);
    int track = (m_info.contains(Kwave::INF_TRACK)) ?
        QVariant(m_info.get(Kwave::INF_TRACK)).toInt() : 0;
    sbTrack->setValue(track);

    initInfo(Q_NULLPTR, sbTracks, Kwave::INF_TRACKS);
    int tracks = (m_info.contains(Kwave::INF_TRACKS)) ?
        QVariant(m_info.get(Kwave::INF_TRACKS)).toInt() : 0;
    sbTracks->setValue(tracks);

    /* software, engineer, technician */
    initInfoText(lblSoftware,     edSoftware,     Kwave::INF_SOFTWARE);
    initInfoText(lblEngineer,     edEngineer,     Kwave::INF_ENGINEER);
    initInfoText(lblTechnican,    edTechnican,    Kwave::INF_TECHNICAN);

}

Here is the call graph for this function:

Here is the caller graph for this function:

tracksChanged

void Kwave::FileInfoDialog::tracksChanged ( int  tracks )

privateslot

updates the verbose description of the number of tracks

Definition at line 579 of file FileInfoDialog.cpp.

References _.

Referenced by info(), and setupFileInfoTab().

{
    switch (tracks) {
        case 1:
            lblChannelsVerbose->setText(i18n("(Mono)"));
            break;
        case 2:
            lblChannelsVerbose->setText(i18n("(Stereo)"));
            break;
        case 4:
            lblChannelsVerbose->setText(i18n("(Quadro)"));
            break;
        default:
            lblChannelsVerbose->setText(_(""));
            break;
    }
}

Here is the caller graph for this function:

updateAvailableCompressions

void Kwave::FileInfoDialog::updateAvailableCompressions ( )

privateslot

update the combo box with the list of available compressions, according to the current mime type

Definition at line 598 of file FileInfoDialog.cpp.

References Kwave::CodecBase::compressionTypes(), Kwave::CodecManager::encoder(), Kwave::CodecManager::encodingMimeTypes(), Kwave::FileInfo::get(), Kwave::INF_COMPRESSION, Kwave::INF_MIMETYPE, m_info, Kwave::Compression::name(), Kwave::Compression::NONE, Kwave::Compression::toInt(), and Kwave::toInt().

Referenced by info(), and setupCompressionTab().

{
    cbCompression->blockSignals(true);

    QList<Kwave::Compression::Type> supported_compressions;
    QString mime_type = m_info.get(Kwave::INF_MIMETYPE).toString();

    // switch by mime type:
    if (mime_type.length()) {
        // mime type is present -> offer only matching compressions
        Kwave::Encoder *encoder = Kwave::CodecManager::encoder(mime_type);
        if (encoder) supported_compressions = encoder->compressionTypes();
    } else {
        // no mime type -> allow all mimetypes suitable for encoding
        supported_compressions.append(Kwave::Compression::NONE);

        QStringList mime_types = Kwave::CodecManager::encodingMimeTypes();
        foreach (QString m, mime_types) {
            Kwave::Encoder *encoder = Kwave::CodecManager::encoder(m);
            if (!encoder) continue;
            QList<Kwave::Compression::Type> comps = encoder->compressionTypes();
            foreach (Kwave::Compression::Type c, comps)
                if (!supported_compressions.contains(c))
                    supported_compressions.append(c);
        }
    }

    // if nothing is supported, then use only "none"
    if (supported_compressions.isEmpty())
        supported_compressions.append(Kwave::Compression::NONE);

    // add supported compressions to the combo box
    cbCompression->clear();
    foreach (Kwave::Compression::Type c, supported_compressions) {
        Kwave::Compression compression(c);
        cbCompression->addItem(compression.name(), compression.toInt());
    }

    cbCompression->blockSignals(false);

    // update the selection of the compression type
    int c = QVariant(m_info.get(Kwave::INF_COMPRESSION)).toInt();
    int new_index = cbCompression->findData(c);

    // take the highest supported compression if changed to "invalid"
    // (assuming that the last entry in the list is the best one)
    if (new_index < 0)
        new_index = cbCompression->count() - 1;

    cbCompression->setCurrentIndex(new_index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_info

Kwave::FileInfo Kwave::FileInfoDialog::m_info

private

FileInfo to be edited

Definition at line 152 of file FileInfoDialog.h.

Referenced by accept(), acceptEdit(), compressionChanged(), info(), initInfo(), initInfoText(), mpegLayerChanged(), setupCompressionTab(), setupContentTab(), setupFileInfoTab(), setupMiscellaneousTab(), setupMpegTab(), setupSourceTab(), and updateAvailableCompressions().

---

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

• plugins/fileinfo/FileInfoDialog.h
• plugins/fileinfo/FileInfoDialog.cpp