#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.

87 {

88 }

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ export_location_t

◆ overwrite_policy_t

Constructor & Destructor Documentation

◆ K3BExportPlugin()

◆ ~K3BExportPlugin()

Member Function Documentation

◆ createFileName()

◆ detectBlockMetaData()

◆ interpreteParameters()

◆ knownPatterns()

◆ load()

◆ saveBlocks()

◆ saveDocumentData()

◆ saveGeneralDocumentData()

◆ saveK3BFile()

◆ scanBlocksToSave()

◆ setup()

◆ start()

Member Data Documentation

◆ m_block_info

◆ m_export_location

◆ m_overwrite_policy

◆ m_pattern

◆ m_selection_only

◆ m_url