15805077468

Committed 22 Jun 2025 08:36AM UTC coverage: 31.876% (-0.01%) from 31.89%

Build # 15805077468

Build Type

push

github

Committed by

mcallegari

Commit Message

plugins/dmxusb: fix RDM discovery and commands while DMX is running

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

3722 existing lines in 175 files now uncovered.

16438 of 51569 relevant lines covered (31.88%)

19266.08 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();	×
UNCOV 40	m_scene->setSceneRect(0, 0, VIEW_DEFAULT_WIDTH, VIEW_DEFAULT_HEIGHT);	×
UNCOV 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
UNCOV 96	int ypos = 35 + TRACK_HEIGHT;	×
UNCOV 97	int hDivNum = 6;	×
UNCOV 98	if (m_tracks.count() > 5)	×
UNCOV 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	{
UNCOV 128	quint32 gWidth = VIEW_DEFAULT_WIDTH;	×
UNCOV 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();	×
UNCOV 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())	×
UNCOV 170	return;	×
UNCOV 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())	×
UNCOV 225	return;	×
226
227	int trackNum = getTrackIndex(track);	×
228
229	if (track == NULL)	×
230	track = m_tracks.at(trackNum)->getTrack();	×
231
UNCOV 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())	×
UNCOV 243	return;	×
244
245	int trackNum = getTrackIndex(track);	×
246
247	if (track == NULL)	×
248	track = m_tracks.at(trackNum)->getTrack();	×
249
UNCOV 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())	×
UNCOV 261	return;	×
262
263	int trackNum = getTrackIndex(track);	×
264
265	if (track == NULL)	×
266	track = m_tracks.at(trackNum)->getTrack();	×
267
UNCOV 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())	×
UNCOV 279	return;	×
280
281	int trackNum = getTrackIndex(track);	×
282
283	if (track == NULL)	×
284	track = m_tracks.at(trackNum)->getTrack();	×
285
UNCOV 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())	×
UNCOV 297	return;	×
298
299	int trackNum = getTrackIndex(track);	×
300
301	if (track == NULL)	×
302	track = m_tracks.at(trackNum)->getTrack();	×
303
UNCOV 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)
UNCOV 322	== QMessageBox::Yes)	×
323	{
324	quint32 fID = selectedItem->functionID();	×
325	m_scene->removeItem(selectedItem);	×
326	m_items.removeOne(selectedItem);	×
UNCOV 327	return fID;	×
328	}
329	return Function::invalidId();	×
UNCOV 330	}	×
331
UNCOV 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");	×
UNCOV 348	}	×
349	}
350
351	// Ask for user's confirmation
352	if (QMessageBox::question(this, tr("Delete Track"), msg,	×
353	QMessageBox::Yes, QMessageBox::No)
UNCOV 354	== QMessageBox::Yes)	×
355	{
356	m_scene->removeItem(item);	×
UNCOV 357	m_tracks.removeOne(item);	×
UNCOV 358	return trackID;	×
359	}
360	return Function::invalidId();	×
UNCOV 361	}	×
362	trackIndex++;	×
UNCOV 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);	×
UNCOV 403	}	×
404	}	×
405
406	ShowItem *MultiTrackView::getSelectedItem()	×
407	{
408	foreach (ShowItem *item, m_items)	×
409	if (item->isSelected())	×
UNCOV 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)	×
UNCOV 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
UNCOV 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)	×
UNCOV 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);	×
UNCOV 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);	×
UNCOV 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());	×
UNCOV 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
UNCOV 584	bool moved = true;	×
UNCOV 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();	×
UNCOV 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 / 15805077468

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