void ellipse::translateOrigin(qreal x, qreal y)
{
this->transformationTranslate = this->transformationTranslate.translate(x, y);
this->transformationMatrix = this->transformationScale* this->transformationRotate * this->transformationTranslate;
this->transformationMatrix = transformationScale * transformationRotate * 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();
}
QString QTransformToString (const QTransform &transform)
{
const int FIELD_WIDTH = 12;
QString str = QString ("%1 %2 %3 %4\n"
"%5 %6 %7 %8\n"
"%9 %10 %11 %12")
.arg (INDENTATION_PAST_TIMESTAMP)
.arg (transform.m11 (), FIELD_WIDTH)
.arg (transform.m12 (), FIELD_WIDTH)
.arg (transform.m13 (), FIELD_WIDTH)
.arg (INDENTATION_PAST_TIMESTAMP)
.arg (transform.m21 (), FIELD_WIDTH)
.arg (transform.m22 (), FIELD_WIDTH)
.arg (transform.m23 (), FIELD_WIDTH)
.arg (INDENTATION_PAST_TIMESTAMP)
.arg (transform.m31 (), FIELD_WIDTH)
.arg (transform.m32 (), FIELD_WIDTH)
.arg (transform.m33 (), FIELD_WIDTH);
return str;
}
QDomElement TupSerializer::properties(const QGraphicsItem *item, QDomDocument &doc)
{
QDomElement properties = doc.createElement("properties");
QString strMatrix = "matrix(";
QTransform m = item->transform();
qreal a = m.m11();
qreal b = m.m12();
qreal c = m.m21();
qreal d = m.m22();
qreal e = m.dx();
qreal f = m.dy();
strMatrix += QString::number(a) + "," + QString::number(b) + "," + QString::number(c) + "," + QString::number(d) + "," + QString::number(e) + "," + QString::number(f) + ")" ;
properties.setAttribute("transform", strMatrix);
properties.setAttribute("pos", "(" + QString::number(item->pos().x()) + "," + QString::number(item->pos().y()) + ")");
properties.setAttribute("enabled", item->isEnabled());
properties.setAttribute("flags", item->flags());
return properties;
}
bool GraphicsUtils::loadTransform(const QDomElement & transformElement, QTransform & transform)
{
if (transformElement.isNull()) return false;
double m11 = transform.m11();
double m12 = transform.m12();
double m13 = transform.m13();
double m21 = transform.m21();
double m22 = transform.m22();
double m23 = transform.m23();
double m31 = transform.m31();
double m32 = transform.m32();
double m33 = transform.m33();
bool ok;
double temp;
temp = transformElement.attribute("m11").toDouble(&ok);
if (ok) m11 = temp;
temp = transformElement.attribute("m12").toDouble(&ok);
if (ok) m12 = temp;
temp = transformElement.attribute("m13").toDouble(&ok);
if (ok) m13 = temp;
temp = transformElement.attribute("m21").toDouble(&ok);
if (ok) m21 = temp;
temp = transformElement.attribute("m22").toDouble(&ok);
if (ok) m22 = temp;
temp = transformElement.attribute("m23").toDouble(&ok);
if (ok) m23 = temp;
temp = transformElement.attribute("m31").toDouble(&ok);
if (ok) m31 = temp;
temp = transformElement.attribute("m32").toDouble(&ok);
if (ok) m32 = temp;
temp = transformElement.attribute("m33").toDouble(&ok);
if (ok) m33 = temp;
transform.setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33);
return true;
}
void CWhiteBoardView::updateSize(const QSize &size)
{
if(size.width() <= 0 && size.height() <= 0)
{
return;
}
QSize adjustSize = size;
if(m_data->m_needScale)
{
QRectF sceneRect = m_data->m_baseRect;
if(sceneRect.width() < 0.001 && sceneRect.height() < 0.001)
{
return;
}
qreal sx = size.width() / sceneRect.width();
qreal sy = size.height() / sceneRect.height();
QTransform form = this->transform();
form.setMatrix(sx,form.m12(),form.m13(),form.m21(),sy,form.m23(),form.m31(),form.m32(),form.m33());
this->setTransform(form);
adjustSize = sceneRect.size().toSize();
}
else
{
QTransform form = this->transform();
form.reset();
this->setTransform(form);
m_data->m_scene->setSceneRect(QRect(0,0,adjustSize.width(),adjustSize.height()));
}
if(m_data->m_backgroundColor.alpha() == 0)
{
m_data->m_backgroundColor.setAlpha(1);
}
QPixmap pixmap(adjustSize);
pixmap.fill(m_data->m_backgroundColor);
m_data->m_whiteBoardItem->setPixmap(pixmap);
}
QVector3D Conversions::enu2xyz(const QVector3D & enu, qreal reflat, qreal reflon, qreal refalt)
{
const QTransform R1 = Conversions::rot(90.0 + reflon,3);
const QTransform R2 = Conversions::rot(90.0 - reflat,1);
const QTransform R = R2*R1;
const QTransform invR = R.inverted();
if (invR.isIdentity())
{
qDebug() << "Failed to invert rotation matrix --- did you enter a bad lat,lon,or alt?";
return enu;
}
qreal x = invR.m11()*enu.x() + invR.m12()*enu.y() + invR.m13()*enu.z();
qreal y = invR.m21()*enu.x() + invR.m22()*enu.y() + invR.m23()*enu.z();
qreal z = invR.m31()*enu.x() + invR.m32()*enu.y() + invR.m33()*enu.z();
QVector3D diffxyz(x,y,z);
QVector3D refxyz = Conversions::lla2xyz(reflat,reflon,refalt);
return (diffxyz + refxyz);
}
/*
* m11 m12 0
* m21 m22 0
* dx dy 1
*
* m11 = horizontale Skalierung
* m22 = vertikale Skalierung
*
* m21 = horizontale drehung
* m12 = vertikale drehung
*
* dx = translation x
* dy = translation y
*/
ellipse::ellipse(qreal midPointX, qreal midPointY, qreal radiusX, qreal radiusY)
{
//Constructor vertikale Skalierung, vertikale Drehung, horizontale Drehung, horizontale Skalierung, translate X, translate Y
this->transformationRotate = QTransform(1, 0, 0, 1, 0, 0);
this->transformationScale = QTransform(radiusX, 0, 0, radiusY, 0, 0);
this->transformationTranslate = QTransform(1, 0, 0, 1, midPointX, midPointY);
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();
}
bool Features::checkEigenvalues(QTransform tr){
double eig1, eig2, eig3, minDist;
//qDebug() << "EIGENVALUES";
QString program = "./eig/eig.exe";
QStringList arguments;
arguments << QString::number(tr.m11());
arguments << QString::number(tr.m12());
arguments << QString::number(tr.m13());
arguments << QString::number(tr.m21());
arguments << QString::number(tr.m22());
arguments << QString::number(tr.m23());
arguments << QString::number(tr.m31());
arguments << QString::number(tr.m32());
arguments << QString::number(tr.m33());
QProcess *eig = new QProcess();
eig->start(program, arguments);
eig->waitForFinished();
QString line;
line = eig->readLine();
eig1 = line.left(line.indexOf('.') + 5).remove('\n').toDouble();
line = eig->readLine();
eig2 = line.left(line.indexOf('.') + 5).remove('\n').toDouble();
line = eig->readLine();
eig3 = line.left(line.indexOf('.') + 5).remove('\n').toDouble();
//qDebug() << "Eig1:" << eig1 << "| Eig2:" << eig2 << "| Eig3:" << eig3;
minDist = abs(eig1 - eig2);
if(abs(eig1 - eig3) < minDist) minDist = abs(eig1 - eig3);
if(abs(eig2 - eig3) < minDist) minDist = abs(eig2 - eig3);
//qDebug() << "MinDist:" << minDist;
return minDist <= 0.5;
}
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 CanvasMode_Rotate::getNewItemPosition(PageItem* item, FPoint& pos, double& rotation)
{
double newAngle = xy2Deg(m_canvasCurrCoord.x() - m_rotCenter.x(), m_canvasCurrCoord.y() - m_rotCenter.y());
if (m_angleConstrained)
{
newAngle = constrainAngle(newAngle, m_doc->opToolPrefs().constrain);
/*double oldAngle = constrainAngle(m_startAngle, m_doc->opToolPrefs.constrain);
newAngle = m_doc->m_Selection->isMultipleSelection() ? (newAngle - oldAngle) : newAngle;*/
m_view->oldW = constrainAngle(m_view->oldW, m_doc->opToolPrefs().constrain);
newAngle = m_doc->m_Selection->isMultipleSelection() ? (newAngle - m_view->oldW) : newAngle;
}
else if (m_doc->m_Selection->isMultipleSelection())
newAngle = (newAngle - m_startAngle);
else
newAngle = item->rotation() - (m_startAngle - newAngle);
if (m_doc->m_Selection->isMultipleSelection())
{
QTransform ma;
ma.translate(m_rotCenter.x(), m_rotCenter.y());
ma.scale(1, 1);
ma.rotate(newAngle);
FPoint n(item->xPos() - m_rotCenter.x(), item->yPos() - m_rotCenter.y());
pos.setXY(ma.m11() * n.x() + ma.m21() * n.y() + ma.dx(), ma.m22() * n.y() + ma.m12() * n.x() + ma.dy());
rotation = item->rotation() + newAngle;
}
else if (m_rotMode != 0)
{
FPoint n(0,0);
QTransform ma;
ma.translate(item->xPos(), item->yPos());
ma.scale(1, 1);
ma.rotate(item->rotation());
double ro = newAngle - item->rotation();
switch (m_rotMode)
{
case 2:
ma.translate(item->width()/2.0, item->height()/2.0);
n = FPoint(-item->width()/2.0, -item->height()/2.0);
break;
case 4:
ma.translate(item->width(), item->height());
n = FPoint(-item->width(), -item->height());
break;
case 3:
ma.translate(0, item->height());
n = FPoint(0, -item->height());
break;
case 1:
ma.translate(item->width(), 0);
n = FPoint(-item->width(), 0);
break;
}
ma.rotate(ro);
pos.setXY(ma.m11() * n.x() + ma.m21() * n.y() + ma.dx(), ma.m22() * n.y() + ma.m12() * n.x() + ma.dy());
rotation = newAngle;
}
else
{
pos.setXY(item->xPos(), item->yPos());
rotation = newAngle;
}
}
QImage QWindowsFontEngineDirectWrite::imageForGlyph(glyph_t t,
QFixed subPixelPosition,
int margin,
const QTransform &xform)
{
glyph_metrics_t metrics = QFontEngine::boundingBox(t, xform);
int width = (metrics.width + margin * 2 + 4).ceil().toInt() ;
int height = (metrics.height + margin * 2 + 4).ceil().toInt();
UINT16 glyphIndex = t;
FLOAT glyphAdvance = metrics.xoff.toReal();
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;
QFixed x = margin - metrics.x.floor() + subPixelPosition;
QFixed y = margin - metrics.y.floor();
DWRITE_MATRIX transform;
transform.dx = x.toReal();
transform.dy = y.toReal();
transform.m11 = xform.m11();
transform.m12 = xform.m12();
transform.m21 = xform.m21();
transform.m22 = xform.m22();
IDWriteGlyphRunAnalysis *glyphAnalysis = NULL;
HRESULT hr = m_fontEngineData->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;
rect.left = 0;
rect.top = 0;
rect.right = width;
rect.bottom = height;
int size = width * height * 3;
BYTE *alphaValues = new BYTE[size];
memset(alphaValues, size, 0);
hr = glyphAnalysis->CreateAlphaTexture(DWRITE_TEXTURE_CLEARTYPE_3x1,
&rect,
alphaValues,
size);
if (SUCCEEDED(hr)) {
QImage img(width, height, QImage::Format_RGB32);
img.fill(0xffffffff);
for (int y=0; y<height; ++y) {
uint *dest = reinterpret_cast<uint *>(img.scanLine(y));
BYTE *src = alphaValues + width * 3 * y;
for (int x=0; x<width; ++x) {
dest[x] = *(src) << 16
| *(src + 1) << 8
| *(src + 2);
src += 3;
}
}
delete[] alphaValues;
glyphAnalysis->Release();
return img;
} else {
delete[] alphaValues;
glyphAnalysis->Release();
qErrnoWarning("%s: CreateAlphaTexture failed", __FUNCTION__);
}
} else {
qErrnoWarning("%s: CreateGlyphRunAnalysis failed", __FUNCTION__);
}
return QImage();
}
void KoShapeAnchor::saveOdf(KoShapeSavingContext &context) const
{
// anchor-type
switch (d->anchorType) {
case AnchorToCharacter:
shape()->setAdditionalAttribute("text:anchor-type", "char");
break;
case AnchorAsCharacter:
shape()->setAdditionalAttribute("text:anchor-type", "as-char");
break;
case AnchorParagraph:
shape()->setAdditionalAttribute("text:anchor-type", "paragraph");
break;
case AnchorPage:
shape()->setAdditionalAttribute("text:anchor-type", "page");
break;
default:
break;
}
// vertical-pos
switch (d->verticalPos) {
case VBelow:
shape()->setAdditionalStyleAttribute("style:vertical-pos", "below");
break;
case VBottom:
shape()->setAdditionalStyleAttribute("style:vertical-pos", "bottom");
break;
case VFromTop:
shape()->setAdditionalStyleAttribute("style:vertical-pos", "from-top");
break;
case VMiddle:
shape()->setAdditionalStyleAttribute("style:vertical-pos", "middle");
break;
case VTop:
shape()->setAdditionalStyleAttribute("style:vertical-pos", "top");
break;
default:
break;
}
// vertical-rel
switch (d->verticalRel) {
case VBaseline:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "baseline");
break;
case VChar:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "char");
break;
case VFrame:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "frame");
break;
case VFrameContent:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "frame-content");
break;
case VLine:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "line");
break;
case VPage:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "page");
break;
case VPageContent:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "page-content");
break;
case VParagraph:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "paragraph");
break;
case VParagraphContent:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "paragraph-content");
break;
case VText:
shape()->setAdditionalStyleAttribute("style:vertical-rel", "text");
break;
default:
break;
}
// horizontal-pos
switch (d->horizontalPos) {
case HCenter:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "center");
break;
case HFromInside:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "from-inside");
break;
case HFromLeft:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "from-left");
break;
case HInside:
shape()->setAdditionalStyleAttribute("style:horizontal-posl", "inside");
break;
case HLeft:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "left");
break;
case HOutside:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "outside");
break;
case HRight:
shape()->setAdditionalStyleAttribute("style:horizontal-pos", "right");
break;
default:
break;
}
// horizontal-rel
switch (d->horizontalRel) {
case HChar:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "char");
break;
case HPage:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "page");
break;
case HPageContent:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "page-content");
break;
case HPageStartMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "page-start-margin");
break;
case HPageEndMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "page-end-margin");
break;
case HFrame:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "frame");
break;
case HFrameContent:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "frame-content");
break;
case HFrameEndMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "frame-end-margin");
break;
case HFrameStartMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "frame-start-margin");
break;
case HParagraph:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "paragraph");
break;
case HParagraphContent:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "paragraph-content");
break;
case HParagraphEndMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "paragraph-end-margin");
break;
case HParagraphStartMargin:
shape()->setAdditionalStyleAttribute("style:horizontal-rel", "paragraph-start-margin");
break;
default:
break;
}
if (!d->wrapInfluenceOnPosition.isEmpty()) {
shape()->setAdditionalStyleAttribute("draw:wrap-influence-on-position", d->wrapInfluenceOnPosition);
}
if (d->flowWithText) {
shape()->setAdditionalStyleAttribute("style:flow-with-text", "true");
} else {
shape()->setAdditionalStyleAttribute("style:flow-with-text", "false");
}
if (shape()->parent()) {// an anchor may not yet have been layout-ed
QTransform parentMatrix = shape()->parent()->absoluteTransformation(0).inverted();
QTransform shapeMatrix = shape()->absoluteTransformation(0);;
qreal dx = d->offset.x() - shapeMatrix.dx()*parentMatrix.m11()
- shapeMatrix.dy()*parentMatrix.m21();
qreal dy = d->offset.y() - shapeMatrix.dx()*parentMatrix.m12()
- shapeMatrix.dy()*parentMatrix.m22();
context.addShapeOffset(shape(), QTransform(parentMatrix.m11(),parentMatrix.m12(),
parentMatrix.m21(),parentMatrix.m22(),
dx,dy));
}
shape()->saveOdf(context);
context.removeShapeOffset(shape());
}
void
PixmapRenderer::drawPixmap(
QPainter& painter, QPixmap const& pixmap)
{
#if !defined(Q_WS_X11)
drawPixmapNoXRender(painter, pixmap);
#else
QPaintDevice* const dev = painter.device();
QPoint offset; // Both x and y will be either zero or negative.
QPaintDevice* const redir_dev = QPainter::redirected(painter.device(), &offset);
QPaintDevice* const paint_dev = redir_dev ? redir_dev : dev;
#if defined(ENABLE_OPENGL)
if (dynamic_cast<QGLWidget*>(paint_dev)) {
drawPixmapNoXRender(painter, pixmap);
return;
}
#endif
QRect const device_rect(
QRect(0, 0, dev->width(), dev->height()).translated(-offset)
);
QRectF const src_rect(pixmap.rect());
Display* const dpy = QX11Info::display();
Picture const src_pict = pixmap.x11PictureHandle();
Picture dst_pict = 0;
if (QWidget* widget = dynamic_cast<QWidget*>(paint_dev)) {
dst_pict = widget->x11PictureHandle();
} else if (QPixmap* pixmap = dynamic_cast<QPixmap*>(paint_dev)) {
dst_pict = pixmap->x11PictureHandle();
}
if (!dst_pict) {
drawPixmapNoXRender(painter, pixmap);
return;
}
// Note that device transform already accounts for offset
// within a destination surface.
QTransform const src_to_dst(painter.deviceTransform());
QTransform const dst_to_src(src_to_dst.inverted());
QPolygonF const dst_poly(src_to_dst.map(src_rect));
XTransform xform = {{
{
XDoubleToFixed(dst_to_src.m11()),
XDoubleToFixed(dst_to_src.m21()),
XDoubleToFixed(dst_to_src.m31())
},
{
XDoubleToFixed(dst_to_src.m12()),
XDoubleToFixed(dst_to_src.m22()),
XDoubleToFixed(dst_to_src.m32())
},
{
XDoubleToFixed(dst_to_src.m13()),
XDoubleToFixed(dst_to_src.m23()),
XDoubleToFixed(dst_to_src.m33())
}
}};
XRenderSetPictureTransform(dpy, src_pict, &xform);
char const* filter = "fast";
if (painter.testRenderHint(QPainter::SmoothPixmapTransform)) {
filter = "good";
}
XRenderSetPictureFilter(dpy, src_pict, filter, 0, 0);
QRectF const dst_rect_precise(dst_poly.boundingRect());
QRect const dst_rect_fitting(
QPoint(
int(ceil(dst_rect_precise.left())),
int(ceil(dst_rect_precise.top()))
),
QPoint(
int(floor(dst_rect_precise.right())) - 1,
int(floor(dst_rect_precise.bottom())) - 1
)
);
QRect dst_bounding_rect(device_rect);
if (painter.hasClipping()) {
QRect const clip_rect(
src_to_dst.map(painter.clipPath()).boundingRect().toRect()
);
dst_bounding_rect = dst_bounding_rect.intersected(clip_rect);
}
QRect const dst_rect(dst_rect_fitting.intersect(dst_bounding_rect));
// Note that XRenderComposite() expects destination coordinates
// everywhere, even for source picture origin.
XRenderComposite(
dpy, PictOpSrc,
src_pict, 0, dst_pict, dst_rect.left(), dst_rect.top(), 0, 0,
dst_rect.left(), dst_rect.top(), dst_rect.width(), dst_rect.height()
);
#endif
}
bool PropertyMatrixModel::setData(const QModelIndex &index, const QVariant &data, int role)
{
if (!index.isValid())
return false;
if (role != Qt::EditRole)
return false;
bool ok = false;
float floatData = data.toFloat(&ok);
if (!ok)
return false;
switch (m_matrix.type()) {
case QVariant::Vector2D: {
QVector2D value = m_matrix.value<QVector2D>();
switch (index.row()) {
case 0: value.setX(floatData); break;
case 1: value.setY(floatData); break;
}
m_matrix = value;
break;
}
case QVariant::Vector3D: {
QVector3D value = m_matrix.value<QVector3D>();
switch (index.row()) {
case 0: value.setX(floatData); break;
case 1: value.setY(floatData); break;
case 2: value.setZ(floatData); break;
}
m_matrix = value;
break;
}
case QVariant::Vector4D: {
QVector4D value = m_matrix.value<QVector4D>();
switch (index.row()) {
case 0: value.setX(floatData); break;
case 1: value.setY(floatData); break;
case 2: value.setZ(floatData); break;
case 3: value.setW(floatData); break;
}
m_matrix = value;
break;
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
case QVariant::Quaternion: {
float pitch, yaw, roll;
const QQuaternion value = m_matrix.value<QQuaternion>();
value.getEulerAngles(&pitch, &yaw, &roll);
switch (index.row()) {
case 0: pitch = floatData; break;
case 1: yaw = floatData; break;
case 2: roll = floatData; break;
}
m_matrix = QQuaternion::fromEulerAngles(pitch, yaw, roll);
break;
}
#endif
case QVariant::Matrix: {
QMatrix value = m_matrix.value<QMatrix>();
switch (index.row() << 4 | index.column()) {
case 0x00: value.setMatrix(floatData, value.m12(), value.m21(), value.m22(), value.dx(), value.dy()); break;
case 0x01: value.setMatrix(value.m11(), floatData, value.m21(), value.m22(), value.dx(), value.dy()); break;
case 0x10: value.setMatrix(value.m11(), value.m12(), floatData, value.m22(), value.dx(), value.dy()); break;
case 0x11: value.setMatrix(value.m11(), value.m12(), value.m21(), floatData, value.dx(), value.dy()); break;
case 0x20: value.setMatrix(value.m11(), value.m12(), value.m21(), value.m22(), floatData, value.dy()); break;
case 0x21: value.setMatrix(value.m11(), value.m12(), value.m21(), value.m22(), value.dx(), floatData); break;
}
m_matrix = value;
break;
}
case QVariant::Transform: {
QTransform value = m_matrix.value<QTransform>();
switch (index.row() << 4 | index.column()) {
case 0x00: value.setMatrix(floatData, value.m12(), value.m13(), value.m21(), value.m22(), value.m23(), value.m31(), value.m32(), value.m33()); break;
case 0x01: value.setMatrix(value.m11(), floatData, value.m13(), value.m21(), value.m22(), value.m23(), value.m31(), value.m32(), value.m33()); break;
case 0x02: value.setMatrix(value.m11(), value.m12(), floatData, value.m21(), value.m22(), value.m23(), value.m31(), value.m32(), value.m33()); break;
case 0x10: value.setMatrix(value.m11(), value.m12(), value.m13(), floatData, value.m22(), value.m23(), value.m31(), value.m32(), value.m33()); break;
case 0x11: value.setMatrix(value.m11(), value.m12(), value.m13(), value.m21(), floatData, value.m23(), value.m31(), value.m32(), value.m33()); break;
case 0x12: value.setMatrix(value.m11(), value.m12(), value.m13(), value.m21(), value.m22(), floatData, value.m31(), value.m32(), value.m33()); break;
case 0x20: value.setMatrix(value.m11(), value.m12(), value.m13(), value.m21(), value.m22(), value.m23(), floatData, value.m32(), value.m33()); break;
case 0x21: value.setMatrix(value.m11(), value.m12(), value.m13(), value.m21(), value.m22(), value.m23(), value.m31(), floatData, value.m33()); break;
case 0x22: value.setMatrix(value.m11(), value.m12(), value.m13(), value.m21(), value.m22(), value.m23(), value.m31(), value.m32(), floatData); break;
}
m_matrix = value;
break;
}
case QVariant::Matrix4x4: {
QMatrix4x4 value = m_matrix.value<QMatrix4x4>();
value(index.row(), index.column()) = floatData;
m_matrix = value;
break;
}
}
emit dataChanged(index, index);
return true;
}
WMatrix transform(const QTransform& matrix)
{
return WMatrix(matrix.m11(), matrix.m12(), matrix.m21(), matrix.m22(), matrix.dx(), matrix.dy());
}
void PropertiesPalette_XYZ::handleNewX()
{
if (!m_ScMW || m_ScMW->scriptIsRunning())
return;
if ((m_haveDoc) && (m_haveItem))
{
double x,y,w,h, gx, gy, gh, gw, base;
QTransform ma;
x = xposSpin->value() / m_unitRatio;
y = yposSpin->value() / m_unitRatio;
w = widthSpin->value() / m_unitRatio;
h = heightSpin->value() / m_unitRatio;
base = 0;
x += m_doc->rulerXoffset;
y += m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
x += m_doc->currentPage()->xOffset();
y += m_doc->currentPage()->yOffset();
}
if (m_doc->m_Selection->isMultipleSelection())
{
m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
int bp = basePointWidget->checkedId();
if ((bp == 0) || (bp == 3))
base = gx;
else if (bp == 2)
base = gx + gw / 2.0;
else if ((bp == 1) || (bp == 4))
base = gx + gw;
if (!_userActionOn)
m_ScMW->view->startGroupTransaction();
m_doc->moveGroup(x - base, 0, true);
if (!_userActionOn)
{
m_ScMW->view->endGroupTransaction();
}
m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
displayXY(gx, gy);
}
else
{
if ((m_item->asLine()) && (m_lineMode))
{
w += m_doc->rulerXoffset;
h += m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
w += m_doc->currentPage()->xOffset();
h += m_doc->currentPage()->yOffset();
}
double r = atan2(h-y,w-x)*(180.0/M_PI);
w = sqrt(pow(w-x,2)+pow(h-y,2));
m_item->setXYPos(x, m_item->yPos(), true);
m_item->setRotation(r, true);
m_doc->SizeItem(w, m_item->height(), m_item, true);
}
else
{
ma.translate(m_item->xPos(), m_item->yPos());
ma.rotate(m_item->rotation());
int bp = basePointWidget->checkedId();
if (bp == 0)
base = m_item->xPos();
else if (bp == 2)
base = ma.m11() * (m_item->width() / 2.0) + ma.m21() * (m_item->height() / 2.0) + ma.dx();
else if (bp == 1)
base = ma.m11() * m_item->width() + ma.m21() * 0.0 + ma.dx();
else if (bp == 4)
base = ma.m11() * m_item->width() + ma.m21() * m_item->height() + ma.dx();
else if (bp == 3)
base = ma.m11() * 0.0 + ma.m21() * m_item->height() + ma.dx();
m_doc->MoveItem(x - base, 0, m_item, true);
}
}
m_doc->regionsChanged()->update(QRect());
emit DocChanged();
}
}
QVariant PropertyMatrixModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
if (role != Qt::DisplayRole && role != Qt::EditRole)
return QVariant();
switch (m_matrix.type()) {
case QVariant::Matrix: {
const QMatrix value = m_matrix.value<QMatrix>();
switch (index.row() << 4 | index.column()) {
case 0x00: return value.m11();
case 0x01: return value.m12();
case 0x10: return value.m21();
case 0x11: return value.m22();
case 0x20: return value.dx();
case 0x21: return value.dy();
}
break;
}
case QVariant::Transform: {
const QTransform value = m_matrix.value<QTransform>();
switch (index.row() << 4 | index.column()) {
case 0x00: return value.m11();
case 0x01: return value.m12();
case 0x02: return value.m13();
case 0x10: return value.m21();
case 0x11: return value.m22();
case 0x12: return value.m23();
case 0x20: return value.m31();
case 0x21: return value.m32();
case 0x22: return value.m33();
}
break;
}
case QVariant::Matrix4x4: {
const QMatrix4x4 value = m_matrix.value<QMatrix4x4>();
return value(index.row(), index.column());
}
case QVariant::Vector2D: {
const QVector2D value = m_matrix.value<QVector2D>();
switch (index.row()) {
case 0: return value.x();
case 1: return value.y();
}
break;
}
case QVariant::Vector3D: {
const QVector3D value = m_matrix.value<QVector3D>();
switch (index.row()) {
case 0: return value.x();
case 1: return value.y();
case 2: return value.z();
}
break;
}
case QVariant::Vector4D: {
const QVector4D value = m_matrix.value<QVector4D>();
switch (index.row()) {
case 0: return value.x();
case 1: return value.y();
case 2: return value.z();
case 3: return value.w();
}
break;
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
case QVariant::Quaternion: {
float pitch, yaw, roll;
const QQuaternion value = m_matrix.value<QQuaternion>();
value.getEulerAngles(&pitch, &yaw, &roll);
switch (index.row()) {
case 0: return pitch;
case 1: return yaw;
case 2: return roll;
}
break;
}
#endif
default:
break;
}
return QVariant();
}
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 PixmapCachingSheetView::paintCells(QPainter& painter, const QRectF& paintRect, const QPointF& topLeft, CanvasBase* canvas, const QRect& visibleRect)
{
if (!canvas) {
SheetView::paintCells(painter, paintRect, topLeft, canvas, visibleRect);
return;
}
// paintRect: the canvas area, that should be painted; in document coordinates;
// no layout direction consideration; scrolling offset applied;
// independent from painter transformations
// topLeft: the document coordinate of the top left cell's top left corner;
// no layout direction consideration; independent from painter
// transformations
QTransform t = painter.transform();
// figure out scaling from the transformation... not really perfect, but should work as long as rotation is in 90 degree steps I think
const qreal cos_sx = t.m11();
const qreal sin_sx = t.m12();
const qreal msin_sy = t.m21();
const qreal cos_sy = t.m22();
const qreal sx = sqrt(cos_sx*cos_sx + sin_sx*sin_sx);
const qreal sy = sqrt(cos_sy*cos_sy + msin_sy*msin_sy);
//const qreal cost = (sx > 1e-10 ? cos_sx / sx : cos_sy / sy);
//const qreal ang = acos(cost);
QPointF scale = QPointF(sx, sy);
if (scale != d->lastScale) {
d->tileCache.clear();
}
d->lastScale = scale;
QRect tiles;
const QRect visibleCells = paintCellRange();
const Sheet * s = sheet();
const QPointF bottomRight(s->columnPosition(visibleCells.right() + 1), s->rowPosition(visibleCells.bottom() + 1));
tiles.setLeft(topLeft.x() * sx / TILESIZE);
tiles.setTop(topLeft.y() * sy / TILESIZE);
tiles.setRight((bottomRight.x() * sx + TILESIZE-1) / TILESIZE);
tiles.setBottom((bottomRight.y() * sy + TILESIZE-1) / TILESIZE);
bool rtl = s->layoutDirection() == Qt::RightToLeft;
if (rtl) {
for (int x = qMax(0, tiles.left()); x < tiles.right(); x++) {
for (int y = qMax(0, tiles.top()); y < tiles.bottom(); y++) {
QPixmap *p = d->getTile(s, x, y, canvas);
if (p) {
QPointF pt(paintRect.width() - (x+1) * TILESIZE / scale.x(), y * TILESIZE / scale.y());
QRectF r(pt, QSizeF(TILESIZE / sx, TILESIZE / sy));
painter.drawPixmap(r, *p, p->rect());
}
}
}
} else {
for (int x = qMax(0, tiles.left()); x < tiles.right(); x++) {
for (int y = qMax(0, tiles.top()); y < tiles.bottom(); y++) {
QPixmap *p = d->getTile(s, x, y, canvas);
if (p) {
QPointF pt(x * TILESIZE / scale.x(), y * TILESIZE / scale.y());
QRectF r(pt, QSizeF(TILESIZE / sx, TILESIZE / sy));
painter.drawPixmap(r, *p, p->rect());
}
}
}
}
}
QImage QFontEngineDirectWrite::imageForGlyph(glyph_t t,
QFixed subPixelPosition,
int margin,
const QTransform &xform)
{
UINT16 glyphIndex = t;
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 = xform.m11();
transform.m12 = xform.m12();
transform.m21 = xform.m21();
transform.m22 = xform.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);
rect.left -= margin;
rect.top -= margin;
rect.right += margin;
rect.bottom += margin;
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
int size = width * height * 3;
if (size > 0) {
BYTE *alphaValues = new BYTE[size];
qMemSet(alphaValues, size, 0);
hr = glyphAnalysis->CreateAlphaTexture(DWRITE_TEXTURE_CLEARTYPE_3x1,
&rect,
alphaValues,
size);
if (SUCCEEDED(hr)) {
QImage img(width, height, QImage::Format_RGB32);
img.fill(0xffffffff);
for (int y=0; y<height; ++y) {
uint *dest = reinterpret_cast<uint *>(img.scanLine(y));
BYTE *src = alphaValues + width * 3 * y;
for (int x=0; x<width; ++x) {
dest[x] = *(src) << 16
| *(src + 1) << 8
| *(src + 2);
src += 3;
}
}
delete[] alphaValues;
glyphAnalysis->Release();
return img;
} else {
delete[] alphaValues;
glyphAnalysis->Release();
qErrnoWarning("QFontEngineDirectWrite::imageForGlyph: CreateAlphaTexture failed");
}
}
} else {
qErrnoWarning("QFontEngineDirectWrite::imageForGlyph: CreateGlyphRunAnalysis failed");
}
return QImage();
}
int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, int *gStateObject)
{
int paintType = 2; // Uncolored tiling
int w = 8;
int h = 8;
*specifyColor = true;
*gStateObject = 0;
QTransform matrix = m;
matrix.translate(brushOrigin.x(), brushOrigin.y());
matrix = matrix * pageMatrix();
//qDebug() << brushOrigin << matrix;
Qt::BrushStyle style = brush.style();
if (style == Qt::LinearGradientPattern) {// && style <= Qt::ConicalGradientPattern) {
#ifdef USE_NATIVE_GRADIENTS
*specifyColor = false;
return gradientBrush(b, matrix, gStateObject);
#else
return 0;
#endif
}
if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0)
*gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity),
qRound(pen.color().alpha() * opacity));
int imageObject = -1;
QByteArray pattern = QPdf::patternForBrush(brush);
if (pattern.isEmpty()) {
if (brush.style() != Qt::TexturePattern)
return 0;
QImage image = brush.texture().toImage();
bool bitmap = true;
imageObject = addImage(image, &bitmap, qt_pixmap_id(brush.texture()));
if (imageObject != -1) {
QImage::Format f = image.format();
if (f != QImage::Format_MonoLSB && f != QImage::Format_Mono) {
paintType = 1; // Colored tiling
*specifyColor = false;
}
w = image.width();
h = image.height();
QTransform m(w, 0, 0, -h, 0, h);
QPdf::ByteStream s(&pattern);
s << QPdf::generateMatrix(m);
s << "/Im" << imageObject << " Do\n";
}
}
QByteArray str;
QPdf::ByteStream s(&str);
s << "<<\n"
"/Type /Pattern\n"
"/PatternType 1\n"
"/PaintType " << paintType << "\n"
"/TilingType 1\n"
"/BBox [0 0 " << w << h << "]\n"
"/XStep " << w << "\n"
"/YStep " << h << "\n"
"/Matrix ["
<< matrix.m11()
<< matrix.m12()
<< matrix.m21()
<< matrix.m22()
<< matrix.dx()
<< matrix.dy() << "]\n"
"/Resources \n<< "; // open resource tree
if (imageObject > 0) {
s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> ";
}
s << ">>\n"
"/Length " << pattern.length() << "\n"
">>\n"
"stream\n"
<< pattern
<< "endstream\n"
"endobj\n";
int patternObj = addXrefEntry(-1);
write(str);
currentPage->patterns.append(patternObj);
return patternObj;
}
void Transformation::updateTransformFromMatrices (const QTransform &matrixScreen,
const QTransform &matrixGraph)
{
// LOG4CPP_INFO_S is below
m_transformIsDefined = true;
// Extract points from 3x3 matrices
QPointF pointGraphRaw0 (matrixGraph.m11(),
matrixGraph.m21());
QPointF pointGraphRaw1 (matrixGraph.m12(),
matrixGraph.m22());
QPointF pointGraphRaw2 (matrixGraph.m13(),
matrixGraph.m23());
QPointF pointGraphLinearCart0, pointGraphLinearCart1, pointGraphLinearCart2;
transformRawGraphToLinearCartesianGraph (pointGraphRaw0,
pointGraphLinearCart0);
transformRawGraphToLinearCartesianGraph (pointGraphRaw1,
pointGraphLinearCart1);
transformRawGraphToLinearCartesianGraph (pointGraphRaw2,
pointGraphLinearCart2);
// Calculate the transform
m_transform = calculateTransformFromLinearCartesianPoints (QPointF (matrixScreen.m11(), matrixScreen.m21()),
QPointF (matrixScreen.m12(), matrixScreen.m22()),
QPointF (matrixScreen.m13(), matrixScreen.m23()),
QPointF (pointGraphLinearCart0.x(), pointGraphLinearCart0.y()),
QPointF (pointGraphLinearCart1.x(), pointGraphLinearCart1.y()),
QPointF (pointGraphLinearCart2.x(), pointGraphLinearCart2.y()));
// Logging
QTransform matrixGraphLinear (pointGraphLinearCart0.x(),
pointGraphLinearCart1.x(),
pointGraphLinearCart2.x(),
pointGraphLinearCart0.y(),
pointGraphLinearCart1.y(),
pointGraphLinearCart2.y(),
1.0,
1.0);
QPointF pointScreenRoundTrip0, pointScreenRoundTrip1, pointScreenRoundTrip2;
transformRawGraphToScreen (pointGraphRaw0,
pointScreenRoundTrip0);
transformRawGraphToScreen (pointGraphRaw1,
pointScreenRoundTrip1);
transformRawGraphToScreen (pointGraphRaw2,
pointScreenRoundTrip2);
QPointF pointScreen0 (matrixScreen.m11(),
matrixScreen.m21());
QPointF pointScreen1 (matrixScreen.m12(),
matrixScreen.m22());
QPointF pointScreen2 (matrixScreen.m13(),
matrixScreen.m23());
LOG4CPP_INFO_S ((*mainCat)) << "Transformation::updateTransformFromMatrices"
<< " matrixScreen=\n" << QTransformToString (matrixScreen).toLatin1().data () << " "
<< " matrixGraphRaw=\n" << QTransformToString (matrixGraph).toLatin1().data() << " "
<< " matrixGraphLinear=\n" << QTransformToString (matrixGraphLinear).toLatin1().data() << "\n"
<< " originalScreen0=" << QPointFToString (pointScreen0).toLatin1().data() << "\n"
<< " originalScreen1=" << QPointFToString (pointScreen1).toLatin1().data() << "\n"
<< " originalScreen2=" << QPointFToString (pointScreen2).toLatin1().data() << "\n"
<< " roundTripScreen0=" << QPointFToString (pointScreenRoundTrip0).toLatin1().data() << "\n"
<< " roundTripScreen1=" << QPointFToString (pointScreenRoundTrip1).toLatin1().data() << "\n"
<< " roundTripScreen2=" << QPointFToString (pointScreenRoundTrip2).toLatin1().data() << "\n";
}
QString GammaRay::Util::variantToString(const QVariant &value)
{
switch (value.type()) {
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(variantToString(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::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 variantToString(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::SizePolicy:
return QString::fromLatin1("%1 x %2").
arg(sizePolicyToString(value.value<QSizePolicy>().horizontalPolicy())).
arg(sizePolicyToString(value.value<QSizePolicy>().verticalPolicy()));
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() == 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.type() == qMetaTypeId<QWidget*>()) {
return displayString(value.value<QWidget*>());
}
if (value.userType() == qMetaTypeId<QGraphicsEffect*>()) {
return addressToString(value.value<QGraphicsEffect*>());
}
if (value.userType() == qMetaTypeId<QGraphicsItem*>()) {
return addressToString(value.value<QGraphicsItem*>());
}
if (value.userType() == qMetaTypeId<QGraphicsItemGroup*>()) {
return addressToString(value.value<QGraphicsItemGroup*>());
}
if (value.userType() == qMetaTypeId<QGraphicsObject*>()) {
return displayString(value.value<QGraphicsObject*>());
}
if (value.userType() == qMetaTypeId<QGraphicsWidget*>()) {
return displayString(value.value<QGraphicsWidget*>());
}
if (value.userType() == qMetaTypeId<const QStyle*>()) {
return displayString(value.value<const QStyle*>());
}
// enums
const QString enumStr = enumToString(value);
if (!enumStr.isEmpty()) {
return enumStr;
}
return value.toString();
}
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, %2 → %3, %4").
arg(value.toLine().x1()).arg(value.toLine().y1()).
arg(value.toLine().x2()).arg(value.toLine().y2());
case QVariant::LineF:
return
QString::fromUtf8("%1, %2 → %3, %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("%1, %2").
arg(value.toPoint().x()).
arg(value.toPoint().y());
case QVariant::PointF:
return
QString::fromLatin1("%1, %2").
arg(value.toPointF().x()).
arg(value.toPointF().y());
case QVariant::Rect:
return
QString::fromLatin1("%1, %2 %3 x %4").
arg(value.toRect().x()).
arg(value.toRect().y()).
arg(value.toRect().width()).
arg(value.toRect().height());
case QVariant::RectF:
return
QString::fromLatin1("%1, %2 %3 x %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("%1 x %2").
arg(value.toSize().width()).
arg(value.toSize().height());
case QVariant::SizeF:
return
QString::fromLatin1("%1 x %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 (value.userType() == qMetaTypeId<QMatrix4x4>()) {
return displayMatrix4x4(value.value<QMatrix4x4>());
}
if (value.userType() == qMetaTypeId<const QMatrix4x4*>()) {
return displayMatrix4x4(value.value<const QMatrix4x4*>());
}
#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(", ");
}
bool LcmsColorProfileContainer::init()
{
if (d->profile) {
cmsCloseProfile(d->profile);
}
d->profile = cmsOpenProfileFromMem((void *)d->data->rawData().constData(), d->data->rawData().size());
#ifndef NDEBUG
if (d->data->rawData().size() == 4096) {
qWarning() << "Profile has a size of 4096, which is suspicious and indicates a possible misuse of QIODevice::read(int), check your code.";
}
#endif
if (d->profile) {
wchar_t buffer[_BUFFER_SIZE_];
d->colorSpaceSignature = cmsGetColorSpace(d->profile);
d->deviceClass = cmsGetDeviceClass(d->profile);
cmsGetProfileInfo(d->profile, cmsInfoDescription, cmsNoLanguage, cmsNoCountry, buffer, _BUFFER_SIZE_);
d->name = QString::fromWCharArray(buffer);
//apparantly this should give us a localised string??? Not sure about this.
cmsGetProfileInfo(d->profile, cmsInfoModel, cmsNoLanguage, cmsNoCountry, buffer, _BUFFER_SIZE_);
d->productDescription = QString::fromWCharArray(buffer);
cmsGetProfileInfo(d->profile, cmsInfoManufacturer, cmsNoLanguage, cmsNoCountry, buffer, _BUFFER_SIZE_);
d->manufacturer = QString::fromWCharArray(buffer);
cmsGetProfileInfo(d->profile, cmsInfoCopyright, cmsNoLanguage, cmsNoCountry, buffer, _BUFFER_SIZE_);
d->copyright = QString::fromWCharArray(buffer);
cmsProfileClassSignature profile_class;
profile_class = cmsGetDeviceClass(d->profile);
d->valid = (profile_class != cmsSigNamedColorClass);
//This is where obtain the whitepoint, and convert it to the actual white point of the profile in the case a Chromatic adaption tag is
//present. This is necessary for profiles following the v4 spec.
cmsCIEXYZ baseMediaWhitePoint;//dummy to hold copy of mediawhitepoint if this is modified by chromatic adaption.
if (cmsIsTag(d->profile, cmsSigMediaWhitePointTag)) {
d->mediaWhitePoint = *((cmsCIEXYZ *)cmsReadTag(d->profile, cmsSigMediaWhitePointTag));
baseMediaWhitePoint = d->mediaWhitePoint;
cmsXYZ2xyY(&d->whitePoint, &d->mediaWhitePoint);
if (cmsIsTag(d->profile, cmsSigChromaticAdaptationTag)) {
//the chromatic adaption tag represent a matrix from the actual white point of the profile to D50.
cmsCIEXYZ *CAM1 = (cmsCIEXYZ *)cmsReadTag(d->profile, cmsSigChromaticAdaptationTag);
//We first put all our data into structures we can manipulate.
double d3dummy [3] = {d->mediaWhitePoint.X, d->mediaWhitePoint.Y, d->mediaWhitePoint.Z};
QGenericMatrix<1, 3, double> whitePointMatrix(d3dummy);
QTransform invertDummy(CAM1[0].X, CAM1[0].Y, CAM1[0].Z, CAM1[1].X, CAM1[1].Y, CAM1[1].Z, CAM1[2].X, CAM1[2].Y, CAM1[2].Z);
//we then abuse QTransform's invert function because it probably does matrix invertion 20 times better than I can program.
//if the matrix is uninvertable, invertedDummy will be an identity matrix, which for us means that it won't give any noticeble
//effect when we start multiplying.
QTransform invertedDummy = invertDummy.inverted();
//we then put the QTransform into a generic 3x3 matrix.
double d9dummy [9] = {invertedDummy.m11(), invertedDummy.m12(), invertedDummy.m13(),
invertedDummy.m21(), invertedDummy.m22(), invertedDummy.m23(),
invertedDummy.m31(), invertedDummy.m32(), invertedDummy.m33()
};
QGenericMatrix<3, 3, double> chromaticAdaptionMatrix(d9dummy);
//multiplying our inverted adaption matrix with the whitepoint gives us the right whitepoint.
QGenericMatrix<1, 3, double> result = chromaticAdaptionMatrix * whitePointMatrix;
//and then we pour the matrix into the whitepoint variable. Generic matrix does row/column for indices even though it
//uses column/row for initialising.
d->mediaWhitePoint.X = result(0, 0);
d->mediaWhitePoint.Y = result(1, 0);
d->mediaWhitePoint.Z = result(2, 0);
cmsXYZ2xyY(&d->whitePoint, &d->mediaWhitePoint);
}
}
//This is for RGB profiles, but it only works for matrix profiles. Need to design it to work with non-matrix profiles.
if (cmsIsTag(d->profile, cmsSigRedColorantTag)) {
cmsCIEXYZTRIPLE tempColorants;
tempColorants.Red = *((cmsCIEXYZ *)cmsReadTag(d->profile, cmsSigRedColorantTag));
tempColorants.Green = *((cmsCIEXYZ *)cmsReadTag(d->profile, cmsSigGreenColorantTag));
tempColorants.Blue = *((cmsCIEXYZ *)cmsReadTag(d->profile, cmsSigBlueColorantTag));
//convert to d65, this is useless.
cmsAdaptToIlluminant(&d->colorants.Red, &baseMediaWhitePoint, &d->mediaWhitePoint, &tempColorants.Red);
cmsAdaptToIlluminant(&d->colorants.Green, &baseMediaWhitePoint, &d->mediaWhitePoint, &tempColorants.Green);
cmsAdaptToIlluminant(&d->colorants.Blue, &baseMediaWhitePoint, &d->mediaWhitePoint, &tempColorants.Blue);
//d->colorants = tempColorants;
d->hasColorants = true;
} else {
//qDebug()<<d->name<<": has no colorants";
d->hasColorants = false;
}
//retrieve TRC.
if (cmsIsTag(d->profile, cmsSigRedTRCTag) && cmsIsTag(d->profile, cmsSigBlueTRCTag) && cmsIsTag(d->profile, cmsSigGreenTRCTag)) {
d->redTRC = ((cmsToneCurve *)cmsReadTag (d->profile, cmsSigRedTRCTag));
d->greenTRC = ((cmsToneCurve *)cmsReadTag (d->profile, cmsSigGreenTRCTag));
d->blueTRC = ((cmsToneCurve *)cmsReadTag (d->profile, cmsSigBlueTRCTag));
d->redTRCReverse = cmsReverseToneCurve(d->redTRC);
d->greenTRCReverse = cmsReverseToneCurve(d->greenTRC);
d->blueTRCReverse = cmsReverseToneCurve(d->blueTRC);
d->hasTRC = true;
} else if (cmsIsTag(d->profile, cmsSigGrayTRCTag)) {
d->grayTRC = ((cmsToneCurve *)cmsReadTag (d->profile, cmsSigGrayTRCTag));
d->grayTRCReverse = cmsReverseToneCurve(d->grayTRC);
d->hasTRC = true;
} else {
d->hasTRC = false;
}
// Check if the profile can convert (something->this)
d->suitableForOutput = cmsIsMatrixShaper(d->profile)
|| (cmsIsCLUT(d->profile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT) &&
cmsIsCLUT(d->profile, INTENT_PERCEPTUAL, LCMS_USED_AS_OUTPUT));
d->version = cmsGetProfileVersion(d->profile);
d->defaultIntent = cmsGetHeaderRenderingIntent(d->profile);
d->isMatrixShaper = cmsIsMatrixShaper(d->profile);
d->isPerceptualCLUT = cmsIsCLUT(d->profile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT);
d->isSaturationCLUT = cmsIsCLUT(d->profile, INTENT_SATURATION, LCMS_USED_AS_INPUT);
d->isAbsoluteCLUT = cmsIsCLUT(d->profile, INTENT_SATURATION, LCMS_USED_AS_INPUT);
d->isRelativeCLUT = cmsIsCLUT(d->profile, INTENT_RELATIVE_COLORIMETRIC, LCMS_USED_AS_INPUT);
return true;
}
return false;
}
/*!
Traverse QObject based items.
*/
void TasQtTraverse::traverseObject(TasObject* objectInfo, QObject* object, TasCommand* command)
{
// Embedded apps must use coordinates for operations, as the parent has no knowledge of the
// Actual items
bool embeddedApp = false;
if (command && command->parameter("embedded") == "true") {
embeddedApp = true;
}
//TasLogger::logger()->debug("TasQtTraverse::traverseObject in");
mTraverseUtils->addObjectDetails(objectInfo, object);
QGraphicsObject* graphicsObject = qobject_cast<QGraphicsObject*>(object);
if(graphicsObject){
objectInfo->addAttribute("objectType", embeddedApp? TYPE_WEB : TYPE_GRAPHICS_VIEW);
mTraverseUtils->addGraphicsItemCoordinates(objectInfo, graphicsObject, command);
mTraverseUtils->printGraphicsItemProperties(objectInfo, graphicsObject);
//add details only for graphicsitems
QGraphicsWidget* graphicsWidget = qobject_cast<QGraphicsWidget*>(object);
if(graphicsWidget){
mTraverseUtils->addFont(objectInfo, graphicsWidget->font());
// Elided format "this is a text" -> "this is a..." text for
// items that have the "text" property.
QVariant text = graphicsWidget->property("text");
if (text.isValid()) {
mTraverseUtils->addTextInfo(objectInfo, text.toString(), graphicsWidget->font(), graphicsWidget->size().width());
}
QVariant plainText = graphicsWidget->property("plainText");
if (plainText.isValid()) {
mTraverseUtils->addTextInfo(objectInfo, plainText.toString(), graphicsWidget->font(), graphicsWidget->size().width());
}
}
}
else{
QQuickItem* quickObject = qobject_cast<QQuickItem*>(object);
if (quickObject) {
objectInfo->addAttribute("objectType", TYPE_QSCENEGRAPH );
}
//make sure that we are dealing with a widget
else if (object->isWidgetType()){
QWidget* widget = qobject_cast<QWidget*>(object);
objectInfo->addAttribute("objectType", TYPE_STANDARD_VIEW );
addWidgetCoordinates(objectInfo, widget,command);
mTraverseUtils->addFont(objectInfo, widget->font());
//check is the widget a viewport to graphicsscene
QWidget* parentWidget = widget->parentWidget();
bool isViewPort = false;
if(parentWidget && parentWidget->inherits("QGraphicsView")){
QGraphicsView* view = qobject_cast<QGraphicsView*>(parentWidget);
if(view->viewport() == widget){
isViewPort = true;
}
}
//add transformation details
QGraphicsView* graphicsView = qobject_cast<QGraphicsView*>(object);
if(graphicsView){
objectInfo->addBooleanAttribute("isTransformed", graphicsView->isTransformed());
if(graphicsView->isTransformed()){
QTransform tr = graphicsView->transform();
objectInfo->addAttribute("transformM11",tr.m11());
objectInfo->addAttribute("transformM12",tr.m12());
objectInfo->addAttribute("transformM13",tr.m13());
objectInfo->addAttribute("transformM21",tr.m21());
objectInfo->addAttribute("transformM22",tr.m22());
objectInfo->addAttribute("transformM23",tr.m23());
objectInfo->addAttribute("transformM31",tr.m31());
objectInfo->addAttribute("transformM32",tr.m32());
objectInfo->addAttribute("transformM33",tr.m33());
}
}
objectInfo->addBooleanAttribute("isViewPort", isViewPort);
// Add special window id attribute into qwidget atttributes
#if defined(Q_WS_X11)
unsigned long wid = static_cast<unsigned long>(widget->effectiveWinId());
objectInfo->addAttribute("xWindow", (int)wid); // can this fail due to precision?
#endif
} else if(object->isWindowType()) {
objectInfo->addAttribute("objectType", TYPE_WINDOW_VIEW);
} else {
if(object != qApp){
objectInfo->addAttribute("objectType", embeddedApp? TYPE_WEB : TYPE_STANDARD_VIEW );
}
}
}
}
void GlslPainter::paint(QPainter *painter,
QRectF target,
QQuickWindow *window)
{
// Need to reenable those after native painting has begun, otherwise we might
// not be able to paint anything.
bool stencilTestEnabled = glIsEnabled(GL_STENCIL_TEST);
bool scissorTestEnabled = glIsEnabled(GL_SCISSOR_TEST);
painter->beginNativePainting();
if (stencilTestEnabled)
glEnable(GL_STENCIL_TEST);
if (scissorTestEnabled)
glEnable(GL_SCISSOR_TEST);
//////////////////////////////////////////////////////////////
initTextures();
//////////////////////////////////////////////////////////////
// As seen on the telly
#ifdef __GNUC__
#warning DUPLICATED CODE
#endif
const float textureCoordinates[] = {
0, 1, // bottom left
1, 1, // bottom right
0, 0, // top left
1, 0, // top right
};
const GLfloat targetVertex[] =
{
GLfloat(target.left()), GLfloat(target.bottom()),
GLfloat(target.right()), GLfloat(target.bottom()),
GLfloat(target.left()) , GLfloat(target.top()),
GLfloat(target.right()), GLfloat(target.top())
};
//
const int width = window->width();
const int height = window->height();
const QTransform transform = painter->deviceTransform();
const GLfloat wfactor = 2.0 / width;
const GLfloat hfactor = -2.0 / height;
const GLfloat positionMatrix[4][4] = {
{
GLfloat(wfactor * transform.m11() - transform.m13()),
GLfloat(hfactor * transform.m12() + transform.m13()),
0.0,
GLfloat(transform.m13())
}, {
GLfloat(wfactor * transform.m21() - transform.m23()),
GLfloat(hfactor * transform.m22() + transform.m23()),
0.0,
GLfloat(transform.m23())
}, {
0.0,
0.0,
-1.0,
0.0
}, {
GLfloat(wfactor * transform.dx() - transform.m33()),
GLfloat(hfactor * transform.dy() + transform.m33()),
0.0,
GLfloat(transform.m33())
}
};
_program->bind();
_program->enableAttributeArray("targetVertex");
_program->enableAttributeArray("textureCoordinates");
_program->setAttributeArray("targetVertex", targetVertex, 2);
_program->setAttributeArray("textureCoordinates", textureCoordinates, 2);
_program->setUniformValue("positionMatrix", positionMatrix);
if (_textureCount == 3) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureIds[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, _textureIds[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, _textureIds[2]);
glActiveTexture(GL_TEXTURE0);
_program->setUniformValue("texY", 0);
_program->setUniformValue("texU", 1);
_program->setUniformValue("texV", 2);
}
_program->setUniformValue("colorMatrix", _colorMatrix);
_program->setUniformValue("opacity", GLfloat(painter->opacity()));
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
_program->release();
painter->endNativePainting();
#if !defined(Q_OS_WIN)
// TODO: FPS optional
calculateFPS();
addFPSOverlay();
#endif
}
void PropertiesPalette_XYZ::handleBasePoint(int m)
{
if (!m_ScMW || m_ScMW->scriptIsRunning())
return;
double inX, inY, gx, gy, gh, gw;
inX = 0;
inY = 0;
if ((m_haveDoc) && (m_haveItem))
{
m_haveItem = false;
m_doc->RotMode ( m );
if (m_doc->m_Selection->isMultipleSelection())
{
m_doc->m_Selection->setGroupRect();
m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
if (m == 0)
{
m_ScMW->view->RCenter = FPoint(gx, gy);
inX = gx;
inY = gy;
}
if (m == 1)
{
m_ScMW->view->RCenter = FPoint(gx+gw, gy);
inX = gx+gw;
inY = gy;
}
if (m == 2)
{
m_ScMW->view->RCenter = FPoint(gx + gw / 2.0, gy + gh / 2.0);
inX = gx + gw / 2.0;
inY = gy + gh / 2.0;
}
if (m == 3)
{
m_ScMW->view->RCenter = FPoint(gx, gy+gh);
inX = gx;
inY = gy+gh;
}
if (m == 4)
{
m_ScMW->view->RCenter = FPoint(gx+gw, gy+gh);
inX = gx+gw;
inY = gy+gh;
}
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
}
else
{
double b, h, r;
QTransform ma;
FPoint n;
b = m_item->width();
h = m_item->height();
r = m_item->rotation();
ma.translate(m_item->xPos(), m_item->yPos());
ma.rotate(r);
int bp = basePointWidget->checkedId();
if (bp == 0)
n = FPoint(0.0, 0.0);
else if (bp == 1)
n = FPoint(b, 0.0);
else if (bp == 2)
n = FPoint(b / 2.0, h / 2.0);
else if (bp == 3)
n = FPoint(0.0, h);
else if (bp == 4)
n = FPoint(b, h);
inX = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
inY = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
}
if (m_item->itemType() == PageItem::ImageFrame)
{
// FIXME
if (false /*!FreeScale->isChecked()*/)
{
m_item->AdjustPictScale();
m_item->update();
emit DocChanged();
}
}
m_haveItem = true;
}
}
void PropertiesPalette_XYZ::displayXY(double x, double y)
{
if (!m_ScMW || m_ScMW->scriptIsRunning())
return;
disconnect(xposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewX()));
disconnect(yposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewY()));
bool useLineMode = false;
bool tmp = m_haveItem;
double inX, inY, b, h, r, dummy1, dummy2;
QTransform ma;
FPoint n;
if (m_haveItem)
{
if (m_doc->m_Selection->isMultipleSelection())
{
m_doc->m_Selection->getGroupRect(&dummy1, &dummy2, &b, &h);
r = 0.0;
ma.translate(dummy1, dummy2);
}
else
{
b = m_item->width();
h = m_item->height();
r = m_item->rotation();
ma.translate(x, y);
useLineMode = (m_lineMode && m_item->isLine());
}
}
else
{
b = 0.0;
h = 0.0;
r = 0.0;
ma.translate(x, y);
}
m_haveItem = false;
ma.rotate(r);
int bp = basePointWidget->checkedId();
// #8890 : basepoint is meaningless when lines use "end points" mode
if (bp == 0 || useLineMode)
n = FPoint(0.0, 0.0);
else if (bp == 1)
n = FPoint(b, 0.0);
else if (bp == 2)
n = FPoint(b / 2.0, h / 2.0);
else if (bp == 3)
n = FPoint(0.0, h);
else if (bp == 4)
n = FPoint(b, h);
inX = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
inY = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
if (tmp)
{
inX -= m_doc->rulerXoffset;
inY -= m_doc->rulerYoffset;
if (m_doc->guidesPrefs().rulerMode)
{
inX -= m_doc->currentPage()->xOffset();
inY -= m_doc->currentPage()->yOffset();
}
}
xposSpin->setValue(inX*m_unitRatio);
yposSpin->setValue(inY*m_unitRatio);
if (useLineMode)
displayWH(m_item->width(), m_item->height());
m_haveItem = tmp;
connect(xposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewX()));
connect(yposSpin, SIGNAL(valueChanged(double)), this, SLOT(handleNewY()));
}
void transformShow(QTransform t) {
qDebug("%5.3e\t%5.3e\t%5.3e\n",t.m11(),t.m12(),t.m13());
qDebug("%5.3e\t%5.3e\t%5.3e\n",t.m21(),t.m22(),t.m23());
qDebug("%5.3e\t%5.3e\t%5.3e\n",t.m31(),t.m32(),t.m33());
}
