예제 #1
0
QString Zones::summarize(int rnum, QVector<double> &time_in_zone) const
{
    assert(rnum < ranges.size());
    ZoneRange *range = ranges[rnum];
    assert(time_in_zone.size() == range->zones.size());
    QString summary;
    if(range->cp > 0){
        summary += "<table align=\"center\" width=\"70%\" border=\"0\">";
        summary += "<tr><td align=\"center\">";
        summary += tr("Critical Power: %1").arg(range->cp);
        summary += "</td></tr></table>";
    }
    summary += "<table align=\"center\" width=\"70%\" ";
    summary += "border=\"0\">";
    summary += "<tr>";
    summary += "<td align=\"center\">Zone</td>";
    summary += "<td align=\"center\">Description</td>";
    summary += "<td align=\"center\">Low</td>";
    summary += "<td align=\"center\">High</td>";
    summary += "<td align=\"center\">Time</td>";
    summary += "</tr>";
    QColor color = QApplication::palette().alternateBase().color();
    color = QColor::fromHsv(color.hue(), color.saturation() * 2, color.value());
    for (int zone = 0; zone < time_in_zone.size(); ++zone) {
        if (time_in_zone[zone] > 0.0) {
            QString name, desc;
            int lo, hi;
            zoneInfo(rnum, zone, name, desc, lo, hi);
            if (zone % 2 == 0)
                summary += "<tr bgcolor='" + color.name() + "'>";
            else
                summary += "<tr>";
            summary += QString("<td align=\"center\">%1</td>").arg(name);
            summary += QString("<td align=\"center\">%1</td>").arg(desc);
            summary += QString("<td align=\"center\">%1</td>").arg(lo);
            if (hi == INT_MAX)
                summary += "<td align=\"center\">MAX</td>";
            else
                summary += QString("<td align=\"center\">%1</td>").arg(hi);
            summary += QString("<td align=\"center\">%1</td>")
                .arg(time_to_string((unsigned) round(time_in_zone[zone])));
            summary += "</tr>";
        }
    }
    summary += "</table>";
    return summary;
}
예제 #2
0
ColorLabel::ColorLabel(QWidget *parent, const QColor &c, int id, const QString &text)
        : QLabel(parent)
        , m_id(id)
{
    setText(text);

    QPalette palette;
    palette.setColor(backgroundRole(), c);
    palette.setColor(QPalette::WindowText, !c.value());
    setPalette(palette);

    setAutoFillBackground(true);
    setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
    setFrameShape(StyledPanel);
    setFrameShadow(Sunken);
    setLineWidth(2);
}
예제 #3
0
QColor TimelineColorScheme::frameColor(bool present, bool active) const
{
    QColor color = Qt::transparent;

    if (present && !active) {
        color = m_d->baseColor;
    } else if (present && active) {
        QColor bgColor = qApp->palette().color(QPalette::Base);
        int darkenCoeff = bgColor.value() > 128 ? 130 : 80;
        color = m_d->baseColor.darker(darkenCoeff);
    } else if (!present && active) {
        QColor bgColor = qApp->palette().color(QPalette::Base);
        return blendColors(m_d->baseColor, bgColor, 0.2);
    }

    return color;
}
예제 #4
0
QPixmap BrushStyle::getSample(qreal scale, qreal alpha, bool selected, const QColor &color, bool emptyBackground)
{
	QPixmap backgroundPixmap( (selected) ? BRUSH_SAMPLE_SELECTED_BG : BRUSH_SAMPLE_BACKGROUND);

	if (emptyBackground)
		backgroundPixmap.fill(Qt::transparent);

	// Scale the sample
	QSizeF pointSize(BRUSH_SAMPLE_SIDE, BRUSH_SAMPLE_SIDE);

	if (scale != 1.0)
	{
		pointSize.setWidth(pointSize.width() * scale);
		pointSize.setHeight(pointSize.height() * scale);
	}

	// Apply color and alpha
	QColor alphaColor(Qt::black);

	if (color.isValid())
		alphaColor = color;

	if (alpha != 1.0)
		alphaColor.setAlphaF(alpha);
	
	// Draw sample in the middle of background
	QPainter painter(&backgroundPixmap);
	painter.setRenderHint(QPainter::Antialiasing);

	QRectF pointRect(QPointF(0, 0), pointSize);
	pointRect.moveTo(backgroundPixmap.width() / 2 - pointSize.width() / 2, backgroundPixmap.height() / 2 - pointSize.height() / 2);

	if (color.isValid() && color.value() > 210 && color.saturation() < 50)
		painter.setPen("#d0d0d0");
	else
		painter.setPen(Qt::NoPen);

	painter.setBrush(alphaColor);
	painter.drawEllipse(pointRect);

	painter.end();

	return backgroundPixmap;
}
예제 #5
0
void EmbeddedWebView::addCustomStylesheet(const QString &css)
{
    m_customCss = css;

    QWebSettings *s = settings();
    QString bgName, fgName;
    QColor bg = palette().color(QPalette::Active, QPalette::Base),
           fg = palette().color(QPalette::Active, QPalette::Text);

    switch (m_colorScheme) {
    case ColorScheme::BlackOnWhite:
        bgName = QStringLiteral("white !important");
        fgName = QStringLiteral("black !important");
        break;
    case ColorScheme::AdjustedSystem:
    {
        // This is HTML, and the authors of that markup are free to specify only the background colors, or only the foreground colors.
        // No matter what we pass from outside, there will always be some color which will result in unreadable text, and we can do
        // nothing except adding !important everywhere to fix this.
        // This code attempts to create a color which will try to produce exactly ugly results for both dark-on-bright and
        // bright-on-dark segments of text. However, it's pure alchemy and only a limited heuristics. If you do not like this, please
        // submit patches (or talk to the HTML producers, hehehe).
        const int v = bg.value();
        if (v < 96 && fg.value() > 128 + v/2) {
            int h,s,vv,a;
            fg.getHsv(&h, &s, &vv, &a) ;
            fg.setHsv(h, s, 128+v/2, a);
        }
        bgName = bg.name();
        fgName = fg.name();
        break;
    }
    case ColorScheme::System:
        bgName = bg.name();
        fgName = fg.name();
        break;
    }


    const QString urlPrefix(QStringLiteral("data:text/css;charset=utf-8;base64,"));
    const QString myColors(QStringLiteral("body { background-color: %1; color: %2; }\n").arg(bgName, fgName));
    s->setUserStyleSheetUrl(QString::fromUtf8(urlPrefix.toUtf8() + (myColors + m_customCss).toUtf8().toBase64()));
}
예제 #6
0
void KTColorPalette::setColor(const QBrush& brush)
{
	QColor color = brush.color();
	
	if(color.isValid())
	{
		if(m_type == Gradient)
		{
			m_gradientManager->setCurrentColor(color);
		}
		if(m_displayValueColor && m_outlineAndFillColors && m_colorPicker && m_nameColor && m_luminancePicker)
		{
			
			
			m_colorPicker->setCol(color.hue(), color.saturation ());
			if(m_type == Solid)
			{
				m_outlineAndFillColors->setCurrentColor(color);
			}
			m_nameColor->setText(color.name ());
			m_luminancePicker->setCol(color.hue(), color.saturation(), color.value());
			m_containerPalette->setColor( brush );
			m_displayValueColor->setColor(color);
		}
		
	}
	else if(brush.gradient())
	{
		
		QGradient gradient(*brush.gradient());
		changeBrushType(tr("Gradient"));

		m_containerPalette->setColor(gradient);
		m_outlineAndFillColors->setCurrentColor(gradient);
		if( sender () != m_gradientManager )
		{
			m_gradientManager->setGradient(gradient);
		}
		
	}
	emit brushChanged( m_outlineAndFillColors->foreground(),m_outlineAndFillColors->background() );
	
}
예제 #7
0
void ColorWheel::changeColor(const QColor &color)
{
    if (color == m_currentColor)
    {
        return;
    }
    if (color.hue() != m_currentColor.hue())
    {
        hueChanged(color.hue());
    }

    if (color.saturation() != m_currentColor.saturation() ||
        color.value() != m_currentColor.value() )
    {
        svChanged(color);
    }
    //emit colorChanged(color);
    update();
}
예제 #8
0
파일: RColor.cpp 프로젝트: fallenwind/qcad
/**
 * \return Highlighted color for the given color.
 */
RColor RColor::getHighlighted(const RColor& color, const QColor& bgColor, int minDist) {
    if (!color.isValid()) {
        return Qt::gray;
    }

    RColor ret = color;

    int vColor = color.value();
    int vBgColor = bgColor.value();

    // 0     vColor                      vBgColor              255
    // |--------^----------------------------^------------------|
    // |<--d1-->|<------------d2------------>|<-------d3------->|
    int d1 = qMin(vColor, vBgColor);
    //int d2 = qAbs(vColor - vBgColor);
    int d3 = 255 - qMax(vColor, vBgColor);

    // d3 is big enough: set value to max (highlight):
    if (d3>=minDist) {
        ret.setHsv(color.hue(), color.saturation(), 255);
    }

    // d1 is big enough: set value to half (lowlight):
    else if (d1>=minDist) {
        ret.setHsv(color.hue(), color.saturation(), qMin(vColor, vBgColor)/2);
    }

    // black on white:
    else if (vColor<32 && vBgColor>224) {
        ret.setHsv(color.hue(), color.saturation(), 160);
    }

    // d2 is the only significant distance, set value to medium:
    else if (vColor<vBgColor) {
        ret.setHsv(color.hue(), color.saturation(), qMin(vColor+minDist, 255));
    }
    else {
        ret.setHsv(color.hue(), color.saturation(), qMax(vColor-minDist, 0));
    }

    return ret;
}
예제 #9
0
void ColorButton::paintEvent(QPaintEvent *event)
{
    QToolButton::paintEvent(event);
    if (!isEnabled())
        return;

    QColor color = properColor(m_colorString);

    QPainter p(this);


    QRect r(0, 0, width() - 2, height() - 2);
    p.drawTiledPixmap(r.adjusted(1, 1, -1, -1), tilePixMap(9));
    if (isEnabled())
        p.setBrush(color);
    else
        p.setBrush(Qt::transparent);

    if (color.value() > 80)
        p.setPen(QColor(0x444444));
    else
        p.setPen(QColor(0x9e9e9e));
    p.drawRect(r.translated(1, 1));

    if (m_showArrow) {
        p.setRenderHint(QPainter::Antialiasing, true);
        QVector<QPointF> points;
        if (isChecked()) {
            points.append(QPointF(2, 3));
            points.append(QPointF(8, 3));
            points.append(QPointF(5, 9));
        } else {
            points.append(QPointF(8, 6));
            points.append(QPointF(2, 9));
            points.append(QPointF(2, 3));
        }
        p.translate(0.5, 0.5);
        p.setBrush(QColor(0xaaaaaa));
        p.setPen(QColor(0x444444));
        p.drawPolygon(points);
    }
}
예제 #10
0
void ColorWheel::mousePressEvent(QMouseEvent *event)
{
    QPoint lastPos = event->pos();
    if (mSquareRect.contains(lastPos))
    {
        mIsInWheel = false;
        mIsInSquare = true;
        QColor color = pickColor(lastPos);
        saturationChanged(color.saturation());
        valueChanged(color.value());

    }
    else if (mWheelRect.contains(lastPos))
    {
        mIsInWheel = true;
        mIsInSquare = false;
        QColor color = pickColor(lastPos);
        hueChanged(color.hue());
    }
}
예제 #11
0
void ColorWheel::setColor(const QColor &color)
{
    if (color == m_currentColor)
    {
        return;
    }
    if (color.hue() != m_currentColor.hue())
    {
        hueChanged(color.hue());
    }

    if (color.saturation() != m_currentColor.saturation() ||
        color.value() != m_currentColor.value() )
    {
        svChanged(color);
    }

    update();
    emit colorSelected(color);
}
예제 #12
0
		Transformation Transformation::createColor(QString color) {

			Transformation t;

			if (color.toLower() != "random") {
				QColor c(color);
				QColor hsv = c.toHsv();
				t.deltaH = hsv.hue();
				t.scaleAlpha = hsv.alpha()/255.0;
				t.scaleS = hsv.saturation()/255.0;
				t.scaleV = hsv.value()/255.0;
				t.absoluteColor = true;
			} else {
				t.deltaH = 1000;
				t.absoluteColor = true;
			}

			//Debug(QString("Abs Color: %1, %2, %3, %4").arg(t.deltaH).arg(t.scaleS).arg(t.scaleV).arg(t.scaleAlpha));

			return t;
		}
예제 #13
0
파일: RecSkinWidget.cpp 프로젝트: yefy/skp
void RecSkinColorPalette::getColor(const QColor &averageColor)
{
    isDrawEllipse = true;
    emit sigMousePressRGB(averageColor.rgb());
    hsvValue = averageColor.value();
    int width = 359;
    int height = 255;
    QImage temp(QSize(width, height), QImage::Format_ARGB32);
    for(int w = 0; w < width; ++w)
    {
        for(int h = 0; h < height; ++h)
        {
            QRgb rgb = QColor::fromHsv(w,h,hsvValue,255).rgb();
            QRgb r = qRgba(qRed(rgb), qGreen(rgb), qBlue(rgb), 255);
            temp.setPixel(w, h, r);
        }
    }

    drawImage = temp;
    QImage tempImage = drawImage.scaled(this->width(),this->height());

    bool isTrue = false;
    for(int i = 0; i < tempImage.width(); ++i)
    {
        for(int j = 0; j < tempImage.height(); ++j)
        {
            if(QColor::fromRgb(tempImage.pixel(i,j)) == averageColor)
            {
                mousePoint.setX(i);
                mousePoint.setY(j);
                isTrue = true;
                break;
            }

        }
        if(isTrue)
            break;
    }
    update();
}
예제 #14
0
void ColorWheel::setColor(QColor color)
{
    // this is a UI updating function, never emit any signals
    // and don't call any functions that will emit signals

    color = color.toHsv();

    if (color == mCurrentColor)
    {
        return;
    }

    if (color.hue() == -1) // grayscale color, keep the current hue
    {
        color.setHsv(mCurrentColor.hue(), color.saturation(), color.value(), color.alpha());
    }

    mCurrentColor = color;

    drawSquareImage(color.hue());
    update();
}
//----------------------------------------------------------------------------
// Update Chart
//----------------------------------------------------------------------------
void ReportPieChart::updateChart()
{
    mModel->setRowCount( mDataList.size() );
    if( mDataList.size() > 0 )
    {
        // Sort data items
        switch( mSortType )
        {
        case SORT_BY_BALANCE_DESCENDING:
            qSort( mDataList.begin(), mDataList.end(), pieDataSortByBalanceDescending );
            break;
        case SORT_BY_NAME_ASCENDING:
            qSort( mDataList.begin(), mDataList.end(), pieDataSortByNameAscending );
            break;
        }

        const int colorRange = COLOR_RANGE;
        int step = qMin( MAX_COLOR_STEP, (colorRange / mDataList.size()) );
        QColor baseColor = BASE_COLOR.toHsv();
        int h = baseColor.hue();
        int s = baseColor.saturation();
        int v = baseColor.value();
        for (int i = 0; i < mDataList.size(); ++i)
        {
            QColor secondaryLabelColor = ( mDataList[i].mValue > 0 ) ? QColor(Qt::darkGreen) : QColor(Qt::red);
            QColor nextColor;
            int newH = (h + step*i)%colorRange;
            nextColor.setHsv( newH, s, v );
            QString valueStr = Transaction::getAmountText( mDataList[i].mValue );
            mModel->setData( mModel->index(i,(int)PieView::COLUMN_LABEL), mDataList[i].mName );
            mModel->setData( mModel->index(i,(int)PieView::COLUMN_LABEL), nextColor, Qt::DecorationRole );
            mModel->setData( mModel->index(i,(int)PieView::COLUMN_VALUE), qAbs(mDataList[i].mValue) );
            mModel->setData( mModel->index(i,(int)PieView::COLUMN_SEC_LABEL), valueStr );
            mModel->setData( mModel->index(i,(int)PieView::COLUMN_SEC_LABEL), secondaryLabelColor, Qt::DecorationRole );
        }
    }
    updateViewport();
} // ReportPieChart::updateChart
QPointF ColorVolumeWidget::getColorPosition(const QColor &color) const
{
	qreal size = (this->direction == Horizontal) ? imageRect.width() : imageRect.height();
	qreal pos;

	if (this->mode == DarkOnly)
	{
		pos = color.valueF() * size;
	}
	else
	{
		if (color.value() < 255)
		{
			pos = (color.valueF()) * (size / 2);
		}
		else
		{
			pos = (255.0 - color.saturation()) / 255 * (size / 2) + size / 2;
		}
	}

	return (this->direction == Horizontal) ? QPointF(pos, 0) : QPointF(0, pos);
}
예제 #17
0
void ColorWheel::mouseMoveEvent(QMouseEvent* event)
{
    QPoint lastPos = event->pos();
    if (event->buttons() == Qt::NoButton)
    {
        return;
    }
    if (mIsInSquare)
    {
        if (lastPos.x() < mSquareRect.topLeft().x())
        {
            lastPos.setX(mSquareRect.topLeft().x());
        }
        else if (lastPos.x() > mSquareRect.bottomRight().x())
        {
            lastPos.setX(mSquareRect.bottomRight().x());
        }

        if (lastPos.y() < mSquareRect.topLeft().y())
        {
            lastPos.setY(mSquareRect.topLeft().y());
        }
        else if (lastPos.y() > mSquareRect.bottomRight().y())
        {
            lastPos.setY(mSquareRect.bottomRight().y());
        }

        QColor color = pickColor(lastPos);
        saturationChanged(color.saturation());
        valueChanged(color.value());
    }
    else if (mWheelRect.contains(lastPos) && mIsInWheel)
    {
        QColor color = pickColor(lastPos);
        hueChanged(color.hue());
    }
}
예제 #18
0
void ColorWheel::drawPicker(const QColor &color)
{
    QPainter painter(&m_wheelPixmap);
    painter.setRenderHint(QPainter::Antialiasing);

    QPoint squareTopLeft = m_squareRegion.boundingRect().topLeft();

    painter.translate(squareTopLeft.x(), squareTopLeft.y());

    QSize squareSize = m_squareRegion.boundingRect().size();

    qreal S = color.saturationF() * squareSize.width();
    qreal V = squareSize.height() - (color.valueF() * squareSize.height());

    QPen pen;
    pen.setWidth(3);
    if (color.saturation() > 30 || color.value() < 50)
    {
        pen.setColor(Qt::white);
    }
    painter.setPen(pen);

    painter.drawEllipse(S - 5, V - 5, 10, 10);
}
예제 #19
0
void tst_QColor::setHsv()
{
    QColor color;

    for (int A = 0; A <= USHRT_MAX; ++A) {
        {
            // 0-255
            int a = A >> 8;
            color.setHsv(0, 0, 0, a);
            QCOMPARE(color.alpha(), a);

            int h, s, v, a2;
            color.getHsv(&h, &s, &v, &a2);
            QCOMPARE(a2, a);
        }

        {
            // 0.0-1.0
            qreal a = A / qreal(USHRT_MAX);
            color.setHsvF(0.0, 0.0, 0.0, a);
            QCOMPARE(color.alphaF(), a);

            qreal h, s, v, a2;
            color.getHsvF(&h, &s, &v, &a2);
            QCOMPARE(a2, a);
        }
    }

    for (int H = 0; H < 36000; ++H) {
        {
            // 0-255
            int h = H / 100;

            color.setHsv(h, 0, 0, 0);
            QCOMPARE(color.hue(), h);

            int h2, s, v, a;
            color.getHsv(&h2, &s, &v, &a);
            QCOMPARE(h2, h);
        }

        {
            // 0.0-1.0
            qreal h = H / 36000.0;
            color.setHsvF(h, 0.0, 0.0, 0.0);
            QCOMPARE(color.hueF(), h);

            qreal h2, s, v, a;
            color.getHsvF(&h2, &s, &v, &a);
            QCOMPARE(h2, h);
        }
    }

    for (int S = 0; S <= USHRT_MAX; ++S) {
        {
            // 0-255
            int s = S >> 8;
            color.setHsv(0, s, 0, 0);
            QCOMPARE(color.saturation(), s);

            int h, s2, v, a;
            color.getHsv(&h, &s2, &v, &a);
            QCOMPARE(s2, s);
        }

        {
            // 0.0-1.0
            qreal s = S / qreal(USHRT_MAX);
            color.setHsvF(0.0, s, 0.0, 0.0);
            QCOMPARE(color.saturationF(), s);

            qreal h, s2, v, a;
            color.getHsvF(&h, &s2, &v, &a);
            QCOMPARE(s2, s);
        }
    }

    for (int V = 0; V <= USHRT_MAX; ++V) {
        {
            // 0-255
            int v = V >> 8;
            color.setHsv(0, 0, v, 0);
            QCOMPARE(color.value(),  v);

            int h, s, v2, a;
            color.getHsv(&h, &s, &v2, &a);
            QCOMPARE(v2, v);
        }

        {
            // 0.0-1.0
            qreal v = V / qreal(USHRT_MAX);
            color.setHsvF(0.0, 0.0, v, 0.0);
            QCOMPARE(color.valueF(), v);

            qreal h, s, v2, a;
            color.getHsvF(&h, &s, &v2, &a);
            QCOMPARE(v2, v);
        }
    }
}
예제 #20
0
void tst_QColor::dark()
{
    QColor gray(Qt::gray);
    QColor darker = gray.dark();
    QVERIFY(darker.value() < gray.value());
}
예제 #21
0
void tst_QColor::light()
{
    QColor gray(Qt::gray);
    QColor lighter = gray.light();
    QVERIFY(lighter.value() > gray.value());
}
예제 #22
0
void NMGChartSeries::paintArea(QPainter* painter,
                               const QStyleOptionGraphicsItem* option, 
                               QWidget* widget)
{
  int maxValuesInPartialPath = 1000;
  QColor hsv = baseColor.toHsv();
  hsv.setHsv(hsv.hue(), (int)(hsv.saturation()*0.25), hsv.value());

  if(isAveraged || isAccumulated)
  {
    painter->setBrush(hsv);
    paintLine(painter, option, widget); 
  }
  else
  { // not average nor accumulated
        
    /* NOTE A specific implementation is needed in this case because Graphics View doesn't
    * support correctly huge amount of points (X11 crashes). The design has been based in 
    * partial paths that are painted with brush (to paint the area), and later they are 
    * added to the complete path (to paint the boundary line).*/
    
    painter->setPen(Qt::NoPen);
    painter->setBrush(hsv);

    QPainterPath completedPath;
    double closingYpixel = ((minValues.y < 0.0 && 0.0 < maxValues.y) ? yWindowToViewport(0.0) :
                           ((minValues.y >= 0.0) ? yWindowToViewport(minValues.y) : 
                           yWindowToViewport(maxValues.y)));

    QList<Vertex>::const_iterator it = vertexList.constBegin();
    do
    {
      QPainterPath partialPath;
      QPainterPath partialPathModif;
      partialPath.moveTo(xWindowToViewport(it->x), -yWindowToViewport(it->y));
      
      for(int i = 1; i <= maxValuesInPartialPath && it != vertexList.constEnd(); i++, it++)
      {
        partialPath.lineTo(xWindowToViewport(it->x),-yWindowToViewport(it->y));
      }
      if(completedPath.isEmpty()) 
      {
        partialPathModif = partialPath;
        partialPathModif.lineTo(partialPathModif.currentPosition().rx(), -closingYpixel);
        partialPathModif.lineTo(xWindowToViewport(vertexList.first().x), -closingYpixel);
        
        completedPath = partialPath;
      }
      else
      {
        partialPathModif = partialPath;
        
        partialPathModif.lineTo(partialPath.currentPosition().rx(), -closingYpixel);
        partialPathModif.lineTo(completedPath.currentPosition().rx(), -closingYpixel);
        partialPathModif.lineTo(completedPath.currentPosition().rx(), 
                                completedPath.currentPosition().ry());
        
        completedPath.connectPath(partialPath);
      }
      partialPathModif.closeSubpath();
      painter->drawPath(partialPathModif);
    }
    while(it != vertexList.constEnd());
    
    painter->setPen(Qt::SolidLine);
    painter->setPen(baseColor);
    painter->setBrush(Qt::NoBrush);
    
    completedPath.lineTo(xWindowToViewport(vertexList.last().x), -closingYpixel);
    completedPath.lineTo(xWindowToViewport(vertexList.first().x), -closingYpixel);
    completedPath.closeSubpath();
    painter->drawPath(completedPath);
  }
}
예제 #23
0
void PaletteEditor::stopsChangedAction()
{
	static const int GradientBufferLastIdx = GradientBufferSize - 1;
	static const qreal dx  = 1.0 / GradientBufferSize;
	QSize s( m_gradientLabel->maximumSize() );
	QRect r( QPoint(0, 0), QSize(s.width(), (s.height() / 2.0 ) ) );
	QImage palette_image(s, QImage::Format_RGB32);
	QPainter painter(&palette_image);
	GradientStops stops(m_gradientStops->getStops());
	qStableSort(stops.begin(), stops.end(), GradientStop::lessThanGradientStopComparison);

	// now apply the ends and update the palette
	GradientStops ends( m_gradientEnds->getStops() );
	QGradient::Spread spread((QGradient::Spread)m_gradientSpreadGroup->checkedId());

	GradientStop n_stop(stops.first());
	QRgb ccolor = n_stop.second.rgba();
	for (int n = 0, fpos = n_stop.first * GradientBufferSize  ; n < fpos ; n++)
		m_gradient[qMin(n, GradientBufferLastIdx)] = ccolor;

	int last_stop_idx = stops.size() - 1;
	for (int begin_idx = 0; begin_idx < last_stop_idx ; begin_idx++)
	{
		GradientStop a = stops.at(begin_idx);
		GradientStop b = stops.at(begin_idx + 1);
		QColor ac = a.second;
		QColor bc = b.second;
		qreal d = ( b.first - a.first );
		qreal rdx, gdx, bdx, adx;
		if (b.colorspace == 0)
		{
			rdx = ( (bc.red()   - ac.red() )   / d ) * dx;
			gdx = ( (bc.green() - ac.green() ) / d ) * dx;
			bdx = ( (bc.blue()  - ac.blue() )  / d ) * dx;
			adx = ( (bc.alpha() - ac.alpha() ) / d ) * dx;
		}
		else
		{
			rdx = ( (bc.hue()        - ac.hue() )        / d ) * dx;
			gdx = ( (bc.saturation() - ac.saturation() ) / d ) * dx;
			bdx = ( (bc.value()      - ac.value() )      / d ) * dx;
			adx = ( (bc.alpha()      - ac.alpha() )      / d ) * dx;

			if (b.colorspace == 1)
			{
				if (rdx == 0.0)
					rdx = 180.0 / d * dx;
				else if (rdx < 0)
					rdx *= -1;
			}
			else
			{
				if (rdx == 0.0)
					rdx = -180.0 / d * dx;
				else if (rdx > 0)
					rdx *= -1;
			}
		}
		int n  = a.first * GradientBufferSize ;
		int nb = (int)(b.first * GradientBufferSize );
		for (int i = 0 ; n < nb ; i++, n++)
		{
			if (b.colorspace == 0)
			{
				m_gradient[n] = qRgba(
						qBound(0, (int)( ac.red()   + rdx * i + 0.5 ), 255),
						qBound(0, (int)( ac.green() + gdx * i + 0.5 ), 255),
						qBound(0, (int)( ac.blue()  + bdx * i + 0.5 ), 255),
						qBound(0, (int)( ac.alpha() + adx * i + 0.5 ), 255));
			}
			else
			{
				int h = (int)( ac.hue() + rdx * i + 0.5 );
				if (h < 0)
					h += 360;
				m_gradient[n] = QColor::fromHsv(h % 360,
						qBound(0, (int)( ac.saturation() + gdx * i + 0.5 ), 255),
						qBound(0, (int)( ac.value()  + bdx * i + 0.5 ), 255),
						qBound(0, (int)( ac.alpha() + adx * i + 0.5 ), 255)).rgba();
			}
		}
	}

	n_stop = stops.last();
	ccolor = n_stop.second.rgba();
	for (int n = n_stop.first * GradientBufferSize ; n < GradientBufferSize ; n++)
		m_gradient[n] = ccolor;

	qreal start(ends.at(0).first);
	qreal end(ends.at(1).first);
	int begin_idx = start * 256 ;
	int end_idx   = end   * 256 ;
	int ibuf_size = end_idx - begin_idx;
	flam3_palette_entry* ibuf = new flam3_palette_entry[ibuf_size]();

	// a very acute filter
	qreal c2 = 0.01;
	qreal c3 = 1.0;
	qreal c4 = 0.01;
	qreal norm = c2 + c3 + c4;
	qreal k = 0.0;
	qreal skip( (GradientBufferSize / 256.0) / qMax(qreal(1.0/GradientBufferSize), end - start) );
	for (int n = 0 ; n < ibuf_size ; n++, k += skip)
	{
		int j = k;
		QRgb a2( m_gradient[qBound(0, j + 0, GradientBufferLastIdx)] );
		QRgb a3( m_gradient[qMin(j + 1, GradientBufferLastIdx)] );
		QRgb a4( m_gradient[qMin(j + 2, GradientBufferLastIdx)] );

		ibuf[n].color[0] = (qRed(a2)*c2   + qRed(a3)*c3   + qRed(a4)*c4 )   / (norm * 255.);
		ibuf[n].color[1] = (qGreen(a2)*c2 + qGreen(a3)*c3 + qGreen(a4)*c4 ) / (norm * 255.);
		ibuf[n].color[2] = (qBlue(a2)*c2  + qBlue(a3)*c3  + qBlue(a4)*c4 )  / (norm * 255.);
		ibuf[n].color[3] = (qAlpha(a2)*c2 + qAlpha(a3)*c3 + qAlpha(a4)*c4 ) / (norm * 255.);
	}

	// update the gradient editor label
	painter.fillRect(QRect(QPoint(0,0), s), checkers);
	if (ibuf_size == 256)
	{
		for (int n = 0, h = s.height() ; n < 256 ; n++)
		{
			painter.setPen(QColor::fromRgbF(ibuf[n].color[0], ibuf[n].color[1], ibuf[n].color[2], ibuf[n].color[3]));
			painter.drawLine(n, 0, n, h);
		}
	}
	else
	{
		for (int n = 0, h = s.height(), j = 0 ; n < 256 ; n++, j += 4)
		{
			QRgb a2( m_gradient[qBound(0, j + 0, GradientBufferLastIdx)] );
			QRgb a3( m_gradient[qMin(j + 1, GradientBufferLastIdx)] );
			QRgb a4( m_gradient[qMin(j + 2, GradientBufferLastIdx)] );
			QRgb r((qRed(a2)*c2   + qRed(a3)*c3   + qRed(a4)*c4 )   / norm );
			QRgb g((qGreen(a2)*c2 + qGreen(a3)*c3 + qGreen(a4)*c4 ) / norm );
			QRgb b((qBlue(a2)*c2  + qBlue(a3)*c3  + qBlue(a4)*c4 )  / norm );
			QRgb a((qAlpha(a2)*c2 + qAlpha(a3)*c3 + qAlpha(a4)*c4 ) / norm );
			QColor c(r, g, b, a);
			painter.setPen(c);
			painter.drawLine(n, 0, n, h);
		}
	}
	m_gradientLabel->setPixmap(QPixmap::fromImage(palette_image));

	// Rescale the gradient colors into the palette with a simple filter
	if (spread == QGradient::PadSpread)
	{
		QRgb fc(m_gradient[0]);
		flam3_palette_entry e = { 0., { qRed(fc)/255., qGreen(fc)/255., qBlue(fc)/255., qAlpha(fc)/255. }};
		for (int n = 0 ; n < begin_idx ; n++)
			p[n] = e;

		for (int n = begin_idx, j = 0 ; n < end_idx ; n++, j++)
			p[n] = ibuf[j];

		fc = m_gradient[GradientBufferLastIdx];
		e = (flam3_palette_entry){ 1., { qRed(fc)/255., qGreen(fc)/ 255., qBlue(fc)/255., qAlpha(fc)/255. }};
		for (int n = end_idx ; n < 256 ; n++)
			p[n] = e;
	}
	else if (spread == QGradient::RepeatSpread)
	{
		for (int n = begin_idx, j = 0 ; n < 256 ; n++, j++)
			p[n] = ibuf[j % ibuf_size];
		for (int n = begin_idx - 1, j = ibuf_size * 4096 - 1 ; n >= 0 ; n--, j--)
			p[n] = ibuf[j % ibuf_size];
	}
	else if (spread == QGradient::ReflectSpread)
	{
		for (int n = begin_idx, j = 0, h = 4096*ibuf_size -1 ; n < begin_idx + ibuf_size ; n++, j++, h--)
		{
			for (int k = n, q = n + ibuf_size ; k < 256 ; k += 2*ibuf_size, q += 2*ibuf_size )
			{
				p[k] = ibuf[j % ibuf_size];
				if (q < 256)
					p[q] = ibuf[h % ibuf_size];
			}
		}
		for (int n = begin_idx - 1, j = ibuf_size * 4096 - 1, h = 0 ; n >= begin_idx - ibuf_size ; n--, j--, h++)
		{
			for (int k = n, q = n - ibuf_size ; k >= 0 ; k -= 2*ibuf_size, q -= 2*ibuf_size )
			{
				p[k] = ibuf[h % ibuf_size];
				if (q >= 0)
					p[q] = ibuf[j % ibuf_size];
			}
		}
	}
	delete[] ibuf;

	setPaletteView();
	emit paletteChanged();
}
예제 #24
0
NV_INT32 ComputeLineDistanceFilter (NV_F64_COORD2 lineStart, NV_F64_COORD2 lineEnd, nvMap *map, MISC *misc, OPTIONS *options)
{
  NV_INT32 numPointsWithin = 0;
  NV_FLOAT64 utmE, utmN;
  NV_BOOL hitMax = NVFalse;
  QColor color;


  QColor GetAVShotColor (NV_INT32 index, MISC *misc, OPTIONS *options);


  for (NV_INT32 i = 0; i < misc->abe_share->point_cloud_count; i++)
    {
      //  Only send over what's viewable on the screen
	  
      if ((!check_bounds (map, options, misc, i, NVTrue, NVFalse)) && misc->data[i].type == PFM_CZMIL_DATA)
        {
          NV_FLOAT64 x = misc->data[i].x * NV_DEG_TO_RAD;
          NV_FLOAT64 y = misc->data[i].y * NV_DEG_TO_RAD;

          pj_transform (misc->pj_latlon, misc->pj_utm, 1, 1, &x, &y, NULL);

          utmE = x;
          utmN = y;			

          Vertex ptOfInterest (utmE, utmN, 0.0f);

          Vertex closestPt = Vector::ClosestPtOnLine (Vertex (lineStart.x, lineStart.y, 0.0f), Vertex (lineEnd.x, lineEnd.y, 0.0f), ptOfInterest);


          // compare against our class variable not a constant

          if (Vector::GetDistance (ptOfInterest, closestPt) < options->distThresh)
            {
              // load up the shots array for AV

              misc->avb.shotArray[numPointsWithin].recordNumber = misc->data[i].rec;
              misc->avb.shotArray[numPointsWithin].subRecordNumber = misc->data[i].sub;
              misc->avb.shotArray[numPointsWithin].pfmHandle = misc->pfm_handle[misc->data[i].pfm];
              misc->avb.shotArray[numPointsWithin].fileNo = misc->data[i].file;
              misc->avb.shotArray[numPointsWithin].masterIdx = i;
              misc->avb.shotArray[numPointsWithin].type = misc->data[i].type;

              color = GetAVShotColor (i, misc, options);

              misc->avb.shotArray[numPointsWithin].colorH = color.hue ();
              misc->avb.shotArray[numPointsWithin].colorS = color.saturation();
              misc->avb.shotArray[numPointsWithin].colorV = color.value();

              numPointsWithin++;

              if (numPointsWithin == MAX_ATTRIBUTE_SHOTS)
                {
                  hitMax = NVTrue;


                  //  If we hit the maximum, send a message out for the user to re-select.

                  QString msg = QString (pfmEdit::tr ("The line specified results in more shots satisfying the threshold than can be held (MAX = %1).\n").arg
                                         (MAX_ATTRIBUTE_SHOTS) +
                                         pfmEdit::tr ("Please draw a shorter line or change the distance threshold parameter"));
                  QMessageBox::warning (0, pfmEdit::tr ("pfmEdit"), msg);
                  break;
                }
            }
        }
    }


  // lock shared memory and load up shots and notify AV new data is coming

  misc->abeShare->lock ();

  if (numPointsWithin > 0)
    {
      misc->av_dist_count = numPointsWithin;
      misc->av_dist_list = (NV_INT32 *) realloc (misc->av_dist_list, (misc->av_dist_count + 1) * sizeof (NV_INT32));

      if (misc->av_dist_list == NULL)
        {
          perror ("Allocating misc->av_dist_list memory in pfmEdit");
          exit (-1);
        }

      for (NV_INT32 i = 0; i < numPointsWithin; i++)
        {
          misc->abe_share->avShare.shots[i] = misc->avb.shotArray[i];
          misc->av_dist_list[i] = misc->avb.shotArray[i].masterIdx;
        }
    }

  misc->abe_share->avShare.numShots = numPointsWithin;
  misc->abe_share->avShare.avNewData = NVTrue;
  misc->abe_share->avShare.hitMax = hitMax;

  misc->abeShare->unlock ();

  return (numPointsWithin);
}
예제 #25
0
void QgsColorWheel::setColorFromPos( const QPointF pos )
{
  QPointF center = QPointF( width() / 2.0, height() / 2.0 );
  //line from center to mouse position
  QLineF line = QLineF( center.x(), center.y(), pos.x(), pos.y() );

  QColor newColor = QColor();

  int h, s, l, alpha;
  mCurrentColor.getHsl( &h, &s, &l, &alpha );
  //override hue with explicit hue, so we don't get -1 values from QColor for hue
  h = hue();

  if ( mClickedPart == QgsColorWheel::Triangle )
  {
    //adapted from equations at https://github.com/timjb/colortriangle/blob/master/colortriangle.js by Tim Baumann

    //position of event relative to triangle center
    double x = pos.x() - center.x();
    double y = pos.y() - center.y();

    double eventAngleRadians = line.angle() * M_PI / 180.0;
    double hueRadians = h * M_PI / 180.0;
    double rad0 = fmod( eventAngleRadians + 2.0 * M_PI - hueRadians, 2.0 * M_PI );
    double rad1 = fmod( rad0, (( 2.0 / 3.0 ) * M_PI ) ) - ( M_PI / 3.0 );
    double length = mWheelImage->width() / 2.0;
    double triangleLength = length - mWheelThickness - 1;

    double a = 0.5 * triangleLength;
    double b = tan( rad1 ) * a;
    double r = sqrt( x * x + y * y );
    double maxR = sqrt( a * a + b * b );

    if ( r > maxR )
    {
      double dx = tan( rad1 ) * r;
      double rad2 = atan( dx / maxR );
      rad2 = qMin( rad2, M_PI / 3.0 );
      rad2 = qMax( rad2, -M_PI / 3.0 );
      eventAngleRadians += rad2 - rad1;
      rad0 = fmod( eventAngleRadians + 2.0 * M_PI - hueRadians, 2.0 * M_PI );
      rad1 = fmod( rad0, (( 2.0 / 3.0 ) * M_PI ) ) - ( M_PI / 3.0 );
      b = tan( rad1 ) * a;
      r = sqrt( a * a + b * b );
    }

    double triangleSideLength = sqrt( 3.0 ) * triangleLength;
    double newL = (( -sin( rad0 ) * r ) / triangleSideLength ) + 0.5;
    double widthShare = 1.0 - ( fabs( newL - 0.5 ) * 2.0 );
    double newS = ((( cos( rad0 ) * r ) + ( triangleLength / 2.0 ) ) / ( 1.5 * triangleLength ) ) / widthShare;
    s = qMin( qRound( qMax( 0.0, newS ) * 255.0 ), 255 );
    l = qMin( qRound( qMax( 0.0, newL ) * 255.0 ), 255 );
    newColor = QColor::fromHsl( h, s, l );
    //explicitly set the hue again, so that it's exact
    newColor.setHsv( h, newColor.hsvSaturation(), newColor.value(), alpha );
  }
  else if ( mClickedPart == QgsColorWheel::Wheel )
  {
    //use hue angle
    s = mCurrentColor.hsvSaturation();
    int v = mCurrentColor.value();
    int newHue = line.angle();
    newColor = QColor::fromHsv( newHue, s, v, alpha );
    //hue has changed, need to redraw triangle
    mTriangleDirty = true;
  }

  if ( newColor.isValid() && newColor != mCurrentColor )
  {
    //color has changed
    mCurrentColor = QColor( newColor );

    if ( mCurrentColor.hue() >= 0 )
    {
      //color has a valid hue, so update the QgsColorWidget's explicit hue
      mExplicitHue = mCurrentColor.hue();
    }

    update();
    emit colorChanged( mCurrentColor );
  }
}
예제 #26
0
void QgsColorRampWidget::paintEvent( QPaintEvent *event )
{
  Q_UNUSED( event );
  QPainter painter( this );

  if ( mShowFrame )
  {
    //draw frame
    QStyleOptionFrameV3 option;
    option.initFrom( this );
    option.state = hasFocus() ? QStyle::State_KeyboardFocusChange : QStyle::State_None;
    style()->drawPrimitive( QStyle::PE_Frame, &option, &painter );
  }

  if ( hasFocus() )
  {
    //draw focus rect
    QStyleOptionFocusRect option;
    option.initFrom( this );
    option.state = QStyle::State_KeyboardFocusChange;
    style()->drawPrimitive( QStyle::PE_FrameFocusRect, &option, &painter );
  }

  if ( mComponent != QgsColorWidget::Alpha )
  {
    int maxValue = ( mOrientation == QgsColorRampWidget::Horizontal ? width() : height() ) - 1 - 2 * mMargin;
    QColor color = QColor( mCurrentColor );
    color.setAlpha( 255 );
    QPen pen;
    pen.setWidth( 0 );
    painter.setPen( pen );
    painter.setBrush( Qt::NoBrush );

    //draw background ramp
    for ( int c = 0; c <= maxValue; ++c )
    {
      int colorVal = componentRange() * ( double )c / maxValue;
      //vertical sliders are reversed
      if ( mOrientation == QgsColorRampWidget::Vertical )
      {
        colorVal = componentRange() - colorVal;
      }
      alterColor( color, mComponent, colorVal );
      if ( color.hue() < 0 )
      {
        color.setHsv( hue(), color.saturation(), color.value() );
      }
      pen.setColor( color );
      painter.setPen( pen );
      if ( mOrientation == QgsColorRampWidget::Horizontal )
      {
        //horizontal
        painter.drawLine( c + mMargin, mMargin, c + mMargin, height() - mMargin - 1 );
      }
      else
      {
        //vertical
        painter.drawLine( mMargin, c + mMargin, width() - mMargin - 1, c + mMargin );
      }
    }
  }
  else if ( mComponent == QgsColorWidget::Alpha )
  {
    //alpha ramps are drawn differently
    //start with the checkboard pattern
    QBrush checkBrush = QBrush( transparentBackground() );
    painter.setBrush( checkBrush );
    painter.setPen( Qt::NoPen );
    painter.drawRect( mMargin, mMargin, width() - 2 * mMargin - 1, height() - 2 * mMargin - 1 );
    QLinearGradient colorGrad;
    if ( mOrientation == QgsColorRampWidget::Horizontal )
    {
      //horizontal
      colorGrad = QLinearGradient( mMargin, 0, width() - mMargin - 1, 0 );
    }
    else
    {
      //vertical
      colorGrad = QLinearGradient( 0, mMargin, 0, height() - mMargin - 1 );
    }
    QColor transparent = QColor( mCurrentColor );
    transparent.setAlpha( 0 );
    colorGrad.setColorAt( 0, transparent );
    QColor opaque = QColor( mCurrentColor );
    opaque.setAlpha( 255 );
    colorGrad.setColorAt( 1, opaque );
    QBrush colorBrush = QBrush( colorGrad );
    painter.setBrush( colorBrush );
    painter.drawRect( mMargin, mMargin, width() - 2 * mMargin - 1, height() - 2 * mMargin - 1 );
  }

  if ( mOrientation == QgsColorRampWidget::Horizontal )
  {
    //draw marker triangles for horizontal ramps
    painter.setRenderHint( QPainter::Antialiasing );
    painter.setBrush( QBrush( Qt::black ) );
    painter.setPen( Qt::NoPen );
    painter.translate( mMargin + ( width() - 2 * mMargin ) * ( double )componentValue() / componentRange(), mMargin - 1 );
    painter.drawPolygon( mTopTriangle );
    painter.translate( 0, height() - mMargin - 2 );
    painter.setBrush( QBrush( Qt::white ) );
    painter.drawPolygon( mBottomTriangle );
    painter.end();
  }
  else
  {
    //draw cross lines for vertical ramps
    int ypos = mMargin + ( height() - 2 * mMargin - 1 ) - ( height() - 2 * mMargin - 1 ) * ( double )componentValue() / componentRange();
    painter.setBrush( Qt::white );
    painter.setPen( Qt::NoPen );
    painter.drawRect( mMargin, ypos - 1, width() - 2 * mMargin - 1, 3 );
    painter.setPen( Qt::black );
    painter.drawLine( mMargin, ypos, width() - mMargin - 1, ypos );
  }
}
예제 #27
0
파일: tools.cpp 프로젝트: perihelion/basket
bool Tools::tooDark(const QColor &color)
{
	return color.value() < 175;
}
예제 #28
0
static inline QColor invertColor(const QColor color)
{
    QColor c = color.toHsv();
    c.setHsv(c.hue(), c.saturation(), 255 - c.value());
    return c;
}
예제 #29
0
void ManhattanStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                   QPainter *painter, const QWidget *widget) const
{
    if (!panelWidget(widget))
        return QProxyStyle::drawPrimitive(element, option, painter, widget);

    bool animating = (option->state & State_Animating);
    int state = option->state;
    QRect rect = option->rect;
    QRect oldRect;
    QRect newRect;
    if (widget && (element == PE_PanelButtonTool) && !animating) {
        QWidget *w = const_cast<QWidget *> (widget);
        int oldState = w->property("_q_stylestate").toInt();
        oldRect = w->property("_q_stylerect").toRect();
        newRect = w->rect();
        w->setProperty("_q_stylestate", (int)option->state);
        w->setProperty("_q_stylerect", w->rect());

        // Determine the animated transition
        bool doTransition = ((state & State_On)         != (oldState & State_On)     ||
                             (state & State_MouseOver)  != (oldState & State_MouseOver));
        if (oldRect != newRect)
        {
            doTransition = false;
            d->animator.stopAnimation(widget);
        }

        if (doTransition) {
            QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);
            QImage endImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);
            Animation *anim = d->animator.widgetAnimation(widget);
            QStyleOption opt = *option;
            opt.state = (QStyle::State)oldState;
            opt.state |= State_Animating;
            startImage.fill(0);
            Transition *t = new Transition;
            t->setWidget(w);
            QPainter startPainter(&startImage);
            if (!anim) {
                drawPrimitive(element, &opt, &startPainter, widget);
            } else {
                anim->paint(&startPainter, &opt);
                d->animator.stopAnimation(widget);
            }
            QStyleOption endOpt = *option;
            endOpt.state |= State_Animating;
            t->setStartImage(startImage);
            d->animator.startAnimation(t);
            endImage.fill(0);
            QPainter endPainter(&endImage);
            drawPrimitive(element, &endOpt, &endPainter, widget);
            t->setEndImage(endImage);
            if (oldState & State_MouseOver)
                t->setDuration(150);
            else
                t->setDuration(75);
            t->setStartTime(QTime::currentTime());
        }
    }

    switch (element) {
    case PE_IndicatorDockWidgetResizeHandle:
        painter->fillRect(option->rect, creatorTheme()->color(Theme::DockWidgetResizeHandleColor));
        break;
    case PE_FrameDockWidget:
        QCommonStyle::drawPrimitive(element, option, painter, widget);
        break;
    case PE_PanelLineEdit:
        {
            painter->save();

            // Fill the line edit background
            QRect filledRect = option->rect.adjusted(1, 1, -1, -1);
            painter->setBrushOrigin(filledRect.topLeft());
            painter->fillRect(filledRect, option->palette.base());

            if (option->state & State_Enabled)
                StyleHelper::drawCornerImage(d->lineeditImage, painter, option->rect, 5, 5, 5, 5);
            else
                StyleHelper::drawCornerImage(d->lineeditImage_disabled, painter, option->rect, 5, 5, 5, 5);

            if (option->state & State_HasFocus || option->state & State_MouseOver) {
                QColor hover = StyleHelper::baseColor();
                if (state & State_HasFocus)
                    hover.setAlpha(100);
                else
                    hover.setAlpha(50);

                painter->setPen(QPen(hover, 1));
                painter->drawRect(QRectF(option->rect).adjusted(1.5, 1.5, -1.5, -1.5));
            }
            painter->restore();
        }
        break;

    case PE_FrameStatusBarItem:
        break;

    case PE_PanelButtonTool: {
            Animation *anim = d->animator.widgetAnimation(widget);
            if (!animating && anim) {
                anim->paint(painter, option);
            } else {
                bool pressed = option->state & State_Sunken || option->state & State_On;
                QColor shadow(0, 0, 0, 30);
                painter->setPen(shadow);
                if (pressed) {
                    QColor shade = option->palette.base().color();
                    shade.setHsv(shade.hue(), shade.saturation(), 255 - shade.value(), 40);
                    painter->fillRect(rect, shade);
                    const QRectF borderRect = QRectF(rect).adjusted(0.5, 0.5, -0.5, -0.5);
                    painter->drawLine(borderRect.topLeft() + QPointF(1, 0), borderRect.topRight() - QPointF(1, 0));
                    painter->drawLine(borderRect.topLeft(), borderRect.bottomLeft());
                    painter->drawLine(borderRect.topRight(), borderRect.bottomRight());
                } else if (option->state & State_Enabled && option->state & State_MouseOver) {
                    painter->fillRect(rect, creatorTheme()->color(Theme::PanelButtonToolBackgroundColorHover));
                } else if (widget && widget->property("highlightWidget").toBool()) {
                    QColor shade(0, 0, 0, 128);
                    painter->fillRect(rect, shade);
                }
                if (option->state & State_HasFocus && (option->state & State_KeyboardFocusChange)) {
                    QColor highlight = option->palette.highlight().color();
                    highlight.setAlphaF(0.4);
                    painter->setPen(QPen(highlight.lighter(), 1));
                    highlight.setAlphaF(0.3);
                    painter->setBrush(highlight);
                    painter->setRenderHint(QPainter::Antialiasing);
                    const QRectF rect = option->rect;
                    painter->drawRoundedRect(rect.adjusted(2.5, 2.5, -2.5, -2.5), 2, 2);
                }
           }
        }
        break;

    case PE_PanelStatusBar:
        {
            if (creatorTheme()->widgetStyle() == Theme::StyleDefault) {
                painter->save();
                QLinearGradient grad = StyleHelper::statusBarGradient(rect);
                painter->fillRect(rect, grad);
                const QRectF borderRect = QRectF(rect).adjusted(0.5, 0.5, -0.5, -0.5);
                painter->setPen(QColor(255, 255, 255, 60));
                painter->drawLine(borderRect.topLeft() + QPointF(0, 1),
                                  borderRect.topRight()+ QPointF(0, 1));
                painter->setPen(StyleHelper::borderColor().darker(110)); //TODO: make themable
                painter->drawLine(borderRect.topLeft(), borderRect.topRight());
                painter->restore();
            } else {
                painter->fillRect(rect, creatorTheme()->color(Theme::PanelStatusBarBackgroundColor));
            }
        }
        break;

    case PE_IndicatorToolBarSeparator:
        {
            QColor separatorColor = StyleHelper::borderColor();
            separatorColor.setAlpha(100);
            painter->setPen(separatorColor);
            const int margin = 6;
            if (option->state & State_Horizontal) {
                const int offset = rect.width()/2;
                painter->drawLine(rect.bottomLeft().x() + offset,
                            rect.bottomLeft().y() - margin,
                            rect.topLeft().x() + offset,
                            rect.topLeft().y() + margin);
            } else { //Draw vertical separator
                const int offset = rect.height()/2;
                painter->setPen(QPen(option->palette.background().color().darker(110)));
                painter->drawLine(rect.topLeft().x() + margin ,
                            rect.topLeft().y() + offset,
                            rect.topRight().x() - margin,
                            rect.topRight().y() + offset);
            }
        }
        break;

    case PE_IndicatorToolBarHandle:
        {
            bool horizontal = option->state & State_Horizontal;
            painter->save();
            QPainterPath path;
            int x = option->rect.x() + (horizontal ? 2 : 6);
            int y = option->rect.y() + (horizontal ? 6 : 2);
            static const int RectHeight = 2;
            if (horizontal) {
                while (y < option->rect.height() - RectHeight - 6) {
                    path.moveTo(x, y);
                    path.addRect(x, y, RectHeight, RectHeight);
                    y += 6;
                }
            } else {
                while (x < option->rect.width() - RectHeight - 6) {
                    path.moveTo(x, y);
                    path.addRect(x, y, RectHeight, RectHeight);
                    x += 6;
                }
            }

            painter->setPen(Qt::NoPen);
            QColor dark = StyleHelper::borderColor();
            dark.setAlphaF(0.4);

            QColor light = StyleHelper::baseColor();
            light.setAlphaF(0.4);

            painter->fillPath(path, light);
            painter->save();
            painter->translate(1, 1);
            painter->fillPath(path, dark);
            painter->restore();
            painter->translate(3, 3);
            painter->fillPath(path, light);
            painter->translate(1, 1);
            painter->fillPath(path, dark);
            painter->restore();
        }
        break;
    case PE_IndicatorArrowUp:
    case PE_IndicatorArrowDown:
    case PE_IndicatorArrowRight:
    case PE_IndicatorArrowLeft:
        {
            StyleHelper::drawArrow(element, painter, option);
        }
        break;

    default:
        QProxyStyle::drawPrimitive(element, option, painter, widget);
        break;
    }
}
예제 #30
0
void LoadShotsWithinAVBox (MISC *misc, OPTIONS *options, nvMap *map, NV_I32_COORD2 targetPt)
{
  NV_FLOAT64 dz;
  NV_INT32 xyz_x, xyz_y, xyz_z, lock_point;
  NV_I32_COORD2 llSquare, urSquare;
  int numShots = 0;
  NV_BOOL hitMax = NVFalse;

  QColor color;

  QColor GetAVShotColor (NV_INT32 index, MISC *misc, OPTIONS *options);


  if (misc->nearest_point != -1)
    {
      llSquare.x = targetPt.x - misc->avb.avInterfacePixelBuffer;
      llSquare.y = targetPt.y + misc->avb.avInterfacePixelBuffer;

      urSquare.x = targetPt.x + misc->avb.avInterfacePixelBuffer;
      urSquare.y = targetPt.y - misc->avb.avInterfacePixelBuffer;


      //  load the target pt first

      lock_point = misc->nearest_point;


      //  Get the screen coordinates of the primary cursor.  Make sure it is within the AV ROI box.
      //  It is possible that it could be outside in the event that everything within the AV box is deleted by the AV

      map->map_to_screen (1, &misc->data[lock_point].x, &misc->data[lock_point].y, &dz, &xyz_x, &xyz_y, &xyz_z);

      if ((xyz_x <= urSquare.x) && (xyz_x >= llSquare.x) && (xyz_y >= urSquare.y) && (xyz_y <= llSquare.y) && misc->data[lock_point].type == PFM_CZMIL_DATA)
        {
          misc->avb.shotArray[numShots].recordNumber = misc->data[lock_point].rec;
          misc->avb.shotArray[numShots].pfmHandle = misc->pfm_handle[misc->data[lock_point].pfm];
          misc->avb.shotArray[numShots].fileNo = misc->data[lock_point].file;
          misc->avb.shotArray[numShots].type = misc->data[lock_point].type;


          //  Save the master idx

          misc->avb.shotArray[numShots].masterIdx = lock_point;

          color = GetAVShotColor (lock_point, misc, options);

          misc->avb.shotArray[numShots].colorH = color.hue ();
          misc->avb.shotArray[numShots].colorS = color.saturation();
          misc->avb.shotArray[numShots].colorV = color.value();

          numShots++;
        }


      for (NV_INT32 i = 0 ; i < misc->abe_share->point_cloud_count ; i++)
        {
          if (i != lock_point)
            {
              //  Check for single line display.

              if (!misc->num_lines || check_line (misc, misc->data[i].line))
                {
                  //  Do not use null points.  Do not use invalid points unless the 
                  //  display_invalid flag is set.  Do not check points that are not on the 
                  //  display.

                  if (!check_bounds (map, options, misc, i, NVTrue, NVFalse))
                    {
                      map->map_to_screen (1, &misc->data[i].x, &misc->data[i].y, &dz, &xyz_x, &xyz_y, &xyz_z);


                      //  Check the area and the data type ('cause there might be mixed types in the editor).

                      if ((xyz_x <= urSquare.x) && (xyz_x >= llSquare.x) && (xyz_y >= urSquare.y) && (xyz_y <= llSquare.y) &&
                          misc->data[i].type == PFM_CZMIL_DATA)
                        {
                          if (numShots == MAX_ATTRIBUTE_SHOTS)
                            {
                              hitMax = NVTrue;
                              break;
                            }

                          misc->avb.shotArray[numShots].recordNumber = misc->data[i].rec;
                          misc->avb.shotArray[numShots].subRecordNumber = misc->data[i].sub;
                          misc->avb.shotArray[numShots].pfmHandle = misc->pfm_handle[misc->data[i].pfm];
                          misc->avb.shotArray[numShots].fileNo = misc->data[i].file;
                          misc->avb.shotArray[numShots].masterIdx = i;
                          misc->avb.shotArray[numShots].type = misc->data[i].type;

                          color = GetAVShotColor (i, misc, options);

                          misc->avb.shotArray[numShots].colorH = color.hue ();
                          misc->avb.shotArray[numShots].colorS = color.saturation();
                          misc->avb.shotArray[numShots].colorV = color.value();

                          numShots++;
                        }
                    }
                }
            }
        }
    }

  misc->abeShare->lock ();

  for (int i = 0; i < numShots; i++) misc->abe_share->avShare.shots[i] = misc->avb.shotArray[i];

  misc->abe_share->avShare.numShots = numShots;
  misc->abe_share->avShare.avNewData = NVTrue;
  misc->abe_share->avShare.hitMax = hitMax;

  misc->abeShare->unlock ();
}