/* 	Giro.c 
	-----------------------
	SourceCode für GiroMan V3.00
	Letzte Änderung am 06.03.1988

*/

#include "Data.h"


/*********************************************************************/

VOID _cli_parse(){}
VOID _wb_parse(){}

/*********************************************************************/

VOID main()
{
VOID Open_Things(),Auswertung();
BOOL Open_Datei(),Load_Index();

Open_Things();
Set_Screen_Title(MAINWIND,WORKTITEL);
if(!(Load_Index() && Open_Datei()))
	{
	Disk_Fehler(MainWindow);
	EndProgramm(99);
	}
Auswertung();
EndProgramm(0);
}

/*********************************************************************/

VOID Open_Things()
{
VOID Make_Graphics();
UCOUNT	i;

if(!(IntuitionBase = (struct IntuitionBase*)
     	OpenLibrary("intuition.library",NULL))) 		EndProgramm(10);
if(!(GfxBase = (struct GfxBase*)
     	OpenLibrary("graphics.library",NULL))) 			EndProgramm(11);

if(AvailMem(MEMF_CHIP)<50000L || AvailMem(MEMF_PUBLIC)<75000L)	EndProgramm(30);
if(!(UndoBuffer=(STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(31);
if(!(TempText = (STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(32);
if(!(TempTextGr=(STRPTR)AllocMem(100L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(33);

for(i=0;i<3;i++)
	{
	if(!(EingabeBuffer[i]=
		(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(34);
	EinGadInfo[i].Buffer=EingabeBuffer[i];
	EinGadInfo[i].UndoBuffer=UndoBuffer;
	}
for(i=0;i<3;i++)
	{
	if(!(SuchBuffer[i]=
		(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(35);
	SuchInfo[i].Buffer=SuchBuffer[i];
	SuchInfo[i].UndoBuffer=UndoBuffer;
	}
for(i=0;i<3;i++)
	{
	if(!(MonatBuffer[i]=
		(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(36);
	MonatInfo[i].Buffer=MonatBuffer[i];
	MonatInfo[i].UndoBuffer=UndoBuffer;
	}
if(!(Window1.Screen = (MainScreen = (struct Screen*) 
     	OpenScreen(&Screen1))))					EndProgramm(12);
if(!(MainWindow = (struct Window*)
	OpenWindow(&Window1)))					EndProgramm(13);

Make_Graphics();
Off_Str_Gadgets();
return;
}

/*********************************************************************/

VOID Make_Graphics()
{
Main_rp= MainWindow->RPort;
Main_vp= &MainScreen->ViewPort;

SetRGB4(Main_vp,GREY,13L,13L,14L);	/* Farbe 0	= hellgrau */	
SetRGB4(Main_vp,BLACK,1L,1L,1L);	/* Farbe 1	= schwarz  */
SetRGB4(Main_vp,RED,12L,1L,0L);		/* Farbe 2	= rot	  */
SetRGB4(Main_vp,BLUE, 0L,0L,9L);	/* Farbe 3	= blau     */

SetAPen(Main_rp,BLUE);
SetBPen(Main_rp,GREY);
SetDrMd(Main_rp,JAM2);

SetMenuStrip(MainWindow,&Menu1);
Menu_Normal(AN);
Menu_Saven(AUS);
PolyDraw(Main_rp,30L,Umrandungen);
return;
}

/*********************************************************************/

BOOL Load_Index()
{
BOOL Ok = FALSE;

if(!(Index=AllocMem(INDEXLENG,MEMF_CLEAR)))	EndProgramm(30);
if((DateiIndex=Open(IndexName,MODE_OLDFILE))
&&(Read(DateiIndex,Index,INDEXLENG) != DISKERROR))
	Ok =TRUE;
if(DateiIndex)
	Close(DateiIndex);
DateiIndex = NULL;
return(Ok);
}

/*********************************************************************/

BOOL Open_Datei()
{
BOOL Ok = FALSE;

if(!(Eintrag=AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR)))	EndProgramm(31);
if((HauptDatei=Open(DateiName,MODE_READWRITE))
&&(Seek(HauptDatei,-8L,OFFSET_END) != DISKERROR)
&&(Read(HauptDatei,&DatenAkt,2L) != DISKERROR)
&&(Read(HauptDatei,&AltSaldo,4L) != DISKERROR)
&&(Read(HauptDatei,&NeuVergeben,2L) !=DISKERROR))
	{
	Ok = TRUE;
	Geaendert = FALSE;
	NeuSaldo = AltSaldo;
	NeuDatenAkt = DatenAkt;
	AktIndex = Index+DATENMAX;
	MaxIndex = AktIndex-19;
	PrintIText(Main_rp,&Ueber[2],0L,0L);
	Print(Main_rp,BetrInAsc(AltSaldo),TAB(AltSaldo),240L,FAR(AltSaldo));
	PrintNeuSaldo();
	PrintUntereSeite();
	}
return(Ok);
}

/*********************************************************************/

VOID Auswertung()
{
VOID	WelchesGadget();
BOOL	Menu();
VOID	Abfrage_Maus();
BOOL	Ende = FALSE;

while (Ende == FALSE)
	{
	IDCMP_Abfrage(MainWindow);
	switch (MessClass)
		{
		case GADGETDOWN:
		case GADGETUP:
			WelchesGadget();
			break;
		
		case MENUPICK:
			Ende = Menu();
			break;

		case MOUSEBUTTONS:
			Abfrage_Maus();
			break;
		}
	}
return; 
}

/*********************************************************************/

VOID WelchesGadget()
{
VOID Move_Slider();

switch (GadID)
	{
	case 1:  
		Move_Slider();
		break;
	case 2:
		PrintNachOben();
		break;
	case 3:
		PrintNachUnten();
		break;
	}
return;
}

/*********************************************************************/

VOID Move_Slider()
{
INDEX	*IN;
INDEX	*min = Index+DATENMAX-NeuDatenAkt;
BOOL	Direkt = (MessClass != GADGETUP) ? TRUE : FALSE;

do
	{
	if(Direkt)
		{
		if((Message=(struct IntuiMessage*)
		    GetMsg(MainWindow->UserPort))!=NULL)
			{	
			MessClass = Message->Class;
			ReplyMsg(Message);
			}
		}
	IN = min+((Slider.VertPot/NeuProp)*20);
	if(IN > MaxIndex)  IN = MaxIndex;
	Setz_VonBis(IN);
	}
while(MessClass != GADGETUP);

if(IN != AktIndex)
	{
	if(IN > AktIndex)
		{
		if(Direkt) AktIndex = IN-20;
		PrintNachUnten();
		}
	else
		{
		if(Direkt) AktIndex = IN+20;
		PrintNachOben();
		}
	}	
return;
}

/*********************************************************************/

BOOL Menu()
{
VOID	Hinzu_Fuegen();
VOID	Aendere_Eintrag();
VOID	Loesche_Eintrag();
VOID	Suchen();
VOID	Neue_Datei();
VOID	Neues_Saldo();
VOID	Finde_Datum();
VOID	Saldo_Suchen();
VOID	Drucken();
VOID	Monats_Daten();
VOID	Monat_Hinzu();
BOOL	Save_All();

BOOL Ende=FALSE;

if(MENUNUM(MessCode) != MENUNULL)
	switch(MENUNUM(MessCode))
		{
		case 0:					/* PROGRAMM */
		switch(ITEMNUM(MessCode))
			{
			case 0:				/* Beenden */
			if(Geaendert)
				{
				if(Abfr_ReqGr(MainWindow,&ReqText[2],
							&ReqGad2,NULL))
					if(!(Ende = Save_All()))
						Disk_Fehler(MainWindow);
				}
			else
				{
				Ende = TRUE;
				}
			break;

			case 1:
			Abfr_ReqGr(MainWindow,&ReqText[30],&ReqGad1,NULL);
			break;
			}
		break;
		
		case 1:					/* GIRODATEN */
		switch(ITEMNUM(MessCode))
			{
			case 0:
			Hinzu_Fuegen();
			break;
			
			case 1:
			Suchen();
			break;

			case 2:
			if(!(Save_All()))
				Disk_Fehler(MainWindow);
			break;
			}
		break;		
		
		case 2:					/* EDITIEREN */
		switch (ITEMNUM(MessCode))
			{
			case 0:
			Drucken();
			break;

			case 1:
			Saldo_Suchen();
			break;

			case 2:
			Aendere_Eintrag();
			break;
			
			case 3:
			Loesche_Eintrag();
			break;
			}
		break;
		
		case 3:					/* Anzeige */
		switch (ITEMNUM(MessCode))
			{
			case 0:
			if(AktIndex != (Index+DATENMAX-NeuDatenAkt))
				{
				AktIndex = Index + 20;
				PrintNachOben();
				}
			else	Beep(MainScreen);
			break;
			
			case 1:
			if(AktIndex != MaxIndex)
				{
				AktIndex = MaxIndex - 1;
				PrintNachUnten();
				}
			else	Beep(MainScreen);
			break;

			case 2:
			if(Abfr_ReqGr(MainWindow,&ReqText[6],
				&SuchGadget[0],&SuchGadget[0]))
				{
				Finde_Datum(SuchBuffer[0]);
				AktIndex -= 20;
				PrintNachUnten();
				}
			break;
			}
		break;

		case 4:
		switch (ITEMNUM(MessCode))
			{
			case 0:
			Neue_Datei();
			break;

			case 1:
			Neues_Saldo();
			break;
			}
		break;

		case 5:					/* MONATSDATEN */
		switch (ITEMNUM(MessCode))
			{
			case 0:
			Monat_Hinzu();
			break;

			case 1:
			Monats_Daten();
			break;
			}
		break;
		}
return(Ende);
}

/*********************************************************************/

VOID Abfrage_Maus()
{
SHORT Aktiviere_Zeile();

if(MessCode != SELECTUP)
	if(!(MainWindow->MouseY > 212
	  || MainWindow->MouseY < 33
	  || MainWindow->MouseX > 610))
		AktiveZeile = Aktiviere_Zeile((MainWindow->MouseY-33)/9);
return;
}

/*********************************************************************/

VOID IDCMP_Abfrage(Window)
struct Window *Window;
{
struct Gadget *Gadget;

GadID = 0;
Wait(1L<<Window->UserPort->mp_SigBit);
while((Message = (struct IntuiMessage*)
	GetMsg(Window->UserPort)) != NULL)
	{
	MessClass	= Message->Class;
	MessCode 	= Message->Code;
	if((MessClass == GADGETUP) || (MessClass == GADGETDOWN))
		{
		Gadget	= (struct Gadget*) Message->IAddress;
		GadID	= Gadget->GadgetID;
		}

	ReplyMsg(Message);
	}
return;
}

/*********************************************************************/

VOID Hinzu_Fuegen()
{
VOID	Loesch_Str_Gadgets();
BOOL	Abfrage_EingabeSchluss(); 
BOOL	EingabeSchluss = FALSE;
USHORT  No = NeuDatenAkt;

On_Str_Gadgets();
ActivateGadget(&EingabeGadget[0],MainWindow,NULL);

while(EingabeSchluss == FALSE)
	{
	if(NeuDatenAkt < DATENMAX)
		{
		IDCMP_Abfrage(MainWindow);

		if(MessClass == GADGETUP)
			{
			switch(GadID)
				{
				case 10:
				EingabeSchluss = Abfrage_EingabeSchluss(0);
				break;

				case 11:
				EingabeSchluss = Abfrage_EingabeSchluss(1);
				break;

				case 12:
				EingabeSchluss = Abfrage_EingabeSchluss(2);
				break;
				}
			}
		}
	else
		{
		Abfr_ReqGr(MainWindow,&ReqText[5],&ReqGad1,NULL);
		EingabeSchluss = TRUE;
		}
	}
Loesch_Str_Gadgets();
Off_Str_Gadgets();
if(No != NeuDatenAkt)
	{
	Menu_Saven(AN);
	Print_And_Sort();
	}
return;
}

/*********************************************************************/

VOID Suchen()
{
VOID	Zeichne_Border();
INDEX  *IN = AktIndex;
BOOL	StopSuche = FALSE;
BOOL	Gefunden = FALSE;
BOOL	Printed;
UCOUNT	jr,ir;
USHORT	Laenge;
STRPTR	Help;

if((!(Abfr_ReqGr(MainWindow,NULL,&SuchGadget[1],&SuchGadget[0])))
||(*(SuchBuffer[1]) == '\0'))
	return;
Laenge = strlen(SuchBuffer[1]);
Finde_Datum(SuchBuffer[0]);
AktIndex -= 20;

do
	{
	if((AktIndex += 20) > MaxIndex)  AktIndex = MaxIndex;
	Set_Screen_Title(MAINWIND,WORKTITEL);
	Lade_Seite(AktIndex);
	Printed = FALSE;
	for(jr=0;(jr<20) && (StopSuche==FALSE);jr++)
		{
		Help=(STRPTR)(Eintrag+jr);
		for(ir=0;ir<34-Laenge;ir++)
			{
			if(!(strncmp((Help+ir),SuchBuffer[1],Laenge)))
				{
				if(Printed == FALSE)
					{
					Printed = TRUE;
					IN = AktIndex;
					Print_Seite();
					}
				Zeichne_Border(jr,(UBYTE)RED);
				Set_Screen_Title(MAINWIND,MAINTITEL);
				if(Gefunden == FALSE)
					{
					Gefunden = TRUE;
					Request(&RequesterKl,MainWindow);
					}
				do
					IDCMP_Abfrage(MainWindow);
				while(GadID != 20 && GadID != 21);
				StopSuche = (GadID == 21) ? TRUE : FALSE;
				Zeichne_Border(jr,(UBYTE)GREY);
				break;
				}
			}
		}
	}
while((MaxIndex>AktIndex) && (StopSuche==FALSE));
if(Gefunden == TRUE) EndRequest(&RequesterKl,MainWindow);
Set_Screen_Title(MAINWIND,MAINTITEL);
Beep(MainScreen);
AktIndex = IN;
return;
}

/*********************************************************************/

VOID Drucken()
{
SHORT		Aktiviere_Zeile();
INDEX		*AbIn = AktIndex+AktiveZeile;
INDEX		*BisIn;
INDEX		*MaxIn = MaxIndex+19;
INDEX		*Lauf;
ULONG		BisDatum;
USHORT		ZeilenMax;
USHORT		ZeilenAkt;
FLOAT		Gesamt = NeuSaldo;
FLOAT		Einzel;
DruckerIO	*DruckIO;

Aktiviere_Zeile(AktiveZeile);
if(Abfr_ReqGr(MainWindow,NULL,&FanfoGad,&BisDatGadget))
    {
    Set_Screen_Title(MAINWIND,WORKTITEL);
    BisDatum = DatInLong(SuchBuffer[0]);
    if((BisDatum < MINDATUM)
    || (BisDatum > MAXDATUM)
    || (BisDatum <= AbIn->Datum)
    || ((MaxIndex+19)->Datum == BisDatum))
	BisIn = MaxIn;
    else
	for(BisIn=AbIn;BisIn->Datum <= BisDatum;BisIn++);

    for(Lauf=AktIndex+AktiveZeile;Lauf<=MaxIn;++Lauf)
	{
	if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
	OFFSET_BEGINNING) != DISKERROR)
	&& (Read(HauptDatei,&Einzel,4L) != DISKERROR))
	    Gesamt-=Einzel;
	else
	    {
	    Gesamt = 0.0;
	    break;
	    }
	}

    if(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL))
	{
	if((DruckIO = DruckerOnOff(ON)) != NULL)
	    {
	    DruckString(DruckIO,(STRPTR)"\0");
	    DruckCom(DruckIO,aSLRM,5L,75L,0L,0L);
	    if(DraftGad.Flags & SELECTED)
		DruckCom(DruckIO,aDEN2,0L,0L,0L,0L);
	    DruckString(DruckIO,DruckUber);
	    ZeilenMax=(FanfoGad.Flags & SELECTED) ? EINZELSIZE : ENDLOSSIZE;
	    for(ZeilenAkt=4; AbIn<=BisIn ;AbIn++,ZeilenAkt++)
		{
		if(!((Seek(HauptDatei,(SIZEEINTRAG*AbIn->Nummer),
		               OFFSET_BEGINNING) != DISKERROR)
		&& (Read(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
		&& (Read(HauptDatei,&Einzel,4L) != DISKERROR)))
		    {
		    Disk_Fehler(MainWindow);
		    break;
		    }
		Gesamt+=Einzel;
		sprintf(TempTextGr,"%s    %-33s    %9.2f    %9.2f\n",
		     DatInAsc(AbIn->Datum),EingabeBuffer[1],Einzel,Gesamt);
		DruckString(DruckIO,TempTextGr);
		if(ZeilenAkt == ZeilenMax)
		    {
		    if(ZeilenMax == EINZELSIZE)
			if(!(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL)))
			    break;
		    DruckString(DruckIO,DruckUber);
		    ZeilenAkt = 3;
		    }
		}
	    DruckString(DruckIO,(STRPTR)"\f");
	    DruckCom(DruckIO,aRIN,0L,0L,0L,0L);
	    DruckerOnOff(OFF);
	    }
        else
            {
	    Abfr_ReqGr(MainWindow,&ReqText[19],&ReqGad1,NULL);
            }
	}
    Set_Screen_Title(MAINWIND,MAINTITEL);
    }
return;
}

/*********************************************************************/

VOID Saldo_Suchen()
{
SHORT	Aktiviere_Zeile();
BOOL	Ok = TRUE;
INDEX	*MaxIn = MaxIndex+19;
INDEX	*Lauf;
FLOAT	Gesamt = NeuSaldo;
FLOAT	Einzel;

Set_Screen_Title(MAINWIND,WORKTITEL);
for(Lauf=AktIndex+AktiveZeile+1;Lauf<=MaxIn;++Lauf)
		{
	if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
	OFFSET_BEGINNING) != DISKERROR)
	&& (Read(HauptDatei,&Einzel,4L) != DISKERROR))
		{
		Gesamt-=Einzel;
		}
	else
		{
		Ok = FALSE;
		break;
		}
	}
Set_Screen_Title(MAINWIND,MAINTITEL);
if(Ok)
	{
	sprintf(TempText,"%.2f DM.",Gesamt);
	ReqText[16].LeftEdge = (390-(strlen(TempText)*8))/2;
	ReqText[16].IText    = TempText;
	Abfr_ReqGr(MainWindow,&ReqText[16],&ReqGad1,NULL);
	}
else
	{
	Disk_Fehler(MainWindow);
	}
Aktiviere_Zeile(AktiveZeile);
return;
}

/*********************************************************************/

VOID Aendere_Eintrag()
{
VOID 	EingabeDaten_Auswertung();
VOID 	Loesch_Str_Gadgets();
SHORT	Aktiviere_Zeile();
FLOAT	saldo;

On_Str_Gadgets();
strcpy(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum));
strcpy(EingabeBuffer[1],Eintrag+AktiveZeile);
strcpy(EingabeBuffer[2],BetrInAsc((Eintrag+AktiveZeile)->Betrag));
NeuSaldo -= (saldo = (Eintrag+AktiveZeile)->Betrag);
RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
ActivateGadget(EingabeGadget,MainWindow,NULL);

while(!((MessClass == GADGETUP) && (GadID == 12)))
	{
	IDCMP_Abfrage(MainWindow);
	if((GadID == 10) || (GadID == 11))
		ActivateGadget(&EingabeGadget[GadID-9],MainWindow,NULL);
	}

Off_Str_Gadgets();
Aktiviere_Zeile(AktiveZeile);

if(strcmp(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum))
||(strcmp(EingabeBuffer[1],Eintrag+AktiveZeile))
||(strcmp(EingabeBuffer[2],BetrInAsc(saldo))))
	{
	EingabeDaten_Auswertung(AktIndex+AktiveZeile,0);
	Menu_Saven(AN);
	Print_And_Sort();
	}
else
	{
	NeuSaldo += saldo;
	Beep(MainScreen);
	Loesch_Str_Gadgets();
	}
return;
}

/*********************************************************************/

VOID Loesche_Eintrag()
{
if(NeuDatenAkt >20)
	{
	if(Abfr_ReqGr(MainWindow,&ReqText[3],&ReqGad2,NULL))
		{
		(AktIndex+AktiveZeile)->Datum = 1L;
		NeuSaldo -= (Eintrag+AktiveZeile)->Betrag;
		--NeuDatenAkt;
		Aktiviere_Zeile(AktiveZeile);
		PrintNeuSaldo();
		Print_And_Sort();
		Menu_Saven(AN);
		Geaendert = TRUE;
		}
	}
else
	{
	Beep(MainScreen);
	}
return;
}

/*********************************************************************/

VOID Neue_Datei()
{
BOOL			Open_Datei();
BOOL			Load_Index();
BOOL			Ok = FALSE;
INDEX			*IND = NULL;
EINTRAG			*EIN = NULL;
STRPTR			TempInText = NULL;
STRPTR			TempDaText = NULL;
UCOUNT			ir;
USHORT 			Minimum = 19;
USHORT			AbIndex = DATENMAX-Minimum;
static TEXT		HaAlt[] = "HaDat";
static TEXT		InAlt[] = "InDat";
struct FileHandle 	*IndexTemp = NULL;
struct FileHandle	*DateiTemp = NULL;

if(!(Abfr_ReqGr(MainWindow,&ReqText[10],&ReqGad2,NULL)))
	return;
while(Geaendert == TRUE)
	{
	if(!(Save_All()))
		{
	        Disk_Fehler(MainWindow);
		if(!(Abfr_ReqGr(MainWindow,&ReqText[11],&ReqGad2,NULL)))
			return;
		}
	}

if(!((IND=(INDEX*)AllocMem(INDEXLENG,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(EIN=(EINTRAG*)AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(TempInText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(TempDaText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR))))
	{
	if(IND)
		FreeMem(IND,INDEXLENG);
	if(EIN)
		FreeMem(EIN,SIZEEINTRAG*20);
	if(TempInText)
		FreeMem(TempInText,30L);
	Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
	return;
	}

if(AktIndex != MaxIndex)  PrintUntereSeite();
Set_Screen_Title(MAINWIND,WORKTITEL);
for(ir=0;ir<20;ir++,AbIndex++)
	{
	(IND+AbIndex)->Datum  = (Index+AbIndex)->Datum;
	(IND+AbIndex)->Nummer = ir;
	strcpy((EIN+ir),(Eintrag+ir));
	(EIN+ir)->Betrag = (Eintrag+ir)->Betrag;
	}

sprintf(TempInText,"%s-%s",IndexName,Datum());
sprintf(TempDaText,"%s-%s",DateiName,Datum());

if((IndexTemp=Open(TempInText,MODE_NEWFILE))
&&(Write(IndexTemp,IND,INDEXLENG) != DISKERROR))
	{
	Close(IndexTemp);
	if((DateiTemp=Open(TempDaText,MODE_NEWFILE))
	&&(Write(DateiTemp,EIN,(LONG)SIZEEINTRAG*20) != DISKERROR)
	&&(Write(DateiTemp,&Minimum,2L) != DISKERROR)
	&&(Write(DateiTemp,&NeuSaldo,4L) != DISKERROR)
	&&(Write(DateiTemp,&Minimum,2L) != DISKERROR))
		{
		Close(DateiTemp);
		Close(HauptDatei);
		HauptDatei=NULL;
		if((Rename(DateiName,HaAlt))
		&&(Rename(IndexName,InAlt))
		&&(Rename(TempDaText,DateiName))
		&&(Rename(TempInText,IndexName))
		&&(Rename(HaAlt,TempDaText))
		&&(Rename(InAlt,TempInText))
		&&(SetProtection(TempDaText,5L))
		&&(SetProtection(TempInText,5L)))
			Ok = TRUE;
		}
	}
if(!(Ok))
	{
	if(HauptDatei)
		Close(HauptDatei);
	if(IndexTemp)
		Close(IndexTemp);
	if(DateiTemp)
		Close(DateiTemp);
	HauptDatei=NULL;
	Disk_Fehler(MainWindow);
	}
FreeMem(IND,INDEXLENG);
FreeMem(Index,INDEXLENG);
FreeMem(EIN,SIZEEINTRAG*20);
FreeMem(Eintrag,SIZEEINTRAG*20);
FreeMem(TempInText,30L);
FreeMem(TempDaText,30L);
if(!(Load_Index() && Open_Datei()))
	Disk_Fehler(MainWindow);
return;
}

/*********************************************************************/

VOID Neues_Saldo()
{
FLOAT saldo;

if((Abfr_ReqGr(MainWindow,&ReqText[14],&NeuSalGad,&NeuSalGad))
&&(*(SuchBuffer[2]) != '\0')
&&((saldo = (FLOAT)atof(SuchBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT)) 
	{
	NeuSaldo = saldo;
	PrintNeuSaldo();
	}
return;
}

/*********************************************************************/

VOID Monats_Daten()
{
VOID	End_Monat();
VOID	Mon_Auswert();
VOID	Print_Monat();
BOOL	Open_MonGraphs();
BOOL	Open_MonatDat();


if(Open_MonGraphs())
	if(Open_MonatDat())
		{
		Print_Monat(AktMonat);
		Mon_Auswert();
		}
End_Monat();
return;
}

/*********************************************************************/

VOID Monat_Hinzu()
{
VOID EingabeDaten_Auswertung();
LONG	Mon;
UCOUNT	i = 0;
struct FileHandle *MonatDatei = (struct FileHandle *) NULL;

*(SuchBuffer[0]) = '\0';
if(!(Monat = (MONAT *)AllocMem(MONATLENG,MEMF_CLEAR|MEMF_PUBLIC)))
    Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
else
    {
    if(Abfr_ReqGr(MainWindow,&ReqText[25],&SuchGadget[0],&SuchGadget[0]))
	{
	Set_Screen_Title(MAINWIND,WORKTITEL);
	if((Mon = atol(SuchBuffer[0]+3)) < 1L || Mon > 12L)
	    Mon = atol(Datum()+3);
	if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
	&&(Seek(MonatDatei,(Mon-1L)*MONATLENG,OFFSET_BEGINNING) != DISKERROR)
	&&(Read(MonatDatei,Monat,MONATLENG) != DISKERROR)))
	    Disk_Fehler(MainWindow);
	else
	    {
	    while((*((Monat+i)->Bezeichnung) != '\0') && (i < MONEINT))
		{
		strcpy(EingabeBuffer[0],SuchBuffer[0]);
		strcpy(EingabeBuffer[1],(Monat+i)->Bezeichnung);
		strcpy(EingabeBuffer[2],BetrInAsc((Monat+i)->Betrag));
		EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
		i++;
		}
	    Menu_Saven(AN);
	    Print_And_Sort();
	    }
	if(MonatDatei)
	    Close(MonatDatei);
	FreeMem(Monat,MONATLENG);
	Set_Screen_Title(MAINWIND,MAINTITEL);
	*(SuchBuffer[0]) = '\0';
	}
    }
return;
}

/*********************************************************************/
/*********************************************************************/

BOOL Save_All()
{
BOOL Ok=FALSE;

Set_Screen_Title(MAINWIND,WORKTITEL);
if((DateiIndex=Open(IndexName,MODE_NEWFILE))
&&(Write(DateiIndex,Index,INDEXLENG) != DISKERROR)
&&(Seek(HauptDatei,NULL,OFFSET_END) != DISKERROR)
&&(Write(HauptDatei,(USHORT*)&NeuDatenAkt,2L) != DISKERROR)
&&(Write(HauptDatei,(FLOAT*)&NeuSaldo,4L) != DISKERROR)
&&(Write(HauptDatei,(USHORT*)&NeuVergeben,2L) != DISKERROR))
	{
	Menu_Saven(AUS);
	Geaendert = FALSE;
	DatenAkt = NeuDatenAkt;
	Ok=TRUE;
	}
if(DateiIndex)
	Close(DateiIndex);
DateiIndex = NULL;
Set_Screen_Title(MAINWIND,MAINTITEL);
return(Ok);
}

/*********************************************************************/

BOOL Abfr_ReqGr(Window,ReqText,ReqGadget,ActGadget)
struct Window    *Window;
struct IntuiText *ReqText;
struct Gadget	 *ReqGadget;
struct Gadget	 *ActGadget;
{
BOOL AbfrSchluss;
BOOL Erfolg;

RequesterGr.ReqGadget = ReqGadget;
RequesterGr.ReqText   = ReqText;

if(Request(&RequesterGr,Window))
	{
	Delay(5L);
	AbfrSchluss = Erfolg = FALSE;
	if(ActGadget)
		ActivateGadget(ActGadget,Window,&RequesterGr);
	do
		{
		IDCMP_Abfrage(Window);
		switch(GadID)
			{
			case 13:
			if(ReqGadget==&SuchGadget[1])
				{
				ActivateGadget(ReqGadget,
				Window,&RequesterGr);
				break;
				}
			AbfrSchluss = Erfolg = TRUE;
			break;

			case 14:
			case 15:
			case 20:
			case 39:
			AbfrSchluss = Erfolg = TRUE;
			break;

			case 21:
			AbfrSchluss = TRUE;
			break;

			case 37:
			if(ReqGadget == &MonStrGad[2])
				ActivateGadget(&MonStrGad[1],
				Window,&RequesterGr);
			break;

			case 38:
			ActivateGadget(&MonStrGad[2],Window,&RequesterGr);
			break;
			}
		}
	while(AbfrSchluss == FALSE);
	EndRequest(&RequesterGr,Window);
	}
return(Erfolg);
}

/*********************************************************************/

BOOL Abfrage_EingabeSchluss(Nummer)
USHORT Nummer;
{
VOID	EingabeDaten_Auswertung();
BOOL 	EingabeSchluss;

EingabeSchluss = *(EingabeBuffer[Nummer]) == '\0' ? TRUE : FALSE;
if(++Nummer >2 && EingabeSchluss == FALSE)
	{
	Nummer = 0;
	EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
	Loesch_Str_Gadgets();
	}
if(EingabeSchluss == FALSE)
	ActivateGadget(&EingabeGadget[Nummer],MainWindow,NULL);
return(EingabeSchluss);
}

/*********************************************************************/

VOID EingabeDaten_Auswertung(Frei,VonWo)
INDEX *Frei;
USHORT VonWo;
{
VOID   Loesch_Str_Gadgets();

static ULONG  Dat;
static FLOAT  Bet;

Set_Screen_Title(MAINWIND,WORKTITEL);
Dat = DatInLong(EingabeBuffer[0]);			/* Datum umrechnen */
if(Dat < MINDATUM || Dat > MAXDATUM)
	Dat = DatInLong(Datum());
Bet=(FLOAT)atof(EingabeBuffer[2]);			/* Betrag umrechn. */
if(Bet > MAXFLOAT || Bet < MINFLOAT)
	Bet = 0.0; 
NeuSaldo += Bet;

if(VonWo)
	{
	ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L);	/* Ausgabe in Wind */
	PrintEintrag(Dat,EingabeBuffer[1],Bet,yUnt);
	if(Frei->Datum != 1L)				/* noch nie belegt */
		Frei->Nummer = ++NeuVergeben;
	} /* von der normalen Eingaberoutine */

Frei->Datum = Dat;					/* Vorbereitung */

if
(!((Seek(HauptDatei,SIZEEINTRAG*(Frei->Nummer),OFFSET_BEGINNING) != DISKERROR)
&&(Write(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
&&(Write(HauptDatei,&Bet,4L) != DISKERROR)))
	Disk_Fehler(MainWindow);
PrintNeuSaldo();
Geaendert = TRUE;
Loesch_Str_Gadgets();
Set_Screen_Title(MAINWIND,MAINTITEL);
return;
}

/*********************************************************************/

SHORT Aktiviere_Zeile(Zeile)
SHORT(Zeile);
{
VOID	Zeichne_Border();
static	SHORT BufferZeile = -1;
UCOUNT	i;

if(BufferZeile < 0)
	{
	BufferZeile = Zeile;
	Menu_Normal(AUS);
	for(i=0;i<3;i++)
		OffGadget(&ScrollGadget[i],MainWindow,NULL);
	Zeichne_Border(Zeile,(UBYTE)RED);
	}
else
	{
	if(Zeile == BufferZeile)
		{
		BufferZeile = -1;
		Menu_Normal(AN);
		for(i=0;i<3;i++)
			OnGadget(&ScrollGadget[i],MainWindow,NULL);
		Zeichne_Border(Zeile,(UBYTE)GREY);
		}
	}
return(BufferZeile);
}

/*********************************************************************/

VOID Zeichne_Border(Zeile,Farbe)
USHORT Zeile;
UBYTE  Farbe;
{
WahlBorder.FrontPen = Farbe;
DrawBorder(Main_rp,&WahlBorder,8L,(LONG)(31+(Zeile*9)));
return;
}

/*********************************************************************/

VOID Off_Str_Gadgets()
{
register UCOUNT ir;

for(ir=0;ir<3;ir++)
	OffGadget(&EingabeGadget[ir],MainWindow,NULL);
return;
}

/*********************************************************************/

VOID On_Str_Gadgets()
{
register UCOUNT ir;

for(ir=0;ir<3;ir++)
	OnGadget(&EingabeGadget[ir],MainWindow,NULL);
LoeschFeld(Main_rp, 12L,225L,9);
LoeschFeld(Main_rp,108L,225L,34);
return;
}

/*********************************************************************/

VOID Loesch_Str_Gadgets()
{
*EingabeBuffer[0]=*EingabeBuffer[1]=*EingabeBuffer[2]='\0';
RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
return;
}

/*********************************************************************/

VOID Disk_Fehler(Window)
struct Window *Window;
{
USHORT DiskFehler = (USHORT)IoErr();
struct IntuiText *Help;

sprintf(TempText,"IoError Nr. %03u ",DiskFehler);
ReqText[7].IText = TempText;
Help = (Geaendert) ? &ReqText[9] : &ReqText[8];
if(!(Abfr_ReqGr(Window,Help,&ReqGad2,NULL)))
	if((Geaendert) && (Window == MainWindow))
		if(!(Abfr_ReqGr(Window,&ReqText[1],&ReqGad2,NULL)))
			EndProgramm(DiskFehler);
return;
}

/*********************************************************************/

VOID PrintNachUnten()
{
register i;

if(AktIndex != MaxIndex)
	{
	Set_Screen_Title(MAINWIND,WORKTITEL);
	AktIndex+=20;
	if(AktIndex > MaxIndex)	AktIndex=MaxIndex;
	Lade_Seite(AktIndex);
	for(i=0;i<20;i++)
  		{
		ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L);
		PrintEintrag
		((AktIndex+i)->Datum,
		(Eintrag+i)->Bezeichnung,
		(Eintrag+i)->Betrag,
		yUnt);
		}
	Set_Screen_Title(MAINWIND,MAINTITEL);
	}
else	Beep(MainScreen);
return;
}

/*********************************************************************/

VOID PrintNachOben()
{
register i;
INDEX *min = Index+DATENMAX-NeuDatenAkt;

if (AktIndex != min)
	{
	Set_Screen_Title(MAINWIND,WORKTITEL);
	AktIndex-=20;
	if(AktIndex < min)	AktIndex=min;
	Lade_Seite(AktIndex);
	for(i=19;i>-1;i--)
		{
		ScrollRaster(Main_rp,0L,-9L,10L,31L,610L,210L);
		PrintEintrag 
		((AktIndex+i)->Datum,
		(Eintrag+i)->Bezeichnung,
		(Eintrag+i)->Betrag,
		yOben);
		}
	Set_Screen_Title(MAINWIND,MAINTITEL);
	}
else	Beep(MainScreen);
return;
}

/*********************************************************************/

VOID PrintUntereSeite()
{
AktIndex=Index+DATENMAX;
PrintNachUnten();
return;
}

/*********************************************************************/

VOID Print_And_Sort()
{
UCOUNT Zaehler;

Set_Screen_Title(MAINWIND,WORKTITEL);
Sort_Index();
if(++AktIndex > MaxIndex)
	--AktIndex;
Lade_Seite(AktIndex);
Print_Seite();
Set_Screen_Title(MAINWIND,MAINTITEL);
return;
}

/*********************************************************************/

VOID Print_Seite()
{
REGISTER UCOUNT Zaehler;

for(Zaehler=0;Zaehler<20;Zaehler++)
	{
	LoeschFeld(Main_rp,xDatum,yOben+(Zaehler*9),75);
	PrintEintrag((AktIndex+Zaehler)->Datum,
		(Eintrag+Zaehler)->Bezeichnung,
		(Eintrag+Zaehler)->Betrag,yOben+(Zaehler*9));
	}
return;
}

/*********************************************************************/

VOID PrintNeuSaldo()
{
LoeschFeld(Main_rp,xPlus,248L,25);
Print(Main_rp,BetrInAsc(NeuSaldo),TAB(NeuSaldo),248L,FAR(NeuSaldo));
return;
}

/*********************************************************************/

VOID PrintEintrag(dat,bez,bet,pos)
long		dat;
STRPTR		bez;
float		bet;
long		pos;
{
Print(Main_rp,DatInAsc(dat),xDatum,pos,BLUE);
Print(Main_rp,bez,xBez,pos,BLUE);
Print(Main_rp,BetrInAsc(bet),TAB(bet),pos,FAR(bet));
return;
}

/*********************************************************************/

VOID Print(rp,text,x,y,far)
struct RastPort *rp;
STRPTR text;
long x,y,far;
{
SetAPen(rp,far);
Move(rp,x,y);
Text(rp,text,(LONG)strlen(text));
return;
}

/*********************************************************************/

VOID LoeschFeld(rp,x,y,len)
struct Rastport *rp;
ULONG x,y;
USHORT len;
{
SetAPen(rp,GREY);
RectFill(rp,x,y-6,x+(8*len),y+2);
return;
}

/*********************************************************************/

ULONG DatInLong(DatAsc)
STRPTR DatAsc;
{
STRPTR p;
ULONG DatLong = 0;
ULONG Mal = 10000L;

p=DatAsc+6;

while(p>=DatAsc)
	{
	DatLong+=(Mal*atol(p));
	p-=3;
	Mal/=100;
	}
return(DatLong);
}

/*********************************************************************/

STRPTR DatInAsc(DatLong)
ULONG DatLong;
{
ULONG a=10000L;
ULONG b=100L;
ULONG c[3];

c[0]=DatLong/a;
c[1]=(DatLong-(c[0]*a))/b;
c[2]=DatLong-(c[0]*a)-(c[1]*b);
sprintf(TempText,"%02lu.%02lu.%02lu",c[2],c[1],c[0]);
return(TempText);
}

/*********************************************************************/

VOID Finde_Datum(AscDatum)
STRPTR AscDatum;
{
ULONG Datum = DatInLong(AscDatum);

if(Datum < MINDATUM)	Datum = MINDATUM;
if(Datum > MAXDATUM)	Datum = MAXDATUM;
AktIndex = Index;
while(AktIndex->Datum < Datum)
	AktIndex++;
return;
}

/*********************************************************************/

VOID Setz_VonBis(IN)
INDEX *IN;
{
register UCOUNT i;
register USHORT x=155,y=240;

for(i=0;i<2;i++)
	{
	Print(Main_rp,DatInAsc(IN->Datum),(LONG)x,(LONG)y,BLACK);
	y += 8;
	IN += 19;
	}
return;
}

/*********************************************************************/

STRPTR BetrInAsc(Saldo)
float Saldo;
{
sprintf(TempText,"%9.2f",Saldo);
return(TempText);
}

/*********************************************************************/

STRPTR Datum()
{
struct tm *Zeit;
long  Z;

Z    = time(NULL);
Zeit = localtime(&Z);
sprintf(TempText,"%02d.%02d.%02d",Zeit->tm_mday,(Zeit->tm_mon)+1,Zeit->tm_year);
return(TempText);
}

/*********************************************************************/

BOOL Sort_Index()
{
VOID   Sort();

if(!(LG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
	return(FALSE);
if(!(RG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
	{
	FreeMem(LG,500L);
	return(FALSE);
	}
LG[1]=0;
RG[1]=DATENMAX;
Sort();
FreeMem(RG,500L);
FreeMem(LG,500L);
return(TRUE);
}

VOID Sort()
{
VOID swapmem();
static ULONG vg;
static SHORT z,x,y;

z++;

if(LG[z] >= RG[z])
	{
	z--;
	return;
	}

x=LG[z];
y=RG[z];
vg=(Index+((x+y)/2))->Datum;

MARK:
if(x > y)
	{
	RG[z+1]=y;
	LG[z+1]=LG[z];
	Sort();
	LG[z+1]=x;
	RG[z+1]=RG[z];
	Sort();
	z--;
	return;
	}

while ((Index+x)->Datum < vg)	x++;
while ((Index+y)->Datum > vg)	y--;

if(x > y)
	{
	RG[z+1]=y;
	LG[z+1]=LG[z];
	Sort();
	LG[z+1]=x;
	RG[z+1]=RG[z];
	Sort();
	z--;
	return;
	}

swapmem((char*)(Index+y),(char*)(Index+x),6);

x++;
y--;
goto MARK;
}

/*********************************************************************/

VOID Menu_Normal(AnAus)
USHORT AnAus;
{
static USHORT Menus[] = {6,  2, 3, 4, 3, 2, 2};
UCOUNT i;

for(i=1;i<=Menus[0];i++)
	Menu_Schalt(MainWindow,i-1,Menus[i],AnAus);
Menu_Schalt(MainWindow,2,4,(AnAus==AN) ? AUS : AN);
return;
}

/*********************************************************************/

VOID Menu_Saven(AnAus)
USHORT AnAus;
{
Menu_Schalt(MainWindow,1,2,AnAus);
return;
}

/*********************************************************************/

VOID Menu_Schalt(Window,MenuNr,ItemNr,An)
struct Window *Window;
USHORT MenuNr,ItemNr,An;
{
ULONG code = ItemNr*32+MenuNr;

if(An)
	OnMenu(Window,code);
else
	OffMenu(Window,code);
return;
}

/*********************************************************************/

VOID Set_Screen_Title(Wohin,Welchen)
USHORT	Wohin;
USHORT	Welchen;
{
struct Window *Window = (Wohin) ? NebenWindow : MainWindow;
static STRPTR Titel[3]={
(STRPTR)"                 -- GiroMan V3.00 Haupt  © 1987/88  --",
(STRPTR)"                   -- GiroMan V3.00 Monat  © 1988 --",
(STRPTR)"              -- NICHT STÖREN, GIROMAN IST BESCHÄFTIGT --"};

SetWindowTitles(Window,FALSE,Titel[Welchen]);
return;
}

/*********************************************************************/

VOID Beep(Screen)
struct Screen *Screen;
{
int zaehler;
for (zaehler=1;zaehler<250;zaehler++)
	DisplayBeep(Screen);
return;
}

/*********************************************************************/

VOID Lade_Seite(IN)
INDEX *IN;
{
VOID Stell_Prop();
UCOUNT i;

Setz_VonBis(IN);
Stell_Prop();
for(i=0;i<20;i++)
    {
    if(!((Seek(HauptDatei,IN->Nummer*SIZEEINTRAG,OFFSET_BEGINNING) != DISKERROR)
    &&(Read(HauptDatei,Eintrag+i,SIZEEINTRAG) != DISKERROR)))
	{
	Disk_Fehler(MainWindow);
	return;
	break;
	}
    IN++;
    }
return;
}

/*********************************************************************/

VOID Stell_Prop()
{
INDEX	*min = Index+DATENMAX-NeuDatenAkt;
FLOAT	GenauPosi;
ULONG	NeuPosi;

NeuProp = (NeuDatenAkt > 20) ? 0xFFFF/((NeuDatenAkt)/20) : 0;
GenauPosi = ((AktIndex-min)/20.0)+0.999999;
NeuPosi = (ULONG)GenauPosi*NeuProp;
ModifyProp(ScrollGadget,MainWindow,NULL,PROPFLAGS,0L,NeuPosi,0L,(ULONG)NeuProp);
RefreshGadgets(ScrollGadget,MainWindow,NULL);
return;
}

/*********************************************************************/

VOID Mon_Auswert()
{
BOOL Wel_MonGadget();
VOID Mon_MausAbfrage();
BOOL Ende = FALSE;

while(!(Ende))
	{
	IDCMP_Abfrage(NebenWindow);
	switch(MessClass)
		{
		case GADGETUP:
		Ende = Wel_MonGadget();
		break;

		case MOUSEBUTTONS:
		Mon_MausAbfrage();
		break;

		case REFRESHWINDOW:
		Print_Monat(AktMonat);
		break;		
		}
	}
return;
}

/*********************************************************************/

BOOL Wel_MonGadget()
{
VOID Print_Monat();
VOID Eingabe_Monat();
VOID Loesch_Monat();
VOID Aender_Monat();
BOOL Save_MonDat();
BOOL Ende = FALSE;

if(!(MonEinSel))
	{
	switch(GadID)
		{
		case 30:
		if(!(MonGeaendert))
			Ende = TRUE;
		else
			if(Abfr_ReqGr(NebenWindow,&ReqText[21],&ReqGad2,NULL))
				if(Save_MonDat())
					Ende = TRUE;
		break;

		case 31:
		AktMonat = (AktMonat == 11) ? 0 : AktMonat+1;
		Print_Monat(AktMonat);
		break;

		case 32:
		AktMonat = (AktMonat == 0) ? 11 : AktMonat-1;
		Print_Monat(AktMonat);
		break;

		case 33:
		if(MonGeaendert)
			Save_MonDat();
		break;

		case 34:
		Eingabe_Monat();
		break;
		}
	}
else
	{
	switch(GadID)
		{
		case 35:
		Aender_Monat();
		break;

		case 36:
		Loesch_Monat();
		break;
		}
	}
return(Ende);
}

/*********************************************************************/

VOID Eingabe_Monat()
{
SHORT	Sprung;
BOOL	Erfolg;
UCOUNT	i;
UCOUNT	j;
MONAT	**Find_Pointer();
MONAT	**Pointer;
MONAT	*mon;
FLOAT	saldo;

*(MonatBuffer[0]) = *(MonatBuffer[1]) = *(MonatBuffer[2]) = '\0';
if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
&&(*(MonatBuffer[1]) != '\0')
&&(*(MonatBuffer[2]) != '\0')
&&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT))
	{
	Sprung = (SHORT)-(atol(MonatBuffer[0]));
	if((Sprung < 1) || (Sprung == 5) || (Sprung > 6))
		Sprung = 12;
	Pointer = Find_Pointer(Sprung);
	for(i=0;i<(12/Sprung);i++)
		{
		mon = *(Pointer+i);
		Erfolg = FALSE;
		for(j=0;j<MONEINT;j++,mon++)
			{
			if(*((mon)->Bezeichnung) == '\0')
				{
				strcpy((mon)->Bezeichnung,MonatBuffer[1]);
				(mon)->Betrag = saldo;
				Erfolg = TRUE;
				break;
				}
			}
		if(!(Erfolg))
			Abfr_ReqGr(NebenWindow,&ReqText[23],&ReqGad1,NULL);
		}
	MonGeaendert = TRUE;
	}
return;
}

/*********************************************************************/

VOID Aender_Monat()
{
VOID Aktiviere_MonZeile();
MONAT	**Find_Pointer();
MONAT	**Pointer;
MONAT	*mon;
SHORT	Sprung;
SHORT	i;
SHORT	j;
MONAT	*aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);
FLOAT	saldo;

Aktiviere_MonZeile(AktMonZeile);
strcpy(MonatBuffer[0],All);
strcpy(MonatBuffer[1],aktmon->Bezeichnung);
sprintf(MonatBuffer[2],"%9.2f",aktmon->Betrag);
if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
&&(*(MonatBuffer[1]) != '\0')
&&(*(MonatBuffer[2]) != '\0')
&&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT))
	{
	Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
	Pointer = Find_Pointer(Sprung);
	for(i=(Sprung==12)?0:11;i>-1;i--)
		{
		mon = *(Pointer+i);
		for(j=0;j<MONEINT;j++,mon++)
			{
			if(*((mon)->Bezeichnung) == '\0')
				break;
			if((!strcmp((mon)->Bezeichnung,aktmon->Bezeichnung))
			&&((mon)->Betrag == aktmon->Betrag))
				{
				strcpy((mon)->Bezeichnung,MonatBuffer[1]);
				(mon)->Betrag = saldo;
				break;
				}
			}
		}
	MonGeaendert = TRUE;
	}
return;
}

/*********************************************************************/

VOID Loesch_Monat()
{
VOID Aktiviere_MonZeile();
VOID Aktiviere_MonZeile();
MONAT	**Find_Pointer();
MONAT	**Pointer;
MONAT	*mon;
SHORT	Sprung;
SHORT	i;
SHORT	j;
MONAT	*aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);

Aktiviere_MonZeile(AktMonZeile);
strcpy(MonatBuffer[0],All);
if((Abfr_ReqGr(NebenWindow,&ReqText[24],&MonStrGad[0],&MonStrGad[0])))
    {
    Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
    Pointer = Find_Pointer(Sprung);
    for(i=(Sprung==12)?0:11;i>-1;i--)
	{
	mon = *(Pointer+i);
	for(j=0;j<MONEINT;j++)
	    {
	    if((!strcmp((mon+j)->Bezeichnung,aktmon->Bezeichnung))
	    &&((mon+j)->Betrag == aktmon->Betrag))
		{
		*((mon+j)->Bezeichnung) = '\0';
		while((++j < MONEINT) && (*((mon+j)->Bezeichnung) != '\0'))
		    {
		    strcpy((mon+j-1)->Bezeichnung,(mon+j)->Bezeichnung);
		    (mon+j-1)->Betrag = (mon+j)->Betrag;
		    *((mon+j)->Bezeichnung) = '\0';
		    }
		}
	    }
	}
    MonGeaendert = TRUE;
    }
return;
}

/*********************************************************************/

BOOL Save_MonDat()
{
BOOL Ok = FALSE;
struct FileHandle *MonatDatei;

Set_Screen_Title(MONAWIND,WORKTITEL);
if(!((MonatDatei = Open(MonatName,MODE_NEWFILE))
&&(Write(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
	Disk_Fehler(NebenWindow);
else
	{
	MonGeaendert = FALSE;
	Ok = TRUE;
	}
if(MonatDatei)
	Close(MonatDatei);
Set_Screen_Title(MONAWIND,MONATITEL);
return(Ok);
}

/*********************************************************************/

VOID Mon_MausAbfrage()
{
VOID Aktiviere_MonZeile();

if(MessCode != SELECTUP)
	if(!(NebenWindow->MouseX < 11
	||   NebenWindow->MouseX > 503
	||   NebenWindow->MouseY < 35
	||   NebenWindow->MouseY > 34+(AnzMonEin*9)))
		Aktiviere_MonZeile((NebenWindow->MouseY-35)/9);
return;
}

/*********************************************************************/

VOID Aktiviere_MonZeile(TempZeile)
SHORT TempZeile;
{
if(!(MonEinSel))
	{
	AktMonZeile = ((NebenWindow->MouseY)-35)/9;
	MonEinSel = TRUE;
	}
else
	{
	if(AktMonZeile == TempZeile)
		MonEinSel = FALSE;
	}
MonWahlBor.FrontPen = (MonEinSel) ? (UBYTE)RED : (UBYTE)GREY;
DrawBorder(Neben_rp,&MonWahlBor,9L,(LONG)33+(AktMonZeile*9));
return;
}

/*********************************************************************/

BOOL Open_MonGraphs()
{
BOOL Ok;

Window2.Screen = MainScreen;
if((Monat = (MONAT *) AllocMem(JAHRLENG,MEMF_PUBLIC|MEMF_CLEAR))
&&(NebenWindow = (struct Window*) OpenWindow(&Window2)))
	{
	Ok = TRUE;
	Set_Screen_Title(MONAWIND,MONATITEL);
	Neben_rp = NebenWindow->RPort;
	PolyDraw(Neben_rp,16L,RandNWind);
	PrintIText(Neben_rp,&UeberN,0L,0L);
	}
else
	{
	Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
	Ok = FALSE;
	}
return(Ok);
}

/*********************************************************************/

BOOL Open_MonatDat()
{
BOOL Ok = TRUE;
struct FileHandle *MonatDatei;

MonGeaendert = FALSE;
Set_Screen_Title(MONAWIND,WORKTITEL);
if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
&&(Read(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
	{
	Ok = FALSE;
	Disk_Fehler(NebenWindow);
	}
if(MonatDatei)
	Close(MonatDatei);
Set_Screen_Title(MONAWIND,MONATITEL);
return(Ok);
}

/*********************************************************************/

VOID Print_Monat(Welchen)
USHORT Welchen;
{
MONAT	*mon = Monat+(Welchen*MONEINT);
STRPTR	dat = Datum();

AnzMonEin = 0;
SetAPen(Neben_rp,GREY);
RectFill(Neben_rp,7L,28L,503L,227L);
LoeschFeld(Neben_rp,588L,22L,3);
Print(Neben_rp,&NameMonat[Welchen][0],588L,22L,RED);
while((*(mon->Bezeichnung) != '\0') && (AnzMonEin < MONEINT))
	{
	sprintf(TempTextGr,"01.%02u.%2s     %-33s      %9.2f",
		Welchen+1,(dat+6),mon,mon->Betrag);
	Print(Neben_rp,TempTextGr,xDatum,(LONG)40+(9*AnzMonEin),BLUE);
	mon++;
	AnzMonEin++;
	}
return;
}

/*********************************************************************/

MONAT** Find_Pointer(Sprung)
SHORT Sprung;
{
UCOUNT		i;
USHORT		j = AktMonat;
static	MONAT	*MonPoint[12];

for(i=0;i<(12/Sprung);i++,j+=Sprung)
	{
	if(j > 11)
		j-=12;
	MonPoint[i] = Monat+(MONEINT*j);
	}
return(&MonPoint[0]);
}

/*********************************************************************/

VOID End_Monat()
{
if(Monat)
	FreeMem(Monat,JAHRLENG);
if(NebenWindow)
	CloseWindow(NebenWindow);
return;
}

/*********************************************************************/

VOID EndProgramm(Fehler)
int Fehler;
{
UCOUNT i;

if ((Fehler) && (IntuitionBase) && (TempText))
	{
	sprintf(TempText,"GiroManager FATAL-ERROR: %03d",Fehler);
	End.IText=TempText;
	AutoRequest(NULL,&End,&Cancel,&Cancel,NULL,NULL,274L,60L);
	}
if(HauptDatei)		Close(HauptDatei);
if(Index)		FreeMem(Index,INDEXLENG);
if(Eintrag)		FreeMem(Eintrag,SIZEEINTRAG*20);
if(UndoBuffer)		FreeMem(UndoBuffer,50L);
if(TempText)		FreeMem(TempText,50L);
if(TempTextGr)		FreeMem(TempTextGr,100L);

for(i=0;i<3;i++)
	if(EingabeBuffer[i])
			FreeMem(EingabeBuffer[i],34L);
for(i=0;i<3;i++)
	if(SuchBuffer[i])
			FreeMem(SuchBuffer[i],34L);
for(i=0;i<3;i++)
	if(MonatBuffer[i])
			FreeMem(MonatBuffer[i],34L);
if(MainWindow)
	{
	ClearMenuStrip(MainWindow);
	CloseWindow(MainWindow);
	}
if(MainScreen) 		CloseScreen(MainScreen);
if(GfxBase) 		CloseLibrary(GfxBase);
if(IntuitionBase) 	CloseLibrary(IntuitionBase);
exit(Fehler);
}

/*********************************************************************/
/*********************************************************************/
/*********************************************************************/