gradients.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2005-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the demonstration applications of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file.  Alternatively you may (at
** your option) use any later version of the GNU General Public
** License if such license has been publicly approved by Trolltech ASA
** (or its successors, if any) and the KDE Free Qt Foundation. In
** addition, as a special exception, Trolltech gives you certain
** additional rights. These rights are described in the Trolltech GPL
** Exception version 1.1, which can be found at
** http://www.trolltech.com/products/qt/gplexception/ and in the file
** GPL_EXCEPTION.txt in this package.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
** you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** In addition, as a special exception, Trolltech, as the sole
** copyright holder for Qt Designer, grants users of the Qt/Eclipse
** Integration plug-in the right for the Qt/Eclipse Integration to
** link to functionality provided by Qt Designer and its related
** libraries.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
** granted herein.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "gradients.h"
#include "hoverpoints.h"

#include <QtOpenGL>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

/*      Create checkerboard texture     */
#define tfcheckImageWidth 256
#define tfcheckImageHeight 256
static GLubyte tfcheckImage[tfcheckImageHeight][tfcheckImageWidth][4];
//static GLubyte checkImage[64*64];


#ifdef GL_VERSION_1_1
static GLuint tftexName;
#endif

#include <iostream>

void tfmakeCheckImage(void)
{
   int i, j, c;
    
   for (i = 0; i < tfcheckImageHeight; i++) {
      for (j = 0; j < tfcheckImageWidth; j++) {
         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
                 //checkImage[i*checkImageHeight+j] = (GLubyte) c;
                 //checkImage[i*checkImageHeight+j] = (GLubyte) 255;

                 tfcheckImage[i][j][0] = (GLubyte) c;
         tfcheckImage[i][j][1] = (GLubyte) c;
         tfcheckImage[i][j][2] = (GLubyte) c;
         tfcheckImage[i][j][3] = (GLubyte) 255;

      }
   }
}

ShadeWidget::ShadeWidget(ShadeType type, QWidget *parent)
    : QWidget(parent), m_shade_type(type), m_alpha_gradient(QLinearGradient(0, 0, 0, 0))
{

    // Checkers background
    if (m_shade_type == ARGBShade) {
        QPixmap pm(20, 20);
        QPainter pmp(&pm);
        pmp.fillRect(0, 0, 10, 10, Qt::lightGray);
        pmp.fillRect(10, 10, 10, 10, Qt::lightGray);
        pmp.fillRect(0, 10, 10, 10, Qt::darkGray);
        pmp.fillRect(10, 0, 10, 10, Qt::darkGray);
        pmp.end();
        QPalette pal = palette();
        pal.setBrush(backgroundRole(), QBrush(pm));
        setAutoFillBackground(true);
        setPalette(pal);

    } else {
        setAttribute(Qt::WA_NoBackground);

    }

    QPolygonF points;
    points << QPointF(0, sizeHint().height())
           << QPointF(sizeHint().width(), 0);

    m_hoverPoints = new HoverPoints(this, HoverPoints::CircleShape);
//     m_hoverPoints->setConnectionType(HoverPoints::LineConnection);
    m_hoverPoints->setPoints(points);
    m_hoverPoints->setPointLock(0, HoverPoints::LockToLeft);
    m_hoverPoints->setPointLock(1, HoverPoints::LockToRight);
    m_hoverPoints->setSortType(HoverPoints::XSort);

    //setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

    connect(m_hoverPoints, SIGNAL(pointsChanged(const QPolygonF &)), this, SIGNAL(colorsChanged()));
}


QPolygonF ShadeWidget::points() const
{
    return m_hoverPoints->points();
}


uint ShadeWidget::colorAt(int x)
{
    generateShade();

    QPolygonF pts = m_hoverPoints->points();
    for (int i=1; i < pts.size(); ++i) {
                qreal candidate_left_x = pts.at(i-1).x();
                qreal candidate_left_y = pts.at(i-1).y();
                qreal candidate_right_x = pts.at(i).x();
                qreal candidate_right_y = pts.at(i).y();
                qreal lx1,lx2,ly1,ly2,ll;
        if ( candidate_left_x<= x && candidate_right_x >= x) {
            QLineF l(pts.at(i-1), pts.at(i));
                        
                        ll = l.length();

            l.setLength(l.length() * ((x - l.x1()) / l.dx()));

                        ll = l.length();
                        lx1 = l.x1();
                        lx2 = l.x2();
                        ly1 = l.y1();
                        ly2 = l.y2();

                        int widget_width = m_shade.width();
                        int widget_height = m_shade.height();

                        qreal min_px = qMin(l.x2(), qreal(m_shade.width() - 1));
                        qreal min_py = qMin(l.y2(), qreal(m_shade.height() - 1));

                        int px = qRound(min_px);
                        int py = qRound(min_py);

                        QRgb p1 = m_shade.pixel(px,py);
                        int pred = qRed(p1);
                        int pgreen = qGreen(p1);
                        int pblue = qBlue(p1);
                        int palpha = qAlpha(p1);
            
                        return p1;
        }
    }
    return 0;
}


void ShadeWidget::setGradientStops(const QGradientStops &stops)
{
    if (m_shade_type == ARGBShade) {
        m_alpha_gradient = QLinearGradient(0, 0, width()-1, 0);

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

        m_shade = QImage();
        generateShade();
        update();
    }
}


void ShadeWidget::paintEvent(QPaintEvent *)
{
    generateShade();

    QPainter p(this);
    p.drawImage(0, 0, m_shade);

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


void ShadeWidget::generateShade()
{
    if (m_shade.isNull() || m_shade.size() != size()) {

        if (m_shade_type == ARGBShade) {
            m_shade = QImage(size(), QImage::Format_ARGB32_Premultiplied);
            m_shade.fill(0);

            QPainter p(&m_shade);
            p.fillRect(rect(), m_alpha_gradient);

            p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
                        //p.setCompositionMode(QPainter::CompositionMode_DestinationOver);
            QLinearGradient fade(0, 0, 0, height()-1);
            fade.setColorAt(0, QColor(0, 0, 0, 255));
            fade.setColorAt(1, QColor(0, 0, 0, 0));
            p.fillRect(rect(), fade);
                        m_shade.save("argbashade.png");
                        /*
                        m_shade = QImage(size(), QImage::Format_RGB32);
            QLinearGradient shade(0, 0, 0, height()-1);
            shade.setColorAt(1, Qt::black);

            shade.setColorAt(0, Qt::white);

            QPainter p(&m_shade);
            p.fillRect(rect(), shade);
                        */

        } else {
            m_shade = QImage(size(), QImage::Format_RGB32);
            QLinearGradient shade(0, 0, 0, height()-1);
            shade.setColorAt(1, Qt::black);

            if (m_shade_type == RedShade)
                shade.setColorAt(0, Qt::red);
            else if (m_shade_type == GreenShade)
                shade.setColorAt(0, Qt::green);
            else
                shade.setColorAt(0, Qt::blue);

            QPainter p(&m_shade);
            p.fillRect(rect(), shade);
        }
    }


}


GradientEditor::GradientEditor(QWidget *parent)
    : QWidget(parent)
{
    QVBoxLayout *vbox = new QVBoxLayout(this);
    vbox->setSpacing(1);
    vbox->setMargin(1);

    m_red_shade = new ShadeWidget(ShadeWidget::RedShade, this);
    m_green_shade = new ShadeWidget(ShadeWidget::GreenShade, this);
    m_blue_shade = new ShadeWidget(ShadeWidget::BlueShade, this);
    m_alpha_shade = new ShadeWidget(ShadeWidget::ARGBShade, this);

    vbox->addWidget(m_red_shade);
    vbox->addWidget(m_green_shade);
    vbox->addWidget(m_blue_shade);
    vbox->addWidget(m_alpha_shade);

    connect(m_red_shade, SIGNAL(colorsChanged()), this, SLOT(pointsUpdated()));
    connect(m_green_shade, SIGNAL(colorsChanged()), this, SLOT(pointsUpdated()));
    connect(m_blue_shade, SIGNAL(colorsChanged()), this, SLOT(pointsUpdated()));
    connect(m_alpha_shade, SIGNAL(colorsChanged()), this, SLOT(pointsUpdated()));
}


inline static bool x_less_than(const QPointF &p1, const QPointF &p2)
{
    return p1.x() < p2.x();
}


void GradientEditor::pointsUpdated()
{
    double w = m_alpha_shade->width();

    QGradientStops stops;

    QPolygonF points;

    points += m_red_shade->points();
    points += m_green_shade->points();
    points += m_blue_shade->points();
    points += m_alpha_shade->points();

    qSort(points.begin(), points.end(), x_less_than);

    for (int i=0; i<points.size(); ++i) {
        double x = int(points.at(i).x());
        if (i < points.size() - 1 && x == points.at(i+1).x())
            continue;
        QColor color((0x00ff0000 & m_red_shade->colorAt(int(x))) >> 16,
                     (0x0000ff00 & m_green_shade->colorAt(int(x))) >> 8,
                     (0x000000ff & m_blue_shade->colorAt(int(x))),
                     (0xff000000 & m_alpha_shade->colorAt(int(x))) >> 24);


                int r1 = (0x00ff0000 & m_red_shade->colorAt(int(x))) >> 16;
                int g1 = (0x0000ff00 & m_green_shade->colorAt(int(x))) >> 8;
                int b1 = (0x000000ff & m_blue_shade->colorAt(int(x)));
                int a1 = (0xff000000 & m_alpha_shade->colorAt(int(x)) >> 24);
        
                if (x / w > 1)
            return;

        stops << QGradientStop(x / w, color);
    }

    m_alpha_shade->setGradientStops(stops);

    emit gradientStopsChanged(stops);
}


static void set_shade_points(const QPolygonF &points, ShadeWidget *shade)
{
    shade->hoverPoints()->setPoints(points);
    shade->hoverPoints()->setPointLock(0, HoverPoints::LockToLeft);
    shade->hoverPoints()->setPointLock(points.size() - 1, HoverPoints::LockToRight);
    shade->update();
}

void GradientEditor::setGradientStops(const QGradientStops &stops)
{
    QPolygonF pts_red, pts_green, pts_blue, pts_alpha;

    double h_red = m_red_shade->height();
    double h_green = m_green_shade->height();
    double h_blue = m_blue_shade->height();
    double h_alpha = m_alpha_shade->height();

        double w_red = m_red_shade->width();
    double w_green = m_green_shade->width();
    double w_blue = m_blue_shade->width();
    double w_alpha = m_alpha_shade->width();


    for (int i=0; i<stops.size(); ++i) {
        double pos = stops.at(i).first;
        QRgb color = stops.at(i).second.rgba();
                
                qreal red_x = pos * w_red;
                qreal red_y = h_red - qRed(color) * h_red / 255;

                qreal green_x = pos * w_green;
                qreal green_y = h_green - qGreen(color) * h_green / 255;
 
                qreal blue_x = pos * w_blue;
                qreal blue_y = h_blue - qBlue(color) * h_blue / 255;
        
                qreal alpha_x = pos * w_alpha;
                qreal alpha_y = h_alpha - qAlpha(color) * h_alpha / 255;
        
                pts_red << QPointF(red_x, red_y);
                pts_green << QPointF(green_x, green_y);
                pts_blue << QPointF(blue_x, blue_y);
                pts_alpha << QPointF(alpha_x, alpha_y);
    }

    set_shade_points(pts_red, m_red_shade);
    set_shade_points(pts_green, m_green_shade);
    set_shade_points(pts_blue, m_blue_shade);
    set_shade_points(pts_alpha, m_alpha_shade);

        emit gradientStopsChanged(stops);

}

GradientWidget::GradientWidget(QWidget *parent)
    : QWidget(parent)
{
    //setWindowTitle("Transfer Functions");

    //QGroupBox *mainGroup = new QGroupBox(this);
    //mainGroup->setTitle("Color editor");

        //QGroupBox *pcGroup = new QGroupBox(this);
    //pcGroup->setTitle("Parallel coordinates");

    //QGroupBox *editorGroup = new QGroupBox(mainGroup);
    //editorGroup->setAttribute(Qt::WA_ContentsPropagated);
    //editorGroup->setTitle("Color Editor");
    

    /*
        QGroupBox *typeGroup = new QGroupBox(mainGroup);
    typeGroup->setAttribute(Qt::WA_ContentsPropagated);
    typeGroup->setTitle("Gradient Type");

    m_linearButton = new QRadioButton("Linear Gradient", typeGroup);
    m_radialButton = new QRadioButton("Radial Gradient", typeGroup);
    m_conicalButton = new QRadioButton("Conical Gradient", typeGroup);

        QGroupBox *spreadGroup = new QGroupBox(mainGroup);
    spreadGroup->setAttribute(Qt::WA_ContentsPropagated);
    spreadGroup->setTitle("Spread Method");
        
    m_padSpreadButton = new QRadioButton("Pad Spread", spreadGroup);
    m_reflectSpreadButton = new QRadioButton("Reflect Spread", spreadGroup);
    m_repeatSpreadButton = new QRadioButton("Repeat Spread", spreadGroup);

    QGroupBox *defaultsGroup = new QGroupBox(mainGroup);
    defaultsGroup->setAttribute(Qt::WA_ContentsPropagated);
    defaultsGroup->setTitle("Defaults");
    QPushButton *default1Button = new QPushButton("1", defaultsGroup);
    QPushButton *default2Button = new QPushButton("2", defaultsGroup);
    QPushButton *default3Button = new QPushButton("3", defaultsGroup);
    QPushButton *default4Button = new QPushButton("Reset", editorGroup);

    QPushButton *showSourceButton = new QPushButton(mainGroup);
    showSourceButton->setText("Show Source");
#ifdef QT_OPENGL_SUPPORT
    QPushButton *enableOpenGLButton = new QPushButton(mainGroup);
    enableOpenGLButton->setText("Use OpenGL");
    enableOpenGLButton->setCheckable(true);
    enableOpenGLButton->setChecked(m_renderer->usesOpenGL());
    if (!QGLFormat::hasOpenGL())
        enableOpenGLButton->hide();
#endif
    QPushButton *whatsThisButton = new QPushButton(mainGroup);
    whatsThisButton->setText("What's This?");
    whatsThisButton->setCheckable(true);
        */

    // Layouts
    //QHBoxLayout *mainLayout = new QHBoxLayout(this);
    //mainLayout->addWidget(pcGroup);
    //mainLayout->addWidget(colorGroup);

        //QVBoxLayout *pcGroupLayout = new QVBoxLayout(pcGroup);
        //m_renderer = new GradientRenderer(pcGroup);
        //pcGroupLayout->addWidget(m_renderer);
        //m_sliceWidget = new sliceWidget(pcGroup);
        //pcGroupLayout->addWidget(m_sliceWidget);

        /*
    mainGroup->setFixedWidth(180);
    QVBoxLayout *mainGroupLayout = new QVBoxLayout(mainGroup);
    mainGroupLayout->addWidget(editorGroup);
    mainGroupLayout->addWidget(typeGroup);
    mainGroupLayout->addWidget(spreadGroup);
    mainGroupLayout->addWidget(defaultsGroup);
    mainGroupLayout->addStretch(1);
    mainGroupLayout->addWidget(showSourceButton);
#ifdef QT_OPENGL_SUPPORT
    mainGroupLayout->addWidget(enableOpenGLButton);
#endif
    mainGroupLayout->addWidget(whatsThisButton);
        */

        QGroupBox *mainGroup = new QGroupBox(this);
    mainGroup->setTitle("Color editor");
    
        QVBoxLayout *mainLayout = new QVBoxLayout(mainGroup);
        
        m_editor = new GradientEditor(mainGroup);
    mainLayout->addWidget(m_editor);

        tf_widget = new tfGLWidget(mainGroup);
        mainLayout->addWidget(tf_widget);

        QGroupBox *defaultsGroup = new QGroupBox(mainGroup);
        defaultsGroup->setTitle("Pre-defined functions");

        mainLayout->addWidget(defaultsGroup);

        QVBoxLayout *defaultsGroupLayout = new QVBoxLayout(defaultsGroup);

        m_linearButton = new QPushButton("Linear");
        defaultsGroupLayout->addWidget(m_linearButton);
        
        m_zerosButton = new QPushButton("Zeros");
        defaultsGroupLayout->addWidget(m_zerosButton);
        
        m_blackButton = new QPushButton("Black");
        defaultsGroupLayout->addWidget(m_blackButton);

        m_whiteButton = new QPushButton("White");
        defaultsGroupLayout->addWidget(m_whiteButton);
        
        m_redButton = new QPushButton("Red");
        defaultsGroupLayout->addWidget(m_redButton);

        m_greenButton = new QPushButton("Green");
        defaultsGroupLayout->addWidget(m_greenButton);
        
        m_blueButton = new QPushButton("Blue");
        defaultsGroupLayout->addWidget(m_blueButton);

        m_rainbowButton = new QPushButton("Rainbow");
        defaultsGroupLayout->addWidget(m_rainbowButton);


    /*
        QVBoxLayout *typeGroupLayout = new QVBoxLayout(typeGroup);
    typeGroupLayout->addWidget(m_linearButton);
    typeGroupLayout->addWidget(m_radialButton);
    typeGroupLayout->addWidget(m_conicalButton);

    QVBoxLayout *spreadGroupLayout = new QVBoxLayout(spreadGroup);
    spreadGroupLayout->addWidget(m_padSpreadButton);
    spreadGroupLayout->addWidget(m_repeatSpreadButton);
    spreadGroupLayout->addWidget(m_reflectSpreadButton);

    QHBoxLayout *defaultsGroupLayout = new QHBoxLayout(defaultsGroup);
    defaultsGroupLayout->addWidget(default1Button);
    defaultsGroupLayout->addWidget(default2Button);
    defaultsGroupLayout->addWidget(default3Button);
    editorGroupLayout->addWidget(default4Button);
        */

    //connect(m_editor, SIGNAL(gradientStopsChanged(const QGradientStops &)), m_renderer, SLOT(setGradientStops(const QGradientStops &)));
        
        connect(m_editor, SIGNAL(gradientStopsChanged(const QGradientStops &)), this, SLOT(rendertf(const QGradientStops &)));

        //connect(m_renderer, SIGNAL(tfTextureGenerated(GLuint)), tf_widget, SLOT(setTFID(GLuint)));
        connect(this, SIGNAL(tfready(QImage &)), tf_widget, SLOT(setTFImage(QImage &)));
        //connect(m_renderer, SIGNAL(tfTextureGenerated(QImage &)), this, SLOT(setTransferFunction(QImage &)));

        connect(m_zerosButton, SIGNAL(clicked()), this, SLOT(setDefault1()));
        connect(m_blackButton, SIGNAL(clicked()), this, SLOT(setDefault2()));
        connect(m_linearButton, SIGNAL(clicked()), this, SLOT(setDefault3()));
        connect(m_redButton, SIGNAL(clicked()), this, SLOT(setDefault4()));
        connect(m_greenButton, SIGNAL(clicked()), this, SLOT(setDefault5()));
        connect(m_blueButton, SIGNAL(clicked()), this, SLOT(setDefault6()));
        connect(m_rainbowButton, SIGNAL(clicked()), this, SLOT(setDefault7()));
        connect(m_whiteButton, SIGNAL(clicked()), this, SLOT(setDefault8()));

    /*
        connect(m_linearButton, SIGNAL(clicked()), m_renderer, SLOT(setLinearGradient()));
    connect(m_radialButton, SIGNAL(clicked()), m_renderer, SLOT(setRadialGradient()));
    connect(m_conicalButton, SIGNAL(clicked()), m_renderer, SLOT(setConicalGradient()));

    connect(m_padSpreadButton, SIGNAL(clicked()), m_renderer, SLOT(setPadSpread()));
    connect(m_reflectSpreadButton, SIGNAL(clicked()), m_renderer, SLOT(setReflectSpread()));
    connect(m_repeatSpreadButton, SIGNAL(clicked()), m_renderer, SLOT(setRepeatSpread()));

    connect(default1Button, SIGNAL(clicked()), this, SLOT(setDefault1()));
    connect(default2Button, SIGNAL(clicked()), this, SLOT(setDefault2()));
    connect(default3Button, SIGNAL(clicked()), this, SLOT(setDefault3()));
    connect(default4Button, SIGNAL(clicked()), this, SLOT(setDefault4()));

    connect(showSourceButton, SIGNAL(clicked()), m_renderer, SLOT(showSource()));
#ifdef QT_OPENGL_SUPPORT
    connect(enableOpenGLButton, SIGNAL(clicked(bool)), m_renderer, SLOT(enableOpenGL(bool)));
#endif
    connect(whatsThisButton, SIGNAL(clicked(bool)), m_renderer, SLOT(setDescriptionEnabled(bool)));
    connect(whatsThisButton, SIGNAL(clicked(bool)),
            m_renderer->hoverPoints(), SLOT(setDisabled(bool)));
    connect(m_renderer, SIGNAL(descriptionEnabledChanged(bool)),
            whatsThisButton, SLOT(setChecked(bool)));
    connect(m_renderer, SIGNAL(descriptionEnabledChanged(bool)),
            m_renderer->hoverPoints(), SLOT(setDisabled(bool)));

    m_renderer->loadSourceFile(":res/gradients.cpp");
    m_renderer->loadDescription(":res/gradients.html");
*/
    QTimer::singleShot(50, this, SLOT(setDefault3()));
}

void GradientWidget::setTransferFunction(QImage &tf_img)
{
        m_transfer_function = tf_img;
        emit tfready(m_transfer_function);
}

void GradientWidget::setGradientStops(const QGradientStops &stops)
{
        m_stops.clear();
        m_editor->setGradientStops(stops);
        update();
}

void GradientWidget::setDefault(int config)
{
    QGradientStops stops;
    QPolygonF points;
    switch (config) {
                //zeros
    case 1:
        stops << QGradientStop(0.00, QColor::fromRgba(0x00000000));
        stops << QGradientStop(1.00, QColor::fromRgba(0x00000000));
        break;
                //black
    case 2:
        stops << QGradientStop(0.00, QColor::fromRgba(0xff000000));
        stops << QGradientStop(1.00, QColor::fromRgba(0xff000000));
        break;
                //linear
        case 3:
        stops << QGradientStop(0.00, QColor::fromRgba(0x00000000));
        stops << QGradientStop(1.00, QColor::fromRgba(0xffffffff));
        break;
                //only red
        case 4:
                stops << QGradientStop(0.00, QColor::fromRgba(0x00ff0000));
        stops << QGradientStop(1.00, QColor::fromRgba(0x00ff0000));
                break;
                //only green
        case 5:
                stops << QGradientStop(0.00, QColor::fromRgba(0x0000ff00));
        stops << QGradientStop(1.00, QColor::fromRgba(0x0000ff00));
                break;
                //only blue
        case 6:
                stops << QGradientStop(0.00, QColor::fromRgba(0x000000ff));
        stops << QGradientStop(1.00, QColor::fromRgba(0x000000ff));
                break;
                //rainbow
    case 7:
        stops << QGradientStop(0.00, QColor::fromRgba(0xffff0000));
        stops << QGradientStop(0.50, QColor::fromRgba(0xff00ff00));
        stops << QGradientStop(1.00, QColor::fromRgba(0xff0000ff));
        //m_radialButton->animateClick();
        //m_padSpreadButton->animateClick();
        break;
                //white
    case 8:
        stops << QGradientStop(0.00, QColor::fromRgba(0xffffffff));
        stops << QGradientStop(1.00, QColor::fromRgba(0xffffffff));
        break;
    default:
        qWarning("bad default: %d\n", config);
        break;
    }

        /*
    QPolygonF pts;
    int h_off = m_renderer->width() / 10;
    int v_off = m_renderer->height() / 8;
    pts << QPointF(m_renderer->width() / 2, m_renderer->height() / 2)
        << QPointF(m_renderer->width() / 2 - h_off, m_renderer->height() / 2 - v_off);
        */

    m_editor->setGradientStops(stops);
    //m_renderer->hoverPoints()->setPoints(pts);
    //m_renderer->setGradientStops(stops);
}

//method constructs tf texture,uploads it to gpu and emits the signal w/ texture's id
void GradientWidget::rendertf(const QGradientStops &stops)
{
        m_stops = stops;

        QImage tf_img = QImage(256, 256, QImage::Format_ARGB32_Premultiplied);
        tf_img.fill(0);

        QLinearGradient lg = QLinearGradient(0, 0, 255, 0);

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

        QPainter p(&tf_img);

        p.fillRect(rect(), lg);

        QGradient fade;

        p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
        fade = QLinearGradient(0, 0, 255, 0);

        for (int i=0; i<m_stops.size(); ++i)
        {
                fade.setColorAt(m_stops.at(i).first, m_stops.at(i).second);
        }


        p.setBrush(fade);
        p.drawRect(rect());
        
        /*
        QImage alpha_img = QImage(256, 256, QImage::Format_RGB32);
        alpha_img.fill(0);

        QLinearGradient alpha_lg = QLinearGradient(0, 0, 0, 255);

        for (int i=0; i<stops.size(); ++i) {
            QColor ac = stops.at(i).second;
                        alpha_lg.setColorAt(stops.at(i).first, QColor(ac.alpha(), ac.alpha(), ac.alpha()));
    }

        QPainter alpha_painter(&alpha_img);

        alpha_painter.fillRect(rect(), alpha_lg);

        tf_img.setAlphaChannel(alpha_img);
        */

        //QImage tf2_img= tf_img.mirrored(false,false);
        tf_img.save("tf.png");


        //emit tfTextureGenerated(tf_img);

        m_transfer_function = tf_img;
        emit tfready(m_transfer_function);
        //emit gradientStopsChanged(all_rgba_stops);

    update();
}


GradientRenderer::GradientRenderer(QWidget *parent) : QGLWidget(parent)
    //: ArthurFrame(parent)
{
        /*
    m_hoverPoints = new HoverPoints(this, HoverPoints::CircleShape);
    m_hoverPoints->setPointSize(QSize(20, 20));
    m_hoverPoints->setConnectionType(HoverPoints::NoConnection);
    m_hoverPoints->setEditable(false);

    QVector<QPointF> points;
    points << QPointF(100, 100) << QPointF(200, 200);
    m_hoverPoints->setPoints(points);

        m_tf_texture = new unsigned char [256*256*4];
        */

    //m_spread = QGradient::PadSpread;
    //m_gradientType = Qt::LinearGradientPattern;

        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
}

void GradientRenderer::setGradientStops(const QGradientStops &stops)
{
    m_stops = stops;
    update();
}
void GradientRenderer::initializeGL()
{

        //glewInit();
        qglClearColor(QColor::fromRgb(255,255,255));
        glShadeModel (GL_FLAT);
        glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
        glutInitDisplayMode(GLUT_RGBA);
        gluOrtho2D(0.0, 256.0, 0.0, 512.0);
}

void GradientRenderer::paintGL()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glLoadIdentity();

        glTranslated(0.0, 0.0, 0.0);

        //define points of poly-line
        QPointF v00 = QPointF(10.0, 0.0);
        QPointF v01 = QPointF(200.0, 128.0);
        QPointF v02 = QPointF(100.0, 256.0);
        QPointF v03 = QPointF(20.0, 384.0);
        QPointF v04 = QPointF(140.0, 512.0);
        QColor line_color0 = QColor(255,0,0,255);

        //add points of poly-line to list
        QList<QPointF> vertices0;
        vertices0.append(v00);
        vertices0.append(v01);
        vertices0.append(v02);
        vertices0.append(v03);
        vertices0.append(v04);

        //define points of poly-line
        QPointF v10 = QPointF(100.0, 0.0);
        QPointF v11 = QPointF(150.0, 128.0);
        QPointF v12 = QPointF(200.0, 256.0);
        QPointF v13 = QPointF(126.0, 384.0);
        QPointF v14 = QPointF(10.0, 512.0);
        QColor line_color1 = QColor(0,0,255,255);

        //add points of poly-line to list
        QList<QPointF> vertices1;
        vertices1.append(v10);
        vertices1.append(v11);
        vertices1.append(v12);
        vertices1.append(v13);
        vertices1.append(v14);

        //list of parallel lines, where
        //each line is defined by list of vertices and its color
        typedef QPair<QList<QPointF>,QColor> ParralelCoordinatesLine;
        typedef QList<ParralelCoordinatesLine> ParallelCoordinatesLinesList;
        
        ParallelCoordinatesLinesList pc_lines_list;
        pc_lines_list.append(qMakePair(vertices0,line_color0));
        pc_lines_list.append(qMakePair(vertices1,line_color1));
        
        QListIterator<ParralelCoordinatesLine> pc_lineslist_i(pc_lines_list);
        ParralelCoordinatesLine pc_line;
        QList<QPointF> pc_line_vertices;
        QColor pc_line_color;
        while(pc_lineslist_i.hasNext())
        {
                pc_line = pc_lineslist_i.next();
                pc_line_vertices = pc_line.first;
                pc_line_color = pc_line.second;

                //define mode for polygon drawing
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                //define color of poly-line e.g. black
                //glColor3f(0.0, 0.0, 0.0);
                qglColor(pc_line_color);

                //draw poly-line
                glBegin(GL_POLYGON);
                        QListIterator<QPointF> i(pc_line_vertices);
                        QPointF poly_vertex;
                        while (i.hasNext())
                        {
                                poly_vertex = (QPointF)i.next();
                                
                                //we don't want loop
                                if(i.hasNext())
                                        glEdgeFlag(GL_TRUE);
                                else
                                        glEdgeFlag(GL_FALSE);
                                
                                glVertex2f(poly_vertex.x(),poly_vertex.y());
                        }
                        /*
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v0.x(),v0.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v1.x(),v1.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v2.x(),v2.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v3.x(),v3.y());
                        glEdgeFlag(GL_FALSE);
                        glVertex2f(v4.x(),v4.y());
                        */
                glEnd();
        }

        /*
        //define mode for polygon drawing
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        //define color of poly-line e.g. black
        //glColor3f(0.0, 0.0, 0.0);
        qglColor(line_color);
        
        //draw poly-line
        glBegin(GL_POLYGON);
                QListIterator<QPointF> i(vertices);
                QPointF poly_vertex;
                while (i.hasNext())
                {
                        poly_vertex = (QPointF)i.next();
                        
                        //we don't want loop
                        if(i.hasNext())
                                glEdgeFlag(GL_TRUE);
                        else
                                glEdgeFlag(GL_FALSE);
                        
                        glVertex2f(poly_vertex.x(),poly_vertex.y());
                }
        glEnd();
        */

        glFlush ();

}

void GradientRenderer::resizeGL(int width, int height)
{
   int side = qMin(width, height);

   glViewport (0, 0, (GLsizei) width, (GLsizei) height); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
}

void GradientRenderer::mousePressEvent(QMouseEvent *event)
{
}

void GradientRenderer::mouseMoveEvent(QMouseEvent *event)
{
}

/*
void GradientRenderer::mousePressEvent(QMouseEvent *)
{
    setDescriptionEnabled(false);
}
*/

/*
void GradientRenderer::paint(QPainter *p)
{
    QPolygonF pts = m_hoverPoints->points();

    QGradient g;

    if (m_gradientType == Qt::LinearGradientPattern) {
        g = QLinearGradient(pts.at(0), pts.at(1));

    } else if (m_gradientType == Qt::RadialGradientPattern) {
        QLineF line(pts.at(0), pts.at(1));
        if (line.length() > 132)
            line.setLength(132);
        g = QRadialGradient(line.p1(), qMin(width(), height()) / 3.0, line.p2());
    } else {
        QLineF l(pts.at(0), pts.at(1));
        double angle = l.angle(QLineF(0, 0, 1, 0));
        if (l.dy() > 0)
            angle = 360 - angle;
        g = QConicalGradient(pts.at(0), angle);
    }

    for (int i=0; i<m_stops.size(); ++i)
        g.setColorAt(m_stops.at(i).first, m_stops.at(i).second);

    g.setSpread(m_spread);

    p->setBrush(g);
    p->setPen(Qt::NoPen);

    p->drawRect(rect());

}
*/

---