From 6d727e9a5c90b1006523ffe4be7c0a954269b3fe Mon Sep 17 00:00:00 2001 From: Holger Wirtz Date: Sun, 29 Mar 2020 17:35:32 +0200 Subject: [PATCH] Fixing SPECIAL controller mode. Fixing some warnings in LCDMenuLib2. --- config.h | 12 +- controllers.h | 37 +- third-party/LCDMenuLib2/LCDMenuLib2.cpp | 2368 ++++++++++++++++++ third-party/LCDMenuLib2/LCDMenuLib2_macros.h | 653 +++++ 4 files changed, 3039 insertions(+), 31 deletions(-) create mode 100644 third-party/LCDMenuLib2/LCDMenuLib2.cpp create mode 100644 third-party/LCDMenuLib2/LCDMenuLib2_macros.h diff --git a/config.h b/config.h index 903c9ab..f3841ad 100644 --- a/config.h +++ b/config.h @@ -294,6 +294,8 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define MONO_DEFAULT 0 #endif +#define MIDI_CONTROLLER_MODE_MAX 2 + #define VOLUME_MIN 0 #define VOLUME_MAX 100 #define VOLUME_DEFAULT 80 @@ -386,7 +388,7 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define SOUND_INTENSITY_MIN 0 #define SOUND_INTENSITY_MAX 100 #define SOUND_INTENSITY_DEFAULT 100 -#define SOUND_INTENSITY_AMP_MAX 1.5 +#define SOUND_INTENSITY_AMP_MAX 1.3 #define POLYPHONY_MIN 1 #define POLYPHONY_MAX MAX_NOTES @@ -421,7 +423,7 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define MW_ASSIGN_DEFAULT 0 // Bitmapped: 0: Pitch, 1: Amp, 2: Bias #define MW_MODE_MIN 0 -#define MW_MODE_MAX 2 +#define MW_MODE_MAX MIDI_CONTROLLER_MODE_MAX #define MW_MODE_DEFAULT 0 #define FC_RANGE_MIN 0 @@ -433,7 +435,7 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define FC_ASSIGN_DEFAULT 0 // Bitmapped: 0: Pitch, 1: Amp, 2: Bias #define FC_MODE_MIN 0 -#define FC_MODE_MAX 2 +#define FC_MODE_MAX MIDI_CONTROLLER_MODE_MAX #define FC_MODE_DEFAULT 0 #define BC_RANGE_MIN 0 @@ -445,7 +447,7 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define BC_ASSIGN_DEFAULT 2 // Bitmapped: 0: Pitch, 1: Amp, 2: Bias #define BC_MODE_MIN 0 -#define BC_MODE_MAX 2 +#define BC_MODE_MAX MIDI_CONTROLLER_MODE_MAX #define BC_MODE_DEFAULT 2 #define AT_RANGE_MIN 0 @@ -457,7 +459,7 @@ enum { DEXED, CHORUS, DELAY, REVERB}; #define AT_ASSIGN_DEFAULT 0 // Bitmapped: 0: Pitch, 1: Amp, 2: Bias #define AT_MODE_MIN 0 -#define AT_MODE_MAX 2 +#define AT_MODE_MAX MIDI_CONTROLLER_MODE_MAX #define AT_MODE_DEFAULT 0 #define OP_ENABLED_MIN 0 diff --git a/controllers.h b/controllers.h index 208a0d2..4649b1b 100644 --- a/controllers.h +++ b/controllers.h @@ -22,6 +22,7 @@ #include #include #include +#include "config.h" // State of MIDI controllers const int kControllerPitch = 0; @@ -63,7 +64,7 @@ class FmMod { void setMode(uint8_t m) { - ctrl_mode = m > 1 ? 0 : m; + ctrl_mode = m > MIDI_CONTROLLER_MODE_MAX ? 0 : m; } }; @@ -76,40 +77,24 @@ class Controllers { switch (mod.ctrl_mode) { case 0: - total = float(cc) * range; // NORMAL mode + total = uint8_t(float(cc) * range); // NORMAL mode break; case 1: - total = (127.0 - float(cc)) * range; // REVERSE mode + total = uint8_t(127.0 * range - (float(cc) * range)); // REVERSE mode break; case 2: - //total = 100.0 - range + (float)cc * range / 100.0; // Special BC mode by Thierry (opus.quatre) - //total = 127.0 * ( 1.0 - range ) + (float(cc) * range ); // Special BC mode by Thierry (opus.quatre) - total = range * float(cc) + (1.0 - range) * 127.0; // Special BC mode by Thierry (opus.quatre) + total = uint8_t(range * float(cc) + (1.0 - range) * 127.0); // Special BC mode by Thierry (opus.quatre) break; } - if (mod.ctrl_mode < 2) - { - if (mod.amp) - amp_mod = max(amp_mod, total); - - if (mod.pitch) - pitch_mod = max(pitch_mod, total); - - if (mod.eg) - eg_mod = max(eg_mod, total); - } - else - { - if (mod.amp) - amp_mod = total; + if (mod.amp) + amp_mod = max(amp_mod, total); - if (mod.pitch) - pitch_mod = total; + if (mod.pitch) + pitch_mod = max(pitch_mod, total); - if (mod.eg) - eg_mod = total; - } + if (mod.eg) + eg_mod = max(eg_mod, total); } public: diff --git a/third-party/LCDMenuLib2/LCDMenuLib2.cpp b/third-party/LCDMenuLib2/LCDMenuLib2.cpp new file mode 100644 index 0000000..098f20f --- /dev/null +++ b/third-party/LCDMenuLib2/LCDMenuLib2.cpp @@ -0,0 +1,2368 @@ +/* ****************************************************************************** + * LCDMenuLib2 (LCDML) + * ****************************************************************************** + * + * MIT License + * + * Copyright (c) [2019] [Nils Feldkämper] + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ****************************************************************************** + * + * BUG / ISSUES REPORTING + * https://github.com/Jomelo/LCDMenuLib2/issues + * + * ARDUINO FORUM + * http://forum.arduino.cc/index.php?topic=73816.0 + * + * ****************************************************************************** + */ + +#include "LCDMenuLib2.h" +#include "LCDMenuLib2_typedef.h" + +/* ******************************************************************** */ +LCDMenuLib2::LCDMenuLib2(LCDMenuLib2_menu &p_r, const uint8_t p_rows, const uint8_t p_cols, LCDML_FuncPtr contentUpdate, LCDML_FuncPtr contentClear, LCDML_FuncPtr menuControl) +/* ******************************************************************** */ +{ + // initialization + rootMenu = &p_r; + curMenu = rootMenu; + + window_rows = p_rows; + // the cols variable is removed + + callback_contentUpdate = contentUpdate; // callback update content + callback_contentClear = contentClear; // callback clear content + callback_menuControl = menuControl; // callback buttons +} + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* init methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + +/* ******************************************************************** */ +void LCDMenuLib2::init(uint8_t p_maxElements) +/* ******************************************************************** */ +{ + // init some variables + REG_control = 0; + REG_MenuFunction = 0; + REG_button = 0; + REG_special = 0; + REG_update = 0; + cursor_pos = 0; + layer = 0; + cursor_obj_pos = 0; + cursor_pos_abs = 0; + activMenu = NULL; + menu_timer = 0; + menu_default_time = 100000000; + + maxElements = p_maxElements; + + // reset all buttons + BT_resetAll(); + + // set the cursor object position to the right postion + // this is needed when the first and following elements are hidden + MENU_initFirstElement(); + + // update the current cursor possition + // paramter 10 => do not scroll + MENU_doScroll(10); + // update the menu + MENU_display(); + DISP_menuUpdate(); +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* LOOP methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +void LCDMenuLib2::loop(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_LOOP, F("LCDML.loop")); + + loop_control(); + loop_menu(); +} + +/* ******************************************************************** */ +void LCDMenuLib2::loop_control(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_LOOP, F("LCDML.loop_control")); + + // check callback + // check if this function is valid + if(callback_menuControl != NULL) + { + // function is defined + callback_menuControl(); + } + else + { + // do nothing + } + + // screensaver handling + // check + if(cb_screensaver != NULL && bitRead(REG_special, _LCDML_REG_special_disable_screensaver) == false) + { + if(activMenu != NULL) + { + // a menu function is active + if(activMenu->getCbFunction() != cb_screensaver) // check if screensaver is active + { + if(TIMER_ms(screensaver_timer, screensaver_default_time)) + { + // close the running function + FUNC_goBackToMenu(); + loop_control(); + REG_button = 0; + OTHER_jumpToFunc(cb_screensaver); + } + else + { + // do nothing + } + } + else + { + // do nothing + } + } + else + { + // only the menu is active + if(TIMER_ms(screensaver_timer, screensaver_default_time)) + { + // reset all button states + BT_resetAll(); + OTHER_jumpToFunc(cb_screensaver); + } + else + { + // do nothing + } + } + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::loop_menu(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_LOOP, F("LCDML.loop_menu")); + + // local declaration + uint8_t cnt = 0; + uint8_t obj_pos = 0; + LCDMenuLib2_menu *tmp; + //boolean stop_while_loop = false; + boolean found = false; + + + // ============================================ + // check control activity + // ============================================ + if(BT_checkAny() == true) + { + SCREEN_resetTimer(); + + if(activMenu == NULL) + { + // -- ENTER -- + if(BT_checkEnter() == true) + { + //menu is active + MENU_goInto(); + bitSet(REG_control, _LCDML_REG_control_update_direct); + } + else + { + // do nothing + } + + // -- UP -- + if(bitRead(REG_special, _LCDML_REG_special_disable_scroll) == false) + { + if(BT_checkUp() == true) + { + MENU_doScroll(0); + } + else + { + // do nothing + } + + // -- DOWN -- + if(BT_checkDown() == true) + { + MENU_doScroll(1); + } + else + { + // do nothing + } + } + else + { + if(BT_checkUp() == true || BT_checkDown()) + { + DISP_update(); + } + else + { + // do nothing + } + } + + // -- LEFT or RIGHT -- + if(BT_checkLeft() == true or BT_checkRight() == true) + { + DISP_update(); + } + else + { + // do nothing + } + + // -- QUIT Part 1 -- + if(BT_checkQuit() == true) + { + MENU_enScroll(); + + if(layer > 0) + { + MENU_goBack(); + DISP_update(); + } + else + { + // do nothing + } + } + else + { + // do nothing + } + } + else + { + // -- QUIT Part 2 -- + if(BT_checkQuit() == true) + { + MENU_enScroll(); + FUNC_goBackToMenu(); + BT_resetQuit(); + } + else + { + // do nothing + } + } + } + + + // ============================================ + // jump to handling + // ============================================ + if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled)) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - is active")); + + MENU_enScroll(); + + bitClear(REG_special, _LCDML_REG_special_jumpTo_enabled); + bitClear(REG_control, _LCDML_REG_control_dynMenuDisplayed); + + bitSet(REG_control, _LCDML_REG_control_disable_hidden); + bitSet(REG_control, _LCDML_REG_control_search_display); + + // got to root + if(activMenu != NULL) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - close active function")); + + // this function called be recursive (only once) + // set this bit to call the FUNC_close function when the goRoot function is called + bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_close_active) == false) + { + FUNC_call(); // call active function to bring it on a stable state; + } + else + { + // do nothing + } + + BT_resetAll(); + + activMenu = NULL; + + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_close_active); + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_setup); + + bitClear(REG_special, _LCDML_REG_special_disable_screensaver); + } + else + { + // do nothing + } + + // reset the old parameter from the closed function / this parameter is set when a new jumpTo.. function is called + jT_paramOld = 0; + + // set the menu to root + MENU_goRoot(); + + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - searching element")); + + + // search element + switch(jT_mode) + { + case 0: // jumpToFunc + case 2: // setCursorToFunc + found = OTHER_searchFunction(*rootMenu, 0, jT_function, 0); + break; + + case 1: // jumpToID + case 3: // setCursorToID + found = OTHER_searchFunction(*rootMenu, 1, NULL, jT_id); + break; + + default: + // error + break; + } + + + + + //maxElements; + + /* + + New Search function + (only id based) + + */ + + //tmp + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // check element handling + if(found == true) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - element found")); + + // get element to to open + tmp = curMenu->getChild(cursor_obj_pos); + + // reset the search action to do some normal handlings + bitClear(REG_control, _LCDML_REG_control_search_display); + + switch(jT_mode) + { + case 0: // jumpToFunc + case 1: // jumpToID + + // check if element is a menu function and no dynamic function + if(tmp->checkCallback() == false || tmp->checkType_menu() == false) + { + // only set the cursor to this element because it is not callable + // do nothing else here + } + else + { + // open menu element + MENU_goInto(); + } + break; + + case 2: // setCursorToFunc + case 3: // setCursorToID + + if(tmp->checkCondition() == false) + { + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_helpFunction - callbackfunction is hidden, the cursor cannot be set to this possition: go back to root menu")); + + bitClear(REG_control, _LCDML_REG_control_disable_hidden); + MENU_goRoot(); + } + else + { + // do nothing + } + break; + + + default: + // do nothing + + break; + } + + // update the menu + DISP_update(); + + bitClear(REG_control, _LCDML_REG_control_disable_hidden); + + // set current cursor possition without hidden elements + if((tmp = curMenu->getChild(0)) != NULL) + { + cnt = 0; + do + { + if(tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_search_display) == true) + { + if(obj_pos == cursor_obj_pos) + { + cursor_pos_abs = cnt; + if(cursor_pos_abs - (window_rows-1) > 0) + { + window_start = cursor_pos_abs-(window_rows-1); + } + else + { + window_start = 0; + } + MENU_doScroll(10); + break; + } + else + { + // do nothing + } + // count visible elments + cnt++; + } + else + { + // do nothing + } + // count all elements + obj_pos++; + } + while((tmp = tmp->getSibling(1)) != NULL); + } + else + { + // do nothing + } + } + else + { + // do nothing + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - nothing found")); + } + + bitClear(REG_control, _LCDML_REG_control_search_display); + bitClear(REG_control, _LCDML_REG_control_disable_hidden); + } + else + { + // do nothing + } + + + + + // ============================================ + // check if a menu function is active + // ============================================ + if(activMenu != NULL) + { + // check if the running function should be closed + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_end) == false && bitRead(REG_special, _LCDML_REG_special_goRoot) == false) + { + // => do not close the running function + // check if a loop time was set or a button was pressed or the function is called the first time + if(TIMER_ms(menu_timer, menu_default_time) == true || bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_setup) == false || REG_button > 0) + { + // call the current menu function + FUNC_call(); + } + else + { + // do nothing + } + } + else + { + // close the running function + + // set this bit to call the FUNC_close function when the goRoot function is called + bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_close_active) == false) + { + FUNC_call(); // call active function to bring it on a stable state; + } + else + { + // do nothing + } + + activMenu = NULL; + + // reset the custom parameter + jT_param = 0; + + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_close_active); + bitClear(REG_special, _LCDML_REG_special_disable_screensaver); + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_setup); + + + if(bitRead(REG_special, _LCDML_REG_special_goRoot) == true) + { + // set the cursor to the root position + bitClear(REG_special, _LCDML_REG_special_goRoot); + + MENU_goRoot(); + } + else + { + // check go back + for(uint8_t i=0; igetChild(cursor_obj_pos)->checkCondition() == false) + { + MENU_goRoot(); + } + else + { + // do nothing + } + } + else + { + // on going back, when the parent element is hidden, the condition is checken + // if the element is hidden, go to the next parent element and so on ... + while(layer > 0 && MENU_countChilds(curMenu) == 0) + { + MENU_goBack(); + } + } + } + + // only update the content when no jump function is active + DISP_update(); + } + } + else + { + menu_default_time = 100000000; + } + + + + // ============================================ + // check update handling + // ============================================ + if(bitRead(REG_update, _LCDML_REG_update_menu) == true || bitRead(REG_update, _LCDML_REG_update_cursor) == true) + { + if(activMenu == NULL) + { + if(bitRead(REG_special, _LCDML_REG_special_disable_scroll) == false) + { + // clear button status from scrolling + BT_resetUp(); + BT_resetDown(); + } + else + { + // do nothing + } + + callback_contentUpdate(); + BT_resetAll(); + } + else + { + // do nothing + } + + // reset both values here because it can be happen on some examples, that not all values are reset + bitClear(REG_update, _LCDML_REG_update_menu); + bitClear(REG_update, _LCDML_REG_update_cursor); + } + else + { + // reset all button actions + BT_resetAll(); + } +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* MENU methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_initFirstElement(void) +/* ******************************************************************** */ +{ + // + LCDMenuLib2_menu *tmp; + uint8_t obj_pos = cursor_obj_pos; + + // get the current object + if((tmp = curMenu->getChild(cursor_obj_pos)) != NULL) + { + do + { + if(tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_search_display) == true) + { + cursor_obj_pos = obj_pos; + break; + } + else + { + // do nothing + } + + obj_pos++; + } + while((tmp = tmp->getSibling(1)) != NULL); + } + else + { + // do nothing + } + +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_goRoot(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goRoot")); + + if(activMenu != NULL) + { + bitSet(REG_special, _LCDML_REG_special_goRoot); + } + else + { + // check if root position is reached + BT_resetAll(); + + curMenu = rootMenu; + layer = 0; + cursor_pos = 0; + cursor_obj_pos = 0; + cursor_pos_abs = 0; + window_start = 0; + + MENU_initFirstElement(); + + MENU_doScroll(10); + MENU_display(); + } +} + + + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_goBack(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goBack")); + + if(curMenu->getParent() != NULL) + { + //set current menu object + MENU_goMenu(*curMenu->getParent(), true); + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_goInto(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goInto")); + + // declaration + LCDMenuLib2_menu *tmp; + + // check if a menu function is not active + if (activMenu == NULL) + { + // get element to to open + tmp = curMenu->getChild(cursor_obj_pos); + + // check if element is a menu function + if(tmp->checkCallback() == true && tmp->checkType_menu() == true && bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + // Menu function found + activMenu = tmp; + } + else + { + if(tmp->checkType_dynParam() == true && bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + DISP_update(); + } + else + { + if(tmp->getChild(0) != NULL) + { + //check if element has visible children + if(MENU_countChilds(tmp) > 0) + { + // Menu found, goInto + MENU_goMenu(*curMenu->getChild(cursor_obj_pos), false); + + if(bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + BT_resetAll(); // reset all buttons + + DISP_update(); + } + } + else + { + // do nothing + } + } + else + { + // do nothing + } + } + } + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_goMenu(LCDMenuLib2_menu &p_m, uint8_t p_back) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goMenu")); + + //declare variables + LCDMenuLib2_menu *tmp; + uint8_t old_id = curMenu->getID(); + uint8_t j = 0; + uint8_t obj_pos = 0; + boolean found_visible = false; + + // check if the menu is opening or closing + if(p_back == false) + { + // set the curMenu pointer to a other menu element + curMenu = &p_m; + + // only update the contet when the layer is smaller then 254 + if(layer < (_LCDML_NO_FUNC-1)) + { + // new layer + window_start = 0; + cursor_obj_pos = 0; + cursor_pos_abs = 0; + + MENU_initFirstElement(); + + // update the layer counter + layer++; + } + else + { + // do nothing + } + } + else + { + // update the layer counter + if(layer > 0) + { + layer--; + } + else + { + // do nothing + } + + // set the curMenu pointer to a other menu element + curMenu = &p_m; + + // init the cursor_position variables to 0 + cursor_obj_pos = 0; + cursor_pos_abs = 0; + + // get childs from the current menu element + if((tmp = curMenu->getChild(0)) != NULL) + { + // search the current possition of the cursor + do + { + // check conditions + if (tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_disable_hidden)) + { + // when the current element id is the same as the old_id the current cursor position is found + if(tmp->getID() == old_id) + { + cursor_pos_abs = j; + cursor_obj_pos = obj_pos; + if(cursor_pos_abs - (window_rows-1) > 0) + { + window_start = cursor_pos_abs-(window_rows-1); + } + else + { + window_start = 0; + } + + MENU_doScroll(10); + found_visible = true; + break; + } + else + { + // do nothing + } + + // count all visible elements + j++; + } + else + { + // do nothing + } + + obj_pos++; + // select the next sibling when it exists + } while ((tmp = tmp->getSibling(1)) != NULL); + + if(found_visible == false) + { + MENU_goRoot(); + } + } + else + { + // Something is wrong, go to a stable state (root menu) + MENU_goRoot(); + } + + } +} + + +/* ******************************************************************** */ +LCDMenuLib2_menu * LCDMenuLib2::MENU_getCurrentObj(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getCurrentObj")); + + return curMenu; +} + +/* ******************************************************************** */ +LCDMenuLib2_menu * LCDMenuLib2::MENU_getDisplayedObj(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getDisplayedObj")); + + + LCDMenuLib2_menu *tmp; + uint8_t obj_pos = 0; + uint8_t cnt_visible = 0; + + if(window_start > 0) + { + // get the current object + if((tmp = curMenu->getChild(0)) != NULL) + { + do + { + if(tmp->checkCondition()) + { + if(cnt_visible == window_start) + { + break; + } + else + { + cnt_visible++; + } + } + else + { + // do nothing + } + obj_pos++; + + } + while((tmp = tmp->getSibling(1)) != NULL); + } + else + { + // do nothing + } + } + else + { + obj_pos = 0; + } + + return curMenu->getChild(obj_pos); +} + + + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_display(uint8_t update) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_display")); + + //check children + if(bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + bitSet(REG_update, _LCDML_REG_update_menu); + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getScroll(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getScroll")); + + return window_start; +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_doScroll(uint8_t state) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_doScroll")); + + LCDMenuLib2_menu *tmp; + + uint8_t cnt_visible = 0; + uint8_t obj_pos = 0; + uint8_t last_valid_obj_pos = 0; + boolean rollover = false; + boolean update = false; + //uint8_t child_cnt = MENU_countChilds(curMenu); + + //content: + // 0 = scroll up + // 1 = scroll down + + // 10 = update cursor postion + + switch(state) + { + case 0: // up + + obj_pos = 0; + + if(cursor_pos_abs > 0) + { + if((tmp = curMenu->getChild(0)) != NULL) + { + do + { + if(obj_pos == cursor_obj_pos) + { + if(cnt_visible > 0) + { + cursor_pos_abs--; + cursor_obj_pos = last_valid_obj_pos; + update = true; + } + else + { + // rollover is possible + rollover = true; + } + break; + } + else + { + if(tmp->checkCondition() == true || bitRead(REG_control, _LCDML_REG_control_search_display) == true) + { + cnt_visible++; + last_valid_obj_pos = obj_pos; + update = true; + } + else + { + // do nothing + } + } + + obj_pos++; + } + while((tmp = tmp->getSibling(1)) != NULL); + } + else + { + // do nothing + } + } + else + { + // rollover is possible + rollover = true; + } + + if(bitRead(REG_control, _LCDML_REG_control_rollover) && rollover == true) + { + // rollover the menu + if((tmp = curMenu->getChild(0)) != NULL) + { + do + { + if(tmp->checkCondition() == true || bitRead(REG_control, _LCDML_REG_control_search_display) == true) + { + cnt_visible++; + last_valid_obj_pos = obj_pos; + update = true; + } + else + { + // do nothing + } + + obj_pos++; + } + while((tmp = tmp->getSibling(1)) != NULL); + + cursor_pos_abs = cnt_visible-1; + cursor_obj_pos = last_valid_obj_pos; + if(cursor_pos_abs - (window_rows-1) > 0) + { + window_start = cursor_pos_abs-(window_rows-1); + } + else + { + window_start = 0; + } + } + else + { + // do nothing + } + } + else + { + // do nothing + } + + BT_resetUp(); + + // reset the button state here or update the menu + bitSet(REG_update, _LCDML_REG_update_menu); + + break; + + + + case 1: // down + + obj_pos = cursor_obj_pos; + + // get the next object if it exists + if((tmp = curMenu->getChild(cursor_obj_pos)) != NULL) + { + + while((tmp = tmp->getSibling(1)) != NULL) + { + obj_pos++; + + if(tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_search_display) == true) + { + cnt_visible++; + cursor_pos_abs++; + cursor_obj_pos = obj_pos; + update = true; + break; + } + else + { + // do nothing + } + } + + if(cnt_visible == 0) + { + rollover = true; + } + } + else + { + rollover = true; + } + + if(bitRead(REG_control, _LCDML_REG_control_rollover) && rollover == true) + { + cursor_obj_pos = 0; + cursor_pos_abs = 0; + window_start = 0; + MENU_initFirstElement(); + } + else + { + // do nothing + } + + BT_resetDown(); + + // reset the button state here or update the menu + bitSet(REG_update, _LCDML_REG_update_menu); + + break; + + default: // all others + // do nothing + break; + } + + + // update window possition + // only update the window position when no the menu is not rolled over + if(rollover == false) + { + if(cursor_pos_abs - (window_rows-1) > 0 || window_start > 0) + { + switch(state) + { + case 0: // up + if(cursor_pos == 0) + { + if(window_start > 0) + { + window_start--; + } + else + { + // do nothing + } + } + else + { + // do nothing + } + break; + + case 1: // down + if(cursor_pos == (window_rows-1)) + { + window_start = cursor_pos_abs - (window_rows-1); + } + else + { + // do nothing + } + break; + + default: // all others + break; + } + } + else + { + window_start = 0; + } + } + else + { + // do nothing + } + + // update cursor position + cursor_pos = cursor_pos_abs - window_start; + + // check if the cursor position is updated + if(activMenu == NULL && bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + bitSet(REG_update, _LCDML_REG_update_cursor); + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_enRollover(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_enRollover")); + + bitSet(REG_control, _LCDML_REG_control_rollover); +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_disRollover(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_disRollover")); + + bitClear(REG_control, _LCDML_REG_control_rollover); +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getLayer(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getLayer")); + + return layer; +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getCursorPos(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getCursorPos")); + + return (cursor_pos); //return the current cursor position +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getCursorPosAbs(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getCursorPosAbs")); + + return cursor_pos_abs; //return the current cursor position +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_countChilds(LCDMenuLib2_menu *menu, uint8_t all) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_countChilds")); + + //declaration + uint8_t j = 0; + LCDMenuLib2_menu *tmp; + + //check if element has children + if(menu != NULL) + { + if ((tmp = menu->getChild(0)) != NULL) + { + do + { + if (tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_disable_hidden) || all == true) + { + j++; + } + else + { + // do nothing + } + } while ((tmp = tmp->getSibling(1)) != NULL); + } + else + { + // do nothing + } + } + else + { + // do nothing + } + + return j; +} + + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getChilds(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getChilds")); + + return MENU_countChilds(curMenu); +} + + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_getParentID(uint8_t p_layer) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getParentID")); + LCDMenuLib2_menu *tmp; + + if((tmp = curMenu->getChild(0)) != NULL) + { + for(uint8_t i=0; igetParent() != NULL) + { + tmp = tmp->getParent(); + } + else + { + return _LCDML_NO_FUNC; + break; + } + } + + return tmp->getParent()->getID(); + } + else + { + return _LCDML_NO_FUNC; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_setDynContent(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_setDynContent")); + + bitSet(REG_control, _LCDML_REG_control_dynMenuDisplayed); +} + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::MENU_checkDynContent(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_checkDynContent")); + + if(bitRead(REG_control, _LCDML_REG_control_dynMenuDisplayed)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_enScroll(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_enScroll")); + + bitClear(REG_special, _LCDML_REG_special_disable_scroll); +} + +/* ******************************************************************** */ +void LCDMenuLib2::MENU_disScroll(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_disScroll")); + + if(activMenu == NULL) + { + bitSet(REG_special, _LCDML_REG_special_disable_scroll); + } + else + { + bitClear(REG_special, _LCDML_REG_special_disable_scroll); + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::MENU_getScrollDisableStatus(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_getScrollDisableStatus")); + + return bitRead(REG_special, _LCDML_REG_special_disable_scroll); +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* DISP methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +void LCDMenuLib2::DISP_menuUpdate(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_DISP, F("LCDML.DISP_menuUpdate")); + + bitSet(REG_update, _LCDML_REG_update_menu); +} + +/* ******************************************************************** */ +void LCDMenuLib2::DISP_clear(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_DISP, F("LCDML.DISP_clear")); + + if(bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + callback_contentClear(); + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::DISP_checkMenuUpdate(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_DISP, F("LCDML.DISP_checkMenuUpdate")); + + if (bitRead(REG_update, _LCDML_REG_update_menu)) + { + bitClear(REG_update, _LCDML_REG_update_menu); + bitClear(REG_control, _LCDML_REG_control_dynMenuDisplayed); + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::DISP_checkMenuCursorUpdate(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_DISP, F("LCDML.DISP_checkMenuCursorUpdate")); + + if(bitRead(REG_update, _LCDML_REG_update_cursor)) + { + bitClear(REG_update, _LCDML_REG_update_cursor); + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::DISP_update(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_DISP, F("LCDML.DISP_update")); + + MENU_doScroll(10); + MENU_display(); + + if(bitRead(REG_control, _LCDML_REG_control_search_display) == false) + { + bitSet(REG_update, _LCDML_REG_update_menu); + } +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* FUNC methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +uint8_t LCDMenuLib2::FUNC_getID(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_getID")); + + LCDMenuLib2_menu *tmp; + + if(activMenu != NULL) + { + return activMenu->getID(); + } + else + { + if((tmp = curMenu->getChild(cursor_obj_pos)) != NULL) + { + if(tmp->checkType_dynParam() == true) + { + return tmp->getID(); + } + else + { + return _LCDML_NO_FUNC; + } + } + else + { + return _LCDML_NO_FUNC; + } + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::FUNC_setLoopInterval(unsigned long p_t) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_setLoopInterval")); + + menu_default_time = p_t; +} + +/* ******************************************************************** */ +void LCDMenuLib2::FUNC_call(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_call")); + + if(activMenu != NULL) + { + if(jT_paramOld > 0) + { + activMenu->callback(jT_paramOld); + } + else if(jT_param > 0) + { + activMenu->callback(jT_param); + } + else + { + activMenu->callback(activMenu->getParam()); + } + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::FUNC_setup(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_setup")); + + if(activMenu != NULL) + { + // function active + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_setup) == 0) { + bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_setup); // run setup + DISP_clear(); + BT_resetAll(); + return true; + } + else + { + return false; + } + } + else + { + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_setup); // run setup + + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::FUNC_loop(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_loop")); + + + if(activMenu != NULL) + { + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_end) == false) + { + return true; + } + else + { + return false; + } + } + else + { + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::FUNC_close(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_close")); + + if(activMenu != NULL) + { + if(bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_end) == true) + { + bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_close_active); + return true; + } + else + { + return false; + } + } + else + { + bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + + return false; + } +} + + +/* ******************************************************************** */ +void LCDMenuLib2::FUNC_goBackToMenu(uint8_t p_e) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_goBackToMenu")); + + if(activMenu != NULL) + { + goBackCnt = p_e; + bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_end); + } + else + { + // do nothing + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::FUNC_disableScreensaver(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_disableScreensaver")); + + bitSet(REG_special, _LCDML_REG_special_disable_screensaver); +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* BT methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_setup(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_setup")); + + // check if the button initialisation was done + if(bitRead(REG_control, _LCDML_REG_control_bt_init_setup) == false) + { + bitSet(REG_control, _LCDML_REG_control_bt_init_setup); + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_enter(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_enter")); + + bitSet(REG_button, _LCDML_REG_button_enter); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_up(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_up")); + + bitSet(REG_button, _LCDML_REG_button_up); + +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_down(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_down")); + + bitSet(REG_button, _LCDML_REG_button_down); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_left(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_left")); + + bitSet(REG_button, _LCDML_REG_button_left); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_right(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_right")); + + bitSet(REG_button, _LCDML_REG_button_right); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_quit(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_quit")); + + bitSet(REG_button, _LCDML_REG_button_quit); +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkAny(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkAny")); + + if((REG_button > 0)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkEnter(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkEnter")); + + if(bitRead(REG_button, _LCDML_REG_button_enter)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkUp(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkUp")); + + if(bitRead(REG_button, _LCDML_REG_button_up)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkDown(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkDown")); + + if(bitRead(REG_button, _LCDML_REG_button_down)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkLeft(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkLeft")); + + if(bitRead(REG_button, _LCDML_REG_button_left)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkRight(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkRight")); + + if(bitRead(REG_button, _LCDML_REG_button_right)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::BT_checkQuit(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_checkQuit")); + + if(bitRead(REG_button, _LCDML_REG_button_quit)) + { + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetAll(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetAll")); + + REG_button = 0; +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetEnter(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetEnter")); + + bitClear(REG_button, _LCDML_REG_button_enter); +} +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetUp(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetUp")); + + bitClear(REG_button, _LCDML_REG_button_up); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetDown(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetDown")); + + bitClear(REG_button, _LCDML_REG_button_down); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetLeft(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetLeft")); + + bitClear(REG_button, _LCDML_REG_button_left); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetRight(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetRight")); + + bitClear(REG_button, _LCDML_REG_button_right); +} + +/* ******************************************************************** */ +void LCDMenuLib2::BT_resetQuit(void) +/* ******************************************************************** */ + +{ + // debug information + DBG_println(LCDML_DBG_function_name_BT, F("LCDML.BT_resetQuit")); + + bitClear(REG_button, _LCDML_REG_button_quit); +} +/* ******************************************************************** */ + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* TIMER methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +void LCDMenuLib2::TIMER_msReset(unsigned long &p_var) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_TIMER, F("LCDML.TIMER_msReset")); + + p_var = millis(); +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::TIMER_ms(unsigned long &p_var, unsigned long p_t) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_TIMER, F("LCDML.TIMER_ms")); + + if((millis() - p_var) >= p_t) + { + p_var = millis(); + return true; + } + else + { + return false; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::TIMER_usReset(unsigned long &p_var) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_TIMER, F("LCDML.TIMER_usReset")); + + p_var = micros(); +} + +/* ******************************************************************** */ +boolean LCDMenuLib2::TIMER_us(unsigned long &p_var, unsigned long p_t) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_TIMER, F("LCDML.TIMER_us")); + + if((micros() - p_var) >= p_t) + { + p_var = micros(); + return true; + } + else + { + return false; + } +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* OTHER methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +boolean LCDMenuLib2::OTHER_searchFunction(LCDMenuLib2_menu &p_m, uint8_t mode, LCDML_FuncPtr_pu8 p_search, uint8_t p_id) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_searchFunction")); + + // declaration + LCDMenuLib2_menu *search = &p_m; + boolean found = false; + + if(activMenu == NULL) + { + do + { + DBG_print(LCDML_DBG_search, search->getID()); + DBG_print(LCDML_DBG_search, F(" : ")); + DBG_print(LCDML_DBG_search, (activMenu == NULL)?"0":"1"); + DBG_print(LCDML_DBG_search, F(" : obj_pos : ")); + DBG_print(LCDML_DBG_search, cursor_obj_pos); + DBG_print(LCDML_DBG_search, F(" : curMenu->ID : ")); + DBG_print(LCDML_DBG_search, curMenu->getID()); + DBG_print(LCDML_DBG_search, F(" : ")); + + if((search->getCbFunction() == p_search && mode == 0) || (search->getID() == p_id && mode == 1)) { + DBG_println(LCDML_DBG_search, F("found")); + // uncomment found when you will debug this function + found = true; + } + else + { + DBG_println(LCDML_DBG_search, F("")); + + // check if an element have a child or children + if (search->getChild(0) != NULL) + { + //go into a menu, but do not start a menu function until the search mode is run + MENU_goInto(); + + found = OTHER_searchFunction(*search->getChild(0), mode, p_search, p_id); //recursive search until found is true or last item reached + + if (found == false) + { + //quit layer, + MENU_goBack(); + + // go to next element (scroll down) + MENU_doScroll(1); + + } + else + { + // do nothing + } + } + else + { + //select next element (scroll down) + MENU_doScroll(1); + } + } + } while ((search=search->getSibling(1)) != NULL && found == false); + } + else + { + // something is wrong, please report a bug + found = false; + } + + return found; //found; +} + + +/* ******************************************************************** */ +void LCDMenuLib2::OTHER_jumpToFunc(LCDML_FuncPtr_pu8 p_search, uint8_t p_para) +/* ******************************************************************** */ +{ + + if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - is still activ")); + } + else + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - start")); + + // enable jump to Func + bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled); + jT_mode = 0; + jT_id = 0; + + if(activMenu != NULL) + { + jT_paramOld = jT_param; + } + else + { + jT_paramOld = 0; + } + + jT_param = p_para; + jT_function = p_search; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::OTHER_jumpToID(uint8_t p_id, uint8_t p_para) +/* ******************************************************************** */ +{ + if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToID - is still activ")); + } + else + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToID - start")); + + // enable jump to ID + bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled); + jT_mode = 1; + jT_id = p_id; + + if(activMenu != NULL) + { + jT_paramOld = jT_param; + } + else + { + jT_paramOld = 0; + } + + jT_param = p_para; + jT_function = NULL; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::OTHER_setCursorToFunc(LCDML_FuncPtr_pu8 p_search) +/* ******************************************************************** */ +{ + if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToFunc - is still activ")); + } + else + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToFunc - start")); + + // enable jump to Func + bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled); + jT_mode = 2; + jT_id = 0; + + if(activMenu != NULL) + { + jT_paramOld = jT_param; + } + else + { + jT_paramOld = 0; + } + + jT_param = 0; + jT_function = p_search; + } +} + +/* ******************************************************************** */ +void LCDMenuLib2::OTHER_setCursorToID(uint8_t p_id) +/* ******************************************************************** */ +{ + if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true) + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToID - is still activ")); + } + else + { + // debug information + DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToID - start")); + + // enable jump to Func + bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled); + jT_mode = 3; + jT_id = p_id; + + if(activMenu != NULL) + { + jT_paramOld = jT_param; + } + else + { + jT_paramOld = 0; + } + + jT_param = 0; + jT_function = NULL; + } +} + + +/* ******************************************************************** */ +/* ******************************************************************** */ +/* SCREEN methods */ +/* ******************************************************************** */ +/* ******************************************************************** */ + + +/* ******************************************************************** */ +void LCDMenuLib2::SCREEN_enable(LCDML_FuncPtr_pu8 function, unsigned long p_t) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_SCREEN, F("LCDML.SCREEN_enable")); + + cb_screensaver = function; + screensaver_default_time = p_t; +} + +/* ******************************************************************** */ +void LCDMenuLib2::SCREEN_disable(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_SCREEN, F("LCDML.SCREEN_disable")); + + cb_screensaver = NULL; +} + +/* ******************************************************************** */ +void LCDMenuLib2::SCREEN_resetTimer(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_SCREEN, F("LCDML.SCREEN_resetTimer")); + + TIMER_msReset(screensaver_timer); +} + +/* ******************************************************************** */ +void LCDMenuLib2::SCREEN_start(void) +/* ******************************************************************** */ +{ + // debug information + DBG_println(LCDML_DBG_function_name_SCREEN, F("LCDML.SCREEN_start")); + + screensaver_timer = millis() + 1000; +} diff --git a/third-party/LCDMenuLib2/LCDMenuLib2_macros.h b/third-party/LCDMenuLib2/LCDMenuLib2_macros.h new file mode 100644 index 0000000..5a561af --- /dev/null +++ b/third-party/LCDMenuLib2/LCDMenuLib2_macros.h @@ -0,0 +1,653 @@ +/* ****************************************************************************** + * LCDMenuLib2 (LCDML) + * ****************************************************************************** + * + * MIT License + * + * Copyright (c) [2019] [Nils Feldkämper] + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ****************************************************************************** + * + * BUG / ISSUES REPORTING + * https://github.com/Jomelo/LCDMenuLib2/issues + * + * ARDUINO FORUM + * http://forum.arduino.cc/index.php?topic=73816.0 + * + * ****************************************************************************** + */ + +#ifndef _LCDML_macros_h + #define _LCDML_macros_h + + /* ------------------ + * Include Arduino IOS + * ------------------ + */ + #include + + + /* ------------------ + * DISP / MENU + * ------------------ + */ + + // get global language variable for name xyz + #define LCDML_DISP_lang(name, lang) g_LCDML_DISP_lang_ ## lang ## _ ## name ## _var + + // call repeat of function + #define LCDML_DISP_initFunction(N) LCDML_DISP_func_repeat(N); + + #ifndef _LCDML_ESP + // stored in flash (Arduino) + #define LCDML_langDef(name, lang, content) \ + const char g_LCDML_DISP_lang_ ## lang ## _ ## name ##_var[] PROGMEM = {content} + + #define LCDML_getCustomContent(lang, var, id) \ + if(id < _LCDML_NO_FUNC) {\ + strcpy_P(var, (char*)pgm_read_word(&(g_LCDML_DISP_lang_ ## lang ## _table[id]))); \ + } + + #define LCDML_createCustomLang(N, lang) \ + const char * const g_LCDML_DISP_lang_ ## lang ## _table[] PROGMEM = { LCDML_DISP_lang_repeat(N, lang) } + + #define LCDML_getCustomElementName(lang, var, element_id) \ + if(element_id < _LCDML_NO_FUNC && (sizeof(g_LCDML_DISP_lang_ ## lang ## _table)-1) >= element_id) {\ + strcpy_P(var, (char*)pgm_read_word(&(g_LCDML_DISP_lang_ ## lang ## _table[element_id])));\ + } + + #else + // stored in ram (esp) + #define LCDML_langDef(name, lang, content) \ + char g_LCDML_DISP_lang_ ## lang ## _ ## name ##_var[] = {content} + + #define LCDML_getCustomContent(lang, var, id) \ + if(id < _LCDML_NO_FUNC) {\ + strcpy(var, g_LCDML_DISP_lang_ ## lang ## _table[id]); \ + } + + #define LCDML_createCustomLang(N, lang) \ + char * g_LCDML_DISP_lang_ ## lang ## _table[] = { LCDML_DISP_lang_repeat(N, lang) } + + #define LCDML_getCustomElementName(lang, var, element_id) \ + if(element_id < _LCDML_NO_FUNC && (sizeof(g_LCDML_DISP_lang_ ## lang ## _table)-1) >= element_id) {\ + strcpy(var, g_LCDML_DISP_lang_ ## lang ## _table[element_id]);\ + } + + #endif + + #define LCDML_getElementName(var, element_id) \ + LCDML_getCustomElementName(lcdml, var, element_id) + + #define LCDML_createMenu(N)\ + LCDML_createCustomLang(N, lcdml) + + #define LCDML_getContent(var, id) \ + LCDML_getCustomContent(lcdml, var, id) + + //Menu Item Types + #define LCDML_addAdvanced(id, parent, child, p_condition, p_content, p_callback, p_param, p_settings) \ + LCDML_langDef(id, lcdml, p_content); \ + LCDMenuLib2_menu parent ## _ ## child(id, p_param, p_settings, p_callback, p_condition ); \ + void LCDML_DISP_ ## id ## _function() { \ + parent.addChild(parent ## _ ## child); \ + } + + #define LCDML_add(id, parent, child, content, callback) \ + LCDML_addAdvanced(id, parent, child, NULL, content, callback, 0, _LCDML_TYPE_default) + + #define LCDML_setup(N)\ + LCDML_DISP_initFunction(N); \ + LCDML.init(N) + + + + /* --------------------------------------- + * lang repeat + * --------------------------------------- + */ + #define LCDML_DISP_lang_repeat_255(lang) LCDML_DISP_lang_repeat_254(lang) LCDML_DISP_lang(255, lang), + #define LCDML_DISP_lang_repeat_254(lang) LCDML_DISP_lang_repeat_253(lang) LCDML_DISP_lang(254, lang), + #define LCDML_DISP_lang_repeat_253(lang) LCDML_DISP_lang_repeat_252(lang) LCDML_DISP_lang(253, lang), + #define LCDML_DISP_lang_repeat_252(lang) LCDML_DISP_lang_repeat_251(lang) LCDML_DISP_lang(252, lang), + #define LCDML_DISP_lang_repeat_251(lang) LCDML_DISP_lang_repeat_250(lang) LCDML_DISP_lang(251, lang), + #define LCDML_DISP_lang_repeat_250(lang) LCDML_DISP_lang_repeat_249(lang) LCDML_DISP_lang(250, lang), + #define LCDML_DISP_lang_repeat_249(lang) LCDML_DISP_lang_repeat_248(lang) LCDML_DISP_lang(249, lang), + #define LCDML_DISP_lang_repeat_248(lang) LCDML_DISP_lang_repeat_247(lang) LCDML_DISP_lang(248, lang), + #define LCDML_DISP_lang_repeat_247(lang) LCDML_DISP_lang_repeat_246(lang) LCDML_DISP_lang(247, lang), + #define LCDML_DISP_lang_repeat_246(lang) LCDML_DISP_lang_repeat_245(lang) LCDML_DISP_lang(246, lang), + #define LCDML_DISP_lang_repeat_245(lang) LCDML_DISP_lang_repeat_244(lang) LCDML_DISP_lang(245, lang), + #define LCDML_DISP_lang_repeat_244(lang) LCDML_DISP_lang_repeat_243(lang) LCDML_DISP_lang(244, lang), + #define LCDML_DISP_lang_repeat_243(lang) LCDML_DISP_lang_repeat_242(lang) LCDML_DISP_lang(243, lang), + #define LCDML_DISP_lang_repeat_242(lang) LCDML_DISP_lang_repeat_241(lang) LCDML_DISP_lang(242, lang), + #define LCDML_DISP_lang_repeat_241(lang) LCDML_DISP_lang_repeat_240(lang) LCDML_DISP_lang(241, lang), + #define LCDML_DISP_lang_repeat_240(lang) LCDML_DISP_lang_repeat_239(lang) LCDML_DISP_lang(240, lang), + #define LCDML_DISP_lang_repeat_239(lang) LCDML_DISP_lang_repeat_238(lang) LCDML_DISP_lang(239, lang), + #define LCDML_DISP_lang_repeat_238(lang) LCDML_DISP_lang_repeat_237(lang) LCDML_DISP_lang(238, lang), + #define LCDML_DISP_lang_repeat_237(lang) LCDML_DISP_lang_repeat_236(lang) LCDML_DISP_lang(237, lang), + #define LCDML_DISP_lang_repeat_236(lang) LCDML_DISP_lang_repeat_235(lang) LCDML_DISP_lang(236, lang), + #define LCDML_DISP_lang_repeat_235(lang) LCDML_DISP_lang_repeat_234(lang) LCDML_DISP_lang(235, lang), + #define LCDML_DISP_lang_repeat_234(lang) LCDML_DISP_lang_repeat_233(lang) LCDML_DISP_lang(234, lang), + #define LCDML_DISP_lang_repeat_233(lang) LCDML_DISP_lang_repeat_232(lang) LCDML_DISP_lang(233, lang), + #define LCDML_DISP_lang_repeat_232(lang) LCDML_DISP_lang_repeat_231(lang) LCDML_DISP_lang(232, lang), + #define LCDML_DISP_lang_repeat_231(lang) LCDML_DISP_lang_repeat_230(lang) LCDML_DISP_lang(231, lang), + #define LCDML_DISP_lang_repeat_230(lang) LCDML_DISP_lang_repeat_229(lang) LCDML_DISP_lang(230, lang), + #define LCDML_DISP_lang_repeat_229(lang) LCDML_DISP_lang_repeat_228(lang) LCDML_DISP_lang(229, lang), + #define LCDML_DISP_lang_repeat_228(lang) LCDML_DISP_lang_repeat_227(lang) LCDML_DISP_lang(228, lang), + #define LCDML_DISP_lang_repeat_227(lang) LCDML_DISP_lang_repeat_226(lang) LCDML_DISP_lang(227, lang), + #define LCDML_DISP_lang_repeat_226(lang) LCDML_DISP_lang_repeat_225(lang) LCDML_DISP_lang(226, lang), + #define LCDML_DISP_lang_repeat_225(lang) LCDML_DISP_lang_repeat_224(lang) LCDML_DISP_lang(225, lang), + #define LCDML_DISP_lang_repeat_224(lang) LCDML_DISP_lang_repeat_223(lang) LCDML_DISP_lang(224, lang), + #define LCDML_DISP_lang_repeat_223(lang) LCDML_DISP_lang_repeat_222(lang) LCDML_DISP_lang(223, lang), + #define LCDML_DISP_lang_repeat_222(lang) LCDML_DISP_lang_repeat_221(lang) LCDML_DISP_lang(222, lang), + #define LCDML_DISP_lang_repeat_221(lang) LCDML_DISP_lang_repeat_220(lang) LCDML_DISP_lang(221, lang), + #define LCDML_DISP_lang_repeat_220(lang) LCDML_DISP_lang_repeat_219(lang) LCDML_DISP_lang(220, lang), + #define LCDML_DISP_lang_repeat_219(lang) LCDML_DISP_lang_repeat_218(lang) LCDML_DISP_lang(219, lang), + #define LCDML_DISP_lang_repeat_218(lang) LCDML_DISP_lang_repeat_217(lang) LCDML_DISP_lang(218, lang), + #define LCDML_DISP_lang_repeat_217(lang) LCDML_DISP_lang_repeat_216(lang) LCDML_DISP_lang(217, lang), + #define LCDML_DISP_lang_repeat_216(lang) LCDML_DISP_lang_repeat_215(lang) LCDML_DISP_lang(216, lang), + #define LCDML_DISP_lang_repeat_215(lang) LCDML_DISP_lang_repeat_214(lang) LCDML_DISP_lang(215, lang), + #define LCDML_DISP_lang_repeat_214(lang) LCDML_DISP_lang_repeat_213(lang) LCDML_DISP_lang(214, lang), + #define LCDML_DISP_lang_repeat_213(lang) LCDML_DISP_lang_repeat_212(lang) LCDML_DISP_lang(213, lang), + #define LCDML_DISP_lang_repeat_212(lang) LCDML_DISP_lang_repeat_211(lang) LCDML_DISP_lang(212, lang), + #define LCDML_DISP_lang_repeat_211(lang) LCDML_DISP_lang_repeat_210(lang) LCDML_DISP_lang(211, lang), + #define LCDML_DISP_lang_repeat_210(lang) LCDML_DISP_lang_repeat_209(lang) LCDML_DISP_lang(210, lang), + #define LCDML_DISP_lang_repeat_209(lang) LCDML_DISP_lang_repeat_208(lang) LCDML_DISP_lang(209, lang), + #define LCDML_DISP_lang_repeat_208(lang) LCDML_DISP_lang_repeat_207(lang) LCDML_DISP_lang(208, lang), + #define LCDML_DISP_lang_repeat_207(lang) LCDML_DISP_lang_repeat_206(lang) LCDML_DISP_lang(207, lang), + #define LCDML_DISP_lang_repeat_206(lang) LCDML_DISP_lang_repeat_205(lang) LCDML_DISP_lang(206, lang), + #define LCDML_DISP_lang_repeat_205(lang) LCDML_DISP_lang_repeat_204(lang) LCDML_DISP_lang(205, lang), + #define LCDML_DISP_lang_repeat_204(lang) LCDML_DISP_lang_repeat_203(lang) LCDML_DISP_lang(204, lang), + #define LCDML_DISP_lang_repeat_203(lang) LCDML_DISP_lang_repeat_202(lang) LCDML_DISP_lang(203, lang), + #define LCDML_DISP_lang_repeat_202(lang) LCDML_DISP_lang_repeat_201(lang) LCDML_DISP_lang(202, lang), + #define LCDML_DISP_lang_repeat_201(lang) LCDML_DISP_lang_repeat_200(lang) LCDML_DISP_lang(201, lang), + #define LCDML_DISP_lang_repeat_200(lang) LCDML_DISP_lang_repeat_199(lang) LCDML_DISP_lang(200, lang), + #define LCDML_DISP_lang_repeat_199(lang) LCDML_DISP_lang_repeat_198(lang) LCDML_DISP_lang(199, lang), + #define LCDML_DISP_lang_repeat_198(lang) LCDML_DISP_lang_repeat_197(lang) LCDML_DISP_lang(198, lang), + #define LCDML_DISP_lang_repeat_197(lang) LCDML_DISP_lang_repeat_196(lang) LCDML_DISP_lang(197, lang), + #define LCDML_DISP_lang_repeat_196(lang) LCDML_DISP_lang_repeat_195(lang) LCDML_DISP_lang(196, lang), + #define LCDML_DISP_lang_repeat_195(lang) LCDML_DISP_lang_repeat_194(lang) LCDML_DISP_lang(195, lang), + #define LCDML_DISP_lang_repeat_194(lang) LCDML_DISP_lang_repeat_193(lang) LCDML_DISP_lang(194, lang), + #define LCDML_DISP_lang_repeat_193(lang) LCDML_DISP_lang_repeat_192(lang) LCDML_DISP_lang(193, lang), + #define LCDML_DISP_lang_repeat_192(lang) LCDML_DISP_lang_repeat_191(lang) LCDML_DISP_lang(192, lang), + #define LCDML_DISP_lang_repeat_191(lang) LCDML_DISP_lang_repeat_190(lang) LCDML_DISP_lang(191, lang), + #define LCDML_DISP_lang_repeat_190(lang) LCDML_DISP_lang_repeat_189(lang) LCDML_DISP_lang(190, lang), + #define LCDML_DISP_lang_repeat_189(lang) LCDML_DISP_lang_repeat_188(lang) LCDML_DISP_lang(189, lang), + #define LCDML_DISP_lang_repeat_188(lang) LCDML_DISP_lang_repeat_187(lang) LCDML_DISP_lang(188, lang), + #define LCDML_DISP_lang_repeat_187(lang) LCDML_DISP_lang_repeat_186(lang) LCDML_DISP_lang(187, lang), + #define LCDML_DISP_lang_repeat_186(lang) LCDML_DISP_lang_repeat_185(lang) LCDML_DISP_lang(186, lang), + #define LCDML_DISP_lang_repeat_185(lang) LCDML_DISP_lang_repeat_184(lang) LCDML_DISP_lang(185, lang), + #define LCDML_DISP_lang_repeat_184(lang) LCDML_DISP_lang_repeat_183(lang) LCDML_DISP_lang(184, lang), + #define LCDML_DISP_lang_repeat_183(lang) LCDML_DISP_lang_repeat_182(lang) LCDML_DISP_lang(183, lang), + #define LCDML_DISP_lang_repeat_182(lang) LCDML_DISP_lang_repeat_181(lang) LCDML_DISP_lang(182, lang), + #define LCDML_DISP_lang_repeat_181(lang) LCDML_DISP_lang_repeat_180(lang) LCDML_DISP_lang(181, lang), + #define LCDML_DISP_lang_repeat_180(lang) LCDML_DISP_lang_repeat_179(lang) LCDML_DISP_lang(180, lang), + #define LCDML_DISP_lang_repeat_179(lang) LCDML_DISP_lang_repeat_178(lang) LCDML_DISP_lang(179, lang), + #define LCDML_DISP_lang_repeat_178(lang) LCDML_DISP_lang_repeat_177(lang) LCDML_DISP_lang(178, lang), + #define LCDML_DISP_lang_repeat_177(lang) LCDML_DISP_lang_repeat_176(lang) LCDML_DISP_lang(177, lang), + #define LCDML_DISP_lang_repeat_176(lang) LCDML_DISP_lang_repeat_175(lang) LCDML_DISP_lang(176, lang), + #define LCDML_DISP_lang_repeat_175(lang) LCDML_DISP_lang_repeat_174(lang) LCDML_DISP_lang(175, lang), + #define LCDML_DISP_lang_repeat_174(lang) LCDML_DISP_lang_repeat_173(lang) LCDML_DISP_lang(174, lang), + #define LCDML_DISP_lang_repeat_173(lang) LCDML_DISP_lang_repeat_172(lang) LCDML_DISP_lang(173, lang), + #define LCDML_DISP_lang_repeat_172(lang) LCDML_DISP_lang_repeat_171(lang) LCDML_DISP_lang(172, lang), + #define LCDML_DISP_lang_repeat_171(lang) LCDML_DISP_lang_repeat_170(lang) LCDML_DISP_lang(171, lang), + #define LCDML_DISP_lang_repeat_170(lang) LCDML_DISP_lang_repeat_169(lang) LCDML_DISP_lang(170, lang), + #define LCDML_DISP_lang_repeat_169(lang) LCDML_DISP_lang_repeat_168(lang) LCDML_DISP_lang(169, lang), + #define LCDML_DISP_lang_repeat_168(lang) LCDML_DISP_lang_repeat_167(lang) LCDML_DISP_lang(168, lang), + #define LCDML_DISP_lang_repeat_167(lang) LCDML_DISP_lang_repeat_166(lang) LCDML_DISP_lang(167, lang), + #define LCDML_DISP_lang_repeat_166(lang) LCDML_DISP_lang_repeat_165(lang) LCDML_DISP_lang(166, lang), + #define LCDML_DISP_lang_repeat_165(lang) LCDML_DISP_lang_repeat_164(lang) LCDML_DISP_lang(165, lang), + #define LCDML_DISP_lang_repeat_164(lang) LCDML_DISP_lang_repeat_163(lang) LCDML_DISP_lang(164, lang), + #define LCDML_DISP_lang_repeat_163(lang) LCDML_DISP_lang_repeat_162(lang) LCDML_DISP_lang(163, lang), + #define LCDML_DISP_lang_repeat_162(lang) LCDML_DISP_lang_repeat_161(lang) LCDML_DISP_lang(162, lang), + #define LCDML_DISP_lang_repeat_161(lang) LCDML_DISP_lang_repeat_160(lang) LCDML_DISP_lang(161, lang), + #define LCDML_DISP_lang_repeat_160(lang) LCDML_DISP_lang_repeat_159(lang) LCDML_DISP_lang(160, lang), + #define LCDML_DISP_lang_repeat_159(lang) LCDML_DISP_lang_repeat_158(lang) LCDML_DISP_lang(159, lang), + #define LCDML_DISP_lang_repeat_158(lang) LCDML_DISP_lang_repeat_157(lang) LCDML_DISP_lang(158, lang), + #define LCDML_DISP_lang_repeat_157(lang) LCDML_DISP_lang_repeat_156(lang) LCDML_DISP_lang(157, lang), + #define LCDML_DISP_lang_repeat_156(lang) LCDML_DISP_lang_repeat_155(lang) LCDML_DISP_lang(156, lang), + #define LCDML_DISP_lang_repeat_155(lang) LCDML_DISP_lang_repeat_154(lang) LCDML_DISP_lang(155, lang), + #define LCDML_DISP_lang_repeat_154(lang) LCDML_DISP_lang_repeat_153(lang) LCDML_DISP_lang(154, lang), + #define LCDML_DISP_lang_repeat_153(lang) LCDML_DISP_lang_repeat_152(lang) LCDML_DISP_lang(153, lang), + #define LCDML_DISP_lang_repeat_152(lang) LCDML_DISP_lang_repeat_151(lang) LCDML_DISP_lang(152, lang), + #define LCDML_DISP_lang_repeat_151(lang) LCDML_DISP_lang_repeat_150(lang) LCDML_DISP_lang(151, lang), + #define LCDML_DISP_lang_repeat_150(lang) LCDML_DISP_lang_repeat_149(lang) LCDML_DISP_lang(150, lang), + #define LCDML_DISP_lang_repeat_149(lang) LCDML_DISP_lang_repeat_148(lang) LCDML_DISP_lang(149, lang), + #define LCDML_DISP_lang_repeat_148(lang) LCDML_DISP_lang_repeat_147(lang) LCDML_DISP_lang(148, lang), + #define LCDML_DISP_lang_repeat_147(lang) LCDML_DISP_lang_repeat_146(lang) LCDML_DISP_lang(147, lang), + #define LCDML_DISP_lang_repeat_146(lang) LCDML_DISP_lang_repeat_145(lang) LCDML_DISP_lang(146, lang), + #define LCDML_DISP_lang_repeat_145(lang) LCDML_DISP_lang_repeat_144(lang) LCDML_DISP_lang(145, lang), + #define LCDML_DISP_lang_repeat_144(lang) LCDML_DISP_lang_repeat_143(lang) LCDML_DISP_lang(144, lang), + #define LCDML_DISP_lang_repeat_143(lang) LCDML_DISP_lang_repeat_142(lang) LCDML_DISP_lang(143, lang), + #define LCDML_DISP_lang_repeat_142(lang) LCDML_DISP_lang_repeat_141(lang) LCDML_DISP_lang(142, lang), + #define LCDML_DISP_lang_repeat_141(lang) LCDML_DISP_lang_repeat_140(lang) LCDML_DISP_lang(141, lang), + #define LCDML_DISP_lang_repeat_140(lang) LCDML_DISP_lang_repeat_139(lang) LCDML_DISP_lang(140, lang), + #define LCDML_DISP_lang_repeat_139(lang) LCDML_DISP_lang_repeat_138(lang) LCDML_DISP_lang(139, lang), + #define LCDML_DISP_lang_repeat_138(lang) LCDML_DISP_lang_repeat_137(lang) LCDML_DISP_lang(138, lang), + #define LCDML_DISP_lang_repeat_137(lang) LCDML_DISP_lang_repeat_136(lang) LCDML_DISP_lang(137, lang), + #define LCDML_DISP_lang_repeat_136(lang) LCDML_DISP_lang_repeat_135(lang) LCDML_DISP_lang(136, lang), + #define LCDML_DISP_lang_repeat_135(lang) LCDML_DISP_lang_repeat_134(lang) LCDML_DISP_lang(135, lang), + #define LCDML_DISP_lang_repeat_134(lang) LCDML_DISP_lang_repeat_133(lang) LCDML_DISP_lang(134, lang), + #define LCDML_DISP_lang_repeat_133(lang) LCDML_DISP_lang_repeat_132(lang) LCDML_DISP_lang(133, lang), + #define LCDML_DISP_lang_repeat_132(lang) LCDML_DISP_lang_repeat_131(lang) LCDML_DISP_lang(132, lang), + #define LCDML_DISP_lang_repeat_131(lang) LCDML_DISP_lang_repeat_130(lang) LCDML_DISP_lang(131, lang), + #define LCDML_DISP_lang_repeat_130(lang) LCDML_DISP_lang_repeat_129(lang) LCDML_DISP_lang(130, lang), + #define LCDML_DISP_lang_repeat_129(lang) LCDML_DISP_lang_repeat_128(lang) LCDML_DISP_lang(129, lang), + #define LCDML_DISP_lang_repeat_128(lang) LCDML_DISP_lang_repeat_127(lang) LCDML_DISP_lang(128, lang), + #define LCDML_DISP_lang_repeat_127(lang) LCDML_DISP_lang_repeat_126(lang) LCDML_DISP_lang(127, lang), + #define LCDML_DISP_lang_repeat_126(lang) LCDML_DISP_lang_repeat_125(lang) LCDML_DISP_lang(126, lang), + #define LCDML_DISP_lang_repeat_125(lang) LCDML_DISP_lang_repeat_124(lang) LCDML_DISP_lang(125, lang), + #define LCDML_DISP_lang_repeat_124(lang) LCDML_DISP_lang_repeat_123(lang) LCDML_DISP_lang(124, lang), + #define LCDML_DISP_lang_repeat_123(lang) LCDML_DISP_lang_repeat_122(lang) LCDML_DISP_lang(123, lang), + #define LCDML_DISP_lang_repeat_122(lang) LCDML_DISP_lang_repeat_121(lang) LCDML_DISP_lang(122, lang), + #define LCDML_DISP_lang_repeat_121(lang) LCDML_DISP_lang_repeat_120(lang) LCDML_DISP_lang(121, lang), + #define LCDML_DISP_lang_repeat_120(lang) LCDML_DISP_lang_repeat_119(lang) LCDML_DISP_lang(120, lang), + #define LCDML_DISP_lang_repeat_119(lang) LCDML_DISP_lang_repeat_118(lang) LCDML_DISP_lang(119, lang), + #define LCDML_DISP_lang_repeat_118(lang) LCDML_DISP_lang_repeat_117(lang) LCDML_DISP_lang(118, lang), + #define LCDML_DISP_lang_repeat_117(lang) LCDML_DISP_lang_repeat_116(lang) LCDML_DISP_lang(117, lang), + #define LCDML_DISP_lang_repeat_116(lang) LCDML_DISP_lang_repeat_115(lang) LCDML_DISP_lang(116, lang), + #define LCDML_DISP_lang_repeat_115(lang) LCDML_DISP_lang_repeat_114(lang) LCDML_DISP_lang(115, lang), + #define LCDML_DISP_lang_repeat_114(lang) LCDML_DISP_lang_repeat_113(lang) LCDML_DISP_lang(114, lang), + #define LCDML_DISP_lang_repeat_113(lang) LCDML_DISP_lang_repeat_112(lang) LCDML_DISP_lang(113, lang), + #define LCDML_DISP_lang_repeat_112(lang) LCDML_DISP_lang_repeat_111(lang) LCDML_DISP_lang(112, lang), + #define LCDML_DISP_lang_repeat_111(lang) LCDML_DISP_lang_repeat_110(lang) LCDML_DISP_lang(111, lang), + #define LCDML_DISP_lang_repeat_110(lang) LCDML_DISP_lang_repeat_109(lang) LCDML_DISP_lang(110, lang), + #define LCDML_DISP_lang_repeat_109(lang) LCDML_DISP_lang_repeat_108(lang) LCDML_DISP_lang(109, lang), + #define LCDML_DISP_lang_repeat_108(lang) LCDML_DISP_lang_repeat_107(lang) LCDML_DISP_lang(108, lang), + #define LCDML_DISP_lang_repeat_107(lang) LCDML_DISP_lang_repeat_106(lang) LCDML_DISP_lang(107, lang), + #define LCDML_DISP_lang_repeat_106(lang) LCDML_DISP_lang_repeat_105(lang) LCDML_DISP_lang(106, lang), + #define LCDML_DISP_lang_repeat_105(lang) LCDML_DISP_lang_repeat_104(lang) LCDML_DISP_lang(105, lang), + #define LCDML_DISP_lang_repeat_104(lang) LCDML_DISP_lang_repeat_103(lang) LCDML_DISP_lang(104, lang), + #define LCDML_DISP_lang_repeat_103(lang) LCDML_DISP_lang_repeat_102(lang) LCDML_DISP_lang(103, lang), + #define LCDML_DISP_lang_repeat_102(lang) LCDML_DISP_lang_repeat_101(lang) LCDML_DISP_lang(102, lang), + #define LCDML_DISP_lang_repeat_101(lang) LCDML_DISP_lang_repeat_100(lang) LCDML_DISP_lang(101, lang), + #define LCDML_DISP_lang_repeat_100(lang) LCDML_DISP_lang_repeat_99(lang) LCDML_DISP_lang(100, lang), + #define LCDML_DISP_lang_repeat_99(lang) LCDML_DISP_lang_repeat_98(lang) LCDML_DISP_lang(99, lang), + #define LCDML_DISP_lang_repeat_98(lang) LCDML_DISP_lang_repeat_97(lang) LCDML_DISP_lang(98, lang), + #define LCDML_DISP_lang_repeat_97(lang) LCDML_DISP_lang_repeat_96(lang) LCDML_DISP_lang(97, lang), + #define LCDML_DISP_lang_repeat_96(lang) LCDML_DISP_lang_repeat_95(lang) LCDML_DISP_lang(96, lang), + #define LCDML_DISP_lang_repeat_95(lang) LCDML_DISP_lang_repeat_94(lang) LCDML_DISP_lang(95, lang), + #define LCDML_DISP_lang_repeat_94(lang) LCDML_DISP_lang_repeat_93(lang) LCDML_DISP_lang(94, lang), + #define LCDML_DISP_lang_repeat_93(lang) LCDML_DISP_lang_repeat_92(lang) LCDML_DISP_lang(93, lang), + #define LCDML_DISP_lang_repeat_92(lang) LCDML_DISP_lang_repeat_91(lang) LCDML_DISP_lang(92, lang), + #define LCDML_DISP_lang_repeat_91(lang) LCDML_DISP_lang_repeat_90(lang) LCDML_DISP_lang(91, lang), + #define LCDML_DISP_lang_repeat_90(lang) LCDML_DISP_lang_repeat_89(lang) LCDML_DISP_lang(90, lang), + #define LCDML_DISP_lang_repeat_89(lang) LCDML_DISP_lang_repeat_88(lang) LCDML_DISP_lang(89, lang), + #define LCDML_DISP_lang_repeat_88(lang) LCDML_DISP_lang_repeat_87(lang) LCDML_DISP_lang(88, lang), + #define LCDML_DISP_lang_repeat_87(lang) LCDML_DISP_lang_repeat_86(lang) LCDML_DISP_lang(87, lang), + #define LCDML_DISP_lang_repeat_86(lang) LCDML_DISP_lang_repeat_85(lang) LCDML_DISP_lang(86, lang), + #define LCDML_DISP_lang_repeat_85(lang) LCDML_DISP_lang_repeat_84(lang) LCDML_DISP_lang(85, lang), + #define LCDML_DISP_lang_repeat_84(lang) LCDML_DISP_lang_repeat_83(lang) LCDML_DISP_lang(84, lang), + #define LCDML_DISP_lang_repeat_83(lang) LCDML_DISP_lang_repeat_82(lang) LCDML_DISP_lang(83, lang), + #define LCDML_DISP_lang_repeat_82(lang) LCDML_DISP_lang_repeat_81(lang) LCDML_DISP_lang(82, lang), + #define LCDML_DISP_lang_repeat_81(lang) LCDML_DISP_lang_repeat_80(lang) LCDML_DISP_lang(81, lang), + #define LCDML_DISP_lang_repeat_80(lang) LCDML_DISP_lang_repeat_79(lang) LCDML_DISP_lang(80, lang), + #define LCDML_DISP_lang_repeat_79(lang) LCDML_DISP_lang_repeat_78(lang) LCDML_DISP_lang(79, lang), + #define LCDML_DISP_lang_repeat_78(lang) LCDML_DISP_lang_repeat_77(lang) LCDML_DISP_lang(78, lang), + #define LCDML_DISP_lang_repeat_77(lang) LCDML_DISP_lang_repeat_76(lang) LCDML_DISP_lang(77, lang), + #define LCDML_DISP_lang_repeat_76(lang) LCDML_DISP_lang_repeat_75(lang) LCDML_DISP_lang(76, lang), + #define LCDML_DISP_lang_repeat_75(lang) LCDML_DISP_lang_repeat_74(lang) LCDML_DISP_lang(75, lang), + #define LCDML_DISP_lang_repeat_74(lang) LCDML_DISP_lang_repeat_73(lang) LCDML_DISP_lang(74, lang), + #define LCDML_DISP_lang_repeat_73(lang) LCDML_DISP_lang_repeat_72(lang) LCDML_DISP_lang(73, lang), + #define LCDML_DISP_lang_repeat_72(lang) LCDML_DISP_lang_repeat_71(lang) LCDML_DISP_lang(72, lang), + #define LCDML_DISP_lang_repeat_71(lang) LCDML_DISP_lang_repeat_70(lang) LCDML_DISP_lang(71, lang), + #define LCDML_DISP_lang_repeat_70(lang) LCDML_DISP_lang_repeat_69(lang) LCDML_DISP_lang(70, lang), + #define LCDML_DISP_lang_repeat_69(lang) LCDML_DISP_lang_repeat_68(lang) LCDML_DISP_lang(69, lang), + #define LCDML_DISP_lang_repeat_68(lang) LCDML_DISP_lang_repeat_67(lang) LCDML_DISP_lang(68, lang), + #define LCDML_DISP_lang_repeat_67(lang) LCDML_DISP_lang_repeat_66(lang) LCDML_DISP_lang(67, lang), + #define LCDML_DISP_lang_repeat_66(lang) LCDML_DISP_lang_repeat_65(lang) LCDML_DISP_lang(66, lang), + #define LCDML_DISP_lang_repeat_65(lang) LCDML_DISP_lang_repeat_64(lang) LCDML_DISP_lang(65, lang), + #define LCDML_DISP_lang_repeat_64(lang) LCDML_DISP_lang_repeat_63(lang) LCDML_DISP_lang(64, lang), + #define LCDML_DISP_lang_repeat_63(lang) LCDML_DISP_lang_repeat_62(lang) LCDML_DISP_lang(63, lang), + #define LCDML_DISP_lang_repeat_62(lang) LCDML_DISP_lang_repeat_61(lang) LCDML_DISP_lang(62, lang), + #define LCDML_DISP_lang_repeat_61(lang) LCDML_DISP_lang_repeat_60(lang) LCDML_DISP_lang(61, lang), + #define LCDML_DISP_lang_repeat_60(lang) LCDML_DISP_lang_repeat_59(lang) LCDML_DISP_lang(60, lang), + #define LCDML_DISP_lang_repeat_59(lang) LCDML_DISP_lang_repeat_58(lang) LCDML_DISP_lang(59, lang), + #define LCDML_DISP_lang_repeat_58(lang) LCDML_DISP_lang_repeat_57(lang) LCDML_DISP_lang(58, lang), + #define LCDML_DISP_lang_repeat_57(lang) LCDML_DISP_lang_repeat_56(lang) LCDML_DISP_lang(57, lang), + #define LCDML_DISP_lang_repeat_56(lang) LCDML_DISP_lang_repeat_55(lang) LCDML_DISP_lang(56, lang), + #define LCDML_DISP_lang_repeat_55(lang) LCDML_DISP_lang_repeat_54(lang) LCDML_DISP_lang(55, lang), + #define LCDML_DISP_lang_repeat_54(lang) LCDML_DISP_lang_repeat_53(lang) LCDML_DISP_lang(54, lang), + #define LCDML_DISP_lang_repeat_53(lang) LCDML_DISP_lang_repeat_52(lang) LCDML_DISP_lang(53, lang), + #define LCDML_DISP_lang_repeat_52(lang) LCDML_DISP_lang_repeat_51(lang) LCDML_DISP_lang(52, lang), + #define LCDML_DISP_lang_repeat_51(lang) LCDML_DISP_lang_repeat_50(lang) LCDML_DISP_lang(51, lang), + #define LCDML_DISP_lang_repeat_50(lang) LCDML_DISP_lang_repeat_49(lang) LCDML_DISP_lang(50, lang), + #define LCDML_DISP_lang_repeat_49(lang) LCDML_DISP_lang_repeat_48(lang) LCDML_DISP_lang(49, lang), + #define LCDML_DISP_lang_repeat_48(lang) LCDML_DISP_lang_repeat_47(lang) LCDML_DISP_lang(48, lang), + #define LCDML_DISP_lang_repeat_47(lang) LCDML_DISP_lang_repeat_46(lang) LCDML_DISP_lang(47, lang), + #define LCDML_DISP_lang_repeat_46(lang) LCDML_DISP_lang_repeat_45(lang) LCDML_DISP_lang(46, lang), + #define LCDML_DISP_lang_repeat_45(lang) LCDML_DISP_lang_repeat_44(lang) LCDML_DISP_lang(45, lang), + #define LCDML_DISP_lang_repeat_44(lang) LCDML_DISP_lang_repeat_43(lang) LCDML_DISP_lang(44, lang), + #define LCDML_DISP_lang_repeat_43(lang) LCDML_DISP_lang_repeat_42(lang) LCDML_DISP_lang(43, lang), + #define LCDML_DISP_lang_repeat_42(lang) LCDML_DISP_lang_repeat_41(lang) LCDML_DISP_lang(42, lang), + #define LCDML_DISP_lang_repeat_41(lang) LCDML_DISP_lang_repeat_40(lang) LCDML_DISP_lang(41, lang), + #define LCDML_DISP_lang_repeat_40(lang) LCDML_DISP_lang_repeat_39(lang) LCDML_DISP_lang(40, lang), + #define LCDML_DISP_lang_repeat_39(lang) LCDML_DISP_lang_repeat_38(lang) LCDML_DISP_lang(39, lang), + #define LCDML_DISP_lang_repeat_38(lang) LCDML_DISP_lang_repeat_37(lang) LCDML_DISP_lang(38, lang), + #define LCDML_DISP_lang_repeat_37(lang) LCDML_DISP_lang_repeat_36(lang) LCDML_DISP_lang(37, lang), + #define LCDML_DISP_lang_repeat_36(lang) LCDML_DISP_lang_repeat_35(lang) LCDML_DISP_lang(36, lang), + #define LCDML_DISP_lang_repeat_35(lang) LCDML_DISP_lang_repeat_34(lang) LCDML_DISP_lang(35, lang), + #define LCDML_DISP_lang_repeat_34(lang) LCDML_DISP_lang_repeat_33(lang) LCDML_DISP_lang(34, lang), + #define LCDML_DISP_lang_repeat_33(lang) LCDML_DISP_lang_repeat_32(lang) LCDML_DISP_lang(33, lang), + #define LCDML_DISP_lang_repeat_32(lang) LCDML_DISP_lang_repeat_31(lang) LCDML_DISP_lang(32, lang), + #define LCDML_DISP_lang_repeat_31(lang) LCDML_DISP_lang_repeat_30(lang) LCDML_DISP_lang(31, lang), + #define LCDML_DISP_lang_repeat_30(lang) LCDML_DISP_lang_repeat_29(lang) LCDML_DISP_lang(30, lang), + #define LCDML_DISP_lang_repeat_29(lang) LCDML_DISP_lang_repeat_28(lang) LCDML_DISP_lang(29, lang), + #define LCDML_DISP_lang_repeat_28(lang) LCDML_DISP_lang_repeat_27(lang) LCDML_DISP_lang(28, lang), + #define LCDML_DISP_lang_repeat_27(lang) LCDML_DISP_lang_repeat_26(lang) LCDML_DISP_lang(27, lang), + #define LCDML_DISP_lang_repeat_26(lang) LCDML_DISP_lang_repeat_25(lang) LCDML_DISP_lang(26, lang), + #define LCDML_DISP_lang_repeat_25(lang) LCDML_DISP_lang_repeat_24(lang) LCDML_DISP_lang(25, lang), + #define LCDML_DISP_lang_repeat_24(lang) LCDML_DISP_lang_repeat_23(lang) LCDML_DISP_lang(24, lang), + #define LCDML_DISP_lang_repeat_23(lang) LCDML_DISP_lang_repeat_22(lang) LCDML_DISP_lang(23, lang), + #define LCDML_DISP_lang_repeat_22(lang) LCDML_DISP_lang_repeat_21(lang) LCDML_DISP_lang(22, lang), + #define LCDML_DISP_lang_repeat_21(lang) LCDML_DISP_lang_repeat_20(lang) LCDML_DISP_lang(21, lang), + #define LCDML_DISP_lang_repeat_20(lang) LCDML_DISP_lang_repeat_19(lang) LCDML_DISP_lang(20, lang), + #define LCDML_DISP_lang_repeat_19(lang) LCDML_DISP_lang_repeat_18(lang) LCDML_DISP_lang(19, lang), + #define LCDML_DISP_lang_repeat_18(lang) LCDML_DISP_lang_repeat_17(lang) LCDML_DISP_lang(18, lang), + #define LCDML_DISP_lang_repeat_17(lang) LCDML_DISP_lang_repeat_16(lang) LCDML_DISP_lang(17, lang), + #define LCDML_DISP_lang_repeat_16(lang) LCDML_DISP_lang_repeat_15(lang) LCDML_DISP_lang(16, lang), + #define LCDML_DISP_lang_repeat_15(lang) LCDML_DISP_lang_repeat_14(lang) LCDML_DISP_lang(15, lang), + #define LCDML_DISP_lang_repeat_14(lang) LCDML_DISP_lang_repeat_13(lang) LCDML_DISP_lang(14, lang), + #define LCDML_DISP_lang_repeat_13(lang) LCDML_DISP_lang_repeat_12(lang) LCDML_DISP_lang(13, lang), + #define LCDML_DISP_lang_repeat_12(lang) LCDML_DISP_lang_repeat_11(lang) LCDML_DISP_lang(12, lang), + #define LCDML_DISP_lang_repeat_11(lang) LCDML_DISP_lang_repeat_10(lang) LCDML_DISP_lang(11, lang), + #define LCDML_DISP_lang_repeat_10(lang) LCDML_DISP_lang_repeat_9(lang) LCDML_DISP_lang(10, lang), + #define LCDML_DISP_lang_repeat_9(lang) LCDML_DISP_lang_repeat_8(lang) LCDML_DISP_lang(9, lang), + #define LCDML_DISP_lang_repeat_8(lang) LCDML_DISP_lang_repeat_7(lang) LCDML_DISP_lang(8, lang), + #define LCDML_DISP_lang_repeat_7(lang) LCDML_DISP_lang_repeat_6(lang) LCDML_DISP_lang(7, lang), + #define LCDML_DISP_lang_repeat_6(lang) LCDML_DISP_lang_repeat_5(lang) LCDML_DISP_lang(6, lang), + #define LCDML_DISP_lang_repeat_5(lang) LCDML_DISP_lang_repeat_4(lang) LCDML_DISP_lang(5, lang), + #define LCDML_DISP_lang_repeat_4(lang) LCDML_DISP_lang_repeat_3(lang) LCDML_DISP_lang(4, lang), + #define LCDML_DISP_lang_repeat_3(lang) LCDML_DISP_lang_repeat_2(lang) LCDML_DISP_lang(3, lang), + #define LCDML_DISP_lang_repeat_2(lang) LCDML_DISP_lang_repeat_1(lang) LCDML_DISP_lang(2, lang), + #define LCDML_DISP_lang_repeat_1(lang) LCDML_DISP_lang_repeat_0(lang) LCDML_DISP_lang(1, lang), + #define LCDML_DISP_lang_repeat_0(lang) LCDML_DISP_lang(0, lang), + #define LCDML_DISP_lang_repeat(N, lang) LCDML_DISP_lang_repeat_##N (lang) + + + + + + + + /* --------------------------------------- + * func repeat + * --------------------------------------- + */ + #define LCDML_DISP_func_repeat_255() LCDML_DISP_func_repeat_254() LCDML_DISP_255_function(); + #define LCDML_DISP_func_repeat_254() LCDML_DISP_func_repeat_253() LCDML_DISP_254_function(); + #define LCDML_DISP_func_repeat_253() LCDML_DISP_func_repeat_252() LCDML_DISP_253_function(); + #define LCDML_DISP_func_repeat_252() LCDML_DISP_func_repeat_251() LCDML_DISP_252_function(); + #define LCDML_DISP_func_repeat_251() LCDML_DISP_func_repeat_250() LCDML_DISP_251_function(); + #define LCDML_DISP_func_repeat_250() LCDML_DISP_func_repeat_249() LCDML_DISP_250_function(); + #define LCDML_DISP_func_repeat_249() LCDML_DISP_func_repeat_248() LCDML_DISP_249_function(); + #define LCDML_DISP_func_repeat_248() LCDML_DISP_func_repeat_247() LCDML_DISP_248_function(); + #define LCDML_DISP_func_repeat_247() LCDML_DISP_func_repeat_246() LCDML_DISP_247_function(); + #define LCDML_DISP_func_repeat_246() LCDML_DISP_func_repeat_245() LCDML_DISP_246_function(); + #define LCDML_DISP_func_repeat_245() LCDML_DISP_func_repeat_244() LCDML_DISP_245_function(); + #define LCDML_DISP_func_repeat_244() LCDML_DISP_func_repeat_243() LCDML_DISP_244_function(); + #define LCDML_DISP_func_repeat_243() LCDML_DISP_func_repeat_242() LCDML_DISP_243_function(); + #define LCDML_DISP_func_repeat_242() LCDML_DISP_func_repeat_241() LCDML_DISP_242_function(); + #define LCDML_DISP_func_repeat_241() LCDML_DISP_func_repeat_240() LCDML_DISP_241_function(); + #define LCDML_DISP_func_repeat_240() LCDML_DISP_func_repeat_239() LCDML_DISP_240_function(); + #define LCDML_DISP_func_repeat_239() LCDML_DISP_func_repeat_238() LCDML_DISP_239_function(); + #define LCDML_DISP_func_repeat_238() LCDML_DISP_func_repeat_237() LCDML_DISP_238_function(); + #define LCDML_DISP_func_repeat_237() LCDML_DISP_func_repeat_236() LCDML_DISP_237_function(); + #define LCDML_DISP_func_repeat_236() LCDML_DISP_func_repeat_235() LCDML_DISP_236_function(); + #define LCDML_DISP_func_repeat_235() LCDML_DISP_func_repeat_234() LCDML_DISP_235_function(); + #define LCDML_DISP_func_repeat_234() LCDML_DISP_func_repeat_233() LCDML_DISP_234_function(); + #define LCDML_DISP_func_repeat_233() LCDML_DISP_func_repeat_232() LCDML_DISP_233_function(); + #define LCDML_DISP_func_repeat_232() LCDML_DISP_func_repeat_231() LCDML_DISP_232_function(); + #define LCDML_DISP_func_repeat_231() LCDML_DISP_func_repeat_230() LCDML_DISP_231_function(); + #define LCDML_DISP_func_repeat_230() LCDML_DISP_func_repeat_229() LCDML_DISP_230_function(); + #define LCDML_DISP_func_repeat_229() LCDML_DISP_func_repeat_228() LCDML_DISP_229_function(); + #define LCDML_DISP_func_repeat_228() LCDML_DISP_func_repeat_227() LCDML_DISP_228_function(); + #define LCDML_DISP_func_repeat_227() LCDML_DISP_func_repeat_226() LCDML_DISP_227_function(); + #define LCDML_DISP_func_repeat_226() LCDML_DISP_func_repeat_225() LCDML_DISP_226_function(); + #define LCDML_DISP_func_repeat_225() LCDML_DISP_func_repeat_224() LCDML_DISP_225_function(); + #define LCDML_DISP_func_repeat_224() LCDML_DISP_func_repeat_223() LCDML_DISP_224_function(); + #define LCDML_DISP_func_repeat_223() LCDML_DISP_func_repeat_222() LCDML_DISP_223_function(); + #define LCDML_DISP_func_repeat_222() LCDML_DISP_func_repeat_221() LCDML_DISP_222_function(); + #define LCDML_DISP_func_repeat_221() LCDML_DISP_func_repeat_220() LCDML_DISP_221_function(); + #define LCDML_DISP_func_repeat_220() LCDML_DISP_func_repeat_219() LCDML_DISP_220_function(); + #define LCDML_DISP_func_repeat_219() LCDML_DISP_func_repeat_218() LCDML_DISP_219_function(); + #define LCDML_DISP_func_repeat_218() LCDML_DISP_func_repeat_217() LCDML_DISP_218_function(); + #define LCDML_DISP_func_repeat_217() LCDML_DISP_func_repeat_216() LCDML_DISP_217_function(); + #define LCDML_DISP_func_repeat_216() LCDML_DISP_func_repeat_215() LCDML_DISP_216_function(); + #define LCDML_DISP_func_repeat_215() LCDML_DISP_func_repeat_214() LCDML_DISP_215_function(); + #define LCDML_DISP_func_repeat_214() LCDML_DISP_func_repeat_213() LCDML_DISP_214_function(); + #define LCDML_DISP_func_repeat_213() LCDML_DISP_func_repeat_212() LCDML_DISP_213_function(); + #define LCDML_DISP_func_repeat_212() LCDML_DISP_func_repeat_211() LCDML_DISP_212_function(); + #define LCDML_DISP_func_repeat_211() LCDML_DISP_func_repeat_210() LCDML_DISP_211_function(); + #define LCDML_DISP_func_repeat_210() LCDML_DISP_func_repeat_209() LCDML_DISP_210_function(); + #define LCDML_DISP_func_repeat_209() LCDML_DISP_func_repeat_208() LCDML_DISP_209_function(); + #define LCDML_DISP_func_repeat_208() LCDML_DISP_func_repeat_207() LCDML_DISP_208_function(); + #define LCDML_DISP_func_repeat_207() LCDML_DISP_func_repeat_206() LCDML_DISP_207_function(); + #define LCDML_DISP_func_repeat_206() LCDML_DISP_func_repeat_205() LCDML_DISP_206_function(); + #define LCDML_DISP_func_repeat_205() LCDML_DISP_func_repeat_204() LCDML_DISP_205_function(); + #define LCDML_DISP_func_repeat_204() LCDML_DISP_func_repeat_203() LCDML_DISP_204_function(); + #define LCDML_DISP_func_repeat_203() LCDML_DISP_func_repeat_202() LCDML_DISP_203_function(); + #define LCDML_DISP_func_repeat_202() LCDML_DISP_func_repeat_201() LCDML_DISP_202_function(); + #define LCDML_DISP_func_repeat_201() LCDML_DISP_func_repeat_200() LCDML_DISP_201_function(); + #define LCDML_DISP_func_repeat_200() LCDML_DISP_func_repeat_199() LCDML_DISP_200_function(); + #define LCDML_DISP_func_repeat_199() LCDML_DISP_func_repeat_198() LCDML_DISP_199_function(); + #define LCDML_DISP_func_repeat_198() LCDML_DISP_func_repeat_197() LCDML_DISP_198_function(); + #define LCDML_DISP_func_repeat_197() LCDML_DISP_func_repeat_196() LCDML_DISP_197_function(); + #define LCDML_DISP_func_repeat_196() LCDML_DISP_func_repeat_195() LCDML_DISP_196_function(); + #define LCDML_DISP_func_repeat_195() LCDML_DISP_func_repeat_194() LCDML_DISP_195_function(); + #define LCDML_DISP_func_repeat_194() LCDML_DISP_func_repeat_193() LCDML_DISP_194_function(); + #define LCDML_DISP_func_repeat_193() LCDML_DISP_func_repeat_192() LCDML_DISP_193_function(); + #define LCDML_DISP_func_repeat_192() LCDML_DISP_func_repeat_191() LCDML_DISP_192_function(); + #define LCDML_DISP_func_repeat_191() LCDML_DISP_func_repeat_190() LCDML_DISP_191_function(); + #define LCDML_DISP_func_repeat_190() LCDML_DISP_func_repeat_189() LCDML_DISP_190_function(); + #define LCDML_DISP_func_repeat_189() LCDML_DISP_func_repeat_188() LCDML_DISP_189_function(); + #define LCDML_DISP_func_repeat_188() LCDML_DISP_func_repeat_187() LCDML_DISP_188_function(); + #define LCDML_DISP_func_repeat_187() LCDML_DISP_func_repeat_186() LCDML_DISP_187_function(); + #define LCDML_DISP_func_repeat_186() LCDML_DISP_func_repeat_185() LCDML_DISP_186_function(); + #define LCDML_DISP_func_repeat_185() LCDML_DISP_func_repeat_184() LCDML_DISP_185_function(); + #define LCDML_DISP_func_repeat_184() LCDML_DISP_func_repeat_183() LCDML_DISP_184_function(); + #define LCDML_DISP_func_repeat_183() LCDML_DISP_func_repeat_182() LCDML_DISP_183_function(); + #define LCDML_DISP_func_repeat_182() LCDML_DISP_func_repeat_181() LCDML_DISP_182_function(); + #define LCDML_DISP_func_repeat_181() LCDML_DISP_func_repeat_180() LCDML_DISP_181_function(); + #define LCDML_DISP_func_repeat_180() LCDML_DISP_func_repeat_179() LCDML_DISP_180_function(); + #define LCDML_DISP_func_repeat_179() LCDML_DISP_func_repeat_178() LCDML_DISP_179_function(); + #define LCDML_DISP_func_repeat_178() LCDML_DISP_func_repeat_177() LCDML_DISP_178_function(); + #define LCDML_DISP_func_repeat_177() LCDML_DISP_func_repeat_176() LCDML_DISP_177_function(); + #define LCDML_DISP_func_repeat_176() LCDML_DISP_func_repeat_175() LCDML_DISP_176_function(); + #define LCDML_DISP_func_repeat_175() LCDML_DISP_func_repeat_174() LCDML_DISP_175_function(); + #define LCDML_DISP_func_repeat_174() LCDML_DISP_func_repeat_173() LCDML_DISP_174_function(); + #define LCDML_DISP_func_repeat_173() LCDML_DISP_func_repeat_172() LCDML_DISP_173_function(); + #define LCDML_DISP_func_repeat_172() LCDML_DISP_func_repeat_171() LCDML_DISP_172_function(); + #define LCDML_DISP_func_repeat_171() LCDML_DISP_func_repeat_170() LCDML_DISP_171_function(); + #define LCDML_DISP_func_repeat_170() LCDML_DISP_func_repeat_169() LCDML_DISP_170_function(); + #define LCDML_DISP_func_repeat_169() LCDML_DISP_func_repeat_168() LCDML_DISP_169_function(); + #define LCDML_DISP_func_repeat_168() LCDML_DISP_func_repeat_167() LCDML_DISP_168_function(); + #define LCDML_DISP_func_repeat_167() LCDML_DISP_func_repeat_166() LCDML_DISP_167_function(); + #define LCDML_DISP_func_repeat_166() LCDML_DISP_func_repeat_165() LCDML_DISP_166_function(); + #define LCDML_DISP_func_repeat_165() LCDML_DISP_func_repeat_164() LCDML_DISP_165_function(); + #define LCDML_DISP_func_repeat_164() LCDML_DISP_func_repeat_163() LCDML_DISP_164_function(); + #define LCDML_DISP_func_repeat_163() LCDML_DISP_func_repeat_162() LCDML_DISP_163_function(); + #define LCDML_DISP_func_repeat_162() LCDML_DISP_func_repeat_161() LCDML_DISP_162_function(); + #define LCDML_DISP_func_repeat_161() LCDML_DISP_func_repeat_160() LCDML_DISP_161_function(); + #define LCDML_DISP_func_repeat_160() LCDML_DISP_func_repeat_159() LCDML_DISP_160_function(); + #define LCDML_DISP_func_repeat_159() LCDML_DISP_func_repeat_158() LCDML_DISP_159_function(); + #define LCDML_DISP_func_repeat_158() LCDML_DISP_func_repeat_157() LCDML_DISP_158_function(); + #define LCDML_DISP_func_repeat_157() LCDML_DISP_func_repeat_156() LCDML_DISP_157_function(); + #define LCDML_DISP_func_repeat_156() LCDML_DISP_func_repeat_155() LCDML_DISP_156_function(); + #define LCDML_DISP_func_repeat_155() LCDML_DISP_func_repeat_154() LCDML_DISP_155_function(); + #define LCDML_DISP_func_repeat_154() LCDML_DISP_func_repeat_153() LCDML_DISP_154_function(); + #define LCDML_DISP_func_repeat_153() LCDML_DISP_func_repeat_152() LCDML_DISP_153_function(); + #define LCDML_DISP_func_repeat_152() LCDML_DISP_func_repeat_151() LCDML_DISP_152_function(); + #define LCDML_DISP_func_repeat_151() LCDML_DISP_func_repeat_150() LCDML_DISP_151_function(); + #define LCDML_DISP_func_repeat_150() LCDML_DISP_func_repeat_149() LCDML_DISP_150_function(); + #define LCDML_DISP_func_repeat_149() LCDML_DISP_func_repeat_148() LCDML_DISP_149_function(); + #define LCDML_DISP_func_repeat_148() LCDML_DISP_func_repeat_147() LCDML_DISP_148_function(); + #define LCDML_DISP_func_repeat_147() LCDML_DISP_func_repeat_146() LCDML_DISP_147_function(); + #define LCDML_DISP_func_repeat_146() LCDML_DISP_func_repeat_145() LCDML_DISP_146_function(); + #define LCDML_DISP_func_repeat_145() LCDML_DISP_func_repeat_144() LCDML_DISP_145_function(); + #define LCDML_DISP_func_repeat_144() LCDML_DISP_func_repeat_143() LCDML_DISP_144_function(); + #define LCDML_DISP_func_repeat_143() LCDML_DISP_func_repeat_142() LCDML_DISP_143_function(); + #define LCDML_DISP_func_repeat_142() LCDML_DISP_func_repeat_141() LCDML_DISP_142_function(); + #define LCDML_DISP_func_repeat_141() LCDML_DISP_func_repeat_140() LCDML_DISP_141_function(); + #define LCDML_DISP_func_repeat_140() LCDML_DISP_func_repeat_139() LCDML_DISP_140_function(); + #define LCDML_DISP_func_repeat_139() LCDML_DISP_func_repeat_138() LCDML_DISP_139_function(); + #define LCDML_DISP_func_repeat_138() LCDML_DISP_func_repeat_137() LCDML_DISP_138_function(); + #define LCDML_DISP_func_repeat_137() LCDML_DISP_func_repeat_136() LCDML_DISP_137_function(); + #define LCDML_DISP_func_repeat_136() LCDML_DISP_func_repeat_135() LCDML_DISP_136_function(); + #define LCDML_DISP_func_repeat_135() LCDML_DISP_func_repeat_134() LCDML_DISP_135_function(); + #define LCDML_DISP_func_repeat_134() LCDML_DISP_func_repeat_133() LCDML_DISP_134_function(); + #define LCDML_DISP_func_repeat_133() LCDML_DISP_func_repeat_132() LCDML_DISP_133_function(); + #define LCDML_DISP_func_repeat_132() LCDML_DISP_func_repeat_131() LCDML_DISP_132_function(); + #define LCDML_DISP_func_repeat_131() LCDML_DISP_func_repeat_130() LCDML_DISP_131_function(); + #define LCDML_DISP_func_repeat_130() LCDML_DISP_func_repeat_129() LCDML_DISP_130_function(); + #define LCDML_DISP_func_repeat_129() LCDML_DISP_func_repeat_128() LCDML_DISP_129_function(); + #define LCDML_DISP_func_repeat_128() LCDML_DISP_func_repeat_127() LCDML_DISP_128_function(); + #define LCDML_DISP_func_repeat_127() LCDML_DISP_func_repeat_126() LCDML_DISP_127_function(); + #define LCDML_DISP_func_repeat_126() LCDML_DISP_func_repeat_125() LCDML_DISP_126_function(); + #define LCDML_DISP_func_repeat_125() LCDML_DISP_func_repeat_124() LCDML_DISP_125_function(); + #define LCDML_DISP_func_repeat_124() LCDML_DISP_func_repeat_123() LCDML_DISP_124_function(); + #define LCDML_DISP_func_repeat_123() LCDML_DISP_func_repeat_122() LCDML_DISP_123_function(); + #define LCDML_DISP_func_repeat_122() LCDML_DISP_func_repeat_121() LCDML_DISP_122_function(); + #define LCDML_DISP_func_repeat_121() LCDML_DISP_func_repeat_120() LCDML_DISP_121_function(); + #define LCDML_DISP_func_repeat_120() LCDML_DISP_func_repeat_119() LCDML_DISP_120_function(); + #define LCDML_DISP_func_repeat_119() LCDML_DISP_func_repeat_118() LCDML_DISP_119_function(); + #define LCDML_DISP_func_repeat_118() LCDML_DISP_func_repeat_117() LCDML_DISP_118_function(); + #define LCDML_DISP_func_repeat_117() LCDML_DISP_func_repeat_116() LCDML_DISP_117_function(); + #define LCDML_DISP_func_repeat_116() LCDML_DISP_func_repeat_115() LCDML_DISP_116_function(); + #define LCDML_DISP_func_repeat_115() LCDML_DISP_func_repeat_114() LCDML_DISP_115_function(); + #define LCDML_DISP_func_repeat_114() LCDML_DISP_func_repeat_113() LCDML_DISP_114_function(); + #define LCDML_DISP_func_repeat_113() LCDML_DISP_func_repeat_112() LCDML_DISP_113_function(); + #define LCDML_DISP_func_repeat_112() LCDML_DISP_func_repeat_111() LCDML_DISP_112_function(); + #define LCDML_DISP_func_repeat_111() LCDML_DISP_func_repeat_110() LCDML_DISP_111_function(); + #define LCDML_DISP_func_repeat_110() LCDML_DISP_func_repeat_109() LCDML_DISP_110_function(); + #define LCDML_DISP_func_repeat_109() LCDML_DISP_func_repeat_108() LCDML_DISP_109_function(); + #define LCDML_DISP_func_repeat_108() LCDML_DISP_func_repeat_107() LCDML_DISP_108_function(); + #define LCDML_DISP_func_repeat_107() LCDML_DISP_func_repeat_106() LCDML_DISP_107_function(); + #define LCDML_DISP_func_repeat_106() LCDML_DISP_func_repeat_105() LCDML_DISP_106_function(); + #define LCDML_DISP_func_repeat_105() LCDML_DISP_func_repeat_104() LCDML_DISP_105_function(); + #define LCDML_DISP_func_repeat_104() LCDML_DISP_func_repeat_103() LCDML_DISP_104_function(); + #define LCDML_DISP_func_repeat_103() LCDML_DISP_func_repeat_102() LCDML_DISP_103_function(); + #define LCDML_DISP_func_repeat_102() LCDML_DISP_func_repeat_101() LCDML_DISP_102_function(); + #define LCDML_DISP_func_repeat_101() LCDML_DISP_func_repeat_100() LCDML_DISP_101_function(); + #define LCDML_DISP_func_repeat_100() LCDML_DISP_func_repeat_99() LCDML_DISP_100_function(); + #define LCDML_DISP_func_repeat_99() LCDML_DISP_func_repeat_98() LCDML_DISP_99_function(); + #define LCDML_DISP_func_repeat_98() LCDML_DISP_func_repeat_97() LCDML_DISP_98_function(); + #define LCDML_DISP_func_repeat_97() LCDML_DISP_func_repeat_96() LCDML_DISP_97_function(); + #define LCDML_DISP_func_repeat_96() LCDML_DISP_func_repeat_95() LCDML_DISP_96_function(); + #define LCDML_DISP_func_repeat_95() LCDML_DISP_func_repeat_94() LCDML_DISP_95_function(); + #define LCDML_DISP_func_repeat_94() LCDML_DISP_func_repeat_93() LCDML_DISP_94_function(); + #define LCDML_DISP_func_repeat_93() LCDML_DISP_func_repeat_92() LCDML_DISP_93_function(); + #define LCDML_DISP_func_repeat_92() LCDML_DISP_func_repeat_91() LCDML_DISP_92_function(); + #define LCDML_DISP_func_repeat_91() LCDML_DISP_func_repeat_90() LCDML_DISP_91_function(); + #define LCDML_DISP_func_repeat_90() LCDML_DISP_func_repeat_89() LCDML_DISP_90_function(); + #define LCDML_DISP_func_repeat_89() LCDML_DISP_func_repeat_88() LCDML_DISP_89_function(); + #define LCDML_DISP_func_repeat_88() LCDML_DISP_func_repeat_87() LCDML_DISP_88_function(); + #define LCDML_DISP_func_repeat_87() LCDML_DISP_func_repeat_86() LCDML_DISP_87_function(); + #define LCDML_DISP_func_repeat_86() LCDML_DISP_func_repeat_85() LCDML_DISP_86_function(); + #define LCDML_DISP_func_repeat_85() LCDML_DISP_func_repeat_84() LCDML_DISP_85_function(); + #define LCDML_DISP_func_repeat_84() LCDML_DISP_func_repeat_83() LCDML_DISP_84_function(); + #define LCDML_DISP_func_repeat_83() LCDML_DISP_func_repeat_82() LCDML_DISP_83_function(); + #define LCDML_DISP_func_repeat_82() LCDML_DISP_func_repeat_81() LCDML_DISP_82_function(); + #define LCDML_DISP_func_repeat_81() LCDML_DISP_func_repeat_80() LCDML_DISP_81_function(); + #define LCDML_DISP_func_repeat_80() LCDML_DISP_func_repeat_79() LCDML_DISP_80_function(); + #define LCDML_DISP_func_repeat_79() LCDML_DISP_func_repeat_78() LCDML_DISP_79_function(); + #define LCDML_DISP_func_repeat_78() LCDML_DISP_func_repeat_77() LCDML_DISP_78_function(); + #define LCDML_DISP_func_repeat_77() LCDML_DISP_func_repeat_76() LCDML_DISP_77_function(); + #define LCDML_DISP_func_repeat_76() LCDML_DISP_func_repeat_75() LCDML_DISP_76_function(); + #define LCDML_DISP_func_repeat_75() LCDML_DISP_func_repeat_74() LCDML_DISP_75_function(); + #define LCDML_DISP_func_repeat_74() LCDML_DISP_func_repeat_73() LCDML_DISP_74_function(); + #define LCDML_DISP_func_repeat_73() LCDML_DISP_func_repeat_72() LCDML_DISP_73_function(); + #define LCDML_DISP_func_repeat_72() LCDML_DISP_func_repeat_71() LCDML_DISP_72_function(); + #define LCDML_DISP_func_repeat_71() LCDML_DISP_func_repeat_70() LCDML_DISP_71_function(); + #define LCDML_DISP_func_repeat_70() LCDML_DISP_func_repeat_69() LCDML_DISP_70_function(); + #define LCDML_DISP_func_repeat_69() LCDML_DISP_func_repeat_68() LCDML_DISP_69_function(); + #define LCDML_DISP_func_repeat_68() LCDML_DISP_func_repeat_67() LCDML_DISP_68_function(); + #define LCDML_DISP_func_repeat_67() LCDML_DISP_func_repeat_66() LCDML_DISP_67_function(); + #define LCDML_DISP_func_repeat_66() LCDML_DISP_func_repeat_65() LCDML_DISP_66_function(); + #define LCDML_DISP_func_repeat_65() LCDML_DISP_func_repeat_64() LCDML_DISP_65_function(); + #define LCDML_DISP_func_repeat_64() LCDML_DISP_func_repeat_63() LCDML_DISP_64_function(); + #define LCDML_DISP_func_repeat_63() LCDML_DISP_func_repeat_62() LCDML_DISP_63_function(); + #define LCDML_DISP_func_repeat_62() LCDML_DISP_func_repeat_61() LCDML_DISP_62_function(); + #define LCDML_DISP_func_repeat_61() LCDML_DISP_func_repeat_60() LCDML_DISP_61_function(); + #define LCDML_DISP_func_repeat_60() LCDML_DISP_func_repeat_59() LCDML_DISP_60_function(); + #define LCDML_DISP_func_repeat_59() LCDML_DISP_func_repeat_58() LCDML_DISP_59_function(); + #define LCDML_DISP_func_repeat_58() LCDML_DISP_func_repeat_57() LCDML_DISP_58_function(); + #define LCDML_DISP_func_repeat_57() LCDML_DISP_func_repeat_56() LCDML_DISP_57_function(); + #define LCDML_DISP_func_repeat_56() LCDML_DISP_func_repeat_55() LCDML_DISP_56_function(); + #define LCDML_DISP_func_repeat_55() LCDML_DISP_func_repeat_54() LCDML_DISP_55_function(); + #define LCDML_DISP_func_repeat_54() LCDML_DISP_func_repeat_53() LCDML_DISP_54_function(); + #define LCDML_DISP_func_repeat_53() LCDML_DISP_func_repeat_52() LCDML_DISP_53_function(); + #define LCDML_DISP_func_repeat_52() LCDML_DISP_func_repeat_51() LCDML_DISP_52_function(); + #define LCDML_DISP_func_repeat_51() LCDML_DISP_func_repeat_50() LCDML_DISP_51_function(); + #define LCDML_DISP_func_repeat_50() LCDML_DISP_func_repeat_49() LCDML_DISP_50_function(); + #define LCDML_DISP_func_repeat_49() LCDML_DISP_func_repeat_48() LCDML_DISP_49_function(); + #define LCDML_DISP_func_repeat_48() LCDML_DISP_func_repeat_47() LCDML_DISP_48_function(); + #define LCDML_DISP_func_repeat_47() LCDML_DISP_func_repeat_46() LCDML_DISP_47_function(); + #define LCDML_DISP_func_repeat_46() LCDML_DISP_func_repeat_45() LCDML_DISP_46_function(); + #define LCDML_DISP_func_repeat_45() LCDML_DISP_func_repeat_44() LCDML_DISP_45_function(); + #define LCDML_DISP_func_repeat_44() LCDML_DISP_func_repeat_43() LCDML_DISP_44_function(); + #define LCDML_DISP_func_repeat_43() LCDML_DISP_func_repeat_42() LCDML_DISP_43_function(); + #define LCDML_DISP_func_repeat_42() LCDML_DISP_func_repeat_41() LCDML_DISP_42_function(); + #define LCDML_DISP_func_repeat_41() LCDML_DISP_func_repeat_40() LCDML_DISP_41_function(); + #define LCDML_DISP_func_repeat_40() LCDML_DISP_func_repeat_39() LCDML_DISP_40_function(); + #define LCDML_DISP_func_repeat_39() LCDML_DISP_func_repeat_38() LCDML_DISP_39_function(); + #define LCDML_DISP_func_repeat_38() LCDML_DISP_func_repeat_37() LCDML_DISP_38_function(); + #define LCDML_DISP_func_repeat_37() LCDML_DISP_func_repeat_36() LCDML_DISP_37_function(); + #define LCDML_DISP_func_repeat_36() LCDML_DISP_func_repeat_35() LCDML_DISP_36_function(); + #define LCDML_DISP_func_repeat_35() LCDML_DISP_func_repeat_34() LCDML_DISP_35_function(); + #define LCDML_DISP_func_repeat_34() LCDML_DISP_func_repeat_33() LCDML_DISP_34_function(); + #define LCDML_DISP_func_repeat_33() LCDML_DISP_func_repeat_32() LCDML_DISP_33_function(); + #define LCDML_DISP_func_repeat_32() LCDML_DISP_func_repeat_31() LCDML_DISP_32_function(); + #define LCDML_DISP_func_repeat_31() LCDML_DISP_func_repeat_30() LCDML_DISP_31_function(); + #define LCDML_DISP_func_repeat_30() LCDML_DISP_func_repeat_29() LCDML_DISP_30_function(); + #define LCDML_DISP_func_repeat_29() LCDML_DISP_func_repeat_28() LCDML_DISP_29_function(); + #define LCDML_DISP_func_repeat_28() LCDML_DISP_func_repeat_27() LCDML_DISP_28_function(); + #define LCDML_DISP_func_repeat_27() LCDML_DISP_func_repeat_26() LCDML_DISP_27_function(); + #define LCDML_DISP_func_repeat_26() LCDML_DISP_func_repeat_25() LCDML_DISP_26_function(); + #define LCDML_DISP_func_repeat_25() LCDML_DISP_func_repeat_24() LCDML_DISP_25_function(); + #define LCDML_DISP_func_repeat_24() LCDML_DISP_func_repeat_23() LCDML_DISP_24_function(); + #define LCDML_DISP_func_repeat_23() LCDML_DISP_func_repeat_22() LCDML_DISP_23_function(); + #define LCDML_DISP_func_repeat_22() LCDML_DISP_func_repeat_21() LCDML_DISP_22_function(); + #define LCDML_DISP_func_repeat_21() LCDML_DISP_func_repeat_20() LCDML_DISP_21_function(); + #define LCDML_DISP_func_repeat_20() LCDML_DISP_func_repeat_19() LCDML_DISP_20_function(); + #define LCDML_DISP_func_repeat_19() LCDML_DISP_func_repeat_18() LCDML_DISP_19_function(); + #define LCDML_DISP_func_repeat_18() LCDML_DISP_func_repeat_17() LCDML_DISP_18_function(); + #define LCDML_DISP_func_repeat_17() LCDML_DISP_func_repeat_16() LCDML_DISP_17_function(); + #define LCDML_DISP_func_repeat_16() LCDML_DISP_func_repeat_15() LCDML_DISP_16_function(); + #define LCDML_DISP_func_repeat_15() LCDML_DISP_func_repeat_14() LCDML_DISP_15_function(); + #define LCDML_DISP_func_repeat_14() LCDML_DISP_func_repeat_13() LCDML_DISP_14_function(); + #define LCDML_DISP_func_repeat_13() LCDML_DISP_func_repeat_12() LCDML_DISP_13_function(); + #define LCDML_DISP_func_repeat_12() LCDML_DISP_func_repeat_11() LCDML_DISP_12_function(); + #define LCDML_DISP_func_repeat_11() LCDML_DISP_func_repeat_10() LCDML_DISP_11_function(); + #define LCDML_DISP_func_repeat_10() LCDML_DISP_func_repeat_9() LCDML_DISP_10_function(); + #define LCDML_DISP_func_repeat_9() LCDML_DISP_func_repeat_8() LCDML_DISP_9_function(); + #define LCDML_DISP_func_repeat_8() LCDML_DISP_func_repeat_7() LCDML_DISP_8_function(); + #define LCDML_DISP_func_repeat_7() LCDML_DISP_func_repeat_6() LCDML_DISP_7_function(); + #define LCDML_DISP_func_repeat_6() LCDML_DISP_func_repeat_5() LCDML_DISP_6_function(); + #define LCDML_DISP_func_repeat_5() LCDML_DISP_func_repeat_4() LCDML_DISP_5_function(); + #define LCDML_DISP_func_repeat_4() LCDML_DISP_func_repeat_3() LCDML_DISP_4_function(); + #define LCDML_DISP_func_repeat_3() LCDML_DISP_func_repeat_2() LCDML_DISP_3_function(); + #define LCDML_DISP_func_repeat_2() LCDML_DISP_func_repeat_1() LCDML_DISP_2_function(); + #define LCDML_DISP_func_repeat_1() LCDML_DISP_func_repeat_0() LCDML_DISP_1_function(); + #define LCDML_DISP_func_repeat_0() LCDML_DISP_0_function(); + #define LCDML_DISP_func_repeat(N) LCDML_DISP_func_repeat_ ## N () + +#endif