/****************************************************************
*																																*
* Filename : Help.c																							*
*																																*
*****************************************************************
*																																*
*	Comment : Diese File beinhaltet alle Funtionen für die				*
*						Darstellung des Helptextes.													*
*																																*
*						Die Helpfunktion hat ein eigenes Window welches			*
*						zuerst geöffnet wird.																*
*						Danach wird die Umgebungsvariable Fplot.Hlp					*
*						abgefragt, nach dem Standort des Helpfiles.					*
*						Dieser wird dann geladen und die ersten Zeilen			*
*						werden dargestellt.																	*
*						Über die verschiedenen Schalter kann man die				*
*						nächsten Zeilen darstellen.													*
*																																*
*						Der Helptext muss eine ASCII-Datei sein mit					*
*						einer max. Zeilenlänge von 75 Charaktern. Wenn			*
*						die Zeile grösser ist, wird der Rest auf die				*
*						nächste Zeile geschrieben.													*
*						Es werden max. 1500 Zeilen des Helptextes						*
*						geladen.																						*
*																																*
*			Rev : V1.1																								*
*																																*
*	History : V1.0 erstellen dieses Files								01.09.89	*
*						V1.1 korr. eines Fehlers in OpenHelp()  	01.09.89	*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/

/****************************************************************
*																																*
* allgemeine Includedateien																			*
*																																*
****************************************************************/

#include <ctype.h>
#include <exec/types.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <mylib/mylib.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dos.h>
#include <graphics/gfxbase.h>
#include <libraries/reqbase.h>
#include <proto/reqproto.h>

/****************************************************************
*																																*
* programmspezifische Includedateien														*
*																																*
****************************************************************/

#include "Definitions.h"						/* allgemeine Definitionen	*/
#include "Help.h"										/* Help Definitionen				*/
#include "Function.h"

/****************************************************************
*																																*
* externe Definitionen																					*
*																																*
****************************************************************/

extern struct ReqBase *ReqBase;
extern struct Screen *Sc;						/* Screenpointer						*/
extern struct Window *Mw;						/* MainWindowpointer				*/
extern struct NewWindow helpwindow;	/* Referenz in Window.h			*/
extern USHORT chip sprite1[];				/* Referenz in Pointer.h		*/
extern int SCREENHOEHE;							/* Screenhoehe							*/

extern char helpload[];							/* Referenz in texte.h			*/
extern char abbruch[];							/*			"										*/
extern char windowtext[];						/*			"										*/
extern char speicher[];							/*			"										*/

/****************************************************************
*																																*
* globale Definitionen																					*
*																																*
****************************************************************/

static struct Window *Hw;						/* Windowpointer						*/
static struct RastPort *HRp;				/* Rasport Helpwindow				*/
static char *textarray[MAXLINE];		/* Pointerarray of char			*/
static int	screenzeilen;						/* Anzahl Zeilen pro screen	*/

/****************************************************************
*																																*
*	Funktion : OpenHelp()																					*
*																																*
*****************************************************************
*																																*
*		Input : None																								*
*																																*
*	 Output : int Zeilen																					*
*								Zeilen ist die Anzahl geladener Zeilen vom			*
*								Datenfile.																			*
*								Wenn Zeilen == NULL dann ist ein Fehler					*
*								beim laden aufgetretten.												*
*																																*
*****************************************************************
*																																*
*	Comment : Diese Routine öffnet den Helpfile. Der Name					*
*						wird in der Umgebungsvariable Fplot.Hlp							*
*						definiert.																					*
*						Wenn fopen erfolgreich, werden alle Zeilen					*
*						geladen, bis MAXLINE oder EOF erreicht.							*
*						Danach wird Fplot.Hlp wieder geschlossen und				*
*						mit den gelesenen Zeilen in die aufrufende					*
*						Routine zurück verzweigt.														*
*																																*
*			Rev : V1.1																								*
*																																*
*	History : V1.0 erstellen dieses Files								01.09.89	*
*						V1.1 korr. beim einlesen von Fplot.help							*
*								 bis und mit MAXLINE überschreiben							*
*								 des Speichers												01.09.89	*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/
	
int OpenHelp()
{
	char	*helpfile,								/* Pointer auf FileNamen		*/
				*buffer,									/* Pointer auf Strings			*/
				line[LINESIZE];						/* Inputzeile vom File			*/
	FILE	*help;										/* Filepointer							*/

	int erfolg,											/* genereller Rückgabewert	*/
			zeilen=FALSE,								/* Funktionrückgabewert			*/
			laenge;											/* Länge vom Inputstring		*/

	helpfile = getenv(helpname);		/* Hole FileNamen						*/
	if (helpfile)										/* Ist Namen vorhanden ?		*/
	{															/* Ja												*/
		help = fopen(helpfile,"r");	/* File öffnen zum lesen		*/
		if (help)
		{
			while((fgets(line,LINESIZE,help)!= NULL)&&(zeilen < MAXLINE))
			{
				laenge = strlen(line);
				buffer = malloc (laenge);
				textarray[zeilen++]=buffer;
				erfolg = stccpy(buffer,line,laenge);
			}
			fclose(help);
		}
	}
	return (zeilen);								/* return mit Zeilen				*/
}

/****************************************************************
*																																*
*	Funktion : CloseHelp()																				*
*																																*
*****************************************************************
*																																*
*		Input : int zeilen																					*
*								line ist die Anzahl eingelesener Zeilen					*
*																																*
*	 Output : Boolean																							*
*							TRUE	-> keine Fehler															*
*							FALSE -> Fehler bei Speicherfreigabe							*
*																																*
*****************************************************************
*																																*
*	Comment : Diese Routine gibt den Speicher für den Helptext		*
*						wieder an das System zurück.												*
*						Die auftrettenden Fehler bei der Speicher-					*
*						rückgabe werden aufaddiert und am Schluss						*
*						ausgewertet.																				*
*																																*
*			Rev : V1.0																								*
*																																*
*	History : V1.0 erstellen dieses Files								01.09.89	*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/

void CloseHelp(zeilen)
int zeilen;													/* Anzahl gelesener Zeilen	*/
	{
		int i;													/* Schleifenzähler					*/

		for (i=0;i<zeilen;i++)					/* Für alle Felder					*/
			free(textarray[i]);						/* Speicher freigeben und		*/
	}

/****************************************************************
*																																*
*	Funktion : PrintPage()																				*
*																																*
*****************************************************************
*																																*
*		Input : int zeile		 Startfeld ab dem geschrieben						*
*												 werden soll.														*
*																																*
*	 Output : None																								*
*																																*
*****************************************************************
*																																*
*	Comment : Diese Routine schreibt eine Bildschirmseite ab			*
*						der Position von [zeile].														*
*																																*
*			Rev : V1.0																								*
*																																*
*	History : V1.0 erstellen dieses Files								01.09.89	*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/

void PrintPage(zeile)
	int zeile;												/* Startwert vom textarray	*/
	{
		int i,													/* Schleifenzähler					*/
				y=SOT+TEXTSIZE/2;						/* Konstante								*/

		Rechteck(	HRp,									/* Rechteck Rastport				*/
							2,										/* Farbe										*/
							TEXTSIZE,							/* linke Begrenzung					*/
							SOT,									/* obere Begrenzung					*/
							SCREENBREITE-TEXTSIZE,
																		/* untere Begrenzung				*/
							(screenzeilen+1)*TEXTSIZE+SOT);
																		/* rechte Begrenzung				*/
		for ( i=0;i<screenzeilen;i++)		/* alle Zeilen des Screens	*/
			PrintText(HRp,textarray[i+zeile],
        (SHORT)(2*TEXTSIZE),(SHORT)(i*TEXTSIZE+y),1);
	}

/****************************************************************
*																																*
*	Funktion : Help																								*
*																																*
*****************************************************************
*																																*
*		Input : None																								*
*																																*
*	 Output : Boolean																							*
*						Boolean für Fehler die nicht selber abgefangen			*
*										sind.																				*
*										TRUE	-> kein Fehler												*
*										FALSE -> Fehler															*
*																																*
*****************************************************************
*																																*
*	Comment : Eine Datei wird geladen und angezeigt.							*
*																																*
*			Rev : V1.0																								*
*																																*
*	History : V1.0 erstellen dieses Files								01.09.89	*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/

int Help()
{
	struct IntuiMessage *message;
	struct Gadget *gadmess;					/* Gadget Message						*/

	int loop = TRUE,
			i = 0,
			zeilen;

	helpwindow.Screen = Sc;					/* Init. MainWindowstruktur	*/
	helpwindow.Height = SCREENHOEHE;

	Hw = (struct Window *)OpenWindow (&helpwindow);
	if (Hw == NULL)
	{
		SimpleRequest(windowtext);
		return (TRUE);
	}

	HRp = Hw->RPort;								/* Rastport initialisieren	*/
	zeilen = OpenHelp();
	screenzeilen = (SCREENHOEHE-SOT-TEXTSIZE)/TEXTSIZE;
	if (zeilen == FALSE)
	{
		SimpleRequest(helpload);
		CloseWindow ( Hw );
		return ( TRUE );
	}
	PrintPage(i);
	while (loop)
	{
		message = (struct IntuiMessage *)GetMsg(Hw->UserPort);
		if (message==NULL)
		{
			ClearPointer(Hw);
			Wait(1L << Hw->UserPort->mp_SigBit);
			continue;
		}
		gadmess = (struct Gadget *)message->IAddress;
		ReplyMsg(message);
		SetPointer(Hw,sprite1,POINTERHOEHE,POINTERBREITE,
													POINTERSPOT,POINTERSPOT);
		switch (gadmess->GadgetID)
		{
			case NEXTPAGE:
				i = i+screenzeilen;
				i = min(i,zeilen-screenzeilen-1);
				PrintPage(i);
				break;
			case CANCEL:
				loop = FALSE;
				ClearPointer(Hw);
				break;
			case PREVPAGE:
				i=i-screenzeilen;
				i=max(i,0);
				PrintPage(i);
				break;
		}
	}
	CloseHelp(zeilen);
	CloseWindow (Hw);
	return(TRUE);
}