8961243534

Committed 05 May 2024 09:23PM UTC coverage: 32.068% (+4.0%) from 28.094%

Build # 8961243534

Build Type

push

github

Committed by

mcallegari

Commit Message

Merge branch 'master' into qmltoqt6

Run Details

902 of 2557 new or added lines in 140 files covered. (35.28%)

166 existing lines in 76 files now uncovered.

15395 of 48008 relevant lines covered (32.07%)

22949.67 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() << "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::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,	×
NEW 104	QPen(QColor(150, 150, 150, 255)),	×
NEW 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(),	×
NEW 110	QPen(QColor(150, 150, 150, 255)),	×
NEW 111	QBrush(QColor(190, 190, 190, 255)));	×
UNCOV 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
NEW 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() << "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;	×
NEW 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	{
NEW 343	msg += QString("\n\n") + tr("This operation will also DELETE:") + QString("\n\n");	×
NEW 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	{
NEW 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	{
NEW 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
NEW 452	void MultiTrackView::setHeaderType(Show::TimeDivision type)	×
453	{
454	m_header->setTimeDivisionType(type);	×
455	}	×
456
NEW 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::slotHeaderClicked(QGraphicsSceneMouseEvent *event)	×
498	{
499	m_cursor->setPos(TRACK_WIDTH + event->pos().toPoint().x(), 0);	×
500	m_cursor->setTime(getTimeFromCursor());	×
501	qDebug() << Q_FUNC_INFO << "Cursor moved to time:" << m_cursor->getTime();	×
502	emit timeChanged(m_cursor->getTime());	×
503	}	×
504
505	void MultiTrackView::slotTimeScaleChanged(int val)	×
506	{
507	//int oldScale = m_header->getTimeScale();
508	m_header->setTimeScale(val);	×
509
NEW 510	foreach (ShowItem *item, m_items)	×
511	{
512	quint32 newXpos = getPositionFromTime(item->getStartTime());	×
513	item->setPos(newXpos + 2, item->y());	×
514	item->setTimeScale(val);	×
515	}
516
517	int newCursorPos = getPositionFromTime(m_cursor->getTime());	×
518	m_cursor->setPos(newCursorPos + 2, m_cursor->y());	×
519	updateViewSize();	×
520	}	×
521
522	void MultiTrackView::slotTrackClicked(TrackItem *track)	×
523	{
NEW 524	foreach (TrackItem *item, m_tracks)	×
525	{
526	if (item == track)	×
527	item->setActive(true);	×
528	else
529	item->setActive(false);	×
530	}
531	emit trackClicked(track->getTrack());	×
532	}	×
533
534	void MultiTrackView::slotTrackDoubleClicked(TrackItem *track)	×
535	{
536	emit trackDoubleClicked(track->getTrack());	×
537	}	×
538
539	void MultiTrackView::slotTrackSoloFlagChanged(TrackItem* track, bool solo)	×
540	{
NEW 541	foreach (TrackItem *item, m_tracks)	×
542	{
543	if (item != track)	×
544	item->setFlags(false, solo);	×
545	Track *trk = item->getTrack();	×
546	if (trk != NULL)	×
547	trk->setMute(item->isMute());	×
548	}
549	}	×
550
551	void MultiTrackView::slotTrackMuteFlagChanged(TrackItem* item, bool mute)	×
552	{
553	Track *trk = item->getTrack();	×
554	if (trk != NULL)	×
555	trk->setMute(mute);	×
556	}	×
557
558	void MultiTrackView::slotViewScrolled(int)	×
559	{
560	//qDebug() << Q_FUNC_INFO << "Percentage: " << value;
561	}	×
562
563	void MultiTrackView::slotItemMoved(QGraphicsSceneMouseEvent event, ShowItem item)	×
564	{
565	qDebug() << Q_FUNC_INFO << "event - <" << event->pos().toPoint().x() << "> - <" << event->pos().toPoint().y() << ">";	×
566	// align to the appropriate track
567	bool moved = true;	×
568	quint32 s_time = 0;	×
569	int trackNum = item->getTrackIndex();	×
570	int ypos = HEADER_HEIGHT + 1 + (trackNum * TRACK_HEIGHT);	×
571	int shift = qAbs(item->getDraggingPos().x() - item->x());	×
572
573	if (item->x() < TRACK_WIDTH + 2)	×
574	{
575	item->setPos(TRACK_WIDTH + 2, ypos); // avoid moving an item too early...	×
576	}
577	else if (shift < 3) // a drag of less than 3 pixel doesn't move the item	×
578	{
579	//qDebug() << "Drag too short (" << shift << "px) not allowed!";
580	item->setPos(item->getDraggingPos());	×
581	s_time = item->getStartTime();	×
582	moved = false;	×
583	}
584	else if (m_snapToGrid == true)	×
585	{
586	float step = m_header->getTimeDivisionStep();	×
587	float gridPos = ((int)(item->x() / step) * step);	×
588	item->setPos(gridPos + 2, ypos);	×
589	s_time = getTimeFromPosition(gridPos);	×
590	}
591	else
592	{
593	item->setPos(item->x(), ypos);	×
594	s_time = getTimeFromPosition(item->x() - 2);	×
595	}
596
597	item->setStartTime(s_time);	×
598
599	m_scene->update();	×
600	emit showItemMoved(item, getTimeFromPosition(item->x() + event->pos().toPoint().x()), moved);	×
601	}	×
602
603	void MultiTrackView::slotAlignToCursor(ShowItem *item)	×
604	{
605	item->setX(m_cursor->x());	×
606	item->setStartTime(getTimeFromPosition(item->x()));	×
607	m_scene->update();	×
608	}	×
609

mcallegari / qlcplus / 8961243534

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