void
PixmapRenderer::drawPixmapNoXRender(QPainter& painter, QPixmap const& pixmap)
{
QTransform const inv_transform(painter.worldTransform().inverted());
QRectF const src_rect(inv_transform.map(QRectF(painter.viewport())).boundingRect());
QRectF const bounded_src_rect(src_rect.intersected(pixmap.rect()));
painter.drawPixmap(bounded_src_rect, pixmap, bounded_src_rect);
}
void KisCanvasWidgetBase::drawDecorations(QPainter & gc, const QRect &updateWidgetRect) const
{
gc.save();
if (!m_d->canvas) {
dbgFile<<"canvas doesn't exist, in canvas widget base!";
}
// Setup the painter to take care of the offset; all that the
// classes that do painting need to keep track of is resolution
gc.setRenderHint(QPainter::Antialiasing);
gc.setRenderHint(QPainter::TextAntialiasing);
// This option does not do anything anymore with Qt4.6, so don't reenable it since it seems to break display
// http://www.archivum.info/[email protected]/2010-01/00481/Re:-(Qt-interest)-Is-QPainter::HighQualityAntialiasing-render-hint-broken-in-Qt-4.6.html
// gc.setRenderHint(QPainter::HighQualityAntialiasing);
gc.setRenderHint(QPainter::SmoothPixmapTransform);
gc.save();
gc.setClipRect(updateWidgetRect);
QTransform transform = m_d->coordinatesConverter->flakeToWidgetTransform();
gc.setTransform(transform);
// Paint the shapes (other than the layers)
m_d->canvas->globalShapeManager()->paint(gc, *m_d->viewConverter, false);
// draw green selection outlines around text shapes that are edited, so the user sees where they end
gc.save();
QTransform worldTransform = gc.worldTransform();
gc.setPen( Qt::green );
Q_FOREACH (KoShape *shape, canvas()->shapeManager()->selection()->selectedShapes()) {
if (shape->shapeId() == "ArtisticText" || shape->shapeId() == "TextShapeID") {
gc.setWorldTransform(shape->absoluteTransformation(m_d->viewConverter) * worldTransform);
KoShape::applyConversion(gc, *m_d->viewConverter);
gc.drawRect(QRectF(QPointF(), shape->size()));
}
}
gc.restore();
// Draw text shape over canvas while editing it, that's needs to show the text selection correctly
QString toolId = KoToolManager::instance()->activeToolId();
if (toolId == "ArtisticTextTool" || toolId == "TextTool") {
gc.save();
gc.setPen(Qt::NoPen);
gc.setBrush(Qt::NoBrush);
Q_FOREACH (KoShape *shape, canvas()->shapeManager()->selection()->selectedShapes()) {
if (shape->shapeId() == "ArtisticText" || shape->shapeId() == "TextShapeID") {
KoShapePaintingContext paintContext(canvas(), false);
gc.save();
gc.setTransform(shape->absoluteTransformation(m_d->viewConverter) * gc.transform());
canvas()->shapeManager()->paintShape(shape, gc, *m_d->viewConverter, paintContext);
gc.restore();
}
}
gc.restore();
}
void plotPathsToPainter(QPainter& painter, QPainterPath& path,
const Numpy1DObj& x, const Numpy1DObj& y,
const Numpy1DObj* scaling,
const QRectF* clip,
const QImage* colorimg)
{
QRectF cliprect( QPointF(-32767,-32767), QPointF(32767,32767) );
if( clip != 0 )
{
qreal x1, y1, x2, y2;
clip->getCoords(&x1, &y1, &x2, &y2);
cliprect.setCoords(x1, y1, x2, y2);
}
QRectF pathbox = path.boundingRect();
cliprect.adjust(pathbox.left(), pathbox.top(),
pathbox.bottom(), pathbox.right());
// keep track of duplicate points
QPointF lastpt(-1e6, -1e6);
// keep original transformation for restoration after each iteration
QTransform origtrans(painter.worldTransform());
// number of iterations
int size = min(x.dim, y.dim);
// if few color points, trim down number of paths
if( colorimg != 0 )
size = min(size, colorimg->width());
// too few scaling points
if( scaling != 0 )
size = min(size, scaling->dim);
// draw each path
for(int i = 0; i < size; ++i)
{
const QPointF pt(x(i), y(i));
if( cliprect.contains(pt) && ! smallDelta(lastpt, pt) )
{
painter.translate(pt);
if( scaling != 0 )
{
// scale point if requested
const qreal s = (*scaling)(i);
painter.scale(s, s);
}
if( colorimg != 0 )
{
// get color from pixel and create a new brush
QBrush b( QColor::fromRgba(colorimg->pixel(i, 0)) );
painter.setBrush(b);
}
painter.drawPath(path);
painter.setWorldTransform(origtrans);
lastpt = pt;
}
}
}
void KParameterShape::paintHandle(QPainter & painter, const KViewConverter & converter, int handleId, int handleRadius)
{
Q_D(KParameterShape);
applyConversion(painter, converter);
QTransform worldMatrix = painter.worldTransform();
painter.setTransform(QTransform());
QTransform matrix;
matrix.rotate(45.0);
QPolygonF poly(d->handleRect(QPointF(0, 0), handleRadius));
poly = matrix.map(poly);
poly.translate(worldMatrix.map(d->handles[handleId]));
painter.drawPolygon(poly);
}
void CGContextDrawLayerInRect(CGContextRef context, CGRect rect, CGLayerRef layer)
{
QPainter* painter = CGContextGetPainter(context);
QTransform tf = painter->worldTransform();
qreal sx, sy;
CGSize origSize = CGLayerGetSize(layer);
sx = CGRectGetWidth(rect) / origSize.width;
sy = CGRectGetHeight(rect) / origSize.height;
painter->scale(sx, sy);
painter->drawPicture(QPointF(rect.origin.x / sx, rect.origin.y / sy), *layer->picture);
painter->setWorldTransform(tf);
}
void KoPathPoint::paint(QPainter &painter, int handleRadius, PointTypes types, bool active)
{
QRectF handle(-handleRadius, -handleRadius, 2*handleRadius, 2*handleRadius);
bool drawControlPoint1 = types & ControlPoint1 && (!active || activeControlPoint1());
bool drawControlPoint2 = types & ControlPoint2 && (!active || activeControlPoint2());
// draw lines at the bottom
if (drawControlPoint2)
painter.drawLine(point(), controlPoint2());
if (drawControlPoint1)
painter.drawLine(point(), controlPoint1());
QTransform worldMatrix = painter.worldTransform();
painter.setWorldTransform(QTransform());
// the point is lowest
if (types & Node) {
if (properties() & IsSmooth)
painter.drawRect(handle.translated(worldMatrix.map(point())));
else if (properties() & IsSymmetric) {
QTransform matrix;
matrix.rotate(45.0);
QPolygonF poly(handle);
poly = matrix.map(poly);
poly.translate(worldMatrix.map(point()));
painter.drawPolygon(poly);
} else
painter.drawEllipse(handle.translated(worldMatrix.map(point())));
}
// then comes control point 2
if (drawControlPoint2)
painter.drawEllipse(handle.translated(worldMatrix.map(controlPoint2())));
// then comes control point 1
if (drawControlPoint1)
painter.drawEllipse(handle.translated(worldMatrix.map(controlPoint1())));
painter.setWorldTransform(worldMatrix);
}
void TextureMapperLayerClientQt::renderCompositedLayers(GraphicsContext* context, const IntRect& clip)
{
if (!m_rootTextureMapperLayer || !m_textureMapper)
return;
m_textureMapper->setGraphicsContext(context);
// GraphicsContext::imageInterpolationQuality is always InterpolationDefault here,
// but 'default' may be interpreted differently due to a different backend QPainter,
// so we need to set an explicit imageInterpolationQuality.
if (context->platformContext()->renderHints() & QPainter::SmoothPixmapTransform)
m_textureMapper->setImageInterpolationQuality(WebCore::InterpolationMedium);
else
m_textureMapper->setImageInterpolationQuality(WebCore::InterpolationNone);
m_textureMapper->setTextDrawingMode(context->textDrawingMode());
QPainter* painter = context->platformContext();
QTransform transform;
if (m_textureMapper->accelerationMode() == TextureMapper::OpenGLMode) {
// TextureMapperGL needs to duplicate the entire transform QPainter would do,
// including the transforms QPainter would normally do behind the scenes.
transform = painter->deviceTransform();
} else {
// TextureMapperImageBuffer needs a transform that can be used
// with QPainter::setWorldTransform.
transform = painter->worldTransform();
}
const TransformationMatrix matrix(
transform.m11(), transform.m12(), 0, transform.m13(),
transform.m21(), transform.m22(), 0, transform.m23(),
0, 0, 1, 0,
transform.m31(), transform.m32(), 0, transform.m33()
);
if (m_rootGraphicsLayer->opacity() != painter->opacity() || m_rootGraphicsLayer->transform() != matrix) {
m_rootGraphicsLayer->setOpacity(painter->opacity());
m_rootGraphicsLayer->setTransform(matrix);
m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
}
m_textureMapper->beginPainting();
m_textureMapper->beginClip(matrix, clip);
m_rootTextureMapperLayer->paint();
m_fpsCounter.updateFPSAndDisplay(m_textureMapper.get(), IntPoint::zero(), matrix);
m_textureMapper->endClip();
m_textureMapper->endPainting();
}
void KParameterShape::paintHandles(QPainter & painter, const KViewConverter & converter, int handleRadius)
{
Q_D(KParameterShape);
applyConversion(painter, converter);
QTransform worldMatrix = painter.worldTransform();
painter.setTransform(QTransform());
QTransform matrix;
matrix.rotate(45.0);
QPolygonF poly(d->handleRect(QPointF(0, 0), handleRadius));
poly = matrix.map(poly);
QList<QPointF>::const_iterator it(d->handles.constBegin());
for (; it != d->handles.constEnd(); ++it) {
QPointF moveVector = worldMatrix.map(*it);
poly.translate(moveVector.x(), moveVector.y());
painter.drawPolygon(poly);
poly.translate(-moveVector.x(), -moveVector.y());
}
}
void Tile::paintCheckerPattern(GraphicsContext* context, const FloatRect& target)
{
QPainter* painter = context->platformContext();
QTransform worldTransform = painter->worldTransform();
qreal scaleX = worldTransform.m11();
qreal scaleY = worldTransform.m22();
QRect targetViewRect = QRectF(target.x() * scaleX,
target.y() * scaleY,
target.width() * scaleX,
target.height() * scaleY).toAlignedRect();
QTransform adjustedTransform(1., worldTransform.m12(), worldTransform.m13(),
worldTransform.m21(), 1., worldTransform.m23(),
worldTransform.m31(), worldTransform.m32(), worldTransform.m33());
painter->setWorldTransform(adjustedTransform);
painter->drawTiledPixmap(targetViewRect,
checkeredPixmap(),
QPoint(targetViewRect.left() % checkerSize,
targetViewRect.top() % checkerSize));
painter->setWorldTransform(worldTransform);
}
void
DewarpingView::onPaint(QPainter& painter, InteractionState const& interaction)
{
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0xff, 0xff, 0xff, 150)); // Translucent white.
painter.drawPolygon(virtMarginArea(0)); // Left margin.
painter.drawPolygon(virtMarginArea(1)); // Right margin.
painter.setWorldTransform(imageToVirtual() * painter.worldTransform());
painter.setBrush(Qt::NoBrush);
QPen grid_pen;
grid_pen.setColor(Qt::blue);
grid_pen.setCosmetic(true);
grid_pen.setWidthF(1.2);
painter.setPen(grid_pen);
painter.setBrush(Qt::NoBrush);
int const num_vert_grid_lines = 30;
int const num_hor_grid_lines = 30;
bool valid_model = m_distortionModel.isValid();
if (valid_model) {
try {
std::vector<QVector<QPointF> > curves(num_hor_grid_lines);
dewarping::CylindricalSurfaceDewarper dewarper(
m_distortionModel.topCurve().polyline(),
m_distortionModel.bottomCurve().polyline(), m_depthPerception.value()
);
dewarping::CylindricalSurfaceDewarper::State state;
for (int j = 0; j < num_vert_grid_lines; ++j) {
double const x = j / (num_vert_grid_lines - 1.0);
dewarping::CylindricalSurfaceDewarper::Generatrix const gtx(dewarper.mapGeneratrix(x, state));
QPointF const gtx_p0(gtx.imgLine.pointAt(gtx.pln2img(0)));
QPointF const gtx_p1(gtx.imgLine.pointAt(gtx.pln2img(1)));
painter.drawLine(gtx_p0, gtx_p1);
for (int i = 0; i < num_hor_grid_lines; ++i) {
double const y = i / (num_hor_grid_lines - 1.0);
curves[i].push_back(gtx.imgLine.pointAt(gtx.pln2img(y)));
}
}
BOOST_FOREACH(QVector<QPointF> const& curve, curves) {
painter.drawPolyline(curve);
}
} catch (std::runtime_error const&) {
// Still probably a bad model, even though DistortionModel::isValid() was true.
valid_model = false;
}
} // valid_model
if (!valid_model) {
// Just draw the frame.
dewarping::Curve const& top_curve = m_distortionModel.topCurve();
dewarping::Curve const& bottom_curve = m_distortionModel.bottomCurve();
painter.drawLine(top_curve.polyline().front(), bottom_curve.polyline().front());
painter.drawLine(top_curve.polyline().back(), bottom_curve.polyline().back());
painter.drawPolyline(QVector<QPointF>::fromStdVector(top_curve.polyline()));
painter.drawPolyline(QVector<QPointF>::fromStdVector(bottom_curve.polyline()));
}
paintXSpline(painter, interaction, m_topSpline);
paintXSpline(painter, interaction, m_bottomSpline);
}
//-------------------------------------------------------------------------
void QGuidoPainter::draw( QPainter * painter , int page , const QRect& drawRectangle , const QRect& redrawRectangle)
{
if ( !hasValidGR() )
return;
painter->save();
painter->setClipRect( drawRectangle );
painter->translate( drawRectangle.x() , drawRectangle.y() );
//Creation of temporaries Qt implementations of VGSystem & VGDevice.
VGSystem * sys = new GSystemQt( painter );
VGDevice * dev = sys->CreateDisplayDevice();
//Update the mDesc with the specified page and draw dimensions.
mDesc.hdc = dev;
page = MAX(1 , page);
page = MIN(pageCount() , page);
mDesc.page = page;
mDesc.sizex = drawRectangle.width();
mDesc.sizey = drawRectangle.height();
//mDesc.scrollx = -drawRectangle.x();
//mDesc.scrolly = -drawRectangle.y();
if ( redrawRectangle.isNull() )
{
//Redraw everything
mDesc.updateRegion.erase = true;
}
else
{
//1. Computes the actual drawing rectangle
//(because the Guido Score won't strech and will keep its height/width ratio,
//the drawing rectangle is different from the QPainter's QPaintDevice rectangle.).
float ratio = heightForWidth(1000,page) / 1000.0f;
//This ratio means that: height = ratio * width.
bool drawRectTooHigh = ( mDesc.sizey >= (mDesc.sizex * ratio) );
int actualWidth, actualHeight;
if ( drawRectTooHigh )
{
actualWidth = mDesc.sizex;
actualHeight = actualWidth * ratio;
}
else
{
actualHeight = mDesc.sizey;
actualWidth = actualHeight / ratio;
}
//2. Conversion of the redrawRectangle from QPaintDevice coordinate space to GuidoVirtualUnit.
GuidoPageFormat format;
GuidoGetPageFormat( mDesc.handle , page , &format );
float widthConversionFactor = actualWidth / format.width;
float heightConversionFactor = actualHeight / format.height;
// pixel / conversionFactor = GuidoVirtualUnit
mDesc.updateRegion.left = (redrawRectangle.x() - drawRectangle.x()) / widthConversionFactor;
mDesc.updateRegion.top = (redrawRectangle.y() - drawRectangle.y()) / heightConversionFactor;
mDesc.updateRegion.right = ( (redrawRectangle.x() - drawRectangle.x()) + redrawRectangle.width() ) / widthConversionFactor;
mDesc.updateRegion.bottom = ( (redrawRectangle.y() - drawRectangle.y()) + redrawRectangle.height() ) / heightConversionFactor;
mDesc.updateRegion.erase = false;
}
// QTime time;
// time.start();
//Actual draw of the Guido Score.
VGColor color(fCurrentColor.red(), fCurrentColor.green(), fCurrentColor.blue(), fCurrentColor.alpha());
dev->SelectPenColor (color);
dev->SelectFillColor(color);
dev->SetFontColor (color);
#if absoluteTransform1 || absoluteTransform2
// DF Apr. 28 2011
// rescaling introduced to take account of the QTDevice::SetScale change
// the QTDevice::SetScale change corresponds to the common VGDevice demantic and implementation
// actually commented out due to unresolved problems with rotations
qreal xs, ys;
QPainter * p = (QPainter*)dev->GetNativeContext();
p->worldTransform().map(qreal(mDesc.sizex), qreal(mDesc.sizey), &xs, &ys);
mDesc.sizex = xs;
mDesc.sizey = ys;
#endif
GuidoOnDraw (&mDesc);
// qDebug("Score : width = %d , height = %d" , mDesc.sizex , mDesc.sizey );
// qDebug("QGuidoPainter: Draw time : %d ms" , time.elapsed() );
delete dev;
delete sys;
painter->restore();
}
