changeset 16:21f452cc3310

add
- EasaierSessionManager
- Easaier menus
- Interval model

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/data/model/IntervalModel.cpp	Mon May 14 13:11:29 2007 +0000
@@ -0,0 +1,203 @@
+/* -*- 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"
+
+
+
+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;
+}
+
+QString 
+IntervalModel::toXmlString(QString indent, QString extraAttributes) const
+{ 
+    QString s;
+
+    s += 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));
+
+    s += indent;
+    s += QString("<dataset id=\"%1\" dimensions=\"3\"\">\n")
+	.arg(getObjectExportId(&m_intervals));
+
+    for (IntervalListConstIterator i = m_intervals.begin(); i != m_intervals.end(); ++i) 
+	{
+        s += (*i)->toXmlString(indent + "  ");
+    }
+
+    s += indent + "</dataset>\n";
+
+    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);
+}
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/data/model/IntervalModel.h	Mon May 14 13:11:29 2007 +0000
@@ -0,0 +1,216 @@
+/* -*- 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.
+*/
+
+#ifndef _INTERVAL_MODEL_H_
+#define _INTERVAL_MODEL_H_
+ 
+#include <QMutex>
+
+#include "Model.h"
+#include "base/RealTime.h"
+#include "base/Command.h"
+#include "base/CommandHistory.h"
+
+/**
+ * TimeInterval SparseValueModel
+ */
+
+class TimeInterval
+{
+public:
+    
+	TimeInterval(long start = 0, long end = 0, float value = 0.0f);
+	TimeInterval(long start, long end, const QString& label, float value = 0.0f);
+	virtual ~TimeInterval();
+   
+	QString toXmlString(QString indent = "", QString extraAttributes = "") const;
+    QString toDelimitedDataString(const QString& delimiter, size_t sampleRate) const;
+
+	long start() const {return m_start;}
+	long end() const {return m_end;}
+	float value() const {return m_value;}
+	const QString& label() const { return m_label; }
+
+	void start(long start) { m_start = start;}
+	void end(long end) { m_end = end;}
+	void label(const QString& label) { m_label = label;}
+	void value(float val) { m_value = val;}
+
+private:
+    
+	long	m_start;
+    long	m_end;
+	float	m_value;
+
+	QString	m_label;
+};
+
+typedef TimeInterval* TimeIntervalPtr;
+
+typedef std::list<TimeIntervalPtr> IntervalList;
+typedef IntervalList::iterator IntervalListIterator;
+typedef IntervalList::const_iterator IntervalListConstIterator;
+
+/**
+ * IntervalModel
+ */
+
+class IntervalModel : public Model
+{
+public:
+
+    IntervalModel(size_t sampleRate, size_t resolution,
+	      bool notifyOnAdd = true);
+	~IntervalModel();
+
+
+    virtual bool isOK() const { return true; }
+    virtual size_t getStartFrame() const;
+    virtual size_t getEndFrame() const;
+
+	virtual size_t getSampleRate() const { return m_sampleRate; }
+    virtual size_t getResolution() const { return m_resolution; }
+
+    virtual Model *clone() const;
+  
+	virtual QString toXmlString(QString indent = "", QString extraAttributes = "") const;
+    virtual QString toDelimitedDataString(QString) const;
+
+	virtual void addInterval(long start, long end, const QString& label, float value);
+	virtual void addInterval(TimeIntervalPtr ti);
+
+	virtual void removeInterval(TimeIntervalPtr ti);
+
+	IntervalList& intervals() { return m_intervals; }
+
+	void changeInterval(TimeIntervalPtr ti, long start, long end, float value, const QString& label);
+
+   /**
+     * Command to change an interval.
+     */
+    class IntervalCommand : public Command
+    {
+	    public:
+			
+			enum Mode {
+				Creation,
+				Edition,
+				Deletion,
+			};
+
+			IntervalCommand(IntervalModel* model,
+				   const TimeIntervalPtr& inter,
+				   Mode mode,
+				   long newStart,
+				   long newEnd,
+				   float newValue,
+				   const QString& newLabel) :
+			m_model(model), m_interval(inter), m_mode(mode)
+			{
+				m_oldLabel = inter->label();
+				m_oldStart = inter->start();
+				m_oldEnd   = inter->end();
+				m_oldValue = inter->value();
+				m_newLabel = newLabel;
+				m_newStart = newStart;
+				m_newEnd   = newEnd;
+				m_newValue = newValue;
+			}
+
+			virtual QString getName() const { return tr("Edit Interval"); }
+
+			virtual void execute() 
+			{ 
+				if (m_mode == Creation)
+				{
+					m_model->addInterval(m_interval);
+				} else if (m_mode == Edition)
+				{
+					m_model->changeInterval(m_interval, m_newStart, m_newEnd, m_newValue, m_newLabel);
+				} else if (m_mode == Deletion)
+				{
+					m_model->removeInterval(m_interval);
+				}
+			}
+
+			virtual void unexecute() 
+			{ 
+				if (m_mode == Creation)
+				{
+					m_model->removeInterval(m_interval);
+				} else if (m_mode == Edition)
+				{
+					m_model->changeInterval(m_interval, m_oldStart, m_oldEnd, m_oldValue, m_oldLabel);
+				} else if (m_mode == Deletion)
+				{
+					m_model->addInterval(m_interval);
+				}
+			}
+
+			void newStart(long start) 
+			{ 
+				if (m_newStart != start)
+				{	
+					m_newStart  = start; 
+					m_model->changeInterval(m_interval, m_newStart, m_newEnd, m_newValue, m_newLabel);
+				}
+			}
+
+			void newEnd(long end)
+			{
+				if (m_newEnd != end)
+				{	
+					m_newEnd  = end; 
+					m_model->changeInterval(m_interval, m_newStart, m_newEnd, m_newValue, m_newLabel);
+				}
+			}
+
+			void newLabel(QString label)
+			{
+				if (m_newLabel != label)
+				{	
+					m_newLabel  = label; 
+					m_model->changeInterval(m_interval, m_newStart, m_newEnd, m_newValue, m_newLabel);
+				}
+			}
+
+	private:
+
+			Mode			m_mode;
+
+			IntervalModel*	m_model;
+			TimeIntervalPtr	m_interval;
+			QString			m_newLabel;
+			QString			m_oldLabel;
+			long			m_newStart;
+			long			m_oldStart;
+			long			m_newEnd;
+			long			m_oldEnd;
+			float			m_newValue;
+			float			m_oldValue;
+    };
+
+
+private:
+
+	size_t	m_sampleRate;
+	size_t	m_resolution;
+	bool	m_notifyOnAdd;
+
+	IntervalList	m_intervals; 
+	mutable QMutex	m_mutex;
+
+};
+
+#endif // _INTERVAL_MODEL_H_