/***************************************************************************
 *		  Copyright (C) 1994  Charles P. Peterson                  *
 *	     4007 Enchanted Sun, San Antonio, Texas 78244-1254             *
 *              Email: Charles_P_Peterson@fcircus.sat.tx.us                *
 *                                                                         *
 *		  This is free software with NO WARRANTY.                  *
 *	      See gfft.c, or run program itself, for details.              *
 *		      Support is available for a fee.                      *
 ***************************************************************************
 *
 * Program:     gfft--General FFT analysis
 * File:        wbtime3d.c
 * Purpose:     requester to set Time-3D parameters
 * Author:      Charles Peterson (CPP)
 * History:     18-March-1994 CPP; Created.
 *               9-August-94 CPP (1.10); Auto Setup and Hidden 3D buttons
 *              14-Dec-94 CPP (1.17); Fix button gadgets for >4 colors
 *              12-Feb-95 CPP (1.41); Fix bug with loaded values
 *              1-Jan-95 CPP (2.01); Make Hidden default for Auto Setup
 * Comments:    Workbench GUI.  Amiga Dependent!
 */

#ifdef AMIGA  /* This module is AMIGA dependent */

#include <stdio.h>     /* sprintf() */
#include <string.h>

/*
 * Amiga includes
 */
#include <exec/types.h>
#include <workbench/workbench.h>
#include <intuition/intuition.h>
#include <clib/intuition_protos.h>
#include <clib/exec_protos.h>
#include <dos.h> /* chkabort() */

/*
 * GFFT includes
 */
#include "gfft.h"
#include "settings.h"  /* for testing */
#include "wbench.h"

/*
 * External globals
 */
extern struct Window *dialog_window_p;

static struct Requester *time3d_rp = NULL;

static struct Gadget *help_time3d_gadgetp;
static struct Gadget *set_up_1_gadgetp;
static struct Gadget *time_segsize_gadgetp;
static struct Gadget *time_segments_gadgetp;
static struct Gadget *time_overlap_gadgetp;
static struct Gadget *time_offset_gadgetp;
static struct Gadget *rotx_gadgetp;
static struct Gadget *rotz_gadgetp;
static struct Gadget *reset_time3d_gadgetp;
static struct Gadget *time3d_on_gadgetp;
static struct Gadget *hidden3d_gadgetp;
static struct Gadget *end_time3d_gadgetp;
/* static struct Gadget *time3d_message_gadgetp; */

#define MAX_VAL_SIZE 30

#define SET_TIME3D_ON \
  if (Time3D) radio_button__in (time3d_on_gadgetp, dialog_window_p);

void time3d_requester (void)
{
    struct IntuiMessage *message;
    APTR *address = NULL;
    ULONG class = 0;
    UWORD qualifier = NULL;
    APTR *next_address = NULL;
    ULONG next_class = 0;
    UWORD next_qualifier = NULL;
    APTR string_gadget_being_set = NULL;
    char string[MAX_VAL_SIZE];

    if (!time3d_rp)
    {
	gadget__begin (GTYP_REQGADGET);
/*
 * Setup Gadgets
 */
	help_time3d_gadgetp = action_button__new ("Help", 0, 0);

        set_up_1_gadgetp = action_button__new ("Auto Set-Up 1", 8, 0);

	string[0] = '\0';

	time_segsize_gadgetp = string_gadget__new ("Time Segment Size:",
						   string,
						   MAX_VAL_SIZE,
						   39, 0, 1);

	time_segments_gadgetp = string_gadget__new ("Time Segment Count:",
						    string,
						    MAX_VAL_SIZE,
						    39, 0, 2);

	time_offset_gadgetp = string_gadget__new ("Time Segment Offset:",
						  string,
						  MAX_VAL_SIZE,
						  39, 0, 3);

	time_overlap_gadgetp = string_gadget__new ("Time Segment Overlap:",
						   string,
						   MAX_VAL_SIZE,
						   39, 0, 4);

	rotx_gadgetp = string_gadget__new ("X Rotation:",
					   string,
					   MAX_VAL_SIZE,
					   18, 0, 5);

	rotz_gadgetp = string_gadget__new ("Z Rotation:",
					   string,
					   MAX_VAL_SIZE,
					   18, 21, 5);


	reset_time3d_gadgetp = action_button__new ("Reset", 0, 6);

	time3d_on_gadgetp = radio_button__new ("3D-Time On", 8, 6);

	hidden3d_gadgetp = radio_button__new ("Hidden3D", 21, 6);

/*	time3d_message_gadgetp = message_gadget__new (40, 0, 7); */

	end_time3d_gadgetp = tall_action_button__new ("...Done", 32, 6);

	time3d_rp = requester__new ();
	time3d_rp->ReqGadget = end_time3d_gadgetp;
	time3d_rp->ReqText =  NULL;

    } /* Ok, time3d_rp has been created */
    

    if (requester__display (time3d_rp, dialog_window_p))
    {
    /*
     * Update everything
     */
	SET_TIME3D_ON;

	if (Hidden3D) radio_button__in (hidden3d_gadgetp, dialog_window_p);

	string[0] = '\0';
	if (TimeSegSize != NOT_SET)
	{
	    sprintf (string, "%ld", TimeSegSize);
	}
	string_gadget__reset (time_segsize_gadgetp, string, 
			      dialog_window_p);

	string[0] = '\0';
	if (TimeSegments != NOT_SET)
	{
	    sprintf (string, "%ld", TimeSegments);
	}
	string_gadget__reset (time_segments_gadgetp, string, 
			      dialog_window_p);

	string[0] = '\0';
	if (TimeOffset != NOT_SET)
	{
	    sprintf (string, "%ld", TimeOffset);
	}
	string_gadget__reset (time_offset_gadgetp, string, 
			      dialog_window_p);

	string[0] = '\0';
	if (TimeOffset == NOT_SET)
	{
	    sprintf (string, "%g", TimeOverlap);
	}
	string_gadget__reset (time_overlap_gadgetp, string, 
				  dialog_window_p);

	sprintf (string, "%g", RotX);
        string_gadget__reset (rotx_gadgetp, string, dialog_window_p);

	sprintf (string, "%g", RotZ);
        string_gadget__reset (rotz_gadgetp, string, dialog_window_p);

	ActivateGadget (time_segsize_gadgetp,
			dialog_window_p,
			time3d_rp);
	while (TRUE)
	{
	    Wait (1 << dialog_window_p->UserPort->mp_SigBit);
	    while (message = (struct IntuiMessage *) GetMsg 
		   (dialog_window_p->UserPort))
	    {
		class = message->Class;
		qualifier = message->Qualifier;
		address = message->IAddress;
		ReplyMsg ((struct Message *) message);
            /*
	     * Finish unfinished string
	     */

		if (string_gadget_being_set &&
		    string_gadget_being_set != address &&
		    address != (APTR) reset_time3d_gadgetp)
		{
		    next_address = address;
		    next_class = class;
		    next_qualifier = qualifier;
		    address = string_gadget_being_set;
		    class = IDCMP_GADGETUP;
		    qualifier = NULL;
		}
		string_gadget_being_set = NULL;

		while (address) /* once for previous string, then next */
		{
		    CATCH_ERROR

		    if (qualifier & IEQUALIFIER_CONTROL)
		    {
			help_message ("Workbench 3D-Time Help");
		    }
	        /*
		 * Check for string GADGETDOWN
		 */
		    else if (class == IDCMP_GADGETDOWN && 
			((struct Gadget *) address)->GadgetType &
			GTYP_STRGADGET)
		    {
			string_gadget_being_set = address;
		    }
		    else if (address == (APTR) help_time3d_gadgetp)
		    {
			help_message ("Workbench 3D-Time Help");
		    }
		    else if (address == (APTR) end_time3d_gadgetp)
		    {
			requester__remove (time3d_rp, dialog_window_p);
			return;
		    }
		    else if (address == (APTR) time3d_on_gadgetp)
		    {
			radio_button__toggle (time3d_on_gadgetp,
					      set_time_3d,
					      set_no_time_3d,
					      dialog_window_p);
		    }
		    else if (address == (APTR) hidden3d_gadgetp)
		    {
			radio_button__toggle (hidden3d_gadgetp,
					      set_hidden_3d,
					      set_no_hidden_3d,
					      dialog_window_p);
		    }
		    else if (address == (APTR) time_segsize_gadgetp)
		    {
			string_gadget__apply 
			  (time_segsize_gadgetp, set_time_seg_size);
			if (TimeSegments == NOT_SET)
			{
			    struct StringInfo *sinfop =
			      time_segments_gadgetp->SpecialInfo;
			    char *buffer = sinfop->Buffer;
			    buffer[0] = '\0';
			    refresh_gadget (time_segments_gadgetp,
					    dialog_window_p);
			}
			if (!next_address)
			{
			    ActivateGadget (time_segments_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    else if (address == (APTR) time_segments_gadgetp)
		    {
			string_gadget__apply (time_segments_gadgetp, 
					      set_time_segments);
			if (TimeSegSize == NOT_SET)
			{
			    struct StringInfo *sinfop =
			      time_segsize_gadgetp->SpecialInfo;
			    char *buffer = sinfop->Buffer;
			    buffer[0] = '\0';
			    refresh_gadget (time_segsize_gadgetp,
					    dialog_window_p);
			}
			if (!next_address)
			{
			    ActivateGadget (time_offset_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    else if (address == (APTR) time_offset_gadgetp)
		    {
			string_gadget__apply (time_offset_gadgetp, 
					      set_time_offset);
			if (TimeOffset != NOT_SET)
			{
			    struct StringInfo *sinfop =
			      time_overlap_gadgetp->SpecialInfo;
			    char *buffer = sinfop->Buffer;
			    buffer[0] = '\0';
			    refresh_gadget (time_overlap_gadgetp,
					    dialog_window_p);
			}
			if (!next_address)
			{
			    ActivateGadget (time_overlap_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    else if (address == (APTR) time_overlap_gadgetp)
		    {
		    /*
                     * ignore if unchanged from default
		     */
		        struct StringInfo *sinfo = 
			  time_overlap_gadgetp->SpecialInfo;
			int pos = sinfo->BufferPos;
			char *buffer = sinfo->Buffer;
			
			if (!((pos == 0 && 
			      buffer[0] == '0' &&
			      buffer[1] == '.' &&
			      buffer[2] == '5' &&
			      buffer[3] == '\0') ||
			      (TimeOffset != NOT_SET &&
			       buffer[0] == '\0')))
			{
			    buffer = string_gadget__apply 
			      (time_overlap_gadgetp, set_time_overlap);
			    if (!strlen (buffer))
			    {
				sprintf (buffer, "%g", TimeOverlap);
				refresh_gadget (time_overlap_gadgetp,
						dialog_window_p);
			    }
			    if (TimeOffset == NOT_SET)
			    {
				struct StringInfo *sinfop =
				  time_offset_gadgetp->SpecialInfo;
				char *buffer = sinfop->Buffer;
				buffer[0] = '\0';
				refresh_gadget (time_offset_gadgetp,
						dialog_window_p);
			    }
			}
			if (!next_address)
			{
			    ActivateGadget (rotx_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    else if (address == (APTR) reset_time3d_gadgetp ||
			     address == (APTR) set_up_1_gadgetp)
		    {
			set_time_offset (NullString);
			set_time_overlap (NullString);
			set_time_segments (NullString);
			set_time_seg_size (NullString);
			set_no_time_3d (NullString);
			set_rotation_x (NullString);
			set_rotation_z (NullString);
			set_hidden_3d (NullString);

			string_gadget__reset (time_offset_gadgetp,
					      "\0", dialog_window_p);
			string_gadget__reset (time_segments_gadgetp,
					      "\0", dialog_window_p);
			string_gadget__reset (time_segsize_gadgetp,
					      "\0", dialog_window_p);

			sprintf (string, "%g", TimeOverlap);
			string_gadget__reset (time_overlap_gadgetp,
					      string, dialog_window_p);

			sprintf (string, "%g", RotX);
			string_gadget__reset (rotx_gadgetp,
					      string, dialog_window_p);

			sprintf (string, "%g", RotZ);
			string_gadget__reset (rotz_gadgetp,
					      string, dialog_window_p);

			radio_button__out (time3d_on_gadgetp,
					   dialog_window_p);

			radio_button__in (hidden3d_gadgetp,
					  dialog_window_p);

			if (address == (APTR) set_up_1_gadgetp)
			{
			    string_gadget__reset (time_segments_gadgetp,
						  "10", dialog_window_p);
			    set_time_segments ("10");
			}
		    }
		    else if (address == (APTR) rotx_gadgetp)
		    {
			char *buffer =
			  string_gadget__apply (rotx_gadgetp,
						set_rotation_x);
			if (!strlen (buffer))
			{
			    sprintf (string, "%g", RotX);
			    string_gadget__reset (rotx_gadgetp,
						  string, dialog_window_p);
			}
			if (!next_address)
			{
			    ActivateGadget (rotz_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    else if (address == (APTR) rotz_gadgetp)
		    {
			char *buffer = 
			  string_gadget__apply (rotz_gadgetp,
						set_rotation_z);
			if (!strlen (buffer))
			{
			    sprintf (string, "%g", RotZ);
			    string_gadget__reset (rotz_gadgetp,
						  string, dialog_window_p);
			}
			if (!next_address)
			{
			    ActivateGadget (time_segsize_gadgetp,
					    dialog_window_p,
					    time3d_rp);
			}
		    }
		    END_CATCH_ERROR;
		    SET_TIME3D_ON;
		    address = next_address;
		    class = next_class;
		    qualifier = next_qualifier;
		    next_address = NULL;
		    next_class = NULL;
		    next_qualifier = NULL;
		} /* while next address */
	    }
	}
    }
}

#endif /* end ifdef AMIGA */