Subversion Repositories Projects

/*****************************************************************************
 *   Copyright (C) 2013 Oliver Gemesi                                        *
 *                                                                           *
 *   This program is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation; either version 2 of the License.          *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program; if not, write to the                           *
 *   Free Software Foundation, Inc.,                                         *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
 *****************************************************************************/

//############################################################################
//# HISTORY  menuctrl.c
//#
//# 11.06.2014 OG
//# - add: MenuCtrl_GetMenuIndex()
//#
//# 31.05.2014 OG
//# - chg: MenuCtrl_Refresh() - umgestellt auf PKT_KeylineUpDown()
//#
//# 14.05.2014 OG
//# - chg: include "../mk/paramset.h" geaendert auf "../mksettings/paramset.h"
//# - chg: include "../mk/mkparameters.h" geaendert auf "../mksettings/mkparameters.h"
//#
//# 11.05.2014 OG
//# - add: MenuCtrl_SetTitleFromParentItem()
//# - add: MenuCtrl_GetItemText(), MenuCtrl_IsItemTextPGM()
//# - chg: _MenuCtrl_Error() - auf PKT_Popup_P() umgestellt, Layout geaendert und
//#        einen neuen Fehler (NOPARENTMENU) hinzugefuegt
//#
//# 09.05.2014 OG
//# - fix: MenuCtrl_Refresh() Anzeige von deaktivierten MK-Parametern (Favoriten)
//#        Wenn MK-Paramketer-Menueeintraege deaktiviert sind werden sie vom
//#        aktuellen MK-Parameterset nicht unterstuetzt - dennoch wurde der
//#        aktuelle Wert des MK-Parameters im Menuepunkt (ganz rechts) angezeigt.
//#        Das ist jetzt behoben - es wird kein Wert angezeigt (stattdessen "***")
//#        und auch keine entsprechende editParam-Funktionen aufgerufen.
//#
//# 07.05.2014 OG
//# - add: MenuCtrl_PushSeparatorID()
//#
//# 06.05.2014 OG
//# - chg: MenuCtrl_Refresh() Keyline leicht angepasst
//# - chg: 'not possible' Anzeige (bei deaktiviertem Item) umgestellt auf
//#        PKT_Popup_P()
//# - add: MenuCtrl_GetItemIdByIndex(), MenuCtrl_GetItemCount()
//#
//# 05.05.2014 OG
//# - chg: MenuCtrl_Control()
//#        -> Unterstuetzung fuer: MenuCtrl_SetMove() - Menueeintraege verschieben
//# - chg: MenuCtrl_Refresh() - Anpassung Slider fuer MenuCtrl_SetDelete()
//# - add: MenuCtrl_SetDelete(), MenuCtrl_SetMove()
//# - add: _MenuCtrl_SwapItem()
//# - add: die Datenstruktur vom Menue wurde erweitert um die Eigenschaften
//#        canMove und canDelete
//#
//# 17.04.2014 OG
//# - chg: MENUCTRL_MAXITEMS von 22 auf 28 erhoeht
//#
//# 30.03.2014 OG
//# - del: MenuCtrl_PushML_P(), MenuCtrl_PushML() (Umstellung Sprachen abgeschlossen)
//# - add: MenuCtrl_PushML2(), MenuCtrl_PushML2_P() fuer Umstellung von 3 auf 2 Sprachen
//#
//# 29.03.2014 OG
//# - chg: default MENUDEFAULT_SHOWBATT auf true umgestellt (=PKT-Batterie anzeigen)
//# - chg: MenuCtrl_Control() umgestellt auf clear_key_all()
//#
//# 24.03.2014 OG
//# - add: MenuCtrl_PushSeparator() - fuegt eine Trennlinie im Menue ein
//# - chg: MenuCtrl_Refresh() Codeoptimierung bzgl. topspace/Zeile loeschen/Slider
//# - fix: MenuCtrl_Control() es wurde zuoft ein Screen-Refresh durchgefuehrt
//#
//# 23.03.2014 OG
//# - add: Unterstuetzung fuer MK-Parameter-Edit (mkparameters.c)
//# - chg: MenuCtrl_Refresh() Unterstuetzung fuer MENU_PARAMEDIT
//# - add: MenuCtrl_PushParamEdit()
//# - add: paramset.h und mkparameters.h
//#
//# 04.03.2014 OG
//# - fix: MenuCtrl_Refresh() bei einem blauen Display (das ist wohl schneller
//#        in der Anzeige als das S/W-Display) flackerte der Menue-Slider
//#
//# 17.02.2014 OG
//# - add: MenuCtrl_SetTopSpace()
//# - chg: MenuCtrl_Refresh() angepasst auf MenuCtrl_SetTopSpace()
//#
//# 15.02.2014 OG
//# - add: MenuCtrl_ItemSelect()
//#
//# 01.02.2014 OG
//# - chg: MENUCTRL_MAXITEMS von 16 auf 22 fuer MK_parameters
//# - fix: _MenuCtrl_Error() Anzeigezeit von Menu-Errors auf 8 Sekunden verlaengert
//#        und Anzeige von "menuctrl.c"
//#
//# 07.07.2013 OG
//# - add: MenuCtrl_ItemMarkR() - Markiert einen Menueeintrag mit einem Haken am ENDE (Rechts)
//#
//# 24.05.2013 OG
//# - chg: MenuCtrl_Push... Funktionen vereinheitlicht mit internen Aenderungen
//#        betrifft externe Funktionsaufrufe die geändert wurden
//# - chg: MenuCtrl_Refresh() Anpassungen und Optimierung
//# - add: MenuCtrl_ItemMark()
//# - del: MenuCtrl_PushSimple_P(), MenuCtrl_PushSimple()
//#
//# 23.05.2013 OG
//# - add: MenuCtrl_PushSimple_P(), MenuCtrl_PushSimple()
//# - fix: MenuCtrl_Control() Eventcode Rueckgabe bei KEY_ENTER
//#
//# 22.05.2013 OG
//# - fix: nach Aufruf einer Menuefunktion in MenuCtrl_Control() jetzt
//#        get_key_press(KEY_ALL)
//#
//# 21.05.2013 OG
//# - add: MenuCtrl_ShowLevel()
//#
//# 20.05.2013 OG
//# - chg: MenuCtrl_Control() wieder mit get_key_press(KEY_ALL) ergaenzt
//#        wenn aufgerufen mit MENUCTRL_EVENT oder erster Aufruf mit RETURN
//#
//# 20.05.2013 OG
//# - chg: Space am Anfang der Titelanzeige
//#
//# 19.05.2013 OG
//# - add: define MENU_SHOWLEVEL mit dem der aktuelle Menuelevel in der
//#        Titelzeile angezeigt werden kann
//# - fix: Redraw-Logik bei MENUCTRL_RETURN
//# - chg: MenuCtrl_Control() erweitert um PKT_Update()
//#
//# 18.05.2013 OG - NEU
//############################################################################

#include "../cpu.h"
#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <util/delay.h>
#include <string.h>         // memset
#include <stdarg.h>

#include "../main.h"
#include "../lcd/lcd.h"
#include "../eeprom/eeprom.h"
#include "../messages.h"
#include "../lipo/lipo.h"
#include "../menu.h"
#include "../pkt/pkt.h"
#include "../mksettings/paramset.h"
#include "../mksettings/mkparameters.h"
#include "menuctrl.h"


//#############################################################################################
//# internal defines & structs
//#############################################################################################

#define MENU_SHOWLEVEL          false   // Anzeige der Menue-Verschachtelungstiefe in der Titelzeile
                                        // zeigt dem Benutzer wie weit er wieder zurueckspringen muss
                                        // um in das Hauptmenue zu kommen

#define MENUDEFAULT_CYCLE       false   // cycle: wenn Menue am Ende dann wieder zum Anfang
#define MENUDEFAULT_SHOWBATT    true    // showbatt: zeigt PKT-Batterie im Menuetitel ganz rechts
#define MENUDEFAULT_BEEP        true    // beep: wenn Cursor ueber Ende/Anfang


#define MENUCTRL_MAXMENUES  6           // Anzahl max. verschachlteter Menues
//#define MENUCTRL_MAXITEMS   22          // Anzahl max. Menu-Items pro Menue (verbraucht Speicher)
//#define MENUCTRL_MAXITEMS   28          // Anzahl max. Menu-Items pro Menue (verbraucht Speicher)
#define MENUCTRL_MAXITEMS   34          // Anzahl max. Menu-Items pro Menue (verbraucht Speicher)
#define ERROR_NOMENU        1           // Errorcode
#define ERROR_MAXMENU       2           // Errorcode
#define ERROR_MAXITEM       3           // Errorcode
#define ERROR_NOITEM        4           // Errorcode
#define ERROR_NOPARENTMENU  5           // Errorcode

//-----------------------------------------------------------
// typedef: scrollbox_key_t
//-----------------------------------------------------------
typedef struct
{
    uint8_t     active;             // Taste aktiv? (true/false)
    const char  *text;              // Tastentext
    void (*func)(void);             // ggf. Funktions-Pointer (0=keine Funktion)
}  menue_key_t;


//---------------------------
// typedef: einzelnes Menueitem
//---------------------------
typedef struct
{
    uint8_t     id;
    uint8_t     type;               // MENU_ITEM, MENU_SUB, MENU_PARAMEDIT
    uint8_t     disabled;           // true / false  (deaktiviert einen Menuepunkt)
    uint8_t     mark;               // true / false  (markiert einen Menuepunkt Links '*')
    uint8_t     markR;              // true / false  (markiert einen Menuepunkt Rechts)
    uint8_t     textPGM;            // true / false (true = text in PROGMEN; false = text im RAM)
    uint8_t     textcount;          // 1 .. NUM_LANG
    const char *text[NUM_LANG];     // de, en, nl  (NUM_LANG aus messages.h)
    void (*func)(void);
}  menue_item_t;


//---------------------------
// typedef: Menueitem Liste
//---------------------------
typedef struct
{
    uint8_t         active;         // aktives item
    uint8_t         itemcount;      // Anzahl Items
    uint8_t         scroll_pos;     // aktuelle obere Anzeigezeile
    uint8_t         display_pos;    // aktuelle obere Anzeigezeile
    uint8_t         topspace;       // obere Leerzeilen - default=0 (Vorsicht! ggf. nur bedingt einsetzbar bei Menues die ohne scrollen auskommen!)
    uint8_t         firstredraw;    // true / false  (flag fuer ein erstes redraw bei MENUCTRL_RETURN)
    uint8_t         cycle;          // true / false
    uint8_t         showbatt;       // true / false
    uint8_t         beep;           // true / false
    uint8_t         canMove;        // true / false
    uint8_t         canDelete;      // false/0 = kein entfernen; true/1 = entfernen mit Nachfrage; 2 = entfernen ohne Nachfrage
    uint8_t         titlePGM;       // true / false
    const char      *title;         // Menuetitel (oberste Zeile) (ggf. Multisprache machen?)
    uint8_t         lastkey;        // verwendet von GetKey()
    menue_key_t     key_enter;
    menue_key_t     key_enter_long;
    menue_key_t     key_esc;
    menue_key_t     key_esc_long;
    menue_item_t    item[MENUCTRL_MAXITEMS];
}  menue_t;

uint8_t showlevel = MENU_SHOWLEVEL; // Anzeige Menulevel in der Titelanzeige
int8_t  midx = -1;                  // aktives Menue; -1 = kein Menue
menue_t menu[MENUCTRL_MAXMENUES];   // Stack fuer n geschachltete Menues



//#############################################################################################
//# PRIVAT funcs
//#############################################################################################


//--------------------------------------------------------------
// INTERN
//--------------------------------------------------------------
void _MenuCtrl_Error( uint8_t error )
{
    const char *pStr = NULL;

    switch( error )
    {
        case ERROR_NOMENU:          pStr = PSTR("NOMENU");       break;
        case ERROR_MAXMENU:         pStr = PSTR("MAXMENU");      break;
        case ERROR_MAXITEM:         pStr = PSTR("MAXITEM");      break;
        case ERROR_NOITEM:          pStr = PSTR("NOITEM");       break;
        case ERROR_NOPARENTMENU:    pStr = PSTR("NOPARENTMENU"); break;
    }

    set_beep( 1000, 0x000f, BeepNormal);                                    // Beep Error
    PKT_Popup_P( 10000, PSTR("menuctrl.c"), 0, PSTR("* ERROR *"), pStr );   // 10000 = max. 100 Sekunden anzeigen
}


//--------------------------------------------------------------
// INTERN
//--------------------------------------------------------------
int8_t _MenuCtrl_FindItem( uint8_t itemid )
{
    int8_t i;

    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return -1; }

    for( i=0; i<menu[midx].itemcount; i++)
    {
        if( itemid == menu[midx].item[i].id )
        {
            return i;   // found: return index
        }
    }
    return -1;          // not found
}


//--------------------------------------------------------------
// INTERN
//--------------------------------------------------------------
void _MenuCtrl_CalcDisplayPos( void )
{
    int8_t i;

    i = menu[midx].active - menu[midx].display_pos;

    if( i < 0 )
        menu[midx].display_pos = menu[midx].active;
    else if( i > 5 )
        menu[midx].display_pos = (menu[midx].active - 5);
}


//--------------------------------------------------------------
// INTERN
//--------------------------------------------------------------
void _MenuCtrl_Beep( void )
{
    if( menu[midx].beep )
        set_beep( 25, 0xffff, BeepNormal );
}


//--------------------------------------------------------------
// INTERN
// Dreieckstausch von zwei Menuepunkten.
// Wird verwendet um Menueitems zu verschieben.
//--------------------------------------------------------------
void _MenuCtrl_SwapItem( uint8_t itemindex_1, uint8_t itemindex_2 )
{
    menue_item_t tmpItem;

    memcpy( &tmpItem                      , &menu[midx].item[itemindex_1], sizeof(menue_item_t) );
    memcpy( &menu[midx].item[itemindex_1] , &menu[midx].item[itemindex_2], sizeof(menue_item_t) );
    memcpy( &menu[midx].item[itemindex_2] , &tmpItem, sizeof(menue_item_t) );
}



//#############################################################################################
//# PUBLIC funcs
//#############################################################################################


//--------------------------------------------------------------
// MenuCtrl_Create()
//--------------------------------------------------------------
void MenuCtrl_Create( void )
{
    if( midx >= MENUCTRL_MAXMENUES) { _MenuCtrl_Error( ERROR_MAXMENU ); return; }

    midx++;
    memset( &menu[midx], 0, sizeof(menue_t) );
    menu[midx].cycle        = MENUDEFAULT_CYCLE;
    menu[midx].showbatt     = MENUDEFAULT_SHOWBATT;
    menu[midx].beep         = MENUDEFAULT_BEEP;
}


//--------------------------------------------------------------
// MenuCtrl_Destroy()
//--------------------------------------------------------------
void MenuCtrl_Destroy( void )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    midx--;
}


//--------------------------------------------------------------
// MenuCtrl_ShowLevel( value )
//
// Diese Einstellung ist Global und wirkt sich direkt auf alle
// Menues aus!
// Man kann das also nicht fuer einzelne Menues ein-/ausschalten.
//
// Parameter:
//   value: true / false
//--------------------------------------------------------------
void MenuCtrl_ShowLevel( uint8_t value )
{
    showlevel = value;
}


//--------------------------------------------------------------
// MenuCtrl_SetTitle_P( *title )
//
// Parameter:
//   title: Menuetitel; Zeiger auf String PROGMEM
//--------------------------------------------------------------
void MenuCtrl_SetTitle_P( const char *title )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].title    = title;
    menu[midx].titlePGM = true;
}


//--------------------------------------------------------------
// MenuCtrl_SetTitle( *title )
//
// Parameter:
//   title: Menuetitel; Zeiger auf String im RAM
//--------------------------------------------------------------
void MenuCtrl_SetTitle( const char *title )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].title    = title;
    menu[midx].titlePGM = false;
}



//--------------------------------------------------------------
// MenuCtrl_SetTitleFromParentItem()
//
// setzte anhand des uebergeordneten Menuepunktes (dem aufrufenden
// Menuepunkt) den Titel des neuen Menues
//
// wird u.a. verwendet in setup.c
//--------------------------------------------------------------
void MenuCtrl_SetTitleFromParentItem( void )
{
    uint8_t     lang;
    const char *pStr;
    uint8_t     mparent;

    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU );       return; }
    if( midx < 1)   { _MenuCtrl_Error( ERROR_NOPARENTMENU ); return; }

    mparent = midx-1;

    //--------------------------
    // Sprache: Multilanguage oder 0 wenn wenn nur ein Text
    //--------------------------
    lang = (menu[mparent].item[ menu[mparent].active ].textcount == 1) ? 0 : Config.DisplayLanguage;

    //--------------------------
    // Text vom uebergeordneten Menuepunkt
    //--------------------------
    pStr = menu[mparent].item[ menu[mparent].active ].text[lang];

    //--------------------------
    // Titel setzen
    //--------------------------
    if( menu[mparent].item[ menu[mparent].active ].textPGM )
    {
        MenuCtrl_SetTitle_P( pStr );
    }
    else
    {
        MenuCtrl_SetTitle( pStr );
    }
}



//--------------------------------------------------------------
// MenuCtrl_SetCycle( value )
//
// Parameter:
//   value: true / false
//--------------------------------------------------------------
void MenuCtrl_SetCycle( uint8_t value )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].cycle    = value;
}



//--------------------------------------------------------------
// MenuCtrl_SetBeep( value )
//
// Parameter:
//   value: true / false
//--------------------------------------------------------------
void MenuCtrl_SetBeep( uint8_t value )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].beep = value;
}



//--------------------------------------------------------------
// MenuCtrl_SetMove( value )
//
// Schaltet in einem Menue die Moeglichkeit ein Menueeintraege nach
// oben oder nach unten zu verschieben.
// Zum verschieden eines Menueeintrages muessen die PLUS/MINUS Tasten
// lange gedrueckt werden.
//
// Parameter:
//   value: true / false (Default: false)
//--------------------------------------------------------------
void MenuCtrl_SetMove( uint8_t value )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].canMove = value;
}


//--------------------------------------------------------------
// MenuCtrl_SetDelete( value )
//
// Schaltet in einem Menue die Moeglichkeit ein Menueeintraege zu loeschen.
// Zum loeschen eines Menueeintrages muss dann die ganz rechte 'OK' Taste
// lange gedrueckt werden.
//
// Parameter:
//   value: true / false (Default: false)
//--------------------------------------------------------------
void MenuCtrl_SetDelete( uint8_t value )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].canDelete = value;
}


//--------------------------------------------------------------
// MenuCtrl_SetShowBatt( value )
//
// Parameter:
//   value: true / false
//--------------------------------------------------------------
void MenuCtrl_SetShowBatt( uint8_t value )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].showbatt = value;
}



//--------------------------------------------------------------
// MenuCtrl_SetTopSpace( n )
//
// fuegt oben im Menue n Leerzeichen ein um Abstand vom Menuetitel
// zu erhalten
//
// ACHTUNG! Das funktioniert nur mit Menues die nicht Scrollen!
// -> also weniger als 6 Eintraege haben (je nach Anzahl von TopSpace)
//
// ACHTUNG! Keine Absicherung bzgl. obigem Warnpunkt! Das kann man
// zwar machen - ist aber aktuell nicht so!
//
// Parameter:
//   value: 0..n  Anzahl der Leerzeilen ueber dem Menue
//--------------------------------------------------------------
void MenuCtrl_SetTopSpace( uint8_t n )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }

    menu[midx].topspace = n;
}



//--------------------------------------------------------------
// MenuCtrl_SetKey( key, *keytext, *keyfunc )
//
// Parameter:
//   key    : KEY_ENTER, KEY_ENTER_LONG, KEY_ESC, KEY_ESC_LONG
//   keytext: Pointer auf Text PROGMEM oder NOTEXT (=0)
//   keyfunc: Pointer auf Funktion oder NOFUNC (=0)
//--------------------------------------------------------------
void MenuCtrl_SetKey( uint8_t key, const char *keytext, void (*keyfunc)(void) )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }        // kein aktives Menue

    if( key == KEY_ENTER )
    {
        menu[midx].key_enter.active     = true;
        menu[midx].key_enter.text       = keytext;
        menu[midx].key_enter.func       = keyfunc;
    }

    if( key == KEY_ENTER_LONG )
    {
        menu[midx].key_enter_long.active = true;
        menu[midx].key_enter_long.text  = keytext;
        menu[midx].key_enter_long.func  = keyfunc;
    }

    if( key == KEY_ESC )
    {
        menu[midx].key_esc.active       = true;
        menu[midx].key_esc.text         = keytext;
        menu[midx].key_esc.func         = keyfunc;
    }

    if( key == KEY_ESC_LONG )
    {
        menu[midx].key_esc_long.active  = true;
        menu[midx].key_esc_long.text    = keytext;
        menu[midx].key_esc_long.func    = keyfunc;
    }
}


//--------------------------------------------------------------
// key = MenuCtrl_GetKey()
//
// Rueckgabe:
//   key: z.B. KEY_ENTER oder KEY_ENTER_LONG
//--------------------------------------------------------------
uint8_t MenuCtrl_GetKey( void )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    return menu[midx].lastkey;
}



//--------------------------------------------------------------
// menuindex = MenuCtrl_GetMenuIndex()
//
// gibt den aktuellen Menuindex zurueck
//
// Rueckgabe:
//   menuindex: <0 = keine Menue (-1)
//              =0 = Hauptmenue (Toplevel)
//              >0 = Untermenue Level
//--------------------------------------------------------------
int8_t MenuCtrl_GetMenuIndex( void )
{
    return midx;
}



//--------------------------------------------------------------
// itemid = MenuCtrl_GetItemId()
//
// gibt die itemID des aktuell angewaehlten Menuepunktes zurueck
//
// Rueckgabe:
//   itemid:
//--------------------------------------------------------------
uint8_t MenuCtrl_GetItemId( void )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    return menu[midx].item[ menu[midx].active ].id;
}



//--------------------------------------------------------------
// itemid = MenuCtrl_GetItemIdByIndex( index )
//
// damit koennen die aktuell vorhanden itemID's der Menuepunkte
// ermittelt wenn im Menue via SetMove oder SetDelete Menuepunkte
// durch den Benutzer verschoben oder geloescht wurden.
//
// Parameter:
//   index: von 0..itemcount-1
//--------------------------------------------------------------
uint8_t MenuCtrl_GetItemIdByIndex( uint8_t index )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    if( (menu[midx].itemcount == 0) || (index > menu[midx].itemcount-1) )   return 0;   // index ausserhalb aktiver Menuepunkte

    return menu[midx].item[ index ].id;
}



//--------------------------------------------------------------
// num = MenuCtrl_GetItemCount()
//
// gibt die Anzahl der Menuepunkte zurueck
//
// Rueckgabe:
//   num: Anzahl der Menuepunkte
//--------------------------------------------------------------
uint8_t MenuCtrl_GetItemCount( void )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    return menu[midx].itemcount;
}


//--------------------------------------------------------------
// textPtr = MenuCtrl_GetItemText()
//
// gibt einen Pointer auf den Text des aktuellen Menuepunktes zurueck
//
// ACHTUNG! Der Pointer kann auf RAM oder auch auf PGM zeigen!
//
// Um herauszufinden auf welchen Bereich der Pointer zeigt kann
// MenuCtrl_IsItemTextPGM() verwendet werden.
//
// Rueckgabe:
//   textPtr:  in RAM oder PGM
//--------------------------------------------------------------
const char * MenuCtrl_GetItemText( void )
{
    uint8_t lang;

    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    //--------------------------
    // Sprache: Multilanguage oder 0 wenn wenn nur ein Text
    //--------------------------
    lang = (menu[midx].item[ menu[midx].active ].textcount == 1) ? 0 : Config.DisplayLanguage;

    return menu[midx].item[ menu[midx].active ].text[lang];
}



//--------------------------------------------------------------
// isPGM = MenuCtrl_IsItemTextPGM()
//
// gibt true/false zurueck je nachdem der Text von MenuCtrl_GetItemText()
// im Progmem (=true) oder im RAM (=false) ist
//
// Rueckgabe:
//   isPGM: true / false (true = text in PROGMEN; false = text im RAM)
//--------------------------------------------------------------
uint8_t MenuCtrl_IsItemTextPGM( void )
{
    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }      // kein aktives Menue

    return menu[midx].item[ menu[midx].active ].textPGM;
}



//--------------------------------------------------------------
// MenuCtrl_ItemSelect( itemid )
//
// aktiviert einen Menuepunkt / setzt den Menue-Cursor darauf
//
// die Funktion ist nicht durchgetestet, funktioniert aber
// in MKSettings_Menu() / mkparameters.c
//
// es kann sein das es zu Problemen kommt wenn das Menue
// scrollt (mehr als 6 Menueeintraege)
//
// Parameter:
//   itemid: ID des Menuitems
//--------------------------------------------------------------
void MenuCtrl_ItemSelect( uint8_t itemid )
{
    int8_t i;

    i = _MenuCtrl_FindItem( itemid );

    if( i >= 0 )
    {
        menu[midx].active = i;
    }
}


//--------------------------------------------------------------
// MenuCtrl_ItemActive( itemid, value )
//
// Parameter:
//   itemid: ID des Menuitems
//   value : true / false
//--------------------------------------------------------------
void MenuCtrl_ItemActive( uint8_t itemid, uint8_t value )
{
    int8_t i;

    i = _MenuCtrl_FindItem( itemid );

    if( i >= 0 )
    {
        menu[midx].item[i].disabled = !value;
    }
}


//--------------------------------------------------------------
// MenuCtrl_ItemMark( itemid, value )
//
// Markiert einen Menueeintrag mit einem '*' am Anfang (Links).
// Wird u.a. von BT_SelectDevice() (setup.c) verwendet
//
// Parameter:
//   itemid: ID des Menuitems
//   value : true / false
//--------------------------------------------------------------
void MenuCtrl_ItemMark( uint8_t itemid, uint8_t value )
{
    int8_t i;

    i = _MenuCtrl_FindItem( itemid );

    if( i >= 0 )
    {
        menu[midx].item[i].mark = value;
    }
}


//--------------------------------------------------------------
// MenuCtrl_ItemMarkR( itemid, value )
//
// Markiert einen Menueeintrag mit einem Haken am ENDE (Rechts).
// Wird u.a. von ... (setup.c) verwendet
//
// Parameter:
//   itemid: ID des Menuitems
//   value : true / false
//--------------------------------------------------------------
void MenuCtrl_ItemMarkR( uint8_t itemid, uint8_t value )
{
    int8_t i;

    i = _MenuCtrl_FindItem( itemid );

    if( i >= 0 )
    {
        menu[midx].item[i].markR = value;
    }
}


//--------------------------------------------------------------
// INTERN
//
// fuer: MenuCtrl_PushML_P(), MenuCtrl_Push()
//--------------------------------------------------------------
void _MenuCtrl_Push( uint8_t useprogmem, uint8_t numlang, uint8_t itemid, uint8_t itemtype, void (*menufunc)(void), ... )
{
    va_list ap;
    uint8_t idx;
    uint8_t i;

    if( midx < 0  )                                 { _MenuCtrl_Error( ERROR_NOMENU );  return; }
    if( menu[midx].itemcount >= MENUCTRL_MAXITEMS ) { _MenuCtrl_Error( ERROR_MAXITEM ); return; }
    //if( numlang > NUM_LANG )                      { _MenuCtrl_Error( ERROR_MAXLANG ); return; }

    idx = menu[midx].itemcount;

    menu[midx].item[idx].id       = itemid;
    menu[midx].item[idx].type     = itemtype;   // MENU_ITEM, MENU_SUB
    menu[midx].item[idx].mark     = false;
    menu[midx].item[idx].func     = menufunc;
    menu[midx].item[idx].textPGM  = useprogmem;
    menu[midx].item[idx].textcount= numlang;

    va_start(ap, menufunc);

    for( i=0; i<numlang; i++)
    {
        menu[midx].item[idx].text[i]  = va_arg( ap, const char *);
    }

    va_end(ap);

    menu[midx].itemcount++;
}


//--------------------------------------------------------------
// MenuCtrl_PushML2_P( itemid, itemtype, *menufunc, *text_de, *text_en, *text_nl )
//
// MultiLanguage Texte fuer 2 Sprachen (DE, EN)
// PROGMEN Version
//
// Parameter:
//   itemid  : ID des Menueitems
//   itemtype: MENU_ITEM oder MENU_SUB (bei MENU_SUB wird noch ein ">" angezeigt)
//   menufunc: Pointer auf Funktion oder NOFUNC (=0) wenn keine Funktion
//   texte   : alles Zeiger auf PROGMEM
//--------------------------------------------------------------
void MenuCtrl_PushML2_P( uint8_t itemid, uint8_t itemtype, void (*menufunc)(void), const char *text_de, const char *text_en )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( true, NUM_LANG, itemid, itemtype, menufunc, text_de, text_en );
}


//--------------------------------------------------------------
// MenuCtrl_PushML2( itemid, itemtype, *menufunc, *text_de, *text_en, *text_nl )
//
// MultiLanguage Texte fuer 2 Sprachen (DE, EN)
// RAM Version
//
// Parameter:
//   itemid  : ID des Menueitems
//   itemtype: MENU_ITEM oder MENU_SUB (bei MENU_SUB wird noch ein ">" angezeigt)
//   menufunc: Pointer auf Funktion oder NOFUNC (=0) wenn keine Funktion
//   texte   : alles Zeiger auf RAM
//--------------------------------------------------------------
void MenuCtrl_PushML2( uint8_t itemid, uint8_t itemtype, void (*menufunc)(void), const char *text_de, const char *text_en )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( false, NUM_LANG, itemid, itemtype, menufunc, text_de, text_en );
}


//--------------------------------------------------------------
//--------------------------------------------------------------
void MenuCtrl_Push_P( uint8_t itemid, uint8_t itemtype, void (*menufunc)(void), const char *text )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( true, 1, itemid, itemtype, menufunc, text );
}


//--------------------------------------------------------------
//--------------------------------------------------------------
void MenuCtrl_Push( uint8_t itemid, uint8_t itemtype, void (*menufunc)(void), const char *text )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( false, 1, itemid, itemtype, menufunc, text );
}


//--------------------------------------------------------------
// Spezialfunktion fuer mkparameters.c !
//
// -> siehe: mkparameters.c / Menu_EditCategory()
//
// ACHTUNG!
// Die externe Variable paramEditItem muss in mkparameters.c
// vor Aufruf dieser Funktion richtig initialisiert sein!
// Ich habe darauf verzichtet hier nochmal ein find_paramEditItem()
// aufzurufen um Speicherplatz zu sparen.
//--------------------------------------------------------------
void MenuCtrl_PushParamEdit( uint8_t paramID )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( true, 2, paramID, MENU_PARAMEDIT, NOFUNC, paramEditItem.title_de, paramEditItem.title_en );
}



//--------------------------------------------------------------
// MenuCtrl_PushSeparator()
//
// fuegt eine Trennlinie im Menue ein
// (die itemID ist dabei 0)
//--------------------------------------------------------------
void MenuCtrl_PushSeparator( void )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( true, 0, 0, MENU_SEPARATOR, NOFUNC );
}



//--------------------------------------------------------------
// MenuCtrl_PushSeparatorID( itemId )
//
// fuegt eine Trennlinie im Menue ein mit einer eigenen itemID
//--------------------------------------------------------------
void MenuCtrl_PushSeparatorID( uint8_t itemid )
{
  //_MenuCtrl_Push( useprogmem, numlang, itemid, itemtype, void (*menufunc)(void), ... )
    _MenuCtrl_Push( true, 0, itemid, MENU_SEPARATOR, NOFUNC );
}



//--------------------------------------------------------------
// MenuCtrl_Refresh( mode )
//
// Parameter:
//   mode: MENU_REDRAW || MENU_REFRESH
//--------------------------------------------------------------
void MenuCtrl_Refresh( uint8_t mode )
{
    uint8_t y;
    uint8_t item;
    uint8_t sh;
    uint8_t sy;
    uint8_t actchar;
    uint8_t markchar;
    uint8_t markcharR;
    uint8_t lang;

    if( midx < 0)   { _MenuCtrl_Error( ERROR_NOMENU ); return; }            // kein Menue vorhanden

    if( mode == MENU_REDRAW )
    {
        //--------------------------
        // Clear
        //--------------------------
        lcd_frect( 0,  8, 6, 47, 0);                                        // Clear: ganz linke Spalte des Sliders
        lcd_frect( 127-2, 0, 2, 63, 0);                                     // Clear: ganz rechts 2 Pixel

        //--------------------------
        // Titel
        //--------------------------
        if( menu[midx].title != 0 )
        {
            if( showlevel )
            {
                if( menu[midx].titlePGM )
                    lcdx_printf_at_P( 0, 0, MINVERS, 0,0 , PSTR("  %19S"), menu[midx].title );
                else
                    lcdx_printf_at_P( 0, 0, MINVERS, 0,0 , PSTR("  %19s"), menu[midx].title );

                writex_ndigit_number_u( 0, 0, midx, 1, 0, MINVERS, 1,0);    // Menuelevel zeigen
            }
            else
            {
                if( menu[midx].titlePGM )
                    lcdx_printf_at_P( 0, 0, MINVERS, 0,0 , PSTR(" %20S"), menu[midx].title );
                else
                    lcdx_printf_at_P( 0, 0, MINVERS, 0,0 , PSTR(" %20s"), menu[midx].title );
            }
        }
        else
            lcd_frect( 0, 0, 128, 7, 1);                                       // Titel: Leerzeile


        //--------------------------
        // Keyline Beschriftung
        //--------------------------
        lcdx_cls_row( 7, MNORMAL, 0);
        PKT_KeylineUpDown( 1, 7,  0,0);
        lcd_printp_at( 12, 7, strGet(KEYLINE4), MNORMAL);


        // Taste: KEY_ENTER
        if( menu[midx].key_enter.active && menu[midx].key_enter.text != 0 )
        {
            lcdx_printf_at_P( 17, 7, MNORMAL, 0,0 , PSTR("%4S"), menu[midx].key_enter.text );
        }

        // Taste: KEY_ESC
        if( menu[midx].key_esc.active && menu[midx].key_esc.text != 0 )
        {
            lcdx_printf_at_P( 12, 7, MNORMAL, 0,0 , PSTR("%5S"), menu[midx].key_esc.text );
        }
    }


    //--------------------------
    // PKT Batterie Anzeige
    //--------------------------
    if( menu[midx].showbatt )
    {
        show_Lipo();
    }


    //--------------------------
    // Zeilen
    //--------------------------
    for( y=0; y<6; y++)
    {
        item = y + menu[midx].display_pos;

        if( item < menu[midx].itemcount )
        {
            //--------------------------
            // char: aktuelle Auswahl
            //--------------------------
            actchar = ' ';
            if( item == menu[midx].active )
            {
                if( menu[midx].item[item].disabled )    actchar = 0x15;         // aktuelle Auswahl: Pfeil disabled
                else                                    actchar = 0x1d;         // aktuelle Auswahl: Pfeil
            }

            //--------------------------
            // char: markiert
            //--------------------------
            markchar = ' ';
            if( menu[midx].item[item].mark ) markchar = '*';

            //--------------------------
            // char: markiert RECHTS
            //--------------------------
            markcharR = ' ';
            if( menu[midx].item[item].type == MENU_SUB ) markcharR = 0x1d;
            if( menu[midx].item[item].markR )            markcharR = SYMBOL_CHECK;

            //--------------------------
            // Sprache: Multilanguage oder 0 wenn wenn nur ein Text
            //--------------------------
            lang = (menu[midx].item[item].textcount == 1) ? 0 : Config.DisplayLanguage;

            //--------------------------
            // Ausgabe: RAM oder PROGMEM
            //--------------------------
            if( MENU_SEPARATOR == menu[midx].item[item].type )
            {
                lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%18S")  , actchar, markchar, PSTR("") );
                lcd_frect( 6*3, ((y+1)*8)+3, 124-(6*3), 0, 1);                                  // Trennlinie
            }
            else if( MENU_PARAMEDIT == menu[midx].item[item].type )
            {
                // SPEZIELL fuer mkparameters.c - zeigt die paramID-Bezeichnung inkl. dem aktuellen WERT an!
                strcpy_P( mkparam_strValueBuffer, PSTR("***"));                                     // Vorbelegung von mkparam_strValueBuffer
                if( !menu[midx].item[item].disabled )                                               // nur wenn Menuepunkt nicht deaktiviert (disabled = paramID nicht vorhanden)
                {                                                                                   //   -> ermittle den aktuellen Wert der paramID fuer Anzeige
                    find_paramEditItem( menu[midx].item[item].id );                                 // paramID suchen (Ergebnis in Variable 'paramEditItem')
                    paramEditItem.editfunc( paramEditItem.paramID, MKPARAM_SHORTVALUE );            // Wert von paramID in mkparam_strValueBuffer darstellen
                }
                lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%14S %3s")  , actchar, markchar, menu[midx].item[item].text[lang], mkparam_strValueBuffer );
            }
            else
            {
                // Anmerkung zu menu[midx].topspace: NUR fuer Menues OHNE scrollen!!
                if( menu[midx].item[item].textPGM )
                {
                    // String im PGM
                    if( menu[midx].item[item].type == MENU_SUB || menu[midx].item[item].markR )
                        lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%16S%c "), actchar, markchar, menu[midx].item[item].text[lang], markcharR );
                    else
                        lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%17S ")  , actchar, markchar, menu[midx].item[item].text[lang] );
                }
                else
                {
                    // String im RAM
                    if( menu[midx].item[item].type == MENU_SUB || menu[midx].item[item].markR )
                        lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%16s%c "), actchar, markchar, menu[midx].item[item].text[lang], markcharR );
                    else
                        lcdx_printf_at_P( 1, y+1+menu[midx].topspace, MNORMAL, 0,0 , PSTR("%c%c%17s ")  , actchar, markchar, menu[midx].item[item].text[lang] );
                }
            }

        } // end: if( item < menu[midx].itemcount )


        //--------------------------
        // evtl. Leerzeile loeschen
        //--------------------------
        if( (y < menu[midx].topspace) || (item >= menu[midx].itemcount+menu[midx].topspace) )
        {
            lcd_frect( 6, (y+1)*8, 128-6, 7, 0);                                    // Zeile loeschen
        }

    }


    //--------------------------
    // Slider
    //--------------------------
    #define SLIDERH   45                                                            // Finetuning der Slider-Hoehe

    lcd_frect( 0,  8+1, 1, SLIDERH, 0);                                             // Slider: full Clear

    if( menu[midx].itemcount > 6 )                                                  // Slider nur bei mehr als 6 Menueitems
    {
        // Slider: 7 zeilen * 8 pixel = 56 pixel
        sh = (SLIDERH * 6) / menu[midx].itemcount;                                  // Slider: Hoehe
        sh = (sh > SLIDERH) ? SLIDERH : sh;

        sy = 8+(menu[midx].display_pos * (SLIDERH-sh)) / (menu[midx].itemcount-6);  // Slider: Position

        //lcd_frect( 0,  8+1, 1, SLIDERH, 0);                                       // Slider: full Clear    (flackert auf blauen Display!)
        //lcd_frect( 0, 8+1, 1, sy-(8), 0);                                         // Slider: Clear / oben  (nicht mehr notwendig da Aenderung am Refresh)
        //lcd_frect( 0, sy+1+sh+1, 1, SLIDERH-(sh-sy+1), 0);                        // Slider: Clear / unten (nicht mehr notwendig da Aenderung am Refresh)
        lcd_frect( 0, sy+1, 1, sh, 1);                                              // Slider: Draw
    }
}



//--------------------------------------------------------------
// event = MenuCtrl_Control( ctrlmode )
//
// Parameter:
//   ctrlmode: MENUCTRL_EVENT || MENUCTRL_RETURN
//
// Rueckgabe:
//   event: MENUEVENT_NONE || MENUEVENT_ITEM || MENUEVENT_KEY
//--------------------------------------------------------------
uint8_t MenuCtrl_Control( uint8_t ctrlmode )
{
    uint8_t menu_event;
    uint8_t refreshmode;
    uint8_t item;
    uint8_t wahl;
    uint8_t i;
    uint8_t goUp    = false;
    uint8_t goDown  = false;

    if( midx < 0)                   { _MenuCtrl_Error( ERROR_NOMENU ); return 0; }              // kein Menue vorhanden
    if( menu[midx].itemcount == 0)  { _MenuCtrl_Error( ERROR_NOITEM ); return 0; }              // kein Menueitem vorhanden


    // bei MENUCTRL_RETURN muss man ggf. selber fuer ein Redraw sorgen
    // (beim ersten Aufruf wird es jedoch dennoch erzwungen)
    if( ctrlmode == MENUCTRL_EVENT || !menu[midx].firstredraw )
    {
        MenuCtrl_Refresh( MENU_REDRAW );
        menu[midx].firstredraw = true;
    }

    clear_key_all();

    do
    {
        menu_event         = MENUEVENT_NONE;
        menu[midx].lastkey = KEY_NONE;
        refreshmode        = false;

        //--------------------------
        // Pruefe PKT Update oder
        // andere PKT-Aktion
        //--------------------------
        if( PKT_CtrlHook() )                                                                    // Update vom Updatetool angefordert?
        {
            refreshmode = MENU_REDRAW;
        }

        //--------------------------
        // PKT Batterie Anzeige
        //--------------------------
        if( menu[midx].showbatt )
        {
            show_Lipo();
        }


        //--------------------------
        // Cursor: nach oben (UP)
        //--------------------------
        //+++++
        // UP - Verschiebemodus AKTIV
        //+++++
        if( menu[midx].canMove )
        {
            if( get_key_long(1 << KEY_MINUS) )
            {
                if( (menu[midx].active > 0) && (menu[midx].itemcount > 0) )
                {
                    _MenuCtrl_SwapItem( menu[midx].active, menu[midx].active-1 );
                    goUp = true;
                }
                else _MenuCtrl_Beep();                                                           // am oberen Ende angelangt
            }

            if( get_key_short(1 << KEY_MINUS) )     // up
            {
                goUp = true;
            }
        }   // end: UP - Verschiebemodus AKTIV


        //+++++
        // UP - Verschiebemodus NICHT aktiv
        //+++++
        if( !menu[midx].canMove )     // up
        {
            if( get_key_press(1 << KEY_MINUS) || get_key_long_rpt_sp((1 << KEY_MINUS),2) )      // up
            {
                goUp = true;
            }
        }   // end: UP - Verschiebemodus NICHT aktiv


        //+++++
        // UP - goUp
        //+++++
        if( goUp )     // up
        {
            refreshmode = MENU_REFRESH;
            if( (menu[midx].active > 0)  && (menu[midx].itemcount > 0) )
            {
                menu[midx].active--;
            }
            else if( menu[midx].cycle )
            {
                menu[midx].active = menu[midx].itemcount-1;
            }
            else
            {
                _MenuCtrl_Beep();                                                               // am oberen Ende angelangt
            }
            _MenuCtrl_CalcDisplayPos();
        }


        //--------------------------
        // Cursor: nach unten (DOWN)
        //--------------------------
        //+++++
        // DOWN - Verschiebemodus AKTIV
        //+++++
        if( menu[midx].canMove )
        {
            if( get_key_long(1 << KEY_PLUS) )
            {
                if( menu[midx].active < menu[midx].itemcount-1 )
                {
                    _MenuCtrl_SwapItem( menu[midx].active, menu[midx].active+1 );
                    goDown = true;
                }
                else _MenuCtrl_Beep();                                                           // am unteren Ende angelangt
            }

            if( get_key_short(1 << KEY_PLUS) )     // up
            {
                goDown = true;
            }
        }   // end: DOWN - Verschiebemodus AKTIV


        //+++++
        // DOWN - Verschiebemodus NICHT aktiv
        //+++++
        if( !menu[midx].canMove )     // up
        {
            if( get_key_press(1 << KEY_PLUS) || get_key_long_rpt_sp((1 << KEY_PLUS),2) )     // up
            {
                goDown = true;
            }
        }   // end: DOWN - Verschiebemodus NICHT aktiv


        //+++++
        // DOWN - goDown
        //+++++
        if( goDown )     // down
        {
            refreshmode = MENU_REFRESH;
            if( menu[midx].active < menu[midx].itemcount-1 )
            {
                menu[midx].active++;
            }
            else if( menu[midx].cycle )
            {
                menu[midx].active = 0;
            }
            else
            {
                _MenuCtrl_Beep();                                                           // am unteren Ende angelangt
            }
            _MenuCtrl_CalcDisplayPos();
        }


        //--------------------------
        //--------------------------
        item    = menu[midx].active;
        goUp    = false;
        goDown  = false;


        //--------------------------
        // KEY_ENTER
        //--------------------------
        if( get_key_short(1 << KEY_ENTER) )
        {
            refreshmode = MENU_REFRESH;
            // todo: keyfunc
            if( menu[midx].item[item].type == MENU_SEPARATOR )
            {
                // do nothing
            }
            else if( menu[midx].item[item].disabled )
            {
                set_beep( 200, 0x00ff, BeepNormal);                             // Beep
                PKT_Popup_P( 200, strGet(STR_MENUCTRL_NOTPOSSIBLE),0,0,0);      // "nicht möglich!"
                refreshmode = MENU_REDRAW;
            }
            else if( menu[midx].item[item].func != NOFUNC )
            {
                menu[midx].item[item].func();
                refreshmode = MENU_REDRAW;
            }
            else if( menu[midx].key_enter.func != NOFUNC )
            {
                menu[midx].key_enter.func();
                refreshmode = MENU_REDRAW;
            }
            else
            {
                menu[midx].lastkey = KEY_ENTER;
                menu_event = MENUEVENT_ITEM;
            }
        }


        //--------------------------
        // KEY_ENTER_LONG (Deletemodus AKTIV)
        //
        // loescht einen Menueeintrag
        //--------------------------
        if( menu[midx].canDelete && get_key_long(1 << KEY_ENTER) && (menu[midx].itemcount > 0) )
        {
            wahl = 1;
            if( menu[midx].canDelete == 1 )                                     // ==1 -> mit Nachfrage
            {
                set_beep( 200, 0xffff, BeepNormal);                             // Beep
                PKT_Popup_P( 0, strGet(STR_MENUCTRL_DELASK),PSTR(""),0,0);      // "Eintrag entfernen?"
                lcd_printp_at( 12, 7, strGet(YESNO), MINVERS);

                wahl = 0;
                while( !wahl )
                {
                    if( get_key_short(1<<KEY_ESC) )   wahl = 1;                 // "Ja"
                    if( get_key_short(1<<KEY_ENTER) ) wahl = 2;                 // "Nein"
                }
                refreshmode = MENU_REDRAW;
            }

            if( wahl==1 )
            {
                for( i=menu[midx].active; i<menu[midx].itemcount-1; i++)
                {
                    _MenuCtrl_SwapItem( i, i+1 );
                }
                menu[midx].itemcount--;

                if( (menu[midx].display_pos > 0)  &&   (menu[midx].display_pos+6 > menu[midx].itemcount)  )
                {
                    menu[midx].display_pos--;
                    menu[midx].active--;
                }

                if( menu[midx].active >= menu[midx].itemcount )
                    menu[midx].active = menu[midx].itemcount-1;

                _MenuCtrl_CalcDisplayPos();
                refreshmode = MENU_REDRAW;

                if( menu[midx].canDelete == 2 )                                 // ==2 -> direkt loeschen, ohne Nachfrage
                {
                    set_beep( 200, 0xffff, BeepNormal);                         // Beep
                    PKT_Popup_P( 200, strGet(STR_MENUCTRL_DELITEM),0,0,0);      // "Eintrag entfernt!"
                }
            }
        }


        //--------------------------
        // KEY_ENTER_LONG (NICHT Deletemodus)
        //--------------------------
        if( !menu[midx].canDelete && menu[midx].key_enter_long.active && get_key_long(1 << KEY_ENTER) )
        {
            refreshmode = MENU_REFRESH;
            if( menu[midx].key_enter_long.func != NOFUNC )
            {
                menu[midx].key_enter_long.func();
                refreshmode = MENU_REDRAW;
            }
            else
            {
                menu_event = MENUEVENT_KEY;
                menu[midx].lastkey = KEY_ENTER_LONG;
            }
        }


        //--------------------------
        // KEY_ESC_LONG
        //--------------------------
        if( menu[midx].key_esc_long.active && get_key_long(1 << KEY_ESC) )
        {
            refreshmode = MENU_REFRESH;
            if( menu[midx].key_esc_long.func != NOFUNC )
            {
                menu[midx].key_esc_long.func();
                refreshmode = MENU_REDRAW;
            }
            else
            {
                menu_event = MENUEVENT_KEY;
                menu[midx].lastkey = KEY_ESC_LONG;
            }
        }


        //--------------------------
        // KEY_ESC
        //--------------------------
        if( get_key_short(1 << KEY_ESC) )
        {
            refreshmode = MENU_REFRESH;
            if( menu[midx].key_esc.func != NOFUNC )
            {
                menu[midx].key_esc.func();
                refreshmode = MENU_REDRAW;
            }
            else
            {
                menu_event = MENUEVENT_KEY;
                menu[midx].lastkey = KEY_ESC;
            }
        }

        if( refreshmode )
        {
            MenuCtrl_Refresh( refreshmode );
            clear_key_all();
        }
    }
    while ( menu_event == MENUEVENT_NONE && ctrlmode == MENUCTRL_EVENT );

    return menu_event;
}