Button_Round

Beschreibung

Button_Round Objekte sind Buttons mit einer runden Form. Sie unterscheiden sich von anderen Buttons jediglich hinsichtlich ihres Aussehens.

Beispielbilder

Diese Bilder dienen nur der Veranschaulichung, wie Objekte dieser Klasse aussehen können.

new Button_Round("Hello World", COLOR_DARK_YELLOW, 1, TML_empty_button)

new Button_Round("", COLOR_GREEN, 50, TML_empty_button)

Funktionen

	RoundButton (const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr)
	RoundButton (const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr)
	~RoundButton ()
void	draw () override
void	setTouch (Inputs& input) override
uint16_t	getHeight ()
uint16_t	getWidth ()
uint16_t	getMidX ()
uint16_t	getMidY ()
bool	checkSize (uint16_t sizeX, uint16_t sizeY, uint8_t rotation) override

Variablen und Konstanten

const Color	color
Item*	itemOn
Item*	itemOff
const	d

Funktionen Beschreibung

Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value=nullptr)

Button_Round::Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value):
    Button(button_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(itemOn, color.getItemColor())),
    itemOff(Display::createItem(itemOff, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Button (keinen Switch) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Item für die aktivierte (itemOn) und deaktivierte (itemOff) Form des Buttons, eine Farbe (color), die Breite der Umrandung (borderSize), eine Button Callback Funktion (button_callback) (siehe button_callback), sowie dem value, der angibt, ob der Button aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit itemOn und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit ItemOff und color.getItemColor().

Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value=nullptr)

Button_Round::Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, ExternalButtonValue* const value):
    Button(button_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(item, color.getItemColor())),
    itemOff(Display::createItem(item, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Button (keinen Switch) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Items, welche für sowohl die aktivierte und deaktivierte Form des Buttons verwendet wird (item), eine Farbe (color), die Breite der Umrandung (borderSize), eine Button Callback Funktion (button_callback) (siehe button_callback), sowie dem value, der angibt, ob der Button aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit item und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit item und color.getItemColor().

Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr)

Button_Round::Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value):
    Button(button_callback, longpress_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(itemOn, color.getItemColor())),
    itemOff(Display::createItem(itemOff, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Button (keinen Switch) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Item für die aktivierte (itemOn) und deaktivierte (itemOff) Form des Buttons, eine Farbe (color), die Breite der Umrandung (borderSize), eine Button Callback Funktion (button_callback) (siehe button_callback), eine Longpress Callback Funktion (longpress_callback) (siehe longpress_callback), sowie dem value, der angibt, ob der Button aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit itemOn und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit ItemOff und color.getItemColor().

Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr);

Button_Round::Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void()> button_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value):
    Button(button_callback, longpress_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(item, color.getItemColor())),
    itemOff(Display::createItem(item, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Button (keinen Switch) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Items, welche für sowohl die aktivierte und deaktivierte Form des Buttons verwendet wird (item), eine Farbe (color), die Breite der Umrandung (borderSize), den gewünschten Krümmungsradius der Ecken (borderRadius), eine Button Callback Funktion (button_callback) (siehe button_callback), eine Longpress Callback Funktion (longpress_callback) (siehe longpress_callback), sowie dem value, der angibt, ob der Button aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit item und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit Item und color.getItemColor().

Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value=nullptr);

Button_Round::Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value):
    Button(switch_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(itemOn, color.getItemColor())),
    itemOff(Display::createItem(itemOff, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Switch (keinen Button) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Item für die aktivierte (itemOn) und deaktivierte (itemOff) Form des Switches, eine Farbe (color), die Breite der Umrandung (borderSize), den gewünschten Krümmungsradius der Ecken (borderRadius), eine Switch Callback Funktion (switch_callback) (siehe switch_callback), sowie dem value, der angibt, ob der Switch aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit itemOn und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit ItemOff und color.getItemColor().

Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value=nullptr);

Button_Round::Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, ExternalButtonValue* const value):
    Button(switch_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(item, color.getItemColor())),
    itemOff(Display::createItem(item, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Switch (keinen Button) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Items, welche für sowohl die aktivierte und deaktivierte Form des Switches verwendet wird (item), eine Farbe (color), die Breite der Umrandung (borderSize), den gewünschten Krümmungsradius der Ecken (borderRadius), eine Switch Callback Funktion (switch_callback) (siehe switch_callback), sowie dem value, der angibt, ob der Switch aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit item und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit Item und color.getItemColor().

Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr);

Button_Round::Button_Round(const char* itemOn, const char* itemOff, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value):
    Button(switch_callback, longpress_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(itemOn, color.getItemColor())),
    itemOff(Display::createItem(itemOff, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Switch (keinen Button) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Item für die aktivierte (itemOn) und deaktivierte (itemOff) Form des Switches, eine Farbe (color), die Breite der Umrandung (borderSize), den gewünschten Krümmungsradius der Ecken (borderRadius), eine Switch Callback Funktion (switch_callback) (siehe switch_callback), eine Longpress Callback Funktion (longpress_callback) (siehe longpress_callback), sowie dem value, der angibt, ob der Button aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit itemOn und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit ItemOff und color.getItemColor().

Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value=nullptr);

Button_Round::Button_Round(const char* item, const Color& color, const uint8_t borderSize, const std::function<void(bool)> switch_callback, const std::function<void()> longpress_callback, ExternalButtonValue* const value):
    Button(switch_callback, longpress_callback, value),
    color(color),
    borderSize(borderSize),
    itemOn(Display::createItem(item, color.getItemColor())),
    itemOff(Display::createItem(item, color.getSecondaryItemColor()))
    {}

Diese Funktion ist ein Konstruktor, der einen runden Switch (keinen Button) erzeugt. Als Parameter nimmt der Konstruktor einen String für ein Erzeugung eines Items, welche für sowohl die aktivierte und deaktivierte Form des Switches verwendet wird (item), eine Farbe (color), die Breite der Umrandung (borderSize), den gewünschten Krümmungsradius der Ecken (borderRadius), eine Switch Callback Funktion (switch_callback) (siehe switch_callback), eine Longpress Callback Funktion (longpress_callback) (siehe longpress_callback), sowie dem value, der angibt, ob der Switch aktiviert ist oder nicht.

In der Initialisierungsliste wird zum einen dieser Button Konstruktor aufgerufen, zum anderen erfolgt die Initialisierung von color und borderSize mit den korrespondierenden Parametern. Für die Initialisierung von itemOn erfolgt ein Funktionsaufruf von createItem mit item und color.getItemColor() und für itemOff erfolgt ebenfalls ein Funktionsaufruf von createItem, aber diesmal mit Item und color.getItemColor().

~RoundButton ()

Button_Round::~Button_Round () {
    delete itemOn;
    delete itemOff;
}

Der Destruktor wird bei der Zerstörung eines RoundButton Objektes aufgerufen. Mit delete wird der von Speicherplatz von „itemOn“ und „itemOff“ wieder freigegeben.

void draw () override

void Button_Round::draw() {
    // uint16_t d = std::min(sizeX, sizeY) * 0.9;
 
    if (value){
        display->circle(posX + sizeX/2, posY + sizeY/2, d, borderSize, color.getBorderColor(), color);

        if (itemOn) display->drawItem(posX + sizeX/2, posY + sizeY/2, itemOn, color.getItemColor());
        else LOGGER_ERROR("itemOn ist nicht gültig!")
    } else {
        display->circle(posX + sizeX/2, posY + sizeY/2, d, borderSize, color.getSecondaryBorderColor(), color.getSecondaryColor());
        
        if (itemOff) display->drawItem(posX + sizeX/2, posY + sizeY/2, itemOff, color.getSecondaryItemColor());
        else LOGGER_ERROR("itemOff ist nicht gültig!")
    }
}

Diese Funktion ist verantwortlich für das Zeichnen des RoundButton Objektes.

    if (value){
        display->circle(posX + sizeX/2, posY + sizeY/2, d, borderSize, color.getBorderColor(), color);

        if (itemOn) display->drawItem(posX + sizeX/2, posY + sizeY/2, itemOn, color.getItemColor());

Sollte value==true gelten, also sollte der Button aktiviert sein, wird die circle Funktion des display aufgerufen, um einen Kreis zu zeichen. Die Parameter posX + sizeX/2 und posY + sizeY/2 lassen das Objekt an der gewünschten stelle erscheinen, für die Umrandungsfarbe rufen wir die getBorderColor Funktion von color und als die Füllfarbe des Buttons verwenden wir color. Falls itemOn==true gelten sollte, zeichnen wir dieses Item direkt. Dazu rufen wir die „drawItem“ Funktion auf und übergeben als Parameter u.a. besagtes Item (itemOn) sowie die Farbe des Items, welche mit getItemColor erhalten wird.

    } else {
        display->circle(posX + sizeX/2, posY + sizeY/2, d, borderSize, color.getSecondaryBorderColor(), color.getSecondaryColor());
        
        if (itemOff) display->drawItem(posX + sizeX/2, posY + sizeY/2, itemOff, color.getSecondaryItemColor());
        else LOGGER_ERROR("itemOff ist nicht gültig!")

Sollte value==false gelten, also sollte der Button deaktiviert sein, wird ebenso die circle Funktion des display aufgerufen, um einen Kreis zu zeichen. Nur diesmal übergeben wir das Ergebnis der Funktionsaufrufe von getSecondaryBorderColor und getSecondaryColor für die Umrandungs- bzw- Füllfarbe. Außerdem wird geprüft, ob itemOff==true gelten sollte. Falls dies der Fall ist, wird itemOff gezeichnet. Die Vorgehensweise ist die selbe wie weiter oben, nur übergeben wir diesmal das itemOff und übergeben die Farbe, die nach dem Funktionsaufruf von getSecondaryBorderColor bestimmt wird.

uint16_t getHeight()

uint16_t Button_Round::getHeight(){
    return sizeX;
}

Diese Funktion gibt die Höhe (also die Größe in X-Richtung) des Objektes zurück.

uint16_t getWidth()

uint16_t Button_Round::getWidth(){
    return sizeY;
}

Diese Funktion gibt die Breite (also die Größe in Y-Richtung) des Objektes zurück.

uint16_t getMidX()

    uint16_t getMidX() const { return posX + sizeX/2; }

Diese Funktion gibt den Mittelpunkt der X-Ausprägung des Objektes zurück.

uint16_t getMidY()

    uint16_t getMidY() const { return posY + sizeY/2; }

Diese Funktion gibt den Mittelpunkt der Y-Ausprägung des Objektes zurück.

void setTouch(Inputs& input) override

void Button_Round::setTouch(Inputs& input) {
    uint16_t d = std::min(sizeX, sizeY);
    const uint16_t xr = posX + sizeX/2 - d/2;
    const uint16_t yr = posY + sizeY/2 - d/2;
    const uint16_t xl = posX + sizeX/2 + d/2;
    const uint16_t yl = posY + sizeY/2 + d/2;
    if (input.touchX > xr && input.touchX < xl && input.touchY > yr && input.touchY < yl) Button::setTouch(input);
    else LOGGER_PATTERN("Touch punkt bei Runden Button liegt außerhalb: _<_<_, _<_<_", xr, input.touchX, xl, yr, input.touchY, yl)
}

Mit dieser Funktion wird bestimmt, ob das Objekt berührt wird oder nicht.

    uint16_t d = std::min(sizeX, sizeY);

Zuerst wird der Durchmesser des Kreises bestimmt, indem das Minimum aus sizeX und sizeY gewählt wird. So wird sichergestellt, dass wir uns innerhalb der Kreisform befinden.

    const uint16_t xr = posX + sizeX/2 - d/2;
    const uint16_t yr = posY + sizeY/2 - d/2;
    const uint16_t xl = posX + sizeX/2 + d/2;
    const uint16_t yl = posY + sizeY/2 + d/2;

Anschließend werden zwei Punkte berechnet. Das Koordinatenpaar xr und yr entspricht dem Punkt in der Mitte des Kreises, x1 und y1 ist ein beliebiger Punkt auf dem Rand des Kreises.

    if (input.touchX > xr && input.touchX < xl && input.touchY > yr && input.touchY < yl) Button::setTouch(input);

Nun wird getestet, ob die Toucheingabe innerhalb dieses Bereiches stattfindet, indem die berechneten Punkte mit input.touchX und input.touchY verglichen werden. Wenn das zutrifft, wird setTouch der Button Klasse aufgerufen.

bool checkSize (uint16_t sizeX, uint16_t sizeY, uint8_t rotation) override;

bool Button_Round::checkSize(uint16_t sizeX, uint16_t sizeY, uint8_t rotation) {
    // TODO: anpassen
    d = std::min(sizeX, sizeY) * scale;
    uint16_t tmp = std::sqrt((d-borderSize) * (d-borderSize) / 2.0);
    itemOn->setResolution(tmp, tmp);
    itemOff->setResolution(tmp, tmp);

    return sizeX > 30 && sizeY > 30;
}

Diese Funktion überprüft, ob Objekte der Button_Round Klasse zeichenbar sind, oder zu klein sind, um sie anzuzeigen. Außerdem legt sie Auflösung bzw. Größe von itemOn und itemOff auf dem Objekt fest. Die Parameter der Funktion sind die Höhe (sizeY) und Breite des Objektes (sizeX).

    d = std::min(sizeX, sizeY) * scale;

Zuerst wird der Durchmesser des Kreises bestimmt, indem das Minimum aus sizeX und sizeY gewählt wird. Dieses wird mit dem Skalierungsfaktor scale multipliziert, um die gewünschte Größe zu erhalten.

    uint16_t tmp = std::sqrt((d-borderSize) * (d-borderSize) / 2.0);

Nun wird die Variable tmp erstellt, die den Durchmesser des Kreisinhalts (also ohne Umrandung) speichert.

    itemOn->setResolution(tmp, tmp);
    itemOff->setResolution(tmp, tmp);

Basierend auf tmp wird nun für itemOn und itemOff mit setResolution die Auflösung bzw. Größe berechnet.

    return sizeX > 30 && sizeY > 30;

Sollte jedoch sizeX > 30 && sizeY > 30 nicht gelten, so ist das Objekt nicht groß genug, um es auf dem Display anzuzeigen. Die Funktion gibt false zurück.

Variablen und Konstanten Beschreibung

const Color color

Die Farbe (Color) des Objektes.

const uint8_t borderSize

Gibt an, wie dick die Umrandung ist.

Item* itemOn = nullptr

Das Item (Item), das auf dem Objekt im angeschalteten Zustand angezeigt wird.

Item* itemOff = nullptr

Das Item (Item), das auf dem Objekt im ausgeschalteten Zustand angezeigt wird.

const uint16_t d

Gibt den Durchmesser des Kreises (also der Grundform des Objeketes) an.

const double scale = 0.9

Der Skalierungsfaktor, der die Größe des Kreises beeinflusst.