TouchMenuLib

Beschreibung

TouchMenuLib arbeitet als Schnittstelle, verwaltet das Menü und kommuniziert mit dem Nutzer.

Funktionen

	TouchMenuLib (Display* disp)
	TouchMenuLib ()
	~TouchMenuLib ()
void	init (uint8_t rotation = 1)
void	add (uint8_t id, Screen* screen)
void	add (const uint8_t id, Screen* screen, const uint8_t sitebarID)
void	addSidebar (const uint8_t id, Screen* sidebar, uint16_t size, uint8_t site = 0)
void	loop ()
void	draw ()
void	back (const uint8_t i = 1)
bool	goTo (const uint8_t id, const bool toHistory = true)
void	setInputEnter ()
void	setInputRight ()
void	setInputLeft ()
void	setInputUp ()
void	setInputDown ()
void	setScreenSaver (const uint8_t screenID, unsigned long time, bool backOnInput = true)
bool	enableScreenSaver ()
void	disableScreenSaver ()
Display&	getDisplay ()
uint8_t	getScreenID ()
void	getScreensNumber ()

Variablen und Konstanten

std::map<uint8_t, std::unique_ptr<Screen>>	screens
std::stack<uint8_t>	screenHistory
std::map<uint8_t, std::unique_ptr<Screen>>	sidebars
std::map<uint8_t, uint8_t>	sidebarConnector
uint8_t	currentSidebar = UINT8_MAX
bool	deactivateSidebar = false
Display*	display
bool	isDisplayInit = false
Inputs	input
bool	screensaverBackOnInput = false
bool	isScreensaverEnable = false
unsigned long	screensaverTime = 0
unsigned long	screensaverTimer = 0
uint8_t	screensaverID = UINT8_MAX
unsigned long	inputTimer = 0
bool	updateAll = true
bool	disableSidebarAutomatic = false

Funktionen Beschreibung

TouchMenuLib (Display* disp)

TouchMenuLib::TouchMenuLib (Display* disp): 
    display(disp) 
    {}

Der Konstruktor wird bei der Erzeugung eines neuen Objekts der TouchMenuLib Klasse aufgerufen. Er erhält einen Pointer disp auf ein Display Objekt als Parameter. Das Member display wird mit dem von disp übergebenen Wert initialisiert.

TouchMenuLib ()

TouchMenuLib::TouchMenuLib (): 
    display(new DisplayTFTeSPI())
    {}

Der Konstruktor ruft den TouchMenuLib Konstruktor auf, in dem er ein neues DisplayTFTeSPI Objekt erstellt.

~TouchMenuLib ()

TouchMenuLib::~TouchMenuLib (){
    delete display;
}

Der Destruktor wird bei der Zerstörung eines TouchMenuLib Objektes aufgerufen. Er gibt den Speicher frei, welcher vom display belegt wurde.

void init (uint8_t rotation = 1)

void TouchMenuLib::init(uint8_t rotation) {
    display->init();
    display->setRotation(rotation);
    isDisplayInit = true;
    LOGGER("Touch Menu is initialized")
}

Diese Funktion ist verantwortlich für dir Initialisierung des Displays. Zuerst wird die init Funktion des display aufgerufen, um die Initialisierung zu beginnen. Ebenso wird setRotation aufgerufen, um die Bildschirmausrichtung (rotation) einzustellen. Nach Abschluss der Initialisierung wird isDisplayInit auf true gesetzt. Dieser Flag ermöglicht es, den Status der Display-Initialisierung zu verfolgen.

void add (uint8_t id, Screen* screen)

void TouchMenuLib::add (const uint8_t id, Screen* screen) {

    if (!isDisplayInit) init();

    if (!screen) {
        LOGGER_ERROR("screen Pointer ist NULL")
        return;
    }

    screen->setDisplay(display);

    std::unique_ptr<Screen> uptr (screen);
    screens[id] = std::move(uptr);

    screen->setResolution(display->getWidth(), display->getHeight());
    
    // der erste Screen, den man hinzufügt wird auch als Homescreen genutzt
    if (screenHistory.empty()) {
        screenHistory.push(id);
    }
}

Diese Funktion ermöglicht das Hinzufügen eines neuen Screens mit einer id zur eigenen Anwendung.

    if (!isDisplayInit) init();

    if (!screen) {
        LOGGER_ERROR("screen Pointer ist NULL")
        return;
    }

Zuerst wird überprüft, ob das Display bereits initialisiert wurde (siehe init). Anschließend wird überprüft, ob der übergebene Screens Pointer gültig ist. Zeigt der Pointer auf keine Speicheradresse, kehrt die Funktion vorzeitig zurück.

    screen->setDisplay(display);

Hier wird die Funktion setDisplay des übergebenen Screens aufgerufen, um das display Objekt diesem Screen zuzuweisen.

    std::unique_ptr<Screen> uptr (screen);
    screens[id] = std::move(uptr);

Zunächst wird ein Smart Pointer in der Form eines unique_ptr's erstellt, der auf den übergebenen Screen zeigt. Dieser „besitzt“ und managt den Screen und entsorgt diesen, wenn er out of scope geht. Anschließend wird der unique_ptr in ein Array verschoben, welches alle vorhandenen Screens speichert. Die id dient hierbei als eine Art Schlüssel, um die Screens identifizieren zu können.

    screen->setResolution(display->getWidth(), display->getHeight());

Es folgt ein Funktionsaufruf von setResolution, um die Auflösung des hinzugefügten Bildschirms an das Display anzupassen.

    if (screenHistory.empty()) {
        screenHistory.push(id);
    }

Bei std::stack<uint8_t> screenHistory; handelt es sich um einen Stack, der die tatsächliche Reihenfolge der Screens bei der Benutzung speichert. Ist dieser Stack leer, wird der erste Screen, der hinzugefügt wird zum Homescreen. Der Homescreen erhält das screenHistoryLeveL = 1.

void add (const uint8_t id, Screen* screen, const uint8_t sitebarID)

void TouchMenuLib::add (const uint8_t id, Screen* screen, const uint8_t sitebarID) {
    if (!screen) return;
    // LOGGER("Füge neuen Schreen + Sitebar hinzu")
    add (id, screen);
    if (sitebars.count(sitebarID) == 0) {
        LOGGER_ERROR_PATTERN("Sitebar id _ doesn't exists", sitebarID)
        return;
    }
    
    Screen* sitebar = sitebars[sitebarID].get();
    
    // calculate the size of the Screen
    uint16_t w = (sitebar->getResolutionWidth() == display->getWidth()) ? display->getWidth() : display->getWidth() - sitebar->getResolutionWidth();
    uint16_t h = (sitebar->getResolutionHeight() == display->getHeight()) ? display->getHeight() : display->getHeight() - sitebar->getResolutionHeight();
    uint16_t x = (sitebar->getOffsetX() == 0 && w != display->getWidth()) ? sitebar->getResolutionWidth() : 0;
    uint16_t y = (sitebar->getOffsetY() == 0 && h != display->getHeight()) ? sitebar->getResolutionHeight() : 0;

    // LOGGER_PATTERN("Berechnete größen: x:_, y:_, w:_, h:_", x, y, w, h)
    
    screens[id].get()->setResolution(w, h);
    screens[id].get()->setOffsetPosition(x, y);

    sitebarConnector[id] = sitebarID;
}

Mit dieser Funktion lässt sich ein neuer Screens (screen) mit id und einer Sidebar hinuzfügen.

    if (!screen) return;

Ist screen der nullptr, wird die Funktion abgebrochen, weil sich der screen nicht dem TouchMenuLib Objekt hinzufügen lässt.

    add (id, screen);

Anschließend wird die add Funktion aufgerufen, um den Screen hinzuzufügen.

    if (sitebars.count(sitebarID) == 0) {
        LOGGER_ERROR_PATTERN("Sitebar id _ doesn't exists", sitebarID)
        return;
    }

Hier wird geprüft, ob die Sidebar ID existiert.

    Screen* sitebar = sitebars[sitebarID].get();

Wenn sie existiert, wird ein Pointer auf diese sidebarID innerhalb von sitebars gepseichert.

    uint16_t w = (sitebar->getResolutionWidth() == display->getWidth()) ? display->getWidth() : display->getWidth() - sitebar->getResolutionWidth();
    uint16_t h = (sitebar->getResolutionHeight() == display->getHeight()) ? display->getHeight() : display->getHeight() - sitebar->getResolutionHeight();
    uint16_t x = (sitebar->getOffsetX() == 0 && w != display->getWidth()) ? sitebar->getResolutionWidth() : 0;
    uint16_t y = (sitebar->getOffsetY() == 0 && h != display->getHeight()) ? sitebar->getResolutionHeight() : 0;

Nun werden Breite (w), Höhe (h) des Screens sowie seine X-Koordinate (x) und Y-Koordinate(y) berechnet, sodass später nichts von der Sidebar bedeckt wird.

    screens[id].get()->setResolution(w, h);
    screens[id].get()->setOffsetPosition(x, y);

Nun wird die Auflösung und Position des Screens mit setResolution bzw. setResolution angepasst.

    sitebarConnector[id] = sitebarID;

Zum Schluss wird sidebarID in sidebarConnector gespeichert.

void addSidebar (const uint8_t id, Screen* sidebar, uint16_t size, uint8_t site = 0)

void TouchMenuLib::addSitebar (const uint8_t id, Screen* sitebar, uint16_t size, uint8_t site) {
    // LOGGER("füge neue Sitebar hinzu")
    if (!isDisplayInit) init();

    if (!sitebar) {
        LOGGER_ERROR("screen Pointer ist NULL")
        return;
    }

    sitebar->setDisplay(display);

    std::unique_ptr<Screen> uptr (sitebar);
    sitebars[id] = std::move(uptr);

    // LOGGER("berechne größen")

    // Sitebar is up
    if (site == 0  || site > 3) {
        sitebar->setResolution(display->getWidth(), size);
        sitebar->setOffsetPosition(0, 0);

    // Sitebar is right
    } else if (site == 1) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(display->getWidth()-size, 0);

    // Sitebar is down
    } else if (site == 2) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(0, display->getHeight()-size);

    // Sitebar is left
    } else if (site == 3) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(0, 0);
    }
}

Mit dieser Methode wird eine neue Sidebar einem vorhandenen Screen hinzugefügt.

    if (!isDisplayInit) init();

Dafür wird sichergestellt, dass das Display initialisiert wurde bzw. wird (init).

    if (!sitebar) {
        LOGGER_ERROR("screen Pointer ist NULL")
        return;
    }

Außerdem wird geprüft, ob die angegebene Sidebar sidebar auch existiert und nicht der nullptr ist.

    sitebar->setDisplay(display);

Nun wird die setDisplay Funktion auf der sidebar aufgerufen, um sie dem display hinzuzufügen.

    std::unique_ptr<Screen> uptr (sitebar);
    sitebars[id] = std::move(uptr);

Zunächst wird ein Smart Pointer in der Form eines unique_ptr's erstellt, der auf sidebar zeigt. Dieser „besitzt“ und managt die und entsorgt diesen, wenn er out of scope geht. Anschließend wird der unique_ptr in ein Array verschoben, welches alle vorhandenen Sidebars speichert (sidebars). Die id dient hierbei als eine Art Schlüssel, um die Sidebars identifizieren zu können.

    if (site == 0  || site > 3) {
        sitebar->setResolution(display->getWidth(), size);
        sitebar->setOffsetPosition(0, 0);

    // Sitebar is right
    } else if (site == 1) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(display->getWidth()-size, 0);

    // Sitebar is down
    } else if (site == 2) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(0, display->getHeight()-size);

    // Sitebar is left
    } else if (site == 3) {
        sitebar->setResolution(size, display->getHeight());
        sitebar->setOffsetPosition(0, 0);
    }

Nun wird bestimmt, an welcher Bildschirmseite die Sidebar erscheinen soll. Das lässt sich mit site festlegen. Bei site = 0 und allen Werten >3 befindet sich diese auf der oberen Seite. Für size = 1 auf der rechten, für size = 2 auf der unteren und für size = 3 auf der linken Seite.

void loop ()

void TouchMenuLib::loop(){

    if (updateAll) {
        // if (currentSitebar == UINT8_MAX) LOGGER_PATTERN("zeichne Screen _ und keine Sitebar", screenHistory.top())
        // else LOGGER_PATTERN("zeichne Screen _ und Sitebar _", screenHistory.top(), currentSitebar)
        draw();
        updateAll = false;
    }

    if (screens.size() == 0) {
        // LOGGER_ERROR("No Screen found")
        return;
    }

    // set touch coordinates 
    input.isTouched = display->getTouch(&input.touchX, &input.touchY);

    // touch input counter
    if (input.isTouched && inputTimer < millis()) {
        input.updateTouchPoint = true;
        // if (input.isTouched) display->circle(input.touchX, input.touchY, 4, 0, COLOR_BLACK, COLOR_BLACK);
        inputTimer = millis() + TOUCH_INPUT_TIMER;
    }

    // reset Screensaver time on input
    if (isScreensaverEnable && screensaverTimer != 0 && input.hasInput()) 
        screensaverTimer = millis() + screensaverTime;

    // too long inactivity, go to the screensaver screen 
    if (isScreensaverEnable && screensaverTimer > 0 && screensaverTimer < millis()) {
        LOGGER("go to Screensaver Screen")
        goTo(screensaverID);
        screensaverTimer = 0;
        return;
    }

Diese Funktion dient dazu, den Zustand des Objektes zu aktualisieren.

    if (updateAll) {
        // if (currentSitebar == UINT8_MAX) LOGGER_PATTERN("zeichne Screen _ und keine Sitebar", screenHistory.top())
        // else LOGGER_PATTERN("zeichne Screen _ und Sitebar _", screenHistory.top(), currentSitebar)
        draw();
        updateAll = false;

Zuerst wird geprüft, ob updateAll true ist. Wenn ja, wird draw aufgerufen und ausgeführt, um alle Screens neu zu zeichnen, ehe updateAll auf false gesetzt wird

    if (screens.size() == 0) {
        // LOGGER_ERROR("No Screen found")
        return;
    }

Sollten keine Screens existieren, wird die Funktion abgebrochen.

    input.isTouched = display->getTouch(&input.touchX, &input.touchY);

Nun wird in input.isTouched gespeichert, ob display berührt wird. Dafür werden input.touchX und input.touchY an die getTouch des display gegeben.

    if (input.isTouched && inputTimer < millis()) {
        input.updateTouchPoint = true;
        // if (input.isTouched) display->circle(input.touchX, input.touchY, 4, 0, COLOR_BLACK, COLOR_BLACK);
        inputTimer = millis() + TOUCH_INPUT_TIMER;
    }

Wenn eine Berührung stattfindet und inputTimer geringer als die seit Start vergangenen Millisekunden (siehe millis()) sind, wird input.updateTouchPoint auf true gesetzt und dem inputTimer wird ein neuer Wert zugewiesen. TOUCH_INPUT_TIMER ist ein Macro, welches standardmäßig 300 beträgt. Der input.updateTouchPoint wird also frühstens nach 300 Millisekunden wieder aktualisiert werden können, d.h. erst dann werden neue Eingaben registriert.

    if (isScreensaverEnable && screensaverTimer != 0 && input.hasInput()) 
        screensaverTimer = millis() + screensaverTime;

Mit diesem Codeblock wird der screensaverTimer nach einem gültigen Input resettet. Das ist für den nächsten Absatz relevant.

    if (isScreensaverEnable && screensaverTimer > 0 && screensaverTimer < millis()) {
        LOGGER("go to Screensaver Screen")
        goTo(screensaverID);
        screensaverTimer = 0;
        return;
    }

Denn hier wird nach einer zu langen Inaktivitätszeit der Bildschirmschoner aufgerufen, screensaverTimer wird auf 0 gesetzt und die Funktion wird beendet.

    if (isScreensaverEnable && input.hasInput() && screensaverTimer == 0) {
        LOGGER("reset Screensaver timer")
        screensaverTimer = millis() + screensaverTime;

Sollte ein Input vorgenommen werden, während der Screensaver aktiv ist, so wird dieser wieder verlassen und der screensaverTimer startet erneut.

        if (screensaverBackOnInput) {
            back();
            return;
        }
    }

Sollte screensaverBackOnInput aktiviert sein, so wird back aufgerufen und der letzte Screen vor Einsetzen des Bildschirmschoners wird wieder angezeigt.

    screens[screenHistory.top()]->loop(input);

Es erfolgt ein rekursiver Aufruf dieser loop Funktion mit dem Screen, welcher an höchster Stelle des Stacks liegt (screenHistory.top). Dadurch wird der aktuelle Screen aktualisiert.

    if (input.back > 0) back(input.back);

Sollte input.back > 0 sein, rufen wir mit back den Screen mit der entsprechenden ID auf.

    else if (input.update) {
        LOGGER("Zeichne Screen neu")
        screens[screenHistory.top()]->draw();
        input.update = false;
    }

Andernfalls wird überprüft, ob input.update true ist. Dann zeichnen wir die Änderungen und setzen input.update wieder auf false.

    if (currentSitebar != UINT8_MAX) {
        sitebars[currentSitebar]->loop(input);
        if (input.back > 0) back(input.back);
        else if (input.update) {
            LOGGER("Zeichne Sitebar neu")
            sitebars[currentSitebar]->draw();
        }
    }

Mit diesem Codeblock werden Sidebars neugezeichnet, sollten Änderungen vorliegen. Sollte currentSitebar = UINT8_MAX, so wird die Bedingung zum zeichnen nicht erfüllt. UINT8_MAX ist ein Platzhalter Wert, der in draw Sidebars zugewiesen wird, denen kein Screen zugewiesen werden kann. Die restliche Vorgehensweise ähnelt dem vorherigen Abschnitt sehr und braucht daher keine weitere Erläuterung.

    input.reset();

Zum Schluss wird input.reset aufgerufen. Alle Inputs und Änderungen wurden erfolgreich verarbeitet.

void draw()

void TouchMenuLib::draw() {
    // LOGGER("Zeichne Menu")
    if (screenHistory.empty()) return;
    screens[screenHistory.top()]->draw(); // draw current Screen

    if (!disableSitebarAutomatic && sitebarConnector.count(screenHistory.top()) != 0) 
        currentSitebar = sitebarConnector[screenHistory.top()];
    
    if (!disableSitebarAutomatic && sitebarConnector.count(screenHistory.top()) == 0)
        currentSitebar = UINT8_MAX;
    
    // if sitebar is available, draw this too
    if (currentSitebar != UINT8_MAX)
        sitebars[currentSitebar]->draw();
}

Diese Funktion dient dazu, den aktuellen Screen (und wenn vorhanden auch Sidebars) auf dem Display anzuzeigen.

    if (screenHistory.empty()) return;

Sollten (noch) keine Screens existieren (siehe ScreenHistoryLevel), wird die Funktion sofort verlassen.

    screens[screenHistory.top()]->draw(); // draw current Screen

Andernfalls wird die draw Funktion des aktuell angezeigten Screens aufgerufen (dieser befindet sich an oberster Stelle des screenHistory Stacks).

    if (!disableSitebarAutomatic && sitebarConnector.count(screenHistory.top()) != 0) 
        currentSitebar = sitebarConnector[screenHistory.top()];

Sollte disableSidebarAutomatic false sein und sollte es eine Sidebar für den aktuellen Screen geben, so erhält currentSidebar die entsprechende ID.

    if (!disableSitebarAutomatic && sitebarConnector.count(screenHistory.top()) == 0)
        currentSitebar = UINT8_MAX;

Hat der aktuelle Screen jedoch keine Sidebar und disableSidebarAutomatic ist weiterhin false, so wird currentSidebar UINT8_MAX zugewiesen, da es für diese Sidebar keinen basenden Screen und somit keine passende ID gibt. Das ganze ist eine Art Platzhalter Wert.

    if (currentSitebar != UINT8_MAX)
        sitebars[currentSitebar]->draw();
}

Ist ref:currentSidebar<touchmenulibvcurrentsidebar> nicht UINT8_MAX, so wird sie mit currentSidebar draw gezeichnet.

void back(const uint8_t i = 1)

void TouchMenuLib::back(const uint8_t i){
    LOGGER("go back")
    // TODO: gehe max. bis zum Homescreen (erstes Element im Stack zurück)
    for(int j = i; j > 0 && screenHistory.size() > 1; j--) {
        screenHistory.pop();
    }
    updateAll = true;
}

Diese Funktion ermöglicht es, in der screenHistory i Schritte zurückzugehen, d.h. vorher bereits aufgerufene Screens erneut aufzurufen. Während der for-Schleife wird jeweils das oberste Element des Stacks entfernt, sodass der vorherige Screen nun an der Spitze des Stacks liegt. Das screenHistoryLevel wird um 1 verringert, da wir uns nach dem Entfernen des obersten Screens vom Stack eine Ebene tiefer befinden, als vorher. Nach dem i-ten Schleifendurchlauf, wird updateAll auf true gesetzt.

bool goTo (const uint8_t id, const bool toHistory = true)

bool TouchMenuLib::goTo(const uint8_t id, const bool toHistory){
    LOGGER_PATTERN("goTo Screen _", id)
    if (screens.count(id) == 0) return false;

    if (!toHistory) screenHistory.pop();
    screenHistory.push(id);
    updateAll = true;
    return true;
}

Diese Funktion ermöglicht es, zu einem bestimmten Screen innerhalb der screenHistory zu navigieren.

    if (screens.count(id) == 0) return false;

Wenn die übergebene ID in screens nicht gefunden werden kann, existiert kein Screen mit dieser ID und die Funktion gibt false zurück.

    if (!toHistory) screenHistory.pop();

Wenn der übergebene bool toHistory auf false gesetzt ist, wird der aktuelle Screen aus der screenHistory entfernt. Des ist nützlich, falls, man keinen neuen Screen auf dem screenHistory Stack speichern will.

    screenHistory.push(id);
    updateAll = true;
    return true;
}

Wenn der toHistory jedoch auf true gesetzt ist, wird das screenHistoryLevel um 1 erhöht, die übergebene ID auf den Stack an oberster Stelle gespeichert und anschließend wird updateAll

void setInputEnter()

void TouchMenuLib::setInputEnter(){
    input.enter = true;
}

Diese Funktion setzt enter des inputs auf true.

void setInputRight()

void TouchMenuLib::setInputRight(){
    input.right = true;
}

Diese Funktion setzt right des inputs auf true.

void setInputLeft()

void TouchMenuLib::setInputLeft(){
    input.left = true;
}

Diese Funktion setzt left des inputs auf true.

void setInputUp()

void TouchMenuLib::setInputUp(){
    input.up = true;
}

Diese Funktion setzt up des inputs auf true.

void setInputDown()

void TouchMenuLib::setInputDown(){
    input.down = true;
}

Diese Funktion setzt down des inputs auf true.

void setScreensaver(const uint8_t screenID, unsigned long time, bool backOnInput = true)

void TouchMenuLib::setScreensaver(const uint8_t screenID, unsigned long time, bool backOnInput) {
    isScreensaverEnable = true;
    screensaverBackOnInput = backOnInput;
    screensaverID = screenID;
    screensaverTime = time;
    screensaverTimer = millis() + 2*screensaverTime;
}

Mit dieser Funktion lässt sich ein Bildschirmschoner erstellen, der nach einer bestimmten Zeit (time) einsetzt. Dabei ist screenID die ID, mit der sich der Screensaver aufrufen lässt und mit backOnInput wird angegeben, ob nach Ende des Bildschirmschoners der zuletzt aufgerufene Screen wieder angezeigt werden soll.

bool enableScreenSaver ()

bool TouchMenuLib::enableScreenSaver () {
    if (screensaverID != UINT8_MAX) isScreensaverEnable = true;
    return isScreensaverEnable;
}

Diese Funktion setzt isScreensaverEnable auf true, wenn eine ScreensaverID gesetzt wurde.

void disableScreenSaver ()

void TouchMenuLib::disableScreenSaver () {
    isScreensaverEnable = false;
}

Diese Funktion setzt isScreensaverEnable auf false und sorgt dafür, dass kein Bildschirmschoner mehr einsetzt.

Display& getDisplay()

Display& TouchMenuLib::getDisplay(){
    if (!isDisplayInit) init();
    return *display;
}

Diese Funktion gibt display zurück. Falls dieses noch nicht initialisiert war, wird es zuerst initialisiert.

uint8_t getScreenID()

uint8_t TouchMenuLib::getScreenID() {
    return screenHistory.top();
}

Gibt die ID des aktuellen Screens zurück.

uint8_t getScreensNumber()

uint8_t TouchMenuLib::getScreensNumber() {
    return screens.size();
}

Gibt die Anzahl an Screens in screens zurück.

Variablen und Konstanten Beschreibung

std::map<uint8_t, std::unique_ptr<Screen>> screens

Hierbei handelt es sich um eine Map, die Screens mit einer eindeutigen ID verknüpft.

std::stack<uint8_t> screenHistory;

In diesem Stack werden die IDs der Screens in ihrer Anzeigereihenfolge gespeichert. Der erste hier gespeicherte Screens, der Screen mit der ID 1, wird auch als Homescreen bezeichnet.

std::map<uint8_t, std::unique_ptr<Screen>> sitebars

Hierbei handelt es sich um eine Map, die Screens, die als Sidebar dienen, mit einer eindeutigen ID verknüpft.

std::map<uint8_t, uint8_t> sitebarConnector

Hier werden die IDs von Screens mit ihrer entsprechenden Sidebar gespeichert.

uint8_t currentSitebar = UINT8_MAX

Setzt die aktuelle Sidebar auf UINT8_MAX. Dies ist ein Platzhalterwert, der aussagt, dass die Sidebar keinem Screens zugewiesen ist.

bool deactivateSitebar = false

Mit deactivateSitebar = true lässt sich eine Sidebar deaktivieren. Ist standardmäßig auf deactivateSitebar = false, damit Sidebars (falls vorhanden) auch angezeigt werden.

Display* display

Ein Pointer auf ein Display Objekt.

bool isDisplayInit = false

Gibt an, ob das Display bereits initialisiert wurde. Standardmäßig ist dies nicht der Fall.

uint8_t screenHistoryLevel = 0

Gibt an, in welcher Ebene der screenHistory wir uns befinden. Standardmäßig befinden wir uns in der 0. Ebene, weil noch keine Screens existieren.

Inputs input;

Gibt Informationen zu den Eingaben des Benutzers an, wie z.B. bei Berührungen (siehe input )

bool screensaverBackOnInput = false

Gibt an, ob nach Ende des Bildschirmschoners (also wenn während der Bildschirmschoner aktiv ist ein Input durchgeführt wird), der vor Einsetzen des Bildschirmschoners aktive Screen angezeigt werden soll (screensaverBackOnInput = true) oder ob der Homescreen angezeigt werden soll (screensaverBackOnInput = false).

bool isScreensaverEnable = false

Gibt an, ob ein Bildschirmschoner nach einer gewissen Zeit einsetzen soll.

unsigned long screensaverTime = 0

Die Zeit in Millisekunden die vergehen muss, damit der Bildschirmschoner einsetzt.

unsigned long screensaverTimer = 0

Die Zeit in Millisekunden die bereits vergangen ist. Wird benötigt, um zu prüfen, wann screensaverTime erreicht wird.

uint8_t screensaverID = UINT8_MAX

Eine ID bzw. einzigartiger Schlüssel, um den Bildschirmschoner aufzurufen.

unsigned long inputTimer = 0

Gibt an, nach wie viele Millisekunden der letzte Input getätigt wurde. Das ist wichtig, um Eingaben besser und effizienter verarbeiten zu können.

bool disableSidebarAutomatic = false

Gibt an, ob eine Sidebar automatisch deaktivierbar sein soll (also ob diese ohne eigenes Wirken verschwinden soll). (Anmerkung: Derzeit ist keine Funktion implementiert, die dies könnte)

bool updateAll = true

Gibt an, ob Änderungen vorgenommen wurden. Wenn ja, wird in loop die draw Funktion aufgerufen, um all diese Änderungen zu zeichnen.