#include "/Mailbox.h"
#include "/protos.h"
#include <libraries/zbbs.h>
#include "globals.c"

enum { GD_answer, GD_init, GD_reset, GD_busy, GD_hangup, GD_device, GD_unit,
		GD_ser_read_size, GD_baud, GD_lock_baud, GD_dtr_drop, GD_rts_cts, GD_zurueck };

BOOL CheckSerial(VOID);

VOID Modem()
{
	struct IntuiText	modemIText[] = {1, 0, JAM1, 251, 12, NULL, "Modem Einstellungen", NULL};
	struct Gadget		*modemGadgets[13];

	if(glist)
	{
		RemoveGList(Win, glist, -1);
		FreeGadgets(glist);
		glist = NULL;
		SetRast(Win->RPort, 0);
	}

	if(!(g = CreateContext(&glist)))
	{
		MyEasyRequest("Konnte Gadget-Context nicht generieren.", "Okay");
		return;
	}

	ng.ng_LeftEdge		= 100;
	ng.ng_TopEdge		= 44;
	ng.ng_Width			= 160;
	ng.ng_Height		= 14;
	ng.ng_GadgetText	= "Answer..:";
	ng.ng_GadgetID		= GD_answer;
	ng.ng_Flags			= PLACETEXT_LEFT|NG_HIGHLABEL;
	ng.ng_TextAttr		= &FontAttr,
	ng.ng_VisualInfo	= VisualInfo;

	modemGadgets[GD_answer] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.answer,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_TopEdge		= 61;
	ng.ng_GadgetText	= "Init....:";
	ng.ng_GadgetID		= GD_init;

	modemGadgets[GD_init] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.init,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_TopEdge		= 78;
	ng.ng_GadgetText	= "Reset...:";
	ng.ng_GadgetID		= GD_reset;

	modemGadgets[GD_reset] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.reset,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_TopEdge		= 95;
	ng.ng_GadgetText	= "Busy out:";
	ng.ng_GadgetID		= GD_busy;

	modemGadgets[GD_busy] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.busy,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_TopEdge		= 112;
	ng.ng_GadgetText	= "Hangup..:";
	ng.ng_GadgetID		= GD_hangup;

	modemGadgets[GD_hangup] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.hangup,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_LeftEdge		= 375;
	ng.ng_TopEdge		= 44;
	ng.ng_GadgetText	= "Device.....:";
	ng.ng_GadgetID		= GD_device;

	modemGadgets[GD_device] =
	g = CreateGadget(STRING_KIND, g, &ng,
		GTST_String,	Config.device,
		GTST_MaxChars,	40,
		TAG_DONE);

	ng.ng_LeftEdge		= 590;
	ng.ng_Width			= 40;
	ng.ng_GadgetText	= "Unit:";
	ng.ng_GadgetID		= GD_unit;

	modemGadgets[GD_unit] =
	g = CreateGadget(INTEGER_KIND, g, &ng,
		GTIN_Number,	Config.unit,
		GTIN_MaxChars,	4,
		TAG_DONE);

	ng.ng_LeftEdge		= 375;
	ng.ng_TopEdge		= 61;
	ng.ng_Width			= 80;
	ng.ng_GadgetText	= "Buffer Size:";
	ng.ng_GadgetID		= GD_ser_read_size;

	modemGadgets[GD_ser_read_size] =
	g = CreateGadget(INTEGER_KIND, g, &ng,
		GTIN_Number,	Config.ser_read_size,
		GTIN_MaxChars,	6,
		TAG_DONE);

	ng.ng_TopEdge		= 78;
	ng.ng_GadgetText	= "Baud.......:";
	ng.ng_GadgetID		= GD_baud;

	modemGadgets[GD_baud] =
	g = CreateGadget(INTEGER_KIND, g, &ng,
		GTIN_Number,	Config.baud,
		GTIN_MaxChars,	10,
		TAG_DONE);

	ng.ng_TopEdge		= 95;
	ng.ng_GadgetText	= "Lock Baud..:";
	ng.ng_GadgetID		= GD_lock_baud;

	modemGadgets[GD_lock_baud] =
	g = CreateGadget(CHECKBOX_KIND, g, &ng,
		GTCB_Checked,	Config.lock_baud,
		TAG_DONE);

	ng.ng_TopEdge		= 109;
	ng.ng_GadgetText	= "DTR Drop...:";
	ng.ng_GadgetID		= GD_dtr_drop;

	modemGadgets[GD_dtr_drop] =
	g = CreateGadget(CHECKBOX_KIND, g, &ng,
		GTCB_Checked,	Config.dtr_drop,
		TAG_DONE);

	ng.ng_TopEdge		= 123;
	ng.ng_GadgetText	= "RTS/CTS....:";
	ng.ng_GadgetID		= GD_rts_cts;
	ng.ng_Flags			= PLACETEXT_LEFT|NG_HIGHLABEL;

	modemGadgets[GD_rts_cts] =
	g = CreateGadget(CHECKBOX_KIND, g, &ng,
		GTCB_Checked,	Config.rts_cts,
		TAG_DONE);

	ng.ng_LeftEdge		= 540;
	ng.ng_TopEdge		= 210;
	ng.ng_Width			= 66;
	ng.ng_Height		= 16;
	ng.ng_GadgetText	= "Zurück";
	ng.ng_GadgetID		= GD_zurueck;
	ng.ng_Flags			= PLACETEXT_IN;
	
	modemGadgets[GD_zurueck] =
	g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);

	if(!g)
	{
		MyEasyRequest("Konnte Gadgets nicht generieren.", "Okay");
		return;
	}

	AddGList(Win, glist, 0, -1, NULL);
	RefreshGList(glist, Win, NULL, -1);
	GT_RefreshWindow(Win, NULL);

	PrintIText(Win->RPort, modemIText, Win->BorderLeft, Win->BorderTop);
	ActivateGadget(modemGadgets[GD_answer], Win, NULL);

	while(TRUE)
	{
		Wait(1L << Win->UserPort->mp_SigBit);

		while(imsg = GT_GetIMsg(Win->UserPort))
		{
			class	= imsg->Class;
			code	= imsg->Code;
			g		= imsg->IAddress;

			GT_ReplyIMsg(imsg);

			if(class == IDCMP_GADGETUP)
			{
				switch(g->GadgetID)
				{
					case GD_answer:
						strcpy(Config.answer ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_init], Win, NULL);
						break;

					case GD_init:
						strcpy(Config.init ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_reset], Win, NULL);
						break;

					case GD_reset:
						strcpy(Config.reset ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_busy], Win, NULL);
						break;

					case GD_busy:
						strcpy(Config.busy ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_hangup], Win, NULL);
						break;

					case GD_hangup:
						strcpy(Config.hangup ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_device], Win, NULL);
						break;

					case GD_device:
						strcpy(Config.device ,((struct StringInfo *)g->SpecialInfo)->Buffer);
						ActivateGadget(modemGadgets[GD_unit], Win, NULL);
						break;

					case GD_unit:
						Config.unit = ((struct StringInfo *)g->SpecialInfo)->LongInt;
						ActivateGadget(modemGadgets[GD_ser_read_size], Win, NULL);
						break;

					case GD_ser_read_size:
						Config.ser_read_size  = ((struct StringInfo *)g->SpecialInfo)->LongInt;
						if(Config.ser_read_size < 512 || Config.ser_read_size > 524288)
						{
							MyEasyRequest("Die Buffergrösse darf nicht kleiner als 512 Bytes\nund nicht grösser als 524288 Bytes sein.", "Okay");
							ActivateGadget(g, Win, NULL);
						}
						else	ActivateGadget(modemGadgets[GD_baud], Win, NULL);
						break;

					case GD_baud:
						Config.baud  = ((struct StringInfo *)g->SpecialInfo)->LongInt;
						ActivateGadget(modemGadgets[GD_answer], Win, NULL);
						break;

					case	GD_lock_baud:
						Config.lock_baud = (g->Flags & SELECTED);
						break;

					case	GD_dtr_drop:
						Config.dtr_drop = (g->Flags & SELECTED);
						break;

					case	GD_rts_cts:
						Config.rts_cts = (g->Flags & SELECTED);
						break;

					case GD_zurueck:
						if(!CheckSerial())
						{
							if(MyEasyRequest("Die Konfiguration kann nicht gespeichert werden,\nwenn Device (-nummer), Baudrate oder die Buffergrösse nicht korrekt sind.", "Weiter|Bleiben"))
							{
      						Config.device[0] =
	      					Config.unit =
		   	   			Config.baud = 0;
		   	   			return;
                     }
						}
						else	return;
						break;
				}
			}
		}
	}
}

BOOL CheckSerial()
{
	struct MsgPort		*ReadPortSER;
	struct IOExtSer	*ReadSER;
	BOOL ok;

	if(Config.ser_read_size < 512 || Config.ser_read_size > 524288)
		return(FALSE);

	ok = FALSE;

	if(ReadPortSER = CreateMsgPort())
	{
		if(ReadSER = CreateIORequest(ReadPortSER, sizeof(struct IOExtSer)))
		{
			ReadSER->io_SerFlags	|= SERF_SHARED;
			ReadSER->io_Baud		= Config.baud;
			if(Config.rts_cts)	ReadSER->io_SerFlags |= SERF_7WIRE;

			if(!OpenDevice(Config.device, Config.unit, ReadSER, NULL))
			{
				ok = TRUE;
				CloseDevice(ReadSER);
			}
			DeleteIORequest(ReadSER);
		}
		DeleteMsgPort(ReadPortSER);
	}

	return(ok);
}