Skip to content

Commit

Permalink
qmlui: started EFX action tracking
Browse files Browse the repository at this point in the history 
Moved creation logic away from network manager. Let's keep it focused
  • Loading branch information
@mcallegari
mcallegari committed Nov 2, 2017
1 parent fef947a commit 2ed0003
Show file tree
Hide file tree
Showing 8 changed files with 264 additions and 60 deletions.
11 changes: 11 additions & 0 deletions engine/src/efx.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -683,6 +683,17 @@ const QList <EFXFixture*> EFX::fixtures() const
return m_fixtures;
}

EFXFixture *EFX::fixture(quint32 id, int headIndex)
{
foreach (EFXFixture *ef, m_fixtures)
{
if (ef->head().fxi == id && ef->head().head == headIndex)
return ef;
}

return NULL;
}

void EFX::slotFixtureRemoved(quint32 fxi_id)
{
/* Remove the destroyed fixture from our list */
Expand Down
18 changes: 11 additions & 7 deletions engine/src/efx.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -475,30 +475,34 @@ class EFX : public Function
*********************************************************************/
public:
/** Add a new fixture to this EFX */
bool addFixture(EFXFixture* ef);
bool addFixture(EFXFixture *ef);

/** Remove the designated fixture from this EFX but don't delete it */
bool removeFixture(EFXFixture* ef);
bool removeFixture(EFXFixture *ef);

/** Remove all the fixtures from this EFX but don't delete them */
void removeAllFixtures();

/** Raise a fixture in the serial order to an earlier position */
bool raiseFixture(EFXFixture* ef);
bool raiseFixture(EFXFixture *ef);

/** Lower a fixture in the serial order to a later position */
bool lowerFixture(EFXFixture* ef);
bool lowerFixture(EFXFixture *ef);

/** Get a list of fixtures taking part in this EFX */
const QList <EFXFixture*> fixtures() const;
const QList <EFXFixture *> fixtures() const;

/** Get an EFXFixture reference from Fixture $id and &headIndex
* Returns NULL on failure */
EFXFixture *fixture(quint32 id, int headIndex);

public slots:
/** Slot that captures Doc::fixtureRemoved signals */
void slotFixtureRemoved(quint32 fxi_id);

private:
QList <EFXFixture*> m_fixtures;
GenericFader* m_fader;
QList <EFXFixture *> m_fixtures;
GenericFader *m_fader;

/*********************************************************************
* Fixture propagation mode
Expand Down
13 changes: 9 additions & 4 deletions engine/test/efx/efx_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -449,13 +449,13 @@ void EFX_Test::fixtures()

/* Add first fixture */
EFXFixture* ef1 = new EFXFixture(e);
ef1->setHead(GroupHead(12,0));
ef1->setHead(GroupHead(12, 0));
QVERIFY(e->addFixture(ef1));
QCOMPARE(e->fixtures().size(), 1);

/* Add second fixture */
EFXFixture* ef2 = new EFXFixture(e);
ef2->setHead(GroupHead(34,0));
ef2->setHead(GroupHead(34, 0));
QVERIFY(e->addFixture(ef2));
QCOMPARE(e->fixtures().size(), 2);

Expand All @@ -466,7 +466,7 @@ void EFX_Test::fixtures()

/* Try to remove a non-member fixture */
EFXFixture* ef3 = new EFXFixture(e);
ef3->setHead(GroupHead(56,0));
ef3->setHead(GroupHead(56, 0));
QVERIFY(!e->removeFixture(ef3));
QCOMPARE(e->fixtures().size(), 2);

Expand All @@ -476,10 +476,15 @@ void EFX_Test::fixtures()
QCOMPARE(e->fixtures().at(0), ef1);
QCOMPARE(e->fixtures().at(1), ef2);
QCOMPARE(e->fixtures().at(2), ef3);
QCOMPARE(e->fixture(12, 0), ef1);
QCOMPARE(e->fixture(34, 0), ef2);
QCOMPARE(e->fixture(56, 0), ef3);
/* Test a non existent fixture */
QVERIFY(e->fixture(11, 22) == NULL);

/* Add fourth fixture */
EFXFixture* ef4 = new EFXFixture(e);
ef4->setHead(GroupHead(78,0));
ef4->setHead(GroupHead(78, 0));
e->addFixture(ef4);
QCOMPARE(e->fixtures().size(), 4);
QCOMPARE(e->fixtures().at(0), ef1);
Expand Down
73 changes: 47 additions & 26 deletions qmlui/efxeditor.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,10 +21,10 @@
#include <QDebug>
#include <QQmlEngine>

#include "qlcfixturemode.h"
#include "efxeditor.h"
#include "listmodel.h"
#include "qlcfixturemode.h"

#include "tardis.h"
#include "efx.h"
#include "doc.h"
#include "app.h"
Expand Down Expand Up @@ -88,12 +88,10 @@ int EFXEditor::algorithmIndex() const

void EFXEditor::setAlgorithmIndex(int algoIndex)
{
if (m_efx == NULL)
return;

if (algoIndex == m_efx->algorithm())
if (m_efx == NULL || algoIndex == m_efx->algorithm())
return;

Tardis::instance()->enqueueAction(EFXSetAlgorithmIndex, m_efx, m_efx->algorithm(), algoIndex);
m_efx->setAlgorithm(EFX::Algorithm(algoIndex));
emit algorithmIndexChanged();
updateAlgorithmData();
Expand All @@ -112,6 +110,7 @@ void EFXEditor::setIsRelative(bool val)
if (m_efx == NULL || val == m_efx->isRelative())
return;

Tardis::instance()->enqueueAction(EFXSetRelative, m_efx, m_efx->isRelative(), val);
m_efx->setIsRelative(val);
emit isRelativeChanged();
updateAlgorithmData();
Expand All @@ -130,6 +129,7 @@ void EFXEditor::setAlgorithmWidth(int algorithmWidth)
if (m_efx == NULL || algorithmWidth == m_efx->width())
return;

Tardis::instance()->enqueueAction(EFXSetWidth, m_efx, m_efx->width(), algorithmWidth);
m_efx->setWidth(algorithmWidth);
emit algorithmWidthChanged();
updateAlgorithmData();
Expand All @@ -148,6 +148,7 @@ void EFXEditor::setAlgorithmHeight(int algorithmHeight)
if (m_efx == NULL || algorithmHeight == m_efx->height())
return;

Tardis::instance()->enqueueAction(EFXSetHeight, m_efx, m_efx->height(), algorithmHeight);
m_efx->setHeight(algorithmHeight);
emit algorithmHeightChanged();
updateAlgorithmData();
Expand All @@ -166,6 +167,7 @@ void EFXEditor::setAlgorithmXOffset(int algorithmXOffset)
if (m_efx == NULL || algorithmXOffset == m_efx->xOffset())
return;

Tardis::instance()->enqueueAction(EFXSetXOffset, m_efx, m_efx->xOffset(), algorithmXOffset);
m_efx->setXOffset(algorithmXOffset);
emit algorithmXOffsetChanged();
updateAlgorithmData();
Expand All @@ -184,6 +186,7 @@ void EFXEditor::setAlgorithmYOffset(int algorithmYOffset)
if (m_efx == NULL || algorithmYOffset == m_efx->yOffset())
return;

Tardis::instance()->enqueueAction(EFXSetYOffset, m_efx, m_efx->yOffset(), algorithmYOffset);
m_efx->setYOffset(algorithmYOffset);
emit algorithmYOffsetChanged();
updateAlgorithmData();
Expand All @@ -202,6 +205,7 @@ void EFXEditor::setAlgorithmRotation(int algorithmRotation)
if (m_efx == NULL || algorithmRotation == m_efx->rotation())
return;

Tardis::instance()->enqueueAction(EFXSetRotation, m_efx, m_efx->rotation(), algorithmRotation);
m_efx->setRotation(algorithmRotation);
emit algorithmRotationChanged();
updateAlgorithmData();
Expand All @@ -220,6 +224,7 @@ void EFXEditor::setAlgorithmStartOffset(int algorithmStartOffset)
if (m_efx == NULL || algorithmStartOffset == m_efx->startOffset())
return;

Tardis::instance()->enqueueAction(EFXSetStartOffset, m_efx, m_efx->startOffset(), algorithmStartOffset);
m_efx->setStartOffset(algorithmStartOffset);
emit algorithmStartOffsetChanged();
updateAlgorithmData();
Expand All @@ -238,6 +243,7 @@ void EFXEditor::setAlgorithmXFrequency(int algorithmXFrequency)
if (m_efx == NULL || algorithmXFrequency == m_efx->xFrequency())
return;

Tardis::instance()->enqueueAction(EFXSetXFrequency, m_efx, m_efx->xFrequency(), algorithmXFrequency);
m_efx->setXFrequency(algorithmXFrequency);
emit algorithmXFrequencyChanged();
updateAlgorithmData();
Expand All @@ -256,6 +262,7 @@ void EFXEditor::setAlgorithmYFrequency(int algorithmYFrequency)
if (m_efx == NULL || algorithmYFrequency == m_efx->yFrequency())
return;

Tardis::instance()->enqueueAction(EFXSetYFrequency, m_efx, m_efx->yFrequency(), algorithmYFrequency);
m_efx->setYFrequency(algorithmYFrequency);
emit algorithmYFrequencyChanged();
updateAlgorithmData();
Expand All @@ -274,6 +281,7 @@ void EFXEditor::setAlgorithmXPhase(int algorithmXPhase)
if (m_efx == NULL || algorithmXPhase == m_efx->xPhase())
return;

Tardis::instance()->enqueueAction(EFXSetXPhase, m_efx, m_efx->xPhase(), algorithmXPhase);
m_efx->setXPhase(algorithmXPhase);
emit algorithmXPhaseChanged();
updateAlgorithmData();
Expand All @@ -292,6 +300,7 @@ void EFXEditor::setAlgorithmYPhase(int algorithmYPhase)
if (m_efx == NULL || algorithmYPhase == m_efx->yPhase())
return;

Tardis::instance()->enqueueAction(EFXSetYPhase, m_efx, m_efx->yPhase(), algorithmYPhase);
m_efx->setYPhase(algorithmYPhase);
emit algorithmYPhaseChanged();
updateAlgorithmData();
Expand Down Expand Up @@ -393,9 +402,14 @@ void EFXEditor::addGroup(QVariant reference)
EFXFixture* ef = new EFXFixture(m_efx);
ef->setHead(head);
if (m_efx->addFixture(ef) == false)
{
delete ef;
}
else
{
Tardis::instance()->enqueueAction(EFXAddFixture, m_efx, QVariant(), qVariantFromValue((void *)ef));
listChanged = true;
}
}
}
}
Expand Down Expand Up @@ -427,9 +441,14 @@ void EFXEditor::addFixture(QVariant reference)
ef->setHead(head);

if (m_efx->addFixture(ef) == false)
{
delete ef;
}
else
{
Tardis::instance()->enqueueAction(EFXAddFixture, m_efx, QVariant(), qVariantFromValue((void *)ef));
updateFixtureList();
}
}
}
}
Expand All @@ -444,24 +463,27 @@ void EFXEditor::addHead(int fixtureID, int headIndex)
ef->setHead(head);

if (m_efx->addFixture(ef) == false)
{
delete ef;
}
else
{
Tardis::instance()->enqueueAction(EFXAddFixture, m_efx, QVariant(), qVariantFromValue((void *)ef));
updateFixtureList();
}
}

void EFXEditor::setFixtureReversed(quint32 fixtureID, int headIndex, bool reversed)
{
if (m_efx == NULL)
return;

for (EFXFixture *efxFixture : m_efx->fixtures()) // C++11
{
if (efxFixture->head().fxi != fixtureID || efxFixture->head().head != headIndex)
continue;
EFXFixture *ef = m_efx->fixture(fixtureID, headIndex);

efxFixture->setDirection(reversed ? Function::Backward : Function::Forward);
if (ef != NULL)
{
ef->setDirection(reversed ? Function::Backward : Function::Forward);
updateAlgorithmData();
return;
}
}

Expand All @@ -470,14 +492,12 @@ void EFXEditor::setFixtureOffset(quint32 fixtureID, int headIndex, int offset)
if (m_efx == NULL)
return;

for (EFXFixture *efxFixture : m_efx->fixtures()) // C++11
{
if (efxFixture->head().fxi != fixtureID || efxFixture->head().head != headIndex)
continue;
EFXFixture *ef = m_efx->fixture(fixtureID, headIndex);

efxFixture->setStartOffset(offset);
if (ef != NULL)
{
ef->setStartOffset(offset);
updateAlgorithmData();
return;
}
}

Expand Down Expand Up @@ -643,12 +663,10 @@ int EFXEditor::fadeInSpeed() const

void EFXEditor::setFadeInSpeed(int fadeInSpeed)
{
if (m_efx == NULL)
return;

if (m_efx->fadeInSpeed() == (uint)fadeInSpeed)
if (m_efx == NULL || m_efx->fadeInSpeed() == (uint)fadeInSpeed)
return;

Tardis::instance()->enqueueAction(FunctionSetFadeIn, m_efx, m_efx->fadeInSpeed(), fadeInSpeed);
m_efx->setFadeInSpeed(fadeInSpeed);
emit fadeInSpeedChanged(fadeInSpeed);
}
Expand All @@ -670,6 +688,7 @@ void EFXEditor::setHoldSpeed(int holdSpeed)
return;

uint duration = Function::speedAdd(m_efx->fadeInSpeed(), holdSpeed);
Tardis::instance()->enqueueAction(FunctionSetDuration, m_efx, m_efx->duration(), duration);
m_efx->setDuration(duration);

emit holdSpeedChanged(holdSpeed);
Expand All @@ -686,12 +705,10 @@ int EFXEditor::fadeOutSpeed() const

void EFXEditor::setFadeOutSpeed(int fadeOutSpeed)
{
if (m_efx == NULL)
return;

if (m_efx->fadeOutSpeed() == (uint)fadeOutSpeed)
if (m_efx == NULL || m_efx->fadeOutSpeed() == (uint)fadeOutSpeed)
return;

Tardis::instance()->enqueueAction(FunctionSetFadeOut, m_efx, m_efx->fadeOutSpeed(), fadeOutSpeed);
m_efx->setFadeOutSpeed(fadeOutSpeed);
emit fadeOutSpeedChanged(fadeOutSpeed);
}
Expand Down Expand Up @@ -721,6 +738,8 @@ void EFXEditor::setRunOrder(int runOrder)
if (m_efx == NULL || m_efx->runOrder() == Function::RunOrder(runOrder))
return;

Tardis::instance()->enqueueAction(FunctionSetRunOrder, m_efx, m_efx->runOrder(), runOrder);

m_efx->setRunOrder(Function::RunOrder(runOrder));
emit runOrderChanged(runOrder);
}
Expand All @@ -738,6 +757,8 @@ void EFXEditor::setDirection(int direction)
if (m_efx == NULL || m_efx->direction() == Function::Direction(direction))
return;

Tardis::instance()->enqueueAction(FunctionSetDirection, m_efx, m_efx->direction(), direction);

m_efx->setDirection(Function::Direction(direction));
emit directionChanged(direction);
}
Expand Down

0 comments on commit 2ed0003

Please sign in to comment.