FlowVis/transferwidget.cpp

#include "transferwidget.h"
#include "qtcolortriangle.h"
#include <QDataStream>

#include <iostream>

TransferWidget::TransferWidget(QWidget *parent)
        : QWidget(parent)
{
        gradient = QLinearGradient(0,0,0,0);
        this->setFixedSize(200,40);
        Init();

        addTestPoints();
}

TransferWidget::~TransferWidget()
{

}

void TransferWidget::Init()
{
        //Paint checkerboard
        QPixmap pm(20, 20);
    QPainter pmp(&pm);
        pmp.fillRect(0, 0, 10, 10, Qt::white);
    pmp.fillRect(10, 10, 10, 10, Qt::white);
    pmp.fillRect(0, 10, 10, 10, Qt::lightGray);
    pmp.fillRect(10, 0, 10, 10, Qt::lightGray);
    pmp.end();
         
        QPalette pal = palette();
    pal.setBrush(backgroundRole(), QBrush(pm));
    setAutoFillBackground(true);
    setPalette(pal);


         QVector<QPointF> points;
     //points << QPointF(0, 0) << QPointF(width()/2,height()/3) << QPointF(width(), 0);

         QVector<QColor> colors;
         //colors << Qt::black << Qt::white;
         loadFromFile("transfer.cfg",points,colors);

        
         
         
         hoverPoints = new HoverPoints(this,HoverPoints::CircleShape);  
         QObject::connect(hoverPoints,SIGNAL(pointsChanged(QPolygonF)),this,SLOT(PointsChanged()));
         QObject::connect(this,SIGNAL(InvokeChangeSelectedColor(const QColor)),hoverPoints,SLOT(setCurrentColor(const QColor)));

         hoverPoints->setPoints(QPolygonF(points),colors);
         hoverPoints->setPointLock(0, HoverPoints::LockToLeft);
         hoverPoints->setPointLock(points.size()-1, HoverPoints::LockToRight);
         hoverPoints->setSortType(HoverPoints::XSort);
         hoverPoints->setConnectionType(HoverPoints::LineConnection);
}

void TransferWidget::SaveConfig(QString filename)
{
        //saveToFile("transfer.cfg");
        saveToFile(filename);
}

void TransferWidget::LoadConfig(QString filename)
{
        QVector<QPointF> points;
        QVector<QColor> colors;

        loadFromFile(filename,points,colors);

        hoverPoints->setPoints(QPolygonF(points),colors);
        hoverPoints->setPointLock(0, HoverPoints::LockToLeft);
        hoverPoints->setPointLock(points.size()-1, HoverPoints::LockToRight);
        hoverPoints->firePointChange();
}
void TransferWidget::saveToFile(QString filename)
{
        QFile file(filename);

        file.open(QIODevice::WriteOnly);


        QDataStream out(&file);

        QVector<QPointF> points = hoverPoints->points();
        out << points << hoverPoints->Colors()<< QString("End");
}

QDataStream& operator<<(QDataStream &out,const TransferWidget *transfer)
{
        QVector<QPointF> points = transfer->hoverPoints->points();
        out << points << transfer->hoverPoints->Colors();
        return out;
}
QDataStream& operator>>(QDataStream &in,TransferWidget *transfer)
{
        QVector<QPointF> points;
        QVector<QColor> colors;

        in >> points >> colors;

        transfer->hoverPoints->setPoints(QPolygonF(points),colors);
        transfer->hoverPoints->setPointLock(0, HoverPoints::LockToLeft);
        transfer->hoverPoints->setPointLock(points.size()-1, HoverPoints::LockToRight);
        transfer->hoverPoints->firePointChange();
        return in;
}

void TransferWidget::loadFromFile(QString filename, QVector<QPointF> &points, QVector<QColor> &colors)
{
        //QPolygonF polygon;
        //QVector<QColor> colors;
        
        QFile file(filename);
        if(file.exists()){
                file.open(QIODevice::ReadOnly);

                QDataStream in(&file);
                QString ende;
                in >> points >> colors >> ende;
        }
        else{
                 points << QPointF(0, (float)height()/2.0) << QPointF(width(), (float)height()/2.0);
                 colors << Qt::black << Qt::white;
        }
}
void TransferWidget::PointsChanged()
{
        emit InvokeUpdateColorSelector(hoverPoints->CurrentColor());
        qreal w = this->width();
        qreal h = this->height();

        stops.clear();
        QPolygonF points;
        
        points += hoverPoints->points();

        //std::cout << "TWidget - points changed" << endl;
        //Iterate over all points in polygon
        for(int i=0; i<points.size();i++)
        {
                qreal x = int(points.at(i).x());
                qreal y = int(points.at(i).y());

                if (i < points.size() - 1 && x == points.at(i+1).x())
            continue;

                if(x/w > 1)
                        return;
                
                QColor color = hoverPoints->Colors().at(i);
                color.setAlphaF((h-y)/h);
                stops << QGradientStop(x / w, color);
        }
        
        calcGradientStops();
        //      stops << QGradientStop(x / w, color);
        //}
}
void TransferWidget::paintEvent(QPaintEvent *)
{
        QPainter p(this);

        calcShadeImage();
        p.drawImage(0, 0, shadeImage);

    p.setPen(QColor(146, 146, 146));
    p.drawRect(0, 0, width() - 1, height() - 1);
}

void TransferWidget::addTestPoints()
{
        qreal width = shadeImage.width();

        stops <<  QGradientStop(0, Qt::white) << QGradientStop(0.2, Qt::red) 
                << QGradientStop(0.5, Qt::green) << QGradientStop(0.8,Qt::blue) << QGradientStop(1,Qt::black);

        calcGradientStops();
}
void TransferWidget::calcShadeImage()
{
        if(shadeImage.isNull() || shadeImage.size() != size()){
                shadeImage = QImage(size(), QImage::Format_ARGB32_Premultiplied);
                shadeImage.fill(0);

                QPainter p(&shadeImage);
                
                p.fillRect(rect(), gradient);

                p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
                QLinearGradient fade(0, 0, 0, height());
                fade.setColorAt(0, QColor(0, 0, 0, 255));
                fade.setColorAt(1, QColor(0, 0, 0, 0));
                p.fillRect(rect(), fade);

        }
        
        //calculate transferImage
        transferImage = QImage(4096,1,QImage::Format_ARGB32);
        transferImage.fill(0);

        QPainter i(&transferImage);
        i.fillRect(0,0,4096,1,gradientWithAlpha);
}


void TransferWidget::calcGradientStops()
{
        gradient = QLinearGradient(0, 0, width(), 0);
        gradientWithAlpha = QLinearGradient(0, 0, width(), 0);

        for (int i=0; i<stops.size(); ++i) {
                QColor c = stops.at(i).second;
                gradient.setColorAt(stops.at(i).first, QColor(c.red(), c.green(), c.blue()));
                gradientWithAlpha.setColorAt(stops.at(i).first, QColor(c.red(), c.green(), c.blue(),c.alpha()));
        }

    shadeImage = QImage();
    calcShadeImage();
    update();

        emit TransferImageUpdated(transferImage);
}