rename RgbStacked -> RgbPallete

Author: TomSaw

src/modm/driver/pwm/apa102.hpp

@@ -43,7 +43,7 @@ class Apa102
 	}
 
 	bool
-	setColorBrightness(size_t index, const color::RgbStacked<8,8,8> &color, uint8_t brightness)
+	setColorBrightness(size_t index, const color::RgbPallete<8,8,8> &color, uint8_t brightness)
 	{
 		if (index >= LEDs) return false;
 		uint32_t value = color.value() << 8 | (brightness | 0xe0);
@@ -52,7 +52,7 @@ class Apa102
 	}
 
 	bool
-	setColor(size_t index, const color::RgbStacked<8,8,8> &color)
+	setColor(size_t index, const color::RgbPallete<8,8,8> &color)
 	{
 		if (index >= LEDs) return false;
 		// read the brightness value and clear all colors

src/modm/ui/color.hpp

@@ -15,4 +15,4 @@
 #include "color/hsv.hpp"
 
 #include "color/rgb_html.hpp"
-#include "color/rgb_stacked.hpp"
+#include "color/rgb_pallete.hpp"

src/modm/ui/color/concepts.hpp

@@ -36,7 +36,7 @@ class Rgb;
 
 template<int DR, int DG, int DB>
 requires (DR > 0) && (DG > 0) && (DB > 0)
-class RgbStacked;
+class RgbPallete;
 
 template <int DH, int DS, int DV>
 requires (DH > 0) && (DS > 0) && (DV > 0)
@@ -62,7 +62,7 @@ template<class C>
 concept ColorRgb = is_instance<C, Rgb>::value;
 
 template<class C>
-concept ColorRgbStacked = is_instance<C, RgbStacked>::value;
+concept ColorRgbPallete = is_instance<C, RgbPallete>::value;
 
 template<class C>
 concept ColorHsv = is_instance<C, Hsv>::value;
@@ -71,7 +71,7 @@ concept ColorHsv = is_instance<C, Hsv>::value;
  * @brief 	Concept to ident any colortype instance
  */
 template<class C>
-concept Color = ColorGray<C> || ColorRgb<C> || ColorHsv<C> || ColorRgbStacked<C>; // conjunction
+concept Color = ColorGray<C> || ColorRgb<C> || ColorHsv<C> || ColorRgbPallete<C>; // conjunction
 // concept Color = std::convertible_to<C, Rgb<8,8,8> >; // more tolerant alternative: convertability
 
 }

src/modm/ui/color/gray.hpp

@@ -59,7 +59,7 @@ class Gray : public modm::ProportionalUnsigned<D>
 		) >> 13)
 	{}
 
-	template<ColorRgbStacked C>
+	template<ColorRgbPallete C>
  	constexpr Gray(const C& rgbstacked)
 	 	: Gray(Rgb<C::RedType::digits, C::GreenType::digits, C::BlueType::digits>(rgbstacked))
 	{}

src/modm/ui/color/hsv.hpp

@@ -97,7 +97,7 @@ class Hsv
 		saturation_ = max ? diff / max * maxValue : 0;
 	}
 
-	template<ColorRgbStacked C>
+	template<ColorRgbPallete C>
  	constexpr Hsv(const C& rgbstacked)
 	 	: Hsv(Rgb<C::RedType::digits, C::GreenType::digits, C::BlueType::digits>(rgbstacked))
 	{}

src/modm/ui/color/rgb.hpp

@@ -54,7 +54,7 @@ class Rgb
 	{}
 
 	template<class C>
-	requires ColorRgb<C> || ColorRgbStacked<C>
+	requires ColorRgb<C> || ColorRgbPallete<C>
 	constexpr Rgb(const C& other)
 		: red_(other.red()), green_(other.green()), blue_(other.blue())
 	{}

src/modm/ui/color/rgb_stacked.hpp src/modm/ui/color/rgb_pallete.hppsrc/modm/ui/color/rgb_stacked.hpp renamed to src/modm/ui/color/rgb_pallete.hpp

@@ -19,7 +19,7 @@ namespace modm::color {
  * 					Requires less space than unstacked rgb types. Calculations without dedicated graphics
  * 					acceleration hardware are very inefficient.
  * 					If theres no dedicated graphics acceleration but lots of RAM, using modm::Rgb<> for
- * 					calculations and afterwards conversion to modm::RgbStacked<> may be an option.
+ * 					calculations and afterwards conversion to modm::RgbPallete<> may be an option.
  *
  * @tparam DR 		Digits for red channel
  * @tparam DG 		Digits for green channel
@@ -30,7 +30,7 @@ namespace modm::color {
  */
 template <int DR, int DG, int DB>
 requires (DR > 0) && (DG > 0) && (DB > 0)
-class RgbStacked
+class RgbPallete
 {
 public:
 	using RedType = Gray<DR>;
@@ -39,38 +39,38 @@ class RgbStacked
 
 	using T = uint_t<DR + DG + DB>::least;
 
-	constexpr RgbStacked() = default;
+	constexpr RgbPallete() = default;
 
-	constexpr RgbStacked(T value)
+	constexpr RgbPallete(T value)
 		: value_(value)
 	{}
 
-	constexpr RgbStacked(RedType red, GreenType green, BlueType blue)
+	constexpr RgbPallete(RedType red, GreenType green, BlueType blue)
 		: value_(red.value() << (DG + DB) | green.value() << DB | blue.value())
 	{}
 
-	constexpr RgbStacked(const RgbStacked &rgbstacked)
+	constexpr RgbPallete(const RgbPallete &rgbstacked)
 		: value_(rgbstacked.value_)
 	{}
 
 	template<ColorGray C>
-	constexpr RgbStacked(const C &gray)
-		: RgbStacked(Rgb<C::digits>(gray))
+	constexpr RgbPallete(const C &gray)
+		: RgbPallete(Rgb<C::digits>(gray))
 	{}
 
 	template<ColorRgb C>
-	constexpr RgbStacked(const C &rgb)
-		: RgbStacked(rgb.red(), rgb.green(), rgb.blue())
+	constexpr RgbPallete(const C &rgb)
+		: RgbPallete(rgb.red(), rgb.green(), rgb.blue())
 	{}
 
-	template<ColorRgbStacked C>
-	constexpr RgbStacked(const C &rgstacked)
-		: RgbStacked(rgstacked.red(), rgstacked.green(), rgstacked.blue())
+	template<ColorRgbPallete C>
+	constexpr RgbPallete(const C &rgstacked)
+		: RgbPallete(rgstacked.red(), rgstacked.green(), rgstacked.blue())
 	{}
 
 	template<ColorHsv C>
-	constexpr RgbStacked(const C &hsv)
-		: RgbStacked(Rgb<5,6,5>(hsv))
+	constexpr RgbPallete(const C &hsv)
+		: RgbPallete(Rgb<5,6,5>(hsv))
 	{}
 
 	/**
@@ -105,11 +105,11 @@ class RgbStacked
 	auto blue() { return channel_accessor<T, BlueType, 0>{value_}; }
 
 	// assignment
-	void operator=(const RgbStacked other) {
+	void operator=(const RgbPallete other) {
 		value_ = other.value_;
 	}
 
-	RgbStacked& operator+=(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete& operator+=(const Rgb<DR, DG, DB>& rgb) {
 		operator=({
 			red().value() + rgb.red(),
 			green().value() + rgb.green(),
@@ -118,7 +118,7 @@ class RgbStacked
 		return *this;
 	}
 
-	RgbStacked& operator-=(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete& operator-=(const Rgb<DR, DG, DB>& rgb) {
 		operator=({
 			red().value() - rgb.red(),
 			green().value() - rgb.green(),
@@ -127,7 +127,7 @@ class RgbStacked
 		return *this;
 	}
 
-	RgbStacked& operator*=(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete& operator*=(const Rgb<DR, DG, DB>& rgb) {
 		operator=({
 			red().value() * rgb.red(),
 			green().value() * rgb.green(),
@@ -136,7 +136,7 @@ class RgbStacked
 		return *this;
 	}
 
-	RgbStacked& operator/=(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete& operator/=(const Rgb<DR, DG, DB>& rgb) {
 		operator=({
 			red().value() * rgb.red(),
 			green().value() * rgb.green(),
@@ -145,31 +145,31 @@ class RgbStacked
 		return *this;
 	}
 
-	RgbStacked operator+(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete operator+(const Rgb<DR, DG, DB>& rgb) {
 		return {
 			red().value() + rgb.red(),
 			green().value() + rgb.green(),
 			blue().value() + rgb.blue()
 		};
 	}
 
-	RgbStacked operator-(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete operator-(const Rgb<DR, DG, DB>& rgb) {
 		return {
 			red().value() - rgb.red(),
 			green().value() - rgb.green(),
 			blue().value() - rgb.blue()
 		};
 	}
 
-	RgbStacked operator*(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete operator*(const Rgb<DR, DG, DB>& rgb) {
 		return {
 			red().value() * rgb.red(),
 			green().value() * rgb.green(),
 			blue().value() * rgb.blue()
 		};
 	}
 
-	RgbStacked operator/(const Rgb<DR, DG, DB>& rgb) {
+	RgbPallete operator/(const Rgb<DR, DG, DB>& rgb) {
 		return {
 			red().value() / rgb.red(),
 			green().value() / rgb.green(),
@@ -179,7 +179,7 @@ class RgbStacked
 
 	// Equality
 	constexpr bool
-	operator==(const RgbStacked& other) const = default;
+	operator==(const RgbPallete& other) const = default;
 
 	// Remaining comparison operators are server by color::Rgb<D> and implicit type conversion
 
@@ -191,13 +191,13 @@ class RgbStacked
 	T value_{0};
 };
 
-using Rgb565 = RgbStacked<5,6,5>;
-using Rgb666 = RgbStacked<6,6,6>;
+using Rgb565 = RgbPallete<5,6,5>;
+using Rgb666 = RgbPallete<6,6,6>;
 
 #if __has_include(<modm/io/iostream.hpp>)
 #include <modm/io/iostream.hpp>
 
-template<ColorRgbStacked C>
+template<ColorRgbPallete C>
 IOStream&
 operator<<(IOStream& os, const C& rgb)
 {