15615545913

Committed 12 Jun 2025 04:03PM UTC coverage: 31.812% (-0.06%) from 31.872%

Build # 15615545913

Build Type

Pull #1649

github

Committed by

web-flow

Commit Message

Merge 18a278d0e into 7fd06c76d

Pull Request Pull Request #1649: Function Wizard: create Effects

Run Details

11 of 135 new or added lines in 2 files covered. (8.15%)

2 existing lines in 1 file now uncovered.

16446 of 51698 relevant lines covered (31.81%)

19075.62 hits per line

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

45.61

/ui/src/palettegenerator.cpp

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

#include "qlccapability.h"
#include "qlcfixturedef.h"
#include "qlcfixturehead.h"
#include "qlcchannel.h"

#include "palettegenerator.h"
#include "rgbscriptscache.h"
#include "fixturegroup.h"
#include "chaserstep.h"
#include "rgbmatrix.h"
#include "efx.h"
#include "fixture.h"
#include "chaser.h"
#include "scene.h"
#include "doc.h"

PaletteGenerator::PaletteGenerator(Doc* doc, const QList <Fixture*>& fxList,
                                   PaletteType type, PaletteSubType subType, EFX::Algorithm efxAlgo)
    : m_doc(doc)
    , m_name(QString())
    , m_type(type)
    , m_subType(subType)
    , m_efxAlgo(efxAlgo)
    , m_fixtures(fxList)
    , m_fixtureGroup(NULL)
{
    if (m_fixtures.count() > 0)
    {
        m_name = typetoString(type);
        if (m_fixtures.at(0)->fixtureDef() != NULL)
            m_model = m_fixtures.at(0)->fixtureDef()->model();
        if (type != Undefined)
            createFunctions(type, subType);
    }
}

PaletteGenerator::~PaletteGenerator()
{
    m_fixtures.clear();
    m_scenes.clear();
    m_chasers.clear();
    m_matrices.clear();
    m_efxs.clear();
}

void PaletteGenerator::setName(QString name)
{
    m_name = name;
}

QString PaletteGenerator::name()
{
    return m_name;
}

QString PaletteGenerator::fullName()
{
    return m_name + " - " + m_model;
}

QString PaletteGenerator::model()
{
    return m_model;
}

PaletteGenerator::PaletteType PaletteGenerator::type()
{
    return m_type;
}

PaletteGenerator::PaletteSubType PaletteGenerator::subType()
{
    return m_subType;
}

QString PaletteGenerator::typetoString(PaletteGenerator::PaletteType type)
{
    switch(type)
    {
        case PrimaryColors: return tr("Primary colours"); break;
        case SixteenColors: return tr("16 Colours"); break;
        case Shutter: return tr("Shutter macros");
        case Gobos: return tr("Gobo macros");
        case ColourMacro: return tr("Colour macros");
        case Animation: return tr("Animations");
        case EfxDimmer: return tr("Dimmer EFXs");
        case EfxPosition: return tr("Position EFXs");
        case EfxRGB: return tr("RGB EFXs");
        case Undefined:
        default:
            return tr("Unknown");
        break;
    }
}

QStringList PaletteGenerator::getCapabilities(const Fixture *fixture)
{
    QStringList caps;
    bool hasPan = false, hasTilt = false;
    bool hasRed = false, hasGreen = false, hasBlue = false;
    bool hasCyan = false, hasMagenta = false, hasYellow = false;
    bool hasWhite = false;
    bool hasDimmer = false;

    Q_ASSERT(fixture != NULL);
    for (quint32 ch = 0; ch < fixture->channels(); ch++)
    {
        const QLCChannel* channel(fixture->channel(ch));
        Q_ASSERT(channel != NULL);

        switch (channel->group())
        {
            case QLCChannel::Colour:
            case QLCChannel::Gobo:
            case QLCChannel::Shutter:
            {
                if (channel->capabilities().size() > 1)
                {
                    QString cap = QLCChannel::groupToString(channel->group());
                    if (!caps.contains(cap))
                        caps.append(cap);
                }
            }
            break;
            case QLCChannel::Pan:
                hasPan = true;
            break;
            case QLCChannel::Tilt:
                hasTilt = true;
            break;
            case QLCChannel::Intensity:
            {
                QLCChannel::PrimaryColour col = channel->colour();
                switch (col)
                {
                    case QLCChannel::Red: hasRed = true; break;
                    case QLCChannel::Green: hasGreen = true; break;
                    case QLCChannel::Blue: hasBlue = true; break;
                    case QLCChannel::Cyan: hasCyan = true; break;
                    case QLCChannel::Magenta: hasMagenta = true; break;
                    case QLCChannel::Yellow: hasYellow = true; break;
                    case QLCChannel::White: hasWhite = true; break;
                    default: break;
                }
                if (channel->preset() == QLCChannel::IntensityDimmer ||
                    channel->preset() == QLCChannel::IntensityMasterDimmer)
                    hasDimmer = true;
            }
            break;
            default:
            break;
        }
    }

    if (hasPan && hasTilt)
        caps.append(KQLCChannelMovement);

    if (hasRed && hasGreen && hasBlue)
        caps.append(KQLCChannelRGB);

    if (hasCyan && hasMagenta && hasYellow)
        caps.append(KQLCChannelCMY);

    if (hasWhite)
        caps.append(KQLCChannelWhite);

    if (hasDimmer)
        caps.append(KQLCChannelDimmer);

    return caps;
}

QList<Scene *> PaletteGenerator::scenes()
{
    return m_scenes;
}

QList<Chaser *> PaletteGenerator::chasers()
{
    return m_chasers;
}

QList<RGBMatrix *> PaletteGenerator::matrices()
{
    return m_matrices;
}

QList<EFX *> PaletteGenerator::efxs()
{
    return m_efxs;
}

void PaletteGenerator::addToDoc()
{
    foreach (Scene *scene, m_scenes)
        m_doc->addFunction(scene);

    foreach (Chaser *chaser, m_chasers)
    {
        foreach (Scene *scene, m_scenes)
        {
            qDebug() << "Add chaser step:" << scene->id();
            chaser->addStep(ChaserStep(scene->id()));
        }
        m_doc->addFunction(chaser);
    }

    if (m_fixtureGroup != NULL)
        m_doc->addFixtureGroup(m_fixtureGroup);

    foreach (RGBMatrix *matrix, m_matrices)
    {
        matrix->setFixtureGroup(m_fixtureGroup->id());
        m_doc->addFunction(matrix);
    }
    foreach (EFX *efx, m_efxs)
    {
        m_doc->addFunction(efx);
    }
}

void PaletteGenerator::createColorScene(QList<SceneValue> chMap, QString name, PaletteSubType subType)
{
    if (chMap.size() == 0)
        return;

    Scene *scene = new Scene(m_doc);
    Scene *evenScene = NULL;
    Scene *oddScene = NULL;
    bool even = false;

    if (subType == OddEven)
    {
        evenScene = new Scene(m_doc);
        oddScene = new Scene(m_doc);
    }

    foreach (SceneValue scv, chMap)
    {

        scene->setValue(scv.fxi, scv.channel, 255);
        if (subType == OddEven)
        {
            if (even)
                evenScene->setValue(scv.fxi, scv.channel, 255);
            else
                oddScene->setValue(scv.fxi, scv.channel, 255);
            even = !even;
        }
    }
    scene->setName(getNamePrefix("Color", name));
    m_scenes.append(scene);
    if (subType == OddEven)
    {
        evenScene->setName(tr("%1 (Even)").arg(getNamePrefix("Color", name)));
        oddScene->setName(tr("%1 (Odd)").arg(getNamePrefix("Color", name)));
        m_scenes.append(evenScene);
        m_scenes.append(oddScene);
    }
}

void PaletteGenerator::createRGBCMYScene(QList<SceneValue> rcMap,
                                         QList<SceneValue> gmMap,
                                         QList<SceneValue> byMap,
                                         QString name, bool rgb,
                                         PaletteGenerator::PaletteSubType subType)
{
    if (rcMap.size() == 0 || gmMap.size() == 0 || byMap.size() == 0)
        return;

    bool even = false;
    QList <QColor> m_colList;
    QList <QString> m_colNames;

    m_colList << Qt::black << Qt::darkBlue << Qt::blue << Qt::darkGreen <<
                 Qt::darkCyan << Qt::green << Qt::cyan << Qt::darkRed <<
                 Qt::darkMagenta << Qt::darkYellow << Qt::darkGray << Qt::lightGray <<
                 Qt::red << Qt::magenta << Qt::yellow << Qt::white;

    m_colNames << tr("Black") << tr("Dark Blue") << tr("Blue") << tr("Dark Green")
               << tr("Dark Cyan") << tr("Green") << tr("Cyan") << tr("Dark Red")
               << tr("Dark Magenta") << tr("Dark Yellow") << tr("Dark Gray") << tr("Light Gray")
               << tr("Red") << tr("Magenta") << tr("Yellow") << tr("White");

    for (int i = 0; i < m_colList.count(); i++)
    {
        QColor col = m_colList.at(i);
        uchar rc = col.red();
        uchar gm = col.green();
        uchar by = col.blue();
        if (rgb == false)
        {
            rc = col.cyan();
            gm = col.magenta();
            by = col.yellow();
        }

        Scene *scene = new Scene(m_doc);
        Scene *evenScene = NULL;
        Scene *oddScene = NULL;

        if (subType == OddEven)
        {
            evenScene = new Scene(m_doc);
            oddScene = new Scene(m_doc);
        }

        foreach (SceneValue scv, rcMap)
        {
            Fixture *fxi = m_doc->fixture(scv.fxi);
            int gmCh = -1, byCh = -1;

            for (int i = 0; i < fxi->heads(); i++)
            {
                QLCFixtureHead head = fxi->head(i);
                if (head.channels().contains(scv.channel))
                {
                    if (head.rgbChannels().count() == 3)
                    {
                        gmCh = head.rgbChannels().at(1);
                        byCh = head.rgbChannels().at(2);
                    }
                    else if (head.cmyChannels().count() == 3)
                    {
                        gmCh = head.cmyChannels().at(1);
                        byCh = head.cmyChannels().at(2);
                    }
                    break;
                }
            }

            // if no green/magenta or no blue/yellow channels
            // are found, there's no chance to set a full RGB/CMY color
            if (gmCh == -1 || byCh == -1)
                continue;

            scene->setValue(scv.fxi, scv.channel, rc);
            scene->setValue(scv.fxi, gmCh, gm);
            scene->setValue(scv.fxi, byCh, by);

            if (subType == OddEven)
            {
                if (even)
                {
                    evenScene->setValue(scv.fxi, scv.channel, rc);
                    evenScene->setValue(scv.fxi, gmCh, gm);
                    evenScene->setValue(scv.fxi, byCh, by);
                }
                else
                {
                    oddScene->setValue(scv.fxi, scv.channel, rc);
                    oddScene->setValue(scv.fxi, gmCh, gm);
                    oddScene->setValue(scv.fxi, byCh, by);
                }
                even = !even;
            }
        }
        qDebug() << "color name:" << m_colNames.at(i) << "i:" << i << "count:" << m_colNames.count();

        scene->setName(getNamePrefix(m_colNames.at(i), name));
        m_scenes.append(scene);
        if (subType == OddEven)
        {
            evenScene->setName(tr("%1 (Even)").arg(getNamePrefix(m_colNames.at(i),name)));
            oddScene->setName(tr("%1 (Odd)").arg(getNamePrefix(m_colNames.at(i),name)));
            m_scenes.append(evenScene);
            m_scenes.append(oddScene);
        }
    }
}

void PaletteGenerator::createCapabilityScene(QHash<quint32, quint32> chMap,
                                             PaletteGenerator::PaletteSubType subType)
{
    if (chMap.size() == 0)
        return;

    Fixture *fxi = m_fixtures.at(0);
    Q_ASSERT(fxi != NULL);
    QHashIterator <quint32, quint32> it(chMap);

    quint32 ch = it.next().value();
    const QLCChannel* channel = fxi->channel(ch);
    QStringList tmpCapList;

    for (int cIdx = 0; cIdx < channel->capabilities().count(); cIdx++)
    {
        Scene *scene = new Scene(m_doc);
        Scene *evenScene = NULL;
        Scene *oddScene = NULL;
        bool even = false;
        QLCCapability *cap = channel->capabilities().at(cIdx);
        uchar value = cap->middle();
        QString name = cap->name();

        // Do not add the same capability twice
        if (tmpCapList.contains(name))
            continue;

        tmpCapList.append(name);

        if (subType == OddEven)
        {
            evenScene = new Scene(m_doc);
            oddScene = new Scene(m_doc);
        }

        QHashIterator <quint32, quint32> it(chMap);
        while (it.hasNext() == true)
        {
            it.next();
            scene->setValue(it.key(), it.value(), value);
            if (subType == OddEven)
            {
                if (even)
                    evenScene->setValue(it.key(), it.value(), value);
                else
                    oddScene->setValue(it.key(), it.value(), value);
                even = !even;
            }
        }

        scene->setName(getNamePrefix(channel->name(),  name));
        m_scenes.append(scene);
        if (subType == OddEven)
        {
            evenScene->setName(getNamePrefix(channel->name(),  name) + tr(" - Even"));
            oddScene->setName(getNamePrefix(channel->name(),  name) + tr(" - Odd"));
            m_scenes.append(evenScene);
            m_scenes.append(oddScene);
        }
    }
}

void PaletteGenerator::createRGBMatrices(QList<SceneValue> rgbMap)
{
    m_fixtureGroup = new FixtureGroup(m_doc);
    m_fixtureGroup->setSize(QSize(rgbMap.size(), 1));

    foreach (SceneValue scv, rgbMap)
    {
        m_fixtureGroup->assignFixture(scv.fxi);
        m_fixtureGroup->setName(m_model + tr(" - RGB Group"));
    }
    QStringList algoList = m_doc->rgbScriptsCache()->names();
    foreach (QString algo, algoList)
    {
        RGBMatrix *matrix = new RGBMatrix(m_doc);
        matrix->setName(tr("Animation %1").arg(algo) + " - " + m_model);
        //matrix->setFixtureGroup();
        matrix->setAlgorithm(RGBAlgorithm::algorithm(m_doc, algo));
        m_matrices.append(matrix);
    }
}

EFX *PaletteGenerator::createEfx(QList<Fixture *> fixtures, EFXFixture::Mode mode, EFX::PropagationMode propMode)
{
    EFX *efx = new EFX(m_doc);

    efx->setName(tr("EFX %1 %2 %3 - ")
        .arg(EFXFixture::modeToString(mode))
        .arg(EFX::algorithmToString(m_efxAlgo))
        .arg(EFX::propagationModeToString(propMode)) + m_model);

    efx->setAlgorithm(m_efxAlgo);

    efx->setPropagationMode(propMode);

    for (int i = 0; i < fixtures.count(); i++)
    {
        Fixture *fixture = fixtures[i];
        for (int h = 0; h < fixture->heads(); h++)
        {
            qDebug() << "fx" << fixture->channelAddress(0) << " " << h;

            EFXFixture *ef = new EFXFixture(efx);
            ef->setHead(GroupHead(fixture->id(), h));
            ef->setMode(mode);
            efx->addFixture(ef);
        }
    }

    qDebug() << "efx: " << efx << efx->fixtures().count();

    return efx;
}

void PaletteGenerator::createEfxs(QList<Fixture *> fixtures, EFXFixture::Mode mode,
                                  PaletteSubType subType)
{
    qDebug() << "createEfxs";

    if ((subType & PaletteSubType::Parallel) == PaletteSubType::Parallel)
        m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Parallel));
    if ((subType & PaletteSubType::Serial) == PaletteSubType::Serial)
        m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Serial));
    if ((subType & PaletteSubType::Asymetric) == PaletteSubType::Asymetric)
        m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Asymmetric));
}

void PaletteGenerator::createChaser(QString name)
{
    if (m_scenes.count() == 0)
        return;

    Chaser *chaser = new Chaser(m_doc);
    chaser->setFadeInMode(Chaser::Common);
    chaser->setFadeInSpeed(3000);
    chaser->setFadeOutMode(Chaser::Common);
    chaser->setFadeOutSpeed(0);
    chaser->setDurationMode(Chaser::Common);
    chaser->setDuration(10000);
    chaser->setName(tr("%1 chaser - %2").arg(name).arg(m_model));

    // that's all here. I need to add an empty Chaser cause
    // scene's IDs have not been assigned yet
    m_chasers.append(chaser);
}

void PaletteGenerator::createFunctions(PaletteGenerator::PaletteType type,
                                       PaletteGenerator::PaletteSubType subType)
{
    if (m_fixtures.count() == 0)
        return;

    // the following QHash will hold the fixture/channel map of each fixture
    // in m_fixtures depending on type and subtype
    QHash<quint32, quint32> m_panList;
    QHash<quint32, quint32> m_tiltList;
    QList<SceneValue> m_redList;
    QList<SceneValue> m_greenList;
    QList<SceneValue> m_blueList;
    QList<SceneValue> m_cyanList;
    QList<SceneValue> m_magentaList;
    QList<SceneValue> m_yellowList;
    QList<SceneValue> m_whiteList;
    QHash<quint32, quint32> m_goboList;
    QHash<quint32, quint32> m_shutterList;
    QHash<quint32, quint32> m_colorMacroList;

    for (int i = 0; i < m_fixtures.count(); i++)
    {
        Fixture *fixture = m_fixtures.at(i);
        Q_ASSERT(fixture != NULL);
        quint32 fxID = fixture->id();

        for (quint32 ch = 0; ch < fixture->channels(); ch++)
        {
            const QLCChannel* channel(fixture->channel(ch));
            Q_ASSERT(channel != NULL);

            switch (channel->group())
            {
                case QLCChannel::Pan: m_panList[fxID] = ch; break;
                case QLCChannel::Tilt: m_tiltList[fxID] = ch; break;
                case QLCChannel::Gobo: m_goboList[fxID] = ch; break;
                case QLCChannel::Shutter: m_shutterList[fxID] = ch; break;
                case QLCChannel::Colour: m_colorMacroList[fxID] = ch; break;
                case QLCChannel::Intensity:
                {
                    QLCChannel::PrimaryColour col = channel->colour();
                    switch (col)
                    {
                        case QLCChannel::Red: m_redList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::Green: m_greenList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::Blue: m_blueList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::Cyan: m_cyanList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::Magenta: m_magentaList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::Yellow: m_yellowList.append(SceneValue(fxID, ch)); break;
                        case QLCChannel::White: m_whiteList.append(SceneValue(fxID, ch)); break;
                        default: break;
                    }
                }
                break;
                default:
                break;
            }
        }
    }

    switch (type)
    {
        case PrimaryColors:
        {
            createColorScene(m_redList, tr("Red scene"), subType);
            createColorScene(m_greenList, tr("Green scene"), subType);
            createColorScene(m_blueList, tr("Blue scene"), subType);
            createColorScene(m_cyanList, tr("Cyan scene"), subType);
            createColorScene(m_magentaList, tr("Magenta scene"), subType);
            createColorScene(m_yellowList, tr("Yellow scene"), subType);
            createColorScene(m_whiteList, tr("White scene"), subType);
            createChaser(typetoString(type));
        }
        break;
        case SixteenColors:
        {
            if (m_redList.size() > 0 && m_greenList.size() == m_redList.size() && m_blueList.size() ==  m_redList.size())
                createRGBCMYScene(m_redList, m_greenList, m_blueList, tr("Scene"), true, subType);
            else if (m_cyanList.size() > 0 && m_magentaList.size() == m_cyanList.size() && m_yellowList.size() ==  m_cyanList.size())
                createRGBCMYScene(m_cyanList, m_magentaList, m_yellowList, tr("Scene"), false, subType);
            createChaser(typetoString(type));
        }
        break;
        case Animation:
        {
            if (m_redList.size() > 1 && m_greenList.size() == m_redList.size() && m_blueList.size() ==  m_redList.size())
                createRGBMatrices(m_redList);
        }
        break;
        case EfxDimmer:
            createEfxs(m_fixtures, EFXFixture::Mode::Dimmer, subType);
        break;
        case EfxRGB:
            createEfxs(m_fixtures, EFXFixture::Mode::RGB, subType);
        break;
        case EfxPosition:
            createEfxs(m_fixtures, EFXFixture::Mode::PanTilt, subType);
        break;
        case Gobos:
        {
            createCapabilityScene(m_goboList, subType);
            createChaser(typetoString(type));
        }
        break;
        case Shutter:
        {
            createCapabilityScene(m_shutterList, subType);
            createChaser(typetoString(type));
        }
        break;
        case ColourMacro:
        {
            createCapabilityScene(m_colorMacroList, subType);
            createChaser(typetoString(type));
        }
        break;
        case Undefined:
        default:
        break;

    }
}

QString PaletteGenerator::getNamePrefix(QString name)
{
    // return name + " - " + m_model; // old naming
    return m_model + " - " + name;
}

QString PaletteGenerator::getNamePrefix(QString type, QString name)
{
    // return name + " - " + type + " - " + m_model; // old naming
    return m_model + " - " + type + " - " + name;
}

1	/*
2	Q Light Controller Plus
3	palettegenerator.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 <QString>
21	#include <QDebug>
22
23	#include "qlccapability.h"
24	#include "qlcfixturedef.h"
25	#include "qlcfixturehead.h"
26	#include "qlcchannel.h"
27
28	#include "palettegenerator.h"
29	#include "rgbscriptscache.h"
30	#include "fixturegroup.h"
31	#include "chaserstep.h"
32	#include "rgbmatrix.h"
33	#include "efx.h"
34	#include "fixture.h"
35	#include "chaser.h"
36	#include "scene.h"
37	#include "doc.h"
38
39	PaletteGenerator::PaletteGenerator(Doc* doc, const QList <Fixture*>& fxList,	4✔
40	PaletteType type, PaletteSubType subType, EFX::Algorithm efxAlgo)	4✔
41	: m_doc(doc)	4✔
42	, m_name(QString())	4✔
43	, m_type(type)	4✔
44	, m_subType(subType)	4✔
45	, m_efxAlgo(efxAlgo)	4✔
46	, m_fixtures(fxList)	4✔
47	, m_fixtureGroup(NULL)	8✔
48	{
49	if (m_fixtures.count() > 0)	4✔
50	{
51	m_name = typetoString(type);	4✔
52	if (m_fixtures.at(0)->fixtureDef() != NULL)	4✔
53	m_model = m_fixtures.at(0)->fixtureDef()->model();	3✔
54	if (type != Undefined)	4✔
55	createFunctions(type, subType);	3✔
56	}
57	}	4✔
58
59	PaletteGenerator::~PaletteGenerator()	4✔
60	{
61	m_fixtures.clear();	4✔
62	m_scenes.clear();	4✔
63	m_chasers.clear();	4✔
64	m_matrices.clear();	4✔
65	m_efxs.clear();	4✔
66	}	4✔
67
68	void PaletteGenerator::setName(QString name)	×
69	{
70	m_name = name;	×
71	}	×
72
73	QString PaletteGenerator::name()	×
74	{
75	return m_name;	×
76	}
77
78	QString PaletteGenerator::fullName()	×
79	{
80	return m_name + " - " + m_model;	×
81	}
82
83	QString PaletteGenerator::model()	×
84	{
85	return m_model;	×
86	}
87
88	PaletteGenerator::PaletteType PaletteGenerator::type()	×
89	{
90	return m_type;	×
91	}
92
93	PaletteGenerator::PaletteSubType PaletteGenerator::subType()	×
94	{
95	return m_subType;	×
96	}
97
98	QString PaletteGenerator::typetoString(PaletteGenerator::PaletteType type)	7✔
99	{
100	switch(type)	7✔
101	{
102	case PrimaryColors: return tr("Primary colours"); break;	×
103	case SixteenColors: return tr("16 Colours"); break;	×
104	case Shutter: return tr("Shutter macros");	2✔
105	case Gobos: return tr("Gobo macros");	2✔
106	case ColourMacro: return tr("Colour macros");	2✔
107	case Animation: return tr("Animations");	×
NEW 108	case EfxDimmer: return tr("Dimmer EFXs");	×
NEW 109	case EfxPosition: return tr("Position EFXs");	×
NEW 110	case EfxRGB: return tr("RGB EFXs");	×
111	case Undefined:	1✔
112	default:
113	return tr("Unknown");	1✔
114	break;
115	}
116	}
117
118	QStringList PaletteGenerator::getCapabilities(const Fixture *fixture)	2✔
119	{
120	QStringList caps;	2✔
121	bool hasPan = false, hasTilt = false;	2✔
122	bool hasRed = false, hasGreen = false, hasBlue = false;	2✔
123	bool hasCyan = false, hasMagenta = false, hasYellow = false;	2✔
124	bool hasWhite = false;	2✔
125	bool hasDimmer = false;	2✔
126
127	Q_ASSERT(fixture != NULL);	2✔
128	for (quint32 ch = 0; ch < fixture->channels(); ch++)	17✔
129	{
130	const QLCChannel* channel(fixture->channel(ch));	15✔
131	Q_ASSERT(channel != NULL);	15✔
132
133	switch (channel->group())	15✔
134	{
135	case QLCChannel::Colour:	4✔
136	case QLCChannel::Gobo:
137	case QLCChannel::Shutter:
138	{
139	if (channel->capabilities().size() > 1)	4✔
140	{
141	QString cap = QLCChannel::groupToString(channel->group());	4✔
142	if (!caps.contains(cap))	4✔
143	caps.append(cap);	4✔
144	}	4✔
145	}
146	break;	4✔
147	case QLCChannel::Pan:	2✔
148	hasPan = true;	2✔
149	break;	2✔
150	case QLCChannel::Tilt:	2✔
151	hasTilt = true;	2✔
152	break;	2✔
153	case QLCChannel::Intensity:	5✔
154	{
155	QLCChannel::PrimaryColour col = channel->colour();	5✔
156	switch (col)	5✔
157	{
158	case QLCChannel::Red: hasRed = true; break;	×
159	case QLCChannel::Green: hasGreen = true; break;	×
160	case QLCChannel::Blue: hasBlue = true; break;	×
161	case QLCChannel::Cyan: hasCyan = true; break;	1✔
162	case QLCChannel::Magenta: hasMagenta = true; break;	1✔
163	case QLCChannel::Yellow: hasYellow = true; break;	1✔
164	case QLCChannel::White: hasWhite = true; break;	×
165	default: break;	2✔
166	}
167	if (channel->preset() == QLCChannel::IntensityDimmer \|\|	9✔
168	channel->preset() == QLCChannel::IntensityMasterDimmer)	4✔
169	hasDimmer = true;	1✔
170	}
171	break;	5✔
172	default:	2✔
173	break;	2✔
174	}
175	}
176
177	if (hasPan && hasTilt)	2✔
178	caps.append(KQLCChannelMovement);	2✔
179
180	if (hasRed && hasGreen && hasBlue)	2✔
181	caps.append(KQLCChannelRGB);	×
182
183	if (hasCyan && hasMagenta && hasYellow)	2✔
184	caps.append(KQLCChannelCMY);	1✔
185
186	if (hasWhite)	2✔
187	caps.append(KQLCChannelWhite);	×
188
189	if (hasDimmer)	2✔
190	caps.append(KQLCChannelDimmer);	1✔
191
192	return caps;	2✔
193	}	×
194
195	QList<Scene *> PaletteGenerator::scenes()	×
196	{
197	return m_scenes;	×
198	}
199
200	QList<Chaser *> PaletteGenerator::chasers()	×
201	{
202	return m_chasers;	×
203	}
204
205	QList<RGBMatrix *> PaletteGenerator::matrices()	×
206	{
207	return m_matrices;	×
208	}
209
NEW 210	QList<EFX *> PaletteGenerator::efxs()	×
211	{
NEW 212	return m_efxs;	×
213	}
214
215	void PaletteGenerator::addToDoc()	3✔
216	{
217	foreach (Scene *scene, m_scenes)	36✔
218	m_doc->addFunction(scene);	36✔
219
220	foreach (Chaser *chaser, m_chasers)	6✔
221	{
222	foreach (Scene *scene, m_scenes)	36✔
223	{
224	qDebug() << "Add chaser step:" << scene->id();	33✔
225	chaser->addStep(ChaserStep(scene->id()));	33✔
226	}	3✔
227	m_doc->addFunction(chaser);	3✔
228	}	3✔
229
230	if (m_fixtureGroup != NULL)	3✔
231	m_doc->addFixtureGroup(m_fixtureGroup);	×
232
233	foreach (RGBMatrix *matrix, m_matrices)	3✔
234	{
235	matrix->setFixtureGroup(m_fixtureGroup->id());	×
236	m_doc->addFunction(matrix);	×
237	}	3✔
238	foreach (EFX *efx, m_efxs)	3✔
239	{
NEW 240	m_doc->addFunction(efx);	×
241	}	3✔
242	}	3✔
243
244	void PaletteGenerator::createColorScene(QList<SceneValue> chMap, QString name, PaletteSubType subType)	×
245	{
246	if (chMap.size() == 0)	×
247	return;	×
248
249	Scene *scene = new Scene(m_doc);	×
250	Scene *evenScene = NULL;	×
251	Scene *oddScene = NULL;	×
252	bool even = false;	×
253
254	if (subType == OddEven)	×
255	{
256	evenScene = new Scene(m_doc);	×
257	oddScene = new Scene(m_doc);	×
258	}
259
260	foreach (SceneValue scv, chMap)	×
261	{
262
263	scene->setValue(scv.fxi, scv.channel, 255);	×
264	if (subType == OddEven)	×
265	{
266	if (even)	×
267	evenScene->setValue(scv.fxi, scv.channel, 255);	×
268	else
269	oddScene->setValue(scv.fxi, scv.channel, 255);	×
270	even = !even;	×
271	}
272	}	×
273	scene->setName(getNamePrefix("Color", name));	×
274	m_scenes.append(scene);	×
275	if (subType == OddEven)	×
276	{
277	evenScene->setName(tr("%1 (Even)").arg(getNamePrefix("Color", name)));	×
278	oddScene->setName(tr("%1 (Odd)").arg(getNamePrefix("Color", name)));	×
279	m_scenes.append(evenScene);	×
280	m_scenes.append(oddScene);	×
281	}
282	}
283
284	void PaletteGenerator::createRGBCMYScene(QList<SceneValue> rcMap,	×
285	QList<SceneValue> gmMap,
286	QList<SceneValue> byMap,
287	QString name, bool rgb,
288	PaletteGenerator::PaletteSubType subType)
289	{
290	if (rcMap.size() == 0 \|\| gmMap.size() == 0 \|\| byMap.size() == 0)	×
291	return;	×
292
293	bool even = false;	×
294	QList <QColor> m_colList;	×
295	QList <QString> m_colNames;	×
296
297	m_colList << Qt::black << Qt::darkBlue << Qt::blue << Qt::darkGreen <<	×
298	Qt::darkCyan << Qt::green << Qt::cyan << Qt::darkRed <<	×
299	Qt::darkMagenta << Qt::darkYellow << Qt::darkGray << Qt::lightGray <<	×
300	Qt::red << Qt::magenta << Qt::yellow << Qt::white;	×
301
302	m_colNames << tr("Black") << tr("Dark Blue") << tr("Blue") << tr("Dark Green")	×
303	<< tr("Dark Cyan") << tr("Green") << tr("Cyan") << tr("Dark Red")	×
304	<< tr("Dark Magenta") << tr("Dark Yellow") << tr("Dark Gray") << tr("Light Gray")	×
305	<< tr("Red") << tr("Magenta") << tr("Yellow") << tr("White");	×
306
307	for (int i = 0; i < m_colList.count(); i++)	×
308	{
309	QColor col = m_colList.at(i);	×
310	uchar rc = col.red();	×
311	uchar gm = col.green();	×
312	uchar by = col.blue();	×
313	if (rgb == false)	×
314	{
315	rc = col.cyan();	×
316	gm = col.magenta();	×
317	by = col.yellow();	×
318	}
319
320	Scene *scene = new Scene(m_doc);	×
321	Scene *evenScene = NULL;	×
322	Scene *oddScene = NULL;	×
323
324	if (subType == OddEven)	×
325	{
326	evenScene = new Scene(m_doc);	×
327	oddScene = new Scene(m_doc);	×
328	}
329
330	foreach (SceneValue scv, rcMap)	×
331	{
332	Fixture *fxi = m_doc->fixture(scv.fxi);	×
333	int gmCh = -1, byCh = -1;	×
334
335	for (int i = 0; i < fxi->heads(); i++)	×
336	{
337	QLCFixtureHead head = fxi->head(i);	×
338	if (head.channels().contains(scv.channel))	×
339	{
340	if (head.rgbChannels().count() == 3)	×
341	{
342	gmCh = head.rgbChannels().at(1);	×
343	byCh = head.rgbChannels().at(2);	×
344	}
345	else if (head.cmyChannels().count() == 3)	×
346	{
347	gmCh = head.cmyChannels().at(1);	×
348	byCh = head.cmyChannels().at(2);	×
349	}
350	break;	×
351	}
352	}	×
353
354	// if no green/magenta or no blue/yellow channels
355	// are found, there's no chance to set a full RGB/CMY color
356	if (gmCh == -1 \|\| byCh == -1)	×
357	continue;	×
358
359	scene->setValue(scv.fxi, scv.channel, rc);	×
360	scene->setValue(scv.fxi, gmCh, gm);	×
361	scene->setValue(scv.fxi, byCh, by);	×
362
363	if (subType == OddEven)	×
364	{
365	if (even)	×
366	{
367	evenScene->setValue(scv.fxi, scv.channel, rc);	×
368	evenScene->setValue(scv.fxi, gmCh, gm);	×
369	evenScene->setValue(scv.fxi, byCh, by);	×
370	}
371	else
372	{
373	oddScene->setValue(scv.fxi, scv.channel, rc);	×
374	oddScene->setValue(scv.fxi, gmCh, gm);	×
375	oddScene->setValue(scv.fxi, byCh, by);	×
376	}
377	even = !even;	×
378	}
379	}	×
380	qDebug() << "color name:" << m_colNames.at(i) << "i:" << i << "count:" << m_colNames.count();	×
381
382	scene->setName(getNamePrefix(m_colNames.at(i), name));	×
383	m_scenes.append(scene);	×
384	if (subType == OddEven)	×
385	{
386	evenScene->setName(tr("%1 (Even)").arg(getNamePrefix(m_colNames.at(i),name)));	×
387	oddScene->setName(tr("%1 (Odd)").arg(getNamePrefix(m_colNames.at(i),name)));	×
388	m_scenes.append(evenScene);	×
389	m_scenes.append(oddScene);	×
390	}
391	}
392	}	×
393
394	void PaletteGenerator::createCapabilityScene(QHash<quint32, quint32> chMap,	3✔
395	PaletteGenerator::PaletteSubType subType)
396	{
397	if (chMap.size() == 0)	3✔
398	return;	×
399
400	Fixture *fxi = m_fixtures.at(0);	3✔
401	Q_ASSERT(fxi != NULL);	3✔
402	QHashIterator <quint32, quint32> it(chMap);	3✔
403
404	quint32 ch = it.next().value();	3✔
405	const QLCChannel* channel = fxi->channel(ch);	3✔
406	QStringList tmpCapList;	3✔
407
408	for (int cIdx = 0; cIdx < channel->capabilities().count(); cIdx++)	42✔
409	{
410	Scene *scene = new Scene(m_doc);	39✔
411	Scene *evenScene = NULL;	39✔
412	Scene *oddScene = NULL;	39✔
413	bool even = false;	39✔
414	QLCCapability *cap = channel->capabilities().at(cIdx);	39✔
415	uchar value = cap->middle();	39✔
416	QString name = cap->name();	39✔
417
418	// Do not add the same capability twice
419	if (tmpCapList.contains(name))	39✔
420	continue;	6✔
421
422	tmpCapList.append(name);	33✔
423
424	if (subType == OddEven)	33✔
425	{
426	evenScene = new Scene(m_doc);	×
427	oddScene = new Scene(m_doc);	×
428	}
429
430	QHashIterator <quint32, quint32> it(chMap);	33✔
431	while (it.hasNext() == true)	99✔
432	{
433	it.next();	66✔
434	scene->setValue(it.key(), it.value(), value);	66✔
435	if (subType == OddEven)	66✔
436	{
437	if (even)	×
438	evenScene->setValue(it.key(), it.value(), value);	×
439	else
440	oddScene->setValue(it.key(), it.value(), value);	×
441	even = !even;	×
442	}
443	}
444
445	scene->setName(getNamePrefix(channel->name(), name));	33✔
446	m_scenes.append(scene);	33✔
447	if (subType == OddEven)	33✔
448	{
449	evenScene->setName(getNamePrefix(channel->name(), name) + tr(" - Even"));	×
450	oddScene->setName(getNamePrefix(channel->name(), name) + tr(" - Odd"));	×
451	m_scenes.append(evenScene);	×
452	m_scenes.append(oddScene);	×
453	}
454	}	39✔
455	}	3✔
456
457	void PaletteGenerator::createRGBMatrices(QList<SceneValue> rgbMap)	×
458	{
459	m_fixtureGroup = new FixtureGroup(m_doc);	×
460	m_fixtureGroup->setSize(QSize(rgbMap.size(), 1));	×
461
462	foreach (SceneValue scv, rgbMap)	×
463	{
464	m_fixtureGroup->assignFixture(scv.fxi);	×
465	m_fixtureGroup->setName(m_model + tr(" - RGB Group"));	×
466	}	×
467	QStringList algoList = m_doc->rgbScriptsCache()->names();	×
468	foreach (QString algo, algoList)	×
469	{
470	RGBMatrix *matrix = new RGBMatrix(m_doc);	×
471	matrix->setName(tr("Animation %1").arg(algo) + " - " + m_model);	×
472	//matrix->setFixtureGroup();
473	matrix->setAlgorithm(RGBAlgorithm::algorithm(m_doc, algo));	×
474	m_matrices.append(matrix);	×
475	}	×
476	}	×
477
NEW 478	EFX PaletteGenerator::createEfx(QList<Fixture > fixtures, EFXFixture::Mode mode, EFX::PropagationMode propMode)	×
479	{
NEW 480	EFX *efx = new EFX(m_doc);	×
481
NEW 482	efx->setName(tr("EFX %1 %2 %3 - ")	×
NEW 483	.arg(EFXFixture::modeToString(mode))	×
NEW 484	.arg(EFX::algorithmToString(m_efxAlgo))	×
NEW 485	.arg(EFX::propagationModeToString(propMode)) + m_model);	×
486
NEW 487	efx->setAlgorithm(m_efxAlgo);	×
488
NEW 489	efx->setPropagationMode(propMode);	×
490
NEW 491	for (int i = 0; i < fixtures.count(); i++)	×
492	{
NEW 493	Fixture *fixture = fixtures[i];	×
NEW 494	for (int h = 0; h < fixture->heads(); h++)	×
495	{
NEW 496	qDebug() << "fx" << fixture->channelAddress(0) << " " << h;	×
497
NEW 498	EFXFixture *ef = new EFXFixture(efx);	×
NEW 499	ef->setHead(GroupHead(fixture->id(), h));	×
NEW 500	ef->setMode(mode);	×
NEW 501	efx->addFixture(ef);	×
502	}
503	}
504
NEW 505	qDebug() << "efx: " << efx << efx->fixtures().count();	×
506
NEW 507	return efx;	×
508	}
509
NEW 510	void PaletteGenerator::createEfxs(QList<Fixture *> fixtures, EFXFixture::Mode mode,	×
511	PaletteSubType subType)
512	{
NEW 513	qDebug() << "createEfxs";	×
514
NEW 515	if ((subType & PaletteSubType::Parallel) == PaletteSubType::Parallel)	×
NEW 516	m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Parallel));	×
NEW 517	if ((subType & PaletteSubType::Serial) == PaletteSubType::Serial)	×
NEW 518	m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Serial));	×
NEW 519	if ((subType & PaletteSubType::Asymetric) == PaletteSubType::Asymetric)	×
NEW 520	m_efxs.append(createEfx(fixtures, mode, EFX::PropagationMode::Asymmetric));	×
NEW 521	}	×
522
523	void PaletteGenerator::createChaser(QString name)	3✔
524	{
525	if (m_scenes.count() == 0)	3✔
526	return;	×
527
528	Chaser *chaser = new Chaser(m_doc);	3✔
529	chaser->setFadeInMode(Chaser::Common);	3✔
530	chaser->setFadeInSpeed(3000);	3✔
531	chaser->setFadeOutMode(Chaser::Common);	3✔
532	chaser->setFadeOutSpeed(0);	3✔
533	chaser->setDurationMode(Chaser::Common);	3✔
534	chaser->setDuration(10000);	3✔
535	chaser->setName(tr("%1 chaser - %2").arg(name).arg(m_model));	3✔
536
537	// that's all here. I need to add an empty Chaser cause
538	// scene's IDs have not been assigned yet
539	m_chasers.append(chaser);	3✔
540	}
541
542	void PaletteGenerator::createFunctions(PaletteGenerator::PaletteType type,	3✔
543	PaletteGenerator::PaletteSubType subType)
544	{
545	if (m_fixtures.count() == 0)	3✔
546	return;	×
547
548	// the following QHash will hold the fixture/channel map of each fixture
549	// in m_fixtures depending on type and subtype
550	QHash<quint32, quint32> m_panList;	3✔
551	QHash<quint32, quint32> m_tiltList;	3✔
552	QList<SceneValue> m_redList;	3✔
553	QList<SceneValue> m_greenList;	3✔
554	QList<SceneValue> m_blueList;	3✔
555	QList<SceneValue> m_cyanList;	3✔
556	QList<SceneValue> m_magentaList;	3✔
557	QList<SceneValue> m_yellowList;	3✔
558	QList<SceneValue> m_whiteList;	3✔
559	QHash<quint32, quint32> m_goboList;	3✔
560	QHash<quint32, quint32> m_shutterList;	3✔
561	QHash<quint32, quint32> m_colorMacroList;	3✔
562
563	for (int i = 0; i < m_fixtures.count(); i++)	9✔
564	{
565	Fixture *fixture = m_fixtures.at(i);	6✔
566	Q_ASSERT(fixture != NULL);	6✔
567	quint32 fxID = fixture->id();	6✔
568
569	for (quint32 ch = 0; ch < fixture->channels(); ch++)	48✔
570	{
571	const QLCChannel* channel(fixture->channel(ch));	42✔
572	Q_ASSERT(channel != NULL);	42✔
573
574	switch (channel->group())	42✔
575	{
576	case QLCChannel::Pan: m_panList[fxID] = ch; break;	6✔
577	case QLCChannel::Tilt: m_tiltList[fxID] = ch; break;	6✔
578	case QLCChannel::Gobo: m_goboList[fxID] = ch; break;	4✔
579	case QLCChannel::Shutter: m_shutterList[fxID] = ch; break;	2✔
580	case QLCChannel::Colour: m_colorMacroList[fxID] = ch; break;	6✔
581	case QLCChannel::Intensity:	12✔
582	{
583	QLCChannel::PrimaryColour col = channel->colour();	12✔
584	switch (col)	12✔
585	{
586	case QLCChannel::Red: m_redList.append(SceneValue(fxID, ch)); break;	×
587	case QLCChannel::Green: m_greenList.append(SceneValue(fxID, ch)); break;	×
588	case QLCChannel::Blue: m_blueList.append(SceneValue(fxID, ch)); break;	×
589	case QLCChannel::Cyan: m_cyanList.append(SceneValue(fxID, ch)); break;	2✔
590	case QLCChannel::Magenta: m_magentaList.append(SceneValue(fxID, ch)); break;	2✔
591	case QLCChannel::Yellow: m_yellowList.append(SceneValue(fxID, ch)); break;	2✔
592	case QLCChannel::White: m_whiteList.append(SceneValue(fxID, ch)); break;	×
593	default: break;	6✔
594	}
595	}
596	break;	12✔
597	default:	6✔
598	break;	6✔
599	}
600	}
601	}
602
603	switch (type)	3✔
604	{
605	case PrimaryColors:	×
606	{
607	createColorScene(m_redList, tr("Red scene"), subType);	×
608	createColorScene(m_greenList, tr("Green scene"), subType);	×
609	createColorScene(m_blueList, tr("Blue scene"), subType);	×
610	createColorScene(m_cyanList, tr("Cyan scene"), subType);	×
611	createColorScene(m_magentaList, tr("Magenta scene"), subType);	×
612	createColorScene(m_yellowList, tr("Yellow scene"), subType);	×
613	createColorScene(m_whiteList, tr("White scene"), subType);	×
614	createChaser(typetoString(type));	×
615	}
616	break;	×
617	case SixteenColors:	×
618	{
619	if (m_redList.size() > 0 && m_greenList.size() == m_redList.size() && m_blueList.size() == m_redList.size())	×
620	createRGBCMYScene(m_redList, m_greenList, m_blueList, tr("Scene"), true, subType);	×
621	else if (m_cyanList.size() > 0 && m_magentaList.size() == m_cyanList.size() && m_yellowList.size() == m_cyanList.size())	×
622	createRGBCMYScene(m_cyanList, m_magentaList, m_yellowList, tr("Scene"), false, subType);	×
623	createChaser(typetoString(type));	×
624	}
625	break;	×
626	case Animation:	×
627	{
628	if (m_redList.size() > 1 && m_greenList.size() == m_redList.size() && m_blueList.size() == m_redList.size())	×
629	createRGBMatrices(m_redList);	×
630	}
631	break;	×
NEW 632	case EfxDimmer:	×
NEW 633	createEfxs(m_fixtures, EFXFixture::Mode::Dimmer, subType);	×
NEW 634	break;	×
NEW 635	case EfxRGB:	×
NEW 636	createEfxs(m_fixtures, EFXFixture::Mode::RGB, subType);	×
NEW 637	break;	×
NEW 638	case EfxPosition:	×
NEW 639	createEfxs(m_fixtures, EFXFixture::Mode::PanTilt, subType);	×
NEW 640	break;	×
641	case Gobos:	1✔
642	{
643	createCapabilityScene(m_goboList, subType);	1✔
644	createChaser(typetoString(type));	1✔
645	}
646	break;	1✔
647	case Shutter:	1✔
648	{
649	createCapabilityScene(m_shutterList, subType);	1✔
650	createChaser(typetoString(type));	1✔
651	}
652	break;	1✔
653	case ColourMacro:	1✔
654	{
655	createCapabilityScene(m_colorMacroList, subType);	1✔
656	createChaser(typetoString(type));	1✔
657	}
658	break;	1✔
659	case Undefined:	×
660	default:
661	break;	×
662
663	}
664	}	3✔
665
666	QString PaletteGenerator::getNamePrefix(QString name)	×
667	{
668	// return name + " - " + m_model; // old naming
669	return m_model + " - " + name;	×
670	}
671
672	QString PaletteGenerator::getNamePrefix(QString type, QString name)	33✔
673	{
674	// return name + " - " + type + " - " + m_model; // old naming
675	return m_model + " - " + type + " - " + name;	66✔
676	}

mcallegari / qlcplus / 15615545913

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