diff --git a/ChangeLog b/ChangeLog index e51439049..0e73dde4e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,22 @@ +2009-02-10 Paul Giblock + + * include/gui: + * include/gui/tracks: + * include/gui/tracks/track_content_object_item.h: + * include/gui/tracks/track_item.h: + * include/gui/tracks/track_container_scene.h: + * include/track_container.h: + * include/track.h: + * src/gui/tracks: + * src/gui/tracks/track_content_object_item.cpp: + * src/gui/tracks/track_item.cpp: + * src/gui/tracks/track_container_scene.cpp: + * src/gui/main_window.cpp: + * src/core/track_container.cpp: + * src/core/track.cpp: + - Commit initial version of QGraphicsScene-based Song Editor + - Please save bugreports for another week or so, this is immature code + 2009-02-09 Paul Giblock * include/basic_filters.h: diff --git a/include/gui/tracks/track_container_scene.h b/include/gui/tracks/track_container_scene.h new file mode 100644 index 000000000..df9acef9a --- /dev/null +++ b/include/gui/tracks/track_container_scene.h @@ -0,0 +1,122 @@ +/* + * track_container_scene.h - view-component for trackContainer + * + * Copyright (c) 2009 Paul Giblock + * + * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + + +#ifndef _TRACK_CONTAINER_SCENE_H +#define _TRACK_CONTAINER_SCENE_H + +#include +#include + +#include "track.h" + +class trackContainer; +class TrackContentObjectItem; +class TrackItem; + +class TrackContainerScene : public QGraphicsScene +{ + Q_OBJECT + +public: + const static float DEFAULT_CELL_HEIGHT = 32; + const static float DEFAULT_CELL_WIDTH = 16; + + TrackContainerScene( QObject * parent, trackContainer * _tc ); + virtual ~TrackContainerScene(); + + + inline const midiTime & currentPosition( void ) const + { + return( m_currentPosition ); + } + + inline float pixelsPerTact( void ) const + { + return( m_ppt ); + } + + + void setPixelsPerTact( float _ppt ); + + trackContainer * model( void ) + { + return( m_trackContainer ); + } + + const trackContainer * model( void ) const + { + return( m_trackContainer ); + } + + + virtual QString nodeName( void ) const + { + return( "trackcontainerscene" ); + } + +private slots: + + void addTrack( track * _t ); + void removeTrack( track * _t ); + + /* + virtual void dragEnterEvent( QDragEnterEvent * _dee ); + virtual void dropEvent( QDropEvent * _de ); + virtual void mousePressEvent( QMouseEvent * _me ); + virtual void mouseMoveEvent( QMouseEvent * _me ); + virtual void mouseReleaseEvent( QMouseEvent * _me ); + virtual void resizeEvent( QResizeEvent * ); + virtual void undoStep( journalEntry & _je ); + virtual void redoStep( journalEntry & _je ); + */ + +protected: + midiTime m_currentPosition; + trackContainer * m_trackContainer; + float m_ppt; + + //QVector m_trackItems; + QMap m_trackItems; + + virtual void keyPressEvent( QKeyEvent * event ); + +private: + /* + enum Actions + { + AddTrack, + RemoveTrack + } ;*/ + + +//signals: + //void positionChanged( const midiTime & _pos ); + + +} ; + + + +#endif diff --git a/include/gui/tracks/track_content_object_item.h b/include/gui/tracks/track_content_object_item.h new file mode 100644 index 000000000..0bf56be49 --- /dev/null +++ b/include/gui/tracks/track_content_object_item.h @@ -0,0 +1,64 @@ +#ifndef TRACK_CONTENT_OBJECT_ITEM_H_ +#define TRACK_CONTENT_OBJECT_ITEM_H_ + +#include +#include +#include +#include +#include +#include +#include + +class trackContentObject; +class TrackItem; + +class TrackContentObjectItem : public QObject, public QGraphicsItem +{ + Q_OBJECT + + friend class TrackContainerScene; + +public: + TrackContentObjectItem( TrackItem * _track, trackContentObject * _object ); + + virtual ~TrackContentObjectItem() + { + if( m_snapBackAnimation != NULL ) + { + delete m_snapBackAnimation; + } + }; + + QRectF boundingRect() const; + + void paint( QPainter * _painter, const QStyleOptionGraphicsItem * _option, + QWidget * _widget ); + + QVariant itemChange( GraphicsItemChange _change, const QVariant & _value ); + + + virtual qreal zValue() const; + + // For TrackItem to call + void updateGeometry(); + +protected: + void prepareSnapBackAnimation( QTimeLine * timeLine ); + void prepareSnapBackAnimation( QTimeLine * timeLine, int newX ); + + virtual void mousePressEvent( QGraphicsSceneMouseEvent * event ); + virtual void mouseReleaseEvent( QGraphicsSceneMouseEvent * event ); + virtual void hoverEnterEvent( QGraphicsSceneHoverEvent * event ); + virtual void hoverLeaveEvent( QGraphicsSceneHoverEvent * event ); + +protected: + QPointF m_lastPos; + QPointF m_lastDest; + QGraphicsItemAnimation * m_snapBackAnimation; + static QTimeLine s_snapBackTimeLine; + + TrackItem * m_trackItem; + trackContentObject * m_tco; +}; + +#endif diff --git a/include/gui/tracks/track_item.h b/include/gui/tracks/track_item.h new file mode 100644 index 000000000..a4a54aafb --- /dev/null +++ b/include/gui/tracks/track_item.h @@ -0,0 +1,47 @@ +/* + * track_item.h + * + * Created on: Jan 27, 2009 + * Author: llama + */ + +#ifndef TRACK_ITEM_H_ +#define TRACK_ITEM_H_ + +#include +#include +#include + +class TrackContainerScene; +class track; +class trackContentObject; +class TrackContentObjectItem; + +class TrackItem : public QObject +{ + Q_OBJECT; +public: + TrackItem( TrackContainerScene * _scene, track * _track ); + virtual ~TrackItem( ); + + float height(); + void setHeight( float _height ); + + float y(); + void setY( float _x ); + +private slots: + void addTCO( trackContentObject * _tco ); + void removeTCO( trackContentObject * _tco ); + +private: + QRectF m_rect; + + TrackContainerScene * m_scene; + track * m_track; + QMap m_tcoItems; + +}; + + +#endif /* TRACK_ITEM_H_ */ diff --git a/include/track.h b/include/track.h index 526a71aa5..049ff10b9 100644 --- a/include/track.h +++ b/include/track.h @@ -63,7 +63,7 @@ const int TCO_BORDER_WIDTH = 1; class trackContentObject : public model, public journallingObject { Q_OBJECT - mapPropertyFromModel(bool,isMuted,setMuted,m_mutedModel); + mapPropertyFromModel( bool, isMuted, setMuted, m_mutedModel); public: trackContentObject( track * _track ); virtual ~trackContentObject(); @@ -463,6 +463,7 @@ signals: void destroyedTrack( void ); void nameChanged( void ); void trackContentObjectAdded( trackContentObject * ); + void trackContentObjectRemoved( trackContentObject * ); } ; diff --git a/include/track_container.h b/include/track_container.h index 6920d25df..8a6222786 100644 --- a/include/track_container.h +++ b/include/track_container.h @@ -82,6 +82,7 @@ public: signals: void trackAdded( track * _track ); + void trackRemoved( track * _track ); protected: mutable QReadWriteLock m_tracksMutex; diff --git a/src/core/track.cpp b/src/core/track.cpp index 826d3b145..cd7fbf798 100644 --- a/src/core/track.cpp +++ b/src/core/track.cpp @@ -493,7 +493,7 @@ void trackContentObjectView::dropEvent( QDropEvent * _de ) // the user doesn't expect... midiTime pos = m_tco->startPosition(); m_tco->restoreState( mmp.content().firstChild().toElement() ); - m_tco->movePosition( pos ); + m_tco->movePosition( pos ); automationPattern::resolveAllIDs(); _de->accept(); } @@ -1776,6 +1776,7 @@ void track::removeTCO( trackContentObject * _tco ) if( it != m_trackContentObjects.end() ) { m_trackContentObjects.erase( it ); + emit trackContentObjectRemoved( _tco ); engine::getSong()->setModified(); } } diff --git a/src/core/track_container.cpp b/src/core/track_container.cpp index 4dc9f1b5a..1c33542b8 100644 --- a/src/core/track_container.cpp +++ b/src/core/track_container.cpp @@ -170,6 +170,7 @@ void trackContainer::removeTrack( track * _track ) m_tracksMutex.lockForWrite(); m_tracks.remove( index ); m_tracksMutex.unlock(); + emit trackRemoved( _track ); if( engine::getSong() ) { @@ -193,6 +194,7 @@ void trackContainer::clearAllTracks( void ) //m_tracksMutex.lockForWrite(); while( !m_tracks.isEmpty() ) { + emit trackRemoved( m_tracks.first() ); delete m_tracks.first(); } //m_tracksMutex.unlock(); diff --git a/src/gui/main_window.cpp b/src/gui/main_window.cpp index 03e0fd3ff..9bcb5fb76 100644 --- a/src/gui/main_window.cpp +++ b/src/gui/main_window.cpp @@ -40,6 +40,8 @@ #include #include +#include + #include "lmmsversion.h" #include "main_window.h" @@ -74,6 +76,7 @@ #include "cpuload_widget.h" #include "visualization_widget.h" +#include "gui/tracks/track_container_scene.h" mainWindow::mainWindow( void ) : @@ -192,6 +195,29 @@ mainWindow::mainWindow( void ) : vbox->addWidget( w ); setCentralWidget( main_widget ); + /// HACK TO CREATE EXTRA SONG EDITOR FOR NOW /// + //Fun test + TrackContainerScene * scene = new TrackContainerScene( this, engine::getSong() ); + + // Mem leak + QPixmap * sceneBg = new QPixmap( 16*4*2, 32 ); + QPainter * sceneBgPainter = new QPainter( sceneBg ); + engine::getLmmsStyle()->drawTrackContentBackground( + sceneBgPainter, + QSize( 16*4, 32 ), + 16 ); + + QGraphicsView *view = new QGraphicsView( scene ); + view->setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform ); + view->setDragMode( QGraphicsView::RubberBandDrag ); + view->setAlignment( Qt::AlignLeft | Qt::AlignTop ); + view->setBackgroundBrush( QBrush(*sceneBg) ); + view->show(); + //view->scale(2.0, 1.0); + + QMdiSubWindow * subWin = workspace()->addSubWindow( view ); + /// END HACK TO CREATE EXTRA SONG EDITOR FOR NOW /// + m_updateTimer.start( 1000 / 20, this ); // 20 fps } diff --git a/src/gui/tracks/track_container_scene.cpp b/src/gui/tracks/track_container_scene.cpp new file mode 100644 index 000000000..1c7aa5917 --- /dev/null +++ b/src/gui/tracks/track_container_scene.cpp @@ -0,0 +1,118 @@ +#include +#include +#include + +#include + +#include "gui/tracks/track_container_scene.h" +#include "gui/tracks/track_content_object_item.h" +#include "gui/tracks/track_item.h" +#include "track_container.h" + +TrackContainerScene::TrackContainerScene( QObject * parent, trackContainer * _tc ) : + QGraphicsScene( parent ), + //modelView( NULL, this ), + //journallingObject(), + //serializingObjectHook(), + m_trackContainer( _tc ), + m_ppt( 16 ) +{ + connect( m_trackContainer, SIGNAL( trackAdded( track * ) ), + this, SLOT( addTrack( track * ) ), + Qt::QueuedConnection ); + connect( m_trackContainer, SIGNAL( trackRemoved( track * ) ), + this, SLOT( removeTrack( track * ) ) ); +} + + +TrackContainerScene::~TrackContainerScene() +{ + +} + + + +void TrackContainerScene::setPixelsPerTact( float _ppt ) +{ + m_ppt = _ppt; +} + + + +void TrackContainerScene::addTrack( track * _t ) +{ + TrackItem * item = new TrackItem( this, _t ); + item->setHeight( DEFAULT_CELL_HEIGHT ); + item->setY( m_trackItems.size() * DEFAULT_CELL_HEIGHT ); + + m_trackItems.insert( _t, item ); +} + + +void TrackContainerScene::removeTrack( track * _t ) +{ + QMap::iterator i = + m_trackItems.find( _t ); + + if( i != m_trackItems.end() && i.key() == _t ) + { + TrackItem * item = i.value(); + qreal h = item->height(); + + i = m_trackItems.erase(i); + delete item; + + // Now move everything after back up + while( i != m_trackItems.end() ) + { + (*i)->setY( (*i)->y() - h ); + ++i; + } + } +} + + + +void TrackContainerScene::keyPressEvent( QKeyEvent * event ) +{ + if( event->modifiers() == Qt::ShiftModifier ) + { + const qreal cellWidth = TrackContainerScene::DEFAULT_CELL_WIDTH; + + if( event->key() == Qt::Key_Left ) + { + } + else if( event->key() == Qt::Key_Right ) + { + QTimeLine * timeLine = new QTimeLine(); + + // TODO: Cleanup the friendly references + QList selItems = selectedItems(); + for( QList::iterator it = selItems.begin(); + it != selItems.end(); ++it ) + { + TrackContentObjectItem * tcoItem = + dynamic_cast( *it ); + if( tcoItem ) + { + qreal destPos = tcoItem->m_snapBackAnimation->posAt( 1.0 ).x(); + tcoItem->prepareSnapBackAnimation( timeLine, destPos + cellWidth ); + } + } + + + + timeLine->setCurrentTime( 0.0f ); + timeLine->setDuration( 300 ); + timeLine->setCurveShape( QTimeLine::EaseInOutCurve ); + connect( timeLine, SIGNAL(finished()), timeLine, SLOT(deleteLater())); + timeLine->start(); + } + } +} + + + + +#include "gui/tracks/moc_track_container_scene.cxx" + diff --git a/src/gui/tracks/track_content_object_item.cpp b/src/gui/tracks/track_content_object_item.cpp new file mode 100644 index 000000000..60575ac3b --- /dev/null +++ b/src/gui/tracks/track_content_object_item.cpp @@ -0,0 +1,244 @@ +#include +#include +#include +#include +#include + +#include "gui/tracks/track_content_object_item.h" +#include "gui/tracks/track_container_scene.h" +#include "gui/tracks/track_item.h" +#include "track.h" + +//QTimeLine TrackContentObjectItem::s_timeLine; +//QGraphicsItemAnimation TrackContentObjectItem::s_animation; +QTimeLine TrackContentObjectItem::s_snapBackTimeLine; + +TrackContentObjectItem::TrackContentObjectItem( TrackItem * _track, trackContentObject * _object ) : + QObject(), + QGraphicsItem(), + m_trackItem( _track ), + m_tco( _object ), + m_snapBackAnimation( NULL ) +{ + //m_object = _object; + setFlags( QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable ); + setCursor( Qt::OpenHandCursor ); + + midiTime startPos = _object->startPosition(); + float x = TrackContainerScene::DEFAULT_CELL_WIDTH * + startPos.getTicks() / midiTime::ticksPerTact(); + setPos( x, _track->y() ); + setZValue(x); + + m_snapBackAnimation = new QGraphicsItemAnimation(); + m_snapBackAnimation->setItem( this ); +} + +QRectF TrackContentObjectItem::boundingRect() const +{ + qreal penWidth = 1; + // TODO: Calculate based on track length and an adjustable height. + /*return QRectF( -64 - penWidth / 2, -16 - penWidth / 2, + 128 + penWidth / 2, 32 + penWidth / 2 );*/ + QRectF rc = QRectF( 0, 0, TrackContainerScene::DEFAULT_CELL_WIDTH * + m_tco->length().getTicks() / midiTime::ticksPerTact(), m_trackItem->height() ); + return rc; +} + +qreal TrackContentObjectItem::zValue() const +{ + //return x(); + //return m_tco->startPotion().getTicks(); + return QGraphicsItem::zValue(); +} + +void TrackContentObjectItem::updateGeometry() +{ + prepareGeometryChange(); +} + + +void TrackContentObjectItem::paint( QPainter * _painter, + const QStyleOptionGraphicsItem * _option, QWidget * _widget ) +{ + + QColor col; + if( !isSelected() ) + { + col = QColor( 0x00, 0x33, 0x99 ); + } + else + { + col = QColor( 0x99, 0x33, 0x00 ); + } + QColor col0 = col.light( 130 ); + QColor col1 = col.light( 70 ); + QColor col2 = col.light( 40 ); + + QRectF rc = boundingRect(); + + qreal xscale = _option->matrix.m11(); + _painter->save(); + _painter->scale( 1.0f/xscale, 1.0f ); + rc.setWidth( rc.width() * xscale ); + + QLinearGradient lingrad( 0, 0, 0, rc.height() ); + lingrad.setColorAt( 0, col0 ); + lingrad.setColorAt( 1, col1 ); + + QLinearGradient bordergrad( 0, 0, 0, rc.height() ); + bordergrad.setColorAt( 1, col2 ); + bordergrad.setColorAt( 0, col1 ); + + + rc.adjust( 0, 0, -1, -1 ); + + + _painter->setRenderHint( QPainter::Antialiasing, true ); + _painter->setBrush( lingrad ); + _painter->setPen( QPen( bordergrad, 1.5 ) ); // QColor( 6, 6, 6 ) ); + _painter->drawRoundedRect( rc, 4, 4 ); + _painter->setRenderHint( QPainter::Antialiasing, false ); + + _painter->restore(); +} + +QVariant TrackContentObjectItem::itemChange( GraphicsItemChange _change, const QVariant & _value ) +{ + if( _change == ItemPositionChange && scene( ) ) + { + // value is the new position + QPointF newPos = _value.toPointF( ); + + //printf("TCO %lld: itemChange (%.2f %.2f) -> ", m_tco, newPos.x(), newPos.y()); + + if( newPos.x() < 0 ) + { + newPos.setX( 0 ); + } + if( newPos.y() < 0 ) + { + newPos.setY( 0 ); + } + + /* Let's just short-circuit the Y for now + if( fmod( newPos.y(), 32 ) != 16 ) + { + newPos.setY( newPos.y() + 16 - ( fmod( newPos.y(), 32 ) ) ); + } */ + newPos.setY( m_trackItem->y() ); + + /* + if( fmod( newPos.x(), 16 ) != 0 ) + { + newPos.setX( newPos.x() - ( fmod( newPos.x(), 16 ) ) ); + } + + if( newPos.x() != x() ) { + setZValue(newPos.x()); + }*/ + + + //printf("(%.2f %.2f)\n", newPos.x(), newPos.y()); + + + return newPos; + } + else if( _change == QGraphicsItem::ItemSelectedChange && scene() ) + { + bool sel = _value.toBool(); + if( sel ) + { + setCursor( Qt::OpenHandCursor ); + } + else + { + setCursor( Qt::OpenHandCursor ); + } + } + + return QGraphicsItem::itemChange( _change, _value ); +} + + +void TrackContentObjectItem::mousePressEvent( QGraphicsSceneMouseEvent * event ) +{ + QGraphicsItem::mousePressEvent( event ); + + if( isSelected() ) + { + setCursor( Qt::ClosedHandCursor ); + } +} + + + +void TrackContentObjectItem::mouseReleaseEvent( QGraphicsSceneMouseEvent * event ) +{ + QGraphicsItem::mouseReleaseEvent( event ); + + setCursor( Qt::OpenHandCursor ); + + QTimeLine * timeLine = new QTimeLine(); + prepareSnapBackAnimation( timeLine ); + + if( isSelected() ) { + QList selItems = scene()->selectedItems(); + for( QList::iterator it = selItems.begin(); + it != selItems.end(); ++it ) + { + TrackContentObjectItem * tcoItem = + dynamic_cast( *it ); + if( tcoItem ) + { + tcoItem->prepareSnapBackAnimation( timeLine ); + } + } + + } + + timeLine->setCurrentTime( 0.0f ); + timeLine->setDuration( 300 ); + timeLine->setCurveShape( QTimeLine::EaseInOutCurve ); + connect( timeLine, SIGNAL(finished()), timeLine, SLOT(deleteLater())); + timeLine->start(); +} + + + +void TrackContentObjectItem::hoverEnterEvent( QGraphicsSceneHoverEvent * event ) +{ + QGraphicsItem::hoverEnterEvent( event ); +} + + + +void TrackContentObjectItem::hoverLeaveEvent( QGraphicsSceneHoverEvent * event ) +{ + QGraphicsItem::hoverLeaveEvent( event ); +} + + + + +void TrackContentObjectItem::prepareSnapBackAnimation( QTimeLine * timeLine ) +{ + prepareSnapBackAnimation( timeLine, x() ); +} + + + +void TrackContentObjectItem::prepareSnapBackAnimation( QTimeLine * timeLine, int newX ) +{ + const qreal cellWidth = TrackContainerScene::DEFAULT_CELL_WIDTH; + const qreal xVal = newX + TrackContainerScene::DEFAULT_CELL_WIDTH * 0.5f; + + QPointF newPos( xVal - ( fmod( xVal, cellWidth) ), y() ); + + m_snapBackAnimation->setTimeLine( timeLine ); + m_snapBackAnimation->setPosAt( 0.0, pos() ); + m_snapBackAnimation->setPosAt( 1.0, newPos ); +} + + +#include "gui/tracks/moc_track_content_object_item.cxx" diff --git a/src/gui/tracks/track_item.cpp b/src/gui/tracks/track_item.cpp new file mode 100644 index 000000000..54fe3ea15 --- /dev/null +++ b/src/gui/tracks/track_item.cpp @@ -0,0 +1,109 @@ + +#include "track.h" +#include "gui/tracks/track_item.h" +#include "gui/tracks/track_content_object_item.h" +#include "gui/tracks/track_container_scene.h" + +TrackItem::TrackItem( TrackContainerScene * _scene, track * _track ) +{ + m_scene = _scene; + m_track = _track; + + // create views for already existing TCOs + const track::tcoVector & tcos = m_track->getTCOs(); + for( track::tcoVector::const_iterator it = tcos.begin(); it != tcos.end(); ++it ) + { + addTCO( *it ); + } + + QObject * obj = _track; + connect( obj, SIGNAL( trackContentObjectAdded( trackContentObject * ) ), + this, SLOT( addTCO( trackContentObject * ) ), + Qt::QueuedConnection ); + + connect( obj, SIGNAL( trackContentObjectRemoved( trackContentObject * ) ), + this, SLOT( removeTCO( trackContentObject * ) ) ); +} + + + +/* WTF?!?! */ +TrackItem::~TrackItem() +{ + for( QMap::iterator i = m_tcoItems.begin(); + i != m_tcoItems.end(); ++i ) + { + TrackContentObjectItem * item = i.value(); + m_scene->removeItem(item); + m_tcoItems.erase(i); + delete item; + } +} + + +void TrackItem::addTCO( trackContentObject * _tco ) +{ + TrackContentObjectItem * tcoItem = new TrackContentObjectItem( this, _tco ); + + // TODO refactor to private updateTCOGeometry + tcoItem->setPos( tcoItem->x(), y() ); + + m_tcoItems.insert( _tco, tcoItem ); + m_scene->addItem( tcoItem ); +} + + + +void TrackItem::removeTCO( trackContentObject * _tco ) +{ + QMap::iterator i = + m_tcoItems.find( _tco ); + + if( i != m_tcoItems.end() && i.key() == _tco ) + { + TrackContentObjectItem * item = i.value(); + m_scene->removeItem(*i); + m_tcoItems.erase(i); + delete item; + } + } + + +void TrackItem::setHeight( float _height ) +{ + m_rect.setHeight( _height ); + for( QMap::const_iterator it = m_tcoItems.constBegin(); + it != m_tcoItems.constEnd(); ++it ) + { + (*it)->updateGeometry(); + } +} + + + +void TrackItem::setY( float _y ) +{ + //printf("TRK %lld: setY(%.2f)\n", m_track, _y); + m_rect.moveTop( _y ); + for( QMap::const_iterator it = m_tcoItems.constBegin(); + it != m_tcoItems.constEnd(); ++it ) + { + (*it)->setPos( (*it)->x(), y() ); + } +} + + + +float TrackItem::height() +{ + return m_rect.height(); +} + + + +float TrackItem::y() +{ + return m_rect.y(); +} + +#include "gui/tracks/moc_track_item.cxx"