src/ShadeWidget.cpp

Go to the documentation of this file.

#include "ShadeWidget.h"
#include <iostream>


ShadeWidget::ShadeWidget(ShadeType type, QWidget *parent, std::string name)
    : QWidget(parent), m_shade_type(type), 
      m_alpha_gradient(QLinearGradient(0, 0, 0, 0)),
      m_shadeName(name)

{
    if (m_shade_type != ARGBShade) 
    {
       setAttribute(Qt::WA_NoBackground);
    }

    // Hide histogram
    histogramVisible = false;
    m_hist = NULL;
    m_nohist = new QPixmap(20,20);
    clearHistogram();

    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);

    if(this->m_shade_type == ARGBShade)
    {
      setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
    }
    else
    {
      setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
    }
    

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


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

void ShadeWidget::setPoints(QPolygonF pts)
{
  m_hoverPoints->setPoints(pts);
}

std::string ShadeWidget::getName() const
{
  return m_shadeName;
}

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

    QPolygonF pts = m_hoverPoints->points();

    //std::cout << "nr. points: " << pts.size() << std::endl;


    for (int i=1; i < pts.size(); ++i) 
    {
        if ( pts.at(i-1).x() <= x && pts.at(i).x() >= x ) 
        {

            QLineF l( pts.at(i-1), pts.at(i) );
            l.setLength( l.length() * ((x - l.x1()) / l.dx()) );
/*
            std::cout << "X1: " << l.x1() <<
                         ", Y1: " << l.y1() << std::endl;

            std::cout << "X2: " << l.x2() <<
                         ", Y2: " << l.y2() << std::endl;

            std::cout << "wdth: " << m_shade.width()  << std::endl;
            std::cout << "hgth: " << m_shade.height() << std::endl;
*/
            int p1 = qRound( qMin( l.x2(), qreal( m_shade.width()  - 1) ));
            int p2 = qRound( qMin( l.y2(), qreal( m_shade.height() - 1) ));

            QRgb pixel = m_shade.pixel( p1 , p2 );

/*
            std::cout << "pixel-value: " << this->getName() <<
              ", p1: " << p1 <<
              ", p2: " << p2 <<
              ", i: " << i <<
              ", R: " << qRed( pixel )   <<
              ", G: " << qGreen( pixel ) <<
              ", B: " << qBlue( pixel )  <<
              ", A: " << qAlpha( pixel ) << std::endl;
*/
            return pixel;

/*
            return m_shade.pixel( qRound( qMin(l.x2(), ( qreal(m_shade.width() - 1))) ),
                                  qRound( qMin(l.y2(), qreal(m_shade.height() - 1))) ));
*/
        }
    }
    return 0;
}


void ShadeWidget::setGradientStops(const QGradientStops &stops)
{
    if (m_shade_type == ARGBShade) {
        m_alpha_gradient = QLinearGradient(0, 0, width(), 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::setHistogram(const int* density)
{
  histogramVisible = true;
  m_density = (int*) density;

  if(m_hist == NULL)
  {
    m_hist = new QPixmap(geometry().width(), geometry().height());
    QPainter pmp(m_hist);
    pmp.fillRect(0, 0, geometry().width(), geometry().height(), Qt::lightGray);

    int xTick = (int) DENSITY_COUNT / geometry().width();
    int height = 0;

    //printf("xTick: %d, width: %d\n", xTick, geometry().width());

    pmp.translate(0, geometry().height());

      for(int i = 0; i < geometry().width(); i++)
      {
        for(int j = 0; j < xTick; j++)
        {
          height += m_density[i*xTick + j];
        }
        //printf("height: %d\n", height);

        height /= xTick;

        pmp.drawLine(i, 0, i, -height);
        height = 0;
      }

      pmp.end();
    }
}

void ShadeWidget::clearHistogram()
{
  histogramVisible = false;
  printf("Clear histogram\n"); 

  QPainter pmp(m_nohist);
    pmp.fillRect(0, 0, 20, 20, Qt::lightGray);
    pmp.end();

  delete m_hist;
  m_hist = NULL;

  this->update();
}


void ShadeWidget::paintEvent(QPaintEvent *)
{
  if(m_shade_type == ARGBShade)
  {
    QPalette pal = palette();
    if(!histogramVisible)
    {
      pal.setBrush(backgroundRole(), QBrush(*m_nohist));
    }
    else
    {
      pal.setBrush(backgroundRole(), QBrush(*m_hist));
    }

    setAutoFillBackground(true);
    setPalette(pal);
  }

  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()) 
  {
    // AlphaShade
    if (m_shade_type == ARGBShade) {
        m_shade = QImage(size(), QImage::Format_ARGB32);
        //m_shade = QImage(size(), QImage::Format_ARGB32_Premultiplied); // ARGB32_Premultiplied ??
        m_shade.fill(Qt::transparent);

        QPainter p(&m_shade);
        p.fillRect(rect(), m_alpha_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);

    } 
    else // RGB Shade
    {
        m_shade = QImage(size(), QImage::Format_RGB32);
        QLinearGradient shade(0, 0, 0, height());
        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);
    }
  }
}

---