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

49.86

/engine/src/qlcpalette.cpp

/*
  Q Light Controller Plus
  qlcpalette.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 <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QtMath>
#include <QDebug>

#include "monitorproperties.h"
#include "qlcpalette.h"
#include "qlcchannel.h"
#include "scenevalue.h"
#include "doc.h"

#define KXMLQLCPaletteType      "Type"
#define KXMLQLCPaletteName      "Name"
#define KXMLQLCPaletteValue     "Value"
#define KXMLQLCPaletteFanning   "Fan"
#define KXMLQLCPaletteFanLayout "Layout"
#define KXMLQLCPaletteFanAmount "Amount"
#define KXMLQLCPaletteFanValue  "FanValue"

QLCPalette::QLCPalette(QLCPalette::PaletteType type, QObject *parent)
    : QObject(parent)
    , m_id(QLCPalette::invalidId())
    , m_type(type)
    , m_fanningType(Flat)
    , m_fanningLayout(XAscending)
    , m_fanningAmount(100)
{
}

QLCPalette *QLCPalette::createCopy()
{
    QLCPalette *copy = new QLCPalette(type());
    copy->setValues(this->values());
    copy->setName(this->name());
    copy->setFanningType(this->fanningType());
    copy->setFanningLayout(this->fanningLayout());
    copy->setFanningAmount(this->fanningAmount());
    copy->setFanningValue(this->fanningValue());

    return copy;
}

QLCPalette::~QLCPalette()
{

}

/************************************************************************
 * Properties
 ************************************************************************/

quint32 QLCPalette::id() const
{
    return m_id;
}

void QLCPalette::setID(quint32 id)
{
    m_id = id;
}

quint32 QLCPalette::invalidId()
{
    return UINT_MAX;
}

QLCPalette::PaletteType QLCPalette::type() const
{
    return m_type;
}

QString QLCPalette::typeToString(QLCPalette::PaletteType type)
{
    switch (type)
    {
        case Dimmer:    return "Dimmer";
        case Color:     return "Color";
        case Pan:       return "Pan";
        case Tilt:      return "Tilt";
        case PanTilt:   return "PanTilt";
        case Shutter:   return "Shutter";
        case Gobo:      return "Gobo";
        case Undefined: return "";
    }

    return "";
}

QLCPalette::PaletteType QLCPalette::stringToType(const QString &str)
{
    if (str == "Dimmer")
        return Dimmer;
    else if (str == "Color")
        return Color;
    else if (str == "Pan")
        return Pan;
    else if (str == "Tilt")
        return Tilt;
    else if (str == "PanTilt")
        return PanTilt;
    else if (str == "Shutter")
        return Shutter;
    else if (str == "Gobo")
        return Gobo;

    return Undefined;
}

QString QLCPalette::iconResource(bool svg) const
{
    QString prefix = svg ? "qrc" : "";
    QString ext = svg ? "svg" : "png";

    switch(type())
    {
        case Dimmer: return QString("%1:/intensity.%2").arg(prefix).arg(ext);
        case Color: return QString("%1:/color.%2").arg(prefix).arg(ext);
        case Pan: return QString("%1:/pan.%2").arg(prefix).arg(ext);
        case Tilt: return QString("%1:/tilt.%2").arg(prefix).arg(ext);
        case PanTilt: return QString("%1:/position.%2").arg(prefix).arg(ext);
        case Shutter: return QString("%1:/shutter.%2").arg(prefix).arg(ext);
        case Gobo: return QString("%1:/gobo.%2").arg(prefix).arg(ext);
        default: return "";
    }
}

QString QLCPalette::name() const
{
    return m_name;
}

void QLCPalette::setName(const QString &name)
{
    if (name == m_name)
        return;

    m_name = QString(name);
    emit nameChanged();
}

QVariant QLCPalette::value() const
{
    if (m_values.isEmpty())
        return QVariant();

    return m_values.first();
}

int QLCPalette::intValue1() const
{
    if (m_values.isEmpty())
        return -1;

    return m_values.at(0).toInt();
}

int QLCPalette::intValue2() const
{
    if (m_values.count() < 2)
        return -1;

    return m_values.at(1).toInt();
}

QString QLCPalette::strValue1() const
{
    if (m_values.isEmpty())
        return QString();

    return m_values.at(0).toString();
}

QColor QLCPalette::rgbValue() const
{
    if (m_values.isEmpty())
        return QColor();

    QColor rgb, wauv;
    stringToColor(m_values.at(0).toString(), rgb, wauv);

    return rgb;
}

QColor QLCPalette::wauvValue() const
{
    if (m_values.isEmpty())
        return QColor();

    QColor rgb, wauv;
    stringToColor(m_values.at(0).toString(), rgb, wauv);

    return wauv;
}

void QLCPalette::setValue(QVariant val)
{
    m_values.clear();
    m_values.append(val);
}

void QLCPalette::setValue(QVariant val1, QVariant val2)
{
    m_values.clear();
    m_values.append(val1);
    m_values.append(val2);
}

QVariantList QLCPalette::values() const
{
    return m_values;
}

void QLCPalette::setValues(QVariantList values)
{
    m_values = values;
}

void QLCPalette::resetValues()
{
    m_values.clear();
}

QList<SceneValue> QLCPalette::valuesFromFixtures(Doc *doc, QList<quint32> fixtures)
{
    QList<SceneValue> list;

    int fxCount = fixtures.count();
    // normalized progress in [ 0.0, 1.0 ] range
    qreal progress = 0.0;
    int intFanValue = fanningValue().toInt();
    FanningType fType = fanningType();
    FanningLayout fLayout = fanningLayout();
    MonitorProperties *mProps = doc->monitorProperties();

    // sort the fixtures list based on selected layout
    std::sort(fixtures.begin(), fixtures.end(),
        [fLayout, mProps](quint32 a, quint32 b) {
            QVector3D posA = mProps->fixturePosition(a, 0, 0);
            QVector3D posB = mProps->fixturePosition(b, 0, 0);

            switch(fLayout)
            {
                case XAscending: return posA.x() < posB.x();
                case XDescending: return posB.x() < posA.x();
                case YAscending: return posA.y() < posB.y();
                case YDescending: return posB.y() < posA.y();
                case ZAscending: return posA.z() < posB.z();
                case ZDescending: return posB.z() < posA.z();
                default: return false;
            }
        });

    foreach (quint32 id, fixtures)
    {
        Fixture *fixture = doc->fixture(id);
        if (fixture == NULL)
            continue;

        qreal factor = valueFactor(progress);

        switch(type())
        {
            case Dimmer:
            {
                int dValue = value().toInt();
                quint32 masterIntensityChannel = fixture->type() == QLCFixtureDef::Dimmer ?
                            0 : fixture->masterIntensityChannel();

                if (fType != Flat)
                    dValue = int((qreal(intFanValue - dValue) * factor) + dValue);

                if (masterIntensityChannel != QLCChannel::invalid())
                    list << SceneValue(id, masterIntensityChannel, uchar(dValue));

                for (int i = 0; i < fixture->heads(); i++)
                {
                    quint32 headDimmerChannel = fixture->channelNumber(QLCChannel::Intensity, QLCChannel::MSB, i);
                    if (headDimmerChannel != QLCChannel::invalid())
                        list << SceneValue(id, headDimmerChannel, uchar(dValue));
                }
            }
            break;
            case Color:
            {
                QColor startColor = value().value<QColor>();
                QColor col = startColor;

                if (fType != Flat)
                {
                    QColor endColor = fanningValue().value<QColor>();
                    qreal rDelta = endColor.red() - startColor.red();
                    qreal gDelta = endColor.green() - startColor.green();
                    qreal bDelta = endColor.blue() - startColor.blue();
                    col.setRed(startColor.red() + qRound(rDelta * factor));
                    col.setGreen(startColor.green() + qRound(gDelta * factor));
                    col.setBlue(startColor.blue() + qRound(bDelta * factor));
                }

                for (int i = 0; i < fixture->heads(); i++)
                {
                    QVector<quint32> rgbCh = fixture->rgbChannels(i);
                    if (rgbCh.size() == 3)
                    {
                        list << SceneValue(id, rgbCh.at(0), uchar(col.red()));
                        list << SceneValue(id, rgbCh.at(1), uchar(col.green()));
                        list << SceneValue(id, rgbCh.at(2), uchar(col.blue()));
                    }
                    QVector<quint32> cmyCh = fixture->cmyChannels(i);
                    if (cmyCh.size() == 3)
                    {
                        list << SceneValue(id, cmyCh.at(0), uchar(col.cyan()));
                        list << SceneValue(id, cmyCh.at(1), uchar(col.magenta()));
                        list << SceneValue(id, cmyCh.at(2), uchar(col.yellow()));
                    }
                }
            }
            break;
            case Pan:
            {
                int degrees = value().toInt();

                if (fType != Flat)
                    degrees = int((qreal(degrees) + qreal(intFanValue) * factor));

                list << fixture->positionToValues(QLCChannel::Pan, degrees);
            }
            break;
            case Tilt:
            {
                int degrees = m_values.count() == 2 ? m_values.at(1).toInt() : value().toInt();

                if (fType != Flat)
                    degrees = int((qreal(degrees) + qreal(intFanValue) * factor));

                list << fixture->positionToValues(QLCChannel::Tilt, degrees);
            }
            break;
            case PanTilt:
            {
                if (m_values.count() == 2)
                {
                    int panDegrees = m_values.at(0).toInt();
                    int tiltDegrees = m_values.at(1).toInt();

                    if (fType != Flat)
                    {
                        panDegrees = int((qreal(panDegrees) + qreal(intFanValue) * factor));
                        tiltDegrees = int((qreal(tiltDegrees) + qreal(intFanValue) * factor));
                    }

                    list << fixture->positionToValues(QLCChannel::Pan, panDegrees);
                    list << fixture->positionToValues(QLCChannel::Tilt, tiltDegrees);
                }
            }
            break;
            case Shutter:
            {
                quint32 shCh = fixture->channelNumber(QLCChannel::Shutter, QLCChannel::MSB);
                if (shCh != QLCChannel::invalid())
                    list << SceneValue(id, shCh, uchar(value().toUInt()));
            }
            break;
            case Gobo:
            {
                quint32 goboCh = fixture->channelNumber(QLCChannel::Gobo, QLCChannel::MSB);
                if (goboCh != QLCChannel::invalid())
                    list << SceneValue(id, goboCh, uchar(value().toUInt()));
            }
            break;
            case Undefined:
            break;
        }

        progress += (1.0 / qreal(fxCount - 1));
    }

    return list;
}

QList<SceneValue> QLCPalette::valuesFromFixtureGroups(Doc *doc, QList<quint32> groups)
{
    QList<quint32> fixturesList;

    foreach (quint32 id, groups)
    {
        FixtureGroup *group = doc->fixtureGroup(id);
        if (group == NULL)
            continue;

        fixturesList.append(group->fixtureList());
    }

    return valuesFromFixtures(doc, fixturesList);
}

qreal QLCPalette::valueFactor(qreal progress)
{
    qreal factor = 1.0;
    qreal normalizedAmount = qreal(m_fanningAmount) / 100.0;

    switch (m_fanningType)
    {
        case Flat:
            // nothing to do. Factor is always 1.0
        break;
        case Linear:
        {
            if (normalizedAmount < 1.0)
            {
                if (progress > normalizedAmount)
                    factor = 1.0;
                else
                    factor = progress * normalizedAmount;
            }
            else if (normalizedAmount > 1.0)
            {
                factor = progress / normalizedAmount;
            }
            else
            {
                factor = progress;
            }
        }
        break;
        case Sine:
        {
            qreal degrees = (progress * 360.0) + 270.0;
            factor = (qSin(normalizedAmount * qDegreesToRadians(degrees)) + 1.0) / 2.0;
        }
        break;
        case Square:
        {
            factor = qSin(normalizedAmount * qDegreesToRadians(progress * 360.0)) < 0 ? 1 : 0;
        }
        break;
        case Saw:
        break;
    }

    return factor;
}

/************************************************************************
 * Fanning
 ************************************************************************/

QLCPalette::FanningType QLCPalette::fanningType() const
{
    return m_fanningType;
}

void QLCPalette::setFanningType(QLCPalette::FanningType type)
{
    if (type == m_fanningType)
        return;

    m_fanningType = type;

    emit fanningTypeChanged();
}

QString QLCPalette::fanningTypeToString(QLCPalette::FanningType type)
{
    switch (type)
    {
        case Flat:      return "Flat";
        case Linear:    return "Linear";
        case Sine:      return "Sine";
        case Square:    return "Square";
        case Saw:       return "Saw";
    }

    return "";
}

QLCPalette::FanningType QLCPalette::stringToFanningType(const QString &str)
{
    if (str == "Flat")
        return Flat;
    else if (str == "Linear")
        return Linear;
    else if (str == "Sine")
        return Sine;
    else if (str == "Square")
        return Square;
    else if (str == "Saw")
        return Saw;

    return Flat;
}

QLCPalette::FanningLayout QLCPalette::fanningLayout() const
{
    return m_fanningLayout;
}

void QLCPalette::setFanningLayout(QLCPalette::FanningLayout layout)
{
    if (layout == m_fanningLayout)
        return;

    m_fanningLayout = layout;

    emit fanningLayoutChanged();
}

QString QLCPalette::fanningLayoutToString(QLCPalette::FanningLayout layout)
{
    switch (layout)
    {
        case XAscending:    return "XAscending";
        case XDescending:   return "XDescending";
        case XCentered:     return "XCentered";
        case YAscending:    return "YAscending";
        case YDescending:   return "YDescending";
        case YCentered:     return "YCentered";
        case ZAscending:    return "ZAscending";
        case ZDescending:   return "ZDescending";
        case ZCentered:     return "ZCentered";
    }

    return "";
}

QLCPalette::FanningLayout QLCPalette::stringToFanningLayout(const QString &str)
{
    if (str == "XAscending")
        return XAscending;
    else if (str == "XDescending")
        return XDescending;
    else if (str == "XCentered")
        return XCentered;
    else     if (str == "YAscending")
        return YAscending;
    else if (str == "YDescending")
        return YDescending;
    else if (str == "YCentered")
        return YCentered;
    else if (str == "ZAscending")
        return ZAscending;
    else if (str == "ZDescending")
        return ZDescending;
    else if (str == "ZCentered")
        return ZCentered;

    return XAscending;
}

int QLCPalette::fanningAmount() const
{
    return m_fanningAmount;
}

void QLCPalette::setFanningAmount(int amount)
{
    if (amount == m_fanningAmount)
        return;

    m_fanningAmount = amount;

    emit fanningAmountChanged();
}

QVariant QLCPalette::fanningValue() const
{
    return m_fanningValue;
}

void QLCPalette::setFanningValue(QVariant value)
{
    if (value == m_fanningValue)
        return;

    m_fanningValue = value;

    emit fanningValueChanged();
}

/************************************************************************
 * Color helpers
 ************************************************************************/

QString QLCPalette::colorToString(QColor rgb, QColor wauv)
{
    QString final = rgb.name();
    final.append(wauv.name().right(6));
    return final;
}

bool QLCPalette::stringToColor(QString str, QColor &rgb, QColor &wauv)
{
    // string must be like #rrggbb or #rrggbbwwaauv
    if (str.length() != 7 && str.length() != 13)
        return false;

    rgb = QColor(str.left(7));

    if (str.length() == 13)
        wauv = QColor("#" + str.right(6));
    else
        wauv = QColor();

    return true;
}

/************************************************************************
 * Load & Save
 ************************************************************************/

bool QLCPalette::loader(QXmlStreamReader &xmlDoc, Doc *doc)
{
    QLCPalette *palette = new QLCPalette(Dimmer, doc);
    Q_ASSERT(palette != NULL);

    if (palette->loadXML(xmlDoc) == true)
    {
        doc->addPalette(palette, palette->id());
    }
    else
    {
        qWarning() << Q_FUNC_INFO << "QLCPalette" << palette->name() << "cannot be loaded.";
        delete palette;
        return false;
    }

    return true;
}

bool QLCPalette::loadXML(QXmlStreamReader &doc)
{
    if (doc.name() != KXMLQLCPalette)
    {
        qWarning() << Q_FUNC_INFO << "Palette node not found";
        return false;
    }

    QXmlStreamAttributes attrs = doc.attributes();

    bool ok = false;
    quint32 id = attrs.value(KXMLQLCPaletteID).toString().toUInt(&ok);
    if (ok == false)
    {
        qWarning() << "Invalid Palette ID:" << attrs.value(KXMLQLCPaletteID).toString();
        return false;
    }

    setID(id);

    if (attrs.hasAttribute(KXMLQLCPaletteType) == false)
    {
        qWarning() << "Palette type not found!";
        return false;
    }

    m_type = stringToType(attrs.value(KXMLQLCPaletteType).toString());

    if (attrs.hasAttribute(KXMLQLCPaletteName))
        setName(attrs.value(KXMLQLCPaletteName).toString());

    if (attrs.hasAttribute(KXMLQLCPaletteValue))
    {
        QString strVal = attrs.value(KXMLQLCPaletteValue).toString();
        switch (m_type)
        {
            case Dimmer:
            case Pan:
            case Tilt:
                setValue(strVal.toInt());
            break;
            case Color:
                setValue(strVal);
            break;
            case PanTilt:
            {
                QStringList posList = strVal.split(",");
                if (posList.count() == 2)
                    setValue(posList.at(0).toInt(), posList.at(1).toInt());
            }
            break;
            case Shutter:   break;
            case Gobo:      break;
            case Undefined: break;
        }
    }

    if (attrs.hasAttribute(KXMLQLCPaletteFanning))
    {
        setFanningType(stringToFanningType(attrs.value(KXMLQLCPaletteFanning).toString()));

        if (attrs.hasAttribute(KXMLQLCPaletteFanLayout))
            setFanningLayout(stringToFanningLayout(attrs.value(KXMLQLCPaletteFanLayout).toString()));

        if (attrs.hasAttribute(KXMLQLCPaletteFanAmount))
            setFanningAmount(attrs.value(KXMLQLCPaletteFanAmount).toInt());

        if (attrs.hasAttribute(KXMLQLCPaletteFanValue))
        {
            QString strVal = attrs.value(KXMLQLCPaletteFanValue).toString();
            switch (m_type)
            {
                case Dimmer:
                case Pan:
                case Tilt:
                case PanTilt:
                    setFanningValue(strVal.toInt());
                break;
                case Color:
                    setFanningValue(strVal);
                break;
                case Shutter:   break;
                case Gobo:      break;
                case Undefined: break;
            }
        }
    }

    return true;
}

bool QLCPalette::saveXML(QXmlStreamWriter *doc)
{
    Q_ASSERT(doc != NULL);

    if (m_values.isEmpty())
    {
        qWarning() << "Unable to save a Palette without value!";
        return false;
    }

    /* write a Palette entry */
    doc->writeStartElement(KXMLQLCPalette);
    doc->writeAttribute(KXMLQLCPaletteID, QString::number(this->id()));
    doc->writeAttribute(KXMLQLCPaletteType, typeToString(m_type));
    doc->writeAttribute(KXMLQLCPaletteName, this->name());

    /* write value */
    switch (m_type)
    {
        case Dimmer:
        case Pan:
        case Tilt:
        case Color:
            doc->writeAttribute(KXMLQLCPaletteValue, value().toString());
        break;
        case PanTilt:
            doc->writeAttribute(KXMLQLCPaletteValue,
                                QString("%1,%2").arg(m_values.at(0).toInt()).arg(m_values.at(1).toInt()));
        break;
        case Shutter:   break;
        case Gobo:      break;
        case Undefined: break;
    }

    /* write fanning */
    if (m_fanningType != Flat)
    {
        doc->writeAttribute(KXMLQLCPaletteFanning, fanningTypeToString(m_fanningType));
        doc->writeAttribute(KXMLQLCPaletteFanLayout, fanningLayoutToString(m_fanningLayout));
        doc->writeAttribute(KXMLQLCPaletteFanAmount, QString::number(m_fanningAmount));
        doc->writeAttribute(KXMLQLCPaletteFanValue, fanningValue().toString());
    }

    doc->writeEndElement();

    return true;
}


1	/*
2	Q Light Controller Plus
3	qlcpalette.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 <QXmlStreamReader>
21	#include <QXmlStreamWriter>
22	#include <QtMath>
23	#include <QDebug>
24
25	#include "monitorproperties.h"
26	#include "qlcpalette.h"
27	#include "qlcchannel.h"
28	#include "scenevalue.h"
29	#include "doc.h"
30
31	#define KXMLQLCPaletteType "Type"
32	#define KXMLQLCPaletteName "Name"
33	#define KXMLQLCPaletteValue "Value"
34	#define KXMLQLCPaletteFanning "Fan"
35	#define KXMLQLCPaletteFanLayout "Layout"
36	#define KXMLQLCPaletteFanAmount "Amount"
37	#define KXMLQLCPaletteFanValue "FanValue"
38
39	QLCPalette::QLCPalette(QLCPalette::PaletteType type, QObject *parent)	17✔
40	: QObject(parent)
41	, m_id(QLCPalette::invalidId())	34✔
42	, m_type(type)	17✔
43	, m_fanningType(Flat)	17✔
44	, m_fanningLayout(XAscending)	17✔
45	, m_fanningAmount(100)	17✔
46	{
47	}	17✔
48
49	QLCPalette *QLCPalette::createCopy()	×
50	{
51	QLCPalette *copy = new QLCPalette(type());	×
52	copy->setValues(this->values());	×
53	copy->setName(this->name());	×
54	copy->setFanningType(this->fanningType());	×
55	copy->setFanningLayout(this->fanningLayout());	×
56	copy->setFanningAmount(this->fanningAmount());	×
57	copy->setFanningValue(this->fanningValue());	×
58
59	return copy;	×
60	}
61
62	QLCPalette::~QLCPalette()	19✔
63	{
64
65	}	19✔
66
67	/************************************************************************
68	* Properties
69	************************************************************************/
70
71	quint32 QLCPalette::id() const	5✔
72	{
73	return m_id;	5✔
74	}
75
76	void QLCPalette::setID(quint32 id)	5✔
77	{
78	m_id = id;	5✔
79	}	5✔
80
81	quint32 QLCPalette::invalidId()	24✔
82	{
83	return UINT_MAX;	24✔
84	}
85
86	QLCPalette::PaletteType QLCPalette::type() const	9✔
87	{
88	return m_type;	9✔
89	}
90
91	QString QLCPalette::typeToString(QLCPalette::PaletteType type)	9✔
92	{
93	switch (type)	9✔
94	{
95	case Dimmer: return "Dimmer";	1✔
96	case Color: return "Color";	1✔
97	case Pan: return "Pan";	1✔
98	case Tilt: return "Tilt";	1✔
99	case PanTilt: return "PanTilt";	2✔
100	case Shutter: return "Shutter";	1✔
101	case Gobo: return "Gobo";	1✔
102	case Undefined: return "";	1✔
103	}
104
105	return "";	×
106	}
107
108	QLCPalette::PaletteType QLCPalette::stringToType(const QString &str)	9✔
109	{
110	if (str == "Dimmer")	9✔
111	return Dimmer;
112	else if (str == "Color")	8✔
113	return Color;
114	else if (str == "Pan")	6✔
115	return Pan;
116	else if (str == "Tilt")	5✔
117	return Tilt;
118	else if (str == "PanTilt")	4✔
119	return PanTilt;
120	else if (str == "Shutter")	3✔
121	return Shutter;
122	else if (str == "Gobo")	2✔
123	return Gobo;	1✔
124
125	return Undefined;
126	}
127
128	QString QLCPalette::iconResource(bool svg) const	7✔
129	{
130	QString prefix = svg ? "qrc" : "";	13✔
131	QString ext = svg ? "svg" : "png";	13✔
132
133	switch(type())	7✔
134	{
135	case Dimmer: return QString("%1:/intensity.%2").arg(prefix).arg(ext);	1✔
136	case Color: return QString("%1:/color.%2").arg(prefix).arg(ext);	1✔
137	case Pan: return QString("%1:/pan.%2").arg(prefix).arg(ext);	1✔
138	case Tilt: return QString("%1:/tilt.%2").arg(prefix).arg(ext);	1✔
139	case PanTilt: return QString("%1:/position.%2").arg(prefix).arg(ext);	1✔
140	case Shutter: return QString("%1:/shutter.%2").arg(prefix).arg(ext);	1✔
141	case Gobo: return QString("%1:/gobo.%2").arg(prefix).arg(ext);	1✔
142	default: return "";	×
143	}
144	}	7✔
145
146	QString QLCPalette::name() const	4✔
147	{
148	return m_name;	4✔
149	}
150
151	void QLCPalette::setName(const QString &name)	3✔
152	{
153	if (name == m_name)	3✔
154	return;
155
156	m_name = QString(name);	3✔
157	emit nameChanged();	3✔
158	}
159
160	QVariant QLCPalette::value() const	4✔
161	{
162	if (m_values.isEmpty())	4✔
163	return QVariant();
164
165	return m_values.first();	4✔
166	}
167
168	int QLCPalette::intValue1() const	×
169	{
170	if (m_values.isEmpty())	×
171	return -1;
172
173	return m_values.at(0).toInt();	×
174	}
175
176	int QLCPalette::intValue2() const	×
177	{
178	if (m_values.count() < 2)	×
179	return -1;
180
181	return m_values.at(1).toInt();	×
182	}
183
184	QString QLCPalette::strValue1() const	×
185	{
186	if (m_values.isEmpty())	×
187	return QString();
188
189	return m_values.at(0).toString();	×
190	}
191
192	QColor QLCPalette::rgbValue() const	×
193	{
194	if (m_values.isEmpty())	×
195	return QColor();
196
197	QColor rgb, wauv;	×
198	stringToColor(m_values.at(0).toString(), rgb, wauv);	×
199
200	return rgb;
201	}
202
203	QColor QLCPalette::wauvValue() const	×
204	{
205	if (m_values.isEmpty())	×
206	return QColor();
207
208	QColor rgb, wauv;	×
209	stringToColor(m_values.at(0).toString(), rgb, wauv);	×
210
211	return wauv;
212	}
213
214	void QLCPalette::setValue(QVariant val)	3✔
215	{
216	m_values.clear();	3✔
217	m_values.append(val);	3✔
218	}	3✔
219
220	void QLCPalette::setValue(QVariant val1, QVariant val2)	2✔
221	{
222	m_values.clear();	2✔
223	m_values.append(val1);	2✔
224	m_values.append(val2);	2✔
225	}	2✔
226
227	QVariantList QLCPalette::values() const	6✔
228	{
229	return m_values;	6✔
230	}
231
232	void QLCPalette::setValues(QVariantList values)	×
233	{
234	m_values = values;	×
235	}	×
236
237	void QLCPalette::resetValues()	×
238	{
239	m_values.clear();	×
240	}	×
241
242	QList<SceneValue> QLCPalette::valuesFromFixtures(Doc *doc, QList<quint32> fixtures)	×
243	{
244	QList<SceneValue> list;
245
246	int fxCount = fixtures.count();
247	// normalized progress in [ 0.0, 1.0 ] range
248	qreal progress = 0.0;
249	int intFanValue = fanningValue().toInt();	×
250	FanningType fType = fanningType();	×
251	FanningLayout fLayout = fanningLayout();	×
252	MonitorProperties *mProps = doc->monitorProperties();	×
253
254	// sort the fixtures list based on selected layout
255	std::sort(fixtures.begin(), fixtures.end(),	×
256	[fLayout, mProps](quint32 a, quint32 b) {	×
257	QVector3D posA = mProps->fixturePosition(a, 0, 0);	×
258	QVector3D posB = mProps->fixturePosition(b, 0, 0);	×
259
260	switch(fLayout)	×
261	{
262	case XAscending: return posA.x() < posB.x();	×
263	case XDescending: return posB.x() < posA.x();	×
264	case YAscending: return posA.y() < posB.y();	×
265	case YDescending: return posB.y() < posA.y();	×
266	case ZAscending: return posA.z() < posB.z();	×
267	case ZDescending: return posB.z() < posA.z();	×
268	default: return false;
269	}
270	});
271
272	foreach (quint32 id, fixtures)	×
273	{
274	Fixture *fixture = doc->fixture(id);	×
275	if (fixture == NULL)	×
276	continue;	×
277
278	qreal factor = valueFactor(progress);	×
279
280	switch(type())	×
281	{
282	case Dimmer:	×
283	{
284	int dValue = value().toInt();	×
285	quint32 masterIntensityChannel = fixture->type() == QLCFixtureDef::Dimmer ?	×
286	0 : fixture->masterIntensityChannel();	×
287
288	if (fType != Flat)	×
289	dValue = int((qreal(intFanValue - dValue) * factor) + dValue);	×
290
291	if (masterIntensityChannel != QLCChannel::invalid())	×
292	list << SceneValue(id, masterIntensityChannel, uchar(dValue));	×
293
294	for (int i = 0; i < fixture->heads(); i++)	×
295	{
296	quint32 headDimmerChannel = fixture->channelNumber(QLCChannel::Intensity, QLCChannel::MSB, i);	×
297	if (headDimmerChannel != QLCChannel::invalid())	×
298	list << SceneValue(id, headDimmerChannel, uchar(dValue));	×
299	}
300	}
301	break;
302	case Color:	×
303	{
304	QColor startColor = value().value<QColor>();	×
305	QColor col = startColor;
306
307	if (fType != Flat)	×
308	{
309	QColor endColor = fanningValue().value<QColor>();	×
310	qreal rDelta = endColor.red() - startColor.red();	×
311	qreal gDelta = endColor.green() - startColor.green();	×
312	qreal bDelta = endColor.blue() - startColor.blue();	×
313	col.setRed(startColor.red() + qRound(rDelta * factor));	×
314	col.setGreen(startColor.green() + qRound(gDelta * factor));	×
315	col.setBlue(startColor.blue() + qRound(bDelta * factor));	×
316	}
317
318	for (int i = 0; i < fixture->heads(); i++)	×
319	{
320	QVector<quint32> rgbCh = fixture->rgbChannels(i);	×
321	if (rgbCh.size() == 3)	×
322	{
323	list << SceneValue(id, rgbCh.at(0), uchar(col.red()));	×
324	list << SceneValue(id, rgbCh.at(1), uchar(col.green()));	×
325	list << SceneValue(id, rgbCh.at(2), uchar(col.blue()));	×
326	}
327	QVector<quint32> cmyCh = fixture->cmyChannels(i);	×
328	if (cmyCh.size() == 3)	×
329	{
330	list << SceneValue(id, cmyCh.at(0), uchar(col.cyan()));	×
331	list << SceneValue(id, cmyCh.at(1), uchar(col.magenta()));	×
332	list << SceneValue(id, cmyCh.at(2), uchar(col.yellow()));	×
333	}
334	}	×
335	}
336	break;	×
337	case Pan:	×
338	{
339	int degrees = value().toInt();	×
340
341	if (fType != Flat)	×
342	degrees = int((qreal(degrees) + qreal(intFanValue) * factor));	×
343
344	list << fixture->positionToValues(QLCChannel::Pan, degrees);	×
345	}
346	break;	×
347	case Tilt:	×
348	{
349	int degrees = m_values.count() == 2 ? m_values.at(1).toInt() : value().toInt();	×
350
351	if (fType != Flat)	×
352	degrees = int((qreal(degrees) + qreal(intFanValue) * factor));	×
353
354	list << fixture->positionToValues(QLCChannel::Tilt, degrees);	×
355	}
356	break;	×
357	case PanTilt:	×
358	{
359	if (m_values.count() == 2)	×
360	{
361	int panDegrees = m_values.at(0).toInt();	×
362	int tiltDegrees = m_values.at(1).toInt();	×
363
364	if (fType != Flat)	×
365	{
366	panDegrees = int((qreal(panDegrees) + qreal(intFanValue) * factor));	×
367	tiltDegrees = int((qreal(tiltDegrees) + qreal(intFanValue) * factor));	×
368	}
369
370	list << fixture->positionToValues(QLCChannel::Pan, panDegrees);	×
371	list << fixture->positionToValues(QLCChannel::Tilt, tiltDegrees);	×
372	}
373	}
374	break;
375	case Shutter:	×
376	{
377	quint32 shCh = fixture->channelNumber(QLCChannel::Shutter, QLCChannel::MSB);	×
378	if (shCh != QLCChannel::invalid())	×
379	list << SceneValue(id, shCh, uchar(value().toUInt()));	×
380	}
381	break;
382	case Gobo:	×
383	{
384	quint32 goboCh = fixture->channelNumber(QLCChannel::Gobo, QLCChannel::MSB);	×
385	if (goboCh != QLCChannel::invalid())	×
386	list << SceneValue(id, goboCh, uchar(value().toUInt()));	×
387	}
388	break;
389	case Undefined:
390	break;
391	}
392
393	progress += (1.0 / qreal(fxCount - 1));	×
394	}
395
396	return list;	×
397	}	×
398
399	QList<SceneValue> QLCPalette::valuesFromFixtureGroups(Doc *doc, QList<quint32> groups)	×
400	{
401	QList<quint32> fixturesList;
402
403	foreach (quint32 id, groups)	×
404	{
405	FixtureGroup *group = doc->fixtureGroup(id);	×
406	if (group == NULL)	×
407	continue;	×
408
409	fixturesList.append(group->fixtureList());	×
410	}
411
412	return valuesFromFixtures(doc, fixturesList);	×
413	}	×
414
415	qreal QLCPalette::valueFactor(qreal progress)	×
416	{
417	qreal factor = 1.0;
418	qreal normalizedAmount = qreal(m_fanningAmount) / 100.0;	×
419
420	switch (m_fanningType)	×
421	{
422	case Flat:
423	// nothing to do. Factor is always 1.0
424	break;
425	case Linear:	×
426	{
427	if (normalizedAmount < 1.0)	×
428	{
429	if (progress > normalizedAmount)	×
430	factor = 1.0;
431	else
432	factor = progress * normalizedAmount;	×
433	}
434	else if (normalizedAmount > 1.0)	×
435	{
436	factor = progress / normalizedAmount;	×
437	}
438	else
439	{
440	factor = progress;
441	}
442	}
443	break;
444	case Sine:	×
445	{
446	qreal degrees = (progress * 360.0) + 270.0;	×
447	factor = (qSin(normalizedAmount * qDegreesToRadians(degrees)) + 1.0) / 2.0;	×
448	}
449	break;	×
450	case Square:	×
451	{
452	factor = qSin(normalizedAmount * qDegreesToRadians(progress * 360.0)) < 0 ? 1 : 0;	×
453	}
454	break;
455	case Saw:
456	break;
457	}
458
459	return factor;	×
460	}
461
462	/************************************************************************
463	* Fanning
464	************************************************************************/
465
466	QLCPalette::FanningType QLCPalette::fanningType() const	2✔
467	{
468	return m_fanningType;	2✔
469	}
470
471	void QLCPalette::setFanningType(QLCPalette::FanningType type)	1✔
472	{
473	if (type == m_fanningType)	1✔
474	return;
475
476	m_fanningType = type;	1✔
477
478	emit fanningTypeChanged();	1✔
479	}
480
481	QString QLCPalette::fanningTypeToString(QLCPalette::FanningType type)	5✔
482	{
483	switch (type)	5✔
484	{
485	case Flat: return "Flat";	1✔
486	case Linear: return "Linear";	1✔
487	case Sine: return "Sine";	1✔
488	case Square: return "Square";	1✔
489	case Saw: return "Saw";	1✔
490	}
491
492	return "";	×
493	}
494
495	QLCPalette::FanningType QLCPalette::stringToFanningType(const QString &str)	7✔
496	{
497	if (str == "Flat")	7✔
498	return Flat;
499	else if (str == "Linear")	6✔
500	return Linear;
501	else if (str == "Sine")	4✔
502	return Sine;
503	else if (str == "Square")	3✔
504	return Square;
505	else if (str == "Saw")	2✔
506	return Saw;	1✔
507
508	return Flat;
509	}
510
511	QLCPalette::FanningLayout QLCPalette::fanningLayout() const	2✔
512	{
513	return m_fanningLayout;	2✔
514	}
515
516	void QLCPalette::setFanningLayout(QLCPalette::FanningLayout layout)	1✔
517	{
518	if (layout == m_fanningLayout)	1✔
519	return;
520
521	m_fanningLayout = layout;	×
522
523	emit fanningLayoutChanged();	×
524	}
525
526	QString QLCPalette::fanningLayoutToString(QLCPalette::FanningLayout layout)	9✔
527	{
528	switch (layout)	9✔
529	{
530	case XAscending: return "XAscending";	1✔
531	case XDescending: return "XDescending";	1✔
532	case XCentered: return "XCentered";	1✔
533	case YAscending: return "YAscending";	1✔
534	case YDescending: return "YDescending";	1✔
535	case YCentered: return "YCentered";	1✔
536	case ZAscending: return "ZAscending";	1✔
537	case ZDescending: return "ZDescending";	1✔
538	case ZCentered: return "ZCentered";	1✔
539	}
540
541	return "";	×
542	}
543
544	QLCPalette::FanningLayout QLCPalette::stringToFanningLayout(const QString &str)	11✔
545	{
546	if (str == "XAscending")	11✔
547	return XAscending;
548	else if (str == "XDescending")	10✔
549	return XDescending;
550	else if (str == "XCentered")	9✔
551	return XCentered;
552	else if (str == "YAscending")	8✔
553	return YAscending;
554	else if (str == "YDescending")	7✔
555	return YDescending;
556	else if (str == "YCentered")	6✔
557	return YCentered;
558	else if (str == "ZAscending")	5✔
559	return ZAscending;
560	else if (str == "ZDescending")	4✔
561	return ZDescending;
562	else if (str == "ZCentered")	3✔
563	return ZCentered;	1✔
564
565	return XAscending;
566	}
567
568	int QLCPalette::fanningAmount() const	3✔
569	{
570	return m_fanningAmount;	3✔
571	}
572
573	void QLCPalette::setFanningAmount(int amount)	2✔
574	{
575	if (amount == m_fanningAmount)	2✔
576	return;
577
578	m_fanningAmount = amount;	2✔
579
580	emit fanningAmountChanged();	2✔
581	}
582
583	QVariant QLCPalette::fanningValue() const	2✔
584	{
585	return m_fanningValue;	2✔
586	}
587
588	void QLCPalette::setFanningValue(QVariant value)	1✔
589	{
590	if (value == m_fanningValue)	1✔
591	return;
592
593	m_fanningValue = value;	1✔
594
595	emit fanningValueChanged();	1✔
596	}
597
598	/************************************************************************
599	* Color helpers
600	************************************************************************/
601
602	QString QLCPalette::colorToString(QColor rgb, QColor wauv)	2✔
603	{
604	QString final = rgb.name();	2✔
605	final.append(wauv.name().right(6));	2✔
606	return final;	2✔
607	}	×
608
609	bool QLCPalette::stringToColor(QString str, QColor &rgb, QColor &wauv)	3✔
610	{
611	// string must be like #rrggbb or #rrggbbwwaauv
612	if (str.length() != 7 && str.length() != 13)	3✔
613	return false;
614
615	rgb = QColor(str.left(7));	4✔
616
617	if (str.length() == 13)	2✔
618	wauv = QColor("#" + str.right(6));	4✔
619	else
620	wauv = QColor();
621
622	return true;
623	}
624
625	/************************************************************************
626	* Load & Save
627	************************************************************************/
628
629	bool QLCPalette::loader(QXmlStreamReader &xmlDoc, Doc *doc)	×
630	{
631	QLCPalette *palette = new QLCPalette(Dimmer, doc);	×
632	Q_ASSERT(palette != NULL);
633
634	if (palette->loadXML(xmlDoc) == true)	×
635	{
636	doc->addPalette(palette, palette->id());	×
637	}
638	else
639	{
640	qWarning() << Q_FUNC_INFO << "QLCPalette" << palette->name() << "cannot be loaded.";	×
641	delete palette;	×
642	return false;	×
643	}
644
645	return true;	×
646	}
647
648	bool QLCPalette::loadXML(QXmlStreamReader &doc)	2✔
649	{
650	if (doc.name() != KXMLQLCPalette)	4✔
651	{
652	qWarning() << Q_FUNC_INFO << "Palette node not found";	1✔
653	return false;	1✔
654	}
655
656	QXmlStreamAttributes attrs = doc.attributes();	1✔
657
658	bool ok = false;	1✔
659	quint32 id = attrs.value(KXMLQLCPaletteID).toString().toUInt(&ok);	1✔
660	if (ok == false)	1✔
661	{
662	qWarning() << "Invalid Palette ID:" << attrs.value(KXMLQLCPaletteID).toString();	×
663	return false;	×
664	}
665
666	setID(id);	1✔
667
668	if (attrs.hasAttribute(KXMLQLCPaletteType) == false)	1✔
669	{
670	qWarning() << "Palette type not found!";	×
671	return false;	×
672	}
673
674	m_type = stringToType(attrs.value(KXMLQLCPaletteType).toString());	1✔
675
676	if (attrs.hasAttribute(KXMLQLCPaletteName))	1✔
677	setName(attrs.value(KXMLQLCPaletteName).toString());	1✔
678
679	if (attrs.hasAttribute(KXMLQLCPaletteValue))	1✔
680	{
681	QString strVal = attrs.value(KXMLQLCPaletteValue).toString();	1✔
682	switch (m_type)	1✔
683	{
684	case Dimmer:	×
685	case Pan:
686	case Tilt:
687	setValue(strVal.toInt());	×
688	break;	×
689	case Color:	1✔
690	setValue(strVal);	1✔
691	break;	1✔
692	case PanTilt:	×
693	{
694	QStringList posList = strVal.split(",");	×
695	if (posList.count() == 2)	×
696	setValue(posList.at(0).toInt(), posList.at(1).toInt());	×
697	}
698	break;	×
699	case Shutter: break;
700	case Gobo: break;
701	case Undefined: break;
702	}
703	}	1✔
704
705	if (attrs.hasAttribute(KXMLQLCPaletteFanning))	1✔
706	{
707	setFanningType(stringToFanningType(attrs.value(KXMLQLCPaletteFanning).toString()));	1✔
708
709	if (attrs.hasAttribute(KXMLQLCPaletteFanLayout))	1✔
710	setFanningLayout(stringToFanningLayout(attrs.value(KXMLQLCPaletteFanLayout).toString()));	1✔
711
712	if (attrs.hasAttribute(KXMLQLCPaletteFanAmount))	1✔
713	setFanningAmount(attrs.value(KXMLQLCPaletteFanAmount).toInt());	1✔
714
715	if (attrs.hasAttribute(KXMLQLCPaletteFanValue))	1✔
716	{
717	QString strVal = attrs.value(KXMLQLCPaletteFanValue).toString();	1✔
718	switch (m_type)	1✔
719	{
720	case Dimmer:	×
721	case Pan:
722	case Tilt:
723	case PanTilt:
724	setFanningValue(strVal.toInt());	×
725	break;	×
726	case Color:	1✔
727	setFanningValue(strVal);	1✔
728	break;	1✔
729	case Shutter: break;
730	case Gobo: break;
731	case Undefined: break;
732	}
733	}	1✔
734	}
735
736	return true;
737	}
738
739	bool QLCPalette::saveXML(QXmlStreamWriter *doc)	1✔
740	{
741	Q_ASSERT(doc != NULL);
742
743	if (m_values.isEmpty())	1✔
744	{
745	qWarning() << "Unable to save a Palette without value!";	×
746	return false;	×
747	}
748
749	/* write a Palette entry */
750	doc->writeStartElement(KXMLQLCPalette);	1✔
751	doc->writeAttribute(KXMLQLCPaletteID, QString::number(this->id()));	1✔
752	doc->writeAttribute(KXMLQLCPaletteType, typeToString(m_type));	1✔
753	doc->writeAttribute(KXMLQLCPaletteName, this->name());	1✔
754
755	/* write value */
756	switch (m_type)	1✔
757	{
758	case Dimmer:	×
759	case Pan:
760	case Tilt:
761	case Color:
762	doc->writeAttribute(KXMLQLCPaletteValue, value().toString());	×
763	break;	×
764	case PanTilt:	1✔
765	doc->writeAttribute(KXMLQLCPaletteValue,	1✔
766	QString("%1,%2").arg(m_values.at(0).toInt()).arg(m_values.at(1).toInt()));	4✔
767	break;	1✔
768	case Shutter: break;
769	case Gobo: break;
770	case Undefined: break;
771	}
772
773	/* write fanning */
774	if (m_fanningType != Flat)	1✔
775	{
776	doc->writeAttribute(KXMLQLCPaletteFanning, fanningTypeToString(m_fanningType));	×
777	doc->writeAttribute(KXMLQLCPaletteFanLayout, fanningLayoutToString(m_fanningLayout));	×
778	doc->writeAttribute(KXMLQLCPaletteFanAmount, QString::number(m_fanningAmount));	×
779	doc->writeAttribute(KXMLQLCPaletteFanValue, fanningValue().toString());	×
780	}
781
782	doc->writeEndElement();	1✔
783
784	return true;	1✔
785	}
786

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