/*!
Store a path command in the command list
\sa QPaintEngine::drawPath()
*/
void QwtGraphic::drawPath( const QPainterPath &path )
{
const QPainter *painter = paintEngine()->painter();
if ( painter == NULL )
return;
d_data->commands += QwtPainterCommand( path );
if ( !path.isEmpty() )
{
const QPainterPath scaledPath = painter->transform().map( path );
QRectF pointRect = scaledPath.boundingRect();
QRectF boundingRect = pointRect;
if ( painter->pen().style() != Qt::NoPen
&& painter->pen().brush().style() != Qt::NoBrush )
{
boundingRect = qwtStrokedPathRect( painter, path );
}
updateControlPointRect( pointRect );
updateBoundingRect( boundingRect );
d_data->pathInfos += PathInfo( pointRect,
boundingRect, qwtHasScalablePen( painter ) );
}
}
/*!
\overload
Creates and returns a QPainterPath object that is a copy of the
given \a path, mapped into the coordinate system defined by this
matrix.
*/
QPainterPath QMatrix::map(const QPainterPath &path) const
{
if (path.isEmpty())
return QPainterPath();
QPainterPath copy = path;
// Translate or identity
if (_m11 == 1.0 && _m22 == 1.0 && _m12 == 0.0 && _m21 == 0.0) {
// Translate
if (_dx != 0.0 || _dy != 0.0) {
copy.detach();
for (int i=0; i<path.elementCount(); ++i) {
QPainterPath::Element &e = copy.d_ptr->elements[i];
e.x += _dx;
e.y += _dy;
}
}
// Full xform
} else {
copy.detach();
for (int i=0; i<path.elementCount(); ++i) {
QPainterPath::Element &e = copy.d_ptr->elements[i];
qreal fx = e.x, fy = e.y;
e.x = _m11*fx + _m21*fy + _dx;
e.y = _m12*fx + _m22*fy + _dy;
}
}
return copy;
}
void CSharedPainterScene::drawLastItemBorderRect( void )
{
if( ! lastAddItem_ )
return;
if( ! lastAddItem_->drawingObject() )
return;
QAbstractGraphicsShapeItem* i = reinterpret_cast<QAbstractGraphicsShapeItem *>(lastAddItem_->drawingObject());
if( ! i )
return;
// setting style..
QPainterPath path = createCoveringBorderPath( lastItemBorderType_, i );
if ( path.isEmpty() )
return;
clearLastItemBorderRect();
QAbstractGraphicsShapeItem* lastBorderItem = addPath( path );
lastBorderItem->setPen( QPen( Util::getComplementaryColor(backgroundColor_, penColor() ), 2) );
lastBorderItem->setZValue( currentZValue() );
lastCoverGraphicsItem_ = lastBorderItem;
// clear
lastTempBlinkShowFlag_ = true;
lastTimeValue_ = QDateTime::currentDateTime().toMSecsSinceEpoch();
timeoutRemoveLastCoverItem_ = DEFAULT_TIMEOUT_REMOVE_LAST_COVER_ITEM;
}
void QPaintEngineEx::drawStaticTextItem(QStaticTextItem *staticTextItem)
{
QPainterPath path;
#ifndef Q_WS_MAC
path.setFillRule(Qt::WindingFill);
#endif
if (staticTextItem->numGlyphs == 0)
return;
QFontEngine *fontEngine = staticTextItem->fontEngine();
fontEngine->addGlyphsToPath(staticTextItem->glyphs, staticTextItem->glyphPositions,
staticTextItem->numGlyphs, &path, 0);
if (!path.isEmpty()) {
QPainterState *s = state();
QPainter::RenderHints oldHints = s->renderHints;
bool changedHints = false;
if (bool(oldHints & QPainter::TextAntialiasing)
&& !bool(fontEngine->fontDef.styleStrategy & QFont::NoAntialias)
&& !bool(oldHints & QPainter::Antialiasing)) {
s->renderHints |= QPainter::Antialiasing;
renderHintsChanged();
changedHints = true;
}
fill(qtVectorPathForPath(path), s->pen.color());
if (changedHints) {
s->renderHints = oldHints;
renderHintsChanged();
}
}
}
void QgsCircularString::addToPainterPath( QPainterPath &path ) const
{
int nPoints = numPoints();
if ( nPoints < 1 )
{
return;
}
if ( path.isEmpty() || path.currentPosition() != QPointF( mX[0], mY[0] ) )
{
path.moveTo( QPointF( mX[0], mY[0] ) );
}
for ( int i = 0; i < ( nPoints - 2 ) ; i += 2 )
{
QgsPointSequence pt;
segmentize( QgsPointV2( mX[i], mY[i] ), QgsPointV2( mX[i + 1], mY[i + 1] ), QgsPointV2( mX[i + 2], mY[i + 2] ), pt );
for ( int j = 1; j < pt.size(); ++j )
{
path.lineTo( pt.at( j ).x(), pt.at( j ).y() );
}
//arcTo( path, QPointF( mX[i], mY[i] ), QPointF( mX[i + 1], mY[i + 1] ), QPointF( mX[i + 2], mY[i + 2] ) );
}
//if number of points is even, connect to last point with straight line (even though the circular string is not valid)
if ( nPoints % 2 == 0 )
{
path.lineTo( mX[ nPoints - 1 ], mY[ nPoints - 1 ] );
}
}
void TestSnapStrategy::testOrhogonalDecoration()
{
//Making sure the decoration is created but is empty
OrthogonalSnapStrategy toTestTwo;
const QPointF paramMousePositionTwo(3,3);
MockShapeController fakeShapeControllerBaseTwo;
MockCanvas fakeKoCanvasBaseTwo(&fakeShapeControllerBaseTwo);
KoShapeManager *fakeShapeManager = fakeKoCanvasBaseTwo.shapeManager();
MockShape fakeShapeOne;
QList<QPointF> firstSnapPointList;
firstSnapPointList.push_back(QPointF(1,2));
firstSnapPointList.push_back(QPointF(2,2));
firstSnapPointList.push_back(QPointF(3,2));
firstSnapPointList.push_back(QPointF(4,2));
fakeShapeOne.snapData().setSnapPoints(firstSnapPointList);
fakeShapeOne.isVisible(true);
fakeShapeManager->addShape(&fakeShapeOne);
KoSnapGuide aKoSnapGuideTwo(&fakeKoCanvasBaseTwo);
KoSnapProxy paramProxyTwo(&aKoSnapGuideTwo);
//Make sure at least one point in firstSnapPointList is within this distance of
//paramMousePoint to trigger the branches if (dx < minHorzDist && dx < maxSnapDistance)
//and if (dy < minVertDist && dy < maxSnapDistance) WHICH IS WHERE minVertDist and minHorzDist
//ARE CHANGED FROM HUGE_VAL
qreal paramSnapDistanceTwo = 4;
toTestTwo.snap(paramMousePositionTwo, ¶mProxyTwo, paramSnapDistanceTwo);
KoViewConverter irrelevantParameter;
QPainterPath resultingDecoration = toTestTwo.decoration(irrelevantParameter);
QVERIFY( resultingDecoration.isEmpty() );
}
int QTextureGlyphCache::calculateSubPixelPositionCount(glyph_t glyph) const
{
// Test 12 different subpixel positions since it factors into 3*4 so it gives
// the coverage we need.
QList<QImage> images;
for (int i=0; i<12; ++i) {
QImage img = textureMapForGlyph(glyph, QFixed::fromReal(i / 12.0));
if (images.isEmpty()) {
QPainterPath path;
QFixedPoint point;
m_current_fontengine->addGlyphsToPath(&glyph, &point, 1, &path, QTextItem::RenderFlags());
// Glyph is space, return 0 to indicate that we need to keep trying
if (path.isEmpty())
break;
images.append(img);
} else {
bool found = false;
for (int j=0; j<images.size(); ++j) {
if (images.at(j) == img) {
found = true;
break;
}
}
if (!found)
images.append(img);
}
}
return images.size();
}
void QPaintEngineEx::clip(const QPainterPath &path, Qt::ClipOperation op)
{
if (path.isEmpty()) {
QVectorPath vp(0, 0);
clip(vp, op);
} else {
clip(qtVectorPathForPath(path), op);
}
}
void QOutlineMapper::clipElements(const QPointF *elements,
const QPainterPath::ElementType *types,
int element_count)
{
// We could save a bit of time by actually implementing them fully
// instead of going through convenience functionallity, but since
// this part of code hardly every used, it shouldn't matter.
m_in_clip_elements = true;
QPainterPath path;
if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
path.setFillRule(Qt::WindingFill);
if (types) {
for (int i=0; i<element_count; ++i) {
switch (types[i]) {
case QPainterPath::MoveToElement:
path.moveTo(elements[i]);
break;
case QPainterPath::LineToElement:
path.lineTo(elements[i]);
break;
case QPainterPath::CurveToElement:
path.cubicTo(elements[i], elements[i+1], elements[i+2]);
i += 2;
break;
default:
break;
}
}
} else {
path.moveTo(elements[0]);
for (int i=1; i<element_count; ++i)
path.lineTo(elements[i]);
}
QPainterPath clipPath;
clipPath.addRect(m_clip_rect);
QPainterPath clippedPath = path.intersected(clipPath);
uint old_txop = m_txop;
m_txop = QTransform::TxNone;
if (clippedPath.isEmpty())
m_valid = false;
else
convertPath(clippedPath);
m_txop = old_txop;
m_in_clip_elements = false;
}
QString QTikzPicturePrivate::toTikzPath(const QPainterPath & path) const
{
if (path.isEmpty()) return QString();
QStringList pathList;
QString currentPath;
int currentControlPoint = 0;
// convert QPainterPath to a TikZ path string
for (int i = 0; i < path.elementCount(); i++) {
const QPainterPath::Element & element = path.elementAt(i);
switch (element.type) {
case QPainterPath::MoveToElement: {
// close current path + append to path list
if (!currentPath.isEmpty()) {
currentPath += " -- cycle";
pathList << currentPath;
}
// indent with spaces for better readability
const char * indentString = pathList.count() ? " " : "";
// start new path
currentPath.clear();
currentPath += indentString + toCoord(element);
break;
}
case QPainterPath::LineToElement: {
currentPath += " -- " + toCoord(element);
break;
}
case QPainterPath::CurveToElement: {
currentPath += " .. controls " + toCoord(element);
currentControlPoint = 1;
break;
}
case QPainterPath::CurveToDataElement: {
if (currentControlPoint == 1) {
currentPath += " and " + toCoord(element);
++currentControlPoint;
} else if (currentControlPoint == 2) {
currentPath += " .. " + toCoord(element);
currentControlPoint = 0;
}
break;
}
}
}
return pathList.join("\n");
}
void GraphicsUtils::qt_graphicsItem_highlightSelected(QPainter *painter, const QStyleOptionGraphicsItem *option, const QRectF & boundingRect, const QPainterPath & path)
{
const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1))
return;
const QRectF mbrect = painter->transform().mapRect(boundingRect);
if (qMin(mbrect.width(), mbrect.height()) < double(1.0))
return;
double itemPenWidth = 1.0;
const double pad = itemPenWidth / 2;
const double penWidth = 0; // cosmetic pen
const QColor fgcolor = option->palette.windowText().color();
const QColor bgcolor( // ensure good contrast against fgcolor
fgcolor.red() > 127 ? 0 : 255,
fgcolor.green() > 127 ? 0 : 255,
fgcolor.blue() > 127 ? 0 : 255);
painter->setPen(QPen(bgcolor, penWidth, Qt::SolidLine));
painter->setBrush(Qt::NoBrush);
if (path.isEmpty()) {
painter->drawRect(boundingRect.adjusted(pad, pad, -pad, -pad));
}
else {
painter->drawPath(path);
}
painter->setPen(QPen(option->palette.windowText(), 0, Qt::DashLine));
painter->setBrush(Qt::NoBrush);
if (path.isEmpty()) {
painter->drawRect(boundingRect.adjusted(pad, pad, -pad, -pad));
}
else {
painter->drawPath(path);
}
}
QPainterPath AbstractArrow::contour(qreal width) const
{
QPainterPath arrowPath = path();
// if path is empty, return immediately
if (arrowPath.isEmpty()) {
return QPainterPath();
}
QPainterPathStroker stroker;
stroker.setJoinStyle(Qt::RoundJoin);
stroker.setCapStyle(Qt::RoundCap);
stroker.setWidth(width + style()->penWidth().toPoint());
return stroker.createStroke(arrowPath);
}
/*!
\brief Set the shape to be displayed
\param shape Shape
\sa setShape(), shape()
*/
void QwtPlotShapeItem::setShape( const QPainterPath &shape )
{
if ( shape != d_data->shape )
{
d_data->shape = shape;
if ( shape.isEmpty() )
{
d_data->boundingRect = QwtPlotItem::boundingRect();
}
else
{
d_data->boundingRect = shape.boundingRect();
}
itemChanged();
}
}
/*!
Calculate a mask, that can be used to clip away the border frame
\param size Size including the frame
*/
QBitmap QwtPlotCanvas::borderMask( const QSize &size ) const
{
const QRect r( 0, 0, size.width(), size.height() );
const QPainterPath path = borderPath( r );
if ( path.isEmpty() )
return QBitmap();
QImage image( size, QImage::Format_ARGB32_Premultiplied );
image.fill( Qt::color0 );
QPainter painter( &image );
painter.setClipPath( path );
painter.fillRect( r, Qt::color1 );
// now erase the frame
painter.setCompositionMode( QPainter::CompositionMode_DestinationOut );
if ( testAttribute(Qt::WA_StyledBackground ) )
{
QStyleOptionFrame opt;
opt.initFrom(this);
opt.rect = r;
style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, this );
}
else
{
if ( d_data->borderRadius > 0 && frameWidth() > 0 )
{
painter.setPen( QPen( Qt::color1, frameWidth() ) );
painter.setBrush( Qt::NoBrush );
painter.setRenderHint( QPainter::Antialiasing, true );
painter.drawPath( path );
}
}
painter.end();
const QImage mask = image.createMaskFromColor(
QColor( Qt::color1 ).rgb(), Qt::MaskOutColor );
return QBitmap::fromImage( mask );
}
void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
{
const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
QPainterPath path;
path.setFillRule(Qt::WindingFill);
if (ti.glyphs.numGlyphs)
ti.fontEngine->addOutlineToPath(0, 0, ti.glyphs, &path, ti.flags);
if (!path.isEmpty()) {
painter()->save();
painter()->setRenderHint(QPainter::Antialiasing,
bool((painter()->renderHints() & QPainter::TextAntialiasing)
&& !(painter()->font().styleStrategy() & QFont::NoAntialias)));
painter()->translate(p.x(), p.y());
painter()->fillPath(path, state->pen().brush());
painter()->restore();
}
}
void QgsLineStringV2::addToPainterPath( QPainterPath& path ) const
{
int nPoints = numPoints();
if ( nPoints < 1 )
{
return;
}
if ( path.isEmpty() || path.currentPosition() != QPointF( mX.at( 0 ), mY.at( 0 ) ) )
{
path.moveTo( mX.at( 0 ), mY.at( 0 ) );
}
for ( int i = 1; i < nPoints; ++i )
{
path.lineTo( mX.at( i ), mY.at( i ) );
}
}
void QgsLineStringV2::addToPainterPath( QPainterPath& path ) const
{
int nPoints = numPoints();
if ( nPoints < 1 )
{
return;
}
if ( path.isEmpty() || path.currentPosition() != mCoords[0] )
{
path.moveTo( mCoords[0] );
}
for ( int i = 1; i < nPoints; ++i )
{
path.lineTo( mCoords[i] );
}
}
/*!
Draws the first \a rectCount rectangles in the buffer \a
rects. The default implementation of this function calls drawPath()
or drawPolygon() depending on the feature set of the paint engine.
*/
void QPaintEngine::drawRects(const QRectF *rects, int rectCount)
{
if (hasFeature(PainterPaths) &&
!state->penNeedsResolving() &&
!state->brushNeedsResolving()) {
for (int i=0; i<rectCount; ++i) {
QPainterPath path;
path.addRect(rects[i]);
if (path.isEmpty())
continue;
drawPath(path);
}
} else {
for (int i=0; i<rectCount; ++i) {
QRectF rf = rects[i];
QPointF pts[4] = { QPointF(rf.x(), rf.y()),
QPointF(rf.x() + rf.width(), rf.y()),
QPointF(rf.x() + rf.width(), rf.y() + rf.height()),
QPointF(rf.x(), rf.y() + rf.height()) };
drawPolygon(pts, 4, ConvexMode);
}
}
}
void QwtWidgetOverlay::draw( QPainter *painter ) const
{
if ( QWidget *widget = parentWidget() )
{
painter->setClipRect( widget->contentsRect() );
// something special for the plot canvas
const int idx = widget->metaObject()->indexOfMethod( "borderPath(QRect)" );
if ( idx >= 0 )
{
QPainterPath clipPath;
( void )QMetaObject::invokeMethod(
widget, "borderPath", Qt::DirectConnection,
Q_RETURN_ARG( QPainterPath, clipPath ), Q_ARG( QRect, rect() ) );
if (!clipPath.isEmpty())
painter->setClipPath( clipPath, Qt::IntersectClip );
}
}
drawOverlay( painter );
}
void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
{
const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
if (ti.glyphs.numGlyphs == 0)
return;
if (ti.fontEngine->glyphFormat == QFontEngine::Format_ARGB) {
QVarLengthArray<QFixedPoint> positions;
QVarLengthArray<glyph_t> glyphs;
QTransform matrix = QTransform::fromTranslate(p.x(), p.y() - ti.fontEngine->ascent().toReal());
ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
painter()->save();
painter()->setRenderHint(QPainter::SmoothPixmapTransform,
bool((painter()->renderHints() & QPainter::TextAntialiasing)
&& !(painter()->font().styleStrategy() & QFont::NoAntialias)));
for (int i = 0; i < ti.glyphs.numGlyphs; ++i) {
QImage glyph = ti.fontEngine->bitmapForGlyph(glyphs[i], QFixed(), QTransform());
painter()->drawImage(positions[i].x.toReal(), positions[i].y.toReal(), glyph);
}
painter()->restore();
return;
}
QPainterPath path;
path.setFillRule(Qt::WindingFill);
ti.fontEngine->addOutlineToPath(0, 0, ti.glyphs, &path, ti.flags);
if (!path.isEmpty()) {
painter()->save();
painter()->setRenderHint(QPainter::Antialiasing,
bool((painter()->renderHints() & QPainter::TextAntialiasing)
&& !(painter()->font().styleStrategy() & QFont::NoAntialias)));
painter()->translate(p.x(), p.y());
painter()->fillPath(path, painter()->pen().brush());
painter()->restore();
}
}
void TemporalConstraintView::paint(
QPainter* painter,
const QStyleOptionGraphicsItem*,
QWidget*)
{
auto& skin = ScenarioStyle::instance();
qreal min_w = minWidth();
qreal max_w = maxWidth();
qreal def_w = defaultWidth();
qreal play_w = playWidth();
m_labelItem->setPos(def_w / 2. - m_labelItem->boundingRect().width() / 2., -17);
m_counterItem->setPos(def_w - m_counterItem->boundingRect().width() - 5, 5);
m_leftBrace->setX(min_w);
m_rightBrace->setX(max_w);
// Draw the stuff present if there is a rack *in the model* ?
if(presenter().rack())
{
// Background
auto rect = boundingRect();
rect.adjust(0,4,0,-10);
rect.setWidth(this->defaultWidth());
QColor bgColor = m_bgColor.getColor();
bgColor.setAlpha(m_hasFocus ? 84 : 76);
painter->fillRect(rect, bgColor);
// Fake timenode continuation
auto color = skin.RackSideBorder.getColor();
QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin};
painter->setPen(pen);
painter->drawLine(rect.topLeft(), rect.bottomLeft());
painter->drawLine(rect.topRight(), rect.bottomRight());
}
QPainterPath solidPath, dashedPath, leftBrace, rightBrace;
// Paths
if(infinite())
{
if(min_w != 0.)
{
solidPath.lineTo(min_w, 0);
m_leftBrace->show();
}
m_rightBrace->hide();
// TODO end state should be hidden
dashedPath.moveTo(min_w, 0);
dashedPath.lineTo(def_w, 0);
}
else if(min_w == max_w) // TODO rigid()
{
solidPath.lineTo(def_w, 0);
m_leftBrace->hide();
m_rightBrace->hide();
}
else
{
if(min_w != 0.)
solidPath.lineTo(min_w, 0);
dashedPath.moveTo(min_w, 0);
dashedPath.lineTo(max_w, 0);
m_leftBrace->show();
m_rightBrace->show();
}
QPainterPath playedPath;
if(play_w != 0.)
{
playedPath.lineTo(std::min(play_w, std::max(def_w, max_w)), 0);
}
// Colors
QColor constraintColor;
// TODO make a switch instead
if(isSelected())
{
constraintColor = skin.ConstraintSelected.getColor();
}
else if(warning())
{
constraintColor = skin.ConstraintWarning.getColor();
}
else
{
constraintColor = skin.ConstraintBase.getColor();
}
if(! isValid() || m_state == ConstraintExecutionState::Disabled)
{
constraintColor = skin.ConstraintInvalid.getColor();
}
m_solidPen.setColor(constraintColor);
m_dashPen.setColor(constraintColor);
// Drawing
painter->setPen(m_solidPen);
if(!solidPath.isEmpty())
painter->drawPath(solidPath);
painter->setPen(m_dashPen);
if(!dashedPath.isEmpty())
painter->drawPath(dashedPath);
leftBrace.closeSubpath();
rightBrace.closeSubpath();
QPen anotherPen(Qt::transparent, 4);
painter->setPen(anotherPen);
QColor blueish = m_solidPen.color().lighter();
blueish.setAlphaF(0.3);
painter->setBrush(blueish);
const QPen playedPen{
skin.ConstraintPlayFill.getColor(),
4,
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin
};
painter->setPen(playedPen);
if(!playedPath.isEmpty())
painter->drawPath(playedPath);
{
auto& dur = presenter().model().duration;
auto progress = dur.defaultDuration() * dur.playPercentage();
if(!progress.isZero())
{
QString percent = progress.toString();
m_counterItem->setText(percent);
}
}
#if defined(ISCORE_SCENARIO_DEBUG_RECTS)
painter->setPen(Qt::darkRed);
painter->setBrush(Qt::NoBrush);
painter->drawRect(boundingRect());
#endif
}
static void qwtDrawBackground( QPainter *painter, QwtPlotCanvas *canvas )
{
painter->save();
const QPainterPath borderClip = canvas->borderPath( canvas->rect() );
if ( !borderClip.isEmpty() )
painter->setClipPath( borderClip, Qt::IntersectClip );
const QBrush &brush =
canvas->palette().brush( canvas->backgroundRole() );
if ( brush.style() == Qt::TexturePattern )
{
QPixmap pm( canvas->size() );
qwtFillPixmap( canvas, pm );
painter->drawPixmap( 0, 0, pm );
}
else if ( brush.gradient() )
{
QVector<QRect> rects;
if ( brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode )
{
rects += canvas->rect();
}
else
{
rects = painter->clipRegion().rects();
}
#if 1
bool useRaster = false;
if ( painter->paintEngine()->type() == QPaintEngine::X11 )
{
// Qt 4.7.1: gradients on X11 are broken ( subrects +
// QGradient::StretchToDeviceMode ) and horrible slow.
// As workaround we have to use the raster paintengine.
// Even if the QImage -> QPixmap translation is slow
// it is three times faster, than using X11 directly
useRaster = true;
}
#endif
if ( useRaster )
{
QImage::Format format = QImage::Format_RGB32;
const QGradientStops stops = brush.gradient()->stops();
for ( int i = 0; i < stops.size(); i++ )
{
if ( stops[i].second.alpha() != 255 )
{
// don't use Format_ARGB32_Premultiplied. It's
// recommended by the Qt docs, but QPainter::drawImage()
// is horrible slow on X11.
format = QImage::Format_ARGB32;
break;
}
}
QImage image( canvas->size(), format );
QPainter p( &image );
p.setPen( Qt::NoPen );
p.setBrush( brush );
p.drawRects( rects );
p.end();
painter->drawImage( 0, 0, image );
}
else
{
painter->setPen( Qt::NoPen );
painter->setBrush( brush );
painter->drawRects( rects );
}
}
else
{
painter->setPen( Qt::NoPen );
painter->setBrush( brush );
painter->drawRects( painter->clipRegion().rects() );
}
painter->restore();
}
int Nightcharts::draw(QPainter *painter)
{
painter->setRenderHint(QPainter::Antialiasing);
painter->setPen(Qt::NoPen);
if (this->ctype == Nightcharts::Pie)
{
pW = 0;
double pdegree = 0;
//Options
QLinearGradient gradient(cX+0.5*cW,cY,cX+0.5*cW,cY+cH*2.5);
gradient.setColorAt(1,Qt::black);
//Draw
//pdegree = (360/100)*pieces[i].pPerc;
if (shadows)
{
double sumangle = 0;
for (int i = 0; i < pieces.size(); i++)
{
sumangle += 3.6 * pieces[i].pPerc;
}
painter->setBrush(Qt::darkGray);
painter->drawPie(cX,cY+pW+5,cW,cH,palpha*16,sumangle*16);
}
QPen pen;
pen.setWidth(2);
for (int i = 0; i < pieces.size(); i++)
{
gradient.setColorAt(0, pieces[i].rgbColor);
painter->setBrush(gradient);
pen.setColor(pieces[i].rgbColor);
painter->setPen(pen);
pdegree = 3.6 * pieces[i].pPerc;
painter->drawPie(cX, cY, cW, cH, palpha*16, pdegree*16);
palpha += pdegree;
}
}
else if (this->ctype == Nightcharts::Dpie)
{
pW = 50;
double pdegree = 0;
QPointF p;
QLinearGradient gradient(cX - 0.5 * cW, cY + cH/2, cX + 1.5 * cW, cY + cH/2);
gradient.setColorAt(0,Qt::black);
gradient.setColorAt(1,Qt::white);
QLinearGradient gradient_side(cX, cY + cH, cX + cW, cY + cH);
gradient_side.setColorAt(0,Qt::black);
double sumangle = 0;
for (int i = 0; i < pieces.size(); i++)
{
sumangle += 3.6 * pieces[i].pPerc;
}
if (shadows)
{
painter->setBrush(Qt::darkGray);
painter->drawPie(cX, cY + pW + 5, cW, cH, palpha * 16, sumangle * 16);
}
int q = GetQuater(palpha+sumangle);
if (q ==2 || q==3)
{
QPointF p = GetPoint(palpha+sumangle);
QPointF points[4] =
{
QPointF(p.x(), p.y()),
QPointF(p.x(), p.y() + pW),
QPointF(cX + cW/2, cY + cH/2 + pW),
QPointF(cX + cW/2, cY + cH/2)
};
gradient_side.setColorAt(1, pieces[pieces.size()-1].rgbColor);
painter->setBrush(gradient_side);
painter->drawPolygon(points, 4);
}
p = GetPoint(palpha);
q = GetQuater(palpha);
if (q ==1 || q==4)
{
QPointF points[4] =
{
QPointF(p.x(), p.y()),
QPointF(p.x(), p.y() + pW),
QPointF(cX + cW/2, cY + cH/2 + pW),
QPointF(cX + cW/2, cY + cH/2)
};
gradient_side.setColorAt(1, pieces[0].rgbColor);
painter->setBrush(gradient_side);
painter->drawPolygon(points, 4);
}
for (int i = 0;i < pieces.size(); i++)
{
gradient.setColorAt(0.5, pieces[i].rgbColor);
painter->setBrush(gradient);
pdegree = 3.6 * pieces[i].pPerc;
painter->drawPie(cX, cY, cW, cH, palpha * 16, pdegree * 16);
double a_ = Angle360(palpha);
int q_ = GetQuater(palpha);
palpha += pdegree;
double a = Angle360(palpha);
int q = GetQuater(palpha);
QPainterPath path;
p = GetPoint(palpha);
if((q == 3 || q == 4) && (q_ == 3 || q_ == 4))
{
// 1)
if (a>a_)
{
QPointF p_old = GetPoint(palpha-pdegree);
path.moveTo(p_old.x() - 1, p_old.y());
path.arcTo(cX, cY, cW, cH, palpha-pdegree, pdegree);
path.lineTo(p.x(), p.y() + pW);
path.arcTo(cX, cY + pW, cW, cH, palpha, -pdegree);
}
// 2)
else
{
path.moveTo(cX, cY + cH/2);
path.arcTo(cX, cY, cW, cH, 180, Angle360(palpha) - 180);
path.lineTo(p.x(), p.y() + pW);
path.arcTo(cX, cY + pW, cW, cH, Angle360(palpha), -Angle360(palpha) + 180);
path.lineTo(cX, cY + cH/2);
path.moveTo(p.x(), p.y());
path.arcTo(cX, cY, cW, cH, palpha-pdegree, 360 - Angle360(palpha - pdegree));
path.lineTo(cX + cW, cY + cH/2 + pW);
path.arcTo(cX, cY + pW, cW, cH, 0, -360 + Angle360(palpha - pdegree));
}
}
// 3)
else if((q == 3 || q == 4) && (q_ == 1 || q_ == 2) && a>a_ )
{
path.moveTo(cX,cY+cH/2);
path.arcTo(cX,cY,cW,cH,180,Angle360(palpha)-180);
path.lineTo(p.x(),p.y()+pW);
path.arcTo(cX,cY+pW,cW,cH,Angle360(palpha),-Angle360(palpha)+180);
path.lineTo(cX,cY+cH/2);
}
// 4)
else if((q == 1 || q == 2) && (q_ == 3 || q_ == 4) && a<a_)
{
p = GetPoint(palpha-pdegree);
path.moveTo(p.x(),p.y());
path.arcTo(cX,cY,cW,cH,palpha-pdegree,360-Angle360(palpha-pdegree));
path.lineTo(cX+cW,cY+cH/2+pW);
path.arcTo(cX,cY+pW,cW,cH,0,-360+Angle360(palpha-pdegree));
}
// 5)
else if((q ==1 || q==2) && (q_==1 || q_==2) && a<a_)
{
path.moveTo(cX,cY+cH/2);
path.arcTo(cX,cY,cW,cH,180,180);
path.lineTo(cX+cW,cY+cH/2+pW);
path.arcTo(cX,cY+pW,cW,cH,0,-180);
path.lineTo(cX,cY+cH/2);
}
if (!path.isEmpty())
{
gradient_side.setColorAt(1,pieces[i].rgbColor);
painter->setBrush(gradient_side);
painter->drawPath(path);
}
}
}
else if (this->ctype==Nightcharts::Histogramm)
{
double pDist = 15;
double pW = (cW-(pieces.size())*pDist)/pieces.size();
QLinearGradient gradient(cX + cW/2, cY, cX + cW/2, cY + cH);
gradient.setColorAt(0,Qt::black);
QPen pen;
pen.setWidth(3);
for (int i = 0;i < pieces.size(); i++)
{
if (shadows)
{
painter->setPen(Qt::NoPen);
painter->setBrush(Qt::darkGray);
painter->drawRect(cX+pDist+i*(pW + pDist)-pDist/2,cY+cH-1,pW,-cH/100*pieces[i].pPerc+pDist/2-5);
}
gradient.setColorAt(1,pieces[i].rgbColor);
painter->setBrush(gradient);
pen.setColor(pieces[i].rgbColor);
painter->setPen(pen);
painter->drawRect(cX+pDist+i*(pW + pDist),cY+cH,pW,-cH/100*pieces[i].pPerc-5);
QString label = QString::number(pieces[i].pPerc)+"%";
painter->setPen(Qt::SolidLine);
painter->drawText(cX+pDist+i*(pW + pDist)+pW/2-painter->fontMetrics().width(label)/2,cY+cH-cH/100*pieces[i].pPerc-painter->fontMetrics().height()/2,label);
}
painter->setPen(Qt::SolidLine);
for (int i = 1; i < 10; i++)
{
painter->drawLine(cX - 3, cY + cH/10 * i, cX + 3, cY + cH/10 * i); //§Õ§Ö§Ý§Ö§ß§Ú§ñ §á§à §à§ã§Ú Y
//painter->drawText(cX-20,cY+cH/10*i,QString::number((10-i)*10)+"%");
}
painter->drawLine(cX,cY+cH,cX,cY); //§à§ã§î Y
painter->drawLine(cX,cY,cX+4,cY+10); //§ã§ä§â§Ö§Ý§Ü§Ú
painter->drawLine(cX,cY,cX-4,cY+10);
painter->drawLine(cX,cY+cH,cX+cW,cY+cH); //§à§ã§î §·
}
return 0;
}
QList< Model::Link* > Model::DjVuPage::links() const
{
QMutexLocker mutexLocker(&m_parent->m_mutex);
QList< Link* > links;
miniexp_t pageAnnoExp;
while(true)
{
pageAnnoExp = ddjvu_document_get_pageanno(m_parent->m_document, m_index);
if(pageAnnoExp == miniexp_dummy)
{
clearMessageQueue(m_parent->m_context, true);
}
else
{
break;
}
}
const int pageAnnoLength = miniexp_length(pageAnnoExp);
for(int pageAnnoN = 0; pageAnnoN < pageAnnoLength; ++pageAnnoN)
{
miniexp_t linkExp = miniexp_nth(pageAnnoN, pageAnnoExp);
if(miniexp_length(linkExp) <= 3 || qstrncmp(miniexp_to_name(miniexp_nth(0, linkExp)), "maparea", 7 ) != 0 || !miniexp_symbolp(miniexp_nth(0, miniexp_nth(3, linkExp))))
{
continue;
}
const QString type = QString::fromUtf8(miniexp_to_name(miniexp_nth(0, miniexp_nth(3, linkExp))));
if(type == QLatin1String("rect") || type == QLatin1String("oval") || type == QLatin1String("poly"))
{
// boundary
QPainterPath boundary;
miniexp_t areaExp = miniexp_nth(3, linkExp);
const int areaLength = miniexp_length( areaExp );
if(areaLength == 5 && (type == QLatin1String("rect") || type == QLatin1String("oval")))
{
QPoint p(miniexp_to_int(miniexp_nth(1, areaExp)), miniexp_to_int(miniexp_nth(2, areaExp)));
QSize s(miniexp_to_int(miniexp_nth(3, areaExp)), miniexp_to_int(miniexp_nth(4, areaExp)));
p.setY(m_size.height() - s.height() - p.y());
const QRectF r(p, s);
if(type == QLatin1String("rect"))
{
boundary.addRect(r);
}
else
{
boundary.addEllipse(r);
}
}
else if(areaLength > 0 && areaLength % 2 == 1 && type == QLatin1String("poly"))
{
QPolygon polygon;
for(int areaExpN = 1; areaExpN < areaLength; areaExpN += 2)
{
QPoint p(miniexp_to_int(miniexp_nth(areaExpN, areaExp)), miniexp_to_int(miniexp_nth(areaExpN + 1, areaExp)));
p.setY(m_size.height() - p.y());
polygon << p;
}
boundary.addPolygon(polygon);
}
if(boundary.isEmpty())
{
continue;
}
boundary = QTransform::fromScale(1.0 / m_size.width(), 1.0 / m_size.height()).map(boundary);
// target
QString target;
miniexp_t targetExp = miniexp_nth(1, linkExp);
if(miniexp_stringp(targetExp))
{
target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, linkExp)));
}
else if(miniexp_length(targetExp) == 3 && qstrncmp(miniexp_to_name(miniexp_nth(0, targetExp)), "url", 3) == 0)
{
target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, targetExp)));
}
if(target.isEmpty())
{
continue;
}
if(target.at(0) == QLatin1Char('#'))
{
target.remove(0, 1);
bool ok = false;
int targetPage = target.toInt(&ok);
if(!ok)
{
if(m_parent->m_indexByName.contains(target))
{
targetPage = m_parent->m_indexByName[target] + 1;
}
else
{
continue;
}
}
else
{
targetPage = (target.at(0) == QLatin1Char('+') || target.at(0) == QLatin1Char('-')) ? m_index + targetPage : targetPage;
}
links.append(new Link(boundary, targetPage));
}
else
{
links.append(new Link(boundary, target));
}
}
}
ddjvu_miniexp_release(m_parent->m_document, pageAnnoExp);
return links;
}
QString VariantHandler::displayString(const QVariant& value)
{
switch (value.type()) {
#ifndef QT_NO_CURSOR
case QVariant::Cursor:
{
const QCursor cursor = value.value<QCursor>();
return Util::enumToString(QVariant::fromValue<int>(cursor.shape()), "Qt::CursorShape");
}
#endif
case QVariant::Icon:
{
const QIcon icon = value.value<QIcon>();
if (icon.isNull()) {
return QObject::tr("<no icon>");
}
QStringList l;
foreach (const QSize &size, icon.availableSizes()) {
l.push_back(displayString(size));
}
return l.join(QLatin1String(", "));
}
case QVariant::Line:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLine().x1()).arg(value.toLine().y1()).
arg(value.toLine().x2()).arg(value.toLine().y2());
case QVariant::LineF:
return
QString::fromUtf8("%1 x %2 → %3 x %4").
arg(value.toLineF().x1()).arg(value.toLineF().y1()).
arg(value.toLineF().x2()).arg(value.toLineF().y2());
case QVariant::Locale:
return value.value<QLocale>().name();
case QVariant::Point:
return
QString::fromLatin1("%1x%2").
arg(value.toPoint().x()).
arg(value.toPoint().y());
case QVariant::PointF:
return
QString::fromLatin1("%1x%2").
arg(value.toPointF().x()).
arg(value.toPointF().y());
case QVariant::Rect:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRect().x()).
arg(value.toRect().y()).
arg(value.toRect().width()).
arg(value.toRect().height());
case QVariant::RectF:
return
QString::fromLatin1("%1x%2 %3x%4").
arg(value.toRectF().x()).
arg(value.toRectF().y()).
arg(value.toRectF().width()).
arg(value.toRectF().height());
case QVariant::Region:
{
const QRegion region = value.value<QRegion>();
if (region.isEmpty()) {
return QLatin1String("<empty>");
}
if (region.rectCount() == 1) {
return displayString(region.rects().first());
} else {
return QString::fromLatin1("<%1 rects>").arg(region.rectCount());
}
}
case QVariant::Palette:
{
const QPalette pal = value.value<QPalette>();
if (pal == qApp->palette()) {
return QLatin1String("<inherited>");
}
return QLatin1String("<custom>");
}
case QVariant::Size:
return
QString::fromLatin1("%1x%2").
arg(value.toSize().width()).
arg(value.toSize().height());
case QVariant::SizeF:
return
QString::fromLatin1("%1x%2").
arg(value.toSizeF().width()).
arg(value.toSizeF().height());
case QVariant::StringList:
return value.toStringList().join(", ");
case QVariant::Transform:
{
const QTransform t = value.value<QTransform>();
return
QString::fromLatin1("[%1 %2 %3, %4 %5 %6, %7 %8 %9]").
arg(t.m11()).arg(t.m12()).arg(t.m13()).
arg(t.m21()).arg(t.m22()).arg(t.m23()).
arg(t.m31()).arg(t.m32()).arg(t.m33());
}
default:
break;
}
// types with dynamic type ids
if (value.type() == (QVariant::Type)qMetaTypeId<QTextLength>()) {
const QTextLength l = value.value<QTextLength>();
QString typeStr;
switch (l.type()) {
case QTextLength::VariableLength:
typeStr = QObject::tr("variable");
break;
case QTextLength::FixedLength:
typeStr = QObject::tr("fixed");
break;
case QTextLength::PercentageLength:
typeStr = QObject::tr("percentage");
break;
}
return QString::fromLatin1("%1 (%2)").arg(l.rawValue()).arg(typeStr);
}
if (value.userType() == qMetaTypeId<QPainterPath>()) {
const QPainterPath path = value.value<QPainterPath>();
if (path.isEmpty()) {
return QObject::tr("<empty>");
}
return QObject::tr("<%1 elements>").arg(path.elementCount());
}
if (value.userType() == qMetaTypeId<QMargins>()) {
const QMargins margins = value.value<QMargins>();
return QObject::tr("left: %1, top: %2, right: %3, bottom: %4")
.arg(margins.left()).arg(margins.top())
.arg(margins.right()).arg(margins.bottom());
}
if (value.canConvert<QObject*>()) {
return Util::displayString(value.value<QObject*>());
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
if (value.userType() == qMetaTypeId<QSet<QByteArray> >()) {
const QSet<QByteArray> set = value.value<QSet<QByteArray> >();
QStringList l;
foreach (const QByteArray &b, set)
l.push_back(QString::fromUtf8(b));
return l.join(", ");
}
if (value.userType() == qMetaTypeId<QSurfaceFormat>()) {
const QSurfaceFormat format = value.value<QSurfaceFormat>();
QString s;
switch (format.renderableType()) {
case QSurfaceFormat::DefaultRenderableType: s += "Default"; break;
case QSurfaceFormat::OpenGL: s += "OpenGL"; break;
case QSurfaceFormat::OpenGLES: s += "OpenGL ES"; break;
case QSurfaceFormat::OpenVG: s += "OpenVG"; break;
}
s += " (" + QString::number(format.majorVersion()) + "." + QString::number(format.minorVersion());
switch (format.profile()) {
case QSurfaceFormat::CoreProfile: s += " core"; break;
case QSurfaceFormat::CompatibilityProfile: s += " compat"; break;
case QSurfaceFormat::NoProfile: break;
}
s += ")";
s += " RGBA: " + QString::number(format.redBufferSize()) + "/" + QString::number(format.greenBufferSize())
+ "/" + QString::number(format.blueBufferSize()) + "/" + QString::number(format.alphaBufferSize());
s += " Depth: " + QString::number(format.depthBufferSize());
s += " Stencil: " + QString::number(format.stencilBufferSize());
s += " Buffer: ";
switch (format.swapBehavior()) {
case QSurfaceFormat::DefaultSwapBehavior: s += "default"; break;
case QSurfaceFormat::SingleBuffer: s += "single"; break;
case QSurfaceFormat::DoubleBuffer: s += "double"; break;
case QSurfaceFormat::TripleBuffer: s += "triple"; break;
default: s += "unknown";
}
return s;
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceClass>()) {
const QSurface::SurfaceClass sc = value.value<QSurface::SurfaceClass>();
switch (sc) {
case QSurface::Window: return QObject::tr("Window");
#if QT_VERSION > QT_VERSION_CHECK(5, 1, 0)
case QSurface::Offscreen: return QObject::tr("Offscreen");
#endif
default: return QObject::tr("Unknown Surface Class");
}
}
if (value.userType() == qMetaTypeId<QSurface::SurfaceType>()) {
const QSurface::SurfaceType type = value.value<QSurface::SurfaceType>();
switch (type) {
case QSurface::RasterSurface: return QObject::tr("Raster");
case QSurface::OpenGLSurface: return QObject::tr("OpenGL");
default: return QObject::tr("Unknown Surface Type");
}
}
#endif
// enums
const QString enumStr = Util::enumToString(value);
if (!enumStr.isEmpty()) {
return enumStr;
}
// custom converters
const QHash<int, Converter<QString>*>::const_iterator it = s_variantHandlerRepository()->stringConverters.constFind(value.userType());
if (it != s_variantHandlerRepository()->stringConverters.constEnd()) {
return (*it.value())(value);
}
return value.toString();
}
void QOutlineMapper::endOutline()
{
closeSubpath();
if (m_elements.isEmpty()) {
memset(&m_outline, 0, sizeof(m_outline));
return;
}
QPointF *elements = m_elements.data();
// Transform the outline
if (m_txop == QTransform::TxNone) {
// Nothing to do.
} else if (m_txop == QTransform::TxTranslate) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(e.x() + m_dx, e.y() + m_dy);
}
} else if (m_txop == QTransform::TxScale) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy);
}
} else if (m_txop < QTransform::TxProject) {
for (int i = 0; i < m_elements.size(); ++i) {
QPointF &e = elements[i];
e = QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx,
m_m22 * e.y() + m_m12 * e.x() + m_dy);
}
} else {
const QVectorPath vp((qreal *)elements, m_elements.size(),
m_element_types.size() ? m_element_types.data() : 0);
QPainterPath path = vp.convertToPainterPath();
path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
path.setFillRule(Qt::WindingFill);
uint old_txop = m_txop;
m_txop = QTransform::TxNone;
if (path.isEmpty())
m_valid = false;
else
convertPath(path);
m_txop = old_txop;
return;
}
if (m_round_coords) {
// round coordinates to match outlines drawn with drawLine_midpoint_i
for (int i = 0; i < m_elements.size(); ++i)
elements[i] = QPointF(qFloor(elements[i].x() + aliasedCoordinateDelta),
qFloor(elements[i].y() + aliasedCoordinateDelta));
}
controlPointRect = boundingRect(elements, m_elements.size());
#ifdef QT_DEBUG_CONVERT
printf(" - control point rect (%.2f, %.2f) %.2f x %.2f, clip=(%d,%d, %dx%d)\n",
controlPointRect.x(), controlPointRect.y(),
controlPointRect.width(), controlPointRect.height(),
m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height());
#endif
// Check for out of dev bounds...
const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.right() > QT_RASTER_COORD_LIMIT
|| controlPointRect.top() < -QT_RASTER_COORD_LIMIT
|| controlPointRect.bottom() > QT_RASTER_COORD_LIMIT
|| controlPointRect.width() > QT_RASTER_COORD_LIMIT
|| controlPointRect.height() > QT_RASTER_COORD_LIMIT));
if (do_clip) {
clipElements(elements, elementTypes(), m_elements.size());
} else {
convertElements(elements, elementTypes(), m_elements.size());
}
}
void TemporalConstraintView::paint(
QPainter* painter,
const QStyleOptionGraphicsItem* option,
QWidget* widget)
{
// Draw the rack bg
if(auto rack = presenter().rack())
{
auto rackRect = rack->view().boundingRect();
painter->fillRect(rackRect, QColor::fromRgba(qRgba(0, 127, 229, 76)));
auto color = qApp->palette("ScenarioPalette").base().color();
QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin};
painter->setPen(pen);
painter->drawLine(rackRect.topLeft(), rackRect.bottomLeft());
painter->drawLine(rackRect.topRight(), rackRect.bottomRight());
}
QPainterPath solidPath, dashedPath, leftBrace, rightBrace;
// m_endState->setPos(defaultWidth(), 0);
// Paths
if(infinite())
{
if(minWidth() != 0)
{
solidPath.lineTo(minWidth(), 0);
leftBrace.moveTo(minWidth(), -10);
leftBrace.arcTo(minWidth() - 10, -10, 20, 20, 90, 180);
}
// TODO end state should be hidden
dashedPath.moveTo(minWidth(), 0);
dashedPath.lineTo(defaultWidth(), 0);
}
else if(minWidth() == maxWidth()) // TODO rigid()
{
solidPath.lineTo(defaultWidth(), 0);
}
else
{
if(minWidth() != 0)
solidPath.lineTo(minWidth(), 0);
dashedPath.moveTo(minWidth(), 0);
dashedPath.lineTo(maxWidth(), 0);
leftBrace.moveTo(minWidth(), -10);
leftBrace.arcTo(minWidth() - 10, -10, 20, 20, 90, 180);
rightBrace.moveTo(maxWidth(), 10);
rightBrace.arcTo(maxWidth() - 10, -10, 20, 20, 270, 180);
}
QPainterPath playedPath;
if(playWidth() != 0)
{
playedPath.lineTo(playWidth(), 0);
}
// Colors
QColor constraintColor;
if(isSelected())
{
constraintColor = QColor::fromRgbF(0.188235, 0.54902, 0.776471);
}
else
{
constraintColor = qApp->palette("ScenarioPalette").base().color();
}
if(warning())
{
constraintColor = QColor{200,150,0};
}
if(! isValid())
{
constraintColor = Qt::red;
}
m_solidPen.setColor(constraintColor);
m_dashPen.setColor(constraintColor);
// Drawing
painter->setPen(m_solidPen);
if(!solidPath.isEmpty())
painter->drawPath(solidPath);
if(!leftBrace.isEmpty())
painter->drawPath(leftBrace);
if(!rightBrace.isEmpty())
painter->drawPath(rightBrace);
painter->setPen(m_dashPen);
if(!dashedPath.isEmpty())
painter->drawPath(dashedPath);
leftBrace.closeSubpath();
rightBrace.closeSubpath();
QPen anotherPen(Qt::transparent, 4);
painter->setPen(anotherPen);
QColor blueish = m_solidPen.color().lighter();
blueish.setAlphaF(0.3);
painter->setBrush(blueish);
painter->drawPath(leftBrace);
painter->drawPath(rightBrace);
static const QPen playedPen{
QBrush{Qt::green},
4,
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin
};
static const QPen dashedPlayedPen{
QBrush{Qt::green},
4,
Qt::DashLine,
Qt::RoundCap,
Qt::RoundJoin
};
painter->setPen(playedPen);
if(!playedPath.isEmpty())
painter->drawPath(playedPath);
int fontSize = 12;
QRectF labelRect{0,0, defaultWidth(), (-fontSize - 2.)};
QFont f("Ubuntu");
f.setPixelSize(fontSize);
painter->setFont(f);
painter->setPen(m_labelColor);
painter->drawText(labelRect, Qt::AlignCenter, m_label);
/*
painter->setPen(Qt::darkRed);
painter->setBrush(Qt::NoBrush);
painter->drawRect(boundingRect());
*/
}
void QPaintEngineEx::drawPath(const QPainterPath &path)
{
if (!path.isEmpty())
draw(qtVectorPathForPath(path));
}
void TemporalConstraintView::paint(
QPainter* painter,
const QStyleOptionGraphicsItem*,
QWidget*)
{
qreal min_w = minWidth();
qreal max_w = maxWidth();
qreal def_w = defaultWidth();
qreal play_w = playWidth();
// Draw the stuff present if there is a rack *in the model* ?
if(presenter().rack())
{
// Background
auto rect = boundingRect();
rect.adjust(0,15,0,-10);
rect.setWidth(this->defaultWidth());
painter->fillRect(rect, m_bgColor);
// Fake timenode continuation
auto color = ScenarioStyle::instance().RackSideBorder;
QPen pen{color, 2, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin};
painter->setPen(pen);
painter->drawLine(rect.topLeft(), rect.bottomLeft());
painter->drawLine(rect.topRight(), rect.bottomRight());
}
QPainterPath solidPath, dashedPath, leftBrace, rightBrace;
// Paths
if(infinite())
{
if(min_w != 0.)
{
solidPath.lineTo(min_w, 0);
leftBrace.moveTo(min_w, -10);
leftBrace.arcTo(min_w - 10, -10, 20, 20, 90, 180);
}
// TODO end state should be hidden
dashedPath.moveTo(min_w, 0);
dashedPath.lineTo(def_w, 0);
}
else if(min_w == max_w) // TODO rigid()
{
solidPath.lineTo(def_w, 0);
}
else
{
if(min_w != 0.)
solidPath.lineTo(min_w, 0);
dashedPath.moveTo(min_w, 0);
dashedPath.lineTo(max_w, 0);
leftBrace.moveTo(min_w + 10, -10);
leftBrace.arcTo(min_w, -10, 20, 20, 90, 180);
leftBrace.closeSubpath();
rightBrace.moveTo(max_w, 10);
rightBrace.arcTo(max_w - 10, -10, 20, 20, 270, 180);
rightBrace.closeSubpath();
rightBrace.translate(-10, 0); // TODO bleh.
}
QPainterPath playedPath;
if(play_w != 0.)
{
playedPath.lineTo(play_w, 0);
}
// Colors
QColor constraintColor;
// TODO make a switch instead
if(isSelected())
{
constraintColor = ScenarioStyle::instance().ConstraintSelected;
}
else if(warning())
{
constraintColor = ScenarioStyle::instance().ConstraintWarning;
}
else
{
constraintColor = ScenarioStyle::instance().ConstraintBase;
}
if(! isValid())
{
constraintColor = ScenarioStyle::instance().ConstraintInvalid;
this->setZValue(this->zValue()+ 1);
}
else
{
this->setZValue(parentObject()->zValue() + 3);
}
m_solidPen.setColor(constraintColor);
m_dashPen.setColor(constraintColor);
// Drawing
painter->setPen(m_solidPen);
if(!solidPath.isEmpty())
painter->drawPath(solidPath);
if(!leftBrace.isEmpty())
painter->drawPath(leftBrace);
if(!rightBrace.isEmpty())
painter->drawPath(rightBrace);
painter->setPen(m_dashPen);
if(!dashedPath.isEmpty())
painter->drawPath(dashedPath);
leftBrace.closeSubpath();
rightBrace.closeSubpath();
QPen anotherPen(Qt::transparent, 4);
painter->setPen(anotherPen);
QColor blueish = m_solidPen.color().lighter();
blueish.setAlphaF(0.3);
painter->setBrush(blueish);
painter->drawPath(leftBrace);
painter->drawPath(rightBrace);
static const QPen playedPen{
QBrush{ScenarioStyle::instance().ConstraintPlayFill},
4,
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin
};
painter->setPen(playedPen);
if(!playedPath.isEmpty())
painter->drawPath(playedPath);
static const int fontSize = 12;
QRectF labelRect{0,0, defaultWidth(), (-fontSize - 2.)};
auto f = ProcessFonts::Sans();
f.setPointSize(fontSize);
painter->setFont(f);
painter->setPen(m_labelColor);
painter->drawText(labelRect, Qt::AlignCenter, m_label);
#if defined(ISCORE_SCENARIO_DEBUG_RECTS)
painter->setPen(Qt::darkRed);
painter->setBrush(Qt::NoBrush);
painter->drawRect(boundingRect());
#endif
}
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);
}
}
