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/channelmodifiergraphicsview.cpp

/*
  Q Light Controller Plus
  channelmodifiergraphicsview.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 <QGraphicsRectItem>
#include <QDebug>

#include "channelmodifiergraphicsview.h"

ChannelModifierGraphicsView::ChannelModifierGraphicsView(QWidget *parent)
    : QGraphicsView(parent)
    , m_currentHandler(NULL)
{
    m_scene = new QGraphicsScene(this);
    //m_scene->setSceneRect(this->rect());
    setScene(m_scene);

    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    m_bgRect = m_scene->addRect(0, 0, m_scene->width(), m_scene->height(),
                                QPen(Qt::NoPen), QBrush(QColor(70, 70, 70, 255), Qt::SolidPattern));
    m_bgRect->setZValue(0);
}

void ChannelModifierGraphicsView::setHandlerDMXValue(uchar pos, uchar value)
{
    //qDebug() << "Set new DMX value:" << pos << value;
    if (m_currentHandler == NULL)
        return;

    HandlerItem *handler = getSelectedHandler();
    if (handler != NULL)
    {
        handler->m_dmxMap.first = pos;
        handler->m_dmxMap.second = value;
        updateView();
    }
}

void ChannelModifierGraphicsView::addNewHandler()
{
    // always give the fact that there are at least two handlers !
    HandlerItem *prevHandler = getSelectedHandler();
    if (prevHandler == NULL)
        prevHandler = m_handlers.at(0);
    if (prevHandler == m_handlers.last())
        prevHandler = m_handlers.at(m_handlers.count() - 2);

    int prevHdlrIdx = 0;
    HandlerItem *nextHandler = NULL;
    for (prevHdlrIdx = 0; prevHdlrIdx < m_handlers.count(); prevHdlrIdx++)
    {
        HandlerItem *hdlr = m_handlers.at(prevHdlrIdx);
        if (hdlr == prevHandler)
        {
            nextHandler = m_handlers.at(prevHdlrIdx + 1);
            break;
        }
    }

    HandlerItem *newHandler = new HandlerItem;
    uchar halfDMXpos = prevHandler->m_dmxMap.first + ((nextHandler->m_dmxMap.first - prevHandler->m_dmxMap.first) / 2);
    uchar halfDMXval = prevHandler->m_dmxMap.second + ((nextHandler->m_dmxMap.second - prevHandler->m_dmxMap.second) / 2);
    newHandler->m_dmxMap = QPair<uchar, uchar>(halfDMXpos, halfDMXval);
    //qDebug() << "Half way DMX value:" << halfDMXpos << halfDMXval;
    newHandler->m_pos = getPositionFromDMX(newHandler->m_dmxMap);
    newHandler->m_item = updateHandlerItem(NULL, newHandler->m_pos);
    newHandler->m_item->setBoundingBox(QRectF(prevHandler->m_pos.x(), m_bgRect->y(),
                                           nextHandler->m_pos.x() - prevHandler->m_pos.x(),
                                           m_bgRect->rect().height()));
    newHandler->m_line = m_scene->addLine(newHandler->m_pos.x(), newHandler->m_pos.y(),
                                        prevHandler->m_pos.x(), prevHandler->m_pos.y(),
                                        QPen(Qt::yellow));
    m_scene->removeItem(nextHandler->m_line);
    nextHandler->m_line = m_scene->addLine(nextHandler->m_pos.x(), nextHandler->m_pos.y(),
                                           newHandler->m_pos.x(), newHandler->m_pos.y(),
                                           QPen(Qt::yellow));
    m_handlers.insert(prevHdlrIdx + 1, newHandler);
    updateView();
}

void ChannelModifierGraphicsView::removeHander()
{
    if (m_currentHandler == NULL)
        return;

    for (int i = 0; i < m_handlers.count(); i++)
    {
        HandlerItem *handler = m_handlers.at(i);
        if (handler->m_item == m_currentHandler)
        {
            m_currentHandler = NULL;
            m_scene->removeItem(handler->m_item);
            m_scene->removeItem(handler->m_line);
            m_handlers.takeAt(i);
            break;
        }
    }
    updateView();
    emit viewClicked(NULL);
}

void ChannelModifierGraphicsView::setModifierMap(QList<QPair<uchar, uchar> > map)
{
    m_scene->clear();
    m_handlers.clear();
    m_currentHandler = NULL;

    m_bgRect = m_scene->addRect(0, 0, m_scene->width(), m_scene->height(),
                                QPen(Qt::NoPen), QBrush(QColor(70, 70, 70, 255), Qt::SolidPattern));
    m_bgRect->setZValue(0);

    for (int i = 0; i < map.count(); i++)
    {
        QPair<uchar, uchar> dmxPair = map.at(i);
        HandlerItem *handler = new HandlerItem;
        handler->m_dmxMap = QPair<uchar, uchar>(dmxPair.first, dmxPair.second);
        handler->m_pos = getPositionFromDMX(dmxPair);
        handler->m_item = updateHandlerItem(NULL, handler->m_pos);
        if (i == 0)
            handler->m_line = NULL;
        else
            handler->m_line = m_scene->addLine(0,0,1,1,QPen(Qt::yellow));
        m_handlers.append(handler);
    }
    for (int i = 0; i < map.count(); i++)
        updateHandlerBoundingBox(i);
    updateView();
}

QList< QPair<uchar, uchar> > ChannelModifierGraphicsView::modifiersMap()
{
    QList< QPair<uchar, uchar> > modMap;
    foreach (HandlerItem *item, m_handlers)
        modMap.append(item->m_dmxMap);
    return modMap;
}

HandlerItem *ChannelModifierGraphicsView::getSelectedHandler()
{
    foreach (HandlerItem *handler, m_handlers)
        if (handler->m_item->isSelected())
            return handler;
    return NULL;
}

HandlerGraphicsItem *ChannelModifierGraphicsView::updateHandlerItem(HandlerGraphicsItem *item, QPoint pos)
{
    HandlerGraphicsItem *tmpItem = item;
    if (tmpItem == NULL)
    {
        tmpItem =  new HandlerGraphicsItem(pos.x() - 5, pos.y() - 5, 10, 10,
                                           QPen(Qt::yellow), QBrush(Qt::yellow));
        tmpItem->setZValue(1);
        tmpItem->setParent(m_scene);
        connect(tmpItem, SIGNAL(itemMoved(HandlerGraphicsItem *, QGraphicsSceneMouseEvent*,QRectF)),
                this, SLOT(slotItemMoved(HandlerGraphicsItem *,QGraphicsSceneMouseEvent*,QRectF)));
        connect(tmpItem, SIGNAL(itemSelected(HandlerGraphicsItem*)),
                this, SLOT(slotItemSelected(HandlerGraphicsItem*)));
        m_scene->addItem(tmpItem);
    }
    else
    {
        tmpItem->setRect(pos.x() - 5, pos.y() - 5, 10, 10);
    }
    return tmpItem;
}

void ChannelModifierGraphicsView::updateHandlerBoundingBox(int itemIndex)
{
    if (itemIndex < 0 || itemIndex >= m_handlers.count())
        return;

    HandlerItem *handler = m_handlers.at(itemIndex);
    if (itemIndex == 0)
    {
        handler->m_item->setBoundingBox(QRect(m_bgRect->x() - 1, m_bgRect->y(), 1, m_bgRect->rect().height()));
        return;
    }
    else if (itemIndex == m_handlers.count() - 1)
    {
        handler->m_item->setBoundingBox(QRect(m_bgRect->rect().right(), m_bgRect->y(), 1, m_bgRect->rect().height()));
        return;
    }
    else
    {
        HandlerItem *prevHandler = m_handlers.at(itemIndex - 1);
        HandlerItem *nextHandler = m_handlers.at(itemIndex + 1);
        handler->m_item->setBoundingBox(QRectF(prevHandler->m_pos.x(), m_bgRect->y(),
                                             nextHandler->m_pos.x() - prevHandler->m_pos.x(),
                                             m_bgRect->rect().height()));
    }
}

QPoint ChannelModifierGraphicsView::getPositionFromDMX(QPair<uchar, uchar>dmxMap)
{
    qreal xPos = m_bgRect->rect().x() + ((m_bgRect->rect().width() / 255) * (qreal)dmxMap.first);
    qreal yPos = m_bgRect->rect().y() + m_bgRect->rect().height() - ((m_bgRect->rect().height() / 255) * (qreal)dmxMap.second);
    //qDebug() << "New position from values <" << dmxMap.first << "," << dmxMap.second << "=" << xPos << yPos;
    return QPoint(xPos, yPos);
}

QPair<uchar, uchar> ChannelModifierGraphicsView::getDMXFromPosition(QPointF pos)
{
    if (pos.x() < m_bgRect->x()) pos.setX(m_bgRect->x());
    if (pos.y() < m_bgRect->y()) pos.setY(m_bgRect->y());
    QPair<uchar, uchar> newPos;
    newPos.first = ((pos.x() - m_bgRect->x()) * 255) / m_bgRect->rect().width();
    newPos.second = 255 - (((pos.y() - m_bgRect->y()) * 255) / m_bgRect->rect().height());
    //qDebug() << "Elapsed DMX value:" << newPos.first << newPos.second;
    return newPos;
}

void ChannelModifierGraphicsView::updateView()
{
    qDebug() << "Size after resize:" << width() << height();

    //m_scene->setSceneRect(0, 0, width(), height());
    int squareSize = width() - 20;
    if (height() < width())
        squareSize = height() - 20;

    QRect bgRect(5, 5, squareSize, squareSize);
    m_bgRect->setRect(bgRect);

    if (m_handlers.isEmpty())
    {
        // create one bottom-left handler and one top-right handler
        HandlerItem *blHdlr = new HandlerItem;
        blHdlr->m_dmxMap = QPair<uchar, uchar>(0, 0);
        blHdlr->m_pos = QPoint(bgRect.x(), bgRect.bottom());
        blHdlr->m_item = updateHandlerItem(NULL, blHdlr->m_pos);
        blHdlr->m_line = NULL;
        m_handlers.append(blHdlr);

        HandlerItem *trHdlr = new HandlerItem;
        trHdlr->m_dmxMap = QPair<uchar, uchar>(255, 255);
        trHdlr->m_pos = QPoint(bgRect.right(), bgRect.y());
        trHdlr->m_item = updateHandlerItem(NULL, trHdlr->m_pos);
        trHdlr->m_line = m_scene->addLine(blHdlr->m_pos.x(), blHdlr->m_pos.y(),
                                         trHdlr->m_pos.x(), trHdlr->m_pos.y(),
                                         QPen(Qt::yellow));
        m_handlers.append(trHdlr);
        updateHandlerBoundingBox(0);
        updateHandlerBoundingBox(1);
    }
    else
    {
        QPoint lastPos;
        for (int i = 0; i < m_handlers.count(); i++)
        {
            HandlerItem *handler = m_handlers.at(i);
            handler->m_pos = getPositionFromDMX(handler->m_dmxMap);
            handler->m_item = updateHandlerItem(handler->m_item, handler->m_pos);

            if (handler->m_line != NULL)
            {
                handler->m_line->setLine(lastPos.x(), lastPos.y(),
                                         handler->m_pos.x(), handler->m_pos.y());
            }
            updateHandlerBoundingBox(i);
            lastPos = handler->m_pos;
        }
    }
}

void ChannelModifierGraphicsView::resizeEvent(QResizeEvent *event)
{
    QGraphicsView::resizeEvent(event);
    updateView();
}

void ChannelModifierGraphicsView::mouseReleaseEvent(QMouseEvent *e)
{
    if (getSelectedHandler() == NULL)
    {
        if (m_currentHandler != NULL)
            m_currentHandler->setBrush(QBrush(Qt::yellow));
        m_currentHandler = NULL;
        emit viewClicked(e);

        QGraphicsView::mouseReleaseEvent(e);
    }
}

void ChannelModifierGraphicsView::slotItemSelected(HandlerGraphicsItem *item)
{
    if (m_currentHandler != NULL)
        m_currentHandler->setBrush(QBrush(Qt::yellow));
    m_currentHandler = item;
    HandlerItem *handler = getSelectedHandler();
    if (handler != NULL)
        emit itemClicked(handler->m_dmxMap.first, handler->m_dmxMap.second);
}

void ChannelModifierGraphicsView::slotItemMoved(HandlerGraphicsItem *item,
                                                QGraphicsSceneMouseEvent *event, QRectF limits)
{
    QPointF newPos(item->x(), item->y());

    if (!limits.contains(event->scenePos()))
    {
        qreal evX = event->scenePos().x();
        qreal evY = event->scenePos().y();

        if (evX < limits.x())
            newPos.setX(limits.left() - 5);
        else if (evX > limits.right())
            newPos.setX(limits.right() - 5);
        else
            newPos.setX(evX - 5);

        if (evY < limits.y())
            newPos.setY(limits.y() - 5);
        else if (evY > limits.bottom())
            newPos.setY(limits.bottom() - 5);
        else
            newPos.setY(evY - 5);
    }
    else
    {
        newPos.setX(event->scenePos().x() - 5);
        newPos.setY(event->scenePos().y() - 5);
    }
    HandlerItem *handler = getSelectedHandler();
    if (handler != NULL)
    {
        handler->m_dmxMap = getDMXFromPosition(newPos);
        emit itemDMXMapChanged(handler->m_dmxMap.first, handler->m_dmxMap.second);
    }
    updateView();
}

/********************************************************************
 * HandlerGraphicsItem class implementation
 ********************************************************************/

HandlerGraphicsItem::HandlerGraphicsItem(qreal x, qreal y, qreal w, qreal h,
                                         const QPen & pen, const QBrush &brush)
    : QGraphicsEllipseItem(x, y, w, h)
{
    setCursor(Qt::OpenHandCursor);
    setFlag(QGraphicsItem::ItemIsMovable, true);
    setFlag(QGraphicsItem::ItemIsSelectable, true);

    setPen(pen);
    setBrush(brush);
}

void HandlerGraphicsItem::setBoundingBox(QRectF rect)
{
    m_boundingBox = rect;
    //qDebug() << Q_FUNC_INFO << rect;
}

QRectF HandlerGraphicsItem::boundingBox()
{
    return m_boundingBox;
}

void HandlerGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsItem::mousePressEvent(event);
    setSelected(true);
    setBrush(QBrush(Qt::green));
    emit itemSelected(this);
}

void HandlerGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    QGraphicsItem::mouseReleaseEvent(event);
    //qDebug() << Q_FUNC_INFO << "mouse RELEASE event - <" << event->pos().toPoint().x() << "> - <" << event->pos().toPoint().y() << ">";
    setCursor(Qt::OpenHandCursor);
    emit itemDropped(this);
}

void HandlerGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    //qDebug() << "Mouse move event" << event->scenePos();
    //qDebug() << "x:" << x() << "y:" << y();
    emit itemMoved(this, event, m_boundingBox);
}



1	/*
2	Q Light Controller Plus
3	channelmodifiergraphicsview.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 <QGraphicsRectItem>
22	#include <QDebug>
23
24	#include "channelmodifiergraphicsview.h"
25
26	ChannelModifierGraphicsView::ChannelModifierGraphicsView(QWidget *parent)	×
27	: QGraphicsView(parent)
28	, m_currentHandler(NULL)	×
29	{
30	m_scene = new QGraphicsScene(this);	×
31	//m_scene->setSceneRect(this->rect());
32	setScene(m_scene);	×
33
34	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);	×
35	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);	×
36
37	m_bgRect = m_scene->addRect(0, 0, m_scene->width(), m_scene->height(),	×
38	QPen(Qt::NoPen), QBrush(QColor(70, 70, 70, 255), Qt::SolidPattern));	×
39	m_bgRect->setZValue(0);	×
40	}	×
41
42	void ChannelModifierGraphicsView::setHandlerDMXValue(uchar pos, uchar value)	×
43	{
44	//qDebug() << "Set new DMX value:" << pos << value;
45	if (m_currentHandler == NULL)	×
46	return;
47
48	HandlerItem *handler = getSelectedHandler();	×
49	if (handler != NULL)	×
50	{
51	handler->m_dmxMap.first = pos;	×
52	handler->m_dmxMap.second = value;	×
53	updateView();	×
54	}
55	}
56
57	void ChannelModifierGraphicsView::addNewHandler()	×
58	{
59	// always give the fact that there are at least two handlers !
60	HandlerItem *prevHandler = getSelectedHandler();	×
61	if (prevHandler == NULL)	×
62	prevHandler = m_handlers.at(0);	×
63	if (prevHandler == m_handlers.last())	×
64	prevHandler = m_handlers.at(m_handlers.count() - 2);	×
65
66	int prevHdlrIdx = 0;
67	HandlerItem *nextHandler = NULL;
68	for (prevHdlrIdx = 0; prevHdlrIdx < m_handlers.count(); prevHdlrIdx++)	×
69	{
70	HandlerItem *hdlr = m_handlers.at(prevHdlrIdx);	×
71	if (hdlr == prevHandler)	×
72	{
73	nextHandler = m_handlers.at(prevHdlrIdx + 1);	×
74	break;	×
75	}
76	}
77
78	HandlerItem *newHandler = new HandlerItem;	×
79	uchar halfDMXpos = prevHandler->m_dmxMap.first + ((nextHandler->m_dmxMap.first - prevHandler->m_dmxMap.first) / 2);	×
80	uchar halfDMXval = prevHandler->m_dmxMap.second + ((nextHandler->m_dmxMap.second - prevHandler->m_dmxMap.second) / 2);	×
81	newHandler->m_dmxMap = QPair<uchar, uchar>(halfDMXpos, halfDMXval);	×
82	//qDebug() << "Half way DMX value:" << halfDMXpos << halfDMXval;
83	newHandler->m_pos = getPositionFromDMX(newHandler->m_dmxMap);	×
84	newHandler->m_item = updateHandlerItem(NULL, newHandler->m_pos);	×
85	newHandler->m_item->setBoundingBox(QRectF(prevHandler->m_pos.x(), m_bgRect->y(),	×
86	nextHandler->m_pos.x() - prevHandler->m_pos.x(),	×
87	m_bgRect->rect().height()));	×
88	newHandler->m_line = m_scene->addLine(newHandler->m_pos.x(), newHandler->m_pos.y(),	×
89	prevHandler->m_pos.x(), prevHandler->m_pos.y(),
90	QPen(Qt::yellow));	×
91	m_scene->removeItem(nextHandler->m_line);	×
92	nextHandler->m_line = m_scene->addLine(nextHandler->m_pos.x(), nextHandler->m_pos.y(),	×
93	newHandler->m_pos.x(), newHandler->m_pos.y(),	×
94	QPen(Qt::yellow));	×
95	m_handlers.insert(prevHdlrIdx + 1, newHandler);	×
96	updateView();	×
97	}	×
98
99	void ChannelModifierGraphicsView::removeHander()	×
100	{
101	if (m_currentHandler == NULL)	×
102	return;
103
104	for (int i = 0; i < m_handlers.count(); i++)	×
105	{
106	HandlerItem *handler = m_handlers.at(i);	×
107	if (handler->m_item == m_currentHandler)	×
108	{
109	m_currentHandler = NULL;	×
110	m_scene->removeItem(handler->m_item);	×
111	m_scene->removeItem(handler->m_line);	×
112	m_handlers.takeAt(i);	×
113	break;	×
114	}
115	}
116	updateView();	×
117	emit viewClicked(NULL);	×
118	}
119
120	void ChannelModifierGraphicsView::setModifierMap(QList<QPair<uchar, uchar> > map)	×
121	{
122	m_scene->clear();	×
123	m_handlers.clear();	×
124	m_currentHandler = NULL;	×
125
126	m_bgRect = m_scene->addRect(0, 0, m_scene->width(), m_scene->height(),	×
127	QPen(Qt::NoPen), QBrush(QColor(70, 70, 70, 255), Qt::SolidPattern));	×
128	m_bgRect->setZValue(0);	×
129
130	for (int i = 0; i < map.count(); i++)	×
131	{
132	QPair<uchar, uchar> dmxPair = map.at(i);	×
133	HandlerItem *handler = new HandlerItem;	×
134	handler->m_dmxMap = QPair<uchar, uchar>(dmxPair.first, dmxPair.second);	×
135	handler->m_pos = getPositionFromDMX(dmxPair);	×
136	handler->m_item = updateHandlerItem(NULL, handler->m_pos);	×
137	if (i == 0)	×
138	handler->m_line = NULL;	×
139	else
140	handler->m_line = m_scene->addLine(0,0,1,1,QPen(Qt::yellow));	×
141	m_handlers.append(handler);	×
142	}
143	for (int i = 0; i < map.count(); i++)	×
144	updateHandlerBoundingBox(i);	×
145	updateView();	×
146	}	×
147
148	QList< QPair<uchar, uchar> > ChannelModifierGraphicsView::modifiersMap()	×
149	{
150	QList< QPair<uchar, uchar> > modMap;
151	foreach (HandlerItem *item, m_handlers)	×
152	modMap.append(item->m_dmxMap);	×
153	return modMap;	×
154	}	×
155
156	HandlerItem *ChannelModifierGraphicsView::getSelectedHandler()	×
157	{
158	foreach (HandlerItem *handler, m_handlers)	×
159	if (handler->m_item->isSelected())	×
160	return handler;
161	return NULL;	×
162	}
163
164	HandlerGraphicsItem ChannelModifierGraphicsView::updateHandlerItem(HandlerGraphicsItem item, QPoint pos)	×
165	{
166	HandlerGraphicsItem *tmpItem = item;
167	if (tmpItem == NULL)	×
168	{
169	tmpItem = new HandlerGraphicsItem(pos.x() - 5, pos.y() - 5, 10, 10,	×
170	QPen(Qt::yellow), QBrush(Qt::yellow));	×
171	tmpItem->setZValue(1);	×
172	tmpItem->setParent(m_scene);	×
173	connect(tmpItem, SIGNAL(itemMoved(HandlerGraphicsItem , QGraphicsSceneMouseEvent,QRectF)),	×
174	this, SLOT(slotItemMoved(HandlerGraphicsItem ,QGraphicsSceneMouseEvent,QRectF)));
175	connect(tmpItem, SIGNAL(itemSelected(HandlerGraphicsItem*)),	×
176	this, SLOT(slotItemSelected(HandlerGraphicsItem*)));
177	m_scene->addItem(tmpItem);	×
178	}
179	else
180	{
181	tmpItem->setRect(pos.x() - 5, pos.y() - 5, 10, 10);	×
182	}
183	return tmpItem;	×
184	}
185
186	void ChannelModifierGraphicsView::updateHandlerBoundingBox(int itemIndex)	×
187	{
188	if (itemIndex < 0 \|\| itemIndex >= m_handlers.count())	×
189	return;
190
191	HandlerItem *handler = m_handlers.at(itemIndex);	×
192	if (itemIndex == 0)	×
193	{
194	handler->m_item->setBoundingBox(QRect(m_bgRect->x() - 1, m_bgRect->y(), 1, m_bgRect->rect().height()));	×
195	return;	×
196	}
197	else if (itemIndex == m_handlers.count() - 1)	×
198	{
199	handler->m_item->setBoundingBox(QRect(m_bgRect->rect().right(), m_bgRect->y(), 1, m_bgRect->rect().height()));	×
200	return;	×
201	}
202	else
203	{
204	HandlerItem *prevHandler = m_handlers.at(itemIndex - 1);	×
205	HandlerItem *nextHandler = m_handlers.at(itemIndex + 1);	×
206	handler->m_item->setBoundingBox(QRectF(prevHandler->m_pos.x(), m_bgRect->y(),	×
207	nextHandler->m_pos.x() - prevHandler->m_pos.x(),	×
208	m_bgRect->rect().height()));	×
209	}
210	}
211
212	QPoint ChannelModifierGraphicsView::getPositionFromDMX(QPair<uchar, uchar>dmxMap)	×
213	{
214	qreal xPos = m_bgRect->rect().x() + ((m_bgRect->rect().width() / 255) * (qreal)dmxMap.first);	×
215	qreal yPos = m_bgRect->rect().y() + m_bgRect->rect().height() - ((m_bgRect->rect().height() / 255) * (qreal)dmxMap.second);	×
216	//qDebug() << "New position from values <" << dmxMap.first << "," << dmxMap.second << "=" << xPos << yPos;
217	return QPoint(xPos, yPos);	×
218	}
219
220	QPair<uchar, uchar> ChannelModifierGraphicsView::getDMXFromPosition(QPointF pos)	×
221	{
222	if (pos.x() < m_bgRect->x()) pos.setX(m_bgRect->x());	×
223	if (pos.y() < m_bgRect->y()) pos.setY(m_bgRect->y());	×
224	QPair<uchar, uchar> newPos;
225	newPos.first = ((pos.x() - m_bgRect->x()) * 255) / m_bgRect->rect().width();	×
226	newPos.second = 255 - (((pos.y() - m_bgRect->y()) * 255) / m_bgRect->rect().height());	×
227	//qDebug() << "Elapsed DMX value:" << newPos.first << newPos.second;
228	return newPos;	×
229	}
230
231	void ChannelModifierGraphicsView::updateView()	×
232	{
233	qDebug() << "Size after resize:" << width() << height();
234
235	//m_scene->setSceneRect(0, 0, width(), height());
236	int squareSize = width() - 20;	×
237	if (height() < width())	×
238	squareSize = height() - 20;	×
239
240	QRect bgRect(5, 5, squareSize, squareSize);
241	m_bgRect->setRect(bgRect);	×
242
243	if (m_handlers.isEmpty())	×
244	{
245	// create one bottom-left handler and one top-right handler
246	HandlerItem *blHdlr = new HandlerItem;	×
247	blHdlr->m_dmxMap = QPair<uchar, uchar>(0, 0);
248	blHdlr->m_pos = QPoint(bgRect.x(), bgRect.bottom());	×
249	blHdlr->m_item = updateHandlerItem(NULL, blHdlr->m_pos);	×
250	blHdlr->m_line = NULL;	×
251	m_handlers.append(blHdlr);	×
252
253	HandlerItem *trHdlr = new HandlerItem;	×
254	trHdlr->m_dmxMap = QPair<uchar, uchar>(255, 255);	×
255	trHdlr->m_pos = QPoint(bgRect.right(), bgRect.y());	×
256	trHdlr->m_item = updateHandlerItem(NULL, trHdlr->m_pos);	×
257	trHdlr->m_line = m_scene->addLine(blHdlr->m_pos.x(), blHdlr->m_pos.y(),	×
258	trHdlr->m_pos.x(), trHdlr->m_pos.y(),	×
259	QPen(Qt::yellow));	×
260	m_handlers.append(trHdlr);	×
261	updateHandlerBoundingBox(0);	×
262	updateHandlerBoundingBox(1);	×
263	}
264	else
265	{
266	QPoint lastPos;
267	for (int i = 0; i < m_handlers.count(); i++)	×
268	{
269	HandlerItem *handler = m_handlers.at(i);	×
270	handler->m_pos = getPositionFromDMX(handler->m_dmxMap);	×
271	handler->m_item = updateHandlerItem(handler->m_item, handler->m_pos);	×
272
273	if (handler->m_line != NULL)	×
274	{
275	handler->m_line->setLine(lastPos.x(), lastPos.y(),	×
276	handler->m_pos.x(), handler->m_pos.y());
277	}
278	updateHandlerBoundingBox(i);	×
279	lastPos = handler->m_pos;	×
280	}
281	}
282	}	×
283
284	void ChannelModifierGraphicsView::resizeEvent(QResizeEvent *event)	×
285	{
286	QGraphicsView::resizeEvent(event);	×
287	updateView();	×
288	}	×
289
290	void ChannelModifierGraphicsView::mouseReleaseEvent(QMouseEvent *e)	×
291	{
292	if (getSelectedHandler() == NULL)	×
293	{
294	if (m_currentHandler != NULL)	×
295	m_currentHandler->setBrush(QBrush(Qt::yellow));	×
296	m_currentHandler = NULL;	×
297	emit viewClicked(e);	×
298
299	QGraphicsView::mouseReleaseEvent(e);	×
300	}
301	}	×
302
303	void ChannelModifierGraphicsView::slotItemSelected(HandlerGraphicsItem *item)	×
304	{
305	if (m_currentHandler != NULL)	×
306	m_currentHandler->setBrush(QBrush(Qt::yellow));	×
307	m_currentHandler = item;	×
308	HandlerItem *handler = getSelectedHandler();	×
309	if (handler != NULL)	×
310	emit itemClicked(handler->m_dmxMap.first, handler->m_dmxMap.second);	×
311	}	×
312
313	void ChannelModifierGraphicsView::slotItemMoved(HandlerGraphicsItem *item,	×
314	QGraphicsSceneMouseEvent *event, QRectF limits)
315	{
316	QPointF newPos(item->x(), item->y());	×
317
318	if (!limits.contains(event->scenePos()))	×
319	{
320	qreal evX = event->scenePos().x();	×
321	qreal evY = event->scenePos().y();	×
322
323	if (evX < limits.x())	×
324	newPos.setX(limits.left() - 5);	×
325	else if (evX > limits.right())	×
326	newPos.setX(limits.right() - 5);	×
327	else
328	newPos.setX(evX - 5);	×
329
330	if (evY < limits.y())	×
331	newPos.setY(limits.y() - 5);	×
332	else if (evY > limits.bottom())	×
333	newPos.setY(limits.bottom() - 5);	×
334	else
335	newPos.setY(evY - 5);	×
336	}
337	else
338	{
339	newPos.setX(event->scenePos().x() - 5);	×
340	newPos.setY(event->scenePos().y() - 5);	×
341	}
342	HandlerItem *handler = getSelectedHandler();	×
343	if (handler != NULL)	×
344	{
345	handler->m_dmxMap = getDMXFromPosition(newPos);	×
346	emit itemDMXMapChanged(handler->m_dmxMap.first, handler->m_dmxMap.second);	×
347	}
348	updateView();	×
349	}	×
350
351	/********************************************************************
352	* HandlerGraphicsItem class implementation
353	********************************************************************/
354
355	HandlerGraphicsItem::HandlerGraphicsItem(qreal x, qreal y, qreal w, qreal h,	×
356	const QPen & pen, const QBrush &brush)	×
357	: QGraphicsEllipseItem(x, y, w, h)	×
358	{
359	setCursor(Qt::OpenHandCursor);	×
360	setFlag(QGraphicsItem::ItemIsMovable, true);	×
361	setFlag(QGraphicsItem::ItemIsSelectable, true);	×
362
363	setPen(pen);	×
364	setBrush(brush);	×
365	}	×
366
367	void HandlerGraphicsItem::setBoundingBox(QRectF rect)	×
368	{
369	m_boundingBox = rect;	×
370	//qDebug() << Q_FUNC_INFO << rect;
371	}	×
372
373	QRectF HandlerGraphicsItem::boundingBox()	×
374	{
375	return m_boundingBox;	×
376	}
377
378	void HandlerGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)	×
379	{
380	QGraphicsItem::mousePressEvent(event);	×
381	setSelected(true);	×
382	setBrush(QBrush(Qt::green));	×
383	emit itemSelected(this);	×
384	}	×
385
386	void HandlerGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)	×
387	{
388	QGraphicsItem::mouseReleaseEvent(event);	×
389	//qDebug() << Q_FUNC_INFO << "mouse RELEASE event - <" << event->pos().toPoint().x() << "> - <" << event->pos().toPoint().y() << ">";
390	setCursor(Qt::OpenHandCursor);	×
391	emit itemDropped(this);	×
392	}	×
393
394	void HandlerGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)	×
395	{
396	//qDebug() << "Mouse move event" << event->scenePos();
397	//qDebug() << "x:" << x() << "y:" << y();
398	emit itemMoved(this, event, m_boundingBox);	×
399	}	×
400
401

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