13633248611

Committed 03 Mar 2025 02:31PM UTC coverage: 31.871% (+0.4%) from 31.5%

Build # 13633248611

Build Type

push

github

Committed by

web-flow

Commit Message

actions: add chrpath to profile

Run Details

14689 of 46089 relevant lines covered (31.87%)

26426.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/ui/src/showmanager/multitrackview.cpp

/*
  Q Light Controller Plus
  multitrackview.cpp

  Copyright (C) Massimo Callegari

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

#include <QGraphicsSceneMouseEvent>
#include <QGraphicsItem>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QMouseEvent>
#include <QMessageBox>
#include <QScrollBar>
#include <QSlider>
#include <QDebug>

#include "multitrackview.h"
#include "track.h"

#define VIEW_DEFAULT_WIDTH  2000
#define VIEW_DEFAULT_HEIGHT 600

MultiTrackView::MultiTrackView(QWidget *parent) :
        QGraphicsView(parent)
{
    m_scene = new QGraphicsScene();
    m_scene->setSceneRect(0, 0, VIEW_DEFAULT_WIDTH, VIEW_DEFAULT_HEIGHT);
    setSceneRect(0, 0, VIEW_DEFAULT_WIDTH, VIEW_DEFAULT_HEIGHT);
    setScene(m_scene);

    m_timeSlider = new QSlider(Qt::Horizontal);
    m_timeSlider->setRange(1, 15);
    m_timeSlider->setValue(3);
    m_timeSlider->setSingleStep(1);
    m_timeSlider->setFixedSize(TRACK_WIDTH - 4, HEADER_HEIGHT);

    m_timeSlider->setStyleSheet("QSlider { background-color: #969696; }"
                          "QSlider::groove:horizontal {"
                          "border: 1px solid #999999;"
                          "height: 10px;"
                          "background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #b1b1b1, stop:1 #d4d4d4);"
                          "}"
                          "QSlider::handle:horizontal {"
                          "background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #c4c4c4, stop:1 #8f8f8f);"
                          "border: 1px solid #5c5c5c;"
                          "width: 20px;"
                          "margin: -2px 0; /* handle is placed by default on the contents rect of the groove. Expand outside the groove */"
                          "border-radius: 4px;"
                          "}");
    connect(m_timeSlider, SIGNAL(valueChanged(int)), this, SLOT(slotTimeScaleChanged(int)));
    m_scene->addWidget(m_timeSlider);

    m_header = new ShowHeaderItem(m_scene->width());
    m_header->setPos(TRACK_WIDTH, 0);
    connect(m_header, SIGNAL(itemClicked(QGraphicsSceneMouseEvent *)),
            this, SLOT(slotHeaderClicked(QGraphicsSceneMouseEvent *)));
    m_scene->addItem(m_header);
    m_snapToGrid = false;

    m_cursor = new ShowCursorItem(m_scene->height());
    m_cursor->setPos(TRACK_WIDTH, 0);
    m_cursor->setZValue(999); // make sure the cursor is always on top of everything else
    m_scene->addItem(m_cursor);
    connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotViewScrolled(int)));

    m_vdivider = NULL;
    // draw horizontal and vertical lines for tracks
    updateTracksDividers();
}

void MultiTrackView::updateTracksDividers()
{
    if (m_hdividers.count() > 0)
    {
        int hdivCount = m_hdividers.count();
        for (int c = 0; c < hdivCount; c++)
            m_scene->removeItem(m_hdividers.takeLast());
        m_hdividers.clear();
    }
    if (m_vdivider != NULL)
        m_scene->removeItem(m_vdivider);

    int ypos = 35 + TRACK_HEIGHT;
    int hDivNum = 6;
    if (m_tracks.count() > 5)
        hDivNum = m_tracks.count();
    for (int j = 0; j < hDivNum; j++)
    {
        QGraphicsItem *item = m_scene->addRect(0, ypos + (j * TRACK_HEIGHT),
                                               m_scene->width(), 1,
                                               QPen(QColor(150, 150, 150, 255)),
                                               QBrush(QColor(190, 190, 190, 255)));
        item->setZValue(-1);
        m_hdividers.append(item);
    }
    m_vdivider = m_scene->addRect(TRACK_WIDTH - 3, 0, 3, m_scene->height(),
                        QPen(QColor(150, 150, 150, 255)),
                        QBrush(QColor(190, 190, 190, 255)));
}

void MultiTrackView::setViewSize(int width, int height)
{
    m_scene->setSceneRect(0, 0, width, height);
    setSceneRect(0, 0, width, height);
    m_header->setWidth(width);
    if (m_snapToGrid == true)
        m_header->setHeight(height);
    else
        m_header->setHeight(HEADER_HEIGHT);
    updateTracksDividers();
}

void MultiTrackView::updateViewSize()
{
    quint32 gWidth = VIEW_DEFAULT_WIDTH;
    quint32 gHeight = VIEW_DEFAULT_HEIGHT;

    // find leftmost show item
    foreach (ShowItem *item, m_items)
    {
        if (item->x() + item->getWidth() > gWidth)
            gWidth = item->x() + item->getWidth();
    }

    if ((m_tracks.count() * TRACK_HEIGHT) + HEADER_HEIGHT > VIEW_DEFAULT_HEIGHT)
    {
        gHeight = (m_tracks.count() * TRACK_HEIGHT) + HEADER_HEIGHT;
        m_cursor->setHeight(gHeight);
    }

    if (gWidth > VIEW_DEFAULT_WIDTH || gHeight > VIEW_DEFAULT_HEIGHT)
        setViewSize(gWidth + 1000, gHeight);
}

void MultiTrackView::resetView()
{
    for (int t = 0; t < m_tracks.count(); t++)
        m_scene->removeItem(m_tracks.at(t));
    m_tracks.clear();

    for (int i = 0; i < m_items.count(); i++)
        m_scene->removeItem(m_items.at(i));
    m_items.clear();

    rewindCursor();
    this->horizontalScrollBar()->setSliderPosition(0);
    this->verticalScrollBar()->setSliderPosition(0);
    m_scene->update();
}

void MultiTrackView::addTrack(Track *track)
{
    // check if track already exists
    foreach (TrackItem *item, m_tracks)
    {
        if (item->getTrack()->id() == track->id())
            return;
    }

    TrackItem *trackItem = new TrackItem(track, m_tracks.count());
    trackItem->setName(track->name());
    trackItem->setPos(0, HEADER_HEIGHT + (TRACK_HEIGHT * m_tracks.count()));
    m_scene->addItem(trackItem);
    m_tracks.append(trackItem);
    activateTrack(track);
    connect(trackItem, SIGNAL(itemClicked(TrackItem*)),
            this, SLOT(slotTrackClicked(TrackItem*)));
    connect(trackItem, SIGNAL(itemDoubleClicked(TrackItem*)),
            this, SLOT(slotTrackDoubleClicked(TrackItem*)));
    connect(trackItem, SIGNAL(itemSoloFlagChanged(TrackItem*,bool)),
            this, SLOT(slotTrackSoloFlagChanged(TrackItem*,bool)));
    connect(trackItem, SIGNAL(itemMuteFlagChanged(TrackItem*,bool)),
            this, SLOT(slotTrackMuteFlagChanged(TrackItem*,bool)));
    connect(trackItem, SIGNAL(itemMoveUpDown(Track*,int)),
            this, SIGNAL(trackMoved(Track*,int)));
    connect(trackItem, SIGNAL(itemRequestDelete(Track*)),
            this, SIGNAL(trackDelete(Track*)));
}

void MultiTrackView::setItemCommonProperties(ShowItem *item, ShowFunction *func, int trackNum)
{
    qDebug() << "[" << func->functionID() << "] Start time:" << func->startTime() << "Duration:" << func->duration();

    item->setTrackIndex(trackNum);

    int timeScale = m_timeSlider->value();

    if (func->startTime() == UINT_MAX)
    {
        item->setStartTime(getTimeFromCursor());
        item->setPos(m_cursor->x() + 2, 36 + (trackNum * TRACK_HEIGHT));
    }
    else
        item->setPos(getPositionFromTime(func->startTime()) + 2, 36 + (trackNum * TRACK_HEIGHT));

    item->setTimeScale(timeScale);

    connect(item, SIGNAL(itemDropped(QGraphicsSceneMouseEvent *, ShowItem *)),
            this, SLOT(slotItemMoved(QGraphicsSceneMouseEvent *, ShowItem *)));
    connect(item, SIGNAL(alignToCursor(ShowItem*)),
            this, SLOT(slotAlignToCursor(ShowItem*)));
    m_scene->addItem(item);
    m_items.append(item);
    int new_scene_width = item->x() + item->getWidth();
    if (new_scene_width > VIEW_DEFAULT_WIDTH && new_scene_width > m_scene->width())
        setViewSize(new_scene_width + 500, VIEW_DEFAULT_HEIGHT);
}

void MultiTrackView::addSequence(Chaser *chaser, Track *track, ShowFunction *sf)
{
    if (m_tracks.isEmpty())
        return;

    int trackNum = getTrackIndex(track);

    if (track == NULL)
        track = m_tracks.at(trackNum)->getTrack();

    ShowFunction *func = sf;
    if (func == NULL)
        func = track->createShowFunction(chaser->id());

    SequenceItem *item = new SequenceItem(chaser, func);
    setItemCommonProperties(item, func, trackNum);
}

void MultiTrackView::addAudio(Audio *audio, Track *track, ShowFunction *sf)
{
    if (m_tracks.isEmpty())
        return;

    int trackNum = getTrackIndex(track);

    if (track == NULL)
        track = m_tracks.at(trackNum)->getTrack();

    ShowFunction *func = sf;
    if (func == NULL)
        func = track->createShowFunction(audio->id());

    AudioItem *item = new AudioItem(audio, func);
    setItemCommonProperties(item, func, trackNum);
}

void MultiTrackView::addRGBMatrix(RGBMatrix *rgbm, Track *track, ShowFunction *sf)
{
    if (m_tracks.isEmpty())
        return;

    int trackNum = getTrackIndex(track);

    if (track == NULL)
        track = m_tracks.at(trackNum)->getTrack();

    ShowFunction *func = sf;
    if (func == NULL)
        func = track->createShowFunction(rgbm->id());

    RGBMatrixItem *item = new RGBMatrixItem(rgbm, func);
    setItemCommonProperties(item, func, trackNum);
}

void MultiTrackView::addEFX(EFX *efx, Track *track, ShowFunction *sf)
{
    if (m_tracks.isEmpty())
        return;

    int trackNum = getTrackIndex(track);

    if (track == NULL)
        track = m_tracks.at(trackNum)->getTrack();

    ShowFunction *func = sf;
    if (func == NULL)
        func = track->createShowFunction(efx->id());

    EFXItem *item = new EFXItem(efx, func);
    setItemCommonProperties(item, func, trackNum);
}

void MultiTrackView::addVideo(Video *video, Track *track, ShowFunction *sf)
{
    if (m_tracks.isEmpty())
        return;

    int trackNum = getTrackIndex(track);

    if (track == NULL)
        track = m_tracks.at(trackNum)->getTrack();

    ShowFunction *func = sf;
    if (func == NULL)
        func = track->createShowFunction(video->id());

    VideoItem *item = new VideoItem(video, func);
    setItemCommonProperties(item, func, trackNum);
}

quint32 MultiTrackView::deleteSelectedItem()
{
    ShowItem *selectedItem = getSelectedItem();
    if (selectedItem != NULL)
    {
        QString msg = tr("Do you want to DELETE item:") + QString("\n\n") + selectedItem->functionName();

        // Ask for user's confirmation
        if (QMessageBox::question(this, tr("Delete Functions"), msg,
                                  QMessageBox::Yes, QMessageBox::No)
                                  == QMessageBox::Yes)
        {
            quint32 fID = selectedItem->functionID();
            m_scene->removeItem(selectedItem);
            m_items.removeOne(selectedItem);
            return fID;
        }
        return Function::invalidId();
    }

    int trackIndex = 0;
    foreach (TrackItem *item, m_tracks)
    {
        if (item->isActive() == true)
        {
            Track *track = item->getTrack();
            quint32 trackID = track->id();
            QList <ShowFunction *> sfList = track->showFunctions();
            QString msg = tr("Do you want to DELETE track:") + QString("\n\n") + track->name();
            if (sfList.count() > 0)
            {
                msg += QString("\n\n") + tr("This operation will also DELETE:") + QString("\n\n");
                foreach (ShowItem *item, m_items)
                {
                    if (item->getTrackIndex() == trackIndex)
                        msg += item->functionName() + QString("\n");
                }
            }

            // Ask for user's confirmation
            if (QMessageBox::question(this, tr("Delete Track"), msg,
                                  QMessageBox::Yes, QMessageBox::No)
                                  == QMessageBox::Yes)
            {
                m_scene->removeItem(item);
                m_tracks.removeOne(item);
                return trackID;
            }
            return Function::invalidId();
        }
        trackIndex++;
    }

    return Function::invalidId();
}

void MultiTrackView::deleteShowItem(Track *track, ShowFunction *sf)
{
    for (int i = 0; i < m_items.count(); i++)
    {
        if (m_items.at(i)->showFunction() == sf)
        {
            m_scene->removeItem(m_items.at(i));
            break;
        }
    }

    track->removeShowFunction(sf);
}

void MultiTrackView::moveCursor(quint32 timePos)
{
    int newPos = getPositionFromTime(timePos);
    m_cursor->setPos(newPos, 0);
    m_cursor->setTime(timePos);
}

void MultiTrackView::rewindCursor()
{
    m_cursor->setPos(TRACK_WIDTH, 0);
    m_cursor->setTime(0);
}

void MultiTrackView::activateTrack(Track *track)
{
    foreach (TrackItem *item, m_tracks)
    {
        if (item->getTrack()->id() == track->id())
            item->setActive(true);
        else
            item->setActive(false);
    }
}

ShowItem *MultiTrackView::getSelectedItem()
{
    foreach (ShowItem *item, m_items)
        if (item->isSelected())
            return item;

    return NULL;
}

quint32 MultiTrackView::getTimeFromCursor()
{
    quint32 s_time = (double)(m_cursor->x() - TRACK_WIDTH) *
                     (m_header->getTimeScale() * 1000) /
                     (double)(m_header->getHalfSecondWidth() * 2);
    return s_time;
}

quint32 MultiTrackView::getTimeFromPosition(qreal pos)
{
    return ((double)(pos - TRACK_WIDTH) *
            (double)(m_header->getTimeScale() * 1000) /
            (double)(m_header->getHalfSecondWidth() * 2));
}

quint32 MultiTrackView::getPositionFromTime(quint32 time)
{
    if (time == 0)
        return TRACK_WIDTH;
    quint32 xPos = ((double)time / 500) *
                    ((double)m_header->getHalfSecondWidth() /
                     (double)m_header->getTimeScale());
    return TRACK_WIDTH + xPos;
}

int MultiTrackView::getTrackIndex(Track *trk)
{
    for (int idx = 0; idx < m_tracks.count(); idx++)
    {
        if ((trk == NULL && m_tracks.at(idx)->isActive()) ||
            (trk != NULL && trk == m_tracks.at(idx)->getTrack()))
                return idx;
    }

    return 0;
}

void MultiTrackView::setHeaderType(Show::TimeDivision type)
{
    m_header->setTimeDivisionType(type);
}

Show::TimeDivision MultiTrackView::getHeaderType()
{
    return m_header->getTimeDivisionType();
}

void MultiTrackView::setBPMValue(int value)
{
    m_header->setBPMValue(value);
}

void MultiTrackView::setSnapToGrid(bool enable)
{
    m_snapToGrid = enable;
    if (enable == true)
        m_header->setHeight(m_scene->height());
    else
        m_header->setHeight(HEADER_HEIGHT);
}

void MultiTrackView::mouseReleaseEvent(QMouseEvent * e)
{
    if (getSelectedItem() == NULL)
    {
        // Don't handle positions at the left of QLC+ window
        if (mapToScene(e->pos()).x() < 0)
            return;
        quint32 xpos = mapToScene(e->pos()).x();
        if (xpos > TRACK_WIDTH)
        {
            m_cursor->setPos(xpos, 0);
            m_cursor->setTime(getTimeFromCursor());
            emit timeChanged(m_cursor->getTime());
        }
        emit viewClicked(e);
    }

    QGraphicsView::mouseReleaseEvent(e);
    //qDebug() << Q_FUNC_INFO << "View clicked at pos: " << e->pos().x() << e->pos().y();
}

void MultiTrackView::wheelEvent(QWheelEvent *event)
{
    if (event->modifiers() & Qt::ControlModifier)
    {
        int zoomValue = m_timeSlider->value();
        if (event->pixelDelta().y() > 0)
            zoomValue++;
        else
            zoomValue--;

        if (zoomValue >= m_timeSlider->minimum() && zoomValue <= m_timeSlider->maximum())
            m_timeSlider->setValue(zoomValue);
        return;
    }
    QGraphicsView::wheelEvent(event);
}

void MultiTrackView::slotHeaderClicked(QGraphicsSceneMouseEvent *event)
{
    m_cursor->setPos(TRACK_WIDTH + event->pos().toPoint().x(), 0);
    m_cursor->setTime(getTimeFromCursor());
    qDebug() << Q_FUNC_INFO << "Cursor moved to time:" << m_cursor->getTime();
    emit timeChanged(m_cursor->getTime());
}

void MultiTrackView::slotTimeScaleChanged(int val)
{
    //int oldScale = m_header->getTimeScale();
    m_header->setTimeScale(val);

    foreach (ShowItem *item, m_items)
    {
        quint32 newXpos = getPositionFromTime(item->getStartTime());
        item->setPos(newXpos + 2, item->y());
        item->setTimeScale(val);
    }

    int newCursorPos = getPositionFromTime(m_cursor->getTime());
    m_cursor->setPos(newCursorPos + 2, m_cursor->y());
    updateViewSize();
}

void MultiTrackView::slotTrackClicked(TrackItem *track)
{
    foreach (TrackItem *item, m_tracks)
    {
        if (item == track)
            item->setActive(true);
        else
            item->setActive(false);
    }
    emit trackClicked(track->getTrack());
}

void MultiTrackView::slotTrackDoubleClicked(TrackItem *track)
{
    emit trackDoubleClicked(track->getTrack());
}

void MultiTrackView::slotTrackSoloFlagChanged(TrackItem* track, bool solo)
{
    foreach (TrackItem *item, m_tracks)
    {
        if (item != track)
            item->setFlags(false, solo);
        Track *trk = item->getTrack();
        if (trk != NULL)
            trk->setMute(item->isMute());
    }
}

void MultiTrackView::slotTrackMuteFlagChanged(TrackItem* item, bool mute)
{
    Track *trk = item->getTrack();
    if (trk != NULL)
        trk->setMute(mute);
}

void MultiTrackView::slotViewScrolled(int)
{
    //qDebug() << Q_FUNC_INFO << "Percentage: " << value;
}

void MultiTrackView::slotItemMoved(QGraphicsSceneMouseEvent *event, ShowItem *item)
{
    qDebug() << Q_FUNC_INFO << "event - <" << event->pos().toPoint().x() << "> - <" << event->pos().toPoint().y() << ">";
    // align to the appropriate track
    bool moved = true;
    quint32 s_time = 0;
    int trackNum = item->getTrackIndex();
    int ypos = HEADER_HEIGHT + 1 + (trackNum * TRACK_HEIGHT);
    int shift = qAbs(item->getDraggingPos().x() - item->x());

    if (item->x() < TRACK_WIDTH + 2)
    {
        item->setPos(TRACK_WIDTH + 2, ypos); // avoid moving an item too early...
    }
    else if (shift < 3) // a drag of less than 3 pixel doesn't move the item
    {
        //qDebug() << "Drag too short (" << shift << "px) not allowed!";
        item->setPos(item->getDraggingPos());
        s_time = item->getStartTime();
        moved = false;
    }
    else if (m_snapToGrid == true)
    {
        float step = m_header->getTimeDivisionStep();
        float gridPos = ((int)(item->x() / step) * step);
        item->setPos(gridPos + 2, ypos);
        s_time = getTimeFromPosition(gridPos);
    }
    else
    {
        item->setPos(item->x(), ypos);
        s_time = getTimeFromPosition(item->x() - 2);
    }

    item->setStartTime(s_time);

    m_scene->update();
    emit showItemMoved(item, getTimeFromPosition(item->x() + event->pos().toPoint().x()), moved);
}

void MultiTrackView::slotAlignToCursor(ShowItem *item)
{
    item->setX(m_cursor->x());
    item->setStartTime(getTimeFromPosition(item->x()));
    m_scene->update();
}


1	/*
2	Q Light Controller Plus
3	multitrackview.cpp
4
5	Copyright (C) Massimo Callegari
6
7	Licensed under the Apache License, Version 2.0 (the "License");
8	you may not use this file except in compliance with the License.
9	You may obtain a copy of the License at
10
11	http://www.apache.org/licenses/LICENSE-2.0.txt
12
13	Unless required by applicable law or agreed to in writing, software
14	distributed under the License is distributed on an "AS IS" BASIS,
15	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	See the License for the specific language governing permissions and
17	limitations under the License.
18	*/
19
20	#include <QGraphicsSceneMouseEvent>
21	#include <QGraphicsItem>
22	#include <QGraphicsScene>
23	#include <QGraphicsView>
24	#include <QMouseEvent>
25	#include <QMessageBox>
26	#include <QScrollBar>
27	#include <QSlider>
28	#include <QDebug>
29
30	#include "multitrackview.h"
31	#include "track.h"
32
33	#define VIEW_DEFAULT_WIDTH 2000
34	#define VIEW_DEFAULT_HEIGHT 600
35
36	MultiTrackView::MultiTrackView(QWidget *parent) :	×
37	QGraphicsView(parent)	×
38	{
39	m_scene = new QGraphicsScene();	×
40	m_scene->setSceneRect(0, 0, VIEW_DEFAULT_WIDTH, VIEW_DEFAULT_HEIGHT);
41	setSceneRect(0, 0, VIEW_DEFAULT_WIDTH, VIEW_DEFAULT_HEIGHT);
42	setScene(m_scene);	×
43
44	m_timeSlider = new QSlider(Qt::Horizontal);	×
45	m_timeSlider->setRange(1, 15);	×
46	m_timeSlider->setValue(3);	×
47	m_timeSlider->setSingleStep(1);	×
48	m_timeSlider->setFixedSize(TRACK_WIDTH - 4, HEADER_HEIGHT);	×
49
50	m_timeSlider->setStyleSheet("QSlider { background-color: #969696; }"	×
51	"QSlider::groove:horizontal {"
52	"border: 1px solid #999999;"
53	"height: 10px;"
54	"background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #b1b1b1, stop:1 #d4d4d4);"
55	"}"
56	"QSlider::handle:horizontal {"
57	"background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #c4c4c4, stop:1 #8f8f8f);"
58	"border: 1px solid #5c5c5c;"
59	"width: 20px;"
60	"margin: -2px 0; /* handle is placed by default on the contents rect of the groove. Expand outside the groove */"
61	"border-radius: 4px;"
62	"}");
63	connect(m_timeSlider, SIGNAL(valueChanged(int)), this, SLOT(slotTimeScaleChanged(int)));	×
64	m_scene->addWidget(m_timeSlider);	×
65
66	m_header = new ShowHeaderItem(m_scene->width());	×
67	m_header->setPos(TRACK_WIDTH, 0);	×
68	connect(m_header, SIGNAL(itemClicked(QGraphicsSceneMouseEvent *)),	×
69	this, SLOT(slotHeaderClicked(QGraphicsSceneMouseEvent *)));
70	m_scene->addItem(m_header);	×
71	m_snapToGrid = false;	×
72
73	m_cursor = new ShowCursorItem(m_scene->height());	×
74	m_cursor->setPos(TRACK_WIDTH, 0);	×
75	m_cursor->setZValue(999); // make sure the cursor is always on top of everything else	×
76	m_scene->addItem(m_cursor);	×
77	connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotViewScrolled(int)));	×
78
79	m_vdivider = NULL;	×
80	// draw horizontal and vertical lines for tracks
81	updateTracksDividers();	×
82	}	×
83
84	void MultiTrackView::updateTracksDividers()	×
85	{
86	if (m_hdividers.count() > 0)	×
87	{
88	int hdivCount = m_hdividers.count();
89	for (int c = 0; c < hdivCount; c++)	×
90	m_scene->removeItem(m_hdividers.takeLast());	×
91	m_hdividers.clear();	×
92	}
93	if (m_vdivider != NULL)	×
94	m_scene->removeItem(m_vdivider);	×
95
96	int ypos = 35 + TRACK_HEIGHT;
97	int hDivNum = 6;
98	if (m_tracks.count() > 5)
99	hDivNum = m_tracks.count();
100	for (int j = 0; j < hDivNum; j++)	×
101	{
102	QGraphicsItem item = m_scene->addRect(0, ypos + (j TRACK_HEIGHT),	×
103	m_scene->width(), 1,	×
104	QPen(QColor(150, 150, 150, 255)),	×
105	QBrush(QColor(190, 190, 190, 255)));	×
106	item->setZValue(-1);	×
107	m_hdividers.append(item);	×
108	}
109	m_vdivider = m_scene->addRect(TRACK_WIDTH - 3, 0, 3, m_scene->height(),	×
110	QPen(QColor(150, 150, 150, 255)),	×
111	QBrush(QColor(190, 190, 190, 255)));	×
112	}	×
113
114	void MultiTrackView::setViewSize(int width, int height)	×
115	{
116	m_scene->setSceneRect(0, 0, width, height);	×
117	setSceneRect(0, 0, width, height);	×
118	m_header->setWidth(width);	×
119	if (m_snapToGrid == true)	×
120	m_header->setHeight(height);	×
121	else
122	m_header->setHeight(HEADER_HEIGHT);	×
123	updateTracksDividers();	×
124	}	×
125
126	void MultiTrackView::updateViewSize()	×
127	{
128	quint32 gWidth = VIEW_DEFAULT_WIDTH;
129	quint32 gHeight = VIEW_DEFAULT_HEIGHT;
130
131	// find leftmost show item
132	foreach (ShowItem *item, m_items)	×
133	{
134	if (item->x() + item->getWidth() > gWidth)	×
135	gWidth = item->x() + item->getWidth();	×
136	}
137
138	if ((m_tracks.count() * TRACK_HEIGHT) + HEADER_HEIGHT > VIEW_DEFAULT_HEIGHT)	×
139	{
140	gHeight = (m_tracks.count() * TRACK_HEIGHT) + HEADER_HEIGHT;	×
141	m_cursor->setHeight(gHeight);	×
142	}
143
144	if (gWidth > VIEW_DEFAULT_WIDTH \|\| gHeight > VIEW_DEFAULT_HEIGHT)	×
145	setViewSize(gWidth + 1000, gHeight);	×
146	}	×
147
148	void MultiTrackView::resetView()	×
149	{
150	for (int t = 0; t < m_tracks.count(); t++)	×
151	m_scene->removeItem(m_tracks.at(t));	×
152	m_tracks.clear();	×
153
154	for (int i = 0; i < m_items.count(); i++)	×
155	m_scene->removeItem(m_items.at(i));	×
156	m_items.clear();	×
157
158	rewindCursor();	×
159	this->horizontalScrollBar()->setSliderPosition(0);	×
160	this->verticalScrollBar()->setSliderPosition(0);	×
161	m_scene->update();	×
162	}	×
163
164	void MultiTrackView::addTrack(Track *track)	×
165	{
166	// check if track already exists
167	foreach (TrackItem *item, m_tracks)	×
168	{
169	if (item->getTrack()->id() == track->id())	×
170	return;
171	}
172
173	TrackItem *trackItem = new TrackItem(track, m_tracks.count());	×
174	trackItem->setName(track->name());	×
175	trackItem->setPos(0, HEADER_HEIGHT + (TRACK_HEIGHT * m_tracks.count()));	×
176	m_scene->addItem(trackItem);	×
177	m_tracks.append(trackItem);	×
178	activateTrack(track);	×
179	connect(trackItem, SIGNAL(itemClicked(TrackItem*)),	×
180	this, SLOT(slotTrackClicked(TrackItem*)));
181	connect(trackItem, SIGNAL(itemDoubleClicked(TrackItem*)),	×
182	this, SLOT(slotTrackDoubleClicked(TrackItem*)));
183	connect(trackItem, SIGNAL(itemSoloFlagChanged(TrackItem*,bool)),	×
184	this, SLOT(slotTrackSoloFlagChanged(TrackItem*,bool)));
185	connect(trackItem, SIGNAL(itemMuteFlagChanged(TrackItem*,bool)),	×
186	this, SLOT(slotTrackMuteFlagChanged(TrackItem*,bool)));
187	connect(trackItem, SIGNAL(itemMoveUpDown(Track*,int)),	×
188	this, SIGNAL(trackMoved(Track*,int)));
189	connect(trackItem, SIGNAL(itemRequestDelete(Track*)),	×
190	this, SIGNAL(trackDelete(Track*)));
191	}
192
193	void MultiTrackView::setItemCommonProperties(ShowItem item, ShowFunction func, int trackNum)	×
194	{
195	qDebug() << "[" << func->functionID() << "] Start time:" << func->startTime() << "Duration:" << func->duration();
196
197	item->setTrackIndex(trackNum);	×
198
199	int timeScale = m_timeSlider->value();	×
200
201	if (func->startTime() == UINT_MAX)	×
202	{
203	item->setStartTime(getTimeFromCursor());	×
204	item->setPos(m_cursor->x() + 2, 36 + (trackNum * TRACK_HEIGHT));	×
205	}
206	else
207	item->setPos(getPositionFromTime(func->startTime()) + 2, 36 + (trackNum * TRACK_HEIGHT));	×
208
209	item->setTimeScale(timeScale);	×
210
211	connect(item, SIGNAL(itemDropped(QGraphicsSceneMouseEvent , ShowItem )),	×
212	this, SLOT(slotItemMoved(QGraphicsSceneMouseEvent , ShowItem )));
213	connect(item, SIGNAL(alignToCursor(ShowItem*)),	×
214	this, SLOT(slotAlignToCursor(ShowItem*)));
215	m_scene->addItem(item);	×
216	m_items.append(item);	×
217	int new_scene_width = item->x() + item->getWidth();	×
218	if (new_scene_width > VIEW_DEFAULT_WIDTH && new_scene_width > m_scene->width())	×
219	setViewSize(new_scene_width + 500, VIEW_DEFAULT_HEIGHT);	×
220	}	×
221
222	void MultiTrackView::addSequence(Chaser chaser, Track track, ShowFunction *sf)	×
223	{
224	if (m_tracks.isEmpty())	×
225	return;
226
227	int trackNum = getTrackIndex(track);	×
228
229	if (track == NULL)	×
230	track = m_tracks.at(trackNum)->getTrack();	×
231
232	ShowFunction *func = sf;
233	if (func == NULL)	×
234	func = track->createShowFunction(chaser->id());	×
235
236	SequenceItem *item = new SequenceItem(chaser, func);	×
237	setItemCommonProperties(item, func, trackNum);	×
238	}
239
240	void MultiTrackView::addAudio(Audio audio, Track track, ShowFunction *sf)	×
241	{
242	if (m_tracks.isEmpty())	×
243	return;
244
245	int trackNum = getTrackIndex(track);	×
246
247	if (track == NULL)	×
248	track = m_tracks.at(trackNum)->getTrack();	×
249
250	ShowFunction *func = sf;
251	if (func == NULL)	×
252	func = track->createShowFunction(audio->id());	×
253
254	AudioItem *item = new AudioItem(audio, func);	×
255	setItemCommonProperties(item, func, trackNum);	×
256	}
257
258	void MultiTrackView::addRGBMatrix(RGBMatrix rgbm, Track track, ShowFunction *sf)	×
259	{
260	if (m_tracks.isEmpty())	×
261	return;
262
263	int trackNum = getTrackIndex(track);	×
264
265	if (track == NULL)	×
266	track = m_tracks.at(trackNum)->getTrack();	×
267
268	ShowFunction *func = sf;
269	if (func == NULL)	×
270	func = track->createShowFunction(rgbm->id());	×
271
272	RGBMatrixItem *item = new RGBMatrixItem(rgbm, func);	×
273	setItemCommonProperties(item, func, trackNum);	×
274	}
275
276	void MultiTrackView::addEFX(EFX efx, Track track, ShowFunction *sf)	×
277	{
278	if (m_tracks.isEmpty())	×
279	return;
280
281	int trackNum = getTrackIndex(track);	×
282
283	if (track == NULL)	×
284	track = m_tracks.at(trackNum)->getTrack();	×
285
286	ShowFunction *func = sf;
287	if (func == NULL)	×
288	func = track->createShowFunction(efx->id());	×
289
290	EFXItem *item = new EFXItem(efx, func);	×
291	setItemCommonProperties(item, func, trackNum);	×
292	}
293
294	void MultiTrackView::addVideo(Video video, Track track, ShowFunction *sf)	×
295	{
296	if (m_tracks.isEmpty())	×
297	return;
298
299	int trackNum = getTrackIndex(track);	×
300
301	if (track == NULL)	×
302	track = m_tracks.at(trackNum)->getTrack();	×
303
304	ShowFunction *func = sf;
305	if (func == NULL)	×
306	func = track->createShowFunction(video->id());	×
307
308	VideoItem *item = new VideoItem(video, func);	×
309	setItemCommonProperties(item, func, trackNum);	×
310	}
311
312	quint32 MultiTrackView::deleteSelectedItem()	×
313	{
314	ShowItem *selectedItem = getSelectedItem();	×
315	if (selectedItem != NULL)	×
316	{
317	QString msg = tr("Do you want to DELETE item:") + QString("\n\n") + selectedItem->functionName();	×
318
319	// Ask for user's confirmation
320	if (QMessageBox::question(this, tr("Delete Functions"), msg,	×
321	QMessageBox::Yes, QMessageBox::No)
322	== QMessageBox::Yes)
323	{
324	quint32 fID = selectedItem->functionID();	×
325	m_scene->removeItem(selectedItem);	×
326	m_items.removeOne(selectedItem);	×
327	return fID;
328	}
329	return Function::invalidId();	×
330	}	×
331
332	int trackIndex = 0;
333	foreach (TrackItem *item, m_tracks)	×
334	{
335	if (item->isActive() == true)	×
336	{
337	Track *track = item->getTrack();	×
338	quint32 trackID = track->id();	×
339	QList <ShowFunction *> sfList = track->showFunctions();	×
340	QString msg = tr("Do you want to DELETE track:") + QString("\n\n") + track->name();	×
341	if (sfList.count() > 0)	×
342	{
343	msg += QString("\n\n") + tr("This operation will also DELETE:") + QString("\n\n");	×
344	foreach (ShowItem *item, m_items)	×
345	{
346	if (item->getTrackIndex() == trackIndex)	×
347	msg += item->functionName() + QString("\n");	×
348	}
349	}
350
351	// Ask for user's confirmation
352	if (QMessageBox::question(this, tr("Delete Track"), msg,	×
353	QMessageBox::Yes, QMessageBox::No)
354	== QMessageBox::Yes)
355	{
356	m_scene->removeItem(item);	×
357	m_tracks.removeOne(item);	×
358	return trackID;
359	}
360	return Function::invalidId();	×
361	}	×
362	trackIndex++;	×
363	}
364
365	return Function::invalidId();	×
366	}
367
368	void MultiTrackView::deleteShowItem(Track track, ShowFunction sf)	×
369	{
370	for (int i = 0; i < m_items.count(); i++)	×
371	{
372	if (m_items.at(i)->showFunction() == sf)	×
373	{
374	m_scene->removeItem(m_items.at(i));	×
375	break;	×
376	}
377	}
378
379	track->removeShowFunction(sf);	×
380	}	×
381
382	void MultiTrackView::moveCursor(quint32 timePos)	×
383	{
384	int newPos = getPositionFromTime(timePos);	×
385	m_cursor->setPos(newPos, 0);	×
386	m_cursor->setTime(timePos);	×
387	}	×
388
389	void MultiTrackView::rewindCursor()	×
390	{
391	m_cursor->setPos(TRACK_WIDTH, 0);	×
392	m_cursor->setTime(0);	×
393	}	×
394
395	void MultiTrackView::activateTrack(Track *track)	×
396	{
397	foreach (TrackItem *item, m_tracks)	×
398	{
399	if (item->getTrack()->id() == track->id())	×
400	item->setActive(true);	×
401	else
402	item->setActive(false);	×
403	}
404	}	×
405
406	ShowItem *MultiTrackView::getSelectedItem()	×
407	{
408	foreach (ShowItem *item, m_items)	×
409	if (item->isSelected())	×
410	return item;
411
412	return NULL;	×
413	}
414
415	quint32 MultiTrackView::getTimeFromCursor()	×
416	{
417	quint32 s_time = (double)(m_cursor->x() - TRACK_WIDTH) *	×
418	(m_header->getTimeScale() * 1000) /	×
419	(double)(m_header->getHalfSecondWidth() * 2);	×
420	return s_time;	×
421	}
422
423	quint32 MultiTrackView::getTimeFromPosition(qreal pos)	×
424	{
425	return ((double)(pos - TRACK_WIDTH) *	×
426	(double)(m_header->getTimeScale() * 1000) /	×
427	(double)(m_header->getHalfSecondWidth() * 2));	×
428	}
429
430	quint32 MultiTrackView::getPositionFromTime(quint32 time)	×
431	{
432	if (time == 0)	×
433	return TRACK_WIDTH;
434	quint32 xPos = ((double)time / 500) *	×
435	((double)m_header->getHalfSecondWidth() /	×
436	(double)m_header->getTimeScale());	×
437	return TRACK_WIDTH + xPos;	×
438	}
439
440	int MultiTrackView::getTrackIndex(Track *trk)	×
441	{
442	for (int idx = 0; idx < m_tracks.count(); idx++)	×
443	{
444	if ((trk == NULL && m_tracks.at(idx)->isActive()) \|\|	×
445	(trk != NULL && trk == m_tracks.at(idx)->getTrack()))	×
446	return idx;	×
447	}
448
449	return 0;
450	}
451
452	void MultiTrackView::setHeaderType(Show::TimeDivision type)	×
453	{
454	m_header->setTimeDivisionType(type);	×
455	}	×
456
457	Show::TimeDivision MultiTrackView::getHeaderType()	×
458	{
459	return m_header->getTimeDivisionType();	×
460	}
461
462	void MultiTrackView::setBPMValue(int value)	×
463	{
464	m_header->setBPMValue(value);	×
465	}	×
466
467	void MultiTrackView::setSnapToGrid(bool enable)	×
468	{
469	m_snapToGrid = enable;	×
470	if (enable == true)	×
471	m_header->setHeight(m_scene->height());	×
472	else
473	m_header->setHeight(HEADER_HEIGHT);	×
474	}	×
475
476	void MultiTrackView::mouseReleaseEvent(QMouseEvent * e)	×
477	{
478	if (getSelectedItem() == NULL)	×
479	{
480	// Don't handle positions at the left of QLC+ window
481	if (mapToScene(e->pos()).x() < 0)	×
482	return;
483	quint32 xpos = mapToScene(e->pos()).x();	×
484	if (xpos > TRACK_WIDTH)	×
485	{
486	m_cursor->setPos(xpos, 0);	×
487	m_cursor->setTime(getTimeFromCursor());	×
488	emit timeChanged(m_cursor->getTime());	×
489	}
490	emit viewClicked(e);	×
491	}
492
493	QGraphicsView::mouseReleaseEvent(e);	×
494	//qDebug() << Q_FUNC_INFO << "View clicked at pos: " << e->pos().x() << e->pos().y();
495	}
496
497	void MultiTrackView::wheelEvent(QWheelEvent *event)	×
498	{
499	if (event->modifiers() & Qt::ControlModifier)	×
500	{
501	int zoomValue = m_timeSlider->value();	×
502	if (event->pixelDelta().y() > 0)	×
503	zoomValue++;	×
504	else
505	zoomValue--;	×
506
507	if (zoomValue >= m_timeSlider->minimum() && zoomValue <= m_timeSlider->maximum())	×
508	m_timeSlider->setValue(zoomValue);	×
509	return;	×
510	}
511	QGraphicsView::wheelEvent(event);	×
512	}
513
514	void MultiTrackView::slotHeaderClicked(QGraphicsSceneMouseEvent *event)	×
515	{
516	m_cursor->setPos(TRACK_WIDTH + event->pos().toPoint().x(), 0);	×
517	m_cursor->setTime(getTimeFromCursor());	×
518	qDebug() << Q_FUNC_INFO << "Cursor moved to time:" << m_cursor->getTime();
519	emit timeChanged(m_cursor->getTime());	×
520	}	×
521
522	void MultiTrackView::slotTimeScaleChanged(int val)	×
523	{
524	//int oldScale = m_header->getTimeScale();
525	m_header->setTimeScale(val);	×
526
527	foreach (ShowItem *item, m_items)	×
528	{
529	quint32 newXpos = getPositionFromTime(item->getStartTime());	×
530	item->setPos(newXpos + 2, item->y());	×
531	item->setTimeScale(val);	×
532	}
533
534	int newCursorPos = getPositionFromTime(m_cursor->getTime());	×
535	m_cursor->setPos(newCursorPos + 2, m_cursor->y());	×
536	updateViewSize();	×
537	}	×
538
539	void MultiTrackView::slotTrackClicked(TrackItem *track)	×
540	{
541	foreach (TrackItem *item, m_tracks)	×
542	{
543	if (item == track)	×
544	item->setActive(true);	×
545	else
546	item->setActive(false);	×
547	}
548	emit trackClicked(track->getTrack());	×
549	}	×
550
551	void MultiTrackView::slotTrackDoubleClicked(TrackItem *track)	×
552	{
553	emit trackDoubleClicked(track->getTrack());	×
554	}	×
555
556	void MultiTrackView::slotTrackSoloFlagChanged(TrackItem* track, bool solo)	×
557	{
558	foreach (TrackItem *item, m_tracks)	×
559	{
560	if (item != track)	×
561	item->setFlags(false, solo);	×
562	Track *trk = item->getTrack();	×
563	if (trk != NULL)	×
564	trk->setMute(item->isMute());	×
565	}
566	}	×
567
568	void MultiTrackView::slotTrackMuteFlagChanged(TrackItem* item, bool mute)	×
569	{
570	Track *trk = item->getTrack();	×
571	if (trk != NULL)	×
572	trk->setMute(mute);	×
573	}	×
574
575	void MultiTrackView::slotViewScrolled(int)	×
576	{
577	//qDebug() << Q_FUNC_INFO << "Percentage: " << value;
578	}	×
579
580	void MultiTrackView::slotItemMoved(QGraphicsSceneMouseEvent event, ShowItem item)	×
581	{
582	qDebug() << Q_FUNC_INFO << "event - <" << event->pos().toPoint().x() << "> - <" << event->pos().toPoint().y() << ">";
583	// align to the appropriate track
584	bool moved = true;
585	quint32 s_time = 0;
586	int trackNum = item->getTrackIndex();	×
587	int ypos = HEADER_HEIGHT + 1 + (trackNum * TRACK_HEIGHT);	×
588	int shift = qAbs(item->getDraggingPos().x() - item->x());	×
589
590	if (item->x() < TRACK_WIDTH + 2)	×
591	{
592	item->setPos(TRACK_WIDTH + 2, ypos); // avoid moving an item too early...	×
593	}
594	else if (shift < 3) // a drag of less than 3 pixel doesn't move the item	×
595	{
596	//qDebug() << "Drag too short (" << shift << "px) not allowed!";
597	item->setPos(item->getDraggingPos());	×
598	s_time = item->getStartTime();	×
599	moved = false;
600	}
601	else if (m_snapToGrid == true)	×
602	{
603	float step = m_header->getTimeDivisionStep();	×
604	float gridPos = ((int)(item->x() / step) * step);	×
605	item->setPos(gridPos + 2, ypos);	×
606	s_time = getTimeFromPosition(gridPos);	×
607	}
608	else
609	{
610	item->setPos(item->x(), ypos);	×
611	s_time = getTimeFromPosition(item->x() - 2);	×
612	}
613
614	item->setStartTime(s_time);	×
615
616	m_scene->update();	×
617	emit showItemMoved(item, getTimeFromPosition(item->x() + event->pos().toPoint().x()), moved);	×
618	}	×
619
620	void MultiTrackView::slotAlignToCursor(ShowItem *item)	×
621	{
622	item->setX(m_cursor->x());	×
623	item->setStartTime(getTimeFromPosition(item->x()));	×
624	m_scene->update();	×
625	}	×
626

mcallegari / qlcplus / 13633248611

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous