/*
 *  FM_IntegerReq_React.c
 *
 *  Requester for cycledelay-request and iterations-request with reaction-support
 *  $VER: V2.0, 13.10.2001
 *  Coded by Edgar Schwan
 */

#include <intuition/gadgetclass.h>
#include <intuition/classusr.h>
#include <intuition/screens.h>
#include <classes/window.h>
#include <dos/dos.h>
#include <gadgets/integer.h>

#include <clib/intuition_protos.h>
#include <clib/exec_protos.h>
#include <clib/graphics_protos.h>
#include <clib/alib_protos.h>

#include <pragmas/intuition_pragmas.h>
#include <pragmas/exec_pragmas.h>
#include <pragmas/graphics_pragmas.h>

#include <stdlib.h>
#include <stdio.h>

#include "FM_IntegerReq_React.h"
#include "FM_ReactionBasics.h"
#include "FM_Reaction.h"
#include "FM_ReactionCD.h"

extern ULONG *PALETTE;

struct ReactWinData *cycle_rwd = NULL;
struct ReactWinData *iterat_rwd = NULL;

/*	Do_CycleDelayRequest(): cycledelay-requester (full handling).

		SYNOPSIS: ULONG NewValue = Do_CycleDelayRequest
						(
						struct Window	  *Win;
						char				  *PubScreenName;
						WORD 					Left;
						WORD					Top;
						ULONG					Value;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						PubScreenName:
							name of the public-screen, where the window should appear.

						Left:
							Left edge of palette-window.

						Top:
							Top edge of palette-window.

						Value:
							Actual value for delay-time.

		RETURNS:		NewValue:
							New value for delay-time.
*/

ULONG Do_CycleDelayRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top, ULONG Value)
{
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;
ULONG NewValue = Value;

if (OpenCycleReqWindow(PubScreenName, Value) == TRUE) {

	waitsigs = cycle_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
#ifndef NDEBUG
		printf("mask: %lX\n", mask);
#endif /*NDEBUG*/
		if (mask & cycle_rwd->RWD_WSignals) {
			result = HandleCycleReqWindow(Win, &NewValue);
			if (result == RESULT_CANCEL) NewValue = Value;
			}
		if (mask & SIGBREAKF_CTRL_C) {
			NewValue = Value;
			result = RESULT_CANCEL;
			}
		}

	CloseCycleReqWindow();
	} else DisplayError(Win, TXT_ERR_Window, 5L);

LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
return(NewValue);
}

/*	OpenCycleReqWindow(): open window of cycle-requester.

		SYNOPSIS: BOOL res = OpenCycleReqWindow
						(
						char	  *PubScreenName;
						ULONG		Value;
						);

		INPUTS:		PubScreenName:
							name of the public-screen, where the window should appear.

						Value:
							Value for Integer-Gadget.

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenCycleReqWindow(char *PubScreenName, ULONG Value)
{
if (cycle_rwd = OpenReactionWindow(WIN_CYC_ID, GROUP_Cyc_ID, PubScreenName)) {
	SetGadgetAttrs(cycle_rwd->RWD_GadgetArray[Cyc_INTEGER_DelayTime], cycle_rwd->RWD_IWindow, NULL,
						INTEGER_Number, Value, TAG_DONE);
	return(TRUE);
	}
return(FALSE);
}

/*	CloseCycleReqWindow(): close window of cycle-requester.

		SYNOPSIS: void = CloseCycleReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseCycleReqWindow(void)
{
CloseReactionWindow(cycle_rwd);
}

/*	HandleCycleReqWindow(): Handle the messages of the cycle-requester.

		SYNOPSIS: LONG = HandleCycleReqWindow
						(
						struct Window	*Win;
						ULONG				*NewValue
						);

		INPUTS:		Win:
							Pointer to a window-structure.

						NewValue:
							Pointer to a var to store the new value.

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user wants to quit without a change.
														RESULT_OK      -> accept changes and quit.
*/

LONG HandleCycleReqWindow(struct Window *Win, ULONG *NewValue)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

while((result = DoMethod(cycle_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {

#ifndef NDEBUG
	printf("result: %ld\n", result);
#endif /*NDEBUG*/

	switch (result & WMHI_CLASSMASK) {
		case WMHI_CLOSEWINDOW:
			rc = RESULT_CANCEL;
			break;

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case Cyc_BUTTON_Accept:
					rc = RESULT_OK;
					break;
				case Cyc_BUTTON_Cancel:
					rc = RESULT_CANCEL;
					break;
				case Cyc_INTEGER_DelayTime:
					GetAttr(INTEGER_Number, cycle_rwd->RWD_GadgetArray[Cyc_INTEGER_DelayTime], NewValue);
					break;
#ifndef NDEBUG
				default:
					printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
					DisplayBeep(NULL);
					break;
#endif /*NDEBUG*/
				}
			break;

		case WMHI_ICONIFY:
			DoMethod(cycle_rwd->RWD_WindowObject, WM_ICONIFY);
			GetAttr(WINDOW_Window, cycle_rwd->RWD_WindowObject, (ULONG *) &cycle_rwd->RWD_IWindow);
			break;

		case WMHI_UNICONIFY:
			DoMethod(cycle_rwd->RWD_WindowObject, WM_OPEN);
			GetAttr(WINDOW_Window, cycle_rwd->RWD_WindowObject, (ULONG *) &cycle_rwd->RWD_IWindow);
			break;
#ifndef NDEBUG
		default:
			printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
			DisplayBeep(NULL);
			break;
#endif /*NDEBUG*/
		}
	}
return(rc);
}

/*	Do_IterationsRequest(): iteration-requester (full handling).

		SYNOPSIS: ULONG NewValue = Do_IterationsRequest
						(
						struct Window	  *Win;
						char				  *PubScreenName;
						WORD 					Left;
						WORD					Top;
						ULONG					Value;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						PubScreenName:
							name of the public-screen, where the window should appear.

						Left:
							Left edge of palette-window.

						Top:
							Top edge of palette-window.

						Value:
							Actual value for delay-time.

		RETURNS:		NewValue:
							New value for delay-time.
*/

ULONG Do_IterationsRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top, ULONG Value)
{
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;
ULONG NewValue = Value;

if (OpenIteratReqWindow(PubScreenName, Value) == TRUE) {

	waitsigs = iterat_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
#ifndef NDEBUG
		printf("mask: %lX\n", mask);
#endif /*NDEBUG*/
		if (mask & iterat_rwd->RWD_WSignals) {
			result = HandleIteratReqWindow(Win, &NewValue);
			if (result == RESULT_CANCEL) NewValue = Value;
			}
		if (mask & SIGBREAKF_CTRL_C) {
			NewValue = Value;
			result = RESULT_CANCEL;
			}
		}

	CloseIteratReqWindow();
	} else DisplayError(Win, TXT_ERR_Window, 5L);

LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
return(NewValue);
}

/*	OpenIteratReqWindow(): open window of iteration-requester.

		SYNOPSIS: BOOL res = OpenIteratReqWindow
						(
						char	  *PubScreenName;
						ULONG		Value;
						);

		INPUTS:		PubScreenName:
							name of the public-screen, where the window should appear.

						Value:
							Value for integer-gadget.

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenIteratReqWindow(char *PubScreenName, ULONG Value)
{
if (iterat_rwd = OpenReactionWindow(WIN_IT_ID, GROUP_It_ID, PubScreenName)) {
	SetGadgetAttrs(iterat_rwd->RWD_GadgetArray[It_INTEGER_Iterations], iterat_rwd->RWD_IWindow, NULL,
						INTEGER_Number, Value, TAG_DONE);
	return(TRUE);
	}
return(FALSE);
}

/*	CloseIteratReqWindow(): close window of iteration-requester.

		SYNOPSIS: void = CloseIteratReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseIteratReqWindow(void)
{
CloseReactionWindow(iterat_rwd);
}

/*	HandleIteratReqWindow(): Handle the messages of the iteration-requester.

		SYNOPSIS: LONG = HandleIteratReqWindow
						(
						struct Window	*Win;
						ULONG				*NewValue
						);

		INPUTS:		Win:
							Pointer to a window-structure.

						NewValue:
							Pointer to a var to store the new value.

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user wants to quit without a change.
														RESULT_OK      -> accept changes and quit.
*/

LONG HandleIteratReqWindow(struct Window *Win, ULONG *NewValue)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

while((result = DoMethod(iterat_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {

#ifndef NDEBUG
	printf("result: %ld\n", result);
#endif /*NDEBUG*/

	switch (result & WMHI_CLASSMASK) {
		case WMHI_CLOSEWINDOW:
			rc = RESULT_CANCEL;
			break;

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case It_BUTTON_Accept:
					rc = RESULT_OK;
					break;
				case It_BUTTON_Cancel:
					rc = RESULT_CANCEL;
					break;
				case It_INTEGER_Iterations:
					GetAttr(INTEGER_Number, iterat_rwd->RWD_GadgetArray[It_INTEGER_Iterations], NewValue);
					break;
#ifndef NDEBUG
				default:
					printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
					DisplayBeep(NULL);
					break;
#endif /*NDEBUG*/
				}
			break;

		case WMHI_ICONIFY:
			DoMethod(iterat_rwd->RWD_WindowObject, WM_ICONIFY);
			GetAttr(WINDOW_Window, iterat_rwd->RWD_WindowObject, (ULONG *) &iterat_rwd->RWD_IWindow);
			break;

		case WMHI_UNICONIFY:
			DoMethod(iterat_rwd->RWD_WindowObject, WM_OPEN);
			GetAttr(WINDOW_Window, iterat_rwd->RWD_WindowObject, (ULONG *) &iterat_rwd->RWD_IWindow);
			break;
#ifndef NDEBUG
		default:
			printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
			DisplayBeep(NULL);
			break;
#endif /*NDEBUG*/
		}
	}
return(rc);
}