Kwave::K3BExportPlugin Class Reference

#include <K3BExportPlugin.h>

Inheritance diagram for Kwave::K3BExportPlugin:

Collaboration diagram for Kwave::K3BExportPlugin:

Classes
struct	BlockInfo

Public Types
enum	export_location_t { EXPORT_TO_SAME_DIR = 0, EXPORT_TO_SUB_DIR = 1 }
enum	overwrite_policy_t { OVERWRITE_EXISTING_FILES = 0, USE_NEW_FILE_NAMES = 1 }

Public Member Functions
	K3BExportPlugin (QObject *parent, const QVariantList &args)
virtual	~K3BExportPlugin () Q_DECL_OVERRIDE
virtual void	load (QStringList &params) Q_DECL_OVERRIDE
virtual QStringList *	setup (QStringList &params) Q_DECL_OVERRIDE
virtual int	start (QStringList &params) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::Plugin
	Plugin (QObject *parent, const QVariantList &args)
virtual	~Plugin () Q_DECL_OVERRIDE
virtual QString	name () const
virtual QString	description () const
virtual QString	progressText ()
virtual bool	canClose () const
bool	isRunning () const
bool	shouldStop () const
virtual void	unload ()
virtual int	stop ()
virtual void	run (QStringList params)
Kwave::PluginManager &	manager () const
Kwave::SignalManager &	signalManager ()
QWidget *	parentWidget () const
QString	signalName ()
virtual sample_index_t	signalLength ()
virtual double	signalRate ()
virtual const QList< unsigned int >	selectedTracks ()
virtual sample_index_t	selection (QList< unsigned int > *tracks=Q_NULLPTR, sample_index_t *left=Q_NULLPTR, sample_index_t *right=Q_NULLPTR, bool expand_if_empty=false)
virtual void	selectRange (sample_index_t offset, sample_index_t length)
virtual void	migrateToActiveContext ()
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Static Public Member Functions
static QStringList	knownPatterns ()

Protected Member Functions
int	interpreteParameters (QStringList &params)
void	scanBlocksToSave (const QString &base, sample_index_t selection_left, sample_index_t selection_right)
QString	createFileName (const QString &pattern, unsigned int index)
bool	detectBlockMetaData (const QString &text, const QString &pattern, BlockInfo &block)
void	saveGeneralDocumentData (QDomElement *part)
void	saveDocumentData (QDomElement *docElem)
int	saveBlocks (bool selection_only, const QString &out_dir, const QString &out_pattern)
int	saveK3BFile (const QString &k3b_filename)
Protected Member Functions inherited from Kwave::Plugin
int	execute (QStringList &params)
void	emitCommand (const QString &command)
void	use ()
void	setPluginManager (Kwave::PluginManager *new_plugin_manager)
virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Private Attributes
QUrl	m_url
QString	m_pattern
bool	m_selection_only
export_location_t	m_export_location
overwrite_policy_t	m_overwrite_policy
QVector< BlockInfo >	m_block_info

Additional Inherited Members
Public Slots inherited from Kwave::Plugin
virtual void	setProgressDialogEnabled (bool enable)
virtual void	updateProgress (qreal progress)
virtual void	cancel ()
virtual void	close ()
void	release ()
Signals inherited from Kwave::Plugin
void	sigRunning (Kwave::Plugin *plugin)
void	sigDone (Kwave::Plugin *plugin)
void	sigClosed (Kwave::Plugin *p)
void	sigCommand (const QString &command)
void	setProgressText (const QString &text)

Detailed Description

Definition at line 36 of file K3BExportPlugin.h.

Member Enumeration Documentation

export_location_t

enum Kwave::K3BExportPlugin::export_location_t

Enumerator
EXPORT_TO_SAME_DIR
EXPORT_TO_SUB_DIR

Definition at line 41 of file K3BExportPlugin.h.

                     {
            EXPORT_TO_SAME_DIR = 0,
            EXPORT_TO_SUB_DIR  = 1
        } export_location_t ;

overwrite_policy_t

enum Kwave::K3BExportPlugin::overwrite_policy_t

Enumerator
OVERWRITE_EXISTING_FILES
USE_NEW_FILE_NAMES

Definition at line 46 of file K3BExportPlugin.h.

                     {
            OVERWRITE_EXISTING_FILES = 0,
            USE_NEW_FILE_NAMES       = 1
        } overwrite_policy_t;

Constructor & Destructor Documentation

K3BExportPlugin()

Kwave::K3BExportPlugin::K3BExportPlugin	(	QObject *	parent,
		const QVariantList &	args
	)

Constructor

Parameters

parent	reference to our plugin manager
args	argument list [unused]

Definition at line 73 of file K3BExportPlugin.cpp.

    :Kwave::Plugin(parent, args),
     m_url(),
     m_pattern(),
     m_selection_only(false),
     m_export_location(EXPORT_TO_SUB_DIR),
     m_overwrite_policy(USE_NEW_FILE_NAMES),
     m_block_info()
{
}

~K3BExportPlugin()

Kwave::K3BExportPlugin::~K3BExportPlugin ( )

virtual

Destructor

Definition at line 86 of file K3BExportPlugin.cpp.

{
}

Member Function Documentation

createFileName()

QString Kwave::K3BExportPlugin::createFileName ( const QString &  pattern, unsigned int  index  )

protected

create a filename (with extension) out of a given name pattern and index

Parameters

pattern	the pattern for creating the filename
index	the index of the current file

Returns

the name of the file

Definition at line 196 of file K3BExportPlugin.cpp.

References _, Kwave::Plugin::name(), OUTFILE_DIGITS, OUTFILE_PATTERN, and OUTFILE_SUFFIX.

Referenced by saveBlocks(), and start().

{
    QString name = pattern;
    QString num  = _("%1").arg(index, OUTFILE_DIGITS, 10, QLatin1Char('0'));
    name.replace(OUTFILE_PATTERN, num);
    name += OUTFILE_SUFFIX;
    return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectBlockMetaData()

bool Kwave::K3BExportPlugin::detectBlockMetaData ( const QString &  text, const QString &  pattern, BlockInfo &  block  )

protected

detects the meta data of a block from splitting the description text of a label

Parameters

text	the description of a label
pattern	a pattern describing the format of the text
block	a BlockInfo structure that receives artist and title

Returns

true if the pattern did match, false otherwise

Definition at line 207 of file K3BExportPlugin.cpp.

References _, Kwave::Parser::escape(), knownPatterns(), Kwave::K3BExportPlugin::BlockInfo::m_artist, and Kwave::K3BExportPlugin::BlockInfo::m_title.

Referenced by scanBlocksToSave().

{
    if (!pattern.length()) {
        // auto detect -> try all known patterns
        foreach (const QString &p, knownPatterns())
            if (detectBlockMetaData(text, p, block))
                return true;
        return false;
    }

    // list of placeholders and pointers to the resulting strings
    QMap <QString, QString *> map_patterns;
    map_patterns.insert(_("[%artist]"), &block.m_artist);
    map_patterns.insert(_("[%title]"),  &block.m_title);

    // try to find the placeholders within the pattern
    // NOTE: we use a map because it will automatically be sorted (by pos)
    QString pattern_esc = Kwave::Parser::escape(pattern);
    QMap <int, QString *>   map_result;
    foreach (const QString &placeholder, map_patterns.keys()) {
        QString placeholder_esc;
        placeholder_esc = Kwave::Parser::escape(placeholder);
        if (pattern_esc.contains(placeholder_esc)) {
            const QString rx_string = _("(.+)");
            int pos = pattern.indexOf(placeholder);
            pattern_esc.replace(placeholder_esc, rx_string);
            map_result.insert(pos, map_patterns[placeholder]);
        }
    }
    if (map_result.isEmpty())
        return false; // no placeholders found in the patterns

    // relax the pattern: turn single whitespace to one or more whitespaces
    pattern_esc.replace(QRegExp(_("(\\\\\\s)+")), _("\\s+"));

    // try to match the pattern on the given text
    QRegExp rx(pattern_esc, Qt::CaseInsensitive);
    if (!rx.exactMatch(text.trimmed()))
        return false; // does not match :-(

    // we found a match
    // -> now map the results into the corresponding result strings
    for (int index = 0; index < map_result.count(); ++index) {
        QString value = rx.cap(index + 1).trimmed();
        if (value.length()) {
            QString *result = map_result[map_result.keys()[index]];
            if (result) *result = value;
        }
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

interpreteParameters()

int Kwave::K3BExportPlugin::interpreteParameters ( QStringList &  params )

protected

reads values from the parameter list

Definition at line 91 of file K3BExportPlugin.cpp.

References EXPORT_TO_SAME_DIR, EXPORT_TO_SUB_DIR, m_export_location, m_overwrite_policy, m_pattern, m_selection_only, m_url, OVERWRITE_EXISTING_FILES, Kwave::Parser::unescape(), and USE_NEW_FILE_NAMES.

Referenced by setup(), and start().

{
    bool ok;
    QString param;

    // evaluate the parameter list
    if (params.count() != 5)
        return -EINVAL;

    // the selected URL
    m_url = QUrl::fromUserInput(Kwave::Parser::unescape(params[0]));
    if (!m_url.isValid()) return -EINVAL;

    // label pattern
    m_pattern = Kwave::Parser::unescape(params[1]);

    // selection only
    param = params[2];
    int v = param.toInt(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;
    m_selection_only = (v != 0);

    // export location
    param = params[3];
    int where = param.toInt(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;
    if ((where != EXPORT_TO_SAME_DIR) &&
        (where != EXPORT_TO_SUB_DIR)) return -EINVAL;
    m_export_location = static_cast<export_location_t>(where);

    // overwrite policy
    param = params[4];
    int overwrite = param.toInt(&ok);
    Q_ASSERT(ok);
    if (!ok) return -EINVAL;
    if ((overwrite != OVERWRITE_EXISTING_FILES) &&
        (overwrite != USE_NEW_FILE_NAMES)) return -EINVAL;
    m_overwrite_policy = static_cast<overwrite_policy_t>(overwrite);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

knownPatterns()

QStringList Kwave::K3BExportPlugin::knownPatterns ( )

static

returns a list of all known detection patterns

Definition at line 777 of file K3BExportPlugin.cpp.

References _.

Referenced by detectBlockMetaData(), and Kwave::K3BExportWidget::K3BExportWidget().

{
    // list of all known detection patterns
    QStringList patterns;
    patterns << _("[%title] ([%artist])");
    patterns << _("[%title], [%artist]");
    patterns << _("[%artist]: [%title]");
    patterns << _("[%artist] - [%title]");
    return patterns;
}

Here is the caller graph for this function:

load()

void Kwave::K3BExportPlugin::load ( QStringList &  params )

virtual

See also

Kwave::Plugin::load()

Reimplemented from Kwave::Plugin.

Definition at line 265 of file K3BExportPlugin.cpp.

References _, and Kwave::Plugin::emitCommand().

{
    Q_UNUSED(params);

    QString menu_path = _("File/Save/%1").arg(_(I18N_NOOP2(
        "menu: /File/Save/Export to K3b Project...",
                         "Export to K3b Project..."
    )));
    emitCommand(_("menu(plugin:setup(export_k3b),%1%2)").arg(
        menu_path).arg(_("/#group(@SIGNAL)")));
    emitCommand(_("menu(plugin:setup(export_k3b),%1%2)").arg(
        menu_path).arg(_("/#icon(application-x-k3b)")));
}

Here is the call graph for this function:

saveBlocks()

int Kwave::K3BExportPlugin::saveBlocks ( bool  selection_only, const QString &  out_dir, const QString &  out_pattern  )

protected

save the blocks through the saveblocks plugin

Parameters

selection_only	if true, save only the selection
out_dir	output directory for saving the blocks
out_pattern	the pattern for creating the block filenames

Returns

zero if succeeded, or error code if failed

Definition at line 686 of file K3BExportPlugin.cpp.

References _, createFileName(), Kwave::CodecManager::encoder(), Kwave::Parser::escape(), Kwave::Parser::escapeForFileName(), Kwave::PluginManager::executePlugin(), m_overwrite_policy, m_url, Kwave::Plugin::manager(), Kwave::SignalManager::metaData(), Kwave::CodecManager::mimeTypeOf(), Kwave::FileInfo::properties(), Kwave::MetaDataList::replace(), Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), Kwave::Plugin::signalManager(), Kwave::Encoder::unsupportedProperties(), and USE_NEW_FILE_NAMES.

Referenced by start().

{
    QString first_filename = Kwave::Parser::escapeForFileName(
        QUrl::fromLocalFile(createFileName(out_pattern, 1)).toString());

    // remember the original file info remove all unsupported/ properties,
    // to avoid that the saveblocks plugin complains...
    const Kwave::FileInfo orig_file_info(signalManager().metaData());
    Kwave::FileInfo file_info(orig_file_info);
    QList<Kwave::FileProperty> unsupported_properties;
    {
        QString mimetype = Kwave::CodecManager::mimeTypeOf(m_url);
        Kwave::Encoder *encoder = Kwave::CodecManager::encoder(mimetype);
        if (encoder) {
            unsupported_properties = encoder->unsupportedProperties(
                file_info.properties().keys());
            delete encoder;
        }
        if (!unsupported_properties.isEmpty()) {
            foreach (const Kwave::FileProperty &p, unsupported_properties) {
                file_info.set(p, QVariant());
            }
        }
    }

    // make sure that the file uses 16 bits/sample only
    file_info.setBits(16);

    signalManager().metaData().replace(Kwave::MetaDataList(file_info));

    // call the saveblocks plugin and let it do the main work of exporting
    // the *.wav files with all the tracks...

    QStringList params;
    params << out_dir + QDir::separator() + first_filename;
    params << Kwave::Parser::escape(out_pattern);
    params << ((m_overwrite_policy == USE_NEW_FILE_NAMES) ? _("0") : _("1"));
    params << (selection_only ? _("1") : _("0"));
    int result = manager().executePlugin(_("saveblocks"), &params);

    // restore the original file info
    signalManager().metaData().replace(Kwave::MetaDataList(orig_file_info));

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveDocumentData()

void Kwave::K3BExportPlugin::saveDocumentData ( QDomElement *  docElem )

protected

save the K3b project document data

Definition at line 410 of file K3BExportPlugin.cpp.

References _, Kwave::FileInfo::get(), GET_INF, Kwave::INF_AUTHOR, Kwave::INF_CD, Kwave::INF_COMMENTS, Kwave::INF_COPYRIGHTED, Kwave::INF_ISRC, Kwave::INF_NAME, Kwave::INF_ORGANIZATION, Kwave::INF_PERFORMER, Kwave::INF_TECHNICAN, Kwave::K3BExportPlugin::BlockInfo::m_artist, m_block_info, Kwave::K3BExportPlugin::BlockInfo::m_filename, Kwave::K3BExportPlugin::BlockInfo::m_title, saveGeneralDocumentData(), and Kwave::Plugin::signalManager().

Referenced by saveK3BFile().

{
    #define GET_INF(inf) doc.createTextNode(info.get(inf).toString())

    const Kwave::FileInfo info(signalManager().metaData());

    QDomDocument doc = docElem->ownerDocument();
    saveGeneralDocumentData(docElem);

    // add normalize
    QDomElement normalizeElem = doc.createElement(_("normalize"));
    normalizeElem.appendChild(doc.createTextNode(_("no")));
    docElem->appendChild(normalizeElem);

    // add hide track
    QDomElement hideFirstTrackElem = doc.createElement(_("hide_first_track"));
    hideFirstTrackElem.appendChild(doc.createTextNode(_("no")));
    docElem->appendChild(hideFirstTrackElem);

    // save the audio cd ripping settings
    // paranoia mode, read retries, and ignore read errors
    // ------------------------------------------------------------
    QDomElement ripMain = doc.createElement(_("audio_ripping"));
    docElem->appendChild(ripMain);

    QDomElement ripElem = doc.createElement(_("paranoia_mode"));
    ripElem.appendChild(doc.createTextNode(_("0")));
    ripMain.appendChild(ripElem);

    ripElem = doc.createElement(_("read_retries"));
    ripElem.appendChild(doc.createTextNode(_("0")));
    ripMain.appendChild(ripElem);

    ripElem = doc.createElement(_("ignore_read_errors"));
    ripElem.appendChild(doc.createTextNode(_("no")));
    ripMain.appendChild(ripElem);
    // ------------------------------------------------------------

    // save disc cd-text
    // -------------------------------------------------------------
    QDomElement cdTextMain = doc.createElement(_("cd-text"));
    cdTextMain.setAttribute(_("activated"), _("yes"));

    QDomElement cdTextElem = doc.createElement(_("title"));
    cdTextElem.appendChild(GET_INF(INF_NAME));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("artist"));
    cdTextElem.appendChild(GET_INF(INF_AUTHOR));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("arranger"));
    cdTextElem.appendChild(GET_INF(INF_TECHNICAN));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("songwriter"));
    cdTextElem.appendChild(GET_INF(INF_PERFORMER));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("composer"));
    cdTextElem.appendChild(GET_INF(INF_ORGANIZATION));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("disc_id"));
    cdTextElem.appendChild(GET_INF(INF_CD));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("upc_ean"));
    cdTextElem.appendChild(GET_INF(INF_ISRC));
    cdTextMain.appendChild(cdTextElem);

    cdTextElem = doc.createElement(_("message"));
    cdTextElem.appendChild(GET_INF(INF_COMMENTS));
    cdTextMain.appendChild(cdTextElem);

    docElem->appendChild( cdTextMain );
    // -------------------------------------------------------------

    // save the tracks
    // -------------------------------------------------------------
    QDomElement contentsElem = doc.createElement(_("contents"));

    unsigned int index = 1;
    foreach (const Kwave::K3BExportPlugin::BlockInfo &block, m_block_info) {
        QString title      = block.m_title;
        QString artist     = block.m_artist;
        QString songwriter = QString();
        QString url        = block.m_filename;

        QDomElement trackElem = doc.createElement(_("track"));

        // add sources
        QDomElement sourcesParent = doc.createElement(_("sources"));
        QDomElement sourceElem = doc.createElement(_("file"));
        sourceElem.setAttribute(_("url"), url);
        sourceElem.setAttribute(_("start_offset"), _("00:00:00"));
        sourceElem.setAttribute(_("end_offset"), _("00:00:00"));
        sourcesParent.appendChild(sourceElem);
        trackElem.appendChild(sourcesParent);

        // index 0
        QDomElement index0Elem = doc.createElement(_("index0"));
        index0Elem.appendChild(doc.createTextNode(QString::number(index)));
        trackElem.appendChild(index0Elem);

        // add cd-text
        cdTextMain = doc.createElement(_("cd-text"));
        cdTextElem = doc.createElement(_("title"));
        cdTextElem.appendChild(doc.createTextNode(title));
        cdTextMain.appendChild(cdTextElem);

        cdTextElem = doc.createElement(_("artist"));
        cdTextElem.appendChild(doc.createTextNode(artist));
        cdTextMain.appendChild(cdTextElem);

        cdTextElem = doc.createElement(_("arranger"));
        cdTextElem.appendChild(GET_INF(INF_TECHNICAN));
        cdTextMain.appendChild(cdTextElem);

        cdTextElem = doc.createElement(_("songwriter"));
        cdTextElem.appendChild(doc.createTextNode(songwriter));
        cdTextMain.appendChild(cdTextElem );

        cdTextElem = doc.createElement(_("composer"));
        cdTextElem.appendChild(GET_INF(INF_ORGANIZATION));
        cdTextMain.appendChild(cdTextElem);

        cdTextElem = doc.createElement(_("isrc"));
        cdTextElem.appendChild(GET_INF(INF_ISRC));
        cdTextMain.appendChild(cdTextElem);

        cdTextElem = doc.createElement(_("message"));
        cdTextElem.appendChild(GET_INF(INF_COMMENTS));
        cdTextMain.appendChild(cdTextElem);

        trackElem.appendChild(cdTextMain);

        // add copy protection
        QDomElement copyElem = doc.createElement(_("copy_protection"));
        copyElem.appendChild(doc.createTextNode(
            info.get(INF_COPYRIGHTED).toInt() ? _("yes") : _("no")
        ));
        trackElem.appendChild(copyElem);

        // add pre emphasis
        copyElem = doc.createElement(_("pre_emphasis"));
        copyElem.appendChild(doc.createTextNode(_("no")));
        trackElem.appendChild(copyElem);

        contentsElem.appendChild(trackElem);
        index++;
    }
    // -------------------------------------------------------------

    docElem->appendChild(contentsElem);
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveGeneralDocumentData()

void Kwave::K3BExportPlugin::saveGeneralDocumentData ( QDomElement *  part )

protected

save the "general" section

Definition at line 374 of file K3BExportPlugin.cpp.

References _.

Referenced by saveDocumentData().

{
    QDomDocument doc = part->ownerDocument();
    QDomElement mainElem = doc.createElement(_("general"));

    QDomElement propElem = doc.createElement(_("writing_mode"));
    propElem.appendChild(doc.createTextNode(_("auto")));
    mainElem.appendChild(propElem);

    propElem = doc.createElement(_("dummy"));
    propElem.setAttribute(_("activated"), _("no"));
    mainElem.appendChild(propElem);

    propElem = doc.createElement(_("on_the_fly"));
    propElem.setAttribute(_("activated"), _("true"));
    mainElem.appendChild(propElem);

    propElem = doc.createElement(_("only_create_images"));
    propElem.setAttribute(_("activated"), _("no"));
    mainElem.appendChild(propElem);

    propElem = doc.createElement(_("remove_images"));
    propElem.setAttribute(_("activated"), _("no"));
    mainElem.appendChild(propElem);

    part->appendChild( mainElem );
}

Here is the caller graph for this function:

saveK3BFile()

int Kwave::K3BExportPlugin::saveK3BFile ( const QString &  k3b_filename )

protected

save the *.k3b file

Parameters

k3b_filename

path to the *.k3b file

Returns

zero if succeeded, or error code if failed

Definition at line 735 of file K3BExportPlugin.cpp.

References _, K3B_PROJECT_MIME_TYPE, and saveDocumentData().

Referenced by start().

{
    // create the K3B file
    KZip zip(k3b_filename);

    bool ok = zip.open(QIODevice::WriteOnly);
    if (!ok) return -EIO;

    // write the mime type
    QByteArray app_type(K3B_PROJECT_MIME_TYPE);
    zip.setCompression(KZip::NoCompression);
    zip.setExtraField(KZip::NoExtraField);
    zip.writeFile(_("mimetype"), app_type);

    // export file global data
    QByteArray xml;
    QBuffer out(&xml);
    out.open(QIODevice::WriteOnly);

    // save the data in the document
    QDomDocument xmlDoc(_("k3b_audio_project"));

    xmlDoc.appendChild(xmlDoc.createProcessingInstruction(
        _("xml"), _("version=\"1.0\" encoding=\"UTF-8\"")
    ));
    QDomElement docElem = xmlDoc.createElement(_("k3b_audio_project"));
    xmlDoc.appendChild(docElem);
    saveDocumentData(&docElem);
    QTextStream xmlStream(&out);
    xmlDoc.save(xmlStream, 0);

    out.close();

    zip.setCompression(KZip::NoCompression);
    zip.setExtraField(KZip::NoExtraField);
    zip.writeFile(_("maindata.xml"), xml.data());
    zip.close();

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

scanBlocksToSave()

void Kwave::K3BExportPlugin::scanBlocksToSave ( const QString &  base, sample_index_t  selection_left, sample_index_t  selection_right  )

protected

determines the blocks which should be saved, including start position, length and title.

Parameters

base	the base name, without indices, extension etc...
selection_left	index of the first sample
selection_right	index of the last sample

Definition at line 136 of file K3BExportPlugin.cpp.

References detectBlockMetaData(), Kwave::FileInfo::get(), Kwave::INF_AUTHOR, Kwave::INF_NAME, Kwave::MetaData::isNull(), Kwave::K3BExportPlugin::BlockInfo::m_artist, m_block_info, Kwave::K3BExportPlugin::BlockInfo::m_filename, Kwave::K3BExportPlugin::BlockInfo::m_index, Kwave::K3BExportPlugin::BlockInfo::m_length, m_pattern, Kwave::K3BExportPlugin::BlockInfo::m_start, Kwave::K3BExportPlugin::BlockInfo::m_title, Kwave::Label::name(), Kwave::Label::pos(), Kwave::Plugin::signalLength(), and Kwave::Plugin::signalManager().

Referenced by start().

{
    sample_index_t block_start;
    sample_index_t block_end = 0;

    Kwave::LabelList labels(signalManager().metaData());
    Kwave::LabelListIterator it(labels);
    Kwave::Label label = (it.hasNext()) ? it.next() : Kwave::Label();

    // get the title of the whole file, in case that a block does not have
    // an own title
    FileInfo info(signalManager().metaData());
    QString file_title  = info.get(INF_NAME).toString();
    QString file_artist = info.get(INF_AUTHOR).toString();

    // fallback: if there is no INF_NAME either, fall back to the file
    //           name as last resort
    if (!file_title.length()) file_title = base;

    m_block_info.clear();
    QString prev_title = file_title;
    for (unsigned int index = 1; ; ++index) {
        block_start = block_end;
        block_end   = (label.isNull()) ? signalLength() : label.pos();

        QString block_title = (!label.isNull() && label.name().length()) ?
            label.name() : prev_title;

        if ((block_end > selection_left) && (block_start <= selection_right)) {
            BlockInfo block;

            // init and set reasonable defaults
            block.m_index    = index;
            block.m_filename = QString();
            block.m_start    = block_start;
            block.m_length   = block_end - block_start;
            block.m_title    = prev_title;
            block.m_artist   = file_artist;

            // detect title and artist
            detectBlockMetaData(prev_title, m_pattern, block);
            m_block_info.append(block);

            prev_title = block_title;

//          qDebug("#%d [%llu...%llu]", index, block_start, block_end);
//          qDebug("    title  = '%s'", DBG(block.m_title));
//          qDebug("    artist = '%s'", DBG(block.m_artist));
        } else {
            prev_title = block_title;
        }

        if (label.isNull()) break;
        label = (it.hasNext()) ? it.next() : Kwave::Label();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup()

QStringList * Kwave::K3BExportPlugin::setup ( QStringList &  params )

virtual

Normally this method is used to set up all necessary parameters for executing the plugin. This plugin uses it for performing actions in the context of the GUI thread.

Parameters

params

some parameters

Returns

string list with parameters or null pointer

Reimplemented from Kwave::Plugin.

Definition at line 280 of file K3BExportPlugin.cpp.

References _, Kwave::Plugin::description(), Kwave::Plugin::emitCommand(), Kwave::Parser::escape(), interpreteParameters(), K3B_FILE_SUFFIX, m_export_location, m_overwrite_policy, m_pattern, m_selection_only, Kwave::Plugin::name(), Kwave::Plugin::parentWidget(), Kwave::Plugin::selection(), Kwave::Plugin::signalLength(), and Kwave::Plugin::signalName().

{
    // try to interpret the previous parameters
    interpreteParameters(params);

    sample_index_t selection_left  = 0;
    sample_index_t selection_right = 0;
    selection(Q_NULLPTR, &selection_left, &selection_right, false);

    // enable the "selection only" checkbox only if there is something
    // selected but not everything
    bool selected_something = (selection_left != selection_right);
    bool selected_all = ((selection_left == 0) &&
        (selection_right + 1 >= signalLength()));
    bool enable_selection_only = selected_something && !selected_all;

    // show a "File / Save As..." dialog for the *.k3b file
    QPointer<Kwave::K3BExportDialog> dialog =
        new(std::nothrow) Kwave::K3BExportDialog(
            _("kfiledialog:///kwave_export_k3b"),
            K3B_FILE_SUFFIX + _("|") + i18nc(
                "file type filter when exporting to K3b",
                "K3b project file (*.k3b)"
            ),
            parentWidget(),
            QUrl::fromUserInput(signalName()),
            _("*.k3b"),
            m_pattern,
            m_selection_only,
            enable_selection_only,
            m_export_location,
            m_overwrite_policy
        );
    if (!dialog) return Q_NULLPTR;

    dialog->setWindowTitle(description());
    if (dialog->exec() != QDialog::Accepted) {
        delete dialog;
        return Q_NULLPTR;
    }

    QStringList *list = new(std::nothrow) QStringList();
    Q_ASSERT(list);
    if (!list) {
        delete dialog;
        return Q_NULLPTR;
    }

    // user has pressed "OK"
    QUrl url = dialog->selectedUrl();
    if (url.isEmpty()) {
        delete dialog;
        delete list;
        return Q_NULLPTR;
    }

    QString name = url.path();
    QFileInfo path(name);

    // add the correct extension if necessary
    if (path.suffix() != K3B_FILE_SUFFIX.mid(2))
        url.setPath(name + K3B_FILE_SUFFIX.mid(1));

    name                 = Kwave::Parser::escape(url.toString());
    QString pattern      = Kwave::Parser::escape(dialog->pattern());
    int export_location  = static_cast<int>(dialog->exportLocation());
    int overwrite_policy = static_cast<int>(dialog->overwritePolicy());
    bool selection_only  = (enable_selection_only) ?
        dialog->selectionOnly() : m_selection_only;

    *list << name;                              // url
    *list << pattern;                           // pattern
    *list << QString::number(selection_only);   // selection only
    *list << QString::number(export_location);  // export location
    *list << QString::number(overwrite_policy); // overwrite policy

    emitCommand(_("plugin:execute(export_k3b,") +
        name + _(",") + pattern + _(",")  +
        QString::number(selection_only)   + _(",") +
        QString::number(export_location)  + _(",") +
        QString::number(overwrite_policy) + _(")")
    );

    if (dialog) delete dialog;
    return list;
}

Here is the call graph for this function:

start()

int Kwave::K3BExportPlugin::start ( QStringList &  params )

virtual

Saves the K3b project file, using the settings made in "setup()"

See also

Kwave::Plugin::start()

Reimplemented from Kwave::Plugin.

Definition at line 568 of file K3BExportPlugin.cpp.

References _, createFileName(), DBG, EXPORT_TO_SUB_DIR, interpreteParameters(), m_block_info, m_export_location, m_overwrite_policy, m_selection_only, m_url, Kwave::Plugin::name(), OUTFILE_PATTERN, OUTFILE_SUFFIX, Kwave::Plugin::parentWidget(), Kwave::MessageBox::questionYesNo(), saveBlocks(), saveK3BFile(), scanBlocksToSave(), Kwave::Plugin::selection(), Kwave::Plugin::signalLength(), Kwave::MessageBox::sorry(), and USE_NEW_FILE_NAMES.

{
    qDebug("K3BExportPlugin::start()");

    // interpret the parameters
    int result = interpreteParameters(params);
    if (result) return result;

    // check the output file
    if (!m_url.isLocalFile())
        return -EINVAL; // sorry, KZip supports only local files

    // determine output directory and file name pattern
    QString   k3b_filename = m_url.path();
    QFileInfo fi(k3b_filename);
    QString   base = fi.completeBaseName();
    QString   out_dir;
    QString   out_pattern;
    if (m_export_location == Kwave::K3BExportPlugin::EXPORT_TO_SUB_DIR) {
        // export to a subdir with the name "<filename>.dir"
        out_dir     = fi.absolutePath() + QDir::separator() + base + _(".dir");
        out_pattern = _("track-") + OUTFILE_PATTERN;
    } else {
        // use the same directory as the *.k3b file
        out_dir     = fi.absolutePath();
        out_pattern = base + _("-track-") + OUTFILE_PATTERN;
    }
    qDebug("out_dir     = '%s'", DBG(out_dir));
    qDebug("out_pattern = '%s'", DBG(out_pattern));

    // determine the selection settings
    sample_index_t selection_left  = 0;
    sample_index_t selection_right = 0;
    QList<unsigned int> tracks;
    selection(&tracks, &selection_left, &selection_right, false);

    // check: only mono or stereo files are supported
    if ((tracks.count() != 1) && (tracks.count() != 2)) {
        qWarning("sorry, K3b can not handle %u tracks", tracks.count());
        Kwave::MessageBox::sorry(parentWidget(), i18n(
            "Only mono and stereo files can be used for an audio CD. "
            "You can either deselect some channels or export the file "
            "in a different file format that supports mono and stereo "
            "only (for example FLAC) and then try again."
        ));
        return -EINVAL;
    }

    bool selected_something = (selection_left != selection_right);
    bool selected_all = ( (selection_left == 0) &&
                          ((selection_right + 1) >= signalLength()) );
    bool enable_selection_only = selected_something && !selected_all;
    bool selection_only = enable_selection_only && m_selection_only;
    if (!selection_only) {
        selection_left  = 0;
        selection_right = signalLength() - 1;
    }

    // create a list of blocks to save, but not yet the output file names
    scanBlocksToSave(base, selection_left, selection_right);
    unsigned int count = m_block_info.count();
    if (!count)
        return -EINVAL;

    // find the start index of the file numbering
    unsigned int first = 1;
    if (m_overwrite_policy == Kwave::K3BExportPlugin::USE_NEW_FILE_NAMES) {
        // use new files, find out the highest existing index
        QString pat = out_pattern;
        pat.replace(OUTFILE_PATTERN, _("*"));
        pat += OUTFILE_SUFFIX;

        QDir dir(out_dir, pat);
        QStringList files;
        files = dir.entryList();

        for (unsigned int i = first; i < (first + count); ++i) {
            QString name = createFileName(out_pattern, i);
            QRegExp rx(_("^(") + name + _(")$"), Qt::CaseInsensitive);
            QStringList matches = files.filter(rx);
            if (matches.count() > 0) first = i + 1;
        }
        qDebug("found first usable index -> %d", first);
    } else {
        // overwrite mode, always start at 1
    }

    // create the complete file names
    for (unsigned int i = 0; i < count; ++i) {
        m_block_info[i].m_filename = out_dir + QDir::separator() +
            createFileName(out_pattern, first + i);
    }

    result = saveBlocks(selection_only, out_dir, out_pattern);
    if (result != 0)
        return result; // aborted or failed -> do not create a k3b file

    result = saveK3BFile(k3b_filename);
    if (result != 0)
        return result; // aborted or failed -> do not ask about starting k3b

    if (Kwave::MessageBox::questionYesNo(parentWidget(), i18n(
        "A K3b project file has been created and audio files have "
        "been exported.\n"
        "Should I start K3b and open the audio CD project now?"
    )) == KMessageBox::Yes) {
        // call k3b and pass the project file name (must be full path)
        QStringList args;
        args << k3b_filename;
        if (!QProcess::startDetached(_("k3b"), args)) {
            return -EIO;
        }
    }

    return result;
}

Here is the call graph for this function:

Member Data Documentation

m_block_info

QVector<BlockInfo> Kwave::K3BExportPlugin::m_block_info

private

list of all blocks to save

Definition at line 171 of file K3BExportPlugin.h.

Referenced by saveDocumentData(), scanBlocksToSave(), and start().

m_export_location

export_location_t Kwave::K3BExportPlugin::m_export_location

private

where to export the files of the tracks, subdir, same dir, ...

Definition at line 165 of file K3BExportPlugin.h.

Referenced by interpreteParameters(), setup(), and start().

m_overwrite_policy

overwrite_policy_t Kwave::K3BExportPlugin::m_overwrite_policy

private

overwrite existing files or create a new file name

Definition at line 168 of file K3BExportPlugin.h.

Referenced by interpreteParameters(), saveBlocks(), setup(), and start().

m_pattern

QString Kwave::K3BExportPlugin::m_pattern

private

pattern for detecting title and artist

Definition at line 159 of file K3BExportPlugin.h.

Referenced by interpreteParameters(), scanBlocksToSave(), and setup().

m_selection_only

bool Kwave::K3BExportPlugin::m_selection_only

private

if true, export only the selected range

Definition at line 162 of file K3BExportPlugin.h.

Referenced by interpreteParameters(), setup(), and start().

m_url

QUrl Kwave::K3BExportPlugin::m_url

private

the URL of the project file

Definition at line 156 of file K3BExportPlugin.h.

Referenced by interpreteParameters(), saveBlocks(), and start().

---

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

• plugins/export_k3b/K3BExportPlugin.h
• plugins/export_k3b/K3BExportPlugin.cpp