int isValidAutobahnName(char *Name){// Ist der Autobahnname Erlaubt(von den zeichen her)
char* buffer= malloc(sizeof(char)*1000);
if(isdigit(Name[0])){
puts(" ");
sprintf(buffer," Fehler , Der Autobahn Name muss mit einem Buchstaben beginnen");
printMenuHeader(buffer);
free(buffer);
return 1;
}
for(int i=0;i< CountUTF8String(Name);i++){
if(isalnum((int)Name[i])==0 && Name[i]!='_' && Name[i]!='.'){
sprintf(buffer," Fehler , Der Autobahn Name enthält '%c' , ein Verbotenes Zeichen",Name[i]);
printMenuHeader(buffer);
printMenuItem("Erlaubte zeichen [A-Z] [a-z] [0-9] '_' '.' ");
printFooter();
free(buffer);
return 1;
}
}
free(buffer);
return 0;
}
static void GUI_showMenu( const MenuItem * items, int count,
int selection, int row, int height )
{
int i;
CursorState cursorState;
if ( items == NULL || count == 0 )
return;
// head and tail points to the start and the end of the list.
// top and bottom points to the first and last visible items
// in the menu window.
gMenuItems = items;
gMenuRow = row;
gMenuHeight = height;
gMenuItemCount = count;
gMenuTop = 0;
gMenuBottom = min( count, height ) - 1;
gMenuSelection = selection;
gMenuStart = 0;
gMenuEnd = min( count, gui.maxdevices ) - 1;
// If the selected item is not visible, shift the list down.
if ( gMenuSelection > gMenuBottom )
{
gMenuTop += ( gMenuSelection - gMenuBottom );
gMenuBottom = gMenuSelection;
}
if ( gMenuSelection > gMenuEnd )
{
gMenuStart += ( gMenuSelection - gMenuEnd );
gMenuEnd = gMenuSelection;
}
// Draw the visible items.
if( bootArgs->Video.v_display == GRAPHICS_MODE )
{
drawDeviceList(gMenuStart, gMenuEnd, gMenuSelection);
}
else
{
changeCursor( 0, row, kCursorTypeHidden, &cursorState );
for ( i = gMenuTop; i <= gMenuBottom; i++ )
{
printMenuItem( &items[i], (i == gMenuSelection) );
}
restoreCursor( &cursorState );
}
}
static void showMenu( const MenuItem * items, int count,
int selection, int row, int height )
{
int i;
CursorState cursorState;
if ( items == NULL || count == 0 )
return;
// head and tail points to the start and the end of the list.
// top and bottom points to the first and last visible items
// in the menu window.
gMenuItems = items;
int MenuTop = 0;
int MenuBottom = min( count, height ) - 1;
int MenuSelection = selection;
int MenuStart = 0;
int MenuEnd = count; //min( count, gui.maxdevices ) - 1;
// If the selected item is not visible, shift the list down.
if ( MenuSelection > MenuBottom )
{
MenuTop += ( MenuSelection - MenuBottom );
MenuBottom = MenuSelection;
}
if ( MenuSelection > MenuEnd )
{
MenuStart += ( MenuSelection - MenuEnd );
MenuEnd = MenuSelection;
}
// Draw the visible items.
changeCursor( 0, row, kCursorTypeHidden, &cursorState );
for ( i = MenuTop; i <= MenuBottom; i++ )
{
printMenuItem( &items[i], (i == MenuSelection) );
}
safe_set_env(envgMenuRow,row);
safe_set_env(envgMenuHeight,height);
safe_set_env(envgMenuItemCount,count);
safe_set_env(envgMenuTop,MenuTop);
safe_set_env(envgMenuBottom,MenuBottom);
safe_set_env(envgMenuSelection,MenuSelection);
safe_set_env(envgMenuStart,MenuStart);
safe_set_env(envgMenuEnd,MenuEnd);
restoreCursor( &cursorState );
}
static void showMenu( const MenuItem * items, int count,
int selection, int row, int height )
{
int i;
CursorState cursorState;
if ( items == NULL || count == 0 ) return;
// head and tail points to the start and the end of the list.
// top and bottom points to the first and last visible items
// in the menu window.
gMenuItems = items;
gMenuRow = row;
gMenuHeight = height;
gMenuItemCount = count;
gMenuTop = 0;
gMenuBottom = min( count, height ) - 1;
gMenuSelection = selection;
// If the selected item is not visible, shift the list down.
if ( gMenuSelection > gMenuBottom )
{
gMenuTop += ( gMenuSelection - gMenuBottom );
gMenuBottom = gMenuSelection;
}
// Draw the visible items.
changeCursor( 0, row, kCursorTypeHidden, &cursorState );
for ( i = gMenuTop; i <= gMenuBottom; i++ )
{
printMenuItem( &items[i], (i == gMenuSelection) );
}
restoreCursor( &cursorState );
}
static int updateMenu( int key, void ** paramPtr )
{
int moved = 0;
union {
struct {
unsigned int
selectionUp : 1,
selectionDown : 1,
scrollUp : 1,
scrollDown : 1;
} f;
unsigned int w;
} draw = {{0}};
if ( gMenuItems == NULL )
return 0;
if( bootArgs->Video.v_display == GRAPHICS_MODE )
{
int res;
// set navigation keys for horizontal layout as defaults
int previous = 0x4B00; // left arrow
int subsequent = 0x4D00; // right arrow
int menu = 0x5000; // down arrow
if ( gui.layout == VerticalLayout )
{
// set navigation keys for vertical layout
previous = 0x4800; // up arrow
subsequent = 0x5000; // down arrow
menu = 0x4B00; // right arrow
}
if ( key == previous )
{
if ( gMenuSelection > gMenuTop )
draw.f.selectionUp = 1;
else if ( gMenuTop > 0 )
draw.f.scrollDown = 1;
}
else if ( key == subsequent )
{
if ( gMenuSelection != gMenuBottom)
draw.f.selectionDown = 1;
else if ( gMenuBottom < ( gMenuItemCount - 1 ) )
draw.f.scrollUp = 1;
}
else if ( key == menu )
{
if ( gui.menu.draw )
updateInfoMenu(key);
else
drawInfoMenu();
}
else if ( gui.menu.draw )
{
res = updateInfoMenu(key);
if ( res == CLOSE_INFO_MENU )
gui.menu.draw = false;
else
{
shouldboot = ( res != DO_NOT_BOOT );
if ( shouldboot )
gui.menu.draw = false;
switch (res)
{
case BOOT_NORMAL:
gVerboseMode = false;
gBootMode = kBootModeNormal;
break;
case BOOT_VERBOSE:
gVerboseMode = true;
gBootMode = kBootModeNormal;
addBootArg(kVerboseModeFlag);
break;
case BOOT_IGNORECACHE:
gVerboseMode = false;
gBootMode = kBootModeNormal;
addBootArg(kIgnoreCachesFlag);
break;
case BOOT_SINGLEUSER:
gVerboseMode = true;
gBootMode = kBootModeNormal;
addBootArg(kSingleUserModeFlag);
break;
}
}
}
} else {
switch ( key )
{
case 0x4800: // Up Arrow
if ( gMenuSelection != gMenuTop )
draw.f.selectionUp = 1;
else if ( gMenuTop > 0 )
draw.f.scrollDown = 1;
break;
case 0x5000: // Down Arrow
if ( gMenuSelection != gMenuBottom )
draw.f.selectionDown = 1;
else if ( gMenuBottom < (gMenuItemCount - 1) )
draw.f.scrollUp = 1;
break;
}
}
if ( draw.w )
{
if ( draw.f.scrollUp )
{
scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);
gMenuTop++; gMenuBottom++;
gMenuStart++; gMenuEnd++;
draw.f.selectionDown = 1;
}
if ( draw.f.scrollDown )
{
scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);
gMenuTop--; gMenuBottom--;
gMenuStart--; gMenuEnd--;
draw.f.selectionUp = 1;
}
if ( draw.f.selectionUp || draw.f.selectionDown )
{
CursorState cursorState;
// Set cursor at current position, and clear inverse video.
if( bootArgs->Video.v_display == VGA_TEXT_MODE )
{
changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop, kCursorTypeHidden, &cursorState );
printMenuItem( &gMenuItems[gMenuSelection], 0 );
}
if ( draw.f.selectionUp )
{
gMenuSelection--;
if(( gMenuSelection - gMenuStart) == -1 )
{
gMenuStart--;
gMenuEnd--;
}
} else {
gMenuSelection++;
if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )
{
gMenuStart++;
gMenuEnd++;
}
}
if( bootArgs->Video.v_display == VGA_TEXT_MODE )
{
moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );
printMenuItem( &gMenuItems[gMenuSelection], 1 );
restoreCursor( &cursorState );
} else
drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);
}
*paramPtr = gMenuItems[gMenuSelection].param;
moved = 1;
}
return moved;
}
int printPathToTarget(struct Knoten *meineKnoten,int StartKnoten,int Endknoten,double StartZeit){//Gibt gegangenen Weg aus
char* BewegungsArray[AnzahlKnoten];//Weg wird mit lastnode zuruckverfolgt , deshalb muss die Ausgabe gedreht werden damit nicht das ende zuerst kommt sondern der Anfang , der "gedrehte" weg wird hier gespeichert
char* buffer = malloc(sizeof(char)*1000);// Zwischenspeicer
for (int i = 0; i < AnzahlKnoten; i++){
if (meineKnoten[i].ID == Endknoten){//ENDKNOTEN Finden
int v = i;
int AnzahlBewegungen = 0;
////Zurueckgelegten Weg (Trace) in Bewegungsarray speichern///////
while (meineKnoten[v].knotenZurueck!=NULL) {
if (gibWegLaenge(meineKnoten, v, meineKnoten[v].knotenZurueck->ID)>0.001) {//Kreuzuebergange haben den weg 0.00001 werden somit ignoriert in der ausgabe (z.b. K1_2(A1) ---0.00001km--> K1_2(A2) wird ignoriert)
sprintf(buffer, "------(%4.2f Km)----->", gibWegLaenge(meineKnoten, v, meineKnoten[v].knotenZurueck->ID));
BewegungsArray[AnzahlBewegungen * 3]=strdup(meineKnoten[v].knotenZurueck->Name);//Ausgangspunkt der "Bewegung" -> Jeder 3. wert (0,3,6,...)
BewegungsArray[AnzahlBewegungen * 3 + 1]=strdup(buffer);//Entfernung der "Bewegung" -> Jeder 3.+1 Wert (1,4,7...)
BewegungsArray[AnzahlBewegungen * 3 + 2]=strdup(meineKnoten[v].Name);//Endpunkt der "Bewegung" -> Jeder 3.+2 Wert (2,5,8,..)
v = meineKnoten[v].knotenZurueck->ID;//Einen Knoten Weiter (zuruck)gehen im nachsten durchlauf
AnzahlBewegungen++;
}else{// falls es ein Kreuzuebergang ist eifach weiter gehen ohne ausgabe zu generieren
v = meineKnoten[v].knotenZurueck->ID;
}
}
/////////////////////////////////////////////////////////////////
//////////////////Bewegungsarray Rueckwarts Lesen und Ausgeben -> resultiert in richtiger logischer Reihenfolge///////////////////////////
if (meineKnoten[i].ID != meineKnoten[StartKnoten].ID) {//Wenn Start!=Endknoten
if (meineKnoten[i].entfernungZumUrsprung == INT_MAX) {//Wenn Kein Weg gefunden
puts("\n");
sprintf(buffer, " \"%s\" ist von \"%s\" aus nicht Erreichbar ", meineKnoten[i].Name, meineKnoten[StartKnoten].Name);
printMenuHeaderContinous(buffer);
puts("\n");
} else {//Weg gefunden , ausgabe beginnen
//Ueberschrift
puts("\n");
sprintf(buffer, " Weg von \"%s\" nach \"%s\" ", meineKnoten[StartKnoten].Name, meineKnoten[i].Name);
printMenuHeader(buffer);
printMenuItem("");
//BEWEGUNGSARRAY Rueckwarts Ausgeben
printTabelHeader(3, " Von ", " Strecke ", " Nach ");
for (int x = AnzahlBewegungen - 1; x >= 0; x--) {
printTabelRow(3, BewegungsArray[x * 3], BewegungsArray[x * 3 + 1], BewegungsArray[x * 3 + 2]);
}
//Endzeile
sprintf(buffer, " | Gesamt: %0.2f Km | Über %d Knoten | Berechnet in %f Sekunden | ", meineKnoten[i].entfernungZumUrsprung,AnzahlBewegungen-1, get_time()-StartZeit);
printFooterText(buffer);
puts("\n");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
break; // Ausgabe erfolgte , Engknoten wurde gefunden , eine weitere suche nach endknoten macht keinen sinn
}
}
return 1;
}
static int updateMenu( int key, void ** paramPtr )
{
int moved = 0;
int MenuTop = (int)get_env(envgMenuTop);
int MenuSelection = (int)get_env(envgMenuSelection);
int MenuRow = (int)get_env(envgMenuRow);
int MenuHeight = (int)get_env(envgMenuHeight);
int MenuBottom = (int)get_env(envgMenuBottom);
int MenuStart = (int)get_env(envgMenuStart);
int MenuEnd = (int)get_env(envgMenuEnd);
union {
struct {
unsigned int
selectionUp : 1,
selectionDown : 1,
scrollUp : 1,
scrollDown : 1;
} f;
unsigned int w;
} draw = {{0}};
if ( gMenuItems == NULL )
return 0;
switch ( key )
{
case 0x4800: // Up Arrow
{
if ( MenuSelection != MenuTop )
draw.f.selectionUp = 1;
else if ( MenuTop > 0 )
draw.f.scrollDown = 1;
break;
}
case 0x5000: // Down Arrow
{
if ( MenuSelection != MenuBottom )
draw.f.selectionDown = 1;
else if ( MenuBottom < (get_env(envgMenuItemCount) - 1) )
draw.f.scrollUp = 1;
break;
}
default:
break;
}
if ( draw.w )
{
if ( draw.f.scrollUp )
{
scollPage(0, MenuRow, 40, MenuRow + MenuHeight - 1, 0x07, 1, 1);
MenuTop++; MenuBottom++;
MenuStart++; MenuEnd++;
draw.f.selectionDown = 1;
}
if ( draw.f.scrollDown )
{
scollPage(0, MenuRow, 40, MenuRow + MenuHeight - 1, 0x07, 1, -1);
MenuTop--; MenuBottom--;
MenuStart--; MenuEnd--;
draw.f.selectionUp = 1;
}
if ( draw.f.selectionUp || draw.f.selectionDown )
{
CursorState cursorState;
// Set cursor at current position, and clear inverse video.
changeCursor( 0, MenuRow + MenuSelection - MenuTop, kCursorTypeHidden, &cursorState );
printMenuItem( &gMenuItems[MenuSelection], 0 );
if ( draw.f.selectionUp )
{
MenuSelection--;
if(( MenuSelection - MenuStart) == -1 )
{
MenuStart--;
MenuEnd--;
}
} else {
MenuSelection++;
if(( MenuSelection - ( MenuEnd - 1) - MenuStart) > 0 )
{
MenuStart++;
MenuEnd++;
}
}
moveCursor( 0, MenuRow + MenuSelection - MenuTop );
printMenuItem( &gMenuItems[MenuSelection], 1 );
restoreCursor( &cursorState );
}
*paramPtr = gMenuItems[MenuSelection].param;
moved = 1;
}
safe_set_env(envgMenuSelection,MenuSelection);
safe_set_env(envgMenuTop,MenuTop );
safe_set_env(envgMenuRow,MenuRow);
safe_set_env(envgMenuHeight,MenuHeight);
safe_set_env(envgMenuBottom,MenuBottom);
safe_set_env(envgMenuStart,MenuStart);
safe_set_env(envgMenuEnd,MenuEnd);
return moved;
}
static int updateMenu( int key, void ** paramPtr )
{
int moved = 0;
union {
struct {
unsigned int
selectionUp : 1,
selectionDown : 1,
scrollUp : 1,
scrollDown : 1;
} f;
unsigned int w;
} draw = {{0}};
if ( NULL == gMenuItems ) return 0;
// Look at the scan code.
switch ( key )
{
case 0x4800: // Up Arrow
if ( gMenuSelection != gMenuTop )
draw.f.selectionUp = 1;
else if ( gMenuTop > 0 )
draw.f.scrollDown = 1;
break;
case 0x5000: // Down Arrow
if ( gMenuSelection != gMenuBottom )
draw.f.selectionDown = 1;
else if ( gMenuBottom < (gMenuItemCount - 1) )
draw.f.scrollUp = 1;
break;
}
if ( draw.w )
{
if ( draw.f.scrollUp )
{
scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);
gMenuTop++; gMenuBottom++;
draw.f.selectionDown = 1;
}
if ( draw.f.scrollDown )
{
scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);
gMenuTop--; gMenuBottom--;
draw.f.selectionUp = 1;
}
if ( draw.f.selectionUp || draw.f.selectionDown )
{
CursorState cursorState;
// Set cursor at current position, and clear inverse video.
changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop,
kCursorTypeHidden, &cursorState );
printMenuItem( &gMenuItems[gMenuSelection], 0 );
if ( draw.f.selectionUp ) gMenuSelection--;
else gMenuSelection++;
moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );
printMenuItem( &gMenuItems[gMenuSelection], 1 );
restoreCursor( &cursorState );
}
*paramPtr = gMenuItems[gMenuSelection].param;
moved = 1;
}
return moved;
}
