/****************************************************************
*																																*
* Filename : Main.c																							*
*																																*
*****************************************************************
*																																*
*	Comment : Diese Datei beinhaltet alle Routinen für						*
*						starten und beendigen des Demoprogrammes.					 	*
*						Es werden hier folgende globalen Definitionen				*
*						gemacht:																						*
*																																*
*	IntuitionBase -> Basis von Intuitionlibrary										*
*	GfxBase				-> Basis von Graphicslibrary										*
*	Sc						-> Screenpointer																*
*	Mw						-> Mainwindowpointer														*
*	Vp						-> Viewportpolinter															*
*	Rp						-> Rastportpointer															*
*																																*
*	newscreen			-> NewScreenstruktur														*
*	mainwindow		-> NewWindowstruktur														*
*	Menu1					-> Menustruktur																	*
*																																*
*			Rev : V1.0																								*
*																																*
*	History : V1.0 erstellen dieses Files							01.09.89		*
*																																*
*			Doc :																											*
*																																*
*		 Bugs : keine bekannten																			*
*																																*
*		Autor : Oesch Silvano																				*
*																																*
*		Datum : 01.09.89																						*
*																																*
****************************************************************/


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

#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <exec/alerts.h>
#include <exec/types.h>
#include <exec/io.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <libraries/dos.h>
#include <exec/libraries.h>
#include <libraries/dosextens.h>
#include <mylib/mylib.h>
#include <libraries/reqbase.h>
#include <proto/reqproto.h>

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

char xminval[] = "Xmin = -5         ";
char xmaxval[] = "Xmax =  5         ";
char yminval[] = "Ymin = -5         ";
char ymaxval[] = "Ymax =  5         ";
char zminval[] = "Zmin = -5         ";
char zmaxval[] = "Zmax =  5         ";

char *valtext[] =
{
	xminval,
	xmaxval,
	yminval,
	ymaxval,
	zminval,
	zmaxval
};

#include "Definitions.h"
#include "FileIO.h"
#include "menu.h"										/* init. Menustruktur				*/
#include "Texte.h"
#include "Pointer.h"
#include "Function.h"

#include <Plot/PlotLib.h>
#include <Plot/Plot.h>
#include <Plot/Plerror.h>

char about[] =	"          Function - P L O T        \n"
								"          ------------------        \n"
								"                                    \n"
								" Ein Demonstrationsprogramm für die \n"
								" die  Plotlibrary. Diese Library    \n"
								" wurde geschrieben von              \n"
								" Silvano Oesch                      \n";

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

#define MENUTITEL MenuItem33
#define MENUGITTER MenuItem1
#define MENUAUTOVAL MenuItem2
#define MENUCROSS MenuItem4
#define MENUHIDDEN MenuItem5
#define MENUZAXENAME SubItem3
#define MENUZAXEUNIT SubItem4
#define MENUYAXENAME SubItem5
#define MENUYAXEUNIT SubItem6
#define MENUXAXENAME SubItem7
#define MENUXAXEUNIT SubItem8

struct Process	*myprocess;
APTR	olderrorwindow;
struct FileRequester mfr;

char filename[MAXPATH+FCHARS+2];

int redraw = FALSE,
		loop = TRUE,
		sctitel = TRUE;

DATA myfct(DATA x);
DATA quadrat(DATA x);

DATA (*funcptr[])() =							/* Array von Fkt. adressen	*/
{
	sin,
	cos,
	myfct,
	quadrat,
	log
};

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

extern struct ReqBLib *ReqBase;

extern struct Screen *Sc;
extern struct Window *Mw;
extern struct ViewPort *Vp;
extern struct Rastport *Rp;
extern struct Rastport *WRp;

extern int	SCREENHOEHE,
						plerr;

extern struct Plot *plot;


void setminmaxval()
{
	int i,erfolg;
	DATA value;

	for (i=0;i<6;i++)
	{
		erfolg = get_value(i,&value);
		if (erfolg)
			sprintf(&valtext[i][7],"% .4lg",value);
	}
}


DATA myfct(x)												/* eine eigene Fkt					*/
DATA x;
{
	if (x == 0.0)
		return(1.0);
	else
		return((DATA)(sin(x)/x));
}

DATA quadrat(x)											/* eine eigene Fkt					*/
DATA x;
{
	return((DATA)(x*x));
}

void funktionen(smenu)
int smenu;
{

	DATA min,max;
	char buffer[80];
	int id,erfolg;

	switch(smenu)
	{
		case FORMEL:
			SimpleRequest(funktion);
			break;
		default:
		if (GetFloat("Bitte Startwert eingeben",&min))
		{
			if (GetFloat("Bitte Endwert eingeben",&max))
			{
				id = get_data(funcptr[smenu-1],min,max,500);
				if (id == FALSE)
					SimpleRequest(get_ploterror());
				else
				{
					do
					{
						erfolg = GetString(buffer,"Kurvenname",NULL,20,40);
					}
					while(!erfolg);
					set_curvename(id,buffer);
					redraw = TRUE;
					setminmaxval();
				}
			}
		}
		break;
	}
}


void resetflags()
{
	MENUGITTER.Flags &= ~CHECKED;
	MENUAUTOVAL.Flags &= ~CHECKED;
}

void filemenu(smenu)
int smenu;
{
	int erfolg,
			id;
	char buffer[80];

	switch (smenu)
	{
		case LOESCHEN:
			erfolg = TwoGadRequest("Alles löschen !\nSind Sie sicher ?\n");
			if (erfolg == TRUE)
			{
				erfolg = del_data(DELALL,NULL);
				if (erfolg == FALSE)
					SimpleRequest(get_ploterror());
				else
				{
					Move(WRp,0,0);
					ClearScreen(WRp);
					resetflags();
					setminmaxval();
				}
			}
			break;

		case LADEN:
			mfr.Title = "Laden";
			erfolg = FileRequester(&mfr);
			if (erfolg == TRUE)
			{
				id = load_data(filename,NULL);
				if (id == FALSE)
					SimpleRequest(get_ploterror());
				else
				{
					do
					{
						buffer[0] = 0x00;
						erfolg = GetString(buffer,"Kurvenname",NULL,20,40);
					}
					while(!erfolg);
					set_curvename(id,buffer);
					redraw = TRUE;
					setminmaxval();
				}
			}
			break;

		case DRUCKAUSGABE:
			erfolg = HardCopy(Sc,Mw);
			if ( erfolg == FALSE )
				SimpleRequest(hardcopy);
			break;

		case PLOTAUSGABE:
			erfolg = HpPlot(Sc);
			if ( erfolg == FALSE )
				SimpleRequest(get_ploterror());
			break;

		case BEENDEN:
			erfolg =	 TwoGadRequest("Programm beenden !\nSind Sie sicher ?\n");
			if (erfolg)
			{
				loop=FALSE;
				ClearPointer(Mw);
			}
			break;

		case HELP:
			erfolg = Help();
			if ( erfolg == FALSE )
				SimpleRequest(hardcopy);
			break;

		case INFORMATIONEN:
			SimpleRequest(about);
			break;

		default:
			SimpleRequest(funktion);
			break;
	}
}

void beschriftung (smenu,ssmenu)
int smenu;
{
	int erfolg;
	char buffer[50];

	switch (smenu)
	{
		case GRTITEL:
			if (MENUTITEL.Flags & CHECKED)
			{
				buffer[0] = 0x0;
				erfolg = GetString(buffer,"Titel der Graphik",NULL,28,49);
				if (erfolg)
				{
					erfolg = set_titel(buffer);
					if (erfolg == FALSE)
						SimpleRequest(get_ploterror());
				}
				if (erfolg == FALSE)
					MENUTITEL.Flags &= ~CHECKED;
			}
			else
			{
				erfolg = set_titel(NULL);
				if (erfolg == FALSE)
				{
					MENUTITEL.Flags |= CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			break;

		case X_ACHSE:
			if (ssmenu == XACHSENNAME)
			{
				if (MENUXAXENAME.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Titel der X-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_axisname(XAXIS,buffer);
						if (erfolg == FALSE)
							SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUXAXENAME.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_axisname(XAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUXAXENAME.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			else
			{
				if (MENUXAXEUNIT.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Einheit der X-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_unit(XAXIS,buffer);
						if (erfolg == FALSE)
							SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUXAXEUNIT.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_unit(XAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUXAXEUNIT.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			break;

		case Y_ACHSE:
			if (ssmenu == YACHSENNAME)
			{
				if (MENUYAXENAME.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Titel der Y-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_axisname(YAXIS,buffer);
						if (erfolg == FALSE)
							SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUYAXENAME.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_axisname(YAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUYAXENAME.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			else
			{
				if (MENUYAXEUNIT.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Einheit der Y-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_unit(YAXIS,buffer);
						if (erfolg == FALSE)
							SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUYAXEUNIT.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_unit(YAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUYAXEUNIT.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			break;

		case Z_ACHSE:
			if (ssmenu == ZACHSENNAME)
			{
				if (MENUZAXENAME.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Titel der Z-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_axisname(ZAXIS,buffer);
						if (erfolg == FALSE)
							SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUZAXENAME.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_axisname(ZAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUZAXENAME.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			else
			{
				if (MENUZAXEUNIT.Flags & CHECKED)
				{
					buffer[0] = 0x0;
					erfolg = GetString(buffer,"Einheit der Z-Achse",NULL,28,49);
					if (erfolg)
					{
						erfolg = set_unit(ZAXIS,buffer);
						if (erfolg == FALSE)
						SimpleRequest(get_ploterror());
					}
					if (erfolg == FALSE)
						MENUZAXEUNIT.Flags &= ~CHECKED;
				}
				else
				{
					erfolg = set_unit(ZAXIS,NULL);
					if (erfolg == FALSE)
					{
						MENUZAXEUNIT.Flags |= CHECKED;
						SimpleRequest(get_ploterror());
					}
				}
			}
			break;
		default:
			SimpleRequest(funktion);
			break;
	}
}

void darstellung(smenu,ssmenu)
int smenu,
		ssmenu;
{
	int erfolg;

	switch (smenu)
	{

		case GITTER:
			if (MENUGITTER.Flags & CHECKED)
			{
				erfolg = set_grid(NOGRID);
				if (erfolg == FALSE)
				{
					MENUGITTER.Flags &= ~CHECKED;
					SimpleRequest(get_ploterror());
				}
				else
					redraw = TRUE;
			}
			else
			{
				erfolg = set_grid(GRID);
				if (erfolg == FALSE)
				{
					MENUGITTER.Flags |= CHECKED;
					SimpleRequest(get_ploterror());
				}
				else
					redraw = TRUE;
			}
			break;

		case AUTOVAL:
			if (MENUAUTOVAL.Flags & CHECKED)
			{
				erfolg = set_autoval(AUTOOFF);
				if (erfolg == FALSE)
				{
					MENUAUTOVAL.Flags &= ~CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			else
			{
				erfolg = set_autoval(AUTOON);
				if (erfolg == FALSE)
				{
					MENUAUTOVAL.Flags |= CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			break;

		case SCTITEL:
			sctitel ^= TRUE;
			if (sctitel)
				SetWindowTitles(Mw,(char *)-1,ScreenNamen);
			else
				SetWindowTitles(Mw,(char *)-1,NULL);
			ShowTitle(Sc,sctitel);
			break;

		case CROSSHATCH:
			if (MENUCROSS.Flags & CHECKED)
			{
				erfolg = set_3doptions(CROSHON);
				if (erfolg == FALSE)
				{
					MENUCROSS.Flags &= ~CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			else
			{
				erfolg = set_3doptions(CROSHOFF);
				if (erfolg == FALSE)
				{
					MENUCROSS.Flags |= CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			break;

		case HIDDENL:
			if (MENUHIDDEN.Flags & CHECKED)
			{
				erfolg = set_3doptions(HIDDENON);
				if (erfolg == FALSE)
				{
					MENUHIDDEN.Flags &= ~CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			else
			{
				erfolg = set_3doptions(HIDDENOFF);
				if (erfolg == FALSE)
				{
					MENUHIDDEN.Flags |= CHECKED;
					SimpleRequest(get_ploterror());
				}
			}
			break;

		case NEUZEICHNEN:
			redraw = TRUE;
			break;

		case AUFLOESUNG:
			myprocess->pr_WindowPtr = olderrorwindow;
			erfolg = Oeffne_Screen(ssmenu);
			olderrorwindow = myprocess->pr_WindowPtr;
			myprocess->pr_WindowPtr = (APTR)Mw;
			redraw = TRUE;
			break;

		case FARBENAENDERN:
			ColorRequester(1L);
			break;

		case FARBENLADEN:
			FarbenLaden();
			break;

		case FARBENSICHERN:
			FarbenSichern();
			break;

		default:
			SimpleRequest(funktion);
			break;
	}
}

void skala(menu)
int menu;
{
	int axis,mes,erfolg;

	axis = menu/3;
	mes = menu%3;
	erfolg = set_mes(axis+1,mes+1);
	if (erfolg == FALSE)
		SimpleRequest(get_ploterror());
	else
		redraw = TRUE;
}

void setnewval(smenu)
{
	int erfolg;
	DATA value;
	switch(smenu)
	{
		case MSTAND:
			set_value(CLEAR,0.0);
			setminmaxval();
			break;
		default:
			if (GetFloat("Bitte neuen Grenzwert eingeben",&value))
			{
				erfolg = set_value(smenu,value);
				if (erfolg )
					sprintf(&valtext[smenu][7],"% .4lg",value);
				else
					SimpleRequest(get_ploterror());
			}
			break;
	}
}


int main(zahl,string)
int zahl;
char *string[];
{
	struct IntuiMessage *message;

	ULONG class;
	USHORT code;
	int erfolg;
	int autodisp = TRUE;
	int menu,smenu,ssmenu;

	if (openall() == FALSE)
	{
		Delay (TIME);
		closeall();
		exit(5);
	}

	if (open_plot() == FALSE)
	{
		dis_ploterror();
		Delay (TIME);
		closeall();
		exit(5);
	}

	mfr.PathName = filename;
	mfr.Flags = FRQINFOGADGETM|FRQLOADINGM;
	mfr.dirnamescolor = 2;
	myprocess = (struct Process *)FindTask((char *)0);
	olderrorwindow = myprocess->pr_WindowPtr;
	myprocess->pr_WindowPtr = (APTR)Mw;

	while (loop)
	{
		message = (struct IntuiMessage *)GetMsg(Mw->UserPort);
		if (message==NULL)
		{
			ClearPointer(Mw);
			SetMenuStrip(Mw,&Menu1);
			Wait(1L << Mw->UserPort->mp_SigBit);
			continue;
		}
		class = message->Class;
		code = message->Code;
		ReplyMsg((struct Message *)message);
		ClearMenuStrip(Mw);
		SetPointer(Mw,sprite1,POINTERHOEHE,POINTERBREITE,
													POINTERSPOT,POINTERSPOT);
		switch (class)
		{
			case MENUPICK:
				if (code == MENUNULL) break;
				menu = MENUNUM(code);
				smenu = ITEMNUM(code);
				ssmenu = SUBNUM(code);
				if (menu == NOMENU) break;
				if (smenu == NOITEM) break;
				switch (menu)
				{
					case FILEMENU:
						filemenu(smenu);
						break;

					case BESCHRIFTUNG:
						beschriftung(smenu,ssmenu);
						break;

					case SKALA:
						skala(smenu);
						break;

					case GRENZEN:
						setnewval(smenu);
						break;

					case BERECHNUNG:
						funktionen(smenu);
						break;

					case DARSTELLUNG:
						darstellung(smenu,ssmenu);
						break;

					default:
						SimpleRequest(funktion);
						break;
				}
				break;

			default:
				SimpleRequest(funktion);
				break;
		}

		if ((redraw == TRUE)&&(autodisp == TRUE))
		{
			erfolg = display(SCREENOUT,GRAPHSET);
			redraw = FALSE;
			if ((erfolg == FALSE)&&(plerr != SEQDISP))
				SimpleRequest(get_ploterror());
		}
	}
	myprocess->pr_WindowPtr = (APTR)olderrorwindow;
	close_plot();
	closeall();
	exit (NULL);
}