(**********************************************************************

    :Program.    VEingabe.mod
    :Contents.   Procedure zum Editieren der Vokabeln für das Programm
    :Contents.   VTrainer
    :Author.     Dieter WILHELM
    :Address.    Albert-Schweitzer-Str.44, 8000 München 83
    :Phone.      089/671693
    :Copyright.  PD
    :Language.   Modula-2
    :Translator. M2Amiga A+L V4.0d
    :Imports.    IntuiStruct1.3 [bne] Amok#3, Lists [bne] Amok#22
    :Imports.    VMenue
    :History.    V1.0 Dieter WILHELM 13.Jan.1991
    :History.    V1.1 Dieter WILHELM 29.Sept.1991

**********************************************************************)

IMPLEMENTATION MODULE VEingabe ;


  FROM Conversions IMPORT ValToStr;
  FROM ExecL       IMPORT GetMsg, ReplyMsg, WaitPort;
  FROM GraphicsD   IMPORT jam1;
  FROM GraphicsL   IMPORT Move, RectFill, SetAPen, Text;
  FROM Heap        IMPORT AllocMem, Deallocate;
  FROM IntuiStruct IMPORT AllocProc, BorderEnd, DeallocProc, Rectangle,
                          StructBorder, StructGadget, StructString,
                          StructText;
  FROM IntuitionD  IMPORT ActivationFlags, ActivationFlagSet, boolGadget,
                          Border, Gadget, GadgetFlags, GadgetFlagSet,
                          GadgetPtr, IDCMPFlags, IDCMPFlagSet,
                          IntuiMessagePtr, IntuiText, strGadget,
                          StringInfo, WindowPtr;
  FROM IntuitionL  IMPORT ActivateGadget, AddGList, ModifyIDCMP,
                          PrintIText, RefreshGList, RemoveGList;
  FROM Lists       IMPORT AppendEntryC ;
  FROM SYSTEM      IMPORT ADR, LONGSET ;
  FROM VMenue      IMPORT attr;


  VAR WPtr         : WindowPtr ;
      GPtr         : GadgetPtr ;
      SGad         : ARRAY [0..5] OF Gadget ;
      Buffer       : ARRAY [0..5] OF Zeile ;
      UBuffer      : ARRAY [0..5] OF Zeile ;
      SInfo        : ARRAY [0..5] OF StringInfo ;
      SBorder      : ARRAY [0..5] OF Border ;
      TGad         : ARRAY [0..2] OF Gadget ;
      IText        : ARRAY [0..2] OF IntuiText ;
      TBorder      : ARRAY [0..2] OF Border ;
      Beschriftung : ARRAY [0..3] OF IntuiText ;
      i            : INTEGER ;
      Vok          : Vokabel ;
      Abfall       : BOOLEAN ;
      Zahl         : ARRAY [0..3] OF CHAR ;


  PROCEDURE Einlesen(W: WindowPtr; VAR Kopf: VKopf): BOOLEAN ;
    VAR Msg   : IntuiMessagePtr ;
        class : IDCMPFlagSet ;
        code  : CARDINAL ;
        GPtr2 : GadgetPtr ;
        k     : CARDINAL ;
        aktiv : BOOLEAN ;
    BEGIN
      aktiv := ActivateGadget(ADR(SGad[0]), W, NIL) ;
      LOOP
        WaitPort(W^.userPort) ;
        Msg := GetMsg(W^.userPort) ;
        WHILE Msg # NIL DO
          class := Msg^.class ;
          GPtr2 := Msg^.iAddress ;
          code  := Msg^.code ;
          ReplyMsg(Msg) ;
          IF rawKey IN class THEN
            IF code = 89 THEN
              WITH Vok DO
                FOR k := 0 TO 23 DO
                  Wort[k] := Buffer[0,k] ;
                END ;  (* FOR *)
                FOR i := 0 TO 4 DO
                  FOR k := 0 TO 23 DO
                    Uebersetzung[i,k] := Buffer[i +1,k] ;
                  END ;  (* FOR k *)
                END ;  (* FOR i *)
              END ;  (* WITH *)
              AppendEntryC(Kopf.Gruppe[0], Vok) ;
              INC(Kopf.Anzahl) ;
              RETURN TRUE; (* Vokabel anhängen und auf Eingabe warten *)
            ELSIF code = 84 THEN
              WITH Vok DO
                FOR k := 0 TO 23 DO
                  Wort[k] := Buffer[0,k] ;
                END ;  (* FOR *)
                FOR i := 0 TO 4 DO
                  FOR k := 0 TO 23 DO
                    Uebersetzung[i,k] := Buffer[i +1,k] ;
                  END ;  (* FOR k *)
                END ;  (* FOR i *)
              END ;  (* WITH *)
              AppendEntryC(Kopf.Gruppe[0], Vok) ;
              INC(Kopf.Anzahl) ;
              RETURN FALSE;   (* Eingabe beenden mit Vokabel anhängen *)
            ELSIF code = 80 THEN
              RETURN FALSE; (* Eingabe beenden ohne Vokabel anzuhängen *)
            END ;  (* IF code *)
          END ;  (* IF rawKey *)
          IF gadgetUp IN class THEN
            CASE GPtr2^.gadgetID OF
              10 : aktiv := ActivateGadget(ADR(SGad[1]), W, NIL)|
              11 : aktiv := ActivateGadget(ADR(SGad[2]), W, NIL)|
              12 : aktiv := ActivateGadget(ADR(SGad[3]), W, NIL)|
              13 : aktiv := ActivateGadget(ADR(SGad[4]), W, NIL)|
              14 : aktiv := ActivateGadget(ADR(SGad[5]), W, NIL)|
              15 : |
               0 : RETURN FALSE|   (* Eingabe beenden ohne
                                      Vokabel anzuhängen *)
               1 : WITH Vok DO
                     FOR k := 0 TO 23 DO
                       Wort[k] := Buffer[0,k] ;
                     END ;  (* FOR *)
                     FOR i := 0 TO 4 DO
                       FOR k := 0 TO 23 DO
                         Uebersetzung[i,k] := Buffer[i +1,k] ;
                       END ;  (* FOR k *)
                     END ;  (* FOR i *)
                   END ;  (* WITH *)
                   AppendEntryC(Kopf.Gruppe[0], Vok) ;
                   INC(Kopf.Anzahl) ;
                   RETURN FALSE|     (* Eingabe beenden mit
                                        Vokabel anhängen *)
               2 : WITH Vok DO
                     FOR k := 0 TO 23 DO
                       Wort[k] := Buffer[0,k] ;
                     END ;  (* FOR *)
                     FOR i := 0 TO 4 DO
                       FOR k := 0 TO 23 DO
                         Uebersetzung[i,k] := Buffer[i +1,k] ;
                       END ;  (* FOR k *)
                     END ;  (* FOR i *)
                   END ;  (* WITH *)
                   AppendEntryC(Kopf.Gruppe[0], Vok) ;
                   INC(Kopf.Anzahl) ;
                   RETURN TRUE|   (* Vokabel anhängen und auf
                                     Eingabe warten *)
              ELSE;
            END ;  (* CASE *)
          END ;  (* IF *)
          Msg := GetMsg(W^.userPort) ;
        END ;  (* WHILE *)
      END ;  (* LOOP *)
  END Einlesen ;


  PROCEDURE Eingabe(VAR Kopf: VKopf; WPtr: WindowPtr): BOOLEAN ;
    VAR GadPos : INTEGER ;
        Anzahl : LONGINT ;
    BEGIN
      Anzahl := Kopf.Anzahl ;
      FOR i := 0 TO 5 DO
        Buffer[i]  := "" ;
        UBuffer[i] := "" ;
      END ;  (* FOR *)
      SetAPen(WPtr^.rPort, 0);
      RectFill(WPtr^.rPort, 0, 15, WPtr^.width, WPtr^.height);
      GadPos := AddGList(WPtr, GPtr, -1, 9, NIL) ;
      INCL(WPtr^.idcmpFlags, gadgetUp) ;
      INCL(WPtr^.idcmpFlags, rawKey) ;
      ModifyIDCMP(WPtr, WPtr^.idcmpFlags) ;
      RefreshGList(GPtr, WPtr, NIL, 9) ;
      PrintIText(WPtr^.rPort, ADR(Beschriftung[0]), 80, 40) ;
      Move(WPtr^.rPort, 345, 56) ; SetAPen(WPtr^.rPort, 3) ;
      ValToStr(Kopf.Anzahl, FALSE, Zahl, 10, 4, " ", Abfall) ;
      Text(WPtr^.rPort, ADR(Zahl), 4) ;
      Move(WPtr^.rPort, 117, 232) ; Text(WPtr^.rPort, ADR("   F1"), 5);
      Move(WPtr^.rPort, 237, 232) ; Text(WPtr^.rPort, ADR("   F5"), 5);
      Move(WPtr^.rPort, 482, 232) ; Text(WPtr^.rPort, ADR("  F10"), 5);
      WHILE Einlesen(WPtr, Kopf) DO
        FOR i := 0 TO 5 DO
          Buffer[i]  := "" ;
          UBuffer[i] := "" ;
        END ;  (* FOR *)
        RefreshGList(GPtr, WPtr, NIL, 6) ;
        Move(WPtr^.rPort, 345, 56) ; SetAPen(WPtr^.rPort, 3) ;
        ValToStr(Kopf.Anzahl, FALSE, Zahl, 10, 4, " ", Abfall) ;
        Text(WPtr^.rPort, ADR(Zahl), 4) ;
      END ;  (* WHILE *)
      GadPos := RemoveGList(WPtr, GPtr, 9) ;
      EXCL(WPtr^.idcmpFlags, gadgetUp) ;
      EXCL(WPtr^.idcmpFlags, rawKey) ;
      ModifyIDCMP(WPtr, WPtr^.idcmpFlags) ;
      SetAPen(WPtr^.rPort, 0) ;
      RectFill(WPtr^.rPort, 0, 15, WPtr^.width, WPtr^.height) ;
      IF Anzahl = Kopf.Anzahl THEN
        RETURN FALSE ;
      ELSE
        RETURN TRUE ;
      END ;  (* IF *)
  END Eingabe ;


  BEGIN   (* VEingabe *)
    WITH Vok DO
      Wort := "" ;
      FOR i := 0 TO 4 DO
        Uebersetzung[i] := "" ;
      END ;  (* FOR *)
      abgefragt[v] := 0 ; gewusst[v] := 0 ;
      abgefragt[ue] := 0 ; gewusst[ue] := 0 ;
    END ;  (* WITH *)
    AllocProc := AllocMem ; DeallocProc := Deallocate ;
    StructString(SInfo[0], Buffer[0], UBuffer[0]) ;
    StructBorder(SBorder[0], -2, -2, 1, jam1, 4, NIL) ;
    Rectangle(205, 15) ;
    BorderEnd ;
    StructGadget(SGad[0], 105, 80, 200, 10, GadgetFlagSet{},
                 ActivationFlagSet{stringCenter, relVerify}, strGadget,
                 ADR(SBorder[0]), NIL, LONGSET{}, 10, ADR(SGad[1])) ;
    SGad[0].specialInfo := ADR(SInfo[0]) ;
    FOR i := 1 TO 5 DO
      StructString(SInfo[i], Buffer[i], UBuffer[i]) ;
      StructBorder(SBorder[i], -2, -2, 1, jam1, 4, NIL) ;
      Rectangle(205, 15) ;
      BorderEnd ;
      StructGadget(SGad[i], 337, 60 + 20 * i, 200, 10, GadgetFlagSet{},
                   ActivationFlagSet{stringCenter, relVerify}, strGadget,
                   ADR(SBorder[i]), NIL, LONGSET{}, 10 + i, NIL) ;
      SGad[i].specialInfo := ADR(SInfo[i]) ;
    END ;  (* FOR *)
    FOR i := 1 TO 4 DO
      SGad[i].nextGadget := ADR(SGad[i + 1]) ;
    END ;  (* FOR *)
    FOR i := 0 TO 1 DO
      StructBorder(TBorder[i], -2, -2, 3, jam1, 4, NIL) ;
      Rectangle(85, 16) ;
      BorderEnd ;
      StructText(IText[i], 3, 1, jam1, 1, 1, NIL, NIL) ;
      IText[i].iTextFont := ADR(attr);
      StructGadget(TGad[i], 117 + 120 * i, 210, 80, 12, GadgetFlagSet{},
                   ActivationFlagSet{gadgImmediate, relVerify},
                   boolGadget, ADR(TBorder[i]), ADR(IText[i]), LONGSET{},
                   i, ADR(TGad[i+1]));
    END ;  (* FOR *)
    StructBorder(TBorder[2], -2, -2, 3, jam1, 4, NIL) ;
    Rectangle(65, 16) ;
    BorderEnd ;
    StructText(IText[2], 3, 1, jam1, 1, 1, ADR("  OK"), NIL) ;
    IText[2].iTextFont := ADR(attr);
    StructGadget(TGad[2], 482, 210, 60, 12, GadgetFlagSet{},
                 ActivationFlagSet{gadgImmediate, relVerify}, boolGadget,
                 ADR(TBorder[2]), ADR(IText[2]), LONGSET{}, 2, NIL) ;
    SGad[5].nextGadget := ADR(TGad[0]) ;
    IText[0].iText := ADR("  Abbruch") ;
    IText[1].iText := ADR(" Anhängen") ;
    FOR i := 0 TO 1 DO
      StructText(Beschriftung[i], 1, 3, jam1, 100 + 210 * i, 25, NIL,
                 ADR(Beschriftung[i + 1])) ;
      Beschriftung[i].iTextFont := ADR(attr);
    END ;  (* FOR *)
    StructText(Beschriftung[2], 3, 1, jam1, 57, 155,
               ADR("Zurück zum Hauptmenü"), ADR(Beschriftung[3]) ) ;
    Beschriftung[2].iTextFont := ADR(attr);
    Beschriftung[0].iText := ADR("Vokabel") ;
    Beschriftung[1].iText := ADR("Übersetzung") ;
    StructText(Beschriftung[3], 3, 1, jam1, 100, 10,
               ADR("Anzahl der Vokabeln :"), NIL ) ;
    Beschriftung[3].iTextFont := ADR(attr);
    GPtr := ADR(SGad[0]) ;


END VEingabe.
