AMetric.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Core.h>
#include <type_traits>
#include <ostream>
#include <tuple>
#include "AUI/Util/Assert.h"
 
class AString;

class API_AUI_VIEWS AMetric
{
public:
   enum Unit
   {
       T_UNKNOWN,
       T_PX,
       T_DP,
       T_PT,
   };
 
private:
   float mValue;
   Unit mUnit;
 
   float convertValueToMyUnit(const AMetric& anotherMetric) {
       return fromPxToMetric(anotherMetric.getValuePx(), mUnit);
   }
 
public:
   constexpr AMetric():
       AMetric(0, T_PX) {}

   template<typename T, typename std::enable_if_t<std::is_integral_v<T>, bool> = 0>
   constexpr AMetric(T value):
       AMetric(value, T_PX)
   {
       AUI_ASSERTX(value == 0,
                   "please use _px, _dp or _pt literal for AMetric initialisation. only zero allowed to "
                   "initialise AMetric without literal");
   }
 
   constexpr AMetric(float value, Unit unit): mValue(value), mUnit(unit) {
 
   }
 
   AMetric(const AString& text);
 
   [[nodiscard]] float getRawValue() const
   {
       return mValue;
   }
 
   [[nodiscard]] Unit getUnit() const
   {
       return mUnit;
   }
 
   [[nodiscard]] float getValuePx() const;
   [[nodiscard]] float getValueDp() const;
 
   static float fromPxToMetric(float value, Unit unit);
 
   operator float() const {
       return getValuePx();
   }
   
   AMetric operator-() const {
       return {-mValue, mUnit};
   }
 
   AMetric& operator+=(AMetric rhs) noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       mValue += rhs.mValue;
       return *this;
   }
 
   AMetric& operator-=(AMetric rhs) noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       mValue -= rhs.mValue;
       return *this;
   }
 
   AMetric& operator*=(AMetric rhs) noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       mValue *= rhs.mValue;
       return *this;
   }
 
   AMetric& operator/=(AMetric rhs) noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       mValue /= rhs.mValue;
       return *this;
   }
 
   AMetric operator+(AMetric rhs) const noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       auto copy = *this;
       copy += rhs;
       return copy;
   }
 
   AMetric operator-(AMetric rhs) const noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       auto copy = *this;
       copy -= rhs;
       return copy;
   }
 
   AMetric operator*(AMetric rhs) const noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       auto copy = *this;
       copy *= rhs;
       return copy;
   }
 
   AMetric operator/(AMetric rhs) const noexcept {
       AUI_ASSERT(mUnit == rhs.mUnit);
       auto copy = *this;
       copy /= rhs;
       return copy;
   }
 
   AMetric& operator*=(float rhs) noexcept {
       mValue *= rhs;
       return *this;
   }
 
   AMetric& operator/=(float rhs) noexcept {
       mValue /= rhs;
       return *this;
   }
 
   AMetric operator*(float rhs) const noexcept {
       auto copy = *this;
       copy *= rhs;
       return copy;
   }
 
   AMetric operator/(float rhs) const noexcept {
       auto copy = *this;
       copy /= rhs;
       return copy;
   }
 
   bool operator==(const AMetric& rhs) const {
       return std::tie(mValue, mUnit) == std::tie(rhs.mValue, rhs.mUnit);
   }
 
   bool operator!=(const AMetric& rhs) const {
       return !(rhs == *this);
   }
};
 
 
constexpr inline AMetric operator""_px(unsigned long long v)
{
   return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_PX);
}
constexpr inline AMetric operator""_dp(unsigned long long v)
{
   return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_DP);
}
constexpr inline AMetric operator""_pt(unsigned long long v)
{
   return AMetric(static_cast<float>(static_cast<long long>(v)), AMetric::T_PT);
}
 
inline std::ostream& operator<<(std::ostream& o, const AMetric& value) {
   o << value.getRawValue();
   switch (value.getUnit()) {
       case AMetric::T_PX:
           o << "_px";
           break;
       case AMetric::T_DP:
           o << "_dp";
           break;
       case AMetric::T_PT:
           o << "_pt";
           break;
 
       default:
           break;
   }
   return o;
}

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.