Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include "utils_p.h"
#include <QtGui/QPainter>
#include <QtGui/QOpenGLContext>
#include <QtGui/QOffscreenSurface>
#include <QtGui/qquaternion.h>
#include <QtCore/QCoreApplication>
#include <QtCore/QRegularExpression>
#include <QLocale>
QT_BEGIN_NAMESPACE
#define NUM_IN_POWER(y, x) for (;y<x;y<<=1)
#define MIN_POWER 2
// Some values that only need to be resolved once
static bool staticsResolved = false;
static GLint maxTextureSize = 0;
static bool isES = false;
GLuint Utils::getNearestPowerOfTwo(GLuint value)
{
GLuint powOfTwoValue = MIN_POWER;
NUM_IN_POWER(powOfTwoValue, value);
return powOfTwoValue;
}
QVector4D Utils::vectorFromColor(const QColor &color)
{
return QVector4D(color.redF(), color.greenF(), color.blueF(), color.alphaF());
}
QColor Utils::colorFromVector(const QVector3D &colorVector)
{
return QColor(colorVector.x() * 255.0f, colorVector.y() * 255.0f,
colorVector.z() * 255.0f, 255.0f);
}
QColor Utils::colorFromVector(const QVector4D &colorVector)
{
return QColor(colorVector.x() * 255.0f, colorVector.y() * 255.0f,
colorVector.z() * 255.0f, colorVector.w() * 255.0f);
}
QImage Utils::printTextToImage(const QFont &font, const QString &text, const QColor &bgrColor,
const QColor &txtColor, bool labelBackground,
bool borders, int maxLabelWidth)
{
if (!staticsResolved)
resolveStatics();
GLuint paddingWidth = 20;
GLuint paddingHeight = 20;
GLuint prePadding = 20;
GLint targetWidth = maxTextureSize;
// Calculate text dimensions
QFont valueFont = font;
valueFont.setPointSize(textureFontSize);
QFontMetrics valueFM(valueFont);
int valueStrWidth = valueFM.horizontalAdvance(text);
// ES2 needs to use maxLabelWidth always (when given) because of the power of 2 -issue.
if (maxLabelWidth && (labelBackground || Utils::isOpenGLES()))
valueStrWidth = maxLabelWidth;
int valueStrHeight = valueFM.height();
valueStrWidth += paddingWidth / 2; // Fix clipping problem with skewed fonts (italic or italic-style)
QSize labelSize;
qreal fontRatio = 1.0;
if (Utils::isOpenGLES()) {
// Test if text with slighly smaller font would fit into one step smaller texture
// ie. if the text is just exceeded the smaller texture boundary, it would
// make a label with large empty space
uint testWidth = getNearestPowerOfTwo(valueStrWidth + prePadding) >> 1;
int diffToFit = (valueStrWidth + prePadding) - testWidth;
int maxSqueeze = int((valueStrWidth + prePadding) * 0.25f);
if (diffToFit < maxSqueeze && maxTextureSize > GLint(testWidth))
targetWidth = testWidth;
}
bool sizeOk = false;
int currentFontSize = textureFontSize;
do {
if (Utils::isOpenGLES()) {
// ES2 can't handle textures with dimensions not in power of 2. Resize labels accordingly.
// Add some padding before converting to power of two to avoid too tight fit
labelSize = QSize(valueStrWidth + prePadding, valueStrHeight + prePadding);
labelSize.setWidth(getNearestPowerOfTwo(labelSize.width()));
labelSize.setHeight(getNearestPowerOfTwo(labelSize.height()));
} else {
if (!labelBackground)
labelSize = QSize(valueStrWidth, valueStrHeight);
else
labelSize = QSize(valueStrWidth + paddingWidth * 2, valueStrHeight + paddingHeight * 2);
}
if (!maxTextureSize || (labelSize.width() <= maxTextureSize
&& (labelSize.width() <= targetWidth || !Utils::isOpenGLES()))) {
// Make sure the label is not too wide
sizeOk = true;
} else if (--currentFontSize == 4) {
qCritical() << "Label" << text << "is too long to be generated.";
return QImage();
} else {
fontRatio = (qreal)currentFontSize / (qreal)textureFontSize;
// Reduce font size and try again
valueFont.setPointSize(currentFontSize);
QFontMetrics currentValueFM(valueFont);
if (maxLabelWidth && (labelBackground || Utils::isOpenGLES()))
valueStrWidth = maxLabelWidth * fontRatio;
else
valueStrWidth = currentValueFM.horizontalAdvance(text);
valueStrHeight = currentValueFM.height();
valueStrWidth += paddingWidth / 2;
}
} while (!sizeOk);
return [&] {
// Create image
QImage image = QImage(labelSize, QImage::Format_ARGB32);
image.fill(Qt::transparent);
// Init painter
QPainter painter(&image);
// Paint text
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.setFont(valueFont);
if (!labelBackground) {
painter.setPen(txtColor);
if (Utils::isOpenGLES()) {
painter.drawText((labelSize.width() - valueStrWidth) / 2.0f,
(labelSize.height() - valueStrHeight) / 2.0f,
valueStrWidth, valueStrHeight,
Qt::AlignCenter | Qt::AlignVCenter,
text);
} else {
painter.drawText(0, 0,
valueStrWidth, valueStrHeight,
Qt::AlignCenter | Qt::AlignVCenter,
text);
}
} else {
painter.setBrush(QBrush(bgrColor));
qreal radius = 10.0 * fontRatio;
if (borders) {
painter.setPen(QPen(QBrush(txtColor), 5.0 * fontRatio,
Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin));
painter.drawRoundedRect(5, 5,
labelSize.width() - 10, labelSize.height() - 10,
radius, radius);
} else {
painter.setPen(bgrColor);
painter.drawRoundedRect(0, 0, labelSize.width(), labelSize.height(), radius, radius);
}
painter.setPen(txtColor);
painter.drawText((labelSize.width() - valueStrWidth) / 2.0f,
(labelSize.height() - valueStrHeight) / 2.0f,
valueStrWidth, valueStrHeight,
Qt::AlignCenter | Qt::AlignVCenter,
text);
}
return image;
}();
}
QVector4D Utils::getSelection(QPoint mousepos, int height)
{
// This is the only one that works with OpenGL ES 2.0, so we're forced to use it
// Item count will be limited to 256*256*256
GLubyte pixel[4] = {255, 255, 255, 255};
QOpenGLContext::currentContext()->functions()->glReadPixels(mousepos.x(), height - mousepos.y(),
1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
(void *)pixel);
QVector4D selectedColor(pixel[0], pixel[1], pixel[2], pixel[3]);
return selectedColor;
}
QImage Utils::getGradientImage(QLinearGradient &gradient)
{
QImage image(QSize(gradientTextureWidth, gradientTextureHeight), QImage::Format_RGB32);
gradient.setFinalStop(qreal(gradientTextureWidth), qreal(gradientTextureHeight));
gradient.setStart(0.0, 0.0);
QPainter pmp(&image);
pmp.setBrush(QBrush(gradient));
pmp.setPen(Qt::NoPen);
pmp.drawRect(0, 0, int(gradientTextureWidth), int(gradientTextureHeight));
return image;
}
Utils::ParamType Utils::preParseFormat(const QString &format, QString &preStr, QString &postStr,
int &precision, char &formatSpec)
{
static QRegularExpression formatMatcher(QStringLiteral("^([^%]*)%([\\-\\+#\\s\\d\\.lhjztL]*)([dicuoxfegXFEG])(.*)$"));
static QRegularExpression precisionMatcher(QStringLiteral("\\.(\\d+)"));
Utils::ParamType retVal;
QRegularExpressionMatch formatMatch = formatMatcher.match(format, 0);
if (formatMatch.hasMatch()) {
preStr = formatMatch.captured(1);
// Six and 'g' are defaults in Qt API
precision = 6;
if (!formatMatch.captured(2).isEmpty()) {
QRegularExpressionMatch precisionMatch = precisionMatcher.match(formatMatch.captured(2),
0);
if (precisionMatch.hasMatch())
precision = precisionMatch.captured(1).toInt();
}
if (formatMatch.captured(3).isEmpty())
formatSpec = 'g';
else
formatSpec = formatMatch.captured(3).at(0).toLatin1();
postStr = formatMatch.captured(4);
retVal = mapFormatCharToParamType(formatSpec);
} else {
retVal = ParamTypeUnknown;
// The out parameters are irrelevant in unknown case
}
return retVal;
}
Utils::ParamType Utils::mapFormatCharToParamType(char formatSpec)
{
ParamType retVal = ParamTypeUnknown;
if (formatSpec == 'd' || formatSpec == 'i' || formatSpec == 'c') {
retVal = ParamTypeInt;
} else if (formatSpec == 'u' || formatSpec == 'o'
|| formatSpec == 'x'|| formatSpec == 'X') {
retVal = ParamTypeUInt;
} else if (formatSpec == 'f' || formatSpec == 'F'
|| formatSpec == 'e' || formatSpec == 'E'
|| formatSpec == 'g' || formatSpec == 'G') {
retVal = ParamTypeReal;
}
return retVal;
}
QString Utils::formatLabelSprintf(const QByteArray &format, Utils::ParamType paramType, qreal value)
{
switch (paramType) {
case ParamTypeInt:
return QString::asprintf(format.constData(), qint64(value));
case ParamTypeUInt:
return QString::asprintf(format.constData(), quint64(value));
case ParamTypeReal:
return QString::asprintf(format.constData(), value);
default:
// Return format string to detect errors. Bars selection label logic also depends on this.
return QString::fromUtf8(format);
}
}
QString Utils::formatLabelLocalized(Utils::ParamType paramType, qreal value,
const QLocale &locale, const QString &preStr, const QString &postStr,
int precision, char formatSpec, const QByteArray &format)
{
switch (paramType) {
case ParamTypeInt:
case ParamTypeUInt:
return preStr + locale.toString(qint64(value)) + postStr;
case ParamTypeReal:
return preStr + locale.toString(value, formatSpec, precision) + postStr;
default:
// Return format string to detect errors. Bars selection label logic also depends on this.
return QString::fromUtf8(format);
}
}
QString Utils::defaultLabelFormat()
{
static const QString defaultFormat(QStringLiteral("%.2f"));
return defaultFormat;
}
float Utils::wrapValue(float value, float min, float max)
{
if (value > max) {
value = min + (value - max);
// In case single wrap fails, jump to opposite end.
if (value > max)
value = min;
}
if (value < min) {
value = max + (value - min);
// In case single wrap fails, jump to opposite end.
if (value < min)
value = max;
}
return value;
}
QQuaternion Utils::calculateRotation(const QVector3D &xyzRotations)
{
QQuaternion rotQuatX = QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, xyzRotations.x());
QQuaternion rotQuatY = QQuaternion::fromAxisAndAngle(0.0f, 1.0f, 0.0f, xyzRotations.y());
QQuaternion rotQuatZ = QQuaternion::fromAxisAndAngle(0.0f, 0.0f, 1.0f, xyzRotations.z());
QQuaternion totalRotation = rotQuatY * rotQuatZ * rotQuatX;
return totalRotation;
}
bool Utils::isOpenGLES()
{
if (!staticsResolved)
resolveStatics();
return isES;
}
void Utils::resolveStatics()
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
QOffscreenSurface *dummySurface = 0;
if (!ctx) {
QSurfaceFormat surfaceFormat;
dummySurface = new QOffscreenSurface();
dummySurface->setFormat(surfaceFormat);
dummySurface->create();
ctx = new QOpenGLContext;
ctx->setFormat(surfaceFormat);
ctx->create();
ctx->makeCurrent(dummySurface);
}
#if QT_CONFIG(opengles2)
isES = true;
#elif (QT_VERSION < QT_VERSION_CHECK(5, 3, 0))
isES = false;
#else
isES = ctx->isOpenGLES();
#endif
ctx->functions()->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
// We support only ES2 emulation with software renderer for now
QString versionStr;
#ifdef Q_OS_WIN
const GLubyte *openGLVersion = ctx->functions()->glGetString(GL_VERSION);
versionStr = QString::fromLatin1(reinterpret_cast<const char *>(openGLVersion)).toLower();
#endif
if (versionStr.contains(QStringLiteral("mesa"), Qt::CaseInsensitive)
|| QCoreApplication::testAttribute(Qt::AA_UseSoftwareOpenGL)) {
qWarning("Only OpenGL ES2 emulation is available for software rendering.");
isES = true;
}
#endif
if (dummySurface) {
ctx->doneCurrent();
delete ctx;
delete dummySurface;
}
staticsResolved = true;
}
QT_END_NAMESPACE