comparison layer/IntervalLayer.cpp @ 18:d8e6709e9075

add
- EasaierSessionManager
- Easaier menus
- Interval model

+/* -*- 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 <QObject>
+#include <QColor>
+#include <QPainter>
+#include <QMouseEvent>
+#include <QInputDialog>
+
+#include "layer/IntervalLayer.h"
+#include "view/View.h"
+#include "system/System.h"
+#include "widgets/ItemEditDialog.h"
+
+
+const int gIntervalHeight = 30;
+
+//****************************************************************
+//* Function: Constructor
+//* Description: declaration and initialisation of all private parameters
+//****************************************************************
+IntervalLayer::IntervalLayer():
+	Layer(),
+	m_model(0),
+    m_editing(false),
+    m_colour(Qt::darkRed),
+	m_editingCommand(0)
+{
+}
+
+IntervalLayer::~IntervalLayer()
+{}
+
+void IntervalLayer::setModel(IntervalModel* model)
+{
+    if (m_model == model) return;
+    m_model = model;
+
+    connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));
+    connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
+	    this, SIGNAL(modelChanged(size_t, size_t)));
+
+    connect(m_model, SIGNAL(completionChanged()),
+	    this, SIGNAL(modelCompletionChanged()));
+
+    emit modelReplaced();
+}
+
+Layer::PropertyList
+IntervalLayer::getProperties() const
+{
+    PropertyList list;
+    list.push_back("Colour");
+    return list;
+}
+
+Layer::PropertyType
+IntervalLayer::getPropertyType(const PropertyName &name) const
+{
+    return ValueProperty;
+}
+
+int
+IntervalLayer::getPropertyRangeAndValue(const PropertyName &name,
+                                    int *min, int *max, int *deflt) const
+{
+    //!!! factor this colour handling stuff out into a colour manager class
+	int val = 0;
+
+    if (name == "Colour") {
+
+		if (min) *min = 0;
+		if (max) *max = 5;
+		if (deflt) *deflt = 0;
+
+		if (m_colour == Qt::black) val = 0;
+		else if (m_colour == Qt::darkRed) val = 1;
+		else if (m_colour == Qt::darkBlue) val = 2;
+		else if (m_colour == Qt::darkGreen) val = 3;
+		else if (m_colour == QColor(200, 50, 255)) val = 4;
+		else if (m_colour == QColor(255, 150, 50)) val = 5;
+	}
+
+    return val;
+}
+
+QString
+IntervalLayer::getPropertyValueLabel(const PropertyName &name,
+				    int value) const
+{
+    if (name == "Colour") {
+		switch (value) {
+			default:
+			case 0: return tr("Black");
+			case 1: return tr("Red");
+			case 2: return tr("Blue");
+			case 3: return tr("Green");
+			case 4: return tr("Purple");
+			case 5: return tr("Orange");
+		}
+	}
+    return tr("<unknown>");
+}
+
+
+void IntervalLayer::setProperties(const QXmlAttributes &attributes)
+{
+    QString colourSpec = attributes.value("colour");
+    if (colourSpec != "") {
+		QColor colour(colourSpec);
+		if (colour.isValid()) {
+			setBaseColour(QColor(colourSpec));
+		}
+    }
+
+}
+
+void
+IntervalLayer::setProperty(const PropertyName &name, int value)
+{
+    if (name == "Colour") {
+		switch (value) {
+			default:
+			case 0:	setBaseColour(Qt::black); break;
+			case 1: setBaseColour(Qt::darkRed); break;
+			case 2: setBaseColour(Qt::darkBlue); break;
+			case 3: setBaseColour(Qt::darkGreen); break;
+			case 4: setBaseColour(QColor(200, 50, 255)); break;
+			case 5: setBaseColour(QColor(255, 150, 50)); break;
+		}
+	}
+}
+
+void
+IntervalLayer::setBaseColour(QColor colour)
+{
+    if (m_colour == colour) return;
+    m_colour = colour;
+    emit layerParametersChanged();
+}
+
+QString
+IntervalLayer::toXmlString(QString indent, QString extraAttributes) const
+{
+    return Layer::toXmlString(indent, extraAttributes +
+			      QString(" colour=\"%1\"")
+			      .arg(encodeColour(m_colour)));
+}
+
+QString
+IntervalLayer::toEasaierXmlString(QString indent, QString extraAttributes) const
+{
+    return Layer::toEasaierXmlString(indent, extraAttributes +
+			      QString(" colour=\"%1\"")
+			      .arg(encodeColour(m_colour)));
+}
+
+QString
+IntervalLayer::getPropertyLabel(const PropertyName &name) const
+{
+    if (name == "Colour") return tr("Colour");
+    return "";
+}
+
+int
+IntervalLayer::getYForHeight(View *v, float height) const
+{
+    int h = v->height();
+    return h - int(height * h);
+}
+
+float
+IntervalLayer::getHeightForY(View *v, int y) const
+{
+    int h = v->height();
+    return float(h - y) / h;
+}
+
+
+void 
+IntervalLayer::paint(View *v, QPainter &paint, QRect rect) const
+{
+    if (!m_model || !m_model->isOK()) return;
+
+    int sampleRate = m_model->getSampleRate();
+    if (!sampleRate) return;
+
+    int x0 = rect.left(), x1 = rect.right();
+    long frame0 = v->getFrameForX(x0);
+    long frame1 = v->getFrameForX(x1);
+    	
+	paint.save();
+
+    QColor brushColour(m_colour);
+    brushColour.setAlpha(100);
+	QColor penColour = Qt::black;
+
+	paint.setPen(m_colour);
+
+	IntervalList& intervals = m_model->intervals();
+	
+	int	 xS,xE,y;
+	bool draw, drawText, drawStart, drawEnd;
+
+    QPoint localPos;
+    long illuminateX = -1;
+
+    if (v->shouldIlluminateLocalFeatures(this, localPos)) {
+		// should highlight one endpoint ?
+		illuminateX = localPos.x();
+	}
+
+    for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		draw = drawText = drawStart = drawEnd = false;
+		
+		TimeIntervalPtr ti = (*i);
+		
+		if (ti->start() >= frame0 && ti->start() < frame1)
+		{
+			xS = v->getXForFrame(ti->start());
+			xE = v->getXForFrame(ti->end());
+			if (xE <= x1)
+				drawEnd = true;
+			else
+				xE = x1;	
+			draw = drawText = drawStart = true;
+		}
+		else if (ti->end() > frame0 && ti->end <= frame1)
+		{
+			xS = v->getXForFrame(ti->start());
+			if (xS < x0)
+				xS = x0;
+			xE = v->getXForFrame(ti->end());
+			draw = drawEnd = true;
+		}
+		else if (ti->start <= frame0 && ti->end >= frame1)
+		{
+			xS = x0;
+			xE = x1;
+			draw = true;
+		}
+		if (draw)
+		{
+			y = getYForHeight(v, ti->value());
+			paint.setBrush(brushColour);
+			paint.fillRect(xS, y-gIntervalHeight/2, (xE-xS+1), gIntervalHeight, brushColour);
+		}
+		if (drawStart)
+		{
+			if (abs(illuminateX - xS) < 3)
+				paint.setPen(Qt::black);
+			else
+				paint.setPen(brushColour);
+			paint.drawLine(xS, 0, xS, v->height() - 1);
+		}
+		if (drawEnd)
+		{
+			if (abs (illuminateX - xE) < 3)
+				paint.setPen(Qt::black);
+			else
+				paint.setPen(brushColour);
+			paint.drawLine(xE, 0, xE, v->height() - 1);
+		}
+		if (drawText)
+		{
+			paint.setPen(penColour);
+			paint.drawText(xS+10, y, ti->label());
+		}
+	}
+
+	paint.restore();
+}
+
+
+bool
+IntervalLayer::getValueExtents(float &min, float &max,
+                           bool &logarithmic, QString &unit) const
+{
+    return false;
+}
+
+IntervalList 
+IntervalLayer::getIntervalAt(View *v, int x, int y) // y < 0 means you don't make any test on it
+{
+	IntervalList result;
+	IntervalList& intervals = m_model->intervals();
+
+    for (IntervalListIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{			
+		TimeIntervalPtr ti = (*i);
+
+		int yT = getYForHeight(v, ti->value());
+		int xS = v->getXForFrame(ti->start());
+		int xE = v->getXForFrame(ti->end());
+		if ((x >= xS) && (x <= xE)) 
+		{
+			if ((y < 0) || (abs(y - yT) <= gIntervalHeight/2))
+				result.push_back(ti);
+		}
+	}
+
+	return result;
+}
+
+IntervalList 
+IntervalLayer::getInterval(long start, long end) 
+{
+	IntervalList result;
+	IntervalList& intervals = m_model->intervals();
+
+    for (IntervalListIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{			
+		TimeIntervalPtr ti = (*i);
+
+		if ( (start <= ti->start()) && (ti->start() <= end) &&
+			 (start <= ti->end()) && (ti->end() <= end) ) 
+		{
+			result.push_back(ti);
+		}
+	}
+
+	return result;
+}
+
+QString 
+IntervalLayer::getFeatureDescription(View *v, QPoint& pos) const
+{
+    if (!m_model || !m_model->getSampleRate()) return "";
+
+	QString description;
+
+    int x = pos.x();
+	int y = pos.y();
+
+	long frame = v->getFrameForX(x);	
+
+	IntervalList& intervals = m_model->intervals();
+    for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+		
+		if (ti->start() <= frame && ti->end() >= frame)
+		{
+			int y = getYForHeight(v, ti->value());
+			
+			if (abs(y - pos.y()) <= gIntervalHeight/2)
+			{
+				RealTime rtStart = RealTime::frame2RealTime(ti->start(), m_model->getSampleRate());
+				RealTime rtEnd = RealTime::frame2RealTime(ti->end(), m_model->getSampleRate());
+				RealTime rtDuration = rtEnd - rtStart;
+
+				description = QString(tr("Interval:\t%1\nStart:\t%2 End:\t%3\tDuration:\t%4"))
+					.arg(ti->label())
+					.arg(rtStart.toText(true).c_str())
+					.arg(rtEnd.toText(true).c_str())
+					.arg(rtDuration.toText(true).c_str());
+				break;
+			}
+		}
+	}
+
+	return description;
+}
+
+
+void
+IntervalLayer::drawStart(View *v, QMouseEvent *e)
+{
+	if (!m_model) {
+		std::cerr << "IntervalLayer::drawStart: no model" << std::endl;
+		return;
+    }
+
+    long frame = v->getFrameForX(e->x());
+    
+	if (frame < 0) 
+		frame = 0;
+    
+	frame = frame / m_model->getResolution() * m_model->getResolution();
+
+    int height = (int) (getHeightForY(v, e->y())*100+0.5);
+	float value = ((float) height)/100;
+	
+	m_editingInterval = new TimeInterval(frame, frame, "", value);
+
+	m_model->addInterval(m_editingInterval);
+
+    if (m_editingCommand) 
+	{
+		CommandHistory::getInstance()->addCommand(m_editingCommand, false);
+		m_editingCommand = 0;
+	}
+
+	m_editingCommand = new IntervalModel::IntervalCommand(m_model, m_editingInterval, 
+		IntervalModel::IntervalCommand::Creation ,
+		frame, frame, value, "");
+    
+    m_editing = 1;
+}
+
+void
+IntervalLayer::drawDrag(View *v, QMouseEvent *e)
+{
+	if (!m_model || !m_editing) return;
+
+    long frame = v->getFrameForX(e->x());
+
+    if (frame < 0) 
+		frame = 0;
+    
+	frame = frame / m_model->getResolution() * m_model->getResolution();
+
+	long start = m_editingInterval->start();
+	long end = frame;
+
+	if (start < end)
+	{
+		m_editing = 2;
+		m_editingInterval->end(frame);
+		m_editingCommand->newEnd(frame);
+	} else {
+		m_editing = 1;
+		m_editingInterval->start(frame);
+		m_editingCommand->newStart(frame);
+	}
+}
+
+void
+IntervalLayer::drawEnd(View *v, QMouseEvent *e)
+{
+	if (!m_model || !m_editing) 
+		return;
+
+    bool ok = false;
+    QString label = QInputDialog::getText(v, tr("Enter label"),
+					  tr("Please enter a new label:"),
+					  QLineEdit::Normal, "", &ok);
+
+    if (ok) {
+		m_editingInterval->label(label);
+		m_editingCommand->newLabel(label);
+    }
+
+	if (m_editingCommand) 
+	{
+		CommandHistory::getInstance()->addCommand(m_editingCommand, false);
+		m_editingCommand = 0;
+	}
+    
+	m_editing = false;
+}
+
+void
+IntervalLayer::editStart(View *view, QMouseEvent *evt)
+{
+	if (!m_model)
+		return;
+
+	IntervalList intervals = getIntervalAt(view, evt->x(), evt->y());
+
+	 for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	 {
+		TimeIntervalPtr ti = (*i);
+
+		int xS = view->getXForFrame(ti->start());
+		int xE = view->getXForFrame(ti->end());
+
+		if (abs(xS - evt->x()) < 5)
+		{
+			m_editing  = 1; // editing start
+			m_editingInterval = ti;
+			break;
+		}
+		else if (abs(xE - evt->x()) < 5)
+		{
+			m_editing  = 2; // editing end
+			m_editingInterval = ti;
+			break;
+		}
+		else 
+		{
+			m_editing = 0;
+		}
+	 }
+
+	if (m_editing)
+		view->setCursor(Qt::SizeHorCursor);
+
+    if (m_editingCommand) 
+	{
+		CommandHistory::getInstance()->addCommand(m_editingCommand, false);
+		m_editingCommand = 0;
+	}
+
+}
+
+void
+IntervalLayer::editDrag(View *view, QMouseEvent *evt)
+{
+    if (!m_model || !m_editing) 
+		return;
+
+	long frame = view->getFrameForX(evt->x());
+
+    if (!m_editingCommand) 
+	{
+		m_editingCommand = new IntervalModel::IntervalCommand(m_model, m_editingInterval, IntervalModel::IntervalCommand::Edition,
+					m_editingInterval->start(),
+					m_editingInterval->end(),
+					m_editingInterval->value(),
+					m_editingInterval->label());
+    }
+
+	if (m_editing == 1) // start
+	{
+		if (frame < m_editingInterval->end())
+			m_editingCommand->newStart(frame);
+	}
+	else if (m_editing == 2) // end
+	{
+		if (frame > m_editingInterval->start())
+			m_editingCommand->newEnd(frame);
+	}
+}
+
+void
+IntervalLayer::editEnd(View *view, QMouseEvent *evt)
+{
+    if (!m_model || !m_editing) 
+		return;
+
+	view->setCursor(Qt::UpArrowCursor);
+
+	if (m_editingCommand)
+	{
+		CommandHistory::getInstance()->addCommand(m_editingCommand, false);
+		m_editingCommand = 0;
+    }
+
+    
+    m_editing = false;
+}
+
+void
+IntervalLayer::editOpen(View *view, QMouseEvent *evt) // on double-click
+{
+    if (!m_model) return;
+
+	IntervalList intervals = getIntervalAt(view, evt->x(), evt->y());
+	if (! intervals.empty())
+	{
+		TimeIntervalPtr ti = intervals.front();
+
+		bool ok = false;
+	    ItemEditDialog *dialog = new ItemEditDialog
+		        (m_model->getSampleRate(),
+					 ItemEditDialog::ShowTime |
+					 ItemEditDialog::ShowDuration |
+					 ItemEditDialog::ShowText |
+					 ItemEditDialog::ShowValue);
+
+		dialog->setFrameTime(ti->start());
+		dialog->setFrameDuration(ti->end() - ti->start());
+	    dialog->setText(ti->label());
+		dialog->setValue((int)(ti->value()*100+0.5));
+
+	    if (dialog->exec() == QDialog::Accepted) 
+		{
+
+			IntervalModel::IntervalCommand *command =
+				new IntervalModel::IntervalCommand(m_model, ti, IntervalModel::IntervalCommand::Edition,
+					dialog->getFrameTime(),
+					dialog->getFrameTime() + dialog->getFrameDuration(),
+					dialog->getValue()/100,
+					dialog->getText());
+
+			CommandHistory::getInstance()->addCommand(command);
+			
+		}
+	}
+}
+
+void
+IntervalLayer::moveSelection(Selection s, size_t newStartFrame)
+{
+	if (!m_model) return;
+
+	IntervalList intervals = getInterval(s.getStartFrame(), s.getEndFrame());
+
+	MacroCommand * command = new MacroCommand("Drag Selection");
+
+	long newStart = 0;
+	long newEnd   = 0;
+
+	for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+
+		newStart = ti->start() + ((long) (newStartFrame - s.getStartFrame()));
+		newEnd   = ti->end() + ((long) (newStartFrame - s.getStartFrame()));
+		
+		IntervalModel::IntervalCommand *intervalCommand =
+			new IntervalModel::IntervalCommand(m_model, ti, IntervalModel::IntervalCommand::Edition,
+				newStart,
+				newEnd,
+				ti->value(),
+				ti->label());
+
+		m_model->changeInterval(ti, newStart, newEnd, ti->value(), ti->label() );
+		
+		command->addCommand(intervalCommand);
+	}
+
+	CommandHistory::getInstance()->addCommand(command, false);
+}
+
+void
+IntervalLayer::resizeSelection(Selection s, Selection newSize)
+{
+    if (!m_model) return;
+
+	IntervalList intervals = getInterval(s.getStartFrame(), s.getEndFrame());
+
+	MacroCommand * command = new MacroCommand("Resize Selection");
+
+	long newStart = 0;
+	long newEnd   = 0;
+
+	double ratio = ((double) (newSize.getEndFrame() - newSize.getStartFrame())) /
+					((double) (s.getEndFrame() - s.getStartFrame()));
+
+	for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+
+		newStart = (long) newSize.getStartFrame() + (long) ( ((double) ti->start() - (double) s.getStartFrame()) * ratio );
+		newEnd = (long) newSize.getStartFrame() + (long) ( ((double) ti->end() - (double) s.getStartFrame()) * ratio );
+		
+		IntervalModel::IntervalCommand *intervalCommand =
+			new IntervalModel::IntervalCommand(m_model, ti, IntervalModel::IntervalCommand::Edition,
+				newStart,
+				newEnd,
+				ti->value(),
+				ti->label());
+
+		m_model->changeInterval(ti, newStart, newEnd, ti->value(), ti->label() );
+		
+		command->addCommand(intervalCommand);
+	}
+
+	CommandHistory::getInstance()->addCommand(command, false);
+}
+
+void
+IntervalLayer::deleteSelection(Selection s)
+{
+    if (!m_model) return;
+
+	IntervalList intervals = getInterval(s.getStartFrame(), s.getEndFrame());
+
+	MacroCommand * command = new MacroCommand("Delete Selected Intervals");
+
+	for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+
+		m_model->removeInterval(ti);
+		
+		IntervalModel::IntervalCommand *intervalCommand =
+			new IntervalModel::IntervalCommand(m_model, ti, IntervalModel::IntervalCommand::Deletion,
+				ti->start(),
+				ti->end(),
+				ti->value(),
+				ti->label());
+
+		command->addCommand(intervalCommand);
+	}
+
+	CommandHistory::getInstance()->addCommand(command, false);
+}   
+
+void
+IntervalLayer::paste(const Clipboard &from, int frameOffset)
+{
+	if (!m_model) return;
+
+    const Clipboard::PointList &points = from.getPoints();
+
+    MacroCommand * command = new MacroCommand("Paste");
+
+    for (Clipboard::PointList::const_iterator i = points.begin(); i != points.end(); ++i) 
+	{    
+        if (!i->haveFrame()) 
+			continue;
+        
+		size_t frame = 0;
+        
+		if (frameOffset > 0 || -frameOffset < i->getFrame()) {
+            frame = i->getFrame() + frameOffset;
+        }
+
+		TimeIntervalPtr ti = new TimeInterval((long) frame, (long) (frame+i->getDuration()), i->getLabel(), i->getValue());
+
+		m_model->addInterval(ti);
+
+		IntervalModel::IntervalCommand *intervalCommand =
+			new IntervalModel::IntervalCommand(m_model, ti, IntervalModel::IntervalCommand::Creation,
+				ti->start(),
+				ti->end(),
+				ti->value(),
+				ti->label());
+
+		command->addCommand(intervalCommand);
+    
+    }
+
+    CommandHistory::getInstance()->addCommand(command, false);
+}
+
+void
+IntervalLayer::copy(Selection s, Clipboard &to)
+{
+	if (!m_model) return;
+
+	IntervalList intervals = getInterval(s.getStartFrame(), s.getEndFrame());
+
+	for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+
+		Clipboard::Point point(ti->start(), ti->value(), ti->end()-ti->start(), ti->label());
+        to.addPoint(point);
+	}
+}
+
+bool
+IntervalLayer::snapToFeatureFrame(View *v, int &frame,
+			      size_t &resolution,
+			      SnapType snap) const
+{
+    if (!m_model)
+		return Layer::snapToFeatureFrame(v, frame, resolution, snap);
+
+    resolution = m_model->getResolution();
+    
+	IntervalList& intervals = m_model->intervals();
+
+    int snapped, best = frame;
+    bool found = false;
+	
+	unsigned int dist, distMin;
+	
+	dist = distMin = m_model->getEndFrame();
+
+	for (IntervalListConstIterator i = intervals.begin(); i != intervals.end(); ++i) 
+	{
+		TimeIntervalPtr ti = (*i);
+		switch (snap)
+		{
+			case SnapRight:
+				if (ti->start() >= frame)
+				{
+					dist = ti->start() - frame;
+					snapped = ti->start();
+				} 
+				else if (ti->end() >= frame)
+				{
+					dist = ti->end() - frame;
+					snapped = ti->end();
+				}
+			break;
+
+			case SnapLeft:
+				if (ti->end() <= frame)
+				{
+					dist = frame - ti->end();
+					snapped = ti->end();
+				} 
+				else if (ti->start() <= frame)
+				{
+					dist = frame - ti->start();
+					snapped = ti->start();
+				}
+			break;
+
+			case SnapNearest:
+			{
+				int distS = abs(ti->start() - frame);
+				int distE = abs(ti->end() - frame);
+				if (distS < distE)
+				{
+					dist = distS;
+					snapped = ti->start();
+				} else
+				{
+					dist = distE;
+					snapped = ti->end();
+				}
+			}
+			break;
+
+			case SnapNeighbouring:
+			{
+				int distS = abs(ti->start() - frame);
+				int distE = abs(ti->end() - frame);
+				if (distS < 5)
+				{
+					dist = distS;
+					snapped = ti->start();
+				} else if (distE < 5)
+				{
+					dist = distE;
+					snapped = ti->end();
+				}
+			}
+			break;
+		}
+
+		if (dist < distMin)
+		{
+			found = true;
+			distMin = dist;
+			best = snapped;
+		}
+
+	}
+
+
+	if (found)
+	{
+		frame = best;
+	}
+
+    return found;
+}