/*
 *  FM_ConfirmReq_React.c
 *
 *  Requester for:
 *     print-request,
 *     exit-request,
 *     render-request,
 *     overwrite-request,
 *     newscr-request with reaction-support
 *
 *  V1.1, 14.06.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 <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_ConfirmReq_React.h"
#include "FM_ReactionBasics.h"
#include "FM_Reaction.h"
#include "FM_ReactionCD.h"

extern ULONG *PALETTE;

struct ReactWinData *print_rwd = NULL;
struct ReactWinData *exit_rwd = NULL;
struct ReactWinData *newscr_rwd = NULL;
struct ReactWinData *render_rwd = NULL;
struct ReactWinData *overwr_rwd = NULL;

/*	Do_PrintRequest(): print-requester (full handling).

		SYNOPSIS: BOOL res = Do_PrintRequest
						(
						struct Window	  *Win;
						WORD 					Left;
						WORD					Top;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						Left:
							Left edge of print-window (not supported yet).

						Top:
							Top edge of print-window (not supported yet).

		RETURNS:		res:
							Is TRUE, if user confirms to print.
*/

BOOL Do_PrintRequest(struct Window *Win, WORD Left, WORD Top)
{
BOOL rc = FALSE;
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenPrintReqWindow() == TRUE) {
	waitsigs = print_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
		if (mask & print_rwd->RWD_WSignals) {
			result = HandlePrintReqWindow();
			}
		if (mask & SIGBREAKF_CTRL_C) {
			result = RESULT_CANCEL;
			}
		if (result == RESULT_OK) rc = TRUE;
		}

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

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

/*	OpenPrintReqWindow(): open window of print-requester.

		SYNOPSIS: BOOL res = OpenPrintReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenPrintReqWindow(void)
{
if (print_rwd = OpenReactionWindow(WIN_PRT_ID, GROUP_Prt_ID)) return(TRUE);
return(FALSE);
}

/*	ClosePrintReqWindow(): close window of print-requester.

		SYNOPSIS: void = ClosePrintReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void ClosePrintReqWindow(void)
{
CloseReactionWindow(print_rwd);
}

/*	HandlePrintReqWindow(): Handle the messages of the print-requester.

		SYNOPSIS: LONG res = HandlePrintReqWindow
						(
						void;
						);

		INPUTS:		-

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user canceled.
														RESULT_OK      -> user wants to print.
*/

LONG HandlePrintReqWindow(void)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

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

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

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case Prt_BUTTON_Yes:
					rc = RESULT_OK;
					break;
				case Prt_BUTTON_No:
					rc = RESULT_CANCEL;
					break;
				}
			break;
		}
	}
return(rc);
}

/*	Do_ExitRequest(): exit-requester (full handling).

		SYNOPSIS: BOOL res = Do_ExitRequest
						(
						struct Window	  *Win;
						WORD 					Left;
						WORD					Top;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						Left:
							Left edge of exit-window (not supported yet).

						Top:
							Top edge of exit-window (not supported yet).

		RETURNS:		res:
							Is TRUE, if user confirms to exit.
*/

BOOL Do_ExitRequest(struct Window *Win, WORD Left, WORD Top)
{
BOOL rc = FALSE;
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenExitReqWindow() == TRUE) {
	waitsigs = exit_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
		if (mask & exit_rwd->RWD_WSignals) {
			result = HandleExitReqWindow();
			}
		if (mask & SIGBREAKF_CTRL_C) {
			result = RESULT_CANCEL;
			}
		if (result == RESULT_OK) rc = TRUE;
		}

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

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

/*	OpenExitReqWindow(): open window of exit-requester.

		SYNOPSIS: BOOL res = OpenExitReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenExitReqWindow(void)
{
if (exit_rwd = OpenReactionWindow(WIN_EXIT_ID, GROUP_Exit_ID)) return(TRUE);
return(FALSE);
}

/*	CloseExitReqWindow(): close window of exit-requester.

		SYNOPSIS: void = CloseExitReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseExitReqWindow(void)
{
CloseReactionWindow(exit_rwd);
}

/*	HandleExitReqWindow(): Handle the messages of the exit-requester.

		SYNOPSIS: LONG res = HandleExitReqWindow
						(
						void;
						);

		INPUTS:		-

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user canceled.
														RESULT_OK      -> user wants to exit.
*/

LONG HandleExitReqWindow(void)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

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

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

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case Exit_BUTTON_Yes:
					rc = RESULT_OK;
					break;
				case Exit_BUTTON_No:
					rc = RESULT_CANCEL;
					break;
				}
			break;
		}
	}
return(rc);
}

/*	Do_NewScrRequest(): newscr-requester (full handling).

		SYNOPSIS: BOOL res = Do_NewScrRequest
						(
						struct Window	  *Win;
						WORD 					Left;
						WORD					Top;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						Left:
							Left edge of newscr-window (not supported yet).

						Top:
							Top edge of newscr-window (not supported yet).

		RETURNS:		res:
							Is TRUE, if user confirms to update rendering.
*/

BOOL Do_NewScrRequest(struct Window *Win, WORD Left, WORD Top)
{
BOOL rc = FALSE;
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenNewScrReqWindow() == TRUE) {
	waitsigs = newscr_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
		if (mask & newscr_rwd->RWD_WSignals) {
			result = HandleNewScrReqWindow();
			}
		if (mask & SIGBREAKF_CTRL_C) {
			result = RESULT_CANCEL;
			}
		if (result == RESULT_OK) rc = TRUE;
		}

	CloseNewScrReqWindow();
	}

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

/*	OpenNewScrReqWindow(): open window of newscr-requester.

		SYNOPSIS: BOOL res = OpenNewScrReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenNewScrReqWindow(void)
{
if (newscr_rwd = OpenReactionWindow(WIN_NEWSCR_ID, GROUP_NewScr_ID)) return(TRUE);
return(FALSE);
}

/*	CloseNewScrReqWindow(): close window of newscr-requester.

		SYNOPSIS: void = CloseNewScrReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseNewScrReqWindow(void)
{
CloseReactionWindow(newscr_rwd);
}

/*	HandleNewScrReqWindow(): Handle the messages of the newscr-requester.

		SYNOPSIS: LONG res = HandleNewScrReqWindow
						(
						void;
						);

		INPUTS:		-

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user canceled.
														RESULT_OK      -> user wants to render.
*/

LONG HandleNewScrReqWindow(void)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

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

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

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case NewScr_BUTTON_Yes:
					rc = RESULT_OK;
					break;
				case NewScr_BUTTON_No:
					rc = RESULT_CANCEL;
					break;
				}
			break;
		}
	}
return(rc);
}

/*	Do_RenderRequest(): render-requester (full handling).

		SYNOPSIS: BOOL res = Do_RenderRequest
						(
						struct Window	  *Win;
						WORD 					Left;
						WORD					Top;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						Left:
							Left edge of render-window (not supported yet).

						Top:
							Top edge of render-window (not supported yet).

		RETURNS:		res:
							Is TRUE, if user confirms to update rendering.
*/

BOOL Do_RenderRequest(struct Window *Win, WORD Left, WORD Top)
{
BOOL rc = FALSE;
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenRenderReqWindow() == TRUE) {
	waitsigs = render_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
		if (mask & render_rwd->RWD_WSignals) {
			result = HandleRenderReqWindow();
			}
		if (mask & SIGBREAKF_CTRL_C) {
			result = RESULT_CANCEL;
			}
		if (result == RESULT_OK) rc = TRUE;
		}

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

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

/*	OpenRenderReqWindow(): open window of render-requester.

		SYNOPSIS: BOOL res = OpenRenderReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenRenderReqWindow(void)
{
if (render_rwd = OpenReactionWindow(WIN_RENDER_ID, GROUP_Render_ID)) return(TRUE);
return(FALSE);
}

/*	CloseRenderReqWindow(): close window of render-requester.

		SYNOPSIS: void = CloseRenderReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseRenderReqWindow(void)
{
CloseReactionWindow(render_rwd);
}

/*	HandleRenderReqWindow(): Handle the messages of the render-requester.

		SYNOPSIS: LONG res = HandleRenderReqWindow
						(
						void;
						);

		INPUTS:		-

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user canceled.
														RESULT_OK      -> user wants to render.
*/

LONG HandleRenderReqWindow(void)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

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

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

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case Rend_BUTTON_Yes:
					rc = RESULT_OK;
					break;
				case Rend_BUTTON_No:
					rc = RESULT_CANCEL;
					break;
				}
			break;
		}
	}
return(rc);
}

/*	Do_OverwriteRequest(): overwrite-requester (full handling).

		SYNOPSIS: BOOL res = Do_OverwriteRequest
						(
						struct Window	  *Win;
						WORD 					Left;
						WORD					Top;
						);

		INPUTS:		Win:
							Pointer to the parent-window.

						Left:
							Left edge of overwr-window (not supported yet).

						Top:
							Top edge of overwr-window (not supported yet).

		RETURNS:		res:
							Is TRUE, if user confirms to overwrite file.
*/

BOOL Do_OverwriteRequest(struct Window *Win, WORD Left, WORD Top)
{
BOOL rc = FALSE;
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenOverwriteReqWindow() == TRUE) {
	waitsigs = overwr_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

	while(result == RESULT_NOTHING) {
		mask = Wait(waitsigs);
		if (mask & overwr_rwd->RWD_WSignals) {
			result = HandleOverwriteReqWindow();
			}
		if (mask & SIGBREAKF_CTRL_C) {
			result = RESULT_CANCEL;
			}
		if (result == RESULT_OK) rc = TRUE;
		}

	CloseOverwriteReqWindow();
	}

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

/*	OpenOverwriteReqWindow(): open window of overwrite-requester.

		SYNOPSIS: BOOL res = OpenOverwriteReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		res:
							TRUE, if successfull.
*/

BOOL OpenOverwriteReqWindow(void)
{
if (overwr_rwd = OpenReactionWindow(WIN_OVERWRITE_ID, GROUP_Overwrite_ID)) return(TRUE);
return(FALSE);
}

/*	CloseOverwriteReqWindow(): close window of overwrite-requester.

		SYNOPSIS: void = CloseOverwriteReqWindow
						(
						void
						);

		INPUTS:		-

		RETURNS:		-
*/

void CloseOverwriteReqWindow(void)
{
CloseReactionWindow(overwr_rwd);
}

/*	HandleOverwriteReqWindow(): Handle the messages of the overwrite-requester.

		SYNOPSIS: LONG res = HandleOverwriteReqWindow
						(
						void;
						);

		INPUTS:		-

		RETURNS:		res:
							result of messages:	RESULT_NOTHING -> nothing happens.
														RESULT_CANCEL  -> user canceled.
														RESULT_OK      -> user wants to overwrite.
*/

LONG HandleOverwriteReqWindow(void)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

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

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

		case WMHI_GADGETUP:
			switch (result & RL_GADGETMASK) {
				case OverWr_BUTTON_Yes:
					rc = RESULT_OK;
					break;
				case OverWr_BUTTON_No:
					rc = RESULT_CANCEL;
					break;
				}
			break;
		}
	}
return(rc);
}