Dziennik

{
Autor: Dawid Mocek

}
program dziennik;

uses crt, sysutils;

const
{ nazwa pliku - stala ale nie uzywana globalnie tylko poprzez argumenty funk. }
PLIK = 'uczniowie.bin';

{ Dla okienek w terminalu }
MENU_ROZDZIELACZ_ZANK =  chr(179); // tj '|'
MENU_LEWY_ZANK = chr(195);  // tj '|-'

{ !!! stringi ponizej maja stala dlugosc z powodu wykorzystania do zapisu/odczytu pliku binarnego... !!! }


{ rekord przechowujacy dane ucznia }
type personal = record
    imie : string[32];
    nazwisko : string[32];
end;

{ dla listy przechowujaca oceny }
type woceny=^ocena;
       ocena = record
       nota : integer;
       nastepna_ocena : woceny;
end;

{ dla listy przechowujacej przedmioty i ich oceny }
type wprzedmioty=^przedmioty;
przedmioty = record
       nazwa : string[32]; // nazwa przedmiotu
       oceny : woceny;   // lista ocen
       nastepny_przedmiot : wprzedmioty;
 end;

{ dla listy przechowujacej uwagi ucznia }
type wuwagi=^uwagi;
uwagi = record
       tekst : string[255]; // tekst uwagi ucznia
       nastepna_uwaga : wuwagi;
end;

{ dla listy przechowujacej wszystko co powzyej zostalo wymienione }
type  wuczen=^uczen;
uczen = record
        info : personal; // info o uczniu
        uwagi : wuwagi; // uwagi na jego temat
        przedmioty : wprzedmioty; // przedmioty z ktorych dosatal (w)pale
        nastepny_uczen : wuczen;
end;

{---------------------------------}
{ Operacje na liscie ocen         }
{---------------------------------}

{ procedura dodaje ocene          }
procedure dodaj_ocene(var head: woceny; ocena : integer);
var
   p : woceny;
begin
    new(p);
    p^.nota := ocena;
    p^.nastepna_ocena:= head;
    head := p;
end;

{ procedura liczy ilosc ocen w liscie }
function licz_oceny(head : woceny) : integer;
var
  c : integer;
begin
  c := 0;
  while head <> nil do begin
    inc(c);
    head := head^.nastepna_ocena;
  end;
  licz_oceny := c;
end;

{ procedura usuwa listę jedno. zaw. oceny z pamieci
  - usuwamy cala liste, poniewaz nie mamy w zasadzie zadnej
  informacji za co ocena zostala uzyskana...
}
procedure usun_oceny(var head : woceny);
var
    aktualny: woceny;
begin
    aktualny := head;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nastepna_ocena;
          dispose(head);
          head := aktualny;

  end;
    head := nil;
end;

{---------------------------------}
{ Operacje na liscie uwag         }
{---------------------------------}

{ procedura dodaje uwage do listy }
procedure dodaj_uwage( var head : wuwagi; uwaga : string);
var
   p : wuwagi;
begin
    new(p);
    p^.tekst := uwaga;
    p^.nastepna_uwaga := head;
    head := p;
end;

{ procedura liczy ilosc uwag      }
function licz_uwagi(head : wuwagi) : integer;
var
  c : integer;
begin
  c := 0;
  while head <> nil do begin
    inc(c);
    head := head^.nastepna_uwaga;
  end;
  licz_uwagi := c;
end;

{ procedura usuwa uwagii          }
procedure usun_uwagi(var head: wuwagi);
var
    aktualny: wuwagi;
begin
    aktualny := head;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nastepna_uwaga;
          dispose(head);
          head := aktualny;
    end;
    head := nil;
end;

{---------------------------------}
{ Operacje na liscie przedmiotow  }
{---------------------------------}

{ procedura dodaje przedmiot do listy }
procedure dodaj_przedmiot(var head : wprzedmioty; nazwa : string);
var
   p : wprzedmioty;
begin
      new(p);
      p^.nazwa := nazwa;
      p^.oceny := nil;
      p^.nastepny_przedmiot := head;
      head := p;
end;

{ funkcja licząca ilosc przedmiotow }
function licz_przedmioty(head : wprzedmioty) : integer;
var
  c : integer;
begin
  c := 0;
  while head <> nil do begin
    inc(c);
    head := head^.nastepny_przedmiot;
  end;
  licz_przedmioty := c;
end;

{ procedura usuwa przedmioty      }
procedure usun_przedmioty(var head: wprzedmioty);
var
    aktualny: wprzedmioty;
begin
    aktualny := head;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nastepny_przedmiot;
          { ! usuwamy oceny ! }
          usun_oceny(head^.oceny);
          dispose(head);
          head := aktualny;
    end;
    head := nil;
end;

{ funkcja sprawdzjaca czy podany przedmiot istnieje - jesli tak zwraca przedmiot, nie - nil`a }
function szukaj_przedmiot(head : wprzedmioty; nazwa:string) : wprzedmioty;
var
     aktualny : wprzedmioty;
     jest : boolean;
begin
 aktualny := head;

  while aktualny <> nil do begin
      if (aktualny^.nazwa = nazwa)  then begin
         jest:=true;
         break;
      end;

  aktualny:=aktualny^.nastepny_przedmiot;
  end;

  if jest then szukaj_przedmiot := aktualny else szukaj_przedmiot := nil;

end;

{ procedura usuwa z listu jeden konrketny przedmiot }
procedure usun_przedmiot(var head: wprzedmioty; przedmiot_do_kas: wprzedmioty);
var
     poprzedni, aktualny: wprzedmioty;
begin
  aktualny := head;
  while(aktualny <> nil) do begin

    { jesli nazwy pasuja do siebie mozemy usuwac }
    if(aktualny^.nazwa = przedmiot_do_kas^.nazwa) then begin
            { przypadek 1 - usuwamy glowe }
            if(aktualny = head) then begin

                   head := aktualny^.nastepny_przedmiot;

                   { usuwamy oceny }
                   usun_oceny(aktualny^.oceny);

                   { usuwamy nas }
                   dispose(aktualny);

                   { dla bezpiecznstwa }
                   aktualny := nil;

                   { dalej nie musimy iterować }
                   exit;

            end
            { normlane usuwanie }
            else begin

                   poprzedni^.nastepny_przedmiot := aktualny^.nastepny_przedmiot;

                   { usuwamy oceny }
                   usun_oceny(aktualny^.oceny);

                   { usuwamy nas }
                   dispose(aktualny);

                   { dla bezpiecznstwa }
                   aktualny := nil;

                   { dalej nie musimy iterować }
                   exit;
            end;
    end
    { skaczemy dalej }
    else begin
         poprzedni := aktualny;
         aktualny := aktualny^.nastepny_przedmiot;
    end;
  end;
end;

{---------------------------------}
{ Operacje na liscie uczniow      }
{---------------------------------}

{ procedura dodaje ucznia }
procedure dodaj_ucznia(var head :wuczen; info: personal);
var
   p : wuczen;
begin
   new(p);

   p^.info := info;
   p^.przedmioty:=nil;

   p^.uwagi:=nil;
   p^.nastepny_uczen := head;
   head := p;

end;

{ funkcja szuka ucznia }
function szukaj_ucznia(head : wuczen; info:personal) : wuczen;
var
     aktualny : wuczen;
     jest : boolean;
begin
 aktualny := head;

  while aktualny <> nil do begin
      if (aktualny^.info.imie = info.imie) AND (aktualny^.info.nazwisko = info.nazwisko)  then begin
         jest:=true;
         break;
      end;

  aktualny:=aktualny^.nastepny_uczen;
  end;

  if jest then szukaj_ucznia := aktualny else szukaj_ucznia := nil;

end;

{ funkcja zwaraca ilosc uczniow }
function licz_uczniow(head : wuczen) : integer;
var
  c : integer;
begin
  c := 0;
  while head <> nil do begin
    inc(c);
    head := head^.nastepny_uczen;
  end;
  licz_uczniow := c;
end;

{ usuwa konkrentego ucznia }
procedure usun_ucznia(var head: wuczen; uczen_do_usun : wuczen);
var
 poprzedni, aktualny: wuczen;
begin
  aktualny := head;
  while(aktualny <> nil) do begin
    { jesli wskazniki do siebie pasuja mozemy usuwac }
    if(aktualny = uczen_do_usun) then begin
            { przypadek 1 - usuwamy glowe }
            if(aktualny = head) then begin

                   head := aktualny^.nastepny_uczen;

                   { usuwamy przedmiosty i oceny }
                   usun_przedmioty(aktualny^.przedmioty);

                   { usuwamy uwagi }
                   usun_uwagi(aktualny^.uwagi);

                   { usuwamy nas }
                   dispose(aktualny);

                   { dla bezpiecznstwa }
                   aktualny := nil;

                   { dalej nie musimy iterować }
                   exit;

            end
            { normlane usuwanie }
            else begin

                   poprzedni^.nastepny_uczen:= aktualny^.nastepny_uczen;

                   { usuwamy przedmiosty i oceny }
                   usun_przedmioty(aktualny^.przedmioty);

                   { usuwamy uwagi }
                   usun_uwagi(aktualny^.uwagi);

                   { usuwamy nas }
                   dispose(aktualny);

                   { dla bezpiecznstwa }
                   aktualny := nil;

                   { dalej nie musimy iterować }
                   exit;
            end;
    end
    { skaczemy dalej }
    else begin
         poprzedni := aktualny;
         aktualny := aktualny^.nastepny_uczen;
    end;
  end;
end;

{ usuwa cala liste uczniow oraz wszystkie podlisty }
procedure usun_uczniow(var head: wuczen);
var
    aktualny: wuczen;
begin
    aktualny := head;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nastepny_uczen;
         //  writeln('usuwam: ', head^.info.nazwisko);
          { usuwa przedmioty i oceny }
          usun_przedmioty(head^.przedmioty);

          { usuwa uwagi }
          usun_uwagi(head^.uwagi);

          { usawa siebie }
          dispose(head);
          head := aktualny;
    end;
    head := nil;
end;


{---------------------------------}
{ operacje na plikach             }
{---------------------------------}

{ procedura zapisuje do pliku binarego cala liste uczniow z wszystkimi informacjami}
procedure zapisz(p:wuczen; sciezka:string);
var
  F: File;
  i,j,k:integer;

  ptrUwagi : wuwagi;
  ptrPrzedmioty : wprzedmioty;
  ptrOceny : woceny;

begin
   {$I-}
   assign(F, sciezka);
   rewrite(F,1);
   {$I+}
   if IOResult = 0 then begin
        { Zapisujmey uczniow }
       while( p <> nil) do begin
        BlockWrite(F, p^.info.imie, sizeof(p^.info.imie));
        BlockWrite(F, p^.info.nazwisko, sizeof(p^.info.nazwisko));

       {zapisujemy ich uwagi}
       i := licz_uwagi(p^.uwagi);
       BlockWrite(F, i, sizeof(i));
       ptrUwagi := p^.uwagi;

       while(ptrUwagi <> nil) do begin
               BlockWrite(F, ptrUwagi^.tekst, sizeof(ptrUwagi^.tekst));
               ptrUwagi := ptrUwagi^.nastepna_uwaga;
       end; {// Koniec zapisywania uwag // }

       {zapisujemy przedmioty }
       j := licz_przedmioty(p^.przedmioty);
       BlockWrite(F, j, sizeof(j));
       ptrPrzedmioty := p^.przedmioty;

       while(ptrPrzedmioty <> nil) do begin
           BlockWrite(F, ptrPrzedmioty^.nazwa, sizeof(ptrPrzedmioty^.nazwa));

               {Kazdy przedmiot ma swoja ocene/y - zapiszmy ją }
               k :=  licz_oceny(ptrPrzedmioty^.oceny);
               BlockWrite(F, k, sizeof(k));
               ptrOceny := ptrPrzedmioty^.oceny;

               while(ptrOceny <> nil) do begin
                  BlockWrite(F, ptrOceny^.nota, sizeof(ptrOceny^.nota));
                  ptrOceny := ptrOceny^.nastepna_ocena;
               end;  {// Koniec zapisywania ocen //}

          ptrPrzedmioty := ptrPrzedmioty^.nastepny_przedmiot;
       end;  {// Koniec zapisywania przemiotow //}

    p := p^.nastepny_uczen;
    end;   {// Koniec zapisywania uczniow // }
  close(F);
  end;
end;

{ procedura robi dokladnie na odwrot to co procedura zapisz }
procedure wczytaj(var p:wuczen; sciezka:string);
  var
     F: File;
     ptrUczen : wuczen;
     nazwa_przedmiotu : string[32];
     uczen_info : personal;
     uwaga : string[255];

     i,j,k,ilosc_przedmiotow,ilosc_ocen, ilosc_uwag, numer_tmp,nota :integer;

 begin
  {$I-}
  Assign(F, sciezka);
  Reset(F,1);
  {$I+}
  if IOResult = 0 then begin
     i:=0;
     while not eof(F) do begin
        { czytamy dane ucznia i dodajemy ucznia}
        BlockRead(F, uczen_info.imie, sizeof(uczen_info.imie));
        BlockRead(F, uczen_info.nazwisko, sizeof(uczen_info.nazwisko));

        dodaj_ucznia(p, uczen_info);
        { nasz aktualny uczen to po prostu head }
        ptrUczen := p;

        BlockRead(F, ilosc_uwag, sizeof(ilosc_uwag));

        { dodajemy uwagi }
        for i:=1 to ilosc_uwag do begin
              BlockRead(F, uwaga, sizeof(uwaga));
              dodaj_uwage(ptrUczen^.uwagi, uwaga);
        end;

       { dodajemy przedmioty }
       BlockRead(F, ilosc_przedmiotow, sizeof(ilosc_przedmiotow));
       for j:=1 to ilosc_przedmiotow do begin
             BlockRead(F, nazwa_przedmiotu , sizeof(nazwa_przedmiotu));
             dodaj_przedmiot(ptrUczen^.przedmioty, nazwa_przedmiotu);

             { dodajemy oceny }
             BlockRead(F, ilosc_ocen, sizeof(ilosc_ocen));
             for k:=1 to ilosc_ocen do begin
                  BlockRead(F, nota , sizeof(nota));
                  dodaj_ocene(ptrUczen^.przedmioty^.oceny, nota);
             end;
       end;
     end;
 end;
 Close(F)
end;


{---------------------------------}
{  Inne funkcje                   }
{---------------------------------}

{ sprawdza czy string jest pusty - zwaraca true jesli jest pusty }
function pusty_string(v : string) : boolean;
begin
   if Length(v) = 0 then begin
     pusty_string := true;
   end
   else begin
     pusty_string := false;
   end;
end;


{---------------------------------}
{  Interfejs                      }
{---------------------------------}

{ procedura listuje tylko dane personalne uczniow }
procedure wyswietl_uczniow(head : wuczen);
begin
       while (head <> nil) do begin
           writeln('+ Uczen: ', head^.info.imie , ' ', head^.info.nazwisko);
           head := head^.nastepny_uczen;
       end;
end;

{ okno sluzace do skasowania CALEJ listy ocen }
procedure okno_usun_oceny(var head: wuczen);
  var
     przedmiot, imie, nazw : string;
     tmp_info : personal;
     tmp_uczen: wuczen;
     tmp_przedmiot : wprzedmioty;
     tmp_przedmiot1 : wprzedmioty;
  begin
     ClrScr;
     wyswietl_uczniow(head);

     writeln('Komu skasowac ocene ?');

     write('Podaj imie: ');
     readln(imie);

     write('Podaj nazwisko: ');
     readln(nazw);

      if not pusty_string(imie) and not pusty_string(nazw) then begin
          tmp_info.imie := imie;
          tmp_info.nazwisko := nazw;

          { szukamy ucznia ... }
          tmp_uczen := szukaj_ucznia(head, tmp_info);
          if(tmp_uczen <> nil) then begin

             { ...i istnieje, pokazemy liste przedmiotow jakie ma(o ile ma}
             if(tmp_uczen^.przedmioty <> nil) then begin
                tmp_przedmiot :=  tmp_uczen^.przedmioty;
                  while(tmp_przedmiot <> nil) do begin
                    writeln(tmp_przedmiot^.nazwa);
                    tmp_przedmiot := tmp_przedmiot^.nastepny_przedmiot;
                  end;

                  { wczytuemy przedmiot }
                  Write('Podaj nazwe przedmiotu z ktorych chcesz skasowac oceny: ');
                  readln(przedmiot);

                  { sprawdzmy czy uzy. nie wprowadzil pustej nazwy }
                  if not pusty_string(przedmiot) then begin

                        { teraz szukamy czy przedmiot o podanej nazwie istnieje }
                         tmp_przedmiot1 := szukaj_przedmiot(tmp_uczen^.przedmioty, przedmiot);

                        { sprawdzamy czy rzeczywiscie jest w lisice }
                         if(tmp_przedmiot1 <> nil) then begin

                             { mozemy usunac oceny przedmiotu }
                             usun_oceny(tmp_przedmiot1^.oceny);
                             writeln('Oceny skasowane !');
                        end
                        else begin
                           writeln('Taki przedmiot nie istnieje');
                        end;
                  end
                  else begin
                    writeln('Pusta tresc przedmiotu ?');
                  end;
             end
             else begin
                  writeln('Lista przedmiotow nie istnieje');
             end;
          end
          else begin
              writeln('Taki uczen nie istnieje.');
          end;
          end
          else begin
           writeln('Nie wypelniono wszystich pol.')
      end;
  end;

{ okno w ktorym dodajemy ocene }
procedure okno_dodaj_ocene(var head : wuczen);
var
   przedmiot, imie, nazw : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
   tmp_przedmiot : wprzedmioty;
   tmp_przedmiot1 :wprzedmioty;
   nota : integer;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Komu wstawic ocene ?');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        { szukamy ucznia ... }
        tmp_uczen := szukaj_ucznia(head, tmp_info);
        if(tmp_uczen <> nil) then begin

           { ...i istnieje, pokazemy liste przedmiotow jakie ma(o ile ma}
           if(tmp_uczen^.przedmioty <> nil) then begin
                tmp_przedmiot :=  tmp_uczen^.przedmioty;

                while(tmp_przedmiot <> nil) do begin
                  writeln(tmp_przedmiot^.nazwa);
                  tmp_przedmiot := tmp_przedmiot^.nastepny_przedmiot;
                end;

                { wczytujemy nazwe przedmiotu }
                Write('Podaj nazwe przedmiotu do wpisania oceny: ');
                readln(przedmiot);

                { sprawdzmy czy uzy. nie wprowadzil pustej nazwy }
                if not pusty_string(przedmiot) then begin

                { teraz szukamy czy przedmiot o podanej nazwie istnieje }
                  tmp_przedmiot1 := szukaj_przedmiot(tmp_uczen^.przedmioty, przedmiot);

                      { sprawdzamy czy rzeczywiscie jest w lisice }
                       if(tmp_przedmiot1 <> nil) then begin

                           { mozemy dodac ocene }
                            write('Podaj ocene: ');
                            readln(nota);
                            dodaj_ocene(tmp_przedmiot1^.oceny, nota);
                            writeln('Ocena dodana !');
                      end
                      else begin
                         writeln('Taki przedmiot nie istnieje');
                      end;
                end
                else begin
                     writeln('Pusta tresc przedmiotu ?');
                end;
           end
           else begin
                 writeln('Lista przedmiotow nie istnieje');
           end;
        end
        else begin
          writeln('Taki uczen nie istnieje.');
        end;
        end
    else begin
          writeln('Nie wypelniono wszystich pol.')
     end;

end;

{ okno w ktorym usuwamy dany przedmiot }
procedure okno_usun_przedmiot(var head : wuczen);
var
   przedmiot, imie, nazw : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
   tmp_przedmiot, tmp_przedmiot1 : wprzedmioty;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Komu usunac przedmiot ?');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        { szukamy ucznia ... }
        tmp_uczen := szukaj_ucznia(head, tmp_info);
        if(tmp_uczen <> nil) then begin

           { ...i istnieje, pokazemy liste przedmiotow jakie ma(o ile ma}
           if(tmp_uczen^.przedmioty <> nil) then begin
                 tmp_przedmiot :=  tmp_uczen^.przedmioty;
                while(tmp_przedmiot <> nil) do begin
                  writeln(tmp_przedmiot^.nazwa);
                  tmp_przedmiot := tmp_przedmiot^.nastepny_przedmiot;
                end;

                { wczytuemy przedmiot }
                Write('Podaj nazwe przedmiotu do usuniecia: ');
                readln(przedmiot);

                { sprawdzmy czy uzy. nie wprowadzil pustej nazwy }
                if not pusty_string(przedmiot) then begin

                      { teraz szukamy czy przedmiot o podanej nazwie istnieje }
                       tmp_przedmiot1 := szukaj_przedmiot(tmp_uczen^.przedmioty, przedmiot);

                      { sprawdzamy czy rzeczywiscie jest w lisice }
                       if(tmp_przedmiot1 <> nil) then begin

                           { mozemy go usunac }
                           usun_przedmiot(tmp_uczen^.przedmioty, tmp_przedmiot1);
                           writeln('Przedmiot usunieto.');
                      end
                      else begin
                         writeln('Taki przedmiot nie istnieje');
                      end;

                end
                else begin
                  writeln('Pusta tresc przedmiotu ?');
                end;
           end
           else begin
                writeln('Lista przedmiotow nie istnieje');
           end;
        end
        else begin
            writeln('Taki uczen nie istnieje.');
        end;
        end
        else begin
         writeln('Nie wypelniono wszystich pol.')
    end;
end;

{ okno w ktorum dodajemy przedmiot danemu uczniowi }
procedure okno_dodaj_przedmiot(var head : wuczen);
var
   przedmiot, imie, nazw : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
   tmp_przedmiot : wprzedmioty;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Komu dodac przedmiot ?');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        { szukamy ucznia ... }
        tmp_uczen := szukaj_ucznia(head, tmp_info);
        if(tmp_uczen <> nil) then begin

           { ... jest takowy, szukamy przedmiotu ... }
              Write('Podaj nazwe przedmiotu ktory chcesz dodac: ');
              readln(przedmiot);

              { ... ktory uzytkownik dobrze wprowadzil ...}
              if not pusty_string(przedmiot) then begin

                 { ... zatem szukamy go na liscie co by nie bylo duplikatow ... }
                     tmp_przedmiot := szukaj_przedmiot(tmp_uczen^.przedmioty, przedmiot);
                     if(tmp_przedmiot = nil) then begin

                        { ... wszystko ok - dodajemy nowy przedmiot. }
                        dodaj_przedmiot(tmp_uczen^.przedmioty, przedmiot);
                        Writeln('Dodano przedmiot: ', przedmiot);
                     end
                     else begin
                         writeln('Taki przedmiot juz istnieje!');
                     end;
              end
              else begin
                writeln('Tresc przedmiotu jest pusta ?');
              end;
        end
        else begin
            writeln('Taki uczen nie istnieje.');
        end;
        end
        else begin
         writeln('Nie wypelniono wszystich pol.')
    end;

end;

{ okno w ktorym usuwamy ucznia }
procedure okno_usun_ucznia(var head : wuczen);
var
   imie, nazw : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Kogo usunac ?');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        tmp_uczen := szukaj_ucznia(head, tmp_info);
        if(tmp_uczen <> nil) then begin
           usun_ucznia(head, tmp_uczen);
           writeln('Uczen odwolany.');
        end
        else begin
             writeln('Taki uczen nie istnieje.');
        end;
    end
    else begin
         writeln('Nie wypelniono wszystich pol.')
    end;
end;

{ okno w ktorym dodajemy uwage }
procedure okno_dodaj_uwage(var head: wuczen);
var
   imie, nazw, uwaga : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Komus dodac uwage ?');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        tmp_uczen := szukaj_ucznia(head, tmp_info);
        if(tmp_uczen <> nil) then begin
            ClrScr;
            WriteLn('Podaj uwage dla: ', tmp_uczen^.info.nazwisko);
            ReadLn(uwaga);

            if not pusty_string(uwaga) then begin
               dodaj_uwage(tmp_uczen^.uwagi, uwaga);
               writeln('Uwaga dodana !');
            end
            else begin
               writeln('Uwaga bez tresc?');
            end;
        end
        else begin
            writeln('Taki uczen nie istnieje.');
        end;
    end
    else begin
       writeln('Nie wypelniono wszystich pol.')
    end;
end;

{ okno w ktorym listujemy uwagi uzyskane przez ucznia }
procedure okno_uwag(head: wuczen);
var
   imie, nazw : string;
   tmp_info : personal;
   tmp_uczen: wuczen;
   tmp_uwaga: wuwagi;
begin
   ClrScr;
   wyswietl_uczniow(head);

   writeln('Podaj inf. zeby zobaczyc uwagi.');

   write('Podaj imie: ');
   readln(imie);

   write('Podaj nazwisko: ');
   readln(nazw);

    if not pusty_string(imie) and not pusty_string(nazw) then begin
        tmp_info.imie := imie;
        tmp_info.nazwisko := nazw;

        tmp_uczen := szukaj_ucznia(head, tmp_info);

        { sprawdzamy czy taki uczen istnieje ... }
        if tmp_uczen <> nil then begin

           { ...i czy uwagi tez jakies ma ... }
           tmp_uwaga := tmp_uczen^.uwagi;
           if(tmp_uwaga <> nil ) then begin

              { ... zatem wydrukujemy je. }
              ClrScr;
              writeln('Uwagi pana(i): ', tmp_uczen^.info.nazwisko);
              while( tmp_uwaga <> nil) do begin
                  writeln(tmp_uwaga^.tekst) ;
                  tmp_uwaga := tmp_uwaga^.nastepna_uwaga;
              end;
           end
           else begin
               writeln('Uwagi ucznia: Brak.');
           end;
        end
        else begin
           writeln('Taki uczen nie istnieje.');
        end;
      end
      else begin
       writeln('Nie wypelniono wszystich pol.')
     end;

end;

{ okno w ktorym listujemy uczniow ich przedmioty oraz oceny }
procedure okno_uczniow_i_ocen(head :wuczen);
var
   tmp_oceny : woceny;
   tmp_przedmioty :wprzedmioty;
begin
  ClrScr;
   while (head <> nil) do begin

     { listujemy uczniów }
     writeln('+ Uczen: ', head^.info.imie , ' ', head^.info.nazwisko);

     { listujemy przedmioty }
     if(head^.przedmioty = nil) then begin
        writeln('| Brak przedmiotow');
        end
        else begin
        writeln('| Przedmioty: ');
        tmp_przedmioty     := head^.przedmioty;
        while( tmp_przedmioty  <> nil) do begin
                write('|-> ', tmp_przedmioty^.nazwa, ': ');

                tmp_oceny := tmp_przedmioty^.oceny;

                { listujemy oceny danego przedmiotu }
                while(tmp_oceny <> nil) do begin
                        write(tmp_oceny^.nota, ',');
                        tmp_oceny := tmp_oceny^.nastepna_ocena;
                end;
                writeln;

       tmp_przedmioty  := tmp_przedmioty^.nastepny_przedmiot;
        end;
        end;
   head := head^.nastepny_uczen;
   end;
end;

{ wyswietla menu }
procedure wyswietl_menu;
begin
   Window(1,1,15,25);
   TextBackGround(LightMagenta);
   ClrScr;
   Writeln('MENU');

   Writeln;

   Writeln('Uczniowie');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' D'); TextColor(LightGray); Writeln('odaj');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' W'); TextColor(LightGray); Writeln('ykaz ocen');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' L'); TextColor(LightGray); Writeln('ista uwag');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' U'); TextColor(LightGray); Writeln('waga+');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' O'); TextColor(LightGray); Writeln('dwolaj');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' ['); TextColor(LightGray); Writeln('Przedmiot+');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' ]'); TextColor(LightGray); Writeln('Przedmiot-');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' /'); TextColor(LightGray); Writeln('Ocena+');
   Write(MENU_LEWY_ZANK); TextColor(LightRed);  Write(' \'); TextColor(LightGray); Writeln('OcenY-');

   GoToXY(1,24);

                         TextColor(LightRed);  Write('C'); TextColor(LightGray); Writeln('ya!');

end;

{ wyswietla glowne okno programu }
procedure wyswietl_glowne_okno;
begin
   Window(17,1,80,26);
   TextBackGround(Black);
   ClrScr;
end;

{ drukuje sperator rozdzielajacy menu od glownego okna }
procedure wyswietl_separator;
var i:integer;
begin
   Window(16,1,17,25);
   ClrScr;
   For i:=1 To 25 Do Writeln(MENU_ROZDZIELACZ_ZANK);
end;

{ wyswietla jak widac }
procedure stworz_okna;
begin
    Window(10,1,80,25);

    wyswietl_menu;
    wyswietl_separator;
    wyswietl_glowne_okno;

end;

{ okono do dodania ucznia }
procedure okno_dodaj_ucznia(var head: wuczen);
var
   imie, nazw : string;
   nowy_uczen : personal;
   tmp_uczen : wuczen;

begin
     ClrScr;

     Write('Imie: ');
     readln(imie);

     Write('Nazwisko: ');
     readln(nazw);

     if not pusty_string(imie) and not pusty_string(nazw) then begin
        nowy_uczen.imie := imie;
        nowy_uczen.nazwisko := nazw;

        tmp_uczen := szukaj_ucznia(head, nowy_uczen);

        { sprawdzamy czy taki uczen aby nie istnieje }
        if tmp_uczen = nil then begin
           dodaj_ucznia(head, nowy_uczen);
           writeln('Dodano ucznia.');
        end
        else begin
           writeln('Taki uczen juz istnieje.');
        end;
      end
      else begin
       writeln('Nie wypelniono wszystich pol.')
     end;
end;

{---------------------------------}
{ Program glowny                  }
{---------------------------------}

var
   { nasza glowna lista uczniow }
   lista_uczniow : wuczen;

   { char do sterowania menu }
   wybor : char;

   {sciezka z ktorej program sie uruchomil }
   sciezka : string;

   { absolutna scieka do pliku birnaego }
   plik_uczniow : string;


begin
  lista_uczniow := nil;

  { sciezka z ktorej program sie uruchomil }
  sciezka := GetCurrentDir;

  { sciezka + plik czyli absolutna sciezka do pliku }
  plik_uczniow := sciezka + '\' + PLIK;

  {
    wczytuje z pliku binarnego rekordy do listy uczniow oraz wszystkie informaje
    o ocenach i przedmiotach
  }
  wczytaj(lista_uczniow, plik_uczniow);

  { tworzymy okna tj menu, separtor, glownego okno}
  stworz_okna;
  repeat
        repeat
        wybor := ReadKey;
        wybor := UpCase(wybor);

        until wybor in ['D','W', 'L' ,'U', ']','[','/','\', 'O', 'C'];
        case wybor of

        { zapisujemy po kazdym wywolaniu okna nowo dodane informacje }
        'D': begin okno_dodaj_ucznia(lista_uczniow);    zapisz(lista_uczniow, plik_uczniow);            end;
        'W': begin okno_uczniow_i_ocen(lista_uczniow);                                                  end;

        'L': begin okno_uwag(lista_uczniow);                                                            end;
        'U': begin okno_dodaj_uwage(lista_uczniow);     zapisz(lista_uczniow, plik_uczniow);            end;

        ']': begin okno_usun_przedmiot(lista_uczniow);  zapisz(lista_uczniow, plik_uczniow);            end;
        '[': begin okno_dodaj_przedmiot(lista_uczniow); zapisz(lista_uczniow, plik_uczniow);            end;

        '/': begin okno_dodaj_ocene(lista_uczniow);     zapisz(lista_uczniow, plik_uczniow);            end;
        '\': begin okno_usun_oceny(lista_uczniow);      zapisz(lista_uczniow, plik_uczniow);            end;

        'O': begin okno_usun_ucznia(lista_uczniow);     zapisz(lista_uczniow, plik_uczniow);            end;
        end;

  until wybor = 'C';

{ usuwamy liste z pamieci wraz z wszystkimi podlistami }
 usun_uczniow(lista_uczniow);
end.