/**
* @brief NewSceneRect calculate scene rect what contains all items and doesn't less that size of scene view.
* @param sc scene.
* @param view view.
*/
void VAbstractTool::NewSceneRect(QGraphicsScene *sc, QGraphicsView *view)
{
QRectF rect = sc->itemsBoundingRect();
QRect rec0 = view->rect();
rec0 = QRect(0, 0, rec0.width()-2, rec0.height()-2);
QTransform t = view->transform();
QRectF rec1;
if (t.m11() < 1)
{
qreal width = rec0.width()/t.m11();
qreal height = rec0.height()/t.m22();
rec1 = QRect(0, 0, static_cast<qint32>(width), static_cast<qint32>(height));
rec1.translate(rec0.center().x()-rec1.center().x(), rec0.center().y()-rec1.center().y());
QPolygonF polygone = view->mapToScene(rec1.toRect());
rec1 = polygone.boundingRect();
}
else
{
rec1 = rec0;
}
rec1 = rec1.united(rect.toRect());
sc->setSceneRect(rec1);
}
bool MainWindow::eventFilter(QObject* obj, QEvent* event) {
if(event->type() == QEvent::Wheel) {
if(obj == ui->graphicsView) {
QWheelEvent* wheel = (QWheelEvent*) event;
//Ensure that [-240 <= delta <= +240]
qreal delta = fmax(fmin(240, (qreal)wheel->delta()), -240);
qreal scale = ((delta / 4.0) / 120.0) + 1.0;
QTransform t = ui->graphicsView->transform();
t.scale(scale, scale);
//Prevent excessive zooming
if(t.m11() > 0.1 && t.m11() < 4.0) {
ui->graphicsView->setTransform(t);
}
return true;
}
else if(obj == ui->graphicsView->verticalScrollBar()) {
return true;
}
}
return false;
}
void qTransformToTemplateTransform(const QTransform& in, TemplateTransform* out)
{
out->template_x = qRound(1000 * in.m31());
out->template_y = qRound(1000 * in.m32());
out->template_rotation = qAtan2(-in.m21(), in.m11());
out->template_scale_x = in.m11() / qCos(out->template_rotation);
out->template_scale_y = in.m22() / qCos(out->template_rotation);
}
void VGradientEx::transform( const QTransform &m )
{
double mx, my;
mx = m.m11() * m_origin.x() + m.m21() * m_origin.y() + m.dx();
my = m.m22() * m_origin.y() + m.m12() * m_origin.x() + m.dy();
m_origin = FPoint(mx, my);
mx = m.m11() * m_focalPoint.x() + m.m21() * m_focalPoint.y() + m.dx();
my = m.m22() * m_focalPoint.y() + m.m12() * m_focalPoint.x() + m.dy();
m_focalPoint = FPoint(mx, my);
mx = m.m11() * m_vector.x() + m.m21() * m_vector.y() + m.dx();
my = m.m22() * m_vector.y() + m.m12() * m_vector.x() + m.dy();
m_vector = FPoint(mx, my);
}
static QLineF preciselyMap( const QTransform& transform, const QLineF& line )
{
qreal fx1 = line.x1();
qreal fy1 = line.y1();
qreal fx2 = line.x2();
qreal fy2 = line.y2();
qreal x1 = transform.m11() * fx1 + transform.m21() * fy1 + transform.dx();
qreal y1 = transform.m12() * fx1 + transform.m22() * fy1 + transform.dy();
qreal x2 = transform.m11() * fx2 + transform.m21() * fy2 + transform.dx();
qreal y2 = transform.m12() * fx2 + transform.m22() * fy2 + transform.dy();
return QLineF( x1, y1, x2, y2 );
}
void MGLES2Renderer::draw(const QList<QRect>& targets, const QList<QRect>& sources)
{
GLuint num = d_ptr->setupVertices(d_ptr->m_boundTexSize, sources, targets);
QTransform transform;
GLfloat o = 1.0;
if (d_ptr->m_activePainter) {
transform = d_ptr->m_activePainter->combinedTransform();
o = d_ptr->m_activePainter->opacity();
}
d_ptr->m_matWorld[0][0] = transform.m11();
d_ptr->m_matWorld[0][1] = transform.m12();
d_ptr->m_matWorld[0][3] = transform.m13();
d_ptr->m_matWorld[1][0] = transform.m21();
d_ptr->m_matWorld[1][1] = transform.m22();
d_ptr->m_matWorld[1][3] = transform.m23();
d_ptr->m_matWorld[3][0] = transform.dx();
d_ptr->m_matWorld[3][1] = transform.dy();
d_ptr->m_matWorld[3][3] = transform.m33();
d_ptr->m_activeProgram->setUniformValue("matWorld", d_ptr->m_matWorld);
d_ptr->m_activeProgram->setUniformValue("opacity", o);
glDrawElements(GL_TRIANGLES, num, GL_UNSIGNED_SHORT, d_ptr->m_indices.data());
}
void TransformEditDialog::init(QTransform aTransform, const PropertyAttributes *aAttributes)
{
ui->setupUi(this);
setWindowFlags(Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint);
ui->m11SpinBox->setValue(aTransform.m11());
ui->m12SpinBox->setValue(aTransform.m12());
ui->m13SpinBox->setValue(aTransform.m13());
ui->m21SpinBox->setValue(aTransform.m21());
ui->m22SpinBox->setValue(aTransform.m22());
ui->m23SpinBox->setValue(aTransform.m23());
ui->m31SpinBox->setValue(aTransform.m31());
ui->m32SpinBox->setValue(aTransform.m32());
ui->m33SpinBox->setValue(aTransform.m33());
if (aAttributes)
{
aAttributes->applyToDoubleSpinBox(ui->m11SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m12SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m13SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m21SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m22SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m23SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m31SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m32SpinBox);
aAttributes->applyToDoubleSpinBox(ui->m33SpinBox);
}
}
void ellipse::rotate(qreal angle)
{
this->transformationRotate = this->transformationRotate.rotate(angle);
QPointF translatePoint(this->transformationTranslate.dx(),this->transformationTranslate.dy());
QTransform tempRotate(1, 0, 0, 1, 0, 0);
tempRotate.rotate(angle);
QPointF rotatedPoint = tempRotate.map(translatePoint);
this->transformationTranslate = QTransform(1, 0, 0, 1, rotatedPoint.x(), rotatedPoint.y());
this->transformationMatrix = this->transformationScale* this->transformationRotate * this->transformationTranslate;
if(!this->transformationMatrix.isInvertible())
{
//qDebug() << "Notinvertible";
}
QTransform inverted = this->transformationMatrix.inverted();
data.scaleX = (cl_float) inverted.m11();
data.scaleY = (cl_float) inverted.m22();
data.angleX = (cl_float) inverted.m21();
data.angleY = (cl_float) inverted.m12();
data.dx = (cl_float) inverted.dx();
data.dy = (cl_float) inverted.dy();
}
void QgsComposerRuler::setSceneTransform( const QTransform& transform )
{
QString debug = QString::number( transform.dx() ) + "," + QString::number( transform.dy() ) + ","
+ QString::number( transform.m11() ) + "," + QString::number( transform.m22() );
mTransform = transform;
update();
}
void QNanoPainter::transform(const QTransform &transform)
{
nvgTransform(nvgCtx()
, transform.m11(), transform.m12()
, transform.m21(), transform.m22()
, transform.m31(), transform.m32());
}
void MGLES2Renderer::draw(const QRect &rectangle)
{
GLfloat *vertices = d_ptr->m_vertices.data();
vertices[0] = rectangle.left(); vertices[1] = rectangle.top();
vertices[2] = rectangle.left(); vertices[3] = rectangle.top() + rectangle.height();
vertices[4] = rectangle.left() + rectangle.width(); vertices[5] = rectangle.top() + rectangle.height();
vertices[6] = rectangle.left() + rectangle.width(); vertices[7] = rectangle.top();
QTransform transform;
GLfloat o = 1.0;
if (d_ptr->m_activePainter) {
transform = d_ptr->m_activePainter->combinedTransform();
o = d_ptr->m_activePainter->opacity();
}
d_ptr->m_matWorld[0][0] = transform.m11();
d_ptr->m_matWorld[0][1] = transform.m12();
d_ptr->m_matWorld[0][3] = transform.m13();
d_ptr->m_matWorld[1][0] = transform.m21();
d_ptr->m_matWorld[1][1] = transform.m22();
d_ptr->m_matWorld[1][3] = transform.m23();
d_ptr->m_matWorld[3][0] = transform.dx();
d_ptr->m_matWorld[3][1] = transform.dy();
d_ptr->m_matWorld[3][3] = transform.m33();
d_ptr->m_activeProgram->setUniformValue("matWorld", d_ptr->m_matWorld);
d_ptr->m_activeProgram->setUniformValue("opacity", o);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
void RasterImage::draw(QPainter* painter) const
{
painter->save();
QSizeF s;
if (_sizeIsSpatium)
s = _size * spatium();
else
s = _size * MScore::DPMM;
if (score()->printing()) {
// use original image size for printing
painter->scale(s.width() / doc.width(), s.height() / doc.height());
painter->drawPixmap(QPointF(0, 0), QPixmap::fromImage(doc));
}
else {
QTransform t = painter->transform();
QSize ss = QSizeF(s.width() * t.m11(), s.height() * t.m22()).toSize();
t.setMatrix(1.0, t.m12(), t.m13(), t.m21(), 1.0, t.m23(), t.m31(), t.m32(), t.m33());
painter->setWorldTransform(t);
if ((buffer.size() != ss || _dirty) && !doc.isNull()) {
buffer = QPixmap::fromImage(doc.scaled(ss, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
_dirty = false;
}
Image::draw(painter, ss);
}
painter->restore();
}
OutputImageParams::PartialXform::PartialXform(QTransform const& xform)
: m_11(xform.m11()),
m_12(xform.m12()),
m_21(xform.m21()),
m_22(xform.m22())
{
}
void Selection::transform(QTransform transform, int pageNum)
{
m_selectionPolygon = transform.map(m_selectionPolygon);
qreal sx = transform.m11();
qreal sy = transform.m22();
qreal s = (sx + sy) / 2.0;
for (int i = 0; i < m_strokes.size(); ++i)
{
m_strokes[i].points = transform.map(m_strokes[i].points);
/*
'if (!transform.isRotating())' doesn't work, since rotation of 180 and 360 degrees is treated as a scaling transformation. Same goes for
'if (transform.isScaling())'
*/
if (transform.determinant() != 1)
{
m_strokes[i].penWidth = m_strokes[i].penWidth * s;
}
}
if (transform.determinant() != 1)
{
m_x_padding *= sx;
m_y_padding *= sy;
}
if (transform.isRotating())
{
m_x_padding = m_padding;
m_y_padding = m_padding;
}
m_angle = 0.0;
setPageNum(pageNum);
}
QT_BEGIN_NAMESPACE
static inline bool qtransform_equals_no_translate(const QTransform &a, const QTransform &b)
{
if (a.type() <= QTransform::TxTranslate && b.type() <= QTransform::TxTranslate) {
return true;
} else {
// We always use paths for perspective text anyway, so no
// point in checking the full matrix...
Q_ASSERT(a.type() < QTransform::TxProject);
Q_ASSERT(b.type() < QTransform::TxProject);
return a.m11() == b.m11()
&& a.m12() == b.m12()
&& a.m21() == b.m21()
&& a.m22() == b.m22();
}
}
inline QString toOctaveFormat(const QTransform &t)
{
QString s("T = [%1 %2 %3; %4 %5 %6; %7 %8 %9]");
s = s
.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());
return s;
}
void Image::draw(QPainter* painter) const
{
bool emptyImage = false;
if (imageType == ImageType::SVG) {
if (!svgDoc)
emptyImage = true;
else
svgDoc->render(painter, bbox());
}
else if (imageType == ImageType::RASTER) {
if (rasterDoc == nullptr)
emptyImage = true;
else {
painter->save();
QSizeF s;
if (_sizeIsSpatium)
s = _size * spatium();
else
s = _size * MScore::DPMM;
if (score()->printing()) {
// use original image size for printing
painter->scale(s.width() / rasterDoc->width(), s.height() / rasterDoc->height());
painter->drawPixmap(QPointF(0, 0), QPixmap::fromImage(*rasterDoc));
}
else {
QTransform t = painter->transform();
QSize ss = QSizeF(s.width() * t.m11(), s.height() * t.m22()).toSize();
t.setMatrix(1.0, t.m12(), t.m13(), t.m21(), 1.0, t.m23(), t.m31(), t.m32(), t.m33());
painter->setWorldTransform(t);
if ((buffer.size() != ss || _dirty) && rasterDoc && !rasterDoc->isNull()) {
buffer = QPixmap::fromImage(rasterDoc->scaled(ss, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
_dirty = false;
}
if (buffer.isNull())
emptyImage = true;
else
painter->drawPixmap(QPointF(0.0, 0.0), buffer);
}
painter->restore();
}
}
if (emptyImage) {
painter->setBrush(Qt::NoBrush);
painter->setPen(Qt::black);
painter->drawRect(bbox());
painter->drawLine(0.0, 0.0, bbox().width(), bbox().height());
painter->drawLine(bbox().width(), 0.0, 0.0, bbox().height());
}
if (selected() && !(score() && score()->printing())) {
painter->setBrush(Qt::NoBrush);
painter->setPen(MScore::selectColor[0]);
painter->drawRect(bbox());
}
}
glyph_metrics_t QFontEngineDirectWrite::alphaMapBoundingBox(glyph_t glyph, QFixed subPixelPosition,
const QTransform &matrix,
GlyphFormat /*format*/)
{
glyph_metrics_t bbox = QFontEngine::boundingBox(glyph, matrix); // To get transformed advance
UINT16 glyphIndex = glyph;
FLOAT glyphAdvance = 0;
DWRITE_GLYPH_OFFSET glyphOffset;
glyphOffset.advanceOffset = 0;
glyphOffset.ascenderOffset = 0;
DWRITE_GLYPH_RUN glyphRun;
glyphRun.fontFace = m_directWriteFontFace;
glyphRun.fontEmSize = fontDef.pixelSize;
glyphRun.glyphCount = 1;
glyphRun.glyphIndices = &glyphIndex;
glyphRun.glyphAdvances = &glyphAdvance;
glyphRun.isSideways = false;
glyphRun.bidiLevel = 0;
glyphRun.glyphOffsets = &glyphOffset;
DWRITE_MATRIX transform;
transform.dx = subPixelPosition.toReal();
transform.dy = 0;
transform.m11 = matrix.m11();
transform.m12 = matrix.m12();
transform.m21 = matrix.m21();
transform.m22 = matrix.m22();
IDWriteGlyphRunAnalysis *glyphAnalysis = NULL;
HRESULT hr = m_directWriteFactory->CreateGlyphRunAnalysis(
&glyphRun,
1.0f,
&transform,
DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC,
DWRITE_MEASURING_MODE_NATURAL,
0.0, 0.0,
&glyphAnalysis
);
if (SUCCEEDED(hr)) {
RECT rect;
glyphAnalysis->GetAlphaTextureBounds(DWRITE_TEXTURE_CLEARTYPE_3x1, &rect);
glyphAnalysis->Release();
return glyph_metrics_t(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
bbox.xoff, bbox.yoff);
} else {
return glyph_metrics_t();
}
}
void updateVertices(const QTransform &t)
{
worldMatrix[0][0] = t.m11();
worldMatrix[0][1] = t.m12();
worldMatrix[0][3] = t.m13();
worldMatrix[1][0] = t.m21();
worldMatrix[1][1] = t.m22();
worldMatrix[1][3] = t.m23();
worldMatrix[3][0] = t.dx();
worldMatrix[3][1] = t.dy();
worldMatrix[3][3] = t.m33();
}
void
qDebug(QTransform transform)
{
QString string;
string = "m11:" + QString::number(transform.m11()) + "\n";
string += "m12:" + QString::number(transform.m12()) + "\n";
string += "m13:" + QString::number(transform.m13()) + "\n";
string += "m21:" + QString::number(transform.m21()) + "\n";
string += "m22:" + QString::number(transform.m22()) + "\n";
string += "m23::" + QString::number(transform.m23()) + "\n";
qDebug(string);
}
SEXP to_sexp(QTransform tform) {
SEXP ans = allocMatrix(REALSXP, 3, 3);;
REAL(ans)[0] = tform.m11();
REAL(ans)[1] = tform.m21();
REAL(ans)[2] = tform.m31();
REAL(ans)[3] = tform.m12();
REAL(ans)[4] = tform.m22();
REAL(ans)[5] = tform.m32();
REAL(ans)[6] = tform.m13();
REAL(ans)[7] = tform.m23();
REAL(ans)[8] = tform.m33();
return ans;
}
void QJsonPaintEngine::updateMatrix(const QTransform &matrix)
{
Q_D(QJsonPaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateMatrix():" << matrix;
#endif
d->s << QString("\t{\"m\": {\"m11\": %1, \"m12\": %2, \"m21\": %3, \"m22\": %4, \"dx\": %5, \"dy\": %6}},\r\n")
.arg(matrix.m11())
.arg(matrix.m12())
.arg(matrix.m21())
.arg(matrix.m22())
.arg(matrix.dx())
.arg(matrix.dy());
}
void
FlowView::
scaleUp()
{
double const step = 1.2;
double const factor = std::pow(step, 1.0);
QTransform t = transform();
if (t.m11() > 2.0)
return;
scale(factor, factor);
}
void RasterImage::draw(Painter*) const
{
#if 0
QTransform t = p.worldTransform();
QSize s = QSizeF(sz.width() * t.m11(), sz.height() * t.m22()).toSize();
t.setMatrix(1.0, t.m12(), t.m13(), t.m21(), 1.0, t.m23(), t.m31(), t.m32(), t.m33());
p.setWorldTransform(t);
if (buffer.size() != s || _dirty) {
buffer = QPixmap::fromImage(doc.scaled(s, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
_dirty = false;
}
Image::draw(p, v);
#endif
}
void GraphicsUtils::saveTransform(QXmlStreamWriter & streamWriter, const QTransform & transform) {
if (transform.isIdentity()) return;
streamWriter.writeStartElement("transform");
streamWriter.writeAttribute("m11", QString::number(transform.m11()));
streamWriter.writeAttribute("m12", QString::number(transform.m12()));
streamWriter.writeAttribute("m13", QString::number(transform.m13()));
streamWriter.writeAttribute("m21", QString::number(transform.m21()));
streamWriter.writeAttribute("m22", QString::number(transform.m22()));
streamWriter.writeAttribute("m23", QString::number(transform.m23()));
streamWriter.writeAttribute("m31", QString::number(transform.m31()));
streamWriter.writeAttribute("m32", QString::number(transform.m32()));
streamWriter.writeAttribute("m33", QString::number(transform.m33()));
streamWriter.writeEndElement();
}
void paint(QPainter* painter, const QStyleOptionGraphicsItem* options, QWidget* widget)
{
if (!m_layer)
return;
GraphicsContext gc(painter);
const QTransform transform = painter->transform();
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()
);
painter->beginNativePainting();
m_layer->paint(&gc, widget->size(), options->rect, options->exposedRect.toAlignedRect(), matrix, painter->opacity());
painter->endNativePainting();
}
QVector3D Conversions::xyz2enu(const QVector3D &xyz, qreal reflat, qreal reflon, qreal refalt)
{
QVector3D refxyz = Conversions::lla2xyz(reflat,reflon,refalt);
QVector3D diffxyz = xyz - refxyz;
QTransform R1 = Conversions::rot(90.0 + reflon,3);
QTransform R2 = Conversions::rot(90.0-reflat,1);
QTransform R = R2*R1;
//MAKE THIS MATRIX MULTIPLY
qreal x = R.m11()*diffxyz.x() + R.m12()*diffxyz.y() + R.m13()*diffxyz.z();
qreal y = R.m21()*diffxyz.x() + R.m22()*diffxyz.y() + R.m23()*diffxyz.z();
qreal z = R.m31()*diffxyz.x() + R.m32()*diffxyz.y() + R.m33()*diffxyz.z();
QVector3D enu(x,y,z);
return enu;
}
void svg_renderer::update_drawing (const QTransform &transform, const QRectF &rect_to_update, int cache_object_type)
{
m_cache->lock ();
DO_ON_EXIT (m_cache->unlock ());
double cache_zoom_x = m_cache->zoom_x ();
double cache_zoom_y = m_cache->zoom_y ();
double cur_zoom_x = transform.m11 ();
double cur_zoom_y = transform.m22 ();
QRectF rect_to_draw = rect_to_update;
QTransform real_transform = transform;
SkBitmap bitmap;
bitmap.setConfig (SkBitmap::kARGB_8888_Config, rect_to_draw.width (), rect_to_draw.height ());
bitmap.allocPixels ();
SkBitmapDevice device (bitmap);
SkCanvas canvas (&device);
if (!are_equal (cache_zoom_x, cur_zoom_x) || !are_equal (cache_zoom_y, cur_zoom_y))
{
QTransform scale_transform = QTransform::fromScale (cache_zoom_x / cur_zoom_x, cache_zoom_y / cur_zoom_y);
real_transform = real_transform * scale_transform;
canvas.setMatrix (qt2skia::matrix (scale_transform.inverted ()));
rect_to_draw = scale_transform.mapRect (rect_to_draw);
}
canvas.drawColor (SK_ColorTRANSPARENT, SkXfermode::kSrc_Mode);
pair<render_cache_id, render_cache_id> it_pair = render_cache_id::get_id_for_pixel_rect (real_transform, rect_to_draw, cache_object_type);
for (int x = it_pair.first.x (); x <= it_pair.second.x (); x++)
for (int y = it_pair.first.y (); y <= it_pair.second.y (); y++)
{
render_cache_id cur_id (x, y, cache_object_type);
SkBitmap bitmap = m_cache->bitmap (cur_id);
if (bitmap.empty ())
continue;
QRectF pixel_rect = cur_id.pixel_rect (real_transform);
canvas.drawBitmap (bitmap, SkFloatToScalar (pixel_rect.x ()), SkFloatToScalar (pixel_rect.y ()));
}
m_cache->set_current_screen (bitmap, cache_object_type);
}
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 QMLProfile::paint(QPainter *painter)
{
// let's look at the intended size of the content and scale our scene accordingly
QRect painterRect = painter->viewport();
QRect profileRect = m_profileWidget->viewport()->rect();
// qDebug() << "profile viewport and painter viewport" << profileRect << painterRect;
qreal sceneSize = 104; // that should give us 2% margin all around (100x100 scene)
qreal dprComp = devicePixelRatio() * painterRect.width() / profileRect.width();
qreal sx = painterRect.width() / sceneSize / dprComp;
qreal sy = painterRect.height() / sceneSize / dprComp;
// next figure out the weird magic by which we need to shift the painter so the profile is shown
int dpr = rint(devicePixelRatio());
qreal magicShiftFactor = (dpr == 2 ? 0.25 : (dpr == 3 ? 0.33 : 0.0));
// now set up the transformations scale the profile and
// shift the painter (taking its existing transformation into account)
QTransform profileTransform = QTransform();
profileTransform.scale(sx, sy);
QTransform painterTransform = painter->transform();
painterTransform.translate(-painterRect.width() * magicShiftFactor ,-painterRect.height() * magicShiftFactor);
#if PROFILE_SCALING_DEBUG
// some debugging messages to help adjust this in case the magic above is insufficient
QMLManager::instance()->appendTextToLog(QString("dpr %1 profile viewport %2 %3 painter viewport %4 %5").arg(dpr).arg(profileRect.width()).arg(profileRect.height())
.arg(painterRect.width()).arg(painterRect.height()));
QMLManager::instance()->appendTextToLog(QString("profile matrix %1 %2 %3 %4 %5 %6 %7 %8 %9").arg(profileTransform.m11()).arg(profileTransform.m12()).arg(profileTransform.m13())
.arg(profileTransform.m21()).arg(profileTransform.m22()).arg(profileTransform.m23())
.arg(profileTransform.m31()).arg(profileTransform.m32()).arg(profileTransform.m33()));
QMLManager::instance()->appendTextToLog(QString("painter matrix %1 %2 %3 %4 %5 %6 %7 %8 %9").arg(painterTransform.m11()).arg(painterTransform.m12()).arg(painterTransform.m13())
.arg(painterTransform.m21()).arg(painterTransform.m22()).arg(painterTransform.m23())
.arg(painterTransform.m31()).arg(painterTransform.m32()).arg(painterTransform.m33()));
qDebug() << "profile scaled by" << profileTransform.m11() << profileTransform.m22() << "and translated by" << profileTransform.m31() << profileTransform.m32();
qDebug() << "exist profile transform" << m_profileWidget->transform() << "painter transform" << painter->transform();
#endif
// apply the transformation
painter->setTransform(painterTransform);
m_profileWidget->setTransform(profileTransform);
// finally, render the profile
m_profileWidget->render(painter);
}
