Implemented basic keyboard #18
@@ -34,282 +34,22 @@ class Keyboard
|
|||||||
|
|||||||
public:
|
public:
|
||||||
explicit Keyboard(TDisplay &display) : m_display(display) {}
|
explicit Keyboard(TDisplay &display) : m_display(display) {}
|
||||||
|
|
||||||
void start()
|
void start();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const auto isLandscape = espgui::isLandscape();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_keyboard_start_y = isLandscape ? 98 : 120;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
tft.fillRect(1, m_keyboard_start_y - 10, tft.width()-1, tft.height() - m_keyboard_start_y - (isLandscape ? 0 : 30), TFT_BLACK);
|
void buttonPressed(Button button);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawSunkenRect(1, m_keyboard_start_y - 10, tft.width()-1, tft.height() - m_keyboard_start_y - (isLandscape ? 0 : 30), TFT_WHITE, TFT_GREY, TFT_BLACK);
|
void buttonReleased(Button button);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
updateCharLength();
|
void moveSelectorUp();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
drawKeyboard();
|
void moveSelectorDown();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
void moveSelectorLeft();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void moveSelectorRight();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void buttonPressed(Button button)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
switch (button)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Right:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index < m_char_length)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_display.setShownValue(m_display.shownValue() + m_keyset[m_char_index]);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else if (m_char_index == m_char_length) // shift
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
nextScreen();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else if (m_char_index == m_char_length + 1) // space
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_display.setShownValue(m_display.shownValue() + " ");
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else if (m_char_index == m_char_length + 2) // backspace
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_display.removeLastCharFromShownValue();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else if (m_char_index == m_char_length + 3) // enter
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_display.confirmValue();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Left:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
popScreen();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
return;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Up:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
moveSelectorLeft();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
drawKeyboard(true);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Down:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
moveSelectorRight();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
drawKeyboard(true);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
default:;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void buttonReleased(Button button) {}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void moveSelectorUp()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_last_char_index = m_char_index;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index -= 10;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index < 0)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index = (m_char_length + 4) - m_char_index;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void moveSelectorDown()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_last_char_index = m_char_index;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index += 10;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index >= (m_char_length + 4))
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index = m_char_index - (m_char_length + 4);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void moveSelectorLeft()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_last_char_index = m_char_index;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == 0)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index = (m_char_length + 4) - 1;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index--;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void moveSelectorRight()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_last_char_index = m_char_index;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == (m_char_length + 4) - 1)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index = 0;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_index++;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
private:
|
private:
|
||||||
void updateCharLength()
|
void updateCharLength();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
std::string tmpstr;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
switch (m_current_screen)
|
void drawKeyboard(bool dont_draw_string = false);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Screen::SCREEN_1:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tmpstr = KEYBOARD_SCREEN_1;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Screen::SCREEN_2:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tmpstr = KEYBOARD_SCREEN_2;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
case Screen::SCREEN_3:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tmpstr = KEYBOARD_SCREEN_3;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
break;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
default:
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
ESP_LOGE(TAG, "Unknown screen");
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
return;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
m_keyboard = tmpstr;
|
void nextScreen();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
cpputils::stringReplaceAll(" ", "", tmpstr);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_char_length = tmpstr.length();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_keyset = tmpstr;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void drawKeyboard(bool dont_draw_string = false)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
size_t char_index{0};
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
std::string keyboard_screen{m_keyboard};
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
std::vector<std::string> keyboard_lines;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
for (size_t i = 0; i < keyboard_screen.size(); i += 10)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
std::string line = keyboard_screen.substr(i, 10);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (cpputils::stringEndsWith(line, " "))
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
line.pop_back();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
keyboard_lines.push_back(line);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const auto datum = tft.getTextDatum();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextDatum(MC_DATUM);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
for (size_t i = 0; i < keyboard_lines.size(); i++)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{ tft.setTextColor(TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_GREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int32_t y = m_keyboard_start_y + (i * tft.fontHeight() + 9);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
std::string line = keyboard_lines[i];
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int16_t x = tft.width() / (line.size() + 1);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
for (size_t j = 0; j < line.size(); j++)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const std::string _char{line[j]};
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int32_t x_pos = x * (j + 1);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int32_t y_pos = y;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const auto width = tft.textWidth(_char) + 2;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const auto height = tft.fontHeight() + 4;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (char_index == m_char_index)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(x_pos-width/2-1, y_pos-height/2, width+2, height-4, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (char_index == m_last_char_index)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(x_pos-width/2-1, y_pos-height/2, width+2, height-4, 3, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (!dont_draw_string || char_index == m_char_index || char_index == m_last_char_index)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (char_index == m_char_index || char_index == m_last_char_index)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(char_index == m_last_char_index ? TFT_GREY : TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(_char, x_pos, y_pos);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (char_index == m_char_index)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_GREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
char_index++;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextDatum(datum);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// draw 3 extra buttons, back, space and enter (x=10, x=tft.width()/2, x=tft.width()-10)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int32_t y = m_keyboard_start_y + (keyboard_lines.size() * tft.fontHeight());
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (isLandscape())
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align left (SHIFT, SPACE)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(15 - 2, y - 1, tft.textWidth(SHIFT) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(30 + tft.textWidth(SHIFT) - 2, y - 1, tft.textWidth(SPACE) + 4, tft.fontHeight() + 2, 3,
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align right (BACKSPACE, ENTER); align from tft.width()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(tft.width() - 30 - tft.textWidth(ENTER) - tft.textWidth(BACKSPACE) - 2, y - 1,
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.textWidth(BACKSPACE) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(ENTER) - 2, y - 1, tft.textWidth(ENTER) + 4,
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// if (!dont_draw_string)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align left (SHIFT, SPACE)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(SHIFT, 15, y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 1)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(SPACE, 30 + tft.textWidth(SHIFT), y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align right (BACKSPACE, ENTER); align from tft.width()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 2)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(BACKSPACE, tft.width() - 30 - tft.textWidth(ENTER) - tft.textWidth(BACKSPACE), y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 3)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(ENTER, tft.width() - 15 - tft.textWidth(ENTER), y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
const int32_t y_2 = y + tft.fontHeight() + 4;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align left (SHIFT, SPACE)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(15 - 2, y - 1, tft.textWidth(SHIFT) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(15 - 2, y_2 - 1, tft.textWidth(SPACE) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align right (BACKSPACE, ENTER); align from tft.width()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(ENTER) - 2, y - 1, tft.textWidth(ENTER) + 4,
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(BACKSPACE) - 2, y_2 - 1, tft.textWidth(BACKSPACE) + 4,
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// if (!dont_draw_string)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align left (SHIFT, SPACE)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(SHIFT, 15, y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 1)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(SPACE, 15, y_2);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
// align right (BACKSPACE, ENTER); align from tft.width()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 2)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(BACKSPACE, tft.width() - 15 - tft.textWidth(BACKSPACE), y_2);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_char_index == m_char_length + 3)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
else
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
tft.drawString(ENTER, tft.width() - 15 - tft.textWidth(ENTER), y);
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
void nextScreen()
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
{
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_current_screen = static_cast<Screen>(static_cast<uint8_t>(m_current_screen) + uint8_t{1});
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
if (m_current_screen >= Screen::SCREEN_MAX)
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
m_current_screen = Screen::SCREEN_1;
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
updateCharLength();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
start();
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
}
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
int32_t m_char_length{0};
|
int32_t m_char_length{0};
|
||||||
std::string m_keyboard{KEYBOARD_SCREEN_1};
|
std::string m_keyboard{KEYBOARD_SCREEN_1};
|
||||||
@@ -329,4 +69,290 @@ private:
|
|||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() futsch oida futsch oida
|
|||||||
};
|
};
|
||||||
Screen m_current_screen{Screen::SCREEN_2};
|
Screen m_current_screen{Screen::SCREEN_2};
|
||||||
};
|
};
|
||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::moveSelectorUp()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_last_char_index = m_char_index;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index -= 10;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index < 0)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index = (m_char_length + 4) - m_char_index;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::moveSelectorDown()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_last_char_index = m_char_index;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index += 10;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index >= (m_char_length + 4))
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index = m_char_index - (m_char_length + 4);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::nextScreen()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_current_screen = static_cast<Screen>(static_cast<uint8_t>(m_current_screen) + uint8_t{1});
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_current_screen >= Screen::SCREEN_MAX)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_current_screen = Screen::SCREEN_1;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
updateCharLength();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
start();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::drawKeyboard(bool dont_draw_string)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
size_t char_index{0};
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
std::string keyboard_screen{m_keyboard};
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
std::vector<std::string> keyboard_lines;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
for (size_t i = 0; i < keyboard_screen.size(); i += 10)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
std::string line = keyboard_screen.substr(i, 10);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (cpputils::stringEndsWith(line, " "))
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
line.pop_back();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
keyboard_lines.push_back(line);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const auto datum = tft.getTextDatum();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextDatum(MC_DATUM);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
for (size_t i = 0; i < keyboard_lines.size(); i++)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{ tft.setTextColor(TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_GREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int32_t y = m_keyboard_start_y + (i * tft.fontHeight() + 9);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
std::string line = keyboard_lines[i];
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int16_t x = tft.width() / (line.size() + 1);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
for (size_t j = 0; j < line.size(); j++)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const std::string _char{line[j]};
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int32_t x_pos = x * (j + 1);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int32_t y_pos = y;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const auto width = tft.textWidth(_char) + 2;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const auto height = tft.fontHeight() + 4;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (char_index == m_char_index)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(x_pos-width/2-1, y_pos-height/2, width+2, height-4, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (char_index == m_last_char_index)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(x_pos-width/2-1, y_pos-height/2, width+2, height-4, 3, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (!dont_draw_string || char_index == m_char_index || char_index == m_last_char_index)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (char_index == m_char_index || char_index == m_last_char_index)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(char_index == m_last_char_index ? TFT_GREY : TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(_char, x_pos, y_pos);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (char_index == m_char_index)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_GREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
char_index++;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextDatum(datum);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// draw 3 extra buttons, back, space and enter (x=10, x=tft.width()/2, x=tft.width()-10)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int32_t y = m_keyboard_start_y + (keyboard_lines.size() * tft.fontHeight());
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (isLandscape())
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align left (SHIFT, SPACE)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(15 - 2, y - 1, tft.textWidth(SHIFT) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(30 + tft.textWidth(SHIFT) - 2, y - 1, tft.textWidth(SPACE) + 4, tft.fontHeight() + 2, 3,
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align right (BACKSPACE, ENTER); align from tft.width()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(tft.width() - 30 - tft.textWidth(ENTER) - tft.textWidth(BACKSPACE) - 2, y - 1,
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.textWidth(BACKSPACE) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(ENTER) - 2, y - 1, tft.textWidth(ENTER) + 4,
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// if (!dont_draw_string)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align left (SHIFT, SPACE)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(SHIFT, 15, y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 1)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(SPACE, 30 + tft.textWidth(SHIFT), y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align right (BACKSPACE, ENTER); align from tft.width()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 2)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(BACKSPACE, tft.width() - 30 - tft.textWidth(ENTER) - tft.textWidth(BACKSPACE), y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 3)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(ENTER, tft.width() - 15 - tft.textWidth(ENTER), y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const int32_t y_2 = y + tft.fontHeight() + 4;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align left (SHIFT, SPACE)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(15 - 2, y - 1, tft.textWidth(SHIFT) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(15 - 2, y_2 - 1, tft.textWidth(SPACE) + 4, tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align right (BACKSPACE, ENTER); align from tft.width()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(ENTER) - 2, y - 1, tft.textWidth(ENTER) + 4,
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawRoundRect(tft.width() - 15 - tft.textWidth(BACKSPACE) - 2, y_2 - 1, tft.textWidth(BACKSPACE) + 4,
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.fontHeight() + 2, 3, TFT_DARKGREY);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// if (!dont_draw_string)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align left (SHIFT, SPACE)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(SHIFT, 15, y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 1)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(SPACE, 15, y_2);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
// align right (BACKSPACE, ENTER); align from tft.width()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 2)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(BACKSPACE, tft.width() - 15 - tft.textWidth(BACKSPACE), y_2);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == m_char_length + 3)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_BLACK, TFT_WHITE);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawString(ENTER, tft.width() - 15 - tft.textWidth(ENTER), y);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::updateCharLength()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
std::string tmpstr;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
switch (m_current_screen)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Screen::SCREEN_1:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tmpstr = KEYBOARD_SCREEN_1;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Screen::SCREEN_2:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tmpstr = KEYBOARD_SCREEN_2;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Screen::SCREEN_3:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tmpstr = KEYBOARD_SCREEN_3;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
default:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
ESP_LOGE(TAG, "Unknown screen");
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
return;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_keyboard = tmpstr;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
cpputils::stringReplaceAll(" ", "", tmpstr);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_length = tmpstr.length();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_keyset = tmpstr;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::moveSelectorRight()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_last_char_index = m_char_index;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == (m_char_length + 4) - 1)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index = 0;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index++;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::moveSelectorLeft()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_last_char_index = m_char_index;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index == 0)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index = (m_char_length + 4) - 1;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_char_index--;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::start()
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
const auto isLandscape = espgui::isLandscape();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_keyboard_start_y = isLandscape ? 98 : 120;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.fillRect(1, m_keyboard_start_y - 10, tft.width()-1, tft.height() - m_keyboard_start_y - (isLandscape ? 0 : 30), TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
tft.drawSunkenRect(1, m_keyboard_start_y - 10, tft.width()-1, tft.height() - m_keyboard_start_y - (isLandscape ? 0 : 30), TFT_WHITE, TFT_GREY, TFT_BLACK);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
updateCharLength();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
drawKeyboard();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::buttonPressed(Button button)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
switch (button)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Right:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
if (m_char_index < m_char_length)
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_display.setShownValue(m_display.shownValue() + m_keyset[m_char_index]);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else if (m_char_index == m_char_length) // shift
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
nextScreen();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else if (m_char_index == m_char_length + 1) // space
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_display.setShownValue(m_display.shownValue() + " ");
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else if (m_char_index == m_char_length + 2) // backspace
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_display.removeLastCharFromShownValue();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
else if (m_char_index == m_char_length + 3) // enter
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
{
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
m_display.confirmValue();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Left:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
popScreen();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
return;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Up:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
moveSelectorLeft();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
drawKeyboard(true);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
case Down:
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
moveSelectorRight();
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
drawKeyboard(true);
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
break;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
default:;
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
template<typename TDisplay>
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
|
void Keyboard<TDisplay>::buttonReleased(espgui::Button button) {}
|
||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
|
|||||||
} // namespace espgui
|
} // namespace espgui
|
||||||
|
|||||||
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
![]() futsch oida futsch oida
![]() futsch oida futsch oida
|
wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
wenn impl schon im header sein muss, dann zumindest bitte unter der klasse und nicht inline in der klasse. macht zb größe abschätzen unmöglich ohne millionen zeilen zu lesen
futsch oida
futsch oida