604 lines
21 KiB
C++
604 lines
21 KiB
C++
#include <algorithm>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <QWidget>
|
|
#include <QScrollArea>
|
|
#include <QEvent>
|
|
#include <QKeyEvent>
|
|
#include <QShortcut>
|
|
#include <QVBoxLayout>
|
|
#include <QTableWidget>
|
|
#include <QTableWidgetItem>
|
|
#include <QFile>
|
|
#include <QXmlStreamReader>
|
|
#include <QMessageBox>
|
|
#include "cuetracklistwidget.h"
|
|
|
|
CueTrackListWidget::CueTrackListWidget(QWidget *parent)
|
|
{
|
|
layout = new QVBoxLayout(this);
|
|
tableWidget = new QTableWidget();
|
|
tableWidget->setSortingEnabled(false);
|
|
layout->addWidget(tableWidget);
|
|
setLayout(layout);
|
|
QShortcut *shortcut_up = new QShortcut(QKeySequence("Up"), parent);
|
|
QObject::connect(shortcut_up, SIGNAL(activated()), this, SLOT(key_up()));
|
|
QShortcut *shortcut_down = new QShortcut(QKeySequence("Down"), parent);
|
|
QObject::connect(shortcut_down, SIGNAL(activated()), this, SLOT(key_down()));
|
|
QShortcut *shortcut_copy = new QShortcut(QKeySequence("Ctrl+C"), parent);
|
|
QObject::connect(shortcut_copy, SIGNAL(activated()), this, SLOT(copyCueTrack()));
|
|
QShortcut *shortcut_cut = new QShortcut(QKeySequence("Ctrl+X"), parent);
|
|
QObject::connect(shortcut_cut, SIGNAL(activated()), this, SLOT(cutCueTrack()));
|
|
QShortcut *shortcut_paste = new QShortcut(QKeySequence("Ctrl+V"), parent);
|
|
QObject::connect(shortcut_paste, SIGNAL(activated()), this, SLOT(pasteCueTrack()));
|
|
tableWidget->installEventFilter(this);
|
|
QShortcut *shortcut_delete = new QShortcut(QKeySequence("Delete"), parent);
|
|
QObject::connect(shortcut_delete, SIGNAL(activated()), this, SLOT(deleteCueTrack()));
|
|
QShortcut *shortcut_insert = new QShortcut(QKeySequence("Insert"), parent);
|
|
QObject::connect(shortcut_insert, SIGNAL(activated()), this, SLOT(createNewCueTrack()));
|
|
QShortcut *shortcut_edit = new QShortcut(QKeySequence("e"), parent);
|
|
QObject::connect(shortcut_edit, SIGNAL(activated()), this, SLOT(editCueTrack()));
|
|
}
|
|
|
|
void CueTrackListWidget::addCueTrack(CueTrack* cue) {
|
|
cueTracks.push_back(cue);
|
|
displayCueTrackInTable(cue, -1);
|
|
m_size++;
|
|
}
|
|
|
|
void CueTrackListWidget::removeCueTrack(int index) {
|
|
if (index >= m_size) return;
|
|
cueTracks.erase(cueTracks.begin() + index);
|
|
tableWidget->removeRow(index);
|
|
m_size--;
|
|
}
|
|
|
|
CueTrack* CueTrackListWidget::getTrackAtIndex(int index) {
|
|
if (index < m_size) {
|
|
return cueTracks.at(index);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
CueTrack* CueTrackListWidget::getSelectedTrack(bool advance) {
|
|
CueTrack* track = getTrackAtIndex(selectedIndex);
|
|
if (advance)
|
|
key_down();
|
|
return track;
|
|
}
|
|
|
|
void CueTrackListWidget::key_up() {
|
|
|
|
if (m_size > 0 && selectedIndex > 0) {
|
|
updateSelectedCueTrack(false);
|
|
selectedIndex--;
|
|
updateSelectedCueTrack(true);
|
|
tableWidget->scrollToItem(tableWidget->item(selectedIndex, 0));
|
|
}
|
|
emit changeSelectedIndex(selectedIndex);
|
|
}
|
|
|
|
void CueTrackListWidget::key_down() {
|
|
if (selectedIndex < m_size - 1 && m_size > 0) {
|
|
updateSelectedCueTrack(false);
|
|
selectedIndex++;
|
|
updateSelectedCueTrack(true);
|
|
tableWidget->scrollToItem(tableWidget->item(selectedIndex, 0));
|
|
}
|
|
emit changeSelectedIndex(selectedIndex);
|
|
}
|
|
|
|
void CueTrackListWidget::displayCueTrackInTable(CueTrack *cueTrack, int index) {
|
|
if (tableWidget->columnCount() == 0) {
|
|
tableWidget->setColumnCount(7);
|
|
QStringList headers = {"Active", "Number","Audio Channel", "Name", "Volume", "Status", "File"};
|
|
tableWidget->setHorizontalHeaderLabels(headers);
|
|
}
|
|
if (index == -1)
|
|
index = tableWidget->rowCount();
|
|
tableWidget->insertRow(index);
|
|
|
|
tableWidget->setItem(index, 0, new QTableWidgetItem(cueTrack->active ? "Yes" : "No"));
|
|
tableWidget->setItem(index, 1, new QTableWidgetItem(QStringLiteral("%1").arg(cueTrack->userNumber, 3, 10, QLatin1Char('0'))));
|
|
tableWidget->setItem(index, 2, new QTableWidgetItem(QString::number(cueTrack->audioLayer)));
|
|
tableWidget->setItem(index, 3, new QTableWidgetItem(cueTrack->name.data()));
|
|
tableWidget->setItem(index, 4, new QTableWidgetItem(QString::number(cueTrack->volume)));
|
|
QString statusStr;
|
|
statusStr = statusToString(cueTrack->status);
|
|
tableWidget->setItem(index, 5, new QTableWidgetItem(statusStr));
|
|
tableWidget->setItem(index, 6, new QTableWidgetItem(*getFileName(cueTrack->filePath)));
|
|
}
|
|
|
|
void CueTrackListWidget::updateSelectedCueTrack(bool highlightRow) {
|
|
if (selectedIndex >= 0 && selectedIndex < tableWidget->rowCount()) {
|
|
QBrush backgroundBrush(highlightRow ? QColor(248, 248, 200) : Qt::white);
|
|
for (int column = 0; column < tableWidget->columnCount(); ++column) {
|
|
QTableWidgetItem *item = tableWidget->item(selectedIndex, column);
|
|
if (!item) {
|
|
item = new QTableWidgetItem();
|
|
tableWidget->setItem(selectedIndex, column, item);
|
|
}
|
|
item->setBackground(backgroundBrush);
|
|
}
|
|
tableWidget->resizeColumnsToContents();
|
|
tableWidget->resizeRowsToContents();
|
|
}
|
|
}
|
|
|
|
void CueTrackListWidget::cueTrackLoadDefaults(CueTrack * t)
|
|
{
|
|
t->active = false;
|
|
t->audioLayer = 0;
|
|
t->bus1 = 100;
|
|
t->bus2 = 100;
|
|
t->entryPoint = 0;
|
|
t->exitPoint = 255;
|
|
t->fadeIn = 2;
|
|
t->fadeOut = 2;
|
|
t->waitIn = 0;
|
|
t->waitOut = 0;
|
|
t->pan = 0;
|
|
t->pitch = 1;
|
|
t->status = Status::PlayingOnce;
|
|
lastUserCueNumber += 10;
|
|
t->userNumber = lastUserCueNumber;
|
|
t->volume = 80;
|
|
t->stopAtEnd = true;
|
|
t->filePath = "";
|
|
t->duration = 0;
|
|
t->multi = false;
|
|
}
|
|
|
|
void CueTrackListWidget::createNewCueTrack()
|
|
{
|
|
CueTrack *t = new CueTrack;
|
|
cueTrackLoadDefaults(t);
|
|
EditCueTrackWidget dialog(t, this);
|
|
if (dialog.exec() == QDialog::Accepted) {
|
|
t->active = false;
|
|
addCueTrack(t);
|
|
if (m_size == 1)
|
|
{
|
|
updateSelectedCueTrack(true);
|
|
emit changeSelectedIndex(0);
|
|
} else
|
|
redrawCueTrackList();
|
|
if (lastUserCueNumber < t->userNumber)
|
|
lastUserCueNumber = t->userNumber;
|
|
} else
|
|
delete (t);
|
|
}
|
|
|
|
void CueTrackListWidget::editCueTrack()
|
|
{
|
|
CueTrack *current = getTrackAtIndex(selectedIndex);
|
|
EditCueTrackWidget dialog(current, this);
|
|
if (dialog.exec() == QDialog::Accepted) {
|
|
copyCueTrack(dialog.cueTrack, current);
|
|
redrawCueTrackList();
|
|
emit changeSelectedIndex(selectedIndex);
|
|
}
|
|
if (lastUserCueNumber < current->userNumber)
|
|
lastUserCueNumber = current->userNumber;
|
|
}
|
|
|
|
void CueTrackListWidget::deleteCueTrack()
|
|
{
|
|
QMessageBox::StandardButton reply;
|
|
reply = QMessageBox::question(this, "Delete Cue Track", "Are you sure you want to delete this cue track?",
|
|
QMessageBox::Yes | QMessageBox::No);
|
|
if (reply == QMessageBox::Yes) {
|
|
removeCueTrack(selectedIndex);
|
|
if (selectedIndex >= m_size)
|
|
{
|
|
selectedIndex = m_size - 1;
|
|
emit changeSelectedIndex(selectedIndex);
|
|
}
|
|
redrawCueTrackList();
|
|
}
|
|
}
|
|
|
|
void CueTrackListWidget::copyCueTrack(CueTrack *src, CueTrack *dst)
|
|
{
|
|
dst->active = src->active;
|
|
dst->audioLayer = src->audioLayer;
|
|
dst->bus1 = src->bus1;
|
|
dst->bus2 = src->bus2;
|
|
dst->entryPoint = src->entryPoint;
|
|
dst->exitPoint = src->exitPoint;
|
|
dst->fadeIn = src->fadeIn;
|
|
dst->fadeOut = src->fadeOut;
|
|
dst->waitIn = src->waitIn;
|
|
dst->waitOut = src->waitOut;
|
|
dst->pan = src->pan;
|
|
dst->pitch = src->pitch;
|
|
dst->status = src->status;
|
|
dst->userNumber = src->userNumber;
|
|
dst->volume = src->volume;
|
|
dst->stopAtEnd = src->stopAtEnd;
|
|
dst->name = src->name;
|
|
dst->description = src->description;
|
|
dst->filePath = src->filePath;
|
|
dst->duration = src->duration;
|
|
dst->multi = src->multi;
|
|
}
|
|
|
|
QString *CueTrackListWidget::getFileName(std::string s)
|
|
{
|
|
size_t bar = s.rfind("/");
|
|
std::string tmp = s.substr(bar + 1, strlen(s.data()));
|
|
QString *ret = new QString(tmp.data());
|
|
ret->truncate(64);
|
|
return ret;
|
|
}
|
|
|
|
void CueTrackListWidget::sortCueTrackList()
|
|
{
|
|
std::sort(cueTracks.begin(), cueTracks.end(), [](CueTrack *a, CueTrack *b) {
|
|
return a->userNumber < b->userNumber;
|
|
});
|
|
}
|
|
|
|
void CueTrackListWidget::redrawCueTrackList()
|
|
{
|
|
if (!m_size)
|
|
return;
|
|
int selected = cueTracks.at(selectedIndex)->userNumber;
|
|
clearTableWidget();
|
|
tableWidget->setColumnCount(7);
|
|
QStringList headers = {"Active", "Number","Channel", "Name", "Volume", "Status", "File"};
|
|
tableWidget->setHorizontalHeaderLabels(headers);
|
|
sortCueTrackList();
|
|
selectedIndex = 0;
|
|
for (int i = 0; i < m_size; i++)
|
|
{
|
|
displayCueTrackInTable(cueTracks.at(i), i);
|
|
}
|
|
selectedIndex = 0;
|
|
while (cueTracks.at(selectedIndex)->userNumber != selected)
|
|
{
|
|
selectedIndex++;
|
|
}
|
|
updateSelectedCueTrack(true);
|
|
tableWidget->resizeColumnsToContents();
|
|
tableWidget->resizeRowsToContents();
|
|
tableWidget->scrollToItem(tableWidget->item(selectedIndex, 0));
|
|
tableWidget->blockSignals(false);
|
|
emit changeSelectedIndex(selectedIndex);
|
|
}
|
|
|
|
void CueTrackListWidget::loadCueTrackList(std::string filename)
|
|
{
|
|
qDebug() << "loading cue list from " << filename.data();
|
|
QFile file(QString::fromStdString(filename));
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
{
|
|
std::cerr << "No se pudo abrir el archivo para lectura" << std::endl;
|
|
return;
|
|
}
|
|
QXmlStreamReader xmlReader(&file);
|
|
clearCueTrackList();
|
|
lastUserCueNumber = 0;
|
|
while (!xmlReader.atEnd() && !xmlReader.hasError())
|
|
{
|
|
QXmlStreamReader::TokenType token = xmlReader.readNext();
|
|
if (token == QXmlStreamReader::StartElement)
|
|
{
|
|
if (xmlReader.name() == "CueTrack")
|
|
{
|
|
CueTrack *t = new CueTrack;
|
|
while (!(xmlReader.tokenType() == QXmlStreamReader::EndElement && xmlReader.name() == "CueTrack"))
|
|
{
|
|
if (xmlReader.tokenType() == QXmlStreamReader::StartElement)
|
|
{
|
|
QString elementName = xmlReader.name().toString();
|
|
xmlReader.readNext();
|
|
if (xmlReader.tokenType() == QXmlStreamReader::Characters)
|
|
{
|
|
if (elementName == "filePath") {
|
|
t->filePath = xmlReader.text().toString().toStdString();
|
|
}
|
|
else if (elementName == "volume") {
|
|
t->volume = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "pan") {
|
|
t->pan = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "pitch") {
|
|
t->pitch = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "bus1") {
|
|
t->bus1 = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "bus2") {
|
|
t->bus2 = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "status") {
|
|
QString tmp = xmlReader.text().toString();
|
|
t->status = stringToStatus(&tmp);
|
|
}
|
|
else if (elementName == "fadeOut") {
|
|
t->fadeOut = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "fadeIn") {
|
|
t->fadeIn = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "waitIn") {
|
|
t->waitIn = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "waitOut") {
|
|
t->waitOut = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "stopAtEnd") {
|
|
QString tmp = xmlReader.text().toString().toLower();
|
|
if (tmp.compare("false"))
|
|
t->stopAtEnd = true;
|
|
else {
|
|
t->stopAtEnd = false;
|
|
}
|
|
}
|
|
else if (elementName == "name") {
|
|
t->name = xmlReader.text().toString().toStdString();
|
|
}
|
|
else if (elementName == "description") {
|
|
t->description = xmlReader.text().toString().toStdString();
|
|
}
|
|
else if (elementName == "userNumber") {
|
|
t->userNumber = xmlReader.text().toInt();
|
|
if (t->userNumber > lastUserCueNumber)
|
|
{
|
|
lastUserCueNumber = t->userNumber;
|
|
}
|
|
}
|
|
else if (elementName == "entryPoint") {
|
|
t->entryPoint = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "exitPoint") {
|
|
t->exitPoint = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "audioLayer") {
|
|
t->audioLayer = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "duration") {
|
|
t->duration = xmlReader.text().toInt();
|
|
}
|
|
else if (elementName == "multi") {
|
|
QString tmp = xmlReader.text().toString().toLower();
|
|
if (tmp.compare("false"))
|
|
t->multi = true;
|
|
else {
|
|
t->multi = false;
|
|
}
|
|
}
|
|
t->active = false;
|
|
}
|
|
}
|
|
xmlReader.readNext();
|
|
}
|
|
addCueTrack(t);
|
|
}
|
|
}
|
|
}
|
|
if (xmlReader.hasError())
|
|
{
|
|
std::cerr << "Error al leer el archivo XML: " << xmlReader.errorString().toStdString() << std::endl;
|
|
}
|
|
file.close();
|
|
redrawCueTrackList();
|
|
}
|
|
|
|
void CueTrackListWidget::saveCueTrackList(std::string filename)
|
|
{
|
|
qDebug() << "saving cue list to " << filename.data();
|
|
std::ofstream file(filename);
|
|
if (!file.is_open())
|
|
{
|
|
return;
|
|
}
|
|
file << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
|
|
file << "<CueTrackList>\n";
|
|
for (int i = 0; i < m_size; i++)
|
|
{
|
|
file << cueTrackToXml(*cueTracks.at(i)) << std::endl;
|
|
}
|
|
file << "</CueTrackList>\n";
|
|
file.close();
|
|
}
|
|
|
|
std::string CueTrackListWidget::cueTrackToXml(const CueTrack& cueTrack)
|
|
{
|
|
std::string xml = " <CueTrack>\n";
|
|
xml += " <filePath>" + cueTrack.filePath + "</filePath>\n";
|
|
xml += " <volume>" + std::to_string(cueTrack.volume) + "</volume>\n";
|
|
xml += " <pan>" + std::to_string(cueTrack.pan) + "</pan>\n";
|
|
xml += " <pitch>" + std::to_string(cueTrack.pitch) + "</pitch>\n";
|
|
xml += " <bus1>" + std::to_string(cueTrack.bus1) + "</bus1>\n";
|
|
xml += " <bus2>" + std::to_string(cueTrack.bus2) + "</bus2>\n";
|
|
xml += " <status>";
|
|
xml += statusToString(cueTrack.status);
|
|
xml += "</status>\n";
|
|
xml += " <fadeOut>" + std::to_string(cueTrack.fadeOut) + "</fadeOut>\n";
|
|
xml += " <fadeIn>" + std::to_string(cueTrack.fadeIn) + "</fadeIn>\n";
|
|
xml += " <waitIn>" + std::to_string(cueTrack.waitIn) + "</waitIn>\n";
|
|
xml += " <waitOut>" + std::to_string(cueTrack.waitOut) + "</waitOut>\n";
|
|
xml += " <stopAtEnd>";
|
|
xml += (cueTrack.stopAtEnd ? "true" : "false");
|
|
xml += "</stopAtEnd>\n";
|
|
xml += " <name>" + cueTrack.name + "</name>\n";
|
|
xml += " <description>" + cueTrack.description + "</description>\n";
|
|
xml += " <userNumber>" + std::to_string(cueTrack.userNumber) + "</userNumber>\n";
|
|
xml += " <entryPoint>" + std::to_string(cueTrack.entryPoint) + "</entryPoint>\n";
|
|
xml += " <exitPoint>" + std::to_string(cueTrack.exitPoint) + "</exitPoint>\n";
|
|
xml += " <audioLayer>" + std::to_string(cueTrack.audioLayer) + "</audioLayer>\n";
|
|
xml += " <duration>" + std::to_string(cueTrack.duration) + "</duration>\n";
|
|
xml += " <multi>";
|
|
xml += (cueTrack.multi ? "true" : "false");
|
|
xml += "</multi>\n";
|
|
xml += " </CueTrack>\n";
|
|
return xml;
|
|
}
|
|
|
|
void CueTrackListWidget::clearCueTrackList()
|
|
{
|
|
for (int i = 0; i < m_size; i++)
|
|
{
|
|
delete cueTracks.at(i);
|
|
}
|
|
cueTracks.clear();
|
|
m_size = 0;
|
|
selectedIndex = 0;
|
|
}
|
|
|
|
#include <QFile>
|
|
#include <QXmlStreamWriter>
|
|
|
|
void saveCueTrackToXml(const CueTrack& cueTrack, const QString& filename) {
|
|
QFile file(filename);
|
|
if (!file.open(QIODevice::WriteOnly)) {
|
|
qInfo() << "Can not open file " << filename << "\n";
|
|
return;
|
|
}
|
|
|
|
QXmlStreamWriter xmlWriter(&file);
|
|
xmlWriter.setAutoFormatting(true);
|
|
xmlWriter.writeStartDocument();
|
|
xmlWriter.writeStartElement("CueTrack");
|
|
|
|
xmlWriter.writeTextElement("filePath", QString::fromStdString(cueTrack.filePath));
|
|
xmlWriter.writeTextElement("volume", QString::number(cueTrack.volume));
|
|
xmlWriter.writeTextElement("pan", QString::number(cueTrack.pan));
|
|
xmlWriter.writeTextElement("pitch", QString::number(cueTrack.pitch));
|
|
xmlWriter.writeTextElement("bus1", QString::number(cueTrack.bus1));
|
|
xmlWriter.writeTextElement("bus2", QString::number(cueTrack.bus2));
|
|
xmlWriter.writeTextElement("status", statusToString(cueTrack.status));
|
|
xmlWriter.writeTextElement("fadeOut", QString::number(cueTrack.fadeOut));
|
|
xmlWriter.writeTextElement("fadeIn", QString::number(cueTrack.fadeIn));
|
|
xmlWriter.writeTextElement("waitIn", QString::number(cueTrack.waitIn));
|
|
xmlWriter.writeTextElement("waitOut", QString::number(cueTrack.waitOut));
|
|
xmlWriter.writeTextElement("stopAtEnd", cueTrack.stopAtEnd ? "true" : "false");
|
|
xmlWriter.writeTextElement("name", QString::fromStdString(cueTrack.name));
|
|
xmlWriter.writeTextElement("description", QString::fromStdString(cueTrack.description));
|
|
xmlWriter.writeTextElement("userNumber", QString::number(cueTrack.userNumber));
|
|
xmlWriter.writeTextElement("entryPoint", QString::number(cueTrack.entryPoint));
|
|
xmlWriter.writeTextElement("exitPoint", QString::number(cueTrack.exitPoint));
|
|
xmlWriter.writeTextElement("audioLayer", QString::number(cueTrack.audioLayer));
|
|
|
|
xmlWriter.writeEndElement();
|
|
xmlWriter.writeEndDocument();
|
|
|
|
file.close();
|
|
}
|
|
|
|
#include <QFile>
|
|
#include <QXmlStreamReader>
|
|
#include <QString>
|
|
#include <string>
|
|
|
|
CueTrack loadCueTrackFromXml(const QString& filename) {
|
|
QFile file(filename);
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
throw std::runtime_error("No se pudo abrir el archivo");
|
|
}
|
|
|
|
QXmlStreamReader xmlReader(&file);
|
|
CueTrack cueTrack;
|
|
|
|
while (!xmlReader.atEnd() && !xmlReader.hasError()) {
|
|
QXmlStreamReader::TokenType token = xmlReader.readNext();
|
|
if (token == QXmlStreamReader::StartElement) {
|
|
const QString elementName = xmlReader.name().toString();
|
|
if (elementName == "filePath") {
|
|
cueTrack.filePath = xmlReader.readElementText().toStdString();
|
|
} else if (elementName == "volume") {
|
|
cueTrack.volume = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "pan") {
|
|
cueTrack.pan = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "pitch") {
|
|
cueTrack.pitch = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "bus1") {
|
|
cueTrack.bus1 = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "bus2") {
|
|
cueTrack.bus2 = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "status") {
|
|
QString tmp = xmlReader.readElementText();
|
|
cueTrack.status = stringToStatus(&tmp);
|
|
} else if (elementName == "fadeOut") {
|
|
cueTrack.fadeOut = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "fadeIn") {
|
|
cueTrack.fadeIn = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "waitIn") {
|
|
cueTrack.waitIn = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "waitOut") {
|
|
cueTrack.waitOut = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "stopAtEnd") {
|
|
cueTrack.stopAtEnd = xmlReader.readElementText() == "true";
|
|
} else if (elementName == "name") {
|
|
cueTrack.name = xmlReader.readElementText().toStdString();
|
|
} else if (elementName == "description") {
|
|
cueTrack.description = xmlReader.readElementText().toStdString();
|
|
} else if (elementName == "userNumber") {
|
|
cueTrack.userNumber = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "entryPoint") {
|
|
cueTrack.entryPoint = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "exitPoint") {
|
|
cueTrack.exitPoint = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "audioLayer") {
|
|
cueTrack.audioLayer = xmlReader.readElementText().toInt();
|
|
} else if (elementName == "duration") {
|
|
cueTrack.duration = xmlReader.readElementText().toInt();
|
|
}
|
|
}
|
|
}
|
|
if (xmlReader.hasError()) {
|
|
throw std::runtime_error("Error al parsear el archivo XML");
|
|
}
|
|
file.close();
|
|
return cueTrack;
|
|
}
|
|
|
|
void CueTrackListWidget::clearTableWidget()
|
|
{
|
|
for (int i = 0; i < m_size; i++)
|
|
{
|
|
tableWidget->removeRow(i);
|
|
}
|
|
tableWidget->clear();
|
|
tableWidget->setRowCount(0);
|
|
}
|
|
|
|
void CueTrackListWidget::cueTrackAtEnd(int layer)
|
|
{
|
|
for (int i = 0; i < m_size; i++)
|
|
{
|
|
CueTrack * cur = cueTracks.at(i);
|
|
if (cur->audioLayer == layer)
|
|
{
|
|
cur->active = false;
|
|
}
|
|
}
|
|
redrawCueTrackList();
|
|
}
|
|
|
|
void CueTrackListWidget::copyCueTrack() {
|
|
if (selectedIndex >= 0 && selectedIndex < m_size) {
|
|
delete copiedCue;
|
|
copiedCue = new CueTrack(*cueTracks.at(selectedIndex));
|
|
}
|
|
}
|
|
|
|
void CueTrackListWidget::cutCueTrack() {
|
|
if (selectedIndex >= 0 && selectedIndex < m_size) {
|
|
delete copiedCue;
|
|
copiedCue = new CueTrack(*cueTracks.at(selectedIndex));
|
|
removeCueTrack(selectedIndex);
|
|
}
|
|
}
|
|
|
|
void CueTrackListWidget::pasteCueTrack() {
|
|
if (copiedCue != nullptr) {
|
|
CueTrack* newCue = new CueTrack(*copiedCue);
|
|
addCueTrack(newCue);
|
|
}
|
|
}
|
|
|