GLCD Menü "scrollen"

[Jan H. (janiiix3)]

Hey Leute,

ich denke wahrscheinlich wieder viel zu kompliziert.
Möchte gerne durch ein "Menü" scrollen.
Die Texte dafür befinden sich in der Struktur.
Anzeigen klappt auch alles. Nun habe ich nur Zeile 0-5 zur Verfügung.
Wenn ich unten angekommen bin (5) möchte Ich gerne wieder bei Zeile 0 
anfangen und den rest der im Array noch nicht ausgegeben wurde an 
"Menütext" ausgeben..

void openMenue(menue_t *m,uint8_t cursor, size_t array)
{
  static uint8_t oldCursor = 1;
  static uint8_t index = 0;
  uint8_t scroll = 0;
  
  if (oldCursor != cursor)
  {
    glcdGotoXY(oldCursor,0);
    glcdPuts("                     ");
  }
  oldCursor = cursor;
  
  if (cursor >= array)cursor = 0;
  
  do
  {
    if (index == cursor)
    {
      strcpy((char*)buffer,"->");
      strcat((char*)buffer,m[cursor].Name);
    }
    else
    {
      strcpy((char*)buffer,m[index].Name);
    }
    glcdGotoXY(index,0);
    glcdPuts((char*)buffer);
    
  } while (index++<array);
  index = 0;
}

Kann mir jemand auf die Sprünge helfen?

[Joe F. (easylife)]

Jan H. schrieb:
> Nun habe ich nur Zeile 0-5 zur Verfügung.
> Wenn ich unten angekommen bin (5) möchte Ich gerne wieder bei Zeile 0
> anfangen und den rest der im Array noch nicht ausgegeben wurde an
> "Menütext" ausgeben..

Dein Problem verstehe ich noch nicht ganz.
Heisst das du hast 6 Zeilen auf dem Display zur Verfügung, dein Menu 
kann jedoch mehr als 6 Einträge haben?
In diesem Fall möchtest du dann das Menu "seitenweise" (zu je max. 6 
Einträgen) anzeigen?

[Jan H. (janiiix3)]

Folgendes..

Displayaufbau

->Menüpunkt[0]
->Menüpunkt[1]
->Menüpunkt[2]
->Menüpunkt[3]
->Menüpunkt[4]
->Menüpunkt[5]
**Newsticker**

Übergeben tue ich der Funktion die Texte die dargestellt werden sollen 
(Menüpunkte).
Wenn ich jetzt ein "Menü" übergebe welches mehr als "6" Members hat, 
möchte ich gerne das sich "Menüpunkt[0] weiter nach oben verschiebt, so 
das man es nicht mehr sehen kann und alle anderen die weiter unten sind 
nach oben rücken solange ich durch das Menü "scrolle"..

Verständlicher?

[Joe F. (easylife)]

Vorschlag für seitenweise Menu-Darstellung

void showMenue(menue_t *m, uint8_t cursor_pos, size_t menu_len)
{
  uint8_t page_start = (cursor_pos / 6) * 6;
  uint8_t y;
  uint8_t menu_entry;
  
  for (y=0, y<6; y++)
  {
    glcdGotoXY(y, 0);
    glcdPuts("                     "); // clear line

    menu_entry = page_start + y;
    if (menu_entry < menu_len)
    {
      glcdGotoXY(y, 0);
      if (menu_entry == cursor_pos)
        glcdPuts("->");
      else
        glcdPuts("  ");
        
      glcdGotoXY(y, 3);
      glcdPuts((char*)buffer,m[menu_entry].Name);
    }
  } 
}

Und das hier sollte den Cursor vom Anfang so etwa bis zur Mitte des 
Menus bewegen, dann scrollt das ganze Menu zeilenweise, und am Ende 
bewegt sich der Cursor bis zur letzten Zeile.
Alles ungetestet... probiers mal aus.

void showMenue(menue_t *m, uint8_t cursor_pos, size_t menu_len)
{
  int8_t  page_start;
  uint8_t y;
  uint8_t menu_entry;
  
  page_start = cursor_pos - 3;
    
  if ((page_start + 6) >= menu_len)
    page_start = menu_len - 6;

  if (page_start < 0) 
    page_start = 0;
  
  for (y=0, y<6; y++)
  {
    glcdGotoXY(y, 0);
    glcdPuts("                     "); // clear line

    menu_entry = page_start + y;
    if (menu_entry < menu_len)
    {
      glcdGotoXY(y, 0);
      if (menu_entry == cursor_pos)
        glcdPuts("->");
      else
        glcdPuts("  ");
        
      glcdGotoXY(y, 3);
      glcdPuts((char*)buffer,m[menu_entry].Name);
    }
  } 
}

[Jan H. (janiiix3)]

Joe F. schrieb:
> glcdPuts((char*)buffer,m[menu_entry].Name);

Die Funktion erwartet nur einen Parameter(char *).
Ist das so gewollt das beides ausgegeben werden soll?

[Joe F. (easylife)]

Jan H. schrieb:
>> glcdPuts((char*)buffer,m[menu_entry].Name);
>
> Die Funktion erwartet nur einen Parameter(char *).
> Ist das so gewollt das beides ausgegeben werden soll?

ne, soll heissen:

glcdPuts(m[menu_entry].Name);

wie gesagt, ich habs nur kurz runtergehackt ohne irgendwas zu 
compilieren oder zu testen.
Die Idee sollte aber klar werden (mit der Variablen "page_start")

[Jan H. (janiiix3)]

Wenn ich jetzt die Begrenzung einbauen will, was genau wird abgefragt?
Er läuft nach oben und unten jeweils über..?

[Joe F. (easylife)]

Verstehe deine Frage nicht.
Die Funktionen zeigen dir das Menu an, unter Berücksichtigung der 
jeweiligen Cursorposition.
Beim Aufruf musst du natürlich sicherstellen, dass "cursor_pos" >= 0 ist 
und < "menu_len".

[Jan H. (janiiix3)]

Kann man das nicht direkt in der Funktion begrenzen? Ich möchte ja nicht 
über die Bereiche bzw. Einträge scrollen. Scrolle ich zu weit nach oben, 
verschwindet der Pfeil, genau das gleiche wenn Ich zu weit nach unten 
Scrolle..

Ich habe versucht direkt am Anfang innerhalb der Funktion eine if 
Abfrage zu machen...
If cursor >= menueLen.. Hat aber nicht geklappt..

[Joe F. (easylife)]

Jan H. schrieb:
> Kann man das nicht direkt in der Funktion begrenzen?

warum?

> Ich möchte ja nicht
> über die Bereiche bzw. Einträge scrollen.

dann verhindere dies ausserhalb der Funktion, an der Stelle an der 
cursor_pos inkrementiert oder dekrementiert wird (ich vermute über 
Tastendrücke).

Jan H. schrieb:
> Scrolle ich zu weit nach oben,
> verschwindet der Pfeil, genau das gleiche wenn Ich zu weit nach unten
> Scrolle..

Ja eben.
Du müsstest wenn du zu weit nach oben gelaufen bist erstmal wieder die 
gleichen Schritte nach unten machen, damit der Pfeil wieder kommt.

Also. Begrenze cursor_pos an der richtigen Stelle im Programm.

[Jan H. (janiiix3)]

Joe F. schrieb:
> Also. Begrenze cursor_pos an der richtigen Stelle im Programm

Ob ich das jetzt direkt vor dem funktionsaufruf tue oder direkt in der 
Funktion als erstes sollte wohl doch egal sein..

[Joe F. (easylife)]

Jan H. schrieb:
> Ob ich das jetzt direkt vor dem funktionsaufruf tue oder direkt in der
> Funktion als erstes sollte wohl doch egal sein..

Ist es nicht.
showMenue() hat nur die Aufgabe das Menu anzuzeigen, und nicht die 
Variable "cursor_pos" zu verändern.
Dies müsstest du aber in der Funktion tun, um z.B. bei cursor_pos == -1 
cursor_pos auf 0 zu setzen.
Ginge, indem man einen Pointer auf cursor_pos übergäbe.

Das ist aber allerdreckigster Programmierstil.

Warum tust du dir so schwer, cursor_pos ausserhalb der 
Menu-Anzeigefunktion im gültigen Wertebereich zu halten?

if (key_up)
{
  if (cursor_pos > 0)
  {
    cursor_pos--;
    showMenu(&menu, cursor_pos, menu_len);
  }
}
else if (key_down)
{
  if (cursor_pos < menu_len-1)
  {
    cursor_pos++;
    showMenu(&menu, cursor_pos, menu_len);
  }
}

[Jan H. (janiiix3)]

Nehmen wir mal an ich habe X verschiedene Menüs die ich der Funktion an 
anderen Stellen übergeben, so muss ich mehrere if abfragen einbauen 
anstatt eine in der Funktion.

[Joe F. (easylife)]

Wie sieht denn dein menue_t aus?
Sinnvollerweise würdest du dann menu_len und cursor_pos auch dort 
hineinpacken.

Abgesehen davon kannst du für x verschiedene Menüs auch ein array mit x 
menu_len anlegen, und kannst dann jeweils die gleiche if Bedingung für 
alle Menus nutzen.

[Jan H. (janiiix3)]

Joe F. schrieb:
> Wie sieht denn dein menue_t aus?
> Sinnvollerweise würdest du dann menu_len und cursor_pos auch dort
> hineinpacken.
>
> Abgesehen davon kannst du für x verschiedene Menüs auch ein array mit x
> menu_len anlegen, und kannst dann jeweils die gleiche if Bedingung für
> alle Menus nutzen.

Du meinst eine extra Struktur und die dann mit diesen Informationen 
übergeben?

[Joe F. (easylife)]

Jan H. schrieb:
> Joe F. schrieb:
>> Wie sieht denn dein menue_t aus?
>> Sinnvollerweise würdest du dann menu_len und cursor_pos auch dort
>> hineinpacken.
>>
>> Abgesehen davon kannst du für x verschiedene Menüs auch ein array mit x
>> menu_len anlegen, und kannst dann jeweils die gleiche if Bedingung für
>> alle Menus nutzen.
>
> Du meinst eine extra Struktur und die dann mit diesen Informationen
> übergeben?

Nein.
Du baust eine Struktur, in der alle nötigen Informationen für ein Menü 
enthalten sind.
- Anzahl der Menueinträge
- Texte der Menueinträge
- sonstige benötigte Informationen
- und von mir aus auch die Cursorposition

Wenn du mehrere Menus hast, benutzt du einfach ein Array dieser 
Struktur.

[Jan H. (janiiix3)]

Also meine vorhandene Array struktur um eben diese Information 
erweitern. Eine gute Idee. Ich danke dir für deine Hilfe!

[Jan H. (janiiix3)]

Moin,

jetzt muss Ich  doch noch mal eine Frage los werden. Wie würdest du das 
jetzt am besten auswerten, welcher Menüpunkt ausgewählt wurde oder eher 
auf welchen gerade gezeigt wird? Ich habe ja einen Drehencoder auf dem 
Board.

[W.S. (Gast)]

Jan H. schrieb:
> Hey Leute,
>
> ich denke wahrscheinlich wieder viel zu kompliziert.
> Möchte gerne durch ein "Menü" scrollen.
> Die Texte dafür befinden sich in der Struktur.

Hey Jan.

Nee, du hast nicht zu kompliziert gedacht, sondern zu wenig. Du solltest 
einen ganz anderen Denkansatz wählen. Ich versuch mal, dir ein paar 
Denkanstöße zu geben.

Also, ein Menüsystem ist ja erstens etwas, wo man sich durch 
irgendwelche Eingaben hindurch maneuvrieren kann. Obendrein soll es auch 
noch passend angezeigt werden, damit man sieht, wo man grad ist und was 
man grad mit der letzten Eingabe angerichtet hat.

Das sind zwei verschiedene Dinge: a) das Maneuvrieren im Menü und b) das 
Anzeigen des Menüs.

Je nachdem, was man an Eingabemöglichkeiten hat, gibt es zumindest drei 
verschiedene Dinge:
- UP    = ich will rauf (oder eben rückwärts)
- DOWN  = ich will runter (oder eben vorwärts)
- ENTER = ich will ne Aktion (das machen, was der aktuelle Menüpunkt 
anzeigt)

Also sollte dein Menü - wenn es denn in Form eines Arrays aus 
Menü-Elementen aufgebaut sein sollte - in jedem Menü-Element wenigstens 
folgende Dinge haben:
- einen Zeiger auf die Funktion, die bei Eingabe von "ENTER" aufgerufen 
werden soll
- einen Text oder ein Icon, eben etwas, das auf dem Display angezeigt 
werden soll
- bei grafischen Menüs auch eine Koordinate, wo das aktuelle Element 
erscheinen soll

Generell muß es logischermaßen zwei globale Variablen geben:
a)  die Nummer des Menüelements, was grad den Fokus hat, also das, wo du 
grad bist
b) wenn du scrollen mußt, dann eben auch die Nummer des Menüelementes, 
was als oberstes bzw. erstes auf dem Display erscheinen soll

Und nun muß es 2 verschiedene Funktionen geben:
a) die Menüfunktion. Diese kriegt als Input einen Event (UP, DOWN oder 
ENTER oder weitere Tasten o.ä.) und sie erledigt die eigentlichen 
Menüaufgaben. Also bei UP muß der Fokus zum vorherigen Element 
verschoben werden, ggf. umschlagen auf das Ende der Einträge, ebenso muß 
ggf. die Nummer des ersten anzuzeigenden Elements korrigiert werden. 
Entsprechendes dann auch für DOWN. Ausführen der angegebenen Funktion 
bei ENTER.

b) die Zeichenfunktion. Diese muß nach allen Menü-Änderungen aufgerufen 
werden, um das Menü neu zu zeichnen. Sie verläßt sich drauf, daß sie bei 
dem Element anfangen muß, dessen Nummer in der globalen Variable (b) 
steht, und sie muß das Element, was in der globalen Variable (a) steht, 
irgendwie kennzeichnen. z.B. invertiert oder mit einem Häkchen davor 
oder einem Rahmen drumherum o.ä., damit man sieht, welches Element grad 
das Aktuelle ist.

W.S.

[Jan H. (janiiix3)]

W.S. schrieb:
> - einen Zeiger auf die Funktion, die bei Eingabe von "ENTER" aufgerufen
> werden soll

Habe ich soweit ja alles verstanden.
Nur das mit dem Zeiger auf die Funktionen die bei dem jeweiligen 
Menüpunkt ausgeführt werden soll.

Was mache Ich, wenn ich verschiedene Funktionen haben, die auch 
unterschiedliche Übergabeparameter haben oder Rückgabeparameter?

So wie Ich es bis jetzt verstanden habe, ist das ohne "großen" Aufwand 
nicht so einfach möglich?

[grundschüler (Gast)]

Jan H. schrieb:
> Nur das mit dem Zeiger auf die Funktionen die bei dem jeweiligen
> Menüpunkt ausgeführt werden soll.

Ich habe auf der x-1-Position ein '*' der durch Pfeil-oben/unten durch 
das Menu bewegt wird. die jeweilge Menu-position wird als Wert 
gespeichert. Wenn dann ein 'ok' eingegeben wird, wird über ein switch 
der gespeicherte Menu-Wert abgerufen und ausgewertet. Ganz einfach. 
Zeiger braucht man da nicht.

Wenn das funktioniert, muss der Überlauf programmiert werden.