/* c.imagwind1
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "asm.h"
#include "image.h"
#include "imagwind.h"

extern int max_signals;
extern int number_of_signals;
extern VENSTER* vp[MAXSIG];

/*************************** Image Pool declaration ************************/

VENSTER * wind_create(unsigned int alloc_size)
{

	VENSTER *vp;

	/* --- allocate our WINDOW area --- */
	vp = (VENSTER *)malloc(sizeof(VENSTER));
	if (vp == NULL) asm_wprintf("Error in wind_create: WINDOW workspace failed\r");

	Window_DispM(vp)=1;
	DataReal(vp)= (ASM_SAMPLE*) malloc((unsigned int)alloc_size*sizeof(ASM_SAMPLE));
	DataImag(vp)= (ASM_SAMPLE*) malloc((unsigned int)alloc_size*sizeof(ASM_SAMPLE));

	if ((DataReal(vp)==NULL)||(DataImag(vp)==NULL))
		asm_wprintf("Failed to allocate memory for Signals");

	return(vp);
}


VENSTER *Create_ImagePool(unsigned int alloc_size, char * name)
{

	VENSTER * vp;


	vp=wind_create(alloc_size);
	if (vp==NULL) asm_wprintf("Unable to create Signal pool");

	DataAllocSize(vp) = alloc_size;

	/* Geef het window de signaalnaam */

	if ( strlen(name) >= sizeof(DataSignalName(vp)) )
	{
	   strncpy(DataSignalName(vp),name,sizeof(DataSignalName(vp)));
      DataSignalName(vp)[sizeof(DataSignalName(vp))-1] = '\0';
	}
	else
	{
	   strcpy(DataSignalName(vp),name);
	}

	Window_Diag(vp).data=NULL;
	//  init_plot_draw(vp);


	return(vp);

}

/******************************************************************************
 * Realloc_Venster (VENSTER *vp, unsigned int alloc_size)                     *
 * Input:  venster, alloc_size                                                *
 * Output: Voor het venster wordt voor de data opnieuw geheugen geallocceerd  *
 *         Het oude gereserveerde geheugen wordt vrijgegeven.                 *
 * Returns: 0                                                                 *
 ******************************************************************************/

int Realloc_Venster(VENSTER *vp, unsigned int alloc_size)

{

	free(DataReal(vp));        /* Geef oud gereserveerd geheugen vrij */
	free(DataImag(vp));

	DataReal(vp) = NULL;
	DataImag(vp) = NULL;

	/* Vindt nieuw geheugen */
	DataReal(vp) = (ASM_SAMPLE*) malloc((unsigned int)alloc_size*sizeof(ASM_SAMPLE));
	DataImag(vp) = (ASM_SAMPLE*) malloc((unsigned int)alloc_size*sizeof(ASM_SAMPLE));
	if ( (DataReal(vp) == NULL) || (DataImag(vp) == NULL) )
		asm_wprintf("Error in Realloc_Venster: malloc failed\r");

	DataAllocSize(vp) = alloc_size;

	return 0; /* No Error */
}


/***********************************************************************
 * int Find_Signal_Venster(char *signalname)                           *
 * -Input:   Naam van een signaal.                                     *
 * -Returns: Het bijbehorende vensternummer                            *
 *           -1 als signaal niet bestaat.                              *
 ***********************************************************************/

int Find_Signal_Venster(char *signalname)
{
	int i;

	/* Kijk of het signaal bestaat */

	for (i=0; (i < number_of_signals) && ((strcmp(DataSignalName(vp[i]),signalname)) != 0) ; i++);

	if (vp[i] != NULL )
		if (strcmp(DataSignalName(vp[i]),signalname) == 0)
			return i;                        /* Het signaal bestaat, return vensternummer */

	return -1;                        /* Het signaal bestaat niet */
}

/****************************************************************************
 * int Create_Venster(char *signalname,unsigned int Alloc_Size)                                     *
 * Input:   Naam nieuw te creeren signaal.                                  *
 * Output:  Maakt een nieuw venster voor het nieuwe signaal aan.            *
 * Returns: Het nieuwe vensternummer;                                       *
 *          -1 als het aantal displaywindows al het maximale is             *
 ****************************************************************************/

int Create_Venster(char *signalname,unsigned int Alloc_Size)
{

	/* Alloc_Size is de ruimte die voor de data gereserveerd moet worden. */

	int i;

	i = number_of_signals;

	if (number_of_signals < max_signals)
	{
		/* Maak een nieuw window aan */
		vp[i]=Create_ImagePool(Alloc_Size,signalname);

		Window_Mode(vp[i]) = REAL_M;       /* Display real data */
		Window_Log(vp[i]) = 0;          /* Geen log as   */
		Window_InUse(vp[i]) = FALSE;     /* Geen signaal */
		Window_HScale(vp[i]) = 1;
		Window_VScale(vp[i]) = 1;

		number_of_signals++;
		return i;
	}
	else
		return -1;                  /* Te veel displaywindows */
}
/* free the memory allocated by a venster / signal


 */

void remove_venster(VENSTER *vp)
{
	if (DataImag(vp) != NULL ) free(DataImag(vp));
	if (DataReal(vp) != NULL ) free(DataReal(vp));
	if (vp != NULL ) free(vp);
}


