/*
 *       miscE.c             © by Martin Steppler
 */

struct Device   *ConsoleDevice = NULL;
struct IOStdReq ConsoleMsg;

extern void ReleaseFileSelect();
char *BriefText[] = {
   "LETTER", "ASCII ", "AUT", "   "
};

#define OFFSET     431
#define KLOTZ      10240

DeadKeyConvert(Message, KeyBuffer, BufferSize, KeyMap)
struct IntuiMessage *Message;
UBYTE *KeyBuffer;
int BufferSize;
struct KeyMap *KeyMap;
{
   static struct InputEvent InputEvent =
   {
      NULL,             /* struct InputEvent *ie_NextEvent; */
      IECLASS_RAWKEY,   /* UBYTE ie_Class; */
      0,                /* UBYTE ie_SubClass; */
      0,                /* UWORD ie_Code; */
      0                 /* UWORD ie_Qualifier; */
                        /* union */
                        /* { */
                        /*    struct */
                        /*    { */
                        /*       WORD ie_x; */
                        /*       WORD ie_y; */
                        /*    } ie_xy; */
                        /*    APTR ie_addr; */
                        /* } ie_position; */
                        /* struct timeval ie_TimeStamp; */
   };

   if (Message->Class != RAWKEY)          return(-2);
   if (Message->Code & IECODE_UP_PREFIX)  return(0);

   InputEvent.ie_Code = Message->Code;
   InputEvent.ie_Qualifier = Message->Qualifier;
   InputEvent.ie_position.ie_addr = (APTR)*(Message->IAddress);

   return(RawKeyConvert(&InputEvent, KeyBuffer, BufferSize, KeyMap));
}

OpenReadConsole()
{
   if (OpenDevice("console.device", -1L, &ConsoleMsg, 0) != 0)
      return(-1);
   ConsoleDevice = (struct Device *)ConsoleMsg.io_Device;
   return(0);
}

Meldung()
{
   UBYTE string[80];

   StilAus();
   strcpy(string, "                                                     ");
   Move(RP, 6, 20);
   Text(RP, string, strlen(string));
   Move(RP, 6, 20);
   Text(RP, buffer, strlen(buffer));
   sprintf(buffer, "PGE %-3d LIN %-3d COL %-3d", s+1, z+1, x);
   Move(RP, OFFSET, 20);
   Text(RP, buffer, strlen(buffer));
   if(ein==TRUE) ein=FALSE; else ein=TRUE;
   StilAn();
   Einfuegen();
}
Brief()
{
   br++;
   if(br==2) br=0;
   ZSDisplay();
   MenueUeberwachung(3);
}
Auto()
{
   au++; if(au==2) au=0; ZSDisplay();
   MenueUeberwachung(3);
}
Backup()
{
   if(++bak==2) bak=0; MenueUeberwachung(3);
   if(bak) sprintf(buffer, "Backup mode switched ON!");
   else    sprintf(buffer, "Backup mode switched OFF!");
}
NamenSetzen(FName)
UBYTE *FName;
{
   UBYTE string[80];

   StilAus();
   strcpy(string, "                                                     ");
   Move(RP, 6, 9);
   Text(RP, string, strlen(string));
   Move(RP, 6, 9);
   Text(RP, FName, strlen(FName));
   strcpy(titel, FName);
   StilAn();
}
Einfuegen()
{
   StilAus();
   if(ein==FALSE) {
      sprintf(buffer, "INS %s %s LN %-5d", BriefText[au+2],
         BriefText[br], s*(SEITE+1)+z+1);
      ein = TRUE;
   }
   else {
      sprintf(buffer, "    %s %s LN %-5d", BriefText[au+2],
         BriefText[br],s*(SEITE+1)+z+1);
      ein = FALSE;
   }
   Move(RP, OFFSET, 9);
   Text(RP, buffer, strlen(buffer));
   StilAn();
   MenueUeberwachung(3);
}
LadeConfig(fn)
char *fn;
{
   struct FileHandle *handle;
   int ende = FALSE, x1, ln, trans, zaehler=0, alt, weiter=FALSE, durch=FALSE;
   UBYTE buf[256];

   if(!(handle=Open(fn,MODE_OLDFILE))) return(FALSE);
   FOREVER {
      if(ende) break;
      if((ln = Read(handle,buffer,GROESSE))<GROESSE) {
         Close(handle); ende=TRUE;
      }
      trans = ln; ln=0;
hops: if(weiter) {
         FOREVER {
            if(ln==trans) break;
            if(buffer[ln++] == LF) { weiter=FALSE; break; }
         }
         if(ln==trans) continue;
      }
      if(zaehler<3 || zaehler==9) { zaehler++; weiter=TRUE; goto hops; }
      if(zaehler<=18  && !durch ) x1=0;
      alt=zaehler;
      do {
         if((buf[x1++] = buffer[ln++]) == 32) {
            buf[--x1] = EOS; zaehler++;
         }
      } while(ln<trans && zaehler==alt);
      durch=FALSE;
      if(zaehler>alt) {
         switch(zaehler) {
            case 4:
               if((MAX=atoin(buf))>ABSMAX) MAX=ABSMAX; else if(MAX<10) MAX=10;
               break;                    /* Textbreite */
            case 5:
               if((SEITE=atoin(buf)-1)>71) SEITE=71; else if(SEITE<9) SEITE=9;
               break;                    /* Seitenlänge */
            case 6:
               ein = (atoin(buf)) ? FALSE:TRUE;
               break;                    /* Einfügen Modus */
            case 7:
               br  = (atoin(buf)) ? FALSE:TRUE;
               break;                    /* Brief Modus */
            case 8:
               au  = (atoin(buf)) ? FALSE:TRUE;
               break;                    /* Auto-Trenn Modus */
            case 9:
               if((schrift=atoin(buf))<0 || schrift>3) schrift=1;
               break;                    /* Druck Modus */
            case 11:
               if((zg3=atoin(buf))<0) zg3=0;
               break;                    /* linker Rand */
            case 12:
               if((zg4=atoin(buf))<zg3) zg4=zg3+1;
               break;                    /* rechter Rand */
            case 13:
               if((zg5=atoin(buf))>72) zg5=72; else if(zg5<10) zg5=10;
               break;                    /* Papierlänge */
            case 14:
               znum  = (atoin(buf)) ? 4:5;
               break;                    /* Zeilennummerierung */
            case 15:
               snum  = (atoin(buf)) ? FALSE:TRUE;
               break;                    /* Seitennummerierung */
            case 16:
               bak   = (atoin(buf)) ? TRUE:FALSE;
               break;                    /* Backup */
            case 17:
               iconx = atoin(buf);
               break;                    /* Iconify x-Koordinate */
            case 18:
               icony = atoin(buf);
               break;                    /* Iconify y-Koordinate */
            case 22:
               if(strlen(buf)==77) strcpy(tab,buf);
               break;                    /* Tabulator */
         }
         weiter=TRUE; goto hops;
      }
      else durch=TRUE;
   }
   return(TRUE);
}
Laden(fn)      /* fn = Filename */
char *fn;
{
   struct FileHandle *handle;
   register int ln, s1=se, x1=0, z1=ze;
   int trans = KLOTZ-1, zaehler=0, flaggy=FALSE, st=0, txp=FALSE;
   UBYTE *Buf;

   if((ln=strlen(fn))>=4) {     /* File im Briefformat <- `.txp` - Endung */
      if((fn[ln-1]==80||fn[ln-1]==112)&&(fn[ln-2]==120||fn[ln-2]==88)&&
         (fn[ln-3]==84||fn[ln-3]==116)&&fn[ln-4]==46) txp=TRUE;
   }
   if(!br && !txp) { strcat(fn, ".txp"); txp=TRUE; }
   if(!(handle=Open(fn,MODE_OLDFILE)))
   {
      sprintf(buffer, "Can't open %s!", fn); strcpy(str,buffer);
      Meldung();
      return(FALSE);
   }
   if(!(Buf = (UBYTE *)AllocMem(KLOTZ, MEMF_CLEAR))) {
      Close(handle); return(FALSE);
   }
   FOREVER {
      if((ln = Read(handle,Buf,KLOTZ))<KLOTZ) {
         trans = ln-1;
         if(!ln) {           /* EOF */
            Close(handle);
            break;
         }
      }
      zaehler += trans+1;   /* Textlänge mitzählen */
      ln = 0;
lab1: do {
         if((buffer[x1++] = Buf[ln++]) <=9) {
            if(buffer[x1-1]<9) st++;   /* Steuercode im Text */
            else { x1--;       /* TAB     im Text */
               /* if(x1 & 8) { buffer[x1++] = 32; } */
               if(x1<MAX+st) {
                  do {
                     buffer[x1++] = 32;
                  } while((x1 & 15) && x1<MAX+st);
               }
            }
         }
      } while(x1<MAX+st && Buf[ln-1]!=LF && ln<=trans);
      if(Buf[ln-1]==LF || x1==MAX+st || trans<KLOTZ-1) {
         if(Buf[ln-1]==LF) --x1;
         while(x1 && buffer[x1-1] == 32) x1--; /* Rand-Spaces weg damit    */
         buffer[x1] = EOS;           /* LineFeed oder Zeilenende */
         if(x1==MAX+st) {                      /* LineFeed und  Zeilenende */
            if(ln<KLOTZ) { if(Buf[ln]==LF) ln++; }
         }
         if(!(a[s1] [z1] = (UBYTE *)AllocMem(x1+2, MEMF_CLEAR))) {
           flaggy=TRUE; Close(handle); SpeicherMangel();
           break;   /* Out of memory */
         }
         strcpy(a[s1] [z1], buffer);
         a[s1] [z1] [x1+1] = (txp==TRUE) ? st : 0; /* Steuercodes abspei. */
         if(ln>trans && trans<KLOTZ-1) { Close(handle); break; } /* EOF */
         x1=st=0; z1++;
         if(s1==MAS && z1>sei) {
            z1=sei; flaggy=TRUE; Close(handle);
            break;
         }
         if(z1>SEITE) {
            z1=0;
            if(++s1>MAS) {
               s1=MAS; z1=SEITE; flaggy=TRUE; Close(handle);
               break;
            }
         }
         if(ln>trans) continue;  /* Weiter von disk lesen */
         goto lab1;
      }  /* else Weiter von disk lesen */
   }
   FreeMem(Buf, KLOTZ);
   se = s1; ze = z1;
   if(flaggy == TRUE) {
      if(blo)
         sprintf(buffer, "Out of memory! Block-length: %d!", zaehler);
      else
         sprintf(buffer, "Out of memory! Text-length: %d!",zaehler);
   }
   else {
      if(blo)
         sprintf(str, "Length: %d End of block:", zaehler);
      else
         sprintf(buffer, "Length: %d End: page %d line %d!",
            zaehler, se+1, ze+1);
   }
   if(!blo || flaggy) { strcpy(str, buffer); Meldung(); }
   return(TRUE);
}
XPlus()
{
   if((++x)>MAX) {
      x=MIX; Flagge = TRUE+off; off=0;
      YZPlus();
      Flagge=spe=zpe= FALSE;
   }
   else if(x-MAX1==off) {
      off+=OFF1; SText(); meld=FALSE;
   }
}
YZPlus()
{
   int len=0;

   y++;
   if(++z>SEITE) {
      z = 0;
      if(++s>MAS) {
         s=MAS; z=SEITE; y--;
         if(Flagge >= TRUE) x = MAX;
         if(Flagge >  TRUE) off=Flagge-1;
         sprintf(buffer, "%s", FehlerText[2]);
         meld = TRUE;
      }
      if(s>se) {
         s = se; z = ze; y=y-1;
         if(Flagge >= TRUE) x = MAX;
         if(Flagge >  TRUE) off=Flagge-1;
         sprintf(buffer, "%s", FehlerText[1]);
         meld = TRUE;
      }
   }
   if(s==se){
      if(z>ze) {
         z = ze; y-- ;
         if(Flagge >= TRUE) x = MAX;
         if(Flagge >  TRUE) off=Flagge-1;
         sprintf(buffer, "%s", FehlerText[1]);
         meld = TRUE;
      }
   }
   if(Flagge>TRUE && x==MIX) {
      if(y>MAY) y=MAY; Flagge=FALSE; SText(); meld=FALSE;
   }
   if(y>MAY) {
      y = MAY; Hochrollen();
   }
   else if(blo==2) {
      if(BloRel(0)) { y--; if(--z<0) { z=SEITE; s--; } len=1; blo=0; }
      SetAPen(RP, 0); RectFill(RP, 0, y*8-8, RRAND, y*8-1);
      SetAPen(RP, 1);
      Rolling();
      if(len) { y++; blo=2; if(++z>SEITE) { z=0; s++; } }
   }
}
XMinus()
{
   if(--x<MIX) {
      x=MAX;
      if(MAX>=MAX1) off=((MAX-MAX1)/OFF1+1)*OFF1;
      Flagge = TRUE+off;
      YZMinus();
      Flagge=spe=zpe=FALSE;
   }
   else if(x==off) {
      off-=OFF1; SText(); meld=FALSE;
   }
}
YZMinus()
{
   int len=0;

   y--;
   if(--z<0) {
      z = SEITE;
      if(--s<0) {
         s=0; z=0;  y=MIY;
         if(Flagge>=TRUE) { x=MIX; off=0; }
         sprintf(buffer,"%s", FehlerText[0]);
         meld = TRUE;
      }
   }
   if(Flagge>TRUE && x==MAX) {
      if(y<MIY) y=MIY; Flagge=FALSE; SText(); meld=FALSE;
   }
   if(y<MIY) {
      y=MIY;
      Runterrollen();
   }
   else if(blo==2) {
      if(BloRel(0)) { y++; if(++z>SEITE) { z=0; s++; } len=1; blo=0; }
      SetAPen(RP, 0); RectFill(RP, 0, y*8-8, RRAND, y*8-1);
      SetAPen(RP, 1);
      Rolling();
      if(len) { y--; blo=2; if(--z<0) { z=SEITE; s--; } }
   }
}

TitelZeile()
{
   int h, var;

   SetAPen(RP, 1);
   Move(RP, 0, 30);
   Draw(RP, 640, 30);
   for(h = 2; h <= 79; h++) {
      var = (h-1) * 8;
      if(h==10||h==20||h==30||h==40||h==50||h==60||h==70) {
         Move(RP, var, 24);
         Draw(RP, var, 30);
      }
      else {
         if(h==5||h==15||h==25||h==35||h==45||h==55||h==65||h==75) {
            Move(RP, var, 26);
            Draw(RP, var, 30);
         }
         else {
             Move(RP, var, 27);
             Draw(RP, var, 30);
         }
      }
   }
}
Tabulator(ganz,var,yk)
int ganz, var, yk;
{

   if(ganz==TRUE) {
      for(var=0; var<=77; var++) {
         if(tab[var]=='1') {
            Move(RP, (var*8)+1, 25); Draw(RP, (var*8)+5, 25);
            Move(RP, (var*8)+3, 26); Draw(RP, (var*8)+3, 28);
         }
      }
   }
   else {
      var = var/8; if(var<0) var=0; if(var>77) var=77;
      if(yk>30 || ganz==2) {
         yk = yk/8+1; if(yk<MIY) yk=MIY; if(yk>MAY) yk=MAY;
         if(ganz!=2) x=var+off+1;
         if(yk>y) {
            for(ganz=y; ganz<yk; ganz++) YZPlus();
         }
         else if(y>yk) {
            for(ganz=y; ganz>yk; ganz--) YZMinus();
         }
         ZSDisplay(); /* y=yk */
      }
      else {
         if(tab[var]=='1') {
            tab[var]='0';
            SetAPen(RP, 0);
            RectFill(RP, (var*8)+1,25, (var*8)+5, 28);
            SetAPen(RP, 1);
         }
         else {
            tab[var]='1';
            Move(RP, (var*8)+1, 25); Draw(RP, (var*8)+5, 25);
            Move(RP, (var*8)+3, 26); Draw(RP, (var*8)+3, 28);
         }
      }
   }
}

ZSDisplay()
{
   StilAus();
   sprintf(buffer, "PGE %-3d LIN %-3d COL %-3d", s+1, z+1, x);
   Move(RP, OFFSET, 20);
   Text(RP, buffer, strlen(buffer));
   sprintf(buffer, "                                                     ");
   Move(RP, 6, 20);
   Text(RP, buffer, strlen(buffer));
   if(ein==TRUE) ein=FALSE; else ein=TRUE;
   StilAn();
   Einfuegen();
}

Schluss()
{
   register int si, zi;
   int i;

   if(se>=0) {
      for(si=0; si<=se; si++) {
         for(zi=0; zi<=SEITE; zi++) {
            FreeMem(a[si] [zi], SL(si,zi)+2);
            if(si==se && zi==ze) break;
        }
      }
   }
   ReleaseFileSelect();
   if(Fenster->MenuStrip && icfy)  ClearMenuStrip(Fenster, &Menus[0]);
   if(Fenster)                     CloseWindow(Fenster);
   if(Scheibe && icfy)             CloseScreen(Scheibe);
   if(ConsoleDevice)               CloseDevice(&ConsoleMsg);
   if(DosBase)                     CloseLibrary(DosBase);
   if(GfxBase)                     CloseLibrary(GfxBase);
   if(IntuitionBase)               CloseLibrary(IntuitionBase);
}
Oeffnen()
{
   if(!(IntuitionBase=(struct IntuitionBase *)
      OpenLibrary("intuition.library",INTUITION_REV)))
      Und_tschuess("Can't open intuition-library!\n");

   if(!(GfxBase=(struct GfxBase *)
      OpenLibrary("graphics.library",GRAPHICS_REV)))
      Und_tschuess("Can't open graphics-library!\n");

   if(!(DosBase=(struct DosLibrary *) OpenLibrary("dos.library",0)))
      Und_tschuess("Can't open dos-library!\n");

   if(OpenReadConsole() != 0)
      Und_tschuess("Can't open console.device!\n");
   return(TRUE);
}
Und_tschuess(bye)
char *bye;
{
   if(DosBase)       CloseLibrary(DosBase);
   if(GfxBase)       CloseLibrary(GfxBase);
   if(IntuitionBase) CloseLibrary(IntuitionBase);
   printf(bye);
   exit(FALSE);
}