Rework the Statistics Item

YUViewApp/YUViewApp.pro

@@ -2,9 +2,14 @@ QT += core gui widgets opengl xml concurrent network
 
 TARGET = YUView
 TEMPLATE = app
-CONFIG += c++17
 CONFIG -= debug_and_release
 
+CONFIG += c++20
+gcc {
+  # For gcc 9, setting 20 does not work. Must set c++2a.
+  equals(QMAKE_GCC_MAJOR_VERSION, 9): QMAKE_CXXFLAGS += -std=c++2a
+}
+
 SOURCES += $$files(src/*.cpp, false)
 HEADERS += $$files(src/*.h, false)
 

YUViewLib/YUViewLib.pro

@@ -2,10 +2,15 @@ QT += core gui widgets opengl xml concurrent network
 
 TEMPLATE = lib
 CONFIG += staticlib
-CONFIG += c++17
 CONFIG -= debug_and_release
 CONFIG += object_parallel_to_source
 
+CONFIG += c++20
+gcc {
+  # For gcc 9, setting 20 does not work. Must set c++2a.
+  equals(QMAKE_GCC_MAJOR_VERSION, 9): QMAKE_CXXFLAGS += -std=c++2a
+}
+
 SOURCES += $$files(src/*.cpp, true)
 HEADERS += $$files(src/*.h, true)
 

YUViewLib/src/common/Functions.h

@@ -34,6 +34,7 @@
 
 #include <common/Typedef.h>
 
+#include <cmath>
 #include <istream>
 #include <optional>
 
@@ -101,4 +102,15 @@ template <typename T, typename R> inline T clip(T val, Range<R> range)
 std::optional<unsigned> toUnsigned(const std::string_view text);
 std::optional<int>      toInt(const std::string_view text);
 
+template <typename T, typename P> inline T scaleValueByPercent(T value, P percent)
+{
+  static_assert(std::is_integral<T>::value, "Type T must be an integral type.");
+  static_assert(std::is_integral<P>::value || std::is_floating_point<P>::value,
+                "Type P must be an integral or floating point type type.");
+
+  const auto factor      = static_cast<double>(percent) / 100.0;
+  const auto scaledValue = static_cast<double>(value) * factor;
+  return static_cast<T>(std::round(scaledValue));
+}
+
 } // namespace functions

YUViewLib/src/common/Modified.h

@@ -0,0 +1,58 @@
+/*  This file is part of YUView - The YUV player with advanced analytics toolset
+ *   <https://github.com/IENT/YUView>
+ *   Copyright (C) 2015  Institut für Nachrichtentechnik, RWTH Aachen University, GERMANY
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   In addition, as a special exception, the copyright holders give
+ *   permission to link the code of portions of this program with the
+ *   OpenSSL library under certain conditions as described in each
+ *   individual source file, and distribute linked combinations including
+ *   the two.
+ *
+ *   You must obey the GNU General Public License in all respects for all
+ *   of the code used other than OpenSSL. If you modify file(s) with this
+ *   exception, you may extend this exception to your version of the
+ *   file(s), but you are not obligated to do so. If you do not wish to do
+ *   so, delete this exception statement from your version. If you delete
+ *   this exception statement from all source files in the program, then
+ *   also delete it here.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+template <typename T> class modified
+{
+public:
+  modified() = default;
+  modified(const T &value) : internalValue(value), initialValue(value) {}
+
+  T        operator*() const { return this->internalValue; }
+  T        value() const { return this->internalValue; }
+  const T *operator->() const { return &this->internalValue; }
+  T       *operator->() { return &this->internalValue; }
+  operator T() const { return this->internalValue; }
+
+  void operator=(const T &newValue) { this->internalValue = newValue; }
+
+  bool operator==(const T &other) const { return this->internalValue == other; }
+  bool operator==(const modified<T> &other) const { return this->internalValue == other.value(); }
+
+  [[nodiscard]] bool wasModified() const { return !(this->internalValue == this->initialValue); }
+  void               setUnmodified() { this->initialValue = this->internalValue; }
+
+private:
+  T internalValue{};
+  T initialValue{};
+};

YUViewLib/src/common/Typedef.h

@@ -170,9 +170,9 @@ template <typename T> struct Range
   T min{};
   T max{};
 
-  bool operator!=(const Range &other) const
+  bool operator==(const Range &other) const
   {
-    return this->min != other.min || this->max != other.max;
+    return this->min == other.min && this->max == other.max;
   }
 };