Einfaches Menue fuer GLCDs

[Stephan K. (dustpuppy)]

Hi,
nachdem ich den Beitrag Beitrag "Struct aus Flash lesen" 
gelesen hab,
hier mal meine Menu-Funktionen fuer Grafikdisplays. Jedes Menue hat 
einen Eintrag, der sich folgendermassen zusammen setzt:
Zeile , Spalte, Text, Funktion fuer Callback, Naechstes Menue, 
Vorheriges Menue

Die Hauptstruktur muss folgende Daten enthalten:
Kopfzeile, Fusszeile, Anzahl Eintraege im Menue, Name des Menues.

Das Menue wird dann mit Show_Menu(); aufgerufen. Vorblaettern mit 
Menu_Down();. Zureuckblaettern mit Menu_Up();. Ausfuehrung des Menues 
mit Menu_Execute();.
Diese Funktionen muessen in den Keyboard-Routinen mit eingebunden 
werden.

Im Source sind 4 Stellen, die mit // ... eingegrenzt sind. da muessen 
die passenden Print-Funktionen rein. Hab mal die Ausgaben fuer die 
Font-lib von
Christian R. drin gelassen, damit man sieht, wie's sein kann.

Das Ganze muesste sich eigendlich mit andern Scrollfunktionen auch fuer 
Text-Lcds umarbeiten lassen.

Gruesse

Dusty

/// ----------------MENU--------------------------------------
void Show_Menu(void);
void Menu_up(void);
void Menu_Down(void);
void Menu_Back(void);
void Menu_Execute(void);

uint8_t MENU_INDEX;
uint8_t MENU_ENTRIES;
uint8_t MENU_ACTIVE;

uint8_t MENU_RUNNING=TRUE;

typedef const struct {
  uint8_t x;
  uint8_t y;
  char *text;
  void (*function)(int);
  uint8_t next;
  uint8_t last;
}_menu_struct_;

typedef const struct {
  char *top;
  char *bottom;
  uint8_t entries;
  _menu_struct_ *menu_struct;
}_menu_;

/// ----------------MENU CALLBACKS----------------------------
void callback_menu(int n)
{
}

/// ----------------MENU STRUKTUREN---------------------------

/// MENU 0 - Die 2 ist die Anzahl der Eintraege
const _menu_struct_ MAIN_MENU[2] PROGMEM =
{
  {0,20, "MAIN MENU 1"  , NULL,  1, 0},  // x, y, text, function, next, last
  {0,34, "MAIN MENU 2"  , NULL,  2, 0},  // x, y, text, function, next, last
};

/// Menu 1 - 1 ist die Anzahl Eintraege
const _menu_struct_ SUB_MENU_1[1] PROGMEM =
{
  {0,20, "SUB MENU 1 - 1" , NULL, 3, 0},  // x, y, text, function, next, last
};

/// Menu 2 - 3 ist die Anzahl der Eintraege
const _menu_struct_ SUB_MENU_2[3] PROGMEM =
{
  {0,20, "SUB MENU 2 - 1" , &callback_menu, 255, 0},  // x, y, text, function, next, last
  {0,34, "SUB MENU 2 - 2" , &callback_menu, 255, 0},  // x, y, text, function, next, last
  {0,48, "SUB MENU 2 - 3" , &callback_menu, 255, 0},  // x, y, text, function, next, last
};

/// Menu 3 - 3 ist die Anzahl der Eintraege
const _menu_struct_ SUB_MENU_3[3] PROGMEM =
{
  {0,20,  "SUB MENU 3 - 1" , &callback_menu, 255, 1},  // x, y, text, function, next, last
  {0,34,  "SUB MENU 3 - 2" , &callback_menu, 255, 1},  // x, y, text, function, next, last
  {0,48,  "SUB MENU 3 - 3" , &callback_menu, 255, 1},  // x, y, text, function, next, last
};

/// Das eigendliche Menue - 4 Eintraege
const _menu_ MENU[4] PROGMEM =
{
  {"MAIN MENU",  "", 2,  MAIN_MENU },  //Top Line, Bottom Line, Entries, menu_struct
  {"SUB MENU 1", "", 1,  SUB_MENU_1 },  //Top Line, Bottom Line, Entries, menu_struct
  {"SUB MENU 2", "", 3,  SUB_MENU_2 },  //Top Line, Bottom Line, Entries, menu_struct
  {"SUB MENU 3", "", 3,  SUB_MENU_3 },  //Top Line, Bottom Line, Entries, menu_struct
};


/// ------------------------Menu Functions------------------------------
void Show_Menu(void)
{
  uint8_t x,y;
  int c;
  char *text;
  _menu_struct_ *M=NULL;
  
  text=(void*)pgm_read_word(&(MENU[MENU_ACTIVE].top));
  //...
  //...
  // Hier die Ausgabe fuer die Ueberschrift
  //...
  //...
  text=(void*)pgm_read_word(&(MENU[MENU_ACTIVE].bottom));
  //...
  //...
  // Hier die Statuszeile am unteren Bildschrimrand
  //...
  //...
  MENU_ENTRIES=pgm_read_byte(&(MENU[MENU_ACTIVE].entries));
  M= (_menu_struct_ *) pgm_read_word(&(MENU[MENU_ACTIVE].menu_struct));

  for(c=0;c<MENU_ENTRIES;c++)
  {
    text=(void*)pgm_read_word(&(M[c].text));
    x=pgm_read_byte(&(M[c].x));
    y=pgm_read_byte(&(M[c].y));
    if(c==MENU_INDEX)
    {
      //...
      //...
      // Hier die Ausgabe des aktiven Eintrags
//      GLCD_PRINT(x, y, text, &FONT_NORMAL, TRUE);
      // ...
      // ...
    }
    else
    {
      // ...
      // ...
      // Hier die Ausgabe des nicht aktiven Eintrags
//      GLCD_PRINT(x, y, text, &FONT_NORMAL, FALSE);
      // ...
      // ...
    }
  }
  MENU_RUNNING=TRUE;
}

void Menu_up(void)
{
  if(MENU_ACTIVE<255)
  {
    if(MENU_INDEX>0)
    {
      MENU_INDEX--;
    }
    else
    {
      MENU_INDEX=MENU_ENTRIES-1;
    }
    Show_Menu();
  }
}

void Menu_Down(void)
{
  if(MENU_ACTIVE<255)
  {
    if(MENU_INDEX<MENU_ENTRIES-1)
    {
      MENU_INDEX++;
    }
    else
    {
      MENU_INDEX=0;
    }
    Show_Menu();
  }
}

void Menu_Back(void)
{
  _menu_struct_ *M=NULL;
  if(MENU_ACTIVE<255)
  {
    uint8_t last;
    M= (_menu_struct_ *) pgm_read_word(&(MENU[MENU_ACTIVE].menu_struct));
    last=pgm_read_byte(&(M[MENU_INDEX].last));
    GLCD_CLEAR();
    MENU_INDEX=0;
    MENU_ACTIVE=last;
    Show_Menu();
  }
}

void Menu_Execute(void)
{
  if(MENU_ACTIVE<255)
  {
    _menu_struct_ *M=NULL;
    void (*fptr)(int);
    uint8_t next;
    M= (_menu_struct_ *) pgm_read_word(&(MENU[MENU_ACTIVE].menu_struct));
    next=pgm_read_byte(&(M[MENU_INDEX].next));
    fptr=(void*)pgm_read_word(&(M[MENU_INDEX].function));
    if( fptr!=NULL )
    {
      fptr(MENU_INDEX);
      if( (next!=MENU_ACTIVE) && (next!=255) )
      {
  // ...
  // ...
  // Display loeschen
//  GLCD_CLEAR();
  // ...
  // ...
  MENU_INDEX=0;
  MENU_ACTIVE=next;
  Show_Menu();
      }
    }
    else
    {
  // ...
  // ...
  // Display loeschen
//  GLCD_CLEAR();
  // ...
  // ...
      MENU_INDEX=0;
      MENU_ACTIVE=next;
      Show_Menu();
    }
  }
}

///-------------End of Menu Functions-----------------------------

[W.S. (Gast)]

Netter Anfang, aber zu kurz gesprungen. Ich sag's mal ganz generell: Du 
hast dabei zu prozedural gedacht und nix anderes als eine Liste von Text 
im Sinn gehabt.

Versuche es mal mit einem objektorientierten Ansatz:
1. es gibt grafische Elemente auf dem Bildschirm
2. ein solches Element hat eine Koordinate und eine Größe
3. ein solches Element gehört einem übergeordneten Element (Owner) und 
das "übergeordneteste" Element ist der Bildschirm selbst
4. ein solches Element kann selbst andere Elemente (Members) enthalten
5. ein solches Element muß sich selbst zeichnen können
6. ein solches Element muß auf Botschaften (Events) reagieren können, 
die von außen in das ganze Menüsystem hineingeworfen werden, also z.B. 
"jemand hat Taste XYZ gedrückt" oder "es ist eine Sekunde vergangen" 
oder "zeichne dich" oder "initialisiere dich" usw.

W.S.