AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use C++ <cmath> instead of <math.h>

Browse Source 
Including math.h can pollute the default namespace, and break
some compilers if cmath versions of the method are declared as using.

Switching to C++ math functions also greatly simplifies handling of
float qreal as C++ automatically chooses the right method.

[ChangeLog][QtCore][QtMath] qmath.h no longer includes math.h, so any
sources depending on that indirect inclusion may fail to build.

Change-Id: I4d0e331dafba354ec05dc5052e61ef4ff8d387fe
Reviewed-by: Rafael Roquetto <rafael.roquetto@kdab.com>
This commit is contained in:
Allan Sandfeld Jensen 2015-01-14 11:17:47 +01:00
parent 3d835eb62e
commit 515e802ae2
41 changed files with 171 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
config.tests/unix/floatmath/floatmath.cpp
View File

@ -1,50 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the config.tests of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <math.h>
int main(int argc, char **argv)
{
float c = ceilf(1.3f);
float f = floorf(1.7f);
float s = sinf(3.8);
float t = cosf(7.3);
float u = sqrtf(8.4);
float l = logf(9.2);
if (c == 1.0f && f == 2.0f && s == 3.0f && t == 4.0f && u == 5.0f && l == 6.0f)
return 0;
else
return 1;
}

3
config.tests/unix/floatmath/floatmath.pro
View File

@ -1,3 +0,0 @@
SOURCES = floatmath.cpp
CONFIG -= x11 qt

11
configure vendored
View File

@ -4261,13 +4261,6 @@ if [ "$CFG_CXX11" != "no" ]; then
fi
fi
# detect availability of float math.h functions
if compileTest unix/floatmath "floatmath"; then
CFG_USE_FLOATMATH=yes
else
CFG_USE_FLOATMATH=no
fi
# detect sse2 support
if [ "${CFG_SSE2}" = "auto" ]; then
if compileTest common/sse2 "sse2"; then
@ -6498,10 +6491,6 @@ fi
# Add QPA to config.h
QCONFIG_FLAGS="$QCONFIG_FLAGS"
if [ "${CFG_USE_FLOATMATH}" = "yes" ]; then
QCONFIG_FLAGS="${QCONFIG_FLAGS} QT_USE_MATH_H_FLOATS"
fi
# Add turned on SQL drivers
for DRIVER in $CFG_SQL_AVAILABLE; do
eval "VAL=\$CFG_SQL_$DRIVER"

9
examples/corelib/threads/mandelbrot/renderthread.cpp
View File

@ -41,8 +41,7 @@
#include "renderthread.h"
#include <QtWidgets>
#include <math.h>
#include <cmath>
//! [0]
RenderThread::RenderThread(QObject *parent)
@ -207,9 +206,9 @@ uint RenderThread::rgbFromWaveLength(double wave)
else if (wave < 420.0)
s = 0.3 + 0.7 * (wave - 380.0) / (420.0 - 380.0);
r = pow(r * s, 0.8);
g = pow(g * s, 0.8);
b = pow(b * s, 0.8);
r = std::pow(r * s, 0.8);
g = std::pow(g * s, 0.8);
b = std::pow(b * s, 0.8);
return qRgb(int(r * 255), int(g * 255), int(b * 255));
}
//! [10]

4
examples/qtconcurrent/imagescaling/imagescaling.cpp
View File

@ -38,7 +38,7 @@
**
****************************************************************************/
#include "imagescaling.h"
#include "math.h"
#include <qmath.h>
const int imageSize = 100;
@ -110,7 +110,7 @@ void Images::open()
qDeleteAll(labels);
labels.clear();
int dim = sqrt(qreal(files.count())) + 1;
int dim = qSqrt(qreal(files.count())) + 1;
for (int i = 0; i < dim; ++i) {
for (int j = 0; j < dim; ++j) {
QLabel *imageLabel = new QLabel;

9
examples/widgets/animation/animatedtiles/main.cpp
View File

@ -39,6 +39,7 @@
****************************************************************************/
#include <QtWidgets>
#include <QtCore/qmath.h>
#include <QtCore/qstate.h>
class Pixmap : public QObject, public QGraphicsPixmapItem
@ -181,13 +182,13 @@ int main(int argc, char **argv)
Pixmap *item = items.at(i);
// Ellipse
ellipseState->assignProperty(item, "pos",
QPointF(cos((i / 63.0) * 6.28) * 250,
sin((i / 63.0) * 6.28) * 250));
QPointF(qCos((i / 63.0) * 6.28) * 250,
qSin((i / 63.0) * 6.28) * 250));
// Figure 8
figure8State->assignProperty(item, "pos",
QPointF(sin((i / 63.0) * 6.28) * 250,
sin(((i * 2)/63.0) * 6.28) * 250));
QPointF(qSin((i / 63.0) * 6.28) * 250,
qSin(((i * 2)/63.0) * 6.28) * 250));
// Random
randomState->assignProperty(item, "pos",

5
examples/widgets/effects/blurpicker/blurpicker.cpp
View File

@ -41,6 +41,7 @@
#include "blurpicker.h"
#include <QtWidgets>
#include <QtCore/qmath.h>
#include "blureffect.h"
@ -76,8 +77,8 @@ void BlurPicker::setIndex(qreal index)
for (int i = 0; i < m_icons.count(); ++i) {
QGraphicsItem *icon = m_icons[i];
qreal a = ((i + m_index) * 2 * M_PI) / m_icons.count();
qreal xs = 170 * sin(a);
qreal ys = 100 * cos(a);
qreal xs = 170 * qSin(a);
qreal ys = 100 * qCos(a);
QPointF pos(xs, ys);
pos = QTransform().rotate(-20).map(pos);
pos -= QPointF(40, 40);

7
examples/widgets/effects/lighting/lighting.cpp
View File

@ -41,6 +41,7 @@
#include "lighting.h"
#include <QtWidgets>
#include <QtCore/qmath.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
@ -110,8 +111,8 @@ void Lighting::setupScene()
void Lighting::animate()
{
angle += (M_PI / 30);
qreal xs = 200 * sin(angle) - 40 + 25;
qreal ys = 200 * cos(angle) - 40 + 25;
qreal xs = 200 * qSin(angle) - 40 + 25;
qreal ys = 200 * qCos(angle) - 40 + 25;
m_lightSource->setPos(xs, ys);
for (int i = 0; i < m_items.size(); ++i) {
@ -125,7 +126,7 @@ void Lighting::animate()
qreal dx = delta.x();
qreal dy = delta.y();
qreal dd = sqrt(dx * dx + dy * dy);
qreal dd = qSqrt(dx * dx + dy * dy);
QColor color = effect->color();
color.setAlphaF(qBound(0.4, 1 - dd / 200.0, 0.7));
effect->setColor(color);

10
examples/widgets/graphicsview/boxes/qtbox.cpp
View File

@ -242,7 +242,7 @@ void ItemBase::keyPressEvent(QKeyEvent *event)
void ItemBase::wheelEvent(QGraphicsSceneWheelEvent *event)
{
prepareGeometryChange();
m_size = int(m_size * exp(-event->delta() / 600.0));
m_size = int(m_size * qExp(-event->delta() / 600.0));
if (m_size > MAX_ITEM_SIZE)
m_size = MAX_ITEM_SIZE;
else if (m_size < MIN_ITEM_SIZE)
@ -404,10 +404,10 @@ void CircleItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option
{
int dt = m_startTime.msecsTo(QTime::currentTime());
qreal r0 = 0.5 * m_size * (1.0 - exp(-0.001 * ((dt + 3800) % 4000)));
qreal r1 = 0.5 * m_size * (1.0 - exp(-0.001 * ((dt + 0) % 4000)));
qreal r2 = 0.5 * m_size * (1.0 - exp(-0.001 * ((dt + 1800) % 4000)));
qreal r3 = 0.5 * m_size * (1.0 - exp(-0.001 * ((dt + 2000) % 4000)));
qreal r0 = 0.5 * m_size * (1.0 - qExp(-0.001 * ((dt + 3800) % 4000)));
qreal r1 = 0.5 * m_size * (1.0 - qExp(-0.001 * ((dt + 0) % 4000)));
qreal r2 = 0.5 * m_size * (1.0 - qExp(-0.001 * ((dt + 1800) % 4000)));
qreal r3 = 0.5 * m_size * (1.0 - qExp(-0.001 * ((dt + 2000) % 4000)));
if (r0 > r1)
r0 = 0.0;

5
examples/widgets/graphicsview/boxes/scene.cpp
View File

@ -35,6 +35,7 @@
#include "scene.h"
#include <QtGui/qmatrix4x4.h>
#include <QtGui/qvector3d.h>
#include <cmath>
#include "3rdparty/fbm.h"
@ -856,7 +857,7 @@ void Scene::renderCubemaps()
float angle = 2.0f * PI * i / m_cubemaps.size();
center = m_trackBalls[1].rotation().rotatedVector(QVector3D(cos(angle), sin(angle), 0.0f));
center = m_trackBalls[1].rotation().rotatedVector(QVector3D(std::cos(angle), std::sin(angle), 0.0f));
for (int face = 0; face < 6; ++face) {
m_cubemaps[i]->begin(face);
@ -910,7 +911,7 @@ void Scene::drawBackground(QPainter *painter, const QRectF &)
QMatrix4x4 view;
view.rotate(m_trackBalls[2].rotation());
view(2, 3) -= 2.0f * exp(m_distExp / 1200.0f);
view(2, 3) -= 2.0f * std::exp(m_distExp / 1200.0f);
renderBoxes(view);
defaultStates();

7
examples/widgets/graphicsview/boxes/trackball.cpp
View File

@ -33,6 +33,7 @@
#include "trackball.h"
#include "scene.h"
#include <cmath>
//============================================================================//
// TrackBall //
@ -94,19 +95,19 @@ void TrackBall::move(const QPointF& p, const QQuaternion &transformation)
QVector3D lastPos3D = QVector3D(m_lastPos.x(), m_lastPos.y(), 0.0f);
float sqrZ = 1 - QVector3D::dotProduct(lastPos3D, lastPos3D);
if (sqrZ > 0)
lastPos3D.setZ(sqrt(sqrZ));
lastPos3D.setZ(std::sqrt(sqrZ));
else
lastPos3D.normalize();
QVector3D currentPos3D = QVector3D(p.x(), p.y(), 0.0f);
sqrZ = 1 - QVector3D::dotProduct(currentPos3D, currentPos3D);
if (sqrZ > 0)
currentPos3D.setZ(sqrt(sqrZ));
currentPos3D.setZ(std::sqrt(sqrZ));
else
currentPos3D.normalize();
m_axis = QVector3D::crossProduct(lastPos3D, currentPos3D);
float angle = 180 / PI * asin(sqrt(QVector3D::dotProduct(m_axis, m_axis)));
float angle = 180 / PI * std::asin(std::sqrt(QVector3D::dotProduct(m_axis, m_axis)));
m_angularVelocity = angle / msecs;
m_axis.normalize();

6
examples/widgets/itemviews/chart/pieview.cpp
View File

@ -38,8 +38,8 @@
**
****************************************************************************/
#include <math.h>
#include <QtWidgets>
#include <cmath>
#ifndef M_PI
#define M_PI 3.1415927
@ -109,13 +109,13 @@ QModelIndex PieView::indexAt(const QPoint &point) const
double cy = totalSize / 2 - wy; // positive cy for items above the center
// Determine the distance from the center point of the pie chart.
double d = pow(pow(cx, 2) + pow(cy, 2), 0.5);
double d = std::sqrt(std::pow(cx, 2) + std::pow(cy, 2));
if (d == 0 || d > pieSize / 2)
return QModelIndex();
// Determine the angle of the point.
double angle = (180 / M_PI) * acos(cx / d);
double angle = (180 / M_PI) * std::acos(cx / d);
if (cy < 0)
angle = 360 - angle;

6
examples/widgets/itemviews/stardelegate/starrating.cpp
View File

@ -39,7 +39,7 @@
****************************************************************************/
#include <QtWidgets>
#include <math.h>
#include <cmath>
#include "starrating.h"
@ -53,8 +53,8 @@ StarRating::StarRating(int starCount, int maxStarCount)
starPolygon << QPointF(1.0, 0.5);
for (int i = 1; i < 5; ++i)
starPolygon << QPointF(0.5 + 0.5 * cos(0.8 * i * 3.14),
0.5 + 0.5 * sin(0.8 * i * 3.14));
starPolygon << QPointF(0.5 + 0.5 * std::cos(0.8 * i * 3.14),
0.5 + 0.5 * std::sin(0.8 * i * 3.14));
diamondPolygon << QPointF(0.4, 0.5) << QPointF(0.5, 0.4)
<< QPointF(0.6, 0.5) << QPointF(0.5, 0.6)

5
examples/widgets/itemviews/storageview/storagemodel.cpp
View File

@ -43,6 +43,7 @@
#include <QDir>
#include <qmath.h>
#include <cmath>
static QString sizeToString(qint64 size)
{
@ -51,11 +52,11 @@ static QString sizeToString(qint64 size)
if (size <= 0)
return StorageModel::tr("0 b");
double power = log((double)size)/log(1024.0);
double power = std::log((double)size)/std::log(1024.0);
int intPower = (int)power;
intPower = intPower >= 8 ? 8 - 1 : intPower;
double normSize = size / pow(1024.0, intPower);
double normSize = size / std::pow(1024.0, intPower);
//: this should expand to "1.23 GB"
return StorageModel::tr("%1 %2").arg(normSize, 0, 'f', intPower > 0 ? 2 : 0).arg(strings[intPower]);
}

6
examples/widgets/painting/painterpaths/window.cpp
View File

@ -43,7 +43,7 @@
#include <QtWidgets>
#include <math.h>
#include <cmath>
//! [0]
const float Pi = 3.14159f;
@ -123,8 +123,8 @@ Window::Window()
QPainterPath starPath;
starPath.moveTo(90, 50);
for (int i = 1; i < 5; ++i) {
starPath.lineTo(50 + 40 * cos(0.8 * i * Pi),
50 + 40 * sin(0.8 * i * Pi));
starPath.lineTo(50 + 40 * std::cos(0.8 * i * Pi),
50 + 40 * std::sin(0.8 * i * Pi));
}
starPath.closeSubpath();
//! [9]

6
examples/widgets/tools/plugandpaintplugins/basictools/basictoolsplugin.cpp
View File

@ -40,7 +40,7 @@
#include <QtWidgets>
#include <math.h>
#include <cmath>
#include <stdlib.h>
#include "basictoolsplugin.h"
@ -139,8 +139,8 @@ QPainterPath BasicToolsPlugin::generateShape(const QString &shape,
} else if (shape == tr("Star")) {
path.moveTo(90, 50);
for (int i = 1; i < 5; ++i) {
path.lineTo(50 + 40 * cos(0.8 * i * Pi),
50 + 40 * sin(0.8 * i * Pi));
path.lineTo(50 + 40 * std::cos(0.8 * i * Pi),
50 + 40 * std::sin(0.8 * i * Pi));
}
path.closeSubpath();
} else if (shape == tr("Text...")) {

6
examples/widgets/widgets/calculator/calculator.cpp
View File

@ -40,7 +40,7 @@
#include <QtWidgets>
#include <math.h>
#include <cmath>
#include "button.h"
#include "calculator.h"
@ -164,9 +164,9 @@ void Calculator::unaryOperatorClicked()
abortOperation();
return;
}
result = sqrt(operand);
result = std::sqrt(operand);
} else if (clickedOperator == tr("x\302\262")) {
result = pow(operand, 2.0);
result = std::pow(operand, 2.0);
} else if (clickedOperator == tr("1/x")) {
if (operand == 0.0) {
abortOperation();

6
src/corelib/doc/snippets/code/doc_src_qiterator.cpp
View File

@ -257,7 +257,7 @@ while (i.hasNext()) {
QMutableListIterator<double> i(list);
while (i.hasNext()) {
double val = i.next();
i.setValue(sqrt(val));
i.setValue(std::sqrt(val));
}
//! [23]
@ -266,7 +266,7 @@ while (i.hasNext()) {
QMutableLinkedListIterator<double> i(list);
while (i.hasNext()) {
double val = i.next();
i.setValue(sqrt(val));
i.setValue(std::sqrt(val));
}
//! [24]
@ -275,7 +275,7 @@ while (i.hasNext()) {
QMutableVectorIterator<double> i(list);
while (i.hasNext()) {
double val = i.next();
i.setValue(sqrt(val));
i.setValue(std::sqrt(val));
}
//! [25]

2
src/corelib/doc/snippets/code/src_corelib_tools_qpoint.cpp
View File

@ -105,7 +105,7 @@ MyWidget::mouseMoveEvent(QMouseEvent *event)
//! [8]
double trueLength = sqrt(pow(x(), 2) + pow(y(), 2));
double trueLength = std::sqrt(std::pow(x(), 2) + std::pow(y(), 2));
//! [8]

113
src/corelib/kernel/qmath.h
View File

@ -38,153 +38,98 @@
#pragma qt_class(QtMath)
#endif
#include <math.h>
#include <QtCore/qglobal.h>
#include <QtCore/qcompilerdetection.h>
#include <cmath>
QT_BEGIN_NAMESPACE
#define QT_SINE_TABLE_SIZE 256
extern Q_CORE_EXPORT const qreal qt_sine_table[QT_SINE_TABLE_SIZE];
inline int qCeil(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return int(ceilf(float(v)));
else
#endif
return int(ceil(v));
using std::ceil;
return int(ceil(v));
}
inline int qFloor(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return int(floorf(float(v)));
else
#endif
return int(floor(v));
using std::floor;
return int(floor(v));
}
inline qreal qFabs(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if(sizeof(qreal) == sizeof(float))
return fabsf(float(v));
else
#endif
return fabs(v);
using std::fabs;
return fabs(v);
}
inline qreal qSin(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return sinf(float(v));
else
#endif
return sin(v);
using std::sin;
return sin(v);
}
inline qreal qCos(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return cosf(float(v));
else
#endif
return cos(v);
using std::cos;
return cos(v);
}
inline qreal qTan(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return tanf(float(v));
else
#endif
return tan(v);
using std::tan;
return tan(v);
}
inline qreal qAcos(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return acosf(float(v));
else
#endif
return acos(v);
using std::acos;
return acos(v);
}
inline qreal qAsin(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return asinf(float(v));
else
#endif
return asin(v);
using std::asin;
return asin(v);
}
inline qreal qAtan(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return atanf(float(v));
else
#endif
return atan(v);
using std::atan;
return atan(v);
}
inline qreal qAtan2(qreal y, qreal x)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return atan2f(float(y), float(x));
else
#endif
return atan2(y, x);
using std::atan2;
return atan2(y, x);
}
inline qreal qSqrt(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return sqrtf(float(v));
else
#endif
return sqrt(v);
using std::sqrt;
return sqrt(v);
}
inline qreal qLn(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return logf(float(v));
else
#endif
return log(v);
using std::log;
return log(v);
}
inline qreal qExp(qreal v)
{
// only one signature
// exists, exp(double)
using std::exp;
return exp(v);
}
inline qreal qPow(qreal x, qreal y)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return powf(float(x), float(y));
else
#endif
return pow(x, y);
using std::pow;
return pow(x, y);
}
#ifndef M_E

14
src/corelib/tools/qeasingcurve.cpp
View File

@ -657,7 +657,7 @@ struct BezierEase : public QEasingCurveFunction
qreal static inline _acos(qreal x)
{
return sqrt(1-x)*(1.5707963267948966192313216916398f + x*(-0.213300989f + x*(0.077980478f + x*-0.02164095f)));
return std::sqrt(1-x)*(1.5707963267948966192313216916398f + x*(-0.213300989f + x*(0.077980478f + x*-0.02164095f)));
}
qreal static inline _cos(qreal x) //super fast _cos
@ -704,8 +704,8 @@ struct BezierEase : public QEasingCurveFunction
//We use approximations instead
const qreal x_squared = x * x;
const qreal x_plus_one_sqrt = sqrt(1.0 + x);
const qreal one_minus_x_sqrt = sqrt(1.0 - x);
const qreal x_plus_one_sqrt = qSqrt(1.0 + x);
const qreal one_minus_x_sqrt = qSqrt(1.0 - x);
//cos(acos(x) / 3)
//s1 = _cos(_acos(x) / 3);
@ -743,7 +743,7 @@ struct BezierEase : public QEasingCurveFunction
const qreal D = 0.25 * q_squared + p_cubic / 27.0;
if (D >= 0) {
const qreal D_sqrt = sqrt(D);
const qreal D_sqrt = qSqrt(D);
qreal u = _cbrt( -q * 0.5 + D_sqrt);
qreal v = _cbrt( -q * 0.5 - D_sqrt);
qreal z1 = u + v;
@ -758,13 +758,13 @@ struct BezierEase : public QEasingCurveFunction
}
//casus irreducibilis
const qreal p_minus_sqrt = sqrt(-p);
const qreal p_minus_sqrt = qSqrt(-p);
//const qreal f = sqrt(4.0 / 3.0 * -p);
const qreal f = sqrt(4.0 / 3.0) * p_minus_sqrt;
const qreal f = qSqrt(4.0 / 3.0) * p_minus_sqrt;
//const qreal sqrtP = sqrt(27.0 / -p_cubic);
const qreal sqrtP = -3.0*sqrt(3.0) / (p_minus_sqrt * p);
const qreal sqrtP = -3.0*qSqrt(3.0) / (p_minus_sqrt * p);
const qreal g = -q * 0.5 * sqrtP;

16
src/gui/math3d/qmatrix4x4.cpp
View File

@ -1125,8 +1125,8 @@ void QMatrix4x4::rotate(float angle, float x, float y, float z)
c = -1.0f;
} else {
float a = angle * M_PI / 180.0f;
c = cosf(a);
s = sinf(a);
c = std::cos(a);
s = std::sin(a);
}
if (x == 0.0f) {
if (y == 0.0f) {
@ -1186,7 +1186,7 @@ void QMatrix4x4::rotate(float angle, float x, float y, float z)
double(y) * double(y) +
double(z) * double(z);
if (!qFuzzyCompare(len, 1.0) && !qFuzzyIsNull(len)) {
len = sqrt(len);
len = std::sqrt(len);
x = float(double(x) / len);
y = float(double(y) / len);
z = float(double(z) / len);
@ -1234,8 +1234,8 @@ void QMatrix4x4::projectedRotate(float angle, float x, float y, float z)
c = -1.0f;
} else {
float a = angle * M_PI / 180.0f;
c = cosf(a);
s = sinf(a);
c = std::cos(a);
s = std::sin(a);
}
if (x == 0.0f) {
if (y == 0.0f) {
@ -1282,7 +1282,7 @@ void QMatrix4x4::projectedRotate(float angle, float x, float y, float z)
double(y) * double(y) +
double(z) * double(z);
if (!qFuzzyCompare(len, 1.0) && !qFuzzyIsNull(len)) {
len = sqrt(len);
len = std::sqrt(len);
x = float(double(x) / len);
y = float(double(y) / len);
z = float(double(z) / len);
@ -1487,10 +1487,10 @@ void QMatrix4x4::perspective(float verticalAngle, float aspectRatio, float nearP
// Construct the projection.
QMatrix4x4 m(1);
float radians = (verticalAngle / 2.0f) * M_PI / 180.0f;
float sine = sinf(radians);
float sine = std::sin(radians);
if (sine == 0.0f)
return;
float cotan = cosf(radians) / sine;
float cotan = std::cos(radians) / sine;
float clip = farPlane - nearPlane;
m.m[0][0] = cotan / aspectRatio;
m.m[1][0] = 0.0f;

54
src/gui/math3d/qquaternion.cpp
View File

@ -219,7 +219,7 @@ QT_BEGIN_NAMESPACE
*/
float QQuaternion::length() const
{
return qSqrt(xp * xp + yp * yp + zp * zp + wp * wp);
return std::sqrt(xp * xp + yp * yp + zp * zp + wp * wp);
}
/*!
@ -252,7 +252,7 @@ QQuaternion QQuaternion::normalized() const
if (qFuzzyIsNull(len - 1.0f))
return *this;
else if (!qFuzzyIsNull(len))
return *this / qSqrt(len);
return *this / std::sqrt(len);
else
return QQuaternion(0.0f, 0.0f, 0.0f, 0.0f);
}
@ -273,7 +273,7 @@ void QQuaternion::normalize()
if (qFuzzyIsNull(len - 1.0f) || qFuzzyIsNull(len))
return;
len = qSqrt(len);
len = std::sqrt(len);
xp /= len;
yp /= len;
@ -386,8 +386,8 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, float angle)
// We normalize the result just in case the values are close
// to zero, as suggested in the above FAQ.
float a = (angle / 2.0f) * M_PI / 180.0f;
float s = sinf(a);
float c = cosf(a);
float s = std::sin(a);
float c = std::cos(a);
QVector3D ax = axis.normalized();
return QQuaternion(c, ax.x() * s, ax.y() * s, ax.z() * s).normalized();
}
@ -415,12 +415,12 @@ void QQuaternion::toAxisAndAngle(float *x, float *y, float *z, float *angle) con
*y = yp;
*z = zp;
if (!qFuzzyIsNull(length - 1.0f)) {
length = sqrtf(length);
length = std::sqrt(length);
*x /= length;
*y /= length;
*z /= length;
}
*angle = 2.0f * acosf(wp);
*angle = 2.0f * std::acos(wp);
} else {
// angle is 0 (mod 2*pi), so any axis will fit
*x = *y = *z = *angle = 0.0f;
@ -438,15 +438,15 @@ void QQuaternion::toAxisAndAngle(float *x, float *y, float *z, float *angle) con
QQuaternion QQuaternion::fromAxisAndAngle
(float x, float y, float z, float angle)
{
float length = qSqrt(x * x + y * y + z * z);
float length = std::sqrt(x * x + y * y + z * z);
if (!qFuzzyIsNull(length - 1.0f) && !qFuzzyIsNull(length)) {
x /= length;
y /= length;
z /= length;
}
float a = (angle / 2.0f) * M_PI / 180.0f;
float s = sinf(a);
float c = cosf(a);
float s = std::sin(a);
float c = std::cos(a);
return QQuaternion(c, x * s, y * s, z * s).normalized();
}
@ -515,20 +515,20 @@ void QQuaternion::toEulerAngles(float *pitch, float *yaw, float *roll) const
zw /= lengthSquared;
}
*pitch = asinf(-2.0f * (yz - xw));
*pitch = std::asin(-2.0f * (yz - xw));
if (*pitch < M_PI_2) {
if (*pitch > -M_PI_2) {
*yaw = atan2f(2.0f * (xz + yw), 1.0f - 2.0f * (xx + yy));
*roll = atan2f(2.0f * (xy + zw), 1.0f - 2.0f * (xx + zz));
*yaw = std::atan2(2.0f * (xz + yw), 1.0f - 2.0f * (xx + yy));
*roll = std::atan2(2.0f * (xy + zw), 1.0f - 2.0f * (xx + zz));
} else {
// not a unique solution
*roll = 0.0f;
*yaw = -atan2f(-2.0f * (xy - zw), 1.0f - 2.0f * (yy + zz));
*yaw = -std::atan2(-2.0f * (xy - zw), 1.0f - 2.0f * (yy + zz));
}
} else {
// not a unique solution
*roll = 0.0f;
*yaw = atan2f(-2.0f * (xy - zw), 1.0f - 2.0f * (yy + zz));
*yaw = std::atan2(-2.0f * (xy - zw), 1.0f - 2.0f * (yy + zz));
}
*pitch = qRadiansToDegrees(*pitch);
@ -558,12 +558,12 @@ QQuaternion QQuaternion::fromEulerAngles(float pitch, float yaw, float roll)
yaw *= 0.5f;
roll *= 0.5f;
const float c1 = cosf(yaw);
const float s1 = sinf(yaw);
const float c2 = cosf(roll);
const float s2 = sinf(roll);
const float c3 = cosf(pitch);
const float s3 = sinf(pitch);
const float c1 = std::cos(yaw);
const float s1 = std::sin(yaw);
const float c2 = std::cos(roll);
const float s2 = std::sin(roll);
const float c3 = std::cos(pitch);
const float s3 = std::sin(pitch);
const float c1c2 = c1 * c2;
const float s1s2 = s1 * s2;
@ -635,7 +635,7 @@ QQuaternion QQuaternion::fromRotationMatrix(const QMatrix3x3 &rot3x3)
const float trace = rot3x3(0, 0) + rot3x3(1, 1) + rot3x3(2, 2);
if (trace > 0.00000001f) {
const float s = 2.0f * sqrtf(trace + 1.0f);
const float s = 2.0f * std::sqrt(trace + 1.0f);
scalar = 0.25f * s;
axis[0] = (rot3x3(2, 1) - rot3x3(1, 2)) / s;
axis[1] = (rot3x3(0, 2) - rot3x3(2, 0)) / s;
@ -650,7 +650,7 @@ QQuaternion QQuaternion::fromRotationMatrix(const QMatrix3x3 &rot3x3)
int j = s_next[i];
int k = s_next[j];
const float s = 2.0f * sqrtf(rot3x3(i, i) - rot3x3(j, j) - rot3x3(k, k) + 1.0f);
const float s = 2.0f * std::sqrt(rot3x3(i, i) - rot3x3(j, j) - rot3x3(k, k) + 1.0f);
axis[i] = 0.25f * s;
scalar = (rot3x3(k, j) - rot3x3(j, k)) / s;
axis[j] = (rot3x3(j, i) + rot3x3(i, j)) / s;
@ -792,11 +792,11 @@ QQuaternion QQuaternion::slerp
float factor1 = 1.0f - t;
float factor2 = t;
if ((1.0f - dot) > 0.0000001) {
float angle = acosf(dot);
float sinOfAngle = sinf(angle);
float angle = std::acos(dot);
float sinOfAngle = std::sin(angle);
if (sinOfAngle > 0.0000001) {
factor1 = sinf((1.0f - t) * angle) / sinOfAngle;
factor2 = sinf(t * angle) / sinOfAngle;
factor1 = std::sin((1.0f - t) * angle) / sinOfAngle;
factor2 = std::sin(t * angle) / sinOfAngle;
}
}

6
src/gui/math3d/qvector2d.cpp
View File

@ -189,7 +189,7 @@ float QVector2D::length() const
// Need some extra precision if the length is very small.
double len = double(xp) * double(xp) +
double(yp) * double(yp);
return float(sqrt(len));
return float(std::sqrt(len));
}
/*!
@ -220,7 +220,7 @@ QVector2D QVector2D::normalized() const
if (qFuzzyIsNull(len - 1.0f)) {
return *this;
} else if (!qFuzzyIsNull(len)) {
double sqrtLen = sqrt(len);
double sqrtLen = std::sqrt(len);
return QVector2D(float(double(xp) / sqrtLen), float(double(yp) / sqrtLen));
} else {
return QVector2D();
@ -241,7 +241,7 @@ void QVector2D::normalize()
if (qFuzzyIsNull(len - 1.0f) || qFuzzyIsNull(len))
return;
len = sqrt(len);
len = std::sqrt(len);
xp = float(double(xp) / len);
yp = float(double(yp) / len);

6
src/gui/math3d/qvector3d.cpp
View File

@ -235,7 +235,7 @@ QVector3D QVector3D::normalized() const
if (qFuzzyIsNull(len - 1.0f)) {
return *this;
} else if (!qFuzzyIsNull(len)) {
double sqrtLen = sqrt(len);
double sqrtLen = std::sqrt(len);
return QVector3D(float(double(xp) / sqrtLen),
float(double(yp) / sqrtLen),
float(double(zp) / sqrtLen));
@ -259,7 +259,7 @@ void QVector3D::normalize()
if (qFuzzyIsNull(len - 1.0f) || qFuzzyIsNull(len))
return;
len = sqrt(len);
len = std::sqrt(len);
xp = float(double(xp) / len);
yp = float(double(yp) / len);
@ -679,7 +679,7 @@ float QVector3D::length() const
double len = double(xp) * double(xp) +
double(yp) * double(yp) +
double(zp) * double(zp);
return float(sqrt(len));
return float(std::sqrt(len));
}
/*!

6
src/gui/math3d/qvector4d.cpp
View File

@ -256,7 +256,7 @@ float QVector4D::length() const
double(yp) * double(yp) +
double(zp) * double(zp) +
double(wp) * double(wp);
return float(sqrt(len));
return float(std::sqrt(len));
}
/*!
@ -289,7 +289,7 @@ QVector4D QVector4D::normalized() const
if (qFuzzyIsNull(len - 1.0f)) {
return *this;
} else if (!qFuzzyIsNull(len)) {
double sqrtLen = sqrt(len);
double sqrtLen = std::sqrt(len);
return QVector4D(float(double(xp) / sqrtLen),
float(double(yp) / sqrtLen),
float(double(zp) / sqrtLen),
@ -315,7 +315,7 @@ void QVector4D::normalize()
if (qFuzzyIsNull(len - 1.0f) || qFuzzyIsNull(len))
return;
len = sqrt(len);
len = std::sqrt(len);
xp = float(double(xp) / len);
yp = float(double(yp) / len);

4
src/gui/opengl/qopenglpaintengine.cpp
View File

@ -462,8 +462,8 @@ void QOpenGL2PaintEngineExPrivate::updateMatrix()
// anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.
if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {
// 0.50 needs to rounded down to 0.0 for consistency with raster engine:
dx = ceilf(dx - 0.5f);
dy = ceilf(dy - 0.5f);
dx = std::ceil(dx - 0.5f);
dy = std::ceil(dy - 0.5f);
}
pmvMatrix[0][0] = (wfactor * transform.m11()) - transform.m13();
pmvMatrix[1][0] = (wfactor * transform.m21()) - transform.m23();

6
src/gui/opengl/qtriangulatingstroker_p.h
View File

@ -134,11 +134,11 @@ inline void QTriangulatingStroker::normalVector(float x1, float y1, float x2, fl
float pw;
if (dx == 0)
pw = m_width / qAbs(dy);
pw = m_width / std::abs(dy);
else if (dy == 0)
pw = m_width / qAbs(dx);
pw = m_width / std::abs(dx);
else
pw = m_width / sqrt(dx*dx + dy*dy);
pw = m_width / std::sqrt(dx*dx + dy*dy);
*nx = -dy * pw;
*ny = dx * pw;

8
src/gui/opengl/qtriangulator.cpp
View File

@ -49,8 +49,6 @@
#include <private/qopenglextensions_p.h>
#include <private/qrbtree_p.h>
#include <math.h>
QT_BEGIN_NAMESPACE
//#define Q_TRIANGULATOR_DEBUG
@ -1700,8 +1698,8 @@ void QTriangulator<T>::ComplexToSimple::DebugDialog::paintEvent(QPaintEvent *)
QPodPoint q = vertices.at(splits.at(i).vertex);
QPodPoint u = vertices.at(edges.at(splits.at(i).edge).from) - q;
QPodPoint v = vertices.at(edges.at(splits.at(i).edge).to) - q;
qreal uLen = sqrt(qreal(qDot(u, u)));
qreal vLen = sqrt(qreal(qDot(v, v)));
qreal uLen = qSqrt(qDot(u, u));
qreal vLen = qSqrt(qDot(v, v));
if (uLen) {
u.x *= 2 * halfPointSize / uLen;
u.y *= 2 * halfPointSize / uLen;
@ -1719,7 +1717,7 @@ void QTriangulator<T>::ComplexToSimple::DebugDialog::paintEvent(QPaintEvent *)
template <typename T>
void QTriangulator<T>::ComplexToSimple::DebugDialog::wheelEvent(QWheelEvent *event)
{
qreal scale = exp(-0.001 * event->delta());
qreal scale = qExp(-0.001 * event->delta());
QPointF center = m_window.center();
QPointF delta = scale * (m_window.bottomRight() - center);
m_window = QRectF(center - delta, center + delta);

8
src/gui/painting/qdrawhelper.cpp
View File

@ -1684,7 +1684,7 @@ static const uint * QT_FASTCALL fetchTransformedBilinearARGB32PM(uint *buffer, c
b++;
fx += fdx;
}
} else if ((fdx < 0 && fdx > -(fixed_scale / 8)) || fabs(data->m22) < (1./8.)) { // scale up more than 8x
} else if ((fdx < 0 && fdx > -(fixed_scale / 8)) || std::abs(data->m22) < (1./8.)) { // scale up more than 8x
int y1 = (fy >> 16);
int y2;
fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
@ -1843,7 +1843,7 @@ static const uint * QT_FASTCALL fetchTransformedBilinearARGB32PM(uint *buffer, c
}
}
} else { //rotation
if (fabs(data->m11) > 8 || fabs(data->m22) > 8) {
if (std::abs(data->m11) > 8 || std::abs(data->m22) > 8) {
//if we are zooming more than 8 times, we use 8bit precision for the position.
while (b < end) {
int x1 = (fx >> 16);
@ -2196,7 +2196,7 @@ static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Oper
layout->convertToARGB32PM(buf1, buf1, len * 2, layout, clut);
layout->convertToARGB32PM(buf2, buf2, len * 2, layout, clut);
if ((fdx < 0 && fdx > -(fixed_scale / 8)) || fabs(data->m22) < (1./8.)) { // scale up more than 8x
if ((fdx < 0 && fdx > -(fixed_scale / 8)) || std::abs(data->m22) < (1./8.)) { // scale up more than 8x
int disty = (fy & 0x0000ffff) >> 8;
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];
@ -2255,7 +2255,7 @@ static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Oper
layout->convertToARGB32PM(buf1, buf1, len * 2, layout, clut);
layout->convertToARGB32PM(buf2, buf2, len * 2, layout, clut);
if (fabs(data->m11) > 8 || fabs(data->m22) > 8) {
if (std::abs(data->m11) > 8 || std::abs(data->m22) > 8) {
//if we are zooming more than 8 times, we use 8bit precision for the position.
for (int i = 0; i < len; ++i) {
uint tl = buf1[i * 2 + 0];

7
src/gui/painting/qmath_p.h
View File

@ -45,14 +45,13 @@
// We mean it.
//
#include <math.h>
#include <qmath.h>
QT_BEGIN_NAMESPACE
static const qreal Q_PI = qreal(3.14159265358979323846); // pi
static const qreal Q_2PI = qreal(6.28318530717958647693); // 2*pi
static const qreal Q_PI2 = qreal(1.57079632679489661923); // pi/2
static const qreal Q_PI = qreal(M_PI); // pi
static const qreal Q_2PI = qreal(2 * M_PI); // 2*pi
static const qreal Q_PI2 = qreal(M_PI_2); // pi/2
static const qreal Q_MM_PER_INCH = 25.4;
inline int qIntSqrtInt(int v)

16
src/gui/painting/qrasterizer.cpp
View File

@ -712,20 +712,10 @@ static inline bool q26Dot6Compare(qreal p1, qreal p2)
return int((p2 - p1) * 64.) == 0;
}
static inline qreal qFloorF(qreal v)
{
#ifdef QT_USE_MATH_H_FLOATS
if (sizeof(qreal) == sizeof(float))
return floorf(v);
else
#endif
return floor(v);
}
static inline QPointF snapTo26Dot6Grid(const QPointF &p)
{
return QPointF(qFloorF(p.x() * 64) * (1 / qreal(64)),
qFloorF(p.y() * 64) * (1 / qreal(64)));
return QPointF(std::floor(p.x() * 64) * (1 / qreal(64)),
std::floor(p.y() * 64) * (1 / qreal(64)));
}
/*
@ -832,7 +822,7 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
return;
// adjust width which is given relative to |b - a|
width *= sqrt(w0 / w);
width *= qSqrt(w0 / w);
}
QSpanBuffer buffer(d->blend, d->data, d->clipRect);

6
src/gui/text/qdistancefield.cpp
View File

@ -509,8 +509,8 @@ static void makeDistanceField(QDistanceFieldData *data, const QPainterPath &path
bits[i] = exteriorColor;
const qreal angleStep = qreal(15 * 3.141592653589793238 / 180);
const QPoint rotation(qRound(cos(angleStep) * 0x4000),
qRound(sin(angleStep) * 0x4000)); // 2:14 signed
const QPoint rotation(qRound(qCos(angleStep) * 0x4000),
qRound(qSin(angleStep) * 0x4000)); // 2:14 signed
const quint32 *indices = pathIndices.data();
QVarLengthArray<QPoint> normals;
@ -544,7 +544,7 @@ static void makeDistanceField(QDistanceFieldData *data, const QPainterPath &path
QPoint n(to.y() - from.y(), from.x() - to.x());
if (n.x() == 0 && n.y() == 0)
continue;
int scale = qRound((offs << 16) / sqrt(qreal(n.x() * n.x() + n.y() * n.y()))); // 8:16
int scale = qRound((offs << 16) / qSqrt(qreal(n.x() * n.x() + n.y() * n.y()))); // 8:16
n.rx() = n.x() * scale >> 8;
n.ry() = n.y() * scale >> 8;
normals.append(n);

2
src/gui/text/qfontdatabase.cpp
View File

@ -2640,7 +2640,7 @@ void QFontDatabase::load(const QFontPrivate *d, int script)
QFontDef req = d->request;
if (req.pixelSize == -1) {
req.pixelSize = floor(((req.pointSize * d->dpi) / 72) * 100 + 0.5) / 100;
req.pixelSize = std::floor(((req.pointSize * d->dpi) / 72) * 100 + 0.5) / 100;
req.pixelSize = qRound(req.pixelSize);
}
if (req.pointSize < 0)

4
src/gui/util/qgridlayoutengine.cpp
View File

@ -193,7 +193,7 @@ namespace {
// does not return int
static inline qreal qround(qreal f)
{
return floor(f + 0.5);
return std::floor(f + qreal(0.5));
}
}
@ -355,7 +355,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
qreal maxBoxSize = box.q_maximumSize;
if (snapToPixelGrid)
maxBoxSize = qMax(box.q_minimumSize, floor(maxBoxSize));
maxBoxSize = qMax(box.q_minimumSize, std::floor(maxBoxSize));
qreal avail = sumCurrentAvailable * factors[i] / sumFactors;
if (sizes[i] + avail >= maxBoxSize) {

4
src/gui/util/qvalidator.cpp
View File

@ -40,7 +40,7 @@
#include "private/qlocale_p.h"
#include <limits.h>
#include <math.h>
#include <cmath>
QT_BEGIN_NAMESPACE
@ -384,7 +384,7 @@ static int numDigits(qlonglong n)
{
if (n == 0)
return 1;
return (int)log10(double(n)) + 1;
return (int)std::log10(double(n)) + 1;
}
static qlonglong pow10(int exp)

4
src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
View File

@ -400,8 +400,8 @@ void QGL2PaintEngineExPrivate::updateMatrix()
// anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.
if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {
// 0.50 needs to rounded down to 0.0 for consistency with raster engine:
dx = ceilf(dx - 0.5f);
dy = ceilf(dy - 0.5f);
dx = std::ceil(dx - 0.5f);
dy = std::ceil(dy - 0.5f);
}
pmvMatrix[0][0] = (wfactor * transform.m11()) - transform.m13();
pmvMatrix[1][0] = (wfactor * transform.m21()) - transform.m23();

4
src/platformsupport/fontdatabases/mac/qfontengine_coretext.mm
View File

@ -39,9 +39,11 @@
#include <private/qimage_p.h>
#include <cmath>
QT_BEGIN_NAMESPACE
static float SYNTHETIC_ITALIC_SKEW = tanf(14 * acosf(0) / 90);
static float SYNTHETIC_ITALIC_SKEW = std::tan(14.f * std::acos(0.f) / 90.f);
bool QCoreTextFontEngine::ct_getSfntTable(void *user_data, uint tag, uchar *buffer, uint *length)
{

4
src/plugins/platforms/cocoa/qpaintengine_mac.mm
View File

@ -654,11 +654,11 @@ QCoreGraphicsPaintEngine::updateState(const QPaintEngineState &state)
d->cosmeticPenSize = 1.0;
} else {
d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticSetPenWidth;
static const float sqrt2 = sqrt(2);
static const float sqrt2 = std::sqrt(2.0f);
qreal width = d->current.pen.widthF();
if (!width)
width = 1;
d->cosmeticPenSize = sqrt(pow(d->pixelSize.y(), 2) + pow(d->pixelSize.x(), 2)) / sqrt2 * width;
d->cosmeticPenSize = std::sqrt(std::pow(d->pixelSize.y(), 2) + std::pow(d->pixelSize.x(), 2)) / sqrt2 * width;
}
}
}

6
src/plugins/platforms/windows/qwindowstabletsupport.cpp
View File

@ -455,10 +455,10 @@ bool QWindowsTabletSupport::translateTabletPacketEvent()
// X Tilt = arctan(X / Z)
// Y Tilt = arctan(Y / Z)
const double radAzim = (packet.pkOrientation.orAzimuth / 10.0) * (M_PI / 180);
const double tanAlt = tan((abs(packet.pkOrientation.orAltitude / 10.0)) * (M_PI / 180));
const double tanAlt = std::tan((std::abs(packet.pkOrientation.orAltitude / 10.0)) * (M_PI / 180));
const double degX = atan(sin(radAzim) / tanAlt);
const double degY = atan(cos(radAzim) / tanAlt);
const double degX = std::atan(std::sin(radAzim) / tanAlt);
const double degY = std::atan(std::cos(radAzim) / tanAlt);
tiltX = int(degX * (180 / M_PI));
tiltY = int(-degY * (180 / M_PI));
rotation = 360.0 - (packet.pkOrientation.orTwist / 10.0);

6
src/widgets/widgets/qdial.cpp
View File

@ -136,9 +136,9 @@ void QDial::initStyleOption(QStyleOptionSlider *option) const
int QDialPrivate::valueFromPoint(const QPoint &p) const
{
Q_Q(const QDial);
double yy = (double)q->height()/2.0 - p.y();
double xx = (double)p.x() - q->width()/2.0;
double a = (xx || yy) ? qAtan2(yy, xx) : 0;
double yy = q->height()/2.0 - p.y();
double xx = p.x() - q->width()/2.0;
double a = (xx || yy) ? std::atan2(yy, xx) : 0;
if (a < Q_PI / -2)
a = a + Q_PI * 2;