paletteOrganizer.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut für Technische Optik (ITO),
    Universität Stuttgart, Germany
 
    This file is part of itom.
 
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
 
    itom is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
    General Public Licence for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */
 
#ifndef PALETTEORGANIZER_H
#define PALETTEORGANIZER_H
 
#include "../../common/sharedStructures.h"
#include "../../common/sharedStructuresQt.h"
#include "../../common/sharedStructuresGraphics.h"
 
#include <qhash.h>
#include <qsharedpointer.h>
#include <qbrush.h>
#include <qsettings.h>
 
namespace ito
{
 
class ItomPaletteBase
{
    public:
        ItomPaletteBase()
        {
            m_paletteData.name = "";
            m_paletteData.type = 0;
            m_paletteData.inverseColorOne = QColor();
            m_paletteData.inverseColorTwo = QColor();
            m_paletteData.invalidColor = QColor();
        }
        ItomPaletteBase(const QString &name, const char type)
        {
            m_paletteData.name = name;
            m_paletteData.type = type;
            m_paletteData.inverseColorOne = QColor();
            m_paletteData.inverseColorTwo = QColor();
            m_paletteData.invalidColor = QColor();
        }
        ItomPaletteBase(const QString &name, const char type, const QColor &invCol1, const QColor &invCol2,  const QColor &invalCol,  const QVector<QGradientStop> &colStops)
        {
            m_paletteData.name = name;
            m_paletteData.type = type;
            m_paletteData.inverseColorOne = invCol1;
            m_paletteData.inverseColorTwo = invCol2;
            m_paletteData.invalidColor = invalCol;
            m_paletteData.colorStops = colStops;
        }
        ItomPaletteBase(const QString &name, const char type,  const QColor &start,  const QColor &stop)
        {
            m_paletteData.name = name;
            m_paletteData.type = type;
            m_paletteData.colorStops.append(QPair<double, QColor>(0.0, start));
            m_paletteData.colorStops.append(QPair<double, QColor>(1.0, stop));
        }
 
        ItomPaletteBase(const ItomPaletteBase & src) : m_paletteData(src.m_paletteData)
        { }
 
        ~ItomPaletteBase() {
            m_paletteData.colorStops.clear();
        }
 
        QString getName() const { return m_paletteData.name; }
        bool setName(const QString &name);
        inline int getNumColorStops() const { return m_paletteData.colorStops.size(); }
        inline int getType() const { return m_paletteData.type; }
 
        double getPosFirst() const { return m_paletteData.colorStops[0].first; }
        double getPosLast() const { return m_paletteData.colorStops[m_paletteData.colorStops.size()-1].first; }
        double getPos(unsigned int color) const;
 
        bool   setInverseColorOne(const QColor &color);
        QColor getInverseColorOne() const { return m_paletteData.inverseColorOne; }
        bool   setInverseColorTwo(const QColor &color);
        QColor getInverseColorTwo() const { return m_paletteData.inverseColorTwo; }
 
        bool setInvalidColor(const QColor &color);
        QColor getInvalidColor() const;
 
        int findUpper(double pos) const;
        inline QVector<QPair<double, QColor> > getColorStops(void) const { return m_paletteData.colorStops; }
        bool setColorStops(const QVector<QPair<double, QColor> > &colorStops);
        QColor getColor(unsigned int index) const;
 
        ItomPalette getPalette() const;
 
        bool isWriteProtected() const { return m_paletteData.type & ito::tPaletteReadOnly; }
        inline void setWriteProtection() { m_paletteData.type = m_paletteData.type | ito::tPaletteReadOnly; }
        void removeWriteProtection() { m_paletteData.type = m_paletteData.type & (~ito::tPaletteReadOnly); }
        bool insertColorStop( double pos, const QColor &color );
 
        QVector<ito::uint32> get256Colors(bool includeAlpha = false) const;
 
    private:
        ItomPalette m_paletteData;
};
 
//----------------------------------------------------------------------------------
class PaletteOrganizer : public QObject
{
    Q_OBJECT
 
    public:
        PaletteOrganizer();
        ~PaletteOrganizer(){};
 
        /* save the given color palette to the settings. Settings must already be opened in the group,
        where the palette should be saved. Each palette is stored as a subgroup of the current group. */
        ito::RetVal saveColorPaletteToSettings(const ItomPaletteBase &palette, QSettings &settings) const;
 
        /* load a color palette from the settings. Settings must already be opened in the group,
        where the palette should be loaded from. The current group must hereby consist of a subgroup with the group name 'name'. */
        ito::RetVal loadColorPaletteFromSettings(const QString &paletteName, ItomPaletteBase &palette, QSettings &settings) const;
 
        ItomPaletteBase getColorPalette(const int index) const;
        ItomPaletteBase getColorPalette(const QString &name, bool *found = NULL) const;
        int getColorBarIndex(const QString& name, bool *found = NULL) const;
 
        QList<QString> getColorPaletteList(const int type = ito::tPaletteNoType) const;
        QList<QString> getBuiltInPaletteNames() const { return m_builtInPalettes; }
        int numberOfColorPalettes() const { return m_colorPalettes.length(); }
        bool removeColorPalette(const int index);
 
    private:
        void calcColorPaletteLut();
 
        QList<QString>         m_restrictedKeyWords;
        QList<ItomPaletteBase> m_colorPalettes;
        QList<QString>         m_builtInPalettes;
        QHash<QString,int>     m_colorPaletteLUT;
 
        ItomPaletteBase noPalette;
 
    public slots:
        ito::RetVal setColorBarThreaded(QString name, ito::ItomPaletteBase newPalette, ItomSharedSemaphore *waitCond = NULL);
        ito::RetVal getColorBarThreaded(QString name, QSharedPointer<ito::ItomPaletteBase> palette, ItomSharedSemaphore *waitCond = NULL);
        ito::RetVal getColorBarListThreaded(QSharedPointer<QStringList> palettes, ItomSharedSemaphore *waitCond = NULL);
};
} //namespace ito
#endif