Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package kplotting for openSUSE:Factory 
checked in at 2021-04-12 17:10:34
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/kplotting (Old)
 and      /work/SRC/openSUSE:Factory/.kplotting.new.2401 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "kplotting"

Mon Apr 12 17:10:34 2021 rev:89 rq:884281 version:5.81.0

Changes:
--------
--- /work/SRC/openSUSE:Factory/kplotting/kplotting.changes      2021-03-17 
20:19:24.299272418 +0100
+++ /work/SRC/openSUSE:Factory/.kplotting.new.2401/kplotting.changes    
2021-04-12 17:10:39.550584548 +0200
@@ -1,0 +2,9 @@
+Mon Apr  5 07:12:42 UTC 2021 - Christophe Giboudeaux <christo...@krop.fr>
+
+- Update to 5.81.0
+  * New feature release
+  * For more details please see:
+  * https://kde.org/announcements/frameworks/5/5.81.0
+- No code change since 5.80.0
+
+-------------------------------------------------------------------

Old:
----
  kplotting-5.80.0.tar.xz
  kplotting-5.80.0.tar.xz.sig

New:
----
  kplotting-5.81.0.tar.xz
  kplotting-5.81.0.tar.xz.sig

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ kplotting.spec ++++++
--- /var/tmp/diff_new_pack.uTTEmk/_old  2021-04-12 17:10:40.174585238 +0200
+++ /var/tmp/diff_new_pack.uTTEmk/_new  2021-04-12 17:10:40.178585242 +0200
@@ -17,7 +17,7 @@
 
 
 %define lname   libKF5Plotting5
-%define _tar_path 5.80
+%define _tar_path 5.81
 # Full KF5 version (e.g. 5.33.0)
 %{!?_kf5_version: %global _kf5_version %{version}}
 # Last major and minor KF5 version (e.g. 5.33)
@@ -25,7 +25,7 @@
 # Only needed for the package signature condition
 %bcond_without lang
 Name:           kplotting
-Version:        5.80.0
+Version:        5.81.0
 Release:        0
 Summary:        KDE Data plotting library
 License:        LGPL-2.1-or-later


++++++ kplotting-5.80.0.tar.xz -> kplotting-5.81.0.tar.xz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/.git-blame-ignore-revs 
new/kplotting-5.81.0/.git-blame-ignore-revs
--- old/kplotting-5.80.0/.git-blame-ignore-revs 1970-01-01 01:00:00.000000000 
+0100
+++ new/kplotting-5.81.0/.git-blame-ignore-revs 2021-04-03 11:36:21.000000000 
+0200
@@ -0,0 +1,3 @@
+#clang-format
+21af3d1ccf74571006a0cf9b1a41689447490703
+22ac497fcebcdd761c7f9c6301d3a8d4d4866248
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/CMakeLists.txt 
new/kplotting-5.81.0/CMakeLists.txt
--- old/kplotting-5.80.0/CMakeLists.txt 2021-02-28 20:04:05.000000000 +0100
+++ new/kplotting-5.81.0/CMakeLists.txt 2021-04-03 11:36:21.000000000 +0200
@@ -1,10 +1,10 @@
 cmake_minimum_required(VERSION 3.5)
 
-set(KF_VERSION "5.80.0") # handled by release scripts
+set(KF_VERSION "5.81.0") # handled by release scripts
 project(KPlotting VERSION ${KF_VERSION})
 
 include(FeatureSummary)
-find_package(ECM 5.80.0  NO_MODULE)
+find_package(ECM 5.81.0  NO_MODULE)
 set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake 
Modules." URL "https://commits.kde.org/extra-cmake-modules";)
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND 
FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
@@ -14,6 +14,7 @@
 include(KDEInstallDirs)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
+include(KDEGitCommitHooks)
 
 set(REQUIRED_QT_VERSION 5.14.0)
 find_package(Qt5Widgets ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
@@ -73,3 +74,5 @@
         DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel )
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
+kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/autotests/kplotobjecttest.cpp 
new/kplotting-5.81.0/autotests/kplotobjecttest.cpp
--- old/kplotting-5.80.0/autotests/kplotobjecttest.cpp  2021-02-28 
20:04:05.000000000 +0100
+++ new/kplotting-5.81.0/autotests/kplotobjecttest.cpp  2021-04-03 
11:36:21.000000000 +0200
@@ -7,9 +7,9 @@
 #include <kplotobject.h>
 #include <kplotpoint.h>
 
-#include <QTest>
 #include <QBrush>
 #include <QPen>
+#include <QTest>
 
 static const QColor DEFAULT_COLOR = Qt::blue;
 static const QColor MODIFIED_COLOR = Qt::red;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/autotests/kplotwidgettest.cpp 
new/kplotting-5.81.0/autotests/kplotwidgettest.cpp
--- old/kplotting-5.80.0/autotests/kplotwidgettest.cpp  2021-02-28 
20:04:05.000000000 +0100
+++ new/kplotting-5.81.0/autotests/kplotwidgettest.cpp  2021-04-03 
11:36:21.000000000 +0200
@@ -4,8 +4,8 @@
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#include <kplotwidget.h>
 #include <kplotobject.h>
+#include <kplotwidget.h>
 
 #include <qtest_widgets.h>
 
@@ -54,7 +54,7 @@
     void testAddPlotObjects()
     {
         // Add objects
-        QList< KPlotObject * > list;
+        QList<KPlotObject *> list;
         list << new KPlotObject(Qt::red) << new KPlotObject(Qt::green) << new 
KPlotObject(Qt::blue);
 
         widget->addPlotObjects(list);
@@ -70,7 +70,7 @@
     void testRemoveAllObjects()
     {
         // Add objects
-        QList< KPlotObject * > list;
+        QList<KPlotObject *> list;
         list << new KPlotObject() << new KPlotObject() << new KPlotObject();
 
         widget->removeAllPlotObjects();
@@ -79,7 +79,7 @@
 
     void testReplacePlotObject()
     {
-        QList< KPlotObject * > list;
+        QList<KPlotObject *> list;
         list << new KPlotObject(Qt::red) << new KPlotObject(Qt::green) << new 
KPlotObject(Qt::blue);
 
         widget->addPlotObjects(list);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/examples/testplot_widget.cpp 
new/kplotting-5.81.0/examples/testplot_widget.cpp
--- old/kplotting-5.80.0/examples/testplot_widget.cpp   2021-02-28 
20:04:05.000000000 +0100
+++ new/kplotting-5.81.0/examples/testplot_widget.cpp   2021-04-03 
11:36:21.000000000 +0200
@@ -5,18 +5,20 @@
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
-
-#include <math.h>
 #include <QComboBox>
 #include <QPen>
 #include <QVBoxLayout>
+#include <math.h>
 
-#include "kplotwidget.h"
-#include "kplotobject.h"
 #include "kplotaxis.h"
+#include "kplotobject.h"
+#include "kplotwidget.h"
 #include "testplot_widget.h"
 
-TestPlot::TestPlot(QWidget *p) : QMainWindow(p), po1(nullptr), po2(nullptr)
+TestPlot::TestPlot(QWidget *p)
+    : QMainWindow(p)
+    , po1(nullptr)
+    , po2(nullptr)
 {
     QWidget *w = new QWidget(this);
     vlay = new QVBoxLayout(w);
@@ -47,7 +49,7 @@
     plot->resetPlot();
 
     switch (n) {
-    case 0: { //Points plot
+    case 0: { // Points plot
         plot->setLimits(-6.0, 11.0, -10.0, 110.0);
 
         po1 = new KPlotObject(Qt::white, KPlotObject::Points, 4, 
KPlotObject::Asterisk);
@@ -65,14 +67,14 @@
         break;
     }
 
-    case 1: { //Lines plot
+    case 1: { // Lines plot
         plot->setLimits(-0.1, 6.38, -1.1, 1.1);
         plot->setSecondaryLimits(-5.73, 365.55, -1.1, 1.1);
         plot->axis(KPlotWidget::TopAxis)->setTickLabelsShown(true);
         plot->axis(KPlotWidget::BottomAxis)->setLabel(QStringLiteral("Angle 
[radians]"));
         plot->axis(KPlotWidget::TopAxis)->setLabel(QStringLiteral("Angle 
[degrees]"));
 
-        po1 = new KPlotObject(Qt::red,  KPlotObject::Lines, 2);
+        po1 = new KPlotObject(Qt::red, KPlotObject::Lines, 2);
         po2 = new KPlotObject(Qt::cyan, KPlotObject::Lines, 2);
 
         for (float t = 0.0; t <= 6.28; t += 0.04) {
@@ -87,7 +89,7 @@
         break;
     }
 
-    case 2: { //Bars plot
+    case 2: { // Bars plot
         plot->setLimits(-7.0, 7.0, -5.0, 105.0);
 
         po1 = new KPlotObject(Qt::white, KPlotObject::Bars, 2);
@@ -103,20 +105,20 @@
         break;
     }
 
-    case 3: { //Points plot with labels
+    case 3: { // Points plot with labels
         plot->setLimits(-1.1, 1.1, -1.1, 1.1);
 
         po1 = new KPlotObject(Qt::yellow, KPlotObject::Points, 10, 
KPlotObject::Star);
         po1->setLabelPen(QPen(Qt::green));
 
-        po1->addPoint(0.0,  0.8, QStringLiteral("North"));
-        po1->addPoint(0.57,  0.57, QStringLiteral("Northeast"));
-        po1->addPoint(0.8,  0.0, QStringLiteral("East"));
+        po1->addPoint(0.0, 0.8, QStringLiteral("North"));
+        po1->addPoint(0.57, 0.57, QStringLiteral("Northeast"));
+        po1->addPoint(0.8, 0.0, QStringLiteral("East"));
         po1->addPoint(0.57, -0.57, QStringLiteral("Southeast"));
         po1->addPoint(0.0, -0.8, QStringLiteral("South"));
         po1->addPoint(-0.57, -0.57, QStringLiteral("Southwest"));
-        po1->addPoint(-0.8,  0.0, QStringLiteral("West"));
-        po1->addPoint(-0.57,  0.57, QStringLiteral("Northwest"));
+        po1->addPoint(-0.8, 0.0, QStringLiteral("West"));
+        po1->addPoint(-0.57, 0.57, QStringLiteral("Northwest"));
 
         plot->addPlotObject(po1);
 
@@ -124,7 +126,7 @@
         break;
     }
 
-    case 4: { //Points, Lines and Bars plot
+    case 4: { // Points, Lines and Bars plot
         plot->setLimits(-2.1, 2.1, -0.1, 4.1);
 
         po1 = new KPlotObject(Qt::white, KPlotObject::Points, 10, 
KPlotObject::Pentagon);
@@ -150,7 +152,7 @@
         break;
     }
 
-    case 5: { //Points, Lines and Bars plot with labels
+    case 5: { // Points, Lines and Bars plot with labels
         plot->setLimits(-2.1, 2.1, -0.1, 4.1);
 
         po1 = new KPlotObject(Qt::white, KPlotObject::Points, 10, 
KPlotObject::Pentagon);
@@ -177,4 +179,3 @@
     }
     }
 }
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/examples/testplot_widget.h 
new/kplotting-5.81.0/examples/testplot_widget.h
--- old/kplotting-5.80.0/examples/testplot_widget.h     2021-02-28 
20:04:05.000000000 +0100
+++ new/kplotting-5.81.0/examples/testplot_widget.h     2021-04-03 
11:36:21.000000000 +0200
@@ -21,13 +21,14 @@
 
 public:
     TestPlot(QWidget *parent = nullptr);
-    ~TestPlot() {}
+    ~TestPlot()
+    {
+    }
 
 public Q_SLOTS:
     void slotSelectPlot(int index);
 
 private:
-
     QVBoxLayout *vlay;
     QComboBox *PlotSelector;
     KPlotWidget *plot;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotaxis.cpp 
new/kplotting-5.81.0/src/kplotaxis.cpp
--- old/kplotting-5.80.0/src/kplotaxis.cpp      2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotaxis.cpp      2021-04-03 11:36:21.000000000 
+0200
@@ -101,47 +101,47 @@
     d->m_MajorTickMarks.clear();
     d->m_MinorTickMarks.clear();
 
-    //s is the power-of-ten factor of length:
-    //length = t * s; s = 10^(pwr).  e.g., length=350.0 then t=3.5, s = 100.0; 
pwr = 2.0
+    // s is the power-of-ten factor of length:
+    // length = t * s; s = 10^(pwr).  e.g., length=350.0 then t=3.5, s = 
100.0; pwr = 2.0
     double pwr = 0.0;
     modf(log10(length), &pwr);
     double s = pow(10.0, pwr);
     double t = length / s;
 
-    double TickDistance = 0.0; //The distance between major tickmarks
-    int NumMajorTicks = 0; //will be between 3 and 5
-    int NumMinorTicks = 0; //The number of minor ticks between major ticks 
(will be 4 or 5)
+    double TickDistance = 0.0; // The distance between major tickmarks
+    int NumMajorTicks = 0; // will be between 3 and 5
+    int NumMinorTicks = 0; // The number of minor ticks between major ticks 
(will be 4 or 5)
 
-    //adjust s and t such that t is between 3 and 5:
+    // adjust s and t such that t is between 3 and 5:
     if (t < 3.0) {
         t *= 10.0;
         s /= 10.0;
         // t is now between 3 and 30
     }
 
-    if (t < 6.0) {   //accept current values
+    if (t < 6.0) { // accept current values
         TickDistance = s;
         NumMajorTicks = int(t);
         NumMinorTicks = 5;
-    } else if (t < 10.0) {   // adjust by a factor of 2
+    } else if (t < 10.0) { // adjust by a factor of 2
         TickDistance = s * 2.0;
         NumMajorTicks = int(t / 2.0);
         NumMinorTicks = 4;
-    } else if (t < 20.0) {   //adjust by a factor of 4
+    } else if (t < 20.0) { // adjust by a factor of 4
         TickDistance = s * 4.0;
         NumMajorTicks = int(t / 4.0);
         NumMinorTicks = 4;
-    } else { //adjust by a factor of 5
+    } else { // adjust by a factor of 5
         TickDistance = s * 5.0;
         NumMajorTicks = int(t / 5.0);
         NumMinorTicks = 5;
     }
 
-    //We have determined the number of tickmarks and their separation
-    //Now we determine their positions in the Data space.
+    // We have determined the number of tickmarks and their separation
+    // Now we determine their positions in the Data space.
 
-    //Tick0 is the position of a "virtual" tickmark; the first major tickmark
-    //position beyond the "minimum" edge of the data range.
+    // Tick0 is the position of a "virtual" tickmark; the first major tickmark
+    // position beyond the "minimum" edge of the data range.
     double Tick0 = x0 - fmod(x0, TickDistance);
     if (x0 < 0.0) {
         Tick0 -= TickDistance;
@@ -166,7 +166,7 @@
 QString KPlotAxis::tickLabel(double val) const
 {
     if (d->m_labelFmt == 't') {
-        while (val <   0.0) {
+        while (val < 0.0) {
             val += 24.0;
         }
         while (val >= 24.0) {
@@ -174,20 +174,19 @@
         }
 
         int h = int(val);
-        int m = int(60.*(val - h));
+        int m = int(60. * (val - h));
         return QStringLiteral("%1:%2").arg(h, 2, 10, QLatin1Char('0')).arg(m, 
2, 10, QLatin1Char('0'));
     }
 
     return QStringLiteral("%1").arg(val, d->m_labelFieldWidth, d->m_labelFmt, 
d->m_labelPrec);
 }
 
-QList< double > KPlotAxis::majorTickMarks() const
+QList<double> KPlotAxis::majorTickMarks() const
 {
     return d->m_MajorTickMarks;
 }
 
-QList< double > KPlotAxis::minorTickMarks() const
+QList<double> KPlotAxis::minorTickMarks() const
 {
     return d->m_MinorTickMarks;
 }
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotaxis.h 
new/kplotting-5.81.0/src/kplotaxis.h
--- old/kplotting-5.80.0/src/kplotaxis.h        2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotaxis.h        2021-04-03 11:36:21.000000000 
+0200
@@ -10,8 +10,8 @@
 
 #include <kplotting_export.h>
 
-#include <QString>
 #include <QList>
+#include <QString>
 
 /**
  * @short Axis for KPlotWidget
@@ -24,7 +24,6 @@
 class KPLOTTING_EXPORT KPlotAxis
 {
 public:
-
     /**
      * Constructor, constructs an axis with the label @p label.
      */
@@ -130,7 +129,7 @@
      * @sa setTickMarks()
      * @sa minorTickMarks()
      */
-    QList< double > majorTickMarks() const;
+    QList<double> majorTickMarks() const;
 
     /**
      * @return the list with the minor tickmarks
@@ -138,7 +137,7 @@
      * @sa setTickMarks()
      * @sa majorTickMarks()
      */
-    QList< double > minorTickMarks() const;
+    QList<double> minorTickMarks() const;
 
 private:
     class Private;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotobject.cpp 
new/kplotting-5.81.0/src/kplotobject.cpp
--- old/kplotting-5.80.0/src/kplotobject.cpp    2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotobject.cpp    2021-04-03 11:36:21.000000000 
+0200
@@ -7,9 +7,9 @@
 
 #include "kplotobject.h"
 
-#include <QtAlgorithms>
-#include <QPainter>
 #include <QDebug>
+#include <QPainter>
+#include <QtAlgorithms>
 
 #include "kplotpoint.h"
 #include "kplotwidget.h"
@@ -40,7 +40,7 @@
 KPlotObject::KPlotObject(const QColor &c, PlotType t, double size, PointStyle 
ps)
     : d(new Private(this))
 {
-    //By default, all pens and brushes are set to the given color
+    // By default, all pens and brushes are set to the given color
     setBrush(c);
     setBarBrush(c);
     setPen(QPen(brush(), 1));
@@ -170,7 +170,7 @@
     d->barBrush = b;
 }
 
-QList< KPlotPoint * > KPlotObject::points() const
+QList<KPlotPoint *> KPlotObject::points() const
 {
     return d->pList;
 }
@@ -196,7 +196,7 @@
 void KPlotObject::removePoint(int index)
 {
     if ((index < 0) || (index >= d->pList.count())) {
-        //qWarning() << "KPlotObject::removePoint(): index " << index << " out 
of range!";
+        // qWarning() << "KPlotObject::removePoint(): index " << index << " 
out of range!";
         return;
     }
 
@@ -211,8 +211,8 @@
 
 void KPlotObject::draw(QPainter *painter, KPlotWidget *pw)
 {
-    //Order of drawing determines z-distance: Bars in the back, then lines,
-    //then points, then labels.
+    // Order of drawing determines z-distance: Bars in the back, then lines,
+    // then points, then labels.
 
     if (d->type & Bars) {
         painter->setPen(barPen());
@@ -224,7 +224,7 @@
                 if (i < d->pList.size() - 1) {
                     w = d->pList[i + 1]->x() - d->pList[i]->x();
                 }
-                //For the last bin, we'll just keep the previous width
+                // For the last bin, we'll just keep the previous width
 
             } else {
                 w = d->pList[i]->barWidth();
@@ -242,17 +242,17 @@
         }
     }
 
-    //Draw lines:
+    // Draw lines:
     if (d->type & Lines) {
         painter->setPen(linePen());
 
-        QPointF Previous = QPointF();  //Initialize to null
+        QPointF Previous = QPointF(); // Initialize to null
 
         for (const KPlotPoint *pp : qAsConst(d->pList)) {
-            //q is the position of the point in screen pixel coordinates
+            // q is the position of the point in screen pixel coordinates
             QPointF q = pw->mapToWidget(pp->position());
 
-            if (! Previous.isNull()) {
+            if (!Previous.isNull()) {
                 painter->drawLine(Previous, q);
                 pw->maskAlongLine(Previous, q);
             }
@@ -261,18 +261,17 @@
         }
     }
 
-    //Draw points:
+    // Draw points:
     if (d->type & Points) {
-
         for (const KPlotPoint *pp : qAsConst(d->pList)) {
-            //q is the position of the point in screen pixel coordinates
+            // q is the position of the point in screen pixel coordinates
             QPointF q = pw->mapToWidget(pp->position());
             if (pw->pixRect().contains(q.toPoint(), false)) {
                 double x1 = q.x() - size();
                 double y1 = q.y() - size();
                 QRectF qr = QRectF(x1, y1, 2 * size(), 2 * size());
 
-                //Mask out this rect in the plot for label avoidance
+                // Mask out this rect in the plot for label avoidance
                 pw->maskRect(qr, 2.0);
 
                 painter->setPen(pen());
@@ -289,9 +288,11 @@
 
                 case Triangle: {
                     QPolygonF tri;
+                    /* clang-format off */
                     tri << QPointF(q.x() - size(), q.y() + size())
                         << QPointF(q.x(), q.y() - size())
                         << QPointF(q.x() + size(), q.y() + size());
+                    /* clang-format on */
                     painter->drawPolygon(tri);
                     break;
                 }
@@ -302,23 +303,27 @@
 
                 case Pentagon: {
                     QPolygonF pent;
+                    /* clang-format off */
                     pent << QPointF(q.x(), q.y() - size())
                          << QPointF(q.x() + size(), q.y() - 0.309 * size())
                          << QPointF(q.x() + 0.588 * size(), q.y() + size())
                          << QPointF(q.x() - 0.588 * size(), q.y() + size())
                          << QPointF(q.x() - size(), q.y() - 0.309 * size());
+                    /* clang-format on */
                     painter->drawPolygon(pent);
                     break;
                 }
 
                 case Hexagon: {
                     QPolygonF hex;
+                    /* clang-format off */
                     hex << QPointF(q.x(), q.y() + size())
                         << QPointF(q.x() + size(), q.y() + 0.5 * size())
                         << QPointF(q.x() + size(), q.y() - 0.5 * size())
                         << QPointF(q.x(), q.y() - size())
                         << QPointF(q.x() - size(), q.y() + 0.5 * size())
                         << QPointF(q.x() - size(), q.y() - 0.5 * size());
+                    /* clang-format on */
                     painter->drawPolygon(hex);
                     break;
                 }
@@ -334,16 +339,14 @@
 
                 case Star: {
                     QPolygonF star;
+                    /* clang-format off */
                     star << QPointF(q.x(), q.y() - size())
                          << QPointF(q.x() + 0.2245 * size(), q.y() - 0.309 * 
size())
-                         << QPointF(q.x() + size(), q.y() - 0.309 * size())
-                         << QPointF(q.x() + 0.363 * size(), q.y() + 0.118 * 
size())
-                         << QPointF(q.x() + 0.588 * size(), q.y() + size())
-                         << QPointF(q.x(), q.y() + 0.382 * size())
-                         << QPointF(q.x() - 0.588 * size(), q.y() + size())
-                         << QPointF(q.x() - 0.363 * size(), q.y() + 0.118 * 
size())
-                         << QPointF(q.x() - size(), q.y() - 0.309 * size())
-                         << QPointF(q.x() - 0.2245 * size(), q.y() - 0.309 * 
size());
+                         << QPointF(q.x() + size(), q.y() - 0.309 * size()) << 
QPointF(q.x() + 0.363 * size(), q.y() + 0.118 * size())
+                         << QPointF(q.x() + 0.588 * size(), q.y() + size()) << 
QPointF(q.x(), q.y() + 0.382 * size())
+                         << QPointF(q.x() - 0.588 * size(), q.y() + size()) << 
QPointF(q.x() - 0.363 * size(), q.y() + 0.118 * size())
+                         << QPointF(q.x() - size(), q.y() - 0.309 * size()) << 
QPointF(q.x() - 0.2245 * size(), q.y() - 0.309 * size());
+                    /* clang-format on */
                     painter->drawPolygon(star);
                     break;
                 }
@@ -355,14 +358,13 @@
         }
     }
 
-    //Draw labels
+    // Draw labels
     painter->setPen(labelPen());
 
     for (KPlotPoint *pp : qAsConst(d->pList)) {
         QPoint q = pw->mapToWidget(pp->position()).toPoint();
-        if (pw->pixRect().contains(q, false) && ! pp->label().isEmpty()) {
+        if (pw->pixRect().contains(q, false) && !pp->label().isEmpty()) {
             pw->placeLabel(painter, pp);
         }
     }
-
 }
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotobject.h 
new/kplotting-5.81.0/src/kplotobject.h
--- old/kplotting-5.80.0/src/kplotobject.h      2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotobject.h      2021-04-03 11:36:21.000000000 
+0200
@@ -10,8 +10,8 @@
 
 #include <kplotting_export.h>
 
-#include <QString>
 #include <QColor>
+#include <QString>
 
 class QBrush;
 class QPainter;
@@ -51,9 +51,9 @@
      */
     enum PlotType {
         UnknownType = 0,
-        Points = 1,       ///< each KPlotPoint is represented with a drawn 
point
-        Lines = 2,        ///< each KPlotPoint is connected with a line
-        Bars = 4          ///< each KPlotPoint is shown as a vertical bar
+        Points = 1, ///< each KPlotPoint is represented with a drawn point
+        Lines = 2, ///< each KPlotPoint is connected with a line
+        Bars = 4, ///< each KPlotPoint is shown as a vertical bar
     };
     Q_DECLARE_FLAGS(PlotTypes, PlotType)
 
@@ -70,7 +70,7 @@
         Hexagon = 6,
         Asterisk = 7,
         Star = 8,
-        UnknownPoint
+        UnknownPoint,
     };
 
     /**
@@ -205,7 +205,7 @@
     /**
      * @return the list of KPlotPoints that make up this object
      */
-    QList< KPlotPoint * > points() const;
+    QList<KPlotPoint *> points() const;
 
     /**
      * Add a point to the object's list of points, using input data to 
construct a KPlotPoint.
@@ -213,7 +213,7 @@
      * @param label the optional text label for this point
      * @param barWidth the width of the bar, if this object is to be drawn 
with bars
      * @note if @param barWidth is left at its default value of 0.0, then the 
width will be
-         * automatically set to the distance between this point and the one to 
its right.
+     * automatically set to the distance between this point and the one to its 
right.
      */
     void addPoint(const QPointF &p, const QString &label = QString(), double 
barWidth = 0.0);
 
@@ -232,7 +232,7 @@
      * @param label the optional text label
      * @param barWidth the width of the bar, if this object is to be drawn 
with bars
      * @note if @param barWidth is left at its default value of 0.0, then the 
width will be
-         * automatically set to the distance between this point and the one to 
its right.
+     * automatically set to the distance between this point and the one to its 
right.
      */
     void addPoint(double x, double y, const QString &label = QString(), double 
barWidth = 0.0);
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotpoint.cpp 
new/kplotting-5.81.0/src/kplotpoint.cpp
--- old/kplotting-5.80.0/src/kplotpoint.cpp     2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotpoint.cpp     2021-04-03 11:36:21.000000000 
+0200
@@ -7,14 +7,17 @@
 
 #include "kplotpoint.h"
 
-#include <QtAlgorithms>
 #include <QPointF>
+#include <QtAlgorithms>
 
 class KPlotPoint::Private
 {
 public:
     Private(KPlotPoint *qq, const QPointF &p, const QString &l, double bw)
-        : q(qq), point(p), label(l), barWidth(bw)
+        : q(qq)
+        , point(p)
+        , label(l)
+        , barWidth(bw)
     {
     }
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotwidget.cpp 
new/kplotting-5.81.0/src/kplotwidget.cpp
--- old/kplotting-5.80.0/src/kplotwidget.cpp    2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotwidget.cpp    2021-04-03 11:36:21.000000000 
+0200
@@ -16,8 +16,8 @@
 #include <QtAlgorithms>
 
 #include "kplotaxis.h"
-#include "kplotpoint.h"
 #include "kplotobject.h"
+#include "kplotpoint.h"
 
 #define XPADDING 20
 #define YPADDING 20
@@ -29,9 +29,14 @@
 {
 public:
     Private(KPlotWidget *qq)
-        : q(qq),
-          cBackground(Qt::black), cForeground(Qt::white), cGrid(Qt::gray),
-          showGrid(false), showObjectToolTip(true), useAntialias(false), 
autoDelete(true)
+        : q(qq)
+        , cBackground(Qt::black)
+        , cForeground(Qt::white)
+        , cGrid(Qt::gray)
+        , showGrid(false)
+        , showObjectToolTip(true)
+        , useAntialias(false)
+        , autoDelete(true)
     {
         // create the axes and setting their default properties
         KPlotAxis *leftAxis = new KPlotAxis();
@@ -67,14 +72,14 @@
      */
     float rectCost(const QRectF &r) const;
 
-    //Colors
+    // Colors
     QColor cBackground, cForeground, cGrid;
-    //draw options
+    // draw options
     bool showGrid;
     bool showObjectToolTip;
     bool useAntialias;
     bool autoDelete;
-    //padding
+    // padding
     int leftPadding, rightPadding, topPadding, bottomPadding;
     // hashmap with the axes we have
     QHash<Axis, KPlotAxis *> axes;
@@ -84,17 +89,18 @@
     QRectF dataRect, secondDataRect;
     // Limits of the plot area in pixel units
     QRect pixRect;
-    //Array holding the mask of "used" regions of the plot
+    // Array holding the mask of "used" regions of the plot
     QImage plotMask;
 };
 
 KPlotWidget::KPlotWidget(QWidget *parent)
-    : QFrame(parent), d(new Private(this))
+    : QFrame(parent)
+    , d(new Private(this))
 {
     setAttribute(Qt::WA_OpaquePaintEvent);
     setAttribute(Qt::WA_NoSystemBackground);
 
-    d->secondDataRect = QRectF(); //default: no secondary data rect
+    d->secondDataRect = QRectF(); // default: no secondary data rect
     // sets the default limits
     d->calcDataRectLimits(0.0, 1.0, 0.0, 1.0);
 
@@ -141,11 +147,11 @@
     }
 
     if (XA2 == XA1) {
-        //qWarning() << "x1 and x2 cannot be equal. Setting x2 = x1 + 1.0";
+        // qWarning() << "x1 and x2 cannot be equal. Setting x2 = x1 + 1.0";
         XA2 = XA1 + 1.0;
     }
     if (YA2 == YA1) {
-        //qWarning() << "y1 and y2 cannot be equal. Setting y2 = y1 + 1.0";
+        // qWarning() << "y1 and y2 cannot be equal. Setting y2 = y1 + 1.0";
         YA2 = YA1 + 1.0;
     }
     dataRect = QRectF(XA1, YA1, XA2 - XA1, YA2 - YA1);
@@ -178,11 +184,11 @@
     }
 
     if (XA2 == XA1) {
-        //qWarning() << "x1 and x2 cannot be equal. Setting x2 = x1 + 1.0";
+        // qWarning() << "x1 and x2 cannot be equal. Setting x2 = x1 + 1.0";
         XA2 = XA1 + 1.0;
     }
     if (YA2 == YA1) {
-        //qWarning() << "y1 and y2 cannot be equal. Setting y2 = y1 + 1.0";
+        // qWarning() << "y1 and y2 cannot be equal. Setting y2 = y1 + 1.0";
         YA2 = YA1 + 1.0;
     }
     d->secondDataRect = QRectF(XA1, YA1, XA2 - XA1, YA2 - YA1);
@@ -222,7 +228,7 @@
     update();
 }
 
-void KPlotWidget::addPlotObjects(const QList< KPlotObject * > &objects)
+void KPlotWidget::addPlotObjects(const QList<KPlotObject *> &objects)
 {
     bool addedsome = false;
     for (KPlotObject *o : objects) {
@@ -238,7 +244,7 @@
     }
 }
 
-QList< KPlotObject * > KPlotWidget::plotObjects() const
+QList<KPlotObject *> KPlotWidget::plotObjects() const
 {
     return d->objectList;
 }
@@ -453,24 +459,23 @@
             d->plotMask.setPixel(ix, iy, newColor.rgba());
         }
     }
-
 }
 
 void KPlotWidget::maskAlongLine(const QPointF &p1, const QPointF &p2, float 
fvalue)
 {
-    if (! d->pixRect.contains(p1.toPoint()) && ! 
d->pixRect.contains(p2.toPoint())) {
+    if (!d->pixRect.contains(p1.toPoint()) && 
!d->pixRect.contains(p2.toPoint())) {
         return;
     }
 
     int value = int(fvalue);
 
-    //Determine slope and zeropoint of line
+    // Determine slope and zeropoint of line
     double m = (p2.y() - p1.y()) / (p2.x() - p1.x());
     double y0 = p1.y() - m * p1.x();
     QColor newColor;
 
-    //Mask each pixel along the line joining p1 and p2
-    if (m > 1.0 || m < -1.0) {   //step in y-direction
+    // Mask each pixel along the line joining p1 and p2
+    if (m > 1.0 || m < -1.0) { // step in y-direction
         int y1 = int(p1.y());
         int y2 = int(p2.y());
         if (y1 > y2) {
@@ -488,7 +493,7 @@
             }
         }
 
-    } else { //step in x-direction
+    } else { // step in x-direction
         int x1 = int(p1.x());
         int x2 = int(p2.x());
         if (x1 > x2) {
@@ -508,23 +513,23 @@
     }
 }
 
-//Determine optimal placement for a text label for point pp.  We want
-//the label to be near point pp, but we don't want it to overlap with
-//other labels or plot elements.  We will use a "downhill simplex"
-//algorithm to find a label position that minimizes the pixel values
-//in the plotMask image over the label's rect().  The sum of pixel
-//values in the label's rect is the "cost" of placing the label there.
+// Determine optimal placement for a text label for point pp.  We want
+// the label to be near point pp, but we don't want it to overlap with
+// other labels or plot elements.  We will use a "downhill simplex"
+// algorithm to find a label position that minimizes the pixel values
+// in the plotMask image over the label's rect().  The sum of pixel
+// values in the label's rect is the "cost" of placing the label there.
 //
-//Because a downhill simplex follows the local gradient to find low
-//values, it can get stuck in local minima.  To mitigate this, we will
-//iteratively attempt each of the initial path offset directions (up,
-//down, right, left) in the order of increasing cost at each location.
+// Because a downhill simplex follows the local gradient to find low
+// values, it can get stuck in local minima.  To mitigate this, we will
+// iteratively attempt each of the initial path offset directions (up,
+// down, right, left) in the order of increasing cost at each location.
 void KPlotWidget::placeLabel(QPainter *painter, KPlotPoint *pp)
 {
     int textFlags = Qt::TextSingleLine | Qt::AlignCenter;
 
     QPointF pos = mapToWidget(pp->position());
-    if (! d->pixRect.contains(pos.toPoint())) {
+    if (!d->pixRect.contains(pos.toPoint())) {
         return;
     }
 
@@ -535,26 +540,26 @@
     float maxCost = 0.05 * bestRect.width() * bestRect.height();
     float bestCost = d->rectCost(bestRect);
 
-    //We will travel along a path defined by the maximum decrease in
-    //the cost at each step.  If this path takes us to a local minimum
-    //whose cost exceeds maxCost, then we will restart at the
-    //beginning and select the next-best path.  The indices of
-    //already-tried paths are stored in the TriedPathIndex list.
+    // We will travel along a path defined by the maximum decrease in
+    // the cost at each step.  If this path takes us to a local minimum
+    // whose cost exceeds maxCost, then we will restart at the
+    // beginning and select the next-best path.  The indices of
+    // already-tried paths are stored in the TriedPathIndex list.
     //
-    //If we try all four first-step paths and still don't get below
-    //maxCost, then we'll adopt the local minimum position with the
-    //best cost (designated as bestBadCost).
+    // If we try all four first-step paths and still don't get below
+    // maxCost, then we'll adopt the local minimum position with the
+    // best cost (designated as bestBadCost).
     int iter = 0;
     QList<int> TriedPathIndex;
     float bestBadCost = 10000;
     QRectF bestBadRect;
 
-    //needed to halt iteration from inside the switch
+    // needed to halt iteration from inside the switch
     bool flagStop = false;
 
     while (bestCost > maxCost) {
-        //Displace the label up, down, left, right; determine which
-        //step provides the lowest cost
+        // Displace the label up, down, left, right; determine which
+        // step provides the lowest cost
         QRectF upRect = bestRect;
         upRect.moveTop(upRect.top() + yStep);
         float upCost = d->rectCost(upRect);
@@ -568,78 +573,77 @@
         rightRect.moveLeft(rightRect.left() + xStep);
         float rightCost = d->rectCost(rightRect);
 
-        //which direction leads to the lowest cost?
+        // which direction leads to the lowest cost?
         QList<float> costList;
         costList << upCost << downCost << leftCost << rightCost;
         int imin = -1;
         for (int i = 0; i < costList.size(); ++i) {
             if (iter == 0 && TriedPathIndex.contains(i)) {
-                continue; //Skip this first-step path, we already tried it!
+                continue; // Skip this first-step path, we already tried it!
             }
 
-            //If this first-step path doesn't improve the cost,
-            //skip this direction from now on
+            // If this first-step path doesn't improve the cost,
+            // skip this direction from now on
             if (iter == 0 && costList[i] >= bestCost) {
                 TriedPathIndex.append(i);
                 continue;
             }
 
             if (costList[i] < bestCost && (imin < 0 || costList[i] < 
costList[imin])) {
-
                 imin = i;
             }
         }
 
-        //Make a note that we've tried the current first-step path
+        // Make a note that we've tried the current first-step path
         if (iter == 0 && imin >= 0) {
             TriedPathIndex.append(imin);
         }
 
-        //Adopt the step that produced the best cost
+        // Adopt the step that produced the best cost
         switch (imin) {
-        case 0: //up
+        case 0: // up
             bestRect.moveTop(upRect.top());
             bestCost = upCost;
             break;
-        case 1: //down
+        case 1: // down
             bestRect.moveTop(downRect.top());
             bestCost = downCost;
             break;
-        case 2: //left
+        case 2: // left
             bestRect.moveLeft(leftRect.left());
             bestCost = leftCost;
             break;
-        case 3: //right
+        case 3: // right
             bestRect.moveLeft(rightRect.left());
             bestCost = rightCost;
             break;
-        case -1: //no lower cost found!
-            //We hit a local minimum.  Keep the best of these as bestBadRect
+        case -1: // no lower cost found!
+            // We hit a local minimum.  Keep the best of these as bestBadRect
             if (bestCost < bestBadCost) {
                 bestBadCost = bestCost;
                 bestBadRect = bestRect;
             }
 
-            //If all of the first-step paths have now been searched, we'll
-            //have to adopt the bestBadRect
+            // If all of the first-step paths have now been searched, we'll
+            // have to adopt the bestBadRect
             if (TriedPathIndex.size() == 4) {
                 bestRect = bestBadRect;
-                flagStop = true; //halt iteration
+                flagStop = true; // halt iteration
                 break;
             }
 
-            //If we haven't yet tried all of the first-step paths, start over
+            // If we haven't yet tried all of the first-step paths, start over
             if (TriedPathIndex.size() < 4) {
-                iter = -1; //anticipating the ++iter below
+                iter = -1; // anticipating the ++iter below
                 bestRect = fm.boundingRect(QRectF(pos.x(), pos.y(), 1, 1), 
textFlags, pp->label());
                 bestCost = d->rectCost(bestRect);
             }
             break;
         }
 
-        //Halt iteration, because we've tried all directions and
-        //haven't gotten below maxCost (we'll adopt the best
-        //local minimum found)
+        // Halt iteration, because we've tried all directions and
+        // haven't gotten below maxCost (we'll adopt the best
+        // local minimum found)
         if (flagStop) {
             break;
         }
@@ -649,20 +653,20 @@
 
     painter->drawText(bestRect, textFlags, pp->label());
 
-    //Is a line needed to connect the label to the point?
+    // Is a line needed to connect the label to the point?
     float deltax = pos.x() - bestRect.center().x();
     float deltay = pos.y() - bestRect.center().y();
     float rbest = sqrt(deltax * deltax + deltay * deltay);
     if (rbest > 20.0) {
-        //Draw a rectangle around the label
+        // Draw a rectangle around the label
         painter->setBrush(QBrush());
-        //QPen pen = painter->pen();
-        //pen.setStyle( Qt::DotLine );
-        //painter->setPen( pen );
+        // QPen pen = painter->pen();
+        // pen.setStyle( Qt::DotLine );
+        // painter->setPen( pen );
         painter->drawRoundedRect(bestRect, 25, 25, Qt::RelativeSize);
 
-        //Now connect the label to the point with a line.
-        //The line is drawn from the center of the near edge of the rectangle
+        // Now connect the label to the point with a line.
+        // The line is drawn from the center of the near edge of the rectangle
         float xline = bestRect.center().x();
         if (bestRect.left() > pos.x()) {
             xline = bestRect.left();
@@ -682,17 +686,17 @@
         painter->drawLine(QPointF(xline, yline), pos);
     }
 
-    //Mask the label's rectangle so other labels won't overlap it.
+    // Mask the label's rectangle so other labels won't overlap it.
     maskRect(bestRect);
 }
 
 float KPlotWidget::Private::rectCost(const QRectF &r) const
 {
-    if (! plotMask.rect().contains(r.toRect())) {
+    if (!plotMask.rect().contains(r.toRect())) {
         return 10000.;
     }
 
-    //Compute sum of mask values in the rect r
+    // Compute sum of mask values in the rect r
     QImage subMask = plotMask.copy(r.toRect());
     int cost = 0;
     for (int ix = 0; ix < subMask.width(); ++ix) {
@@ -725,8 +729,8 @@
         po->draw(&p, this);
     }
 
-//DEBUG: Draw the plot mask
-//    p.drawImage( 0, 0, d->plotMask );
+    // DEBUG: Draw the plot mask
+    //    p.drawImage( 0, 0, d->plotMask );
 
     p.setClipping(false);
     drawAxes(&p);
@@ -739,14 +743,14 @@
     if (d->showGrid) {
         p->setPen(gridColor());
 
-        //Grid lines are placed at locations of primary axes' major tickmarks
-        //vertical grid lines
+        // Grid lines are placed at locations of primary axes' major tickmarks
+        // vertical grid lines
         const QList<double> majMarks = axis(BottomAxis)->majorTickMarks();
         for (const double xx : majMarks) {
             double px = d->pixRect.width() * (xx - d->dataRect.x()) / 
d->dataRect.width();
             p->drawLine(QPointF(px, 0.0), QPointF(px, 
double(d->pixRect.height())));
         }
-        //horizontal grid lines
+        // horizontal grid lines
         const QList<double> leftTickMarks = axis(LeftAxis)->majorTickMarks();
         for (const double yy : leftTickMarks) {
             double py = d->pixRect.height() * (1.0 - (yy - d->dataRect.y()) / 
d->dataRect.height());
@@ -757,7 +761,7 @@
     p->setPen(foregroundColor());
     p->setBrush(Qt::NoBrush);
 
-    //set small font for tick labels
+    // set small font for tick labels
     QFont f = p->font();
     int s = f.pointSize();
     f.setPointSize(s - 2);
@@ -766,7 +770,7 @@
     /*** BottomAxis ***/
     KPlotAxis *a = axis(BottomAxis);
     if (a->isVisible()) {
-        //Draw axis line
+        // Draw axis line
         p->drawLine(0, d->pixRect.height(), d->pixRect.width(), 
d->pixRect.height());
 
         // Draw major tickmarks
@@ -774,10 +778,10 @@
         for (const double xx : majMarks) {
             double px = d->pixRect.width() * (xx - d->dataRect.x()) / 
d->dataRect.width();
             if (px > 0 && px < d->pixRect.width()) {
-                p->drawLine(QPointF(px, double(d->pixRect.height() - 
TICKOFFSET)),
+                p->drawLine(QPointF(px, double(d->pixRect.height() - 
TICKOFFSET)), //
                             QPointF(px, double(d->pixRect.height() - 
BIGTICKSIZE - TICKOFFSET)));
 
-                //Draw ticklabel
+                // Draw ticklabel
                 if (a->areTickLabelsShown()) {
                     QRect r(int(px) - BIGTICKSIZE, d->pixRect.height() + 
BIGTICKSIZE, 2 * BIGTICKSIZE, BIGTICKSIZE);
                     p->drawText(r, Qt::AlignCenter | Qt::TextDontClip, 
a->tickLabel(xx));
@@ -790,22 +794,22 @@
         for (const double xx : minTickMarks) {
             double px = d->pixRect.width() * (xx - d->dataRect.x()) / 
d->dataRect.width();
             if (px > 0 && px < d->pixRect.width()) {
-                p->drawLine(QPointF(px, double(d->pixRect.height() - 
TICKOFFSET)),
+                p->drawLine(QPointF(px, double(d->pixRect.height() - 
TICKOFFSET)), //
                             QPointF(px, double(d->pixRect.height() - 
SMALLTICKSIZE - TICKOFFSET)));
             }
         }
 
         // Draw BottomAxis Label
-        if (! a->label().isEmpty()) {
+        if (!a->label().isEmpty()) {
             QRect r(0, d->pixRect.height() + 2 * YPADDING, d->pixRect.width(), 
YPADDING);
             p->drawText(r, Qt::AlignCenter, a->label());
         }
-    }  //End of BottomAxis
+    } // End of BottomAxis
 
     /*** LeftAxis ***/
     a = axis(LeftAxis);
     if (a->isVisible()) {
-        //Draw axis line
+        // Draw axis line
         p->drawLine(0, 0, 0, d->pixRect.height());
 
         // Draw major tickmarks
@@ -815,7 +819,7 @@
             if (py > 0 && py < d->pixRect.height()) {
                 p->drawLine(QPointF(TICKOFFSET, py), QPointF(double(TICKOFFSET 
+ BIGTICKSIZE), py));
 
-                //Draw ticklabel
+                // Draw ticklabel
                 if (a->areTickLabelsShown()) {
                     QRect r(-2 * BIGTICKSIZE - SMALLTICKSIZE, int(py) - 
SMALLTICKSIZE, 2 * BIGTICKSIZE, 2 * SMALLTICKSIZE);
                     p->drawText(r, Qt::AlignRight | Qt::AlignVCenter | 
Qt::TextDontClip, a->tickLabel(yy));
@@ -825,30 +829,30 @@
 
         // Draw minor tickmarks
         const QList<double> minTickMarks = a->minorTickMarks();
-        for (const double yy : minTickMarks ) {
+        for (const double yy : minTickMarks) {
             double py = d->pixRect.height() * (1.0 - (yy - d->dataRect.y()) / 
d->dataRect.height());
             if (py > 0 && py < d->pixRect.height()) {
                 p->drawLine(QPointF(TICKOFFSET, py), QPointF(double(TICKOFFSET 
+ SMALLTICKSIZE), py));
             }
         }
 
-        //Draw LeftAxis Label.  We need to draw the text sideways.
-        if (! a->label().isEmpty()) {
-            //store current painter translation/rotation state
+        // Draw LeftAxis Label.  We need to draw the text sideways.
+        if (!a->label().isEmpty()) {
+            // store current painter translation/rotation state
             p->save();
 
-            //translate coord sys to left corner of axis label rectangle, then 
rotate 90 degrees.
+            // translate coord sys to left corner of axis label rectangle, 
then rotate 90 degrees.
             p->translate(-3 * XPADDING, d->pixRect.height());
             p->rotate(-90.0);
 
             QRect r(0, 0, d->pixRect.height(), XPADDING);
-            p->drawText(r, Qt::AlignCenter, a->label());   //draw the label, 
now that we are sideways
+            p->drawText(r, Qt::AlignCenter, a->label()); // draw the label, 
now that we are sideways
 
-            p->restore();  //restore translation/rotation state
+            p->restore(); // restore translation/rotation state
         }
-    }  //End of LeftAxis
+    } // End of LeftAxis
 
-    //Prepare for top and right axes; we may need the secondary data rect
+    // Prepare for top and right axes; we may need the secondary data rect
     double x0 = d->dataRect.x();
     double y0 = d->dataRect.y();
     double dw = d->dataRect.width();
@@ -863,7 +867,7 @@
     /*** TopAxis ***/
     a = axis(TopAxis);
     if (a->isVisible()) {
-        //Draw axis line
+        // Draw axis line
         p->drawLine(0, 0, d->pixRect.width(), 0);
 
         // Draw major tickmarks
@@ -873,9 +877,9 @@
             if (px > 0 && px < d->pixRect.width()) {
                 p->drawLine(QPointF(px, TICKOFFSET), QPointF(px, 
double(BIGTICKSIZE + TICKOFFSET)));
 
-                //Draw ticklabel
+                // Draw ticklabel
                 if (a->areTickLabelsShown()) {
-                    QRect r(int(px) - BIGTICKSIZE, (int) - 1.5 * BIGTICKSIZE, 
2 * BIGTICKSIZE, BIGTICKSIZE);
+                    QRect r(int(px) - BIGTICKSIZE, (int)-1.5 * BIGTICKSIZE, 2 
* BIGTICKSIZE, BIGTICKSIZE);
                     p->drawText(r, Qt::AlignCenter | Qt::TextDontClip, 
a->tickLabel(xx));
                 }
             }
@@ -891,16 +895,16 @@
         }
 
         // Draw TopAxis Label
-        if (! a->label().isEmpty()) {
+        if (!a->label().isEmpty()) {
             QRect r(0, 0 - 3 * YPADDING, d->pixRect.width(), YPADDING);
             p->drawText(r, Qt::AlignCenter, a->label());
         }
-    }  //End of TopAxis
+    } // End of TopAxis
 
     /*** RightAxis ***/
     a = axis(RightAxis);
     if (a->isVisible()) {
-        //Draw axis line
+        // Draw axis line
         p->drawLine(d->pixRect.width(), 0, d->pixRect.width(), 
d->pixRect.height());
 
         // Draw major tickmarks
@@ -908,10 +912,10 @@
         for (const double yy : majMarks) {
             double py = d->pixRect.height() * (1.0 - (yy - y0) / dh);
             if (py > 0 && py < d->pixRect.height()) {
-                p->drawLine(QPointF(double(d->pixRect.width() - TICKOFFSET), 
py),
+                p->drawLine(QPointF(double(d->pixRect.width() - TICKOFFSET), 
py), //
                             QPointF(double(d->pixRect.width() - TICKOFFSET - 
BIGTICKSIZE), py));
 
-                //Draw ticklabel
+                // Draw ticklabel
                 if (a->areTickLabelsShown()) {
                     QRect r(d->pixRect.width() + SMALLTICKSIZE, int(py) - 
SMALLTICKSIZE, 2 * BIGTICKSIZE, 2 * SMALLTICKSIZE);
                     p->drawText(r, Qt::AlignLeft | Qt::AlignVCenter | 
Qt::TextDontClip, a->tickLabel(yy));
@@ -924,26 +928,25 @@
         for (const double yy : minMarks) {
             double py = d->pixRect.height() * (1.0 - (yy - y0) / dh);
             if (py > 0 && py < d->pixRect.height()) {
-                p->drawLine(QPointF(double(d->pixRect.width() - 0.0), py),
-                            QPointF(double(d->pixRect.width() - 0.0 - 
SMALLTICKSIZE), py));
+                p->drawLine(QPointF(double(d->pixRect.width() - 0.0), py), 
QPointF(double(d->pixRect.width() - 0.0 - SMALLTICKSIZE), py));
             }
         }
 
-        //Draw RightAxis Label.  We need to draw the text sideways.
-        if (! a->label().isEmpty()) {
-            //store current painter translation/rotation state
+        // Draw RightAxis Label.  We need to draw the text sideways.
+        if (!a->label().isEmpty()) {
+            // store current painter translation/rotation state
             p->save();
 
-            //translate coord sys to left corner of axis label rectangle, then 
rotate 90 degrees.
+            // translate coord sys to left corner of axis label rectangle, 
then rotate 90 degrees.
             p->translate(d->pixRect.width() + 2 * XPADDING, 
d->pixRect.height());
             p->rotate(-90.0);
 
             QRect r(0, 0, d->pixRect.height(), XPADDING);
-            p->drawText(r, Qt::AlignCenter, a->label());   //draw the label, 
now that we are sideways
+            p->drawText(r, Qt::AlignCenter, a->label()); // draw the label, 
now that we are sideways
 
-            p->restore();  //restore translation/rotation state
+            p->restore(); // restore translation/rotation state
         }
-    }  //End of RightAxis
+    } // End of RightAxis
 }
 
 int KPlotWidget::leftPadding() const
@@ -1021,4 +1024,3 @@
     d->topPadding = -1;
     d->bottomPadding = -1;
 }
-
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/kplotting-5.80.0/src/kplotwidget.h 
new/kplotting-5.81.0/src/kplotwidget.h
--- old/kplotting-5.80.0/src/kplotwidget.h      2021-02-28 20:04:05.000000000 
+0100
+++ new/kplotting-5.81.0/src/kplotwidget.h      2021-04-03 11:36:21.000000000 
+0200
@@ -92,10 +92,10 @@
      * The four types of plot axes.
      */
     enum Axis {
-        LeftAxis = 0,  ///< the left axis
-        BottomAxis,    ///< the bottom axis
-        RightAxis,     ///< the right axis
-        TopAxis        ///< the top axis
+        LeftAxis = 0, ///< the left axis
+        BottomAxis, ///< the bottom axis
+        RightAxis, ///< the right axis
+        TopAxis, ///< the top axis
     };
 
     /**
@@ -165,7 +165,7 @@
     /**
      * @return the rectangle representing the boundaries of the current plot,
      * in screen pixel units.
-      */
+     */
     QRect pixRect() const;
 
     /**
@@ -180,12 +180,12 @@
      * The widget takes ownership of the plot object, unless auto-delete was 
disabled.
      * @param objects the list of KPlotObjects to be added
      */
-    void addPlotObjects(const QList< KPlotObject * > &objects);
+    void addPlotObjects(const QList<KPlotObject *> &objects);
 
     /**
      * @return the current list of plot objects
      */
-    QList< KPlotObject * > plotObjects() const;
+    QList<KPlotObject *> plotObjects() const;
 
     /**
      * Enables auto-deletion of plot objects if autoDelete is true; otherwise 
auto-deletion is disabled.

Reply via email to