/***************************************************************************
 *		  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:        saveset.c
 * Purpose:     save settings
 * Author:      Charles Peterson (CPP)
 * History:     11-Feb-95 CPP (1.39); Created.
 * Comment:     
 */

#include <stdio.h>
#include <string.h>

#include "gfft.h"
#include "settings.h"

#define WRITE_BOOLEAN( NAME, VARIABLE, DEFLT) \
  write_boolean (fp, cstr, NAME, VARIABLE, DEFLT);

static void write_boolean (FILE *fp, char *cstr, char *name, 
			   BOOLEAN variable, BOOLEAN deflt)
{
    if (variable && !deflt)
    {
	fprintf (fp, "%s%s\n", cstr, name);
    }
    else if (!variable && deflt)
    {
	fprintf (fp, "%sNo%s\n", cstr, name);
    }
}

#define WRITE_ULONG( NAME, VARIABLE, DEFLT, IGNORE1) \
write_ulong (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE1)

static void write_ulong (FILE *fp, char *cstr, char *name, ULONG variable, 
			 ULONG deflt, ULONG ignore1)
{
    if (!(variable == deflt || variable == ignore1))
    {
	fprintf (fp, "%s%s=%lu\n", cstr, name, variable);
    }
}

#define WRITE_LONG( NAME, VARIABLE, DEFLT, IGNORE) \
write_long (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE)

static void write_long (FILE *fp, char *cstr, char *name, long variable, 
			long deflt, long ignore)
{
    if (!(variable == deflt || variable == ignore))
    {
	fprintf (fp, "%s%s=%ld\n", cstr, name, variable);
    }
}

#define WRITE_DOUBLE( NAME, VARIABLE, DEFLT, IGNORE) \
write_double (fp, cstr, NAME, VARIABLE, DEFLT, IGNORE)

static void write_double (FILE *fp, char *cstr, char *name, 
			  double variable, double deflt, double ignore)
{
    if (!(variable == deflt || variable == ignore))
    {
#ifdef _FFP
	fprintf (fp, "%s%s=%19.12g\n", cstr, name, variable);
#else
	fprintf (fp, "%s%s=%15.8g\n", cstr, name, variable);
#endif
    }
}

#define WRITE_CHARS( NAME, VARIABLE) \
  write_chars (fp, cstr, NAME, VARIABLE)

static void write_chars (FILE *fp, char *cstr, char *name, char *variable)
{
    if (variable && strlen (variable))
    {
	fprintf (fp, "%s%s=%s\n", cstr, name, variable);
    }
}

#define WRITE_WINDOWT( VARIABLE, DEFLT) \
  write_windowt (fp, cstr, VARIABLE, DEFLT);

static void write_windowt (FILE *fp, char *cstr, int variable, int deflt)
{
    char *windowt;

    if (variable != deflt)
    {
	switch (variable)
	{
	case RECTANGLE_WINDOW:
	    windowt = "Rectangle";
	    break;
	case TRIANGLE_WINDOW:
	    windowt = "Triangle";
	    break;
	case PARZEN_WINDOW:
	    windowt = "Parzen";
	    break;
	case WELCH_WINDOW:
	    windowt = "Welch";
	    break;
	case HANN_WINDOW:
	    windowt = "Hann";
	    break;
	case HAMMING_WINDOW:
	    windowt = "Hamming";
	    break;
	case BLACKMAN_HARRIS_74DB_WINDOW:
	    windowt = "74dB-Blackman-Harris";
	    break;
	case BLACKMAN_HARRIS_92DB_WINDOW:
	    windowt = "92dB-Blackman-Harris";
	    break;
	default:
	    return;
	}
	fprintf (fp, "%s%s\n", cstr, windowt);
    }
}

#define WRITE_CAL_LIST( VARIABLE) \
  calibration_list__write (fp, cstr, &VARIABLE);


#define WRITE_PLOT_COMMANDS( NAME, VARIABLE) \
  write_plot_commands (fp, cstr, NAME, VARIABLE);


void write_settings (FILE *fp, char *cstr, BOOLEAN show_read,
		     BOOLEAN show_write)
{
    if (show_read)
    {
	WRITE_CHARS ("Read", ReadName);
    }

    if (show_write)
    {
	if (Appending)
	{
	    WRITE_CHARS ("Append", WriteName);
	}
	else
	{
	    WRITE_CHARS ("Write", WriteName);
	}
    }

/*  WRITE_BOOLEAN ("Amplitude", Amplitude, TRUE);  
      True by default, else write POWER */

    WRITE_CAL_LIST (CalibrationList);
    WRITE_ULONG ("Channel", Channel, 1L, 0L);
    WRITE_BOOLEAN ("CombinePlots", CombinePlots, FALSE);
    WRITE_BOOLEAN ("Db", Db, FALSE);
    WRITE_ULONG ("Frames", Frames, ULONG_MAX, ULONG_MAX);
    WRITE_BOOLEAN ("Header", Header, TRUE)
    WRITE_BOOLEAN ("Hidden3D", Hidden3D, TRUE);
    WRITE_DOUBLE ("HighFrequency", HighFrequency, HIGHEST_FREQUENCY, HIGHEST_FREQUENCY);
    WRITE_DOUBLE ("HighY", HighY, HIGHEST_Y, HIGHEST_Y);
    WRITE_BOOLEAN ("IgnoreFormat", IgnoreFormat, FALSE);
/*    WRITE_PARAMETER (IOFormatS, InputFormat, INPUT_FORMAT_DEFAULTS); */
    WRITE_ULONG ("Interleave", Interleave, 1, INVALID_INTERLEAVE);
    WRITE_BOOLEAN ("LogX", LogX, FALSE);
    WRITE_BOOLEAN ("LogY", LogY, FALSE);
    WRITE_DOUBLE ("LowFrequency", LowFrequency, LOWEST_FREQUENCY, LOWEST_FREQUENCY);
    WRITE_DOUBLE ("LowY", LowY, LOWEST_Y, LOWEST_Y);
    WRITE_ULONG ("Key", Key, 0, 0);

/*  WRITE_BOOLEAN ("Mean", Mean, TRUE); true by default, else set SUM */

    WRITE_DOUBLE ("Multiply", Multiply, 1.0L, 1.0L);
    WRITE_LONG ("NumberBins", NumberBins, MAX_BINS, INVALID_BINS);
    WRITE_BOOLEAN ("Numerical", Numerical, FALSE);
    WRITE_ULONG ("Octave", Octave, 1L, 1L);
    WRITE_BOOLEAN ("OneShotOnly", OneShotOnly, FALSE);
/*     WRITE_PARAMETER (IOFormatS, OutputFormat, OUTPUT_FORMAT_DEFAULTS); */
    WRITE_BOOLEAN ("Overlap", Overlap, TRUE);
    WRITE_BOOLEAN ("Pad", Pad, FALSE);
    WRITE_BOOLEAN ("Parseval", Parseval, TRUE);
    WRITE_BOOLEAN ("Pink", Pink, FALSE);
    WRITE_BOOLEAN ("Plot", Plot, NO_PLOT);
    WRITE_PLOT_COMMANDS ("PlotCommand", PlotCommands);
    WRITE_CHARS ("PlotOutput", PlotOutput);
    WRITE_BOOLEAN ("Power", Power, FALSE);
    WRITE_BOOLEAN ("PSDensity", PSDensity, FALSE);
    WRITE_DOUBLE ("Quantization", Quantization, MIN_QUANTIZATION, 
		  BAD_QUANTIZATION);
    WRITE_BOOLEAN ("Quiet", Quiet, FALSE);
    WRITE_DOUBLE ("Rate", Rate, AUTO_RATE, INVALID_RATE);
    WRITE_DOUBLE ("RotX", RotX, DEF_ROT_X, INVALID_ROTATION);
    WRITE_DOUBLE ("RotZ", RotZ, DEF_ROT_Z, INVALID_ROTATION);

    WRITE_BOOLEAN ("RepeatOnly", RepeatOnly, FALSE);
    WRITE_BOOLEAN ("SaveMemory", SaveMemory, FALSE);
    WRITE_LONG ("SmoothingSegments", SmoothingSegments, NO_SMOOTHING, 
		INVALID_SMOOTHING);
    WRITE_BOOLEAN ("SquaredSmoothing", SquaredSmoothing, FALSE);
    WRITE_ULONG ("StartByte", StartByte, 0, 0);
    WRITE_ULONG ("StartFrame", StartFrame, 0, 0);
    WRITE_ULONG ("StopByte", StopByte, ULONG_MAX, ULONG_MAX);
    WRITE_CHARS ("Terminal", Terminal);
    WRITE_BOOLEAN ("Time3D", Time3D, FALSE);
    WRITE_LONG ("TimeOffset", TimeOffset, NOT_SET, INVALID_SET);
    WRITE_DOUBLE ("TimeOverlap", TimeOverlap, DEFAULT_TIME_OVERLAP, 
		  (double) INVALID_SET);
    WRITE_LONG ("TimeSegments", TimeSegments, NOT_SET, INVALID_SET);
    WRITE_LONG ("TimeSegSize", TimeSegSize, NOT_SET, INVALID_SET);
    WRITE_BOOLEAN ("Topaz", Topaz, FALSE);
    WRITE_WINDOWT (WindowType, RECTANGLE_WINDOW);
}