void QQuickContext2DTexture::paintWithoutTiles(QQuickContext2DCommandBuffer *ccb)
{
if (!ccb || ccb->isEmpty())
return;
QPaintDevice* device = beginPainting();
if (!device) {
endPainting();
return;
}
QPainter p;
p.begin(device);
if (m_antialiasing)
p.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing | QPainter::TextAntialiasing, true);
else
p.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing | QPainter::TextAntialiasing, false);
if (m_smooth)
p.setRenderHint(QPainter::SmoothPixmapTransform, true);
else
p.setRenderHint(QPainter::SmoothPixmapTransform, false);
p.setCompositionMode(QPainter::CompositionMode_SourceOver);
ccb->replay(&p, m_state, scaleFactor());
endPainting();
markDirtyTexture();
}
void Plotter::drawCurves(QPainter& painter)
{
noOfCurves = curveDataMap.count();
QRect rect = this->printRect();
double x=0,y=0;
double width = rect.width() - 1;
double height = rect.height() - 1;
double yCount = maxY - minY;
if(antiAliasing)
painter.setRenderHints(QPainter::Antialiasing);
painter.translate(Margin + 1,rect.bottom()-1);
for(int i=0; i < noOfCurves ; i++)
{
QPolygonF polyline;
QVector<double>* dataPtr = curveDataMap[i] ;
for(int j = 0 ; j <= noOfPoints ; j++)
{
x = (width * j)/noOfPoints;
y = (height * dataPtr->value(j))/yCount;
polyline << QPoint(x,-y);
//qDebug() << y;
}
qDebug() << x <<rect.right();
painter.setPen(colorMap.value(i));
painter.drawPolyline(polyline);
}
}
void UIButton::paintEvent(QPaintEvent *event) {
QPainter context;
context.begin(this);
QRect rect = contentsRect();
rect.setX((contentsRect().width() - 128) / 2);
rect.setY((contentsRect().height() - 128) / 2);
rect.setWidth(128.0);
rect.setHeight(128.0);
if (isChecked()) {
//rect = rect.adjusted(1, 1, -1, -1);
}
context.save();
context.setRenderHints(QPainter::HighQualityAntialiasing |
QPainter::SmoothPixmapTransform |
QPainter::Antialiasing
);
context.drawPixmap(rect,
ctx->m_icon_dict[ctx->m_current_action].pixmap(256, 256,
isEnabled() ? QIcon::Normal : QIcon::Disabled,
isChecked() ? QIcon::On : QIcon::Off));
context.restore();
context.end();
}
void CanvasRenderer::paintGrid( QPainter& painter )
{
int gridSize = mOptions.nGridSize;
QRectF rect = painter.viewport();
QRectF boundingRect = mViewTransform.inverted().mapRect( rect );
int w = boundingRect.width();
int h = boundingRect.height();
//qDebug() << mViewTransform;
//qDebug() << mViewTransform.inverted();
int left = round100( boundingRect.left(), gridSize ) - gridSize;
int right = round100( boundingRect.right(), gridSize ) + gridSize;
int top = round100( boundingRect.top(), gridSize ) - gridSize;
int bottom = round100( boundingRect.bottom(), gridSize ) + gridSize;
QPen pen( Qt::lightGray );
pen.setCosmetic( true );
painter.setPen( pen );
painter.setWorldMatrixEnabled( true );
painter.setBrush( Qt::NoBrush );
QPainter::RenderHints previous_renderhints = painter.renderHints();
painter.setRenderHint( QPainter::Antialiasing, false );
for ( int x = left; x < right; x += gridSize )
{
painter.drawLine( x, top, x, bottom );
}
for ( int y = top; y < bottom; y += gridSize )
{
painter.drawLine( left, y, right, y );
}
painter.setRenderHints(previous_renderhints);
}
void FreeRegionGrabber::grabRect()
{
QPolygon pol = selection;
if ( !pol.isEmpty() )
{
grabbing = true;
int xOffset = pixmap.rect().x() - pol.boundingRect().x();
int yOffset = pixmap.rect().y() - pol.boundingRect().y();
QPolygon translatedPol = pol.translated(xOffset, yOffset);
QPixmap pixmap2(pol.boundingRect().size());
pixmap2.fill(Qt::transparent);
QPainter pt;
pt.begin(&pixmap2);
if (pt.paintEngine()->hasFeature(QPaintEngine::PorterDuff)) {
pt.setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing | QPainter::SmoothPixmapTransform, true);
pt.setBrush(Qt::black);
pt.setPen(QPen(QBrush(Qt::black), 0.5));
pt.drawPolygon(translatedPol);
pt.setCompositionMode(QPainter::CompositionMode_SourceIn);
} else {
pt.setClipRegion(QRegion(translatedPol));
pt.setCompositionMode(QPainter::CompositionMode_Source);
}
pt.drawPixmap(pixmap2.rect(), pixmap, pol.boundingRect());
pt.end();
emit freeRegionUpdated(pol);
emit freeRegionGrabbed(pixmap2);
}
}
// ********************************************************
ImageBufferData::ImageBufferData(const IntSize& size, bool accelerated)
{
QPainter* painter = new QPainter;
m_painter = adoptPtr(painter);
#if ENABLE(ACCELERATED_2D_CANVAS)
if (accelerated) {
m_impl = adoptPtr(new ImageBufferDataPrivateAccelerated(size));
} else
#endif
m_impl = adoptPtr(new ImageBufferDataPrivateUnaccelerated(size));
if (!m_impl->paintDevice())
return;
if (!painter->begin(m_impl->paintDevice()))
return;
painter->setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing);
QPen pen = painter->pen();
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setCapStyle(Qt::FlatCap);
pen.setJoinStyle(Qt::SvgMiterJoin);
pen.setMiterLimit(10);
painter->setPen(pen);
QBrush brush = painter->brush();
brush.setColor(Qt::black);
painter->setBrush(brush);
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
}
void My_Painter::drawCoordinates(QPainter &painter)
{
painter.setPen(QPen(Qt::black, 4, Qt::SolidLine));
painter.setRenderHints(QPainter::Antialiasing, true);
painter.drawPoint(10, 200);
painter.setPen(Qt::black);
painter.drawText(2 - xBoundingRect.width() / 2,
203 + xBoundingRect.height() / 2, tr("0") );
//---------------| t |------------------------------------------
painter.drawLine(10, 10, 10, 200);
painter.drawLine(10, 10, 15, 15);
painter.drawLine(10, 10, 5, 15);
painter.drawText( 2 - xBoundingRect.width() / 2,
5 + xBoundingRect.height() / 2, tr("t") );
//--------------------------------------------------------------
//---------------| n |------------------------------------------
painter.drawLine(10, 200, 320, 200);
painter.drawLine(320, 200, 315, 195);
painter.drawLine(320, 200, 315, 205);
painter.drawText(326 - yBoundingRect.width() / 2,
201 + yBoundingRect.height() / 2, tr("n"));
//--------------------------------------------------------------
}
void PiecesWidget::paintEvent (QPaintEvent *e)
{
int s = Pieces_.size ();
QPainter painter (this);
painter.setRenderHints (QPainter::Antialiasing |
QPainter::SmoothPixmapTransform);
if (!s)
{
painter.setBackgroundMode (Qt::OpaqueMode);
painter.setBackground (Qt::white);
painter.end ();
return;
}
QPixmap tempPicture (s, 1);
QPainter tempPainter (&tempPicture);
tempPainter.setPen (Qt::red);
tempPainter.drawLine (0, 0, s, 0);
QList<QPair<int, int> > trues = FindTrues (Pieces_);
for (int i = 0; i < trues.size (); ++i)
{
QPair<int, int> pair = trues.at (i);
tempPainter.setPen (Qt::darkGreen);
tempPainter.drawLine (pair.first, 0, pair.second, 0);
}
tempPainter.end ();
painter.drawPixmap (QRect (0, 0, width (), height ()), tempPicture);
painter.end ();
e->accept ();
}
void KarbonCalligraphyTool::paint(QPainter &painter, const KoViewConverter &converter)
{
if (m_selectedPath) {
painter.save();
painter.setRenderHints(QPainter::Antialiasing, false);
painter.setPen(Qt::red); // TODO make configurable
QRectF rect = m_selectedPath->boundingRect();
QPointF p1 = converter.documentToView(rect.topLeft());
QPointF p2 = converter.documentToView(rect.bottomRight());
painter.drawRect(QRectF(p1, p2));
painter.restore();
}
if (!m_shape) {
return;
}
painter.save();
painter.setTransform(m_shape->absoluteTransformation(&converter) *
painter.transform());
KoShapePaintingContext paintContext; //FIXME
m_shape->paint(painter, converter, paintContext);
painter.restore();
}
void LinearChart::paintChart( QPainter& painter ) {
painter.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing );
this->paintAxis(painter);
QList<int> orderedColumns = this->calculateColumnsOrder();
foreach( int c, orderedColumns ) {
this->paintValues( painter, c );
}
void QSGPainterNode::paint()
{
QRect dirtyRect = m_dirtyRect.isNull() ? QRect(0, 0, m_size.width(), m_size.height()) : m_dirtyRect;
QPainter painter;
if (m_actualRenderTarget == QQuickPaintedItem::Image) {
if (m_image.isNull())
return;
painter.begin(&m_image);
} else {
if (!m_gl_device) {
m_gl_device = new QOpenGLPaintDevice(m_fboSize);
m_gl_device->setPaintFlipped(true);
}
if (m_multisampledFbo)
m_multisampledFbo->bind();
else
m_fbo->bind();
painter.begin(m_gl_device);
}
if (m_smoothPainting) {
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
}
painter.scale(m_contentsScale, m_contentsScale);
QRect sclip(qFloor(dirtyRect.x()/m_contentsScale),
qFloor(dirtyRect.y()/m_contentsScale),
qCeil(dirtyRect.width()/m_contentsScale+dirtyRect.x()/m_contentsScale-qFloor(dirtyRect.x()/m_contentsScale)),
qCeil(dirtyRect.height()/m_contentsScale+dirtyRect.y()/m_contentsScale-qFloor(dirtyRect.y()/m_contentsScale)));
if (!m_dirtyRect.isNull())
painter.setClipRect(sclip);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(sclip, m_fillColor);
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
m_item->paint(&painter);
painter.end();
if (m_actualRenderTarget == QQuickPaintedItem::Image) {
m_texture->setImage(m_image);
m_texture->setDirtyRect(dirtyRect);
} else if (m_multisampledFbo) {
QOpenGLFramebufferObject::blitFramebuffer(m_fbo, dirtyRect, m_multisampledFbo, dirtyRect);
}
if (m_multisampledFbo)
m_multisampledFbo->release();
else if (m_fbo)
m_fbo->release();
m_dirtyRect = QRect();
}
void ConnectionStatusWidget::paintEvent(QPaintEvent *){
QPainter myPainter;
myPainter.begin(this);
myPainter.setRenderHints(QPainter::Antialiasing);
myPainter.setBrush(diodeColor);
int radious = qMin(height(), width())/2 -1;
if(radious<1 )
radious = 1;
myPainter.drawEllipse(QPoint(width()/2,height()/2),radious,radious);
}
void GLC_Viewport::renderText(const GLC_Point3d& point, const QString &text, const QColor &color, const QFont &font)
{
m_TextRenderingCollection.clear();
if (!text.isEmpty())
{
QFontMetrics fontMetrics(font);
const double width= fontMetrics.width(text);
const double height= fontMetrics.height();
// Compute the ratio betwwen screen and world
const GLC_Matrix4x4 invertedViewMatrix(GLC_Context::current()->modelViewMatrix().rotationMatrix().invert());
const GLC_Vector2d projectedPoint1(project(point, false));
const GLC_Vector3d vector(invertedViewMatrix * GLC_Vector3d(0.0, height, 0.0));
const GLC_Vector2d projectedPoint2(project((point + vector), false));
const double ratio= height / (projectedPoint2 - projectedPoint1).length();
QPixmap pixmap(width, height);
pixmap.fill(Qt::transparent);
QPainter painter;
painter.begin(&pixmap);
painter.setRenderHints(QPainter::HighQualityAntialiasing | QPainter::TextAntialiasing);
painter.setFont(font);
painter.setPen(color);
painter.drawText(0, fontMetrics.ascent(), text);
painter.end();
QImage image= pixmap.toImage();
GLC_Texture *pTexture= new GLC_Texture(image);
GLC_Material* pMaterial= new GLC_Material(Qt::black);
pMaterial->setTexture(pTexture);
pMaterial->setOpacity(0.99);
GLC_3DViewInstance rectangle= GLC_Factory::instance()->createRectangle(width, height);
GLC_Matrix4x4 scaleMatrix;
scaleMatrix.setMatScaling(ratio, ratio, ratio);
rectangle.setMatrix(scaleMatrix);
rectangle.multMatrix(invertedViewMatrix);
rectangle.multMatrix(GLC_Matrix4x4(point));
rectangle.geomAt(0)->addMaterial(pMaterial);
m_TextRenderingCollection.add(rectangle);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisable(GL_DEPTH_TEST);
m_TextRenderingCollection.render(0, glc::TransparentRenderFlag);
glEnable(GL_DEPTH_TEST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
m_TextRenderingCollection.clear();
}
}
void KateRenderer::paintIndentMarker(QPainter &paint, uint x, uint y /*row*/)
{
QPen penBackup( paint.pen() );
QPen myPen(config()->indentationLineColor());
static const QVector<qreal> dashPattern = QVector<qreal>() << 1 << 1;
myPen.setDashPattern(dashPattern);
if (y % 2)
myPen.setDashOffset(1);
paint.setPen(myPen);
const int height = fontHeight();
const int top = 0;
const int bottom = height-1;
QPainter::RenderHints renderHints = paint.renderHints();
paint.setRenderHints(renderHints, false);
paint.drawLine(x + 2, top, x + 2, bottom);
paint.setRenderHints(renderHints, true);
paint.setPen( penBackup );
}
void MeshWidgetChart::paintEvent(QPaintEvent* event)
{
QWidget::paintEvent(event);
QPainter painter;
painter.begin(this);
setFont(font());
painter.setRenderHints(QPainter::TextAntialiasing);
painter.drawText(m_titleRect, Qt::AlignCenter, m_title);
ChartItemList items = m_topItem.items();
double maxVal = 0;
foreach (MeshChartItem* item, items) { maxVal = std::max(maxVal, item->value()); }
void PHISurfaceEffect::draw( QPainter *painter )
{
/*
QPoint offset;
QPixmap pixmap;
if ( sourceIsPixmap() ) {
// No point in drawing in device coordinates (pixmap will be scaled anyways).
pixmap=sourcePixmap( Qt::LogicalCoordinates, &offset );
} else {
// Draw pixmap in device coordinates to avoid pixmap scaling;
pixmap=sourcePixmap( Qt::DeviceCoordinates, &offset );
painter->setWorldTransform( QTransform() );
}
QImage img=pixmap.toImage();
img=PHI::getSurfacedImage( img, _yOff, _size );
painter->drawImage( offset, img );
*/
QRectF brect=sourceBoundingRect( Qt::LogicalCoordinates );
QImage img( static_cast<int>(brect.width()+1), static_cast<int>(brect.height()+_size+_yOff),
QImage::Format_ARGB32_Premultiplied );
QPainter pixPainter;
pixPainter.begin( &img );
pixPainter.setRenderHints( painter->renderHints() );
pixPainter.setCompositionMode( QPainter::CompositionMode_Clear );
pixPainter.fillRect( 0., 0., brect.width()+1., brect.height()+_size+_yOff+1, Qt::transparent );
pixPainter.setCompositionMode( QPainter::CompositionMode_SourceOver );
drawSource( &pixPainter );
QTransform t;
t.rotate( 180., Qt::XAxis );
t.translate( 0., (-brect.height()*2.)-_yOff+1. );
pixPainter.setTransform( t );
drawSource( &pixPainter );
pixPainter.resetTransform();
pixPainter.translate( 0., brect.height()+_yOff );
QLinearGradient gradient( 0., 0., 0., 1.0 );
gradient.setColorAt( 0., QColor( 0, 0, 0, 220 ) );
gradient.setColorAt( 0.78, QColor( 0, 0, 0, 30 ) );
gradient.setColorAt( 1., Qt::transparent );
gradient.setCoordinateMode( QGradient::ObjectBoundingMode );
pixPainter.setCompositionMode( QPainter::CompositionMode_DestinationIn );
pixPainter.fillRect( 0., 0., brect.width()+1, _size, gradient );
pixPainter.end();
painter->drawImage( 0, 0, img );
}
void PanWidget::
paintEvent ( QPaintEvent * event )
{
QPainter painter (this);
painter.setRenderHints (QPainter::Antialiasing | QPainter::HighQualityAntialiasing);
painter.fillPath (path_, QColor(220,220,220,200));
painter.strokePath (path_, QPen(
QColor(100,100,100,200),
hasFocus () ? 1.6 : .8,
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin));
QWidget::paintEvent(event);
}
void AnchorGraph::paint_( QPainter &painter )
{
QBrush brush( Qt::lightGray );
painter.setRenderHints( QPainter::Antialiasing | QPainter::HighQualityAntialiasing );
painter.setPen( Qt::lightGray );
painter.setBrush( brush );
const FloatVector& tfData = transferFunctionPtr_->getData( );
for ( uint32_t i = 0; i < transferFunctionPtr_->getNumChannels( ); ++i )
{
painter.setPen( colors_[ i ] );
paintCurve_( painter, static_cast< ColorChannel >( i ), tfData.size( ) / transferFunctionPtr_->getNumChannels( ) );
paintAnchors_( painter, static_cast< ColorChannel >( i ) );
}
}
void QvkWidgetcircle::paintEvent( QPaintEvent *event )
{
(void)event;
QRegion RegionWidget( 0, 0, width(), height() );
QRegion RegionPaint( 0, 0, width(), height(), QRegion::Ellipse );
#ifdef QT4
QRegion RegionSpace = RegionWidget.subtract( RegionPaint );
QRegion RegionPaintWidget = RegionWidget.subtract( RegionSpace );
#endif
#ifdef QT5
QRegion RegionSpace = RegionWidget.subtracted( RegionPaint );
QRegion RegionPaintWidget = RegionWidget.subtracted( RegionSpace );
#endif
setMask(RegionPaintWidget);
QPainter painter;;
painter.begin( this );
painter.setRenderHints( QPainter::Antialiasing, true );
QBrush brush( widgetColor, Qt::SolidPattern );
painter.setBrush( brush );
painter.setPen( widgetColor );
painter.drawEllipse ( QPoint( width()/2, height()/2), width()/2-1, height()/2-1 );
if ( set == false )
{
QBrush brush_1( Qt::white, Qt::SolidPattern );
painter.setBrush( brush_1 );
painter.setPen( Qt::white );
painter.drawEllipse ( QPoint( width()/2, height()/2), width()/5, height()/5 );
}
if ( set == true )
{
QBrush brush_2( Qt::white, Qt::SolidPattern );
painter.setBrush( brush_2 );
painter.setPen( Qt::white );
painter.drawEllipse ( QPoint( width()/2, height()/2), width()/5, height()/5 );
QBrush brush_3( Qt::black, Qt::SolidPattern );
painter.setBrush( brush_3 );
painter.setPen( Qt::black );
painter.drawEllipse ( QPoint( width()/2, height()/2), width()/5-2, height()/5-2 );
}
painter.end();
}
void UvTemplateDialog::generateImage()
{
QString mapName=uvMapDrop->text();
QString fileName = QFileDialog::getSaveFileName(this, "Save UV Image Template", db->getProgramOptions()->lastSavedPathUVTemplate+"\\"+mapName,"Image (*.png)");
if(fileName.isNull())
{
savedMsg->setText("Save cancelled.");
return;
}
UvData uvData;
int number=uvSizeEdit->text().toInt();
QImage img(QSize(number,number),QImage::Format_ARGB32);
QColor empty(255,255,255,0);
img.fill(empty.rgba());
QPainter painter;
QPalette palette = uvFColor->palette();
painter.begin(&img);
painter.setRenderHints (QPainter::Antialiasing,false);
painter.setPen(palette.color(QPalette::Button));
uvData.painter=&painter;
uvData.mainData=lwMain;
// set the current uv map to one we will be editing
lwMain->editOp->pointVSet(lwMain->editOp->state,0,LWVMAP_TXUV,mapName.toAscii().data());
lwMain->editOp->polyScan( lwMain->editOp->state, (EDPolyScanFunc (__cdecl *))UvTemplateDialog::scan_poly_for_uv, &uvData, OPLYR_NONEMPTY );
painter.end();
img.save (fileName, "png");
savedMsg->setText("Template saved.");
QFileInfo filePath(fileName);
db->getProgramOptions()->lastSavedPathUVTemplate=filePath.path();
}
bool ExportWizard::printPdf()
{
// get dpi, compute printed size
int printDpi = m_pdfPrinter->resolution();
QSizeF canvasPrintSize = canvasNatInches() * (qreal)printDpi;
Qt::AspectRatioMode printAspect = Qt::KeepAspectRatio;
// open the painter over the printer
QPainter painter;
if (!painter.begin(m_pdfPrinter)) {
QMessageBox::warning(0, tr("PDF Error"), tr("Error saving to the PDF file, try to chose another one."), QMessageBox::Cancel);
return false;
}
QRect paperRect = painter.viewport();
QRect targetRect(0, 0, (int)canvasPrintSize.width(), (int)canvasPrintSize.height());
// adapt rect Scale
switch (m_ui->pdfScaleCombo->currentIndex()) {
case 0: // Original
break;
case 1: { // Fit to page
QSize targetSize = targetRect.size();
targetSize.scale(paperRect.size(), printAspect);
targetRect.setSize(targetSize);
} break;
}
// adapt Position
switch (m_ui->pdfPosCombo->currentIndex()) {
case 0: // Top Left
targetRect.moveTopLeft(paperRect.topLeft());
break;
case 1: // Center
targetRect.moveCenter(paperRect.center());
break;
}
// render to PDF
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform, true);
RenderOpts::PDFExporting = true;
m_canvas->renderVisible(&painter, targetRect, m_canvas->sceneRect(), Qt::IgnoreAspectRatio, true);
RenderOpts::PDFExporting = false;
painter.end();
return true;
}
void RescaleWidget::
paintEvent(QPaintEvent *event)
{
QPainter painter (this);
painter.setRenderHints (QPainter::Antialiasing | QPainter::HighQualityAntialiasing);
//painter.fillPath (path_, QBrush(QColor(125,125,125,125)));
painter.fillPath (path_, QColor(220,220,220,200));
painter.strokePath (path_, QPen(
QColor(100,100,100,200),
hasFocus () ? 1.6 : .8,
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin));
//painter.drawImage(QPoint(),qimage_);
QWidget::paintEvent (event);
}
void myGauge1::paintEvent(QPaintEvent *)
{
QPainter painter;
painter.begin(this);
painter.setRenderHints(QPainter::Antialiasing|QPainter::TextAntialiasing);
resetVariables(&painter);
drawOuterCircle(&painter);
drawInnerCircle(&painter);
drawColorPies(&painter);
drawGraph(&painter);
drawCoverLines(&painter);
drawCoverCircle(&painter);
drawMarkAndText(&painter);
drawTextRect(&painter);
painter.end();
}
void GraphWidget::paintEvent (QPaintEvent*)
{
quint64 max = 0;
for (int i = 0; i < DownSpeeds_.size (); ++i)
{
if (DownSpeeds_.at (i) > max)
max = DownSpeeds_.at (i);
if (UpSpeeds_.at (i) > max)
max = UpSpeeds_.at (i);
}
QPainter painter (this);
painter.setRenderHints (QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
if (max && DownSpeeds_.size ())
{
painter.setPen (UpColor_);
PaintSingle (max, UpSpeeds_, &painter);
painter.setPen (DownColor_);
PaintSingle (max, DownSpeeds_, &painter);
}
}
void paint_QPixmapCachedRoundedRect(QPainter &p)
{
static bool first = true;
static QPixmap cacheRect;
if (first) {
const int pw = 0;
const int radius = 8;
cacheRect = QPixmap(radius*2 + 3 + pw*2, radius*2 + 3 + pw*2);
cacheRect.fill(Qt::transparent);
QPainter paint(&cacheRect);
paint.setRenderHint(QPainter::Antialiasing);
paint.setPen(Qt::black);
paint.setBrush(Qt::red);
if (pw%2)
paint.drawRoundedRect(QRectF(qreal(pw)/2+1, qreal(pw)/2+1, cacheRect.width()-(pw+1), cacheRect.height()-(pw+1)), radius, radius);
else
paint.drawRoundedRect(QRectF(qreal(pw)/2, qreal(pw)/2, cacheRect.width()-pw, cacheRect.height()-pw), radius, radius);
first = false;
}
for (int i = 0; i < count; i++) {
for (int j = 0; j < lines; ++j) {
QSize size((j+1)*50, spacing-1);
p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, true);
const int pw = 0;
int xOffset = (cacheRect.width()-1)/2;
int yOffset = (cacheRect.height()-1)/2;
QMargins margins(xOffset, yOffset, xOffset, yOffset);
QTileRules rules(Qt::StretchTile, Qt::StretchTile);
//NOTE: even though our item may have qreal-based width and height, qDrawBorderPixmap only supports QRects
qDrawBorderPixmap(&p, QRect(-pw/2, j*spacing-pw/2, size.width()+pw, size.height()+pw), margins, cacheRect, cacheRect.rect(), margins, rules);
}
}
}
// --------------------------------------------------------------------------------------------------------------------------------------
void CCachedGraphicsItem::updateCache()
{
if(isActive())
{
QPixmap *pixmap = new QPixmap(size().toSize());
pixmap->fill(QColor(0,0,0,0));
QPainter *painter = new QPainter(pixmap);
painter->setBackgroundMode(Qt::TransparentMode);
painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing, true);
painter->setPen(m_stdPen);
painter->setBrush(m_stdBrush);
painter->setFont(m_stdFont);
paintToCache(painter);
delete painter;
QPixmap *tmp = m_pixmap;
m_pixmap = pixmap;
delete tmp;
//update(boundingRect());
}
}
void PiecesWidget::paintEvent (QPaintEvent *e)
{
int s = Pieces_.size ();
QPainter painter (this);
painter.setRenderHints (QPainter::Antialiasing |
QPainter::SmoothPixmapTransform);
if (!s)
{
painter.setBackgroundMode (Qt::OpaqueMode);
painter.setBackground (Qt::white);
painter.end ();
return;
}
const QPalette& palette = QApplication::palette ();
const QColor& backgroundColor = palette.color (QPalette::Base);
const QColor& downloadedPieceColor = palette.color (QPalette::Highlight);
QPixmap tempPicture (s, 1);
QPainter tempPainter (&tempPicture);
tempPainter.setPen (backgroundColor);
tempPainter.drawLine (0, 0, s, 0);
QList<QPair<int, int> > trues = FindTrues (Pieces_);
for (int i = 0; i < trues.size (); ++i)
{
QPair<int, int> pair = trues.at (i);
tempPainter.setPen (downloadedPieceColor);
tempPainter.drawLine (pair.first, 0, pair.second, 0);
}
tempPainter.end ();
painter.drawPixmap (QRect (0, 0, width (), height ()), tempPicture);
painter.end ();
e->accept ();
}
//___________________________________________________
void Button::paint( QPainter& painter )
{
QPalette palette( _client.palette() );
palette.setCurrentColorGroup( isActive() ? QPalette::Active : QPalette::Inactive);
if(
_client.compositingActive() &&
!( _client.isMaximized() || _type == ButtonItemClose || _type == ButtonItemMenu ) )
{ painter.translate( 0, -1 ); }
// translate buttons down if window maximized
if( _client.isMaximized() ) painter.translate( 0, 1 );
// base button color
QColor base;
if( _type == ButtonItemClose && _forceInactive ) base = _client.backgroundPalette( this, palette ).window().color();
else if( _type == ButtonItemClose ) base = palette.window().color();
else base = palette.button().color();
// text color
QColor color = (_type == ButtonItemClose && _forceInactive ) ?
buttonDetailColor( _client.backgroundPalette( this, palette ) ):
buttonDetailColor( palette );
// decide decoration color
QColor glow;
if( isAnimated() || (_status&Hovered) )
{
glow = isCloseButton() ?
_helper.viewNegativeTextBrush().brush(palette).color():
_helper.viewHoverBrush().brush(palette).color();
if( isAnimated() )
{
color = KColorUtils::mix( color, glow, glowIntensity() );
glow = _helper.alphaColor( glow, glowIntensity() );
} else if( _status&Hovered ) color = glow;
}
if( hasDecoration() )
{
// scale
qreal scale( (21.0*_client.buttonSize())/22.0 );
// pressed state
const bool pressed(
(_status&Pressed) ||
( _type == ButtonSticky && _client.isOnAllDesktops() ) ||
( _type == ButtonAbove && _client.keepAbove() ) ||
( _type == ButtonBelow && _client.keepBelow() ) );
// draw button shape
painter.drawPixmap(0, 0, _helper.windecoButton( base, glow, pressed, scale ) );
}
// Icon
// for menu button the application icon is used
if( isMenuButton() )
{
int iconScale( 0 );
switch( _client.buttonSize() )
{
case Configuration::ButtonSmall: iconScale = 13; break;
default:
case Configuration::ButtonDefault: iconScale = 16; break;
case Configuration::ButtonLarge: iconScale = 20; break;
case Configuration::ButtonVeryLarge: iconScale = 24; break;
case Configuration::ButtonHuge: iconScale = 35; break;
}
const QPixmap& pixmap( _client.icon().pixmap( iconScale ) );
const double offset = 0.5*(width()-pixmap.width() );
painter.drawPixmap(offset, offset-1, pixmap );
} else {
painter.setRenderHints(QPainter::Antialiasing);
qreal width( 1.2 );
// contrast
painter.setBrush(Qt::NoBrush);
painter.setPen(QPen( _helper.calcLightColor( base ), width, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
drawIcon(&painter);
// main
painter.translate(0,-1.5);
painter.setBrush(Qt::NoBrush);
painter.setPen(QPen(color, width, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
drawIcon(&painter);
}
}
static int get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
mlt_properties properties = MLT_FRAME_PROPERTIES( a_frame );
mlt_transition transition = MLT_TRANSITION( mlt_frame_pop_service( a_frame ) );
uint8_t *b_image;
int window_size = mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "window_size" );
double psnr[3], ssim[3];
*format = mlt_image_yuv422;
mlt_frame_get_image( b_frame, &b_image, format, width, height, writable );
mlt_frame_get_image( a_frame, image, format, width, height, writable );
psnr[0] = calc_psnr( *image, b_image, *width * *height, 2 );
psnr[1] = calc_psnr( *image + 1, b_image + 1, *width * *height / 2, 4 );
psnr[2] = calc_psnr( *image + 3, b_image + 3, *width * *height / 2, 4 );
ssim[0] = calc_ssim( *image, b_image, *width, *height, window_size, 2 );
ssim[1] = calc_ssim( *image + 1, b_image + 1, *width / 2, *height, window_size, 4 );
ssim[2] = calc_ssim( *image + 3, b_image + 3, *width / 2, *height, window_size, 4 );
mlt_properties_set_double( properties, "meta.vqm.psnr.y", psnr[0] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cb", psnr[1] );
mlt_properties_set_double( properties, "meta.vqm.psnr.cr", psnr[2] );
mlt_properties_set_double( properties, "meta.vqm.ssim.y", ssim[0] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cb", ssim[1] );
mlt_properties_set_double( properties, "meta.vqm.ssim.cr", ssim[2] );
printf( "%05d %05.2f %05.2f %05.2f %5.3f %5.3f %5.3f\n",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
// copy the B frame to the bottom of the A frame for comparison
window_size = mlt_image_format_size( *format, *width, *height, NULL ) / 2;
memcpy( *image + window_size, b_image + window_size, window_size );
if ( !mlt_properties_get_int( MLT_TRANSITION_PROPERTIES( transition ), "render" ) )
return 0;
// get RGBA image for Qt drawing
*format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// convert mlt image to qimage
QImage img( *width, *height, QImage::Format_ARGB32 );
int y = *height + 1;
uint8_t *src = *image;
while ( --y )
{
QRgb *dst = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRgba( src[0], src[1], src[2], 255 );
src += 4;
}
}
// setup Qt drawing
QPainter painter;
painter.begin( &img );
painter.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing );
// draw some stuff with Qt
QPalette palette;
QFont font;
QString s;
font.setBold( true );
font.setPointSize( 30 * *height / 1080 );
painter.setPen( QColor("black") );
painter.drawLine( 0, *height/2 + 1, *width, *height/2 );
painter.setPen( QColor("white") );
painter.drawLine( 0, *height/2 - 1, *width, *height/2 );
painter.setFont( font );
s.sprintf( "Frame: %05d\nPSNR: %05.2f (Y) %05.2f (Cb) %05.2f (Cr)\nSSIM: %5.3f (Y) %5.3f (Cb) %5.3f (Cr)",
mlt_frame_get_position( a_frame ), psnr[0], psnr[1], psnr[2],
ssim[0], ssim[1], ssim[2] );
painter.setPen( QColor("black") );
painter.drawText( 52, *height * 8 / 10 + 2, *width, *height, 0, s );
painter.setPen( QColor("white") );
painter.drawText( 50, *height * 8 / 10, *width, *height, 0, s );
// finish Qt drawing
painter.end();
window_size = mlt_image_format_size( *format, *width, *height, NULL );
uint8_t *dst = (uint8_t *) mlt_pool_alloc( window_size );
mlt_properties_set_data( MLT_FRAME_PROPERTIES(a_frame), "image", dst, window_size, mlt_pool_release, NULL );
*image = dst;
// convert qimage to mlt
y = *height + 1;
while ( --y )
{
QRgb *src = (QRgb*) img.scanLine( *height - y );
int x = *width + 1;
while ( --x )
{
*dst++ = qRed( *src );
*dst++ = qGreen( *src );
*dst++ = qBlue( *src );
*dst++ = qAlpha( *src );
src++;
}
}
return 0;
}
void
ImageView::onPaint(QPainter& painter, InteractionState const& interaction)
{
painter.setWorldMatrixEnabled(false);
painter.setRenderHints(QPainter::Antialiasing, false);
double const w = maxViewportRect().width();
double const h = maxViewportRect().height();
QPointF const center(getImageRotationOrigin());
// Draw the semi-transparent grid.
QPen pen(QColor(0, 0, 255, 90));
pen.setCosmetic(true);
pen.setWidth(1);
painter.setPen(pen);
QVector<QLineF> lines;
for (double y = center.y(); (y -= m_cellSize) > 0.0;) {
lines.push_back(QLineF(0.5, y, w - 0.5, y));
}
for (double y = center.y(); (y += m_cellSize) < h;) {
lines.push_back(QLineF(0.5, y, w - 0.5, y));
}
for (double x = center.x(); (x -= m_cellSize) > 0.0;) {
lines.push_back(QLineF(x, 0.5, x, h - 0.5));
}
for (double x = center.x(); (x += m_cellSize) < w;) {
lines.push_back(QLineF(x, 0.5, x, h - 0.5));
}
painter.drawLines(lines);
// Draw the horizontal and vertical line crossing at the center.
pen.setColor(QColor(0, 0, 255));
painter.setPen(pen);
painter.setBrush(Qt::NoBrush);
painter.drawLine(
QPointF(0.5, center.y()),
QPointF(w - 0.5, center.y())
);
painter.drawLine(
QPointF(center.x(), 0.5),
QPointF(center.x(), h - 0.5)
);
// Draw the rotation arcs.
// Those will look like this ( )
QRectF const arc_square(getRotationArcSquare());
painter.setRenderHints(QPainter::Antialiasing, true);
pen.setWidthF(1.5);
painter.setPen(pen);
painter.setBrush(Qt::NoBrush);
painter.drawArc(
arc_square,
qRound(16 * -m_maxRotationDeg),
qRound(16 * 2 * m_maxRotationDeg)
);
painter.drawArc(
arc_square,
qRound(16 * (180 - m_maxRotationDeg)),
qRound(16 * 2 * m_maxRotationDeg)
);
std::pair<QPointF, QPointF> const handles(
getRotationHandles(arc_square)
);
QRectF rect(m_handlePixmap.rect());
rect.moveCenter(handles.first);
painter.drawPixmap(rect.topLeft(), m_handlePixmap);
rect.moveCenter(handles.second);
painter.drawPixmap(rect.topLeft(), m_handlePixmap);
}