view data/model/IntervalModel.cpp @ 48:a8dcc1ca82c4

include writing with ToXml function

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*
    Sound Access
	EASAIER client application.
	Silogic 2007. Luc Barthélémy.

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.  See the file
    COPYING included with this distribution for more information.
*/


#include "system/System.h"
#include "model/IntervalModel.h"

#include <QTextStream>


TimeInterval::TimeInterval(long start, long end, float value):
m_start(start), m_end(end), m_value(value)
{
}

TimeInterval::TimeInterval(long start, long end, const QString& label, float value):
m_start(start), m_end(end), m_label(label), m_value(value)
{
}

TimeInterval::~TimeInterval()
{
}

QString 
TimeInterval::toXmlString(QString indent , QString extraAttributes ) const
{
	return QString("%1<interval start=\"%2\" end=\"%3\" label=\"%4\" value=\"%5\" %6/>\n")
	    .arg(indent).arg(m_start).arg(m_end).arg(m_label)
		.arg(m_value).arg(extraAttributes);
}

QString 
TimeInterval::toDelimitedDataString(const QString& delimiter, size_t sampleRate) const
{
    QStringList list;
    list << RealTime::frame2RealTime(m_start, sampleRate).toString().c_str();
    list << RealTime::frame2RealTime(m_end, sampleRate).toString().c_str();
    list << QString("%1").arg(m_value);
    list << m_label;

    return list.join(delimiter);
}

/**
 * IntervalModel
 */

IntervalModel::IntervalModel(size_t sampleRate, size_t resolution, bool notifyOnAdd) :
m_sampleRate(sampleRate), m_resolution(resolution), m_notifyOnAdd(notifyOnAdd)
{


}

IntervalModel::~IntervalModel()
{

}

QString 
IntervalModel::toDelimitedDataString(QString delimiter) const
{ 
    QString s;
    for (IntervalListConstIterator i = m_intervals.begin(); i != m_intervals.end(); ++i) 
	{
        s += (*i)->toDelimitedDataString(delimiter, m_sampleRate) + "\n";
    }

	return s;
}

void
IntervalModel::toXml(QTextStream &out,
                                  QString indent,
                                  QString extraAttributes) const
{ 
    out << Model::toXmlString
	(indent, QString("type=\"interval\" dimensions=\"3\" resolution=\"%1\" notifyOnAdd=\"%2\" dataset=\"%3\" %4")
		.arg(m_resolution)
		.arg(m_notifyOnAdd ? "true" : "false")
		.arg(getObjectExportId(&m_intervals))
		.arg(extraAttributes));

    out << indent;
    out << QString("<dataset id=\"%1\" dimensions=\"3\">\n")
	.arg(getObjectExportId(&m_intervals));

    for (IntervalListConstIterator i = m_intervals.begin(); i != m_intervals.end(); ++i) 
	{
        out << (*i)->toXmlString(indent + "  ");
    }

    out << indent + "</dataset>\n";
}

QString
IntervalModel::toXmlString(QString indent,
					QString extraAttributes) const
{
    QString s;

    {
        QTextStream out(&s);
        toXml(out, indent, extraAttributes);
    }

    return s;
}

size_t 
IntervalModel::getStartFrame() const
{
    QMutexLocker locker(&m_mutex);

	size_t start= 0;
	
	if (m_intervals.size() > 0)
		start = (*m_intervals.begin())->start();

    for (IntervalListConstIterator i = m_intervals.begin() ; i != m_intervals.end(); ++i) 
	{
		if (start > ((size_t) ((*i)->start())))
			start = (size_t) ((*i)->start());
	}

	return start;
}

size_t 
IntervalModel::getEndFrame() const
{
    QMutexLocker locker(&m_mutex);

	size_t end = 0;
	
    for (IntervalListConstIterator i = m_intervals.begin() ; i != m_intervals.end(); ++i) 
	{
		if (end < ((size_t) ((*i)->end())))
			end = (size_t) ((*i)->end());
	}

	return end;
}

Model* 
IntervalModel::clone() const
{
	IntervalModel* model = new IntervalModel(m_sampleRate, m_resolution, m_notifyOnAdd);
	model->m_intervals = m_intervals;
	
	return model;
}

void 
IntervalModel::addInterval(long start, long end, const QString& label, float value)
{
	QMutexLocker locker(&m_mutex);

	m_intervals.push_back(new TimeInterval(start, end, label, value));
}

void IntervalModel::addInterval(TimeIntervalPtr ti)
{
	{
		QMutexLocker locker(&m_mutex);

		m_intervals.push_back(ti);
	}

	emit modelChanged(ti->start(), ti->end());
}

void IntervalModel::removeInterval(TimeIntervalPtr ti)
{
	{
		QMutexLocker locker(&m_mutex);

		m_intervals.remove(ti);
	}

	emit modelChanged(ti->start(), ti->end());
}

void
IntervalModel::changeInterval(TimeIntervalPtr ti, long start, long end, float value, const QString& label)
{

	long startMin = min(start, ti->start());
	long endMax   = max(end, ti->end());

	{
		QMutexLocker locker(&m_mutex);

		if (label != ti->label())
			ti->label(label);
		ti->start(start);
		ti->end(end);
		ti->value(value);
	}

	emit modelChanged(startMin, endMax);
}