/*
* страницы меню
*           16 символов ::          "1234567890123456"
*/

const __flash byte str1_0[]      = "*Введите пароль*"; // password menu
const __flash byte str2_0[]      = "                "; // MENU_PAGE_0

// кнопка "опции" - затемнена
const __flash byte str1_1[]      = "**Слушаю  эфир**"; // main menu
const __flash byte str2_1[]      = "*Режим    Опции*"; // MENU_PAGE_1

//...
//... объявление строк меню
//...
// далее описываем реакцию кнопок на определённой странице меню (кнопок у меня 3 - правая,
// левая и вернуться на пункт выше

void key_handle(byte key_num, byte page_num)
{
  switch (page_num)
  {
    case  MENU_PAGE_0             : // password menu
    {
      switch (key_num)
      {
        case KEY_1    :
          {
            // что-то делаем
          } break; // KEY_1
        case KEY_2    :      
          {
            // что-то делаем
          } break; // KEY_2
        case KEY_BACK :      
          {
            // что-то делаем
          } break; // KEY_BACK
        default : break;        
      } // switch (key_num)
    } break; // MENU_PAGE_0
  
    case  MENU_PAGE_1             : // main menu -------------------------------
    {
      switch (key_num)
      {
        case KEY_1    :
          {
            menu_page = MENU_PAGE_1_1; // собственно вот так происходит обработка
            draw_menu(menu_page);      
          } break; // KEY_1
        case KEY_2    :      
          {
            // grayed
          } break; // KEY_2
        case KEY_BACK :      
          {
            // что-то делаем
          } break; // KEY_BACK
        default : break;        
      } // switch (key_num)
    } break; // MENU_PAGE_1 ----------------------------------------------------

//...
//...
//...
// ну и собственно отрисовка строк меню на дисплее
void draw_menu(byte page_num)
{
  switch (page_num)
  {
    case  MENU_PAGE_0             : // password menu
    {
      LCD_PrintAt(0, 0, &str1_0[0]);
      LCD_PrintAt(0, 1, &str2_0[0]);
    } break;
  
    case  MENU_PAGE_1             : // main menu
    {
      LCD_PrintAt(0, 0, &str1_1[0]);
      LCD_PrintAt(0, 1, &str2_1[0]);
    } break;
//...
//...
//...

/*    Global data type definitions    */

typedef
struct _menuItem    {
            char flash    *itemText;
            void        (*itemFunction)(char);
            char        itemArg;
            }
MenuItem;

static void Run(char _dummy)
    {
    }

static void Stop(char _dummy)
    {
    }


static flash char    _read[]        = "Read device     ",
            _program[]    = "Program device  ",
            _set[]        = "Set device      ",
            _insert[]    = "Insert          ",
            _edit[]        = "Edit buffer     ",
            _clear[]    = "Clear buffer    ",
            _append[]    = "Append          ",
            _run[]        = "Run             ",
            _stop[]        = "Stop            ";
static MenuItem __flash
    MenuItems[] =    {
            _set,        SetType,    0,
            _read,        0,        0,
            _program,    0,        0,
            _insert,    Edit,        INSERT_BUFFER,
            _edit,        Edit,        EDIT_BUFFER,
            _clear,        Edit,        CLEAR_BUFFER,
            _append,    Edit,        APPEND_BUFFER,
            _run,        Run,        0,
            _stop,        Stop,        0
            };
//
// ** Menu    -- the main menu fuction
//
void Menu(void)
    {
    MenuItem __flash    *_mptr = MenuItems;
    static __flash char    _unKnown[] = "Unknown device";

    for (;;)
        {
        Clear_LCD();
        puts_P(_mptr->itemText);
        switch (getchar())
            {
        case '+':    // Next item
            if (++_mptr > &MenuItems[(sizeof MenuItems)/(sizeof (struct _menuItem)) - 1])    // Set pointer to the first item
                _mptr = MenuItems;
            break;
        case '-':    // Previous item
            if (--_mptr < MenuItems)    // Set pointer to the last item
                _mptr = &MenuItems[(sizeof MenuItems)/(sizeof (struct _menuItem)) - 1];
            break;
        case '!':    // Do the selected menu item
            if (Device->_devType==UNKNOWN_TYPE && _mptr->itemFunction!=SetType)
                {
                LCD_MoveCurs2(0);    // Move the LCD cursor
                puts_P(_unKnown);    // Put the message
                getchar();
                break;
                }
            (*_mptr->itemFunction)(_mptr->itemArg);
            }
        }
    }

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
MenuState menu_state[] =
{
//  State                                    State Text          Function
    
    { ST_MAIN,                              "Main            ",    NULL             },
    { ST_MAIN_REV,                            "                ",    mf_revision     },

    { ST_TIME_FUNC,                            "Time            ", mf_showtime     },
    { ST_TIME_SET_FUNC,                        "SetTime         ", mf_settime         },

      { ST_DATE_FUNC,                            "Date            ",    mf_showdate     },

    { ST_SOUND,                              "Sound           ", NULL             },
    { ST_SOUND_SELECT_FUNC,                    NULL,                mf_selectsound     },
    { ST_SOUND_PLAY_FUNC,                      NULL,                mf_playsound     },

    { ST_TEMPERATURE,                        "Temperature     ",    NULL             },
    { ST_TEMPERATURE_FUNC,                   NULL,                mf_temperature     },

    { ST_VOLTAGE,                            "Voltage         ",    NULL             },
    { ST_VOLTAGE_FUNC,                       NULL,                mf_voltage         },

    { ST_LIGHT,                              "Light           ",    NULL             },
    { ST_LIGHT_FUNC,                         NULL,                  mf_light         },

    { ST_OPTIONS,                            "Options         ",    NULL             },
    { ST_OPTIONS_DISPLAY,                    "Display         ",    NULL             },
    { ST_OPTIONS_COMMON,                    "Common          ",    NULL             },
    { ST_OPTIONS_TEST,                        "Test            ",    NULL             },
    // End of list
    { 0,                                     NULL,                  NULL             },

};

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
MenuNavigate menu_nextstate[] =
{
//  State                           Input       NEXT State
    { ST_MAIN,                      KEY_UP,       ST_OPTIONS         },
    { ST_MAIN,                      KEY_PREV,   ST_MAIN_REV     },
    { ST_MAIN,                      KEY_NEXT,   ST_MAIN_REV     },
    { ST_MAIN,                      KEY_DOWN,      ST_TIME_FUNC    },

    { ST_MAIN_REV,                    KEY_PREV,   ST_MAIN            },
    { ST_MAIN_REV,                    KEY_NEXT,   ST_MAIN            },
        
    { ST_SOUND,                      KEY_UP,       ST_DATE_FUNC    },
    { ST_SOUND,                      KEY_NEXT,   ST_SOUND_SELECT_FUNC    },
    { ST_SOUND,                      KEY_PREV,   ST_MAIN            },
    { ST_SOUND,                      KEY_DOWN,   ST_TEMPERATURE    },

    { ST_TEMPERATURE,                KEY_UP,       ST_SOUND        },
    { ST_TEMPERATURE,                KEY_NEXT,   ST_TEMPERATURE_FUNC    },
    { ST_TEMPERATURE,                KEY_PREV,   ST_MAIN            },
    { ST_TEMPERATURE,                KEY_DOWN,      ST_VOLTAGE        },

    { ST_VOLTAGE,                    KEY_UP,       ST_TEMPERATURE    },
    { ST_VOLTAGE,                    KEY_NEXT,   ST_VOLTAGE_FUNC    },
    { ST_VOLTAGE,                    KEY_PREV,   ST_MAIN            },
    { ST_VOLTAGE,                    KEY_DOWN,      ST_LIGHT        },

    { ST_LIGHT,                      KEY_UP,       ST_VOLTAGE        },
    { ST_LIGHT,                      KEY_NEXT,   ST_LIGHT_FUNC    },
    { ST_LIGHT,                      KEY_PREV,   ST_MAIN            },
    { ST_LIGHT,                      KEY_DOWN,      ST_OPTIONS        },

    { ST_OPTIONS,                    KEY_UP,       ST_LIGHT        },
    { ST_OPTIONS,                    KEY_NEXT,   ST_OPTIONS_DISPLAY    },
    { ST_OPTIONS,                    KEY_PREV,   ST_MAIN        },
    { ST_OPTIONS,                    KEY_DOWN,      ST_MAIN        },

    
    { ST_OPTIONS_TEST,                KEY_UP,       ST_OPTIONS_COMMON    },
    { ST_OPTIONS_TEST,                KEY_PREV,   ST_OPTIONS    },
    { ST_OPTIONS_TEST,                KEY_BREAK,  ST_MAIN              },
    { ST_OPTIONS_TEST,                KEY_DOWN,   ST_OPTIONS_DISPLAY  },
    
    { ST_OPTIONS_DISPLAY,            KEY_UP,       ST_OPTIONS_TEST    },
    { ST_OPTIONS_DISPLAY,            KEY_PREV,   ST_OPTIONS    },
    { ST_OPTIONS_DISPLAY,              KEY_BREAK,  ST_MAIN              },
    { ST_OPTIONS_DISPLAY,            KEY_DOWN,      ST_OPTIONS_COMMON    },
    
        
    { ST_OPTIONS_COMMON,            KEY_UP,       ST_OPTIONS_DISPLAY    },
    { ST_OPTIONS_COMMON,            KEY_PREV,   ST_OPTIONS    },
    { ST_OPTIONS_COMMON,               KEY_BREAK,  ST_MAIN              },
    { ST_OPTIONS_COMMON,            KEY_DOWN,   ST_OPTIONS_TEST    },

    // End of list
    { 0,                             0,          0                }
};

BYTE     state;            // Helds the current Menu state
BYTE     enter = TRUE;
BYTE    enter_func = FALSE;

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void MenuProcess( void *params )
{
int rotor_cnt = 0xF7;
char tmp_str[16];
ulong rtc_time;
BYTE nextstate;
BYTE prevstate;
static char *statetext;
BYTE (*statefunc)(BYTE);
BYTE input;
char i;

    params = params;

    // Initial state variables
    prevstate = ST_DUMMY;
    state = nextstate = ST_MAIN;
    statetext = "Hello!";
    statefunc = NULL;
    
    for(;; )                            // Main Menu loop
    {
        // Plain menu text
        if( statetext )
        {   lcd_setpos( 1, 1 );
            lcd_string( statetext );                  
            statetext = NULL;
        }

        input = key_get();               // Read buttons

        if( statefunc )
        {     // When in this state, we must call the state function
            nextstate = statefunc( input );
        }
        else if( input != KEY_NULL )
        {   // Plain menu, clock the state machine
            nextstate = statemachine( state, input );
        }
        if( nextstate != state )
        {   state = nextstate;
            for( i=0; menu_state[i].state; i++ )
            {   if( menu_state[i].state == state )
                {   statetext = menu_state[i].text;
                    statefunc = menu_state[i].func;
                    break;
                }
            }
        }
        
        if( state == ST_MAIN )
        {    
            if( prevstate != ST_MAIN )
            {    prevstate = ST_MAIN;
        
                lcd_setpos( 2, 1 );
                //           1234567890123456
                lcd_string( "No Alarms       " );
            }
            
            if( xQueueReceive( RTCMSG_handle, &rtc_time, 0 ) )
            {
                sprintf( &tmp_str[0], "%02i:%02i", (BYTE)(rtc_time>>16), (BYTE)(rtc_time>>8) );
                lcd_setpos( 1, 17-8 );
                lcd_string( tmp_str );
            }    
            
            if( ++rotor_cnt > 0xF7+5 )
                rotor_cnt = 0xF7;
            lcd_setpos( 1, 16 );
            lcd_char( rotor_cnt );
            
            vTaskDelay_ms( 100 );

        }
        else
        {   prevstate = state;
            vTaskDelay_ms( 100 );
        }
    } //End Main loop
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
BYTE statemachine( BYTE state, BYTE stimul )
{
int i;
BYTE newstate = state;            // Default stay in same state

    for( i=0; menu_nextstate[i].state; i++ )
    {   if( menu_nextstate[i].state == state && menu_nextstate[i].input == stimul )
        {   newstate = menu_nextstate[i].state_next;
            break;
        }
    }
    return( newstate );
}

struct menu_item
{    unsigned char Name[17];
    struct     menu_item    *Parent;
    struct    menu_item    *Child;
    struct    menu_item    *Prev;
    struct    menu_item    *Next;
};

struct menu_item Menu[5]={
  {"Volume         ", NULL, NULL, NULL, &Menu[1]},        // [0]
  {"Power          ", NULL, NULL, &Menu[0], &Menu[2]},    // [1]
  {"Light          ", NULL, NULL, &Menu[1], &Menu[3]},    // [2]
  {"U min of batt  ", NULL, NULL, &Menu[2], &Menu[4]},    // [3]
  {"Autotune       ", NULL, NULL, &Menu[3], NULL}         // [4]
  };

struct menu_item
{    unsigned char Name[17];
    struct     menu_item    *Parent;
    struct    menu_item    *Child;
    struct    menu_item    *Prev;
    struct    menu_item    *Next;
};

struct menu_item Menu[5]={
  {"Volume         ", NULL, NULL, NULL, &Menu[1]},        // [0]
  {"Power          ", NULL, NULL, &Menu[0], &Menu[2]},    // [1]
  {"Light          ", NULL, NULL, &Menu[1], &Menu[3]},    // [2]
  {"U min of batt  ", NULL, NULL, &Menu[2], &Menu[4]},    // [3]
  {"Autotune       ", NULL, NULL, &Menu[3], NULL}         // [4]
  };

#define NULL 0

#include <inavr.h>        
#include "defines.h"
#include "i2c.h"
#include "tic154.h"
#include "Menu.c"

// Prototypes:
void Level1Item1Sub1_Text(void);
void Level1Item1Sub1_Func(void);


const char Buffer[]="OPTIONS";

// Menus:
MAKE_MENU(Level1Item1, Level1Item2, Level1Item3, NULL_ENTRY, Level1Item1Sub1, NULL_FUNC, NULL_FUNC, "ITEM 1");
MAKE_MENU(Level1Item2, Level1Item3, Level1Item1, NULL_ENTRY , NULL_ENTRY, NULL_FUNC, NULL_FUNC, "ITEM 2");
MAKE_MENU(Level1Item3, Level1Item1, Level1Item2, NULL_ENTRY, NULL_ENTRY, NULL_FUNC, NULL_FUNC, "ITEM 3");

MAKE_MENU(Level1Item1Sub1, NULL_ENTRY , NULL_ENTRY , Level1Item1, NULL_ENTRY,Level1Item1Sub1_Func, Level1Item1Sub1_Text, NULL_TEXT);

// Functions:
void Level1Item1Sub1_Text(void)
{
    char Buffer[] = "*YNAMIC MENU TEXT";

    Buffer[0] = 'D';

        LCD_Put_Str(Buffer);

//    LCD_Write_SRAM_String(Buffer);
}

void Level1Item1Sub1_Func(void)
{
//    Shutdown_App();
}

//..........................................

void main (void)
{
  // Initialise
  TWI_Init(100);        // set TWI bit rate to 100KHz    
  LCD_Init();

  SET_MENU_WRITE_FUNC(Buffer);
  SET_MENU(Level1Item1);
  SET_MENU(PARENT);
  SET_MENU(SIBLING);    
  SET_MENU(PREVIOUS);
  SET_MENU(NEXT);    
  GO_MENU_FUNC(SELECTFUNC);    
}

//################################
// Menu.c

#include "Menu.h"
#include <string.h>

Menu_Item        Null_Menu = {(void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0, {0x00}};
Menu_Item*       CurrMenuItem;
WriteFuncPtr*    WriteFunc;

void MenuChange(Menu_Item* NewMenu)
{
    if ((void*)NewMenu == (void*)&NULL_ENTRY)
      return;

    CurrMenuItem = NewMenu;
    
    #if defined(MENU_USE_SRAM_BUFFER)
        #if (MENU_USE_SRAM_BUFFER < 1)
          #error Menu SRAM Buffer Size not Defined!
        #endif
        
        char Buffer[MENU_USE_SRAM_BUFFER];
        strcpy(Buffer, CurrMenuItem->Text);  //strcpy_P

        ((WriteFuncPtr)WriteFunc)((const char*)Buffer);
    #else
        ((WriteFuncPtr)WriteFunc)((const char*)CurrMenuItem->Text);    
    #endif

    GO_MENU_FUNC(ENTERFUNC);
}

void MenuFunc(FuncPtr* Function)
{
    if ((void*)Function == (void*)NULL_FUNC)
      return;

    ((FuncPtr)Function)();
}

//#####################################################
//Menu.h

#ifndef MENU_H
#define MENU_H

//#include <pgmspace.h>

// Typedefs:
typedef void (*FuncPtr)(void);
typedef void (*WriteFuncPtr)(const char*);

typedef struct {       // __flash
    void       *Next;
    void       *Previous;
    void       *Parent;
    void       *Sibling;
    FuncPtr     SelectFunc;
    FuncPtr     EnterFunc;
    const char  Text[6];
} Menu_Item;

// Externs:
extern WriteFuncPtr*    WriteFunc;
extern Menu_Item        Null_Menu;
extern Menu_Item*       CurrMenuItem;

// Defines and Macros:
#define NULL_ENTRY Null_Menu
#define NULL_FUNC  (void*)0
#define NULL_TEXT  0x00
#define MENU_USE_SRAM_BUFFER 32


#define PREVIOUS   *((Menu_Item*)(&CurrMenuItem->Previous))
#define NEXT       *((Menu_Item*)(&CurrMenuItem->Next))
#define PARENT     *((Menu_Item*)(&CurrMenuItem->Parent))
#define SIBLING    *((Menu_Item*)(&CurrMenuItem->Sibling))
#define ENTERFUNC  *((Menu_Item*)(&CurrMenuItem->EnterFunc))
#define SELECTFUNC *((Menu_Item*)(&CurrMenuItem->SelectFunc))

#define MAKE_MENU(Name, Next, Previous, Parent, Sibling, SelectFunc, EnterFunc, Text) \
        extern Menu_Item Next;     \
    extern Menu_Item Previous; \
    extern Menu_Item Parent;   \
    extern Menu_Item Sibling;  \
    Menu_Item Name = {(void*)&Next, (void*)&Previous, (void*)&Parent, (void*)&Sibling, (FuncPtr)SelectFunc, (FuncPtr)EnterFunc, { Text }}

#define SET_MENU_WRITE_FUNC(x) \
    WriteFunc = (WriteFuncPtr*)&x;

#define SET_MENU(x) \
    MenuChange((Menu_Item*)&x);
    
#define GO_MENU_FUNC(x)  \
    MenuFunc((FuncPtr*)&x)
    
#define EXTERN_MENU(Name) \
    extern Menu_Item Name;

// Prototypes:
void MenuChange(Menu_Item* NewMenu);
void MenuFunc(FuncPtr* Function);

#endif

void menu_Init(void)
{
  Level1Item1Sub1_Text();
  SET_MENU_WRITE_FUNC(Level1Item1Sub1_Text);
  SET_MENU(Level1Item1);
    delay_ms(1000);
    SET_MENU(PARENT);
    delay_ms(1000);
    SET_MENU(SIBLING);
    delay_ms(1000);
    SET_MENU(PREVIOUS);
    delay_ms(1000);
    SET_MENU(NEXT);
}

void menu_Init(void)
{
  Level1Item1Sub1_Text();
  SET_MENU_WRITE_FUNC(Level1Item1Sub1_Text);
  SET_MENU(Level1Item1);
    delay_ms(1000);
    SET_MENU(Level1Item2);
    delay_ms(1000);
    SET_MENU(Level1Item3);
    delay_ms(1000);
    SET_MENU(Level1Item1);
    delay_ms(1000);
    SET_MENU(Level1Item2);
}

#define PREVIOUS   *((Menu_Item*)pgm_read_word(&CurrMenuItem->Previous))
#define NEXT       *((Menu_Item*)pgm_read_word(&CurrMenuItem->Next))
#define PARENT     *((Menu_Item*)pgm_read_word(&CurrMenuItem->Parent))
#define SIBLING    *((Menu_Item*)pgm_read_word(&CurrMenuItem->Sibling))
#define ENTERFUNC  *((FuncPtr*)pgm_read_word(&CurrMenuItem->EnterFunc))
#define SELECTFUNC *((FuncPtr*)pgm_read_word(&CurrMenuItem->SelectFunc))

/ MICRO_MENU.H

#ifndef _MENU_H_
#define _MENU_H_

//Тут указываются указатели на функции
typedef void (* FuncPtr) (void);
/*Новый тип FuncPtr - указатель на функцию,
которая ничего не принимает
и не возвращает
*/
typedef void (* WriteFuncPtr) (const char*);
/*Новый тип WriteFuncPtr - указатель на функцию,
входным параметром которой является указатель на строку в ПЗУ,
которая ничего не вовращает
*/
typedef struct PROGMEM {
        void        *Next; //Следующее меню
        void        *Previous; //Предыдущее меню
        void        *Parent; //Родительское меню
        void        *Sibling; //Дочернее меню (вложение)
        FuncPtr     SelectFunc; //Выбор фнкции при выборе меню
        FuncPtr     EnterFunc; //Выбор функции при входе в меню (Применяется после того, как текст меню отображен)
        const char  Text[22]; //Текст меню
} Menu_Item;

//Externs
extern WriteFuncPtr    *WriteFunc; //Переменная-указатель на функцию
extern Menu_Item        Null_Menu; //Переменная типа PROGMEM
extern Menu_Item       *CurrMenuItem; //Переменная-указаетль на данные типа PROGMEM

//Defines and Macros
#define NULL_ENTRY      Null_Menu
#define NULL_FUNC       0
#define NULL_TEXT       0x00

#define PREVIOUS        *((Menu_Item*)pgm_read_word(&CurrMenuItem->Previous))

SET_MENU(PREVIOUS);

#define SET_MENU(x) \
    MenuChange((Menu_Item*)&x);

SET_MENU(PREVIOUS); == MenuChange((Menu_Item*)&*((Menu_Item*)(&CurrMenuItem->Previous)));