/************************************************************************

 File: C.PLOTUTIL

 Inhoud: void find_font(void), void lose_font(void), 
         void gen_signal_background(VENSTER *vp),
         void gen_freq_background(VENSTER *vp),
         void gen_bode_background(VENSTER *vp),
         void gen_magnitude_background(VENSTER *vp),
         void gen_phase_background(VENSTER *vp),
         void gen_hist_background(VENSTER *vp),
         void gen_signal_plot(VENSTER *vp),
         void gen_bode_plot(VENSTER *vp,int mid_type),
         void gen_magnitude_plot(VENSTER *vp,int mid_type),
         void gen_phase_plot(VENSTER *vp,int mid_type),
         void gen_hist_plot(VENSTER *vp);
         void make_plot(VENSTER *vp);
         void save_drawfile(char *filename,void *handle),
         void init_plot_draw(VENSTER *vp), 
         void redo_signal(wimp_redrawstr r,BOOL more),
         void redraw_signal_window(wimp_w handle),
         void update_signal_window(wimp_w handle),
         void open_signal_window(wimp_openstr *o),
         void display_signal_plot(VENSTER *vp),
         void venster_menu_proc(void *handle,char *hit),
         void signal_menu_maker(void *handle)

  Schrijvers: Edwin Zoer & Erwin Waterlander
              HTS Enschede
  Datum     : juni 1993

 ************************************************************************/
         

#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include "aim_stdlib.h"

#include "wimp.h"
#include "wimpt.h"
#include "win.h"  
#include "werr.h"
#include "event.h"
#include "menu.h"
#include "heap.h"
#include "drawfobj.h"
#include "font.h"
#include "colourtran.h"
#include "image.h"
#include "drawExt.h"
#include <math.h>


#define PI                 3.1415926536
#define MIN2(x,y)          ((x < y) ? x : y)
#define MAX2(x,y)          ((x > y) ? x : y)

/* Een paar hulp-getallen die de witte randen om de plot bepalen  */ 

#define SIGNAL_HOOGTE 500      /* Aantal pixels verticaal voor signaal */
#define PH_MAG 3.0             /* Verhouding tussen phase/magn bij bodediagram */
#define PHASE_MAX  200
#define PHASE_MIN -200
#define LEFT_XOFFS 100           /* Marge links */
#define RIGHT_XOFFS 50           /* Marge rechts */
#define BOTTEM_YOFFS 50          /* Marge onder */
#define TOP_YOFFS 50             /* Marge boven */



/* Zo maar een paar kleuren definities die gebruikt kunnen worden bij     */
/* de functies: set_draw_fill_colour of set_draw_colour                   */

#define WIT                        0xffffff00
#define MED_GREY                   0xcfcfcf00
#define BLACK                      0x00000000
#define RED                        0x0000f800 
#define GREEN                      0x00f80000
#define BLUE                       0xf8000000
#define NO_COLOUR                  0xffffffff


/* Het filtype van een drawfile is 0AFF. Deze wordt gebruikt bij saven    */

#define FILETYPE_DRAWFILE          0x0aff



/* globale definitie voor een font nummer. Dit font nummer wordt in de    */
/* draw file gebruikt i.p.v. de fontnaam. De fontnamen en fontnummers     */
/* worden in een tabel opgeslagen. PS ik weet niet of het met mijn        */
/* routines mogelijk is meerdere fonts in EEn drawfile te gebruiken. Het  */
/* is iedergeval nooit getest.                                            */

#define FONT_NUMBER                2        /* font nummer voor de drawfile */
#define FONT_SIZE                  12

/* paar globale variabelen. de variabele current_font_number is de font-  */
/* handle die je van de font manager terug krijgt.                        */

menu hsit;

BOOL plot_grid,plot_abs;
double     zoom=1.0;
char font_name[256];
int current_font_number;
extern VENSTER *vp[MAXSIG];
extern short MAX_LENGTH;
extern short SAMPLE_RATE;
extern BOOL bon;
extern int max_signals;


void find_font(void)
{
   int m = 8;
   wimp_paletteword voor;
   wimp_paletteword achter;

   voor.word = 0x00000000;
  achter.word = 0xffffff00;
   wimpt_complain(font_find(font_name,FONT_SIZE * 16,FONT_SIZE * 16,0,0,&current_font_number));
   colourtran_setfontcolours(&current_font_number,&achter,&voor,&m);
}

/* routine om de 'current_font_number' vrij te geven.                   */

void lose_font(void)
{
   font_lose(current_font_number);
}

/**********************************************************************************
 *                                                                                *
 * gen_signal_background genereerd het assenstelsel, met bijbehorende tekst, deze *
 * achtergrond verschild per domein                                               *
 *                                                                                *
 **********************************************************************************/

#define pixel_afst 100
#define maxy Window_Height(vp)
#define div_struct.quot quot



void gen_signal_background(VENSTER *vp)
{
   draw_error err;
   int tel;
   int lengte,hoogte,aantaltxt;
   double totaal_tijd,delta_t,delta_y,Max_abs;
   double eenheid,xwaarde[100],y_waarde[20],afstand;
   char ch[256],eenhstr,nm[40];
   SAMPLE *s;                            /* pointer naar te displayen data */
   double Minimum, Maximum;               /* min en max waarden van record */

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */
 

   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   switch (Window_Mode(vp))
   {
   case REAL_M:strncat(nm,"  Real (Time)",20);
               break;
   case IMAG_M:strncat(nm,"  Imaginary (Time)",20); 
               break;
   case MAGN_M:strncat(nm,"  Magnitude (Time)",20);  
               break;
   default: break;
   }
   win_settitle(Window_Handle(vp),nm);

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);
   set_text_background_col(WIT);   


   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= (SIGNAL_HOOGTE + TOP_YOFFS + BOTTEM_YOFFS);

   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS;
   hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;
   afstand= pixel_afst;

   aantaltxt= (int) ((lengte/afstand)+1);
   totaal_tijd = (double)(DataLength(vp))/(double)(DataSampleRate(vp)*10);
   delta_t=(double)(totaal_tijd)/(double)(aantaltxt-1); 
   afstand=(double)(lengte)/(double)(aantaltxt-1);

   if (totaal_tijd < (1))
        {eenheid=1e-3;
         eenhstr='m';
        } 
   if (totaal_tijd < (1e-3))
        {eenheid=1e-6;
         eenhstr='';
        }
   if (totaal_tijd < (1e-6))
        {eenheid=1e-9;
         eenhstr='n';
        }
   if (totaal_tijd < (1e-9))
        {eenheid=1e-11; 
         eenhstr='p';
        }
   
   sprintf(ch,"--> Time [%cs]",eenhstr);
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   delta_t=delta_t/eenheid;                /*  totaal_tijd nu  x.xxxx */

   /* print 0  x-as, y-as  text*/

   sprintf(ch,"0");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);

   /* print record_nr en channel_nr  */

   sprintf(ch,"Rec: %d - Chan: %d",Window_Record(vp),Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-200),(-TOP_YOFFS+10),ch); 
  

   for(tel=1;tel < aantaltxt;tel++)
   {
    xwaarde[tel]=(delta_t*tel);
    sprintf(ch,"%3.2f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 
   }

  
   /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(hoogte+TOP_YOFFS));

  

   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-TOP_YOFFS,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,(lengte+LEFT_XOFFS),-TOP_YOFFS);



   /* Bepaal VSCALE m.b.v. Maximum en minimum     */


  
   if (Window_Mode(vp)==REAL_M)
     { 
     s = DataReal(vp);     /* display real data */
     }

   else
     {
     s = DataImag(vp);     /* display imaginary data */
     }
   
   Minimum=Maximum=*s;                       /* Min en Max bepalen */

   for(tel=0;tel < (DataLength(vp));tel++)
      {
       if (*s > Maximum) Maximum=*s;
       if (*s < Minimum) Minimum=*s;
       s++;
       }


   
   if ((Maximum <= 1)  && (Maximum >= 0.0)) Maximum=1; 
   if ((Minimum >= -1) && (Minimum <= 0.0)) Minimum=-1;

   Window_Max(vp)=Maximum;
   Window_Min(vp)=Minimum;

   aantaltxt=9;
   afstand = (int)(-hoogte/(aantaltxt-1));
    
   Max_abs = (double)MAX2(fabs(Maximum),fabs(Minimum)); /* Absolute maximum */

   delta_y = Max_abs*2/(aantaltxt-1);

   Window_VScale(vp) = Max_abs/(hoogte/2);
   set_draw_colour(MED_GREY); 

   if (Max_abs >= USHRT_MAX)
   {
   for(tel=0;tel < aantaltxt;tel++)
     {
     y_waarde[tel]=(int)(Window_Max(vp)-delta_y*tel);
     sprintf(ch,"%8.2g",y_waarde[tel]);
     text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-95),(int)(tel*afstand-TOP_YOFFS-5),ch); 
      
     }
   }

   if (Max_abs < USHRT_MAX)
   {
   for(tel=0;tel < aantaltxt;tel++)
     { 
     y_waarde[tel]=(Window_Max(vp)-delta_y*tel);
     sprintf(ch,"%5.1f",y_waarde[tel]);
     text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-95),(int)(tel*afstand-TOP_YOFFS-5),ch); 
     }
   }

   for(tel=1;tel < aantaltxt-1;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+1,(int)(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(int)(tel*afstand-TOP_YOFFS));
   
   lose_font();

   if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
   {
     draw_show_error("gen_signal_background",&err);
   }
}


/**********************************************************************************
 *                                                                                *
 * gen_freq_background genereerd het assenstelsel, met bijbehorende tekst, deze *
 * achtergrond verschild per domein                                               *
 *                                                                                *
 **********************************************************************************/

#define pixel_afst 100
#define maxy Window_Height(vp)
#define div_struct.quot quot



void gen_freq_background(VENSTER *vp)
{
   draw_error err;
   int tel;
   int lengte,hoogte,aantaltxt,sampler;
   double delta_f,delta_y,Max_abs;
   double eenheid,xwaarde[100],y_waarde[20],afstand;
   char ch[256],nm[40];
   SAMPLE *s;                           
   double Minimum, Maximum;               /* min en max waarden van record */

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */
 
   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   if (Window_Mode(vp)==REAL_M)
     strncat(nm,"  Real (Freq)",20);
   else
     strncat(nm,"  Imaginary (Freq)",20);
   win_settitle(Window_Handle(vp),nm);

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);
   set_text_background_col(WIT);   


   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= (SIGNAL_HOOGTE + TOP_YOFFS + BOTTEM_YOFFS);
 
   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS;     /* Lengte horizontale as */
   hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;    /* Lengte verticale as */
   afstand= pixel_afst;                             /* Aantal pixels tussen twee getallen */
   sampler= DataSampleRate(vp)*10;                  /* Samplerate in Hz */
                                                    
   aantaltxt= (int) ((lengte/afstand)+1);           /* Aantal getallen horizontale as */
   delta_f=(double)(sampler)/(double)(aantaltxt-1); /* freq tussen twee getallen */
   afstand=(double)(lengte)/(double)(aantaltxt-1);  /* Aantal pixels tussen twee getallen */

   eenheid=1e3;             /* Kies voor de eenheid 1000  (kHz)  */
   delta_f=delta_f/eenheid;              

   sprintf(ch,"--> Frequency [kHz]");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   /* print 0  x-as  text*/
   sprintf(ch,"0");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);
  

   for(tel=1;tel < aantaltxt;tel++)
   {
    xwaarde[tel]=(delta_f*tel);
    sprintf(ch,"%3.2f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 
   }

  


   /* print record_nr en channel_nr  */

   sprintf(ch,"Rec: %d - Chan: %d",Window_Record(vp),Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-200),(-TOP_YOFFS+10),ch); 
  

   /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(hoogte+TOP_YOFFS));

   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-TOP_YOFFS,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,(lengte+LEFT_XOFFS),-TOP_YOFFS);



   /* Bepaal VSCALE m.b.v. Maximum en minimum     */


  
   if (Window_Mode(vp)==REAL_M)
     { 
     s = DataReal(vp);     /* display real data */
     }

   else
     {
     s = DataImag(vp);     /* display imaginary data */
     }
   
   s = s + Window_Record(vp)*DataLength(vp);

   Minimum=Maximum=*s;                       /* Min en Max bepalen */

   for(tel=0;tel < (DataLength(vp));tel++)
      {
       if (*s > Maximum) Maximum=*s;
       if (*s < Minimum) Minimum=*s;
       s++;
       }

   
   Window_Max(vp)=Maximum;
   Window_Min(vp)=Minimum;
   
   aantaltxt=9;
   afstand = (int)(-hoogte/(aantaltxt-1));
    
   Max_abs = (double)MAX2(fabs(Maximum),fabs(Minimum)); /* Absolute maximum */
   if (Max_abs == 0.0) Max_abs = 1;
   delta_y = Max_abs*2/(aantaltxt-1);

   Window_VScale(vp) = Max_abs/(hoogte/2);
   set_draw_colour(MED_GREY); 

   if (Max_abs >= USHRT_MAX)
   {
   for(tel=0;tel < aantaltxt;tel++)
     {
     y_waarde[tel]=(int)(Window_Max(vp)-delta_y*tel);
     sprintf(ch,"%8.2g",y_waarde[tel]);
     text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-95),(int)(tel*afstand-TOP_YOFFS-5),ch); 
      
     }
   }

   if (Max_abs < USHRT_MAX)
   {
   for(tel=0;tel < aantaltxt;tel++)
     {
     y_waarde[tel]=(Window_Max(vp)-delta_y*tel);
     sprintf(ch,"%5.1f",y_waarde[tel]);
     text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-95),(int)(tel*afstand-TOP_YOFFS-5),ch); 
     }
   }

   for(tel=1;tel < aantaltxt-1;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+1,(int)(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(int)(tel*afstand-TOP_YOFFS));
   
   lose_font();

   if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
   {
     draw_show_error("gen_freq_background",&err);
   }
}

/*****************************************************************************************/

void gen_bode_background(VENSTER *vp)
{
   draw_error err;
   int tel,midtype;
   int lengte,mag_hoogte,phase_hoogte,aantaltxt,sampler;
   int mag_top_offs; 
   int delta_ph;
   double delta_f,delta_db,Max_abs;
   double eenheid,xwaarde[100],afstand;
   int ywaarde[100],ph_waarde[10];
   char ch[256],nm[40];
   SAMPLE *temp,*tempadres, *real_data, *imag_data;   /* pointer naar te displayen data */
   double Minimum, Maximum;                           /* min en max waarden van record */


   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   strncat(nm,"  BodeDiagram",20);
   win_settitle(Window_Handle(vp),nm);

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);   
   set_text_background_col(WIT);   


   midtype=0;
   mag_hoogte = SIGNAL_HOOGTE;
   phase_hoogte = (int)(SIGNAL_HOOGTE/PH_MAG);  
   mag_top_offs = phase_hoogte + 2*TOP_YOFFS;
  
   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= mag_hoogte + phase_hoogte + 2*TOP_YOFFS + BOTTEM_YOFFS;
   
   lengte=(Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS);        /* Lengte horizontale as */
/*   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS; */   /* Lengte horizontale as */
/* Horizontale as + text */


   afstand= pixel_afst;                             /* Aantal pixels tussen twee getallen */
   sampler= DataSampleRate(vp)*10;                  /* Samplerate in Hz */
                                                    
   aantaltxt= (int) ((lengte/afstand)+1);           /* Aantal getallen horizontale as */
   delta_f=(double)(sampler)/(double)(aantaltxt-1); /* freq tussen twee getallen */
   afstand=(double)(lengte)/(double)(aantaltxt-1);  /* Aantal pixels tussen twee getallen */

   eenheid=1e3;             /* Kies voor de eenheid 1000  (kHz)  */
   delta_f=delta_f/eenheid;              

   sprintf(ch,"--> Frequency [kHz]");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   /* print 0  x-as  text*/
   sprintf(ch,"0");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);
  

   for(tel=1;tel < aantaltxt;tel++)
   {
    xwaarde[tel]=(delta_f*tel);
    sprintf(ch,"%3.2f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 
   }

  
   /* print record_nr en channel_nr  */

   sprintf(ch,"          Chan: %d",Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-200),(-TOP_YOFFS+10),ch); 
  

   /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
   {
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(phase_hoogte+TOP_YOFFS));
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(mag_top_offs),LEFT_XOFFS+tel*afstand,-(mag_top_offs+mag_hoogte));
   }  




   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-mag_top_offs,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-mag_top_offs,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-mag_top_offs,(lengte+LEFT_XOFFS),-mag_top_offs);

   line1(&Window_Diag(vp),LEFT_XOFFS,-(TOP_YOFFS),LEFT_XOFFS,-(TOP_YOFFS+phase_hoogte));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-(TOP_YOFFS),lengte+LEFT_XOFFS,-(TOP_YOFFS+phase_hoogte));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(TOP_YOFFS),(lengte)+LEFT_XOFFS,-(TOP_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(TOP_YOFFS+phase_hoogte),(lengte+LEFT_XOFFS),-(TOP_YOFFS+phase_hoogte));

   /* Bepaal VSCALE m.b.v. Maximum en minimum voor de phase    */


   Window_Max(vp)=PHASE_MAX;
   Window_Min(vp)=PHASE_MIN;

   Max_abs = Window_Max(vp)-Window_Min(vp); /* verschil tussen minimum en maximum */
   aantaltxt = 5;
   afstand = (int)(-phase_hoogte/(aantaltxt-1));
   delta_ph = (int)(Max_abs/(aantaltxt-1));                     /* delta is 20 graden */
   
   Window_VScale(vp) = Max_abs/(double)(phase_hoogte);
 /*  wprintf("MA: %g,phase_hoogte %d, Window_V: %g\n",Max_abs,phase_hoogte,Window_VScale(vp)); */
   
  for(tel=0;tel < aantaltxt;tel++)
  {
    ph_waarde[tel]=(int)(Window_Max(vp)-delta_ph*tel);
    sprintf(ch,"%7d",ph_waarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-80),(int)(tel*afstand-TOP_YOFFS-5),ch); 
  }

  sprintf(ch,"Degrees");
  text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS),(-TOP_YOFFS+10),ch); 
  
  set_draw_colour(MED_GREY);
  for(tel=1;tel < aantaltxt-1;tel++)
  {
    line1(&Window_Diag(vp),LEFT_XOFFS+1,(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(tel*afstand-TOP_YOFFS)); 
  }


   /* Bepaal VSCALE m.b.v. Maximum en minimum voor de magnitude    */


  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_bode_background: heap_alloc failed\r");

  tempadres=temp;
  real_data = DataReal(vp);     /* display real data */
  imag_data = DataImag(vp);     /* display imaginary data */

  for(tel=0;tel < (DataLength(vp));tel++) 
  {
    temp[tel] = 10*log10(sqrt(pow(real_data[tel],2) + pow(imag_data[tel],2))); 
  }
 
  Minimum=Maximum=*temp;                       /* Min en Max bepalen */

  for(tel=0;tel < (DataLength(vp));tel++)
  {
    if (*temp > Maximum) Maximum=*temp;
    if (*temp < Minimum) Minimum=*temp;
    temp++;
   }
   temp=tempadres;
   heap_free(temp);
   
   Window_Max(vp)= ((int)(Maximum/10)+1) * 10;
   Window_Min(vp)= ((int)(Minimum/10)-1) * 10;

   Max_abs = Window_Max(vp)-Window_Min(vp); /* verschil tussen minimum en maximum */
   aantaltxt = (int)(Max_abs/10) + 1;
   afstand = -mag_hoogte/(aantaltxt-1);
   delta_db = 10;
   
   Window_VScale(vp) = Max_abs/(mag_hoogte);
   
  for(tel=0;tel < aantaltxt;tel++)
  {
    ywaarde[tel]=(int)(Window_Max(vp)-delta_db*tel);
    sprintf(ch,"%7d",ywaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-80),(int)(tel*afstand-mag_top_offs-5),ch); 
  }

  sprintf(ch,"dB");
  text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS),(-mag_top_offs+10),ch); 
  
  set_draw_colour(MED_GREY);
  for(tel=1;tel < aantaltxt-1;tel++)
  {
    line1(&Window_Diag(vp),LEFT_XOFFS+1,(tel*afstand-mag_top_offs),lengte+LEFT_XOFFS-1,(tel*afstand-mag_top_offs)); 
  }

  lose_font();

   if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
   {
     draw_show_error("gen_bode_background",&err);
   }
}


/*****************************************************************************************/

void gen_magnitude_background(VENSTER *vp)
{
   draw_error err;
   int tel;
   int lengte,hoogte,aantaltxt,sampler;
   int ywaarde[100];
   double delta_f,delta_db,Max_abs;
   double eenheid,xwaarde[100],afstand;
   char ch[256],nm[40];
   SAMPLE *temp,*tempadres,*real_data, *imag_data;                            /* pointer naar te displayen data */
   double Minimum, Maximum;               /* min en max waarden van record */

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */

   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   strncat(nm,"  Magnitude (Freq)",20);
   win_settitle(Window_Handle(vp),nm);

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);
   set_text_background_col(WIT);   


   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= (SIGNAL_HOOGTE + TOP_YOFFS + BOTTEM_YOFFS);

   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS;     /* Lengte horizontale as */
   hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;    /* Lengte verticale as */
   afstand= pixel_afst;                             /* Aantal pixels tussen twee getallen */
   sampler= DataSampleRate(vp)*10;                  /* Samplerate in Hz */
                                                    
   aantaltxt= (int) ((lengte/afstand)+1);           /* Aantal getallen horizontale as */
   delta_f=(double)(sampler)/(double)(aantaltxt-1); /* freq tussen twee getallen */
   afstand=(double)(lengte)/(double)(aantaltxt-1);  /* Aantal pixels tussen twee getallen */

   eenheid=1e3;             /* Kies voor de eenheid 1000  (kHz)  */
   delta_f=delta_f/eenheid;              

   sprintf(ch,"--> Frequency [kHz]");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   /* print 0  x-as  text*/
   sprintf(ch,"0");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);
  

   for(tel=1;tel < aantaltxt;tel++)
   {
    xwaarde[tel]=(delta_f*tel);
    sprintf(ch,"%3.2f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 
   }



   /* print record_nr en channel_nr  */

   sprintf(ch,"          Chan: %d",Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-200),(-TOP_YOFFS+10),ch); 
  

   /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(hoogte+TOP_YOFFS));


   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-TOP_YOFFS,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,(lengte+LEFT_XOFFS),-TOP_YOFFS);



   /* Bepaal VSCALE m.b.v. Maximum en minimum     */


  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_magnitude_background: heap_alloc failed\r");

  tempadres=temp;
  real_data = DataReal(vp);     /* display real data */
  imag_data = DataImag(vp);     /* display imaginary data */

  if (Window_Log(vp))
    for(tel=0;tel < (DataLength(vp));tel++) 
    {
      temp[tel] = 10*log10(sqrt(pow(real_data[tel],2) + pow(imag_data[tel],2))); 
    }
  else
    for(tel=0;tel < (DataLength(vp));tel++) 
    {
      temp[tel] = (sqrt(pow(real_data[tel],2) + pow(imag_data[tel],2))); 
    }

  Minimum=Maximum=*temp;                       /* Min en Max bepalen */

  for(tel=0;tel < (DataLength(vp));tel++)
  {
    if (*temp > Maximum) Maximum=*temp;
    if (*temp < Minimum) Minimum=*temp;
    temp++;
   }
   temp=tempadres;
   heap_free(temp);
   
   if (Window_Log(vp))
   {
     Window_Max(vp)= ((int)(Maximum/10)+1) * 10;
     Window_Min(vp)= ((int)(Minimum/10)-1) * 10;
     Max_abs = Window_Max(vp)-Window_Min(vp); /* verschil tussen minimum en maximum */
     aantaltxt = (int)(Max_abs/10) + 1;
     delta_db=10;
   }
   else
   {
     Window_Max(vp)= Maximum;
     Window_Min(vp)= 0;
     if (Window_Max(vp) <=1) Window_Max(vp)=1;
     Max_abs = Window_Max(vp);
     aantaltxt=9;
     delta_db= Max_abs/(aantaltxt-1);
   }
   
   afstand = -hoogte/(aantaltxt-1);
   
   Window_VScale(vp) = Max_abs/(hoogte);
   
  for(tel=0;tel < aantaltxt;tel++)
  {
    ywaarde[tel]=(int)(Window_Max(vp)-delta_db*tel);
    sprintf(ch,"%7d",ywaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-80),(int)(tel*afstand-TOP_YOFFS-5),ch); 
  }

  if (Window_Log(vp))
  {
    sprintf(ch,"dB");
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS),(-TOP_YOFFS+10),ch); 
  }

  set_draw_colour(MED_GREY);
  for(tel=1;tel < aantaltxt-1;tel++)
  {
    line1(&Window_Diag(vp),LEFT_XOFFS+1,(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(tel*afstand-TOP_YOFFS)); 
  }

  lose_font();

  if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
  {
    draw_show_error("gen_magnitude_background",&err);
  }
}

/*****************************************************************************************/




void gen_phase_background(VENSTER *vp)
{
   draw_error err;
   int tel;
   int lengte,hoogte,aantaltxt,sampler;
   double delta,delta_f,Max_abs;
   double eenheid,afstand;
   double xwaarde[100];
   int ywaarde[100];
   char ch[256],nm[40];

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */
 
   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   strncat(nm,"  Phase",20);
   win_settitle(Window_Handle(vp),nm);

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);
   set_text_background_col(WIT);   


   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= (SIGNAL_HOOGTE + TOP_YOFFS + BOTTEM_YOFFS);

   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS;     /* Lengte horizontale as */
   hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;    /* Lengte verticale as */
   afstand= pixel_afst;                             /* Aantal pixels tussen twee getallen */
   sampler= DataSampleRate(vp)*10;                  /* Samplerate in Hz */
                                                    
   aantaltxt= (int) ((lengte/afstand)+1);           /* Aantal getallen horizontale as */
   delta_f=(double)(sampler)/(double)(aantaltxt-1); /* freq tussen twee getallen */
   afstand=(double)(lengte)/(double)(aantaltxt-1);  /* Aantal pixels tussen twee getallen */

   eenheid=1e3;             /* Kies voor de eenheid 1000  (kHz)  */
   delta_f=delta_f/eenheid;              

   sprintf(ch,"--> Frequency [kHz]");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   /* print 0  x-as  text*/
   sprintf(ch,"0");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);
  

   for(tel=1;tel < aantaltxt;tel++)
   {
    xwaarde[tel]=(delta_f*tel);
    sprintf(ch,"%3.2f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 
   }


   /* print record_nr en channel_nr  */

   sprintf(ch,"          Chan: %d",Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-200),(-TOP_YOFFS+10),ch); 
  
     /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(hoogte+TOP_YOFFS));


   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-TOP_YOFFS,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,(lengte+LEFT_XOFFS),-TOP_YOFFS);



   /* Bepaal VSCALE m.b.v. Maximum en minimum     */

   Window_Max(vp)=PHASE_MAX;
   Window_Min(vp)=PHASE_MIN;

   Max_abs = Window_Max(vp)-Window_Min(vp); /* verschil tussen minimum en maximum */
   aantaltxt = 11;
   afstand = -hoogte/(aantaltxt-1);
   delta = Max_abs/(aantaltxt-1);                     /* delta is 20 graden */
   
   Window_VScale(vp) = Max_abs/(hoogte);
   
  for(tel=0;tel < aantaltxt;tel++)
  {
    ywaarde[tel]=(int)(Window_Max(vp)-delta*tel);
    sprintf(ch,"%7d",ywaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-80),(int)(tel*afstand-TOP_YOFFS-5),ch); 
  }

  sprintf(ch,"Degrees");
  text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS),(-TOP_YOFFS+10),ch); 
  
  set_draw_colour(MED_GREY);
  for(tel=1;tel < aantaltxt-1;tel++)
  {
    line1(&Window_Diag(vp),LEFT_XOFFS+1,(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(tel*afstand-TOP_YOFFS)); 
  }

  lose_font();

  if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
  {
    draw_show_error("gen_phase_background",&err);
  }
}

/**********************************************************************************/

void gen_hist_background(VENSTER *vp)
{
   draw_error err;
   int tel;
   int lengte,hoogte,aantaltxt;
   int ywaarde[100];
   double delta_a,delta_n,Max_abs;
   double xwaarde[100],afstand;
   char ch[256],nm[40];
   SAMPLE *real_data;   /* pointer naar te displayen data */

/* zoek de font 'corpus.medium' op en maak hem 'current'. Vertel aan */
/* de 'drawext' dat we dit font gaan gebruiken.                      */

   strncpy(nm,"Signal ",10);
   strncat(nm,DataSignalName(vp),40);
   strncat(nm,"  Histogram (Time)",20);
   win_settitle(Window_Handle(vp),nm);

   find_font();
   font_table(&Window_Diag(vp),FONT_NUMBER,font_name);
   set_draw_fill_colour(NO_COLOUR);
   set_text_col(BLACK);
   set_text_background_col(WIT);   


   Window_Width(vp)=Window_HScale(vp)*DataLength(vp) + LEFT_XOFFS + RIGHT_XOFFS;
   Window_Height(vp)= (SIGNAL_HOOGTE + TOP_YOFFS + BOTTEM_YOFFS);

   lengte=Window_Width(vp) - LEFT_XOFFS - RIGHT_XOFFS;     /* Lengte horizontale as */
   hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;    /* Lengte verticale as */
   afstand= pixel_afst;                             /* Aantal pixels tussen twee getallen */
                                                    
   aantaltxt= (int) ((lengte/afstand)+1);           /* Aantal getallen horizontale as */
   delta_a=(double)(DataRealMax(vp)-DataRealMin(vp))/(double)(aantaltxt-1); /* ampl tussen twee getallen */
   afstand=(double)(lengte)/(double)(aantaltxt-1);  /* Aantal pixels tussen twee getallen */

   sprintf(ch,"--> Magnitude");
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(lengte/2),-maxy+5,ch); 
  
   /* print 0  x-as  text*/
   sprintf(ch,"%5.1f",DataRealMin(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,LEFT_XOFFS,-maxy+28,ch);
  

 /*  for(tel=1;tel < aantaltxt;tel++)
   {
    */
    tel = aantaltxt -1;

    xwaarde[tel]=(delta_a*tel+DataRealMin(vp));
    sprintf(ch,"%5.1f",xwaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(int)(tel*afstand+LEFT_XOFFS-25),(int)(-maxy+28),ch); 

/*   }   */



   /* print record_nr en channel_nr  */

   sprintf(ch,"Chan: %d",Window_Channel(vp));
   text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS+lengte-100),(-TOP_YOFFS+10),ch); 
  

   /* teken vertikaal grid  */
   set_draw_colour(MED_GREY);
   
   for(tel=1;tel < aantaltxt;tel++)
     line1(&Window_Diag(vp),LEFT_XOFFS+tel*afstand,-(TOP_YOFFS),LEFT_XOFFS+tel*afstand,-(hoogte+TOP_YOFFS));


   /* teken de x en y as in zwart (+ boven en rechts)   */
    
   set_draw_colour(BLACK);
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),lengte+LEFT_XOFFS,-TOP_YOFFS,lengte+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-(maxy-BOTTEM_YOFFS),(lengte)+LEFT_XOFFS,-(maxy-BOTTEM_YOFFS));
   line1(&Window_Diag(vp),LEFT_XOFFS,-TOP_YOFFS,(lengte+LEFT_XOFFS),-TOP_YOFFS);



   /* Bepaal VSCALE m.b.v. Maximum en minimum     */


  real_data = DataReal(vp);     /* display real data */

  Window_Min(vp) = 0.0;
  Window_Max(vp) = *real_data;                       /* Min en Max bepalen */

  for(tel=0;tel < (DataLength(vp));tel++)
  {
    if (*real_data > Window_Max(vp)) Window_Max(vp)=*real_data;
    real_data++;
   }
   real_data = DataReal(vp);

   Max_abs = 100; /* verschil tussen minimum en maximum in %  */
   aantaltxt = (int)11;
   afstand = -hoogte/(aantaltxt-1);
   delta_n = 10;
   
   Window_VScale(vp) = Window_Max(vp)/(hoogte);
   
  for(tel=0;tel < aantaltxt;tel++)
  {
    ywaarde[tel]=(int)(100-delta_n*tel);
    sprintf(ch,"%7d",ywaarde[tel]);
    text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE-2,FONT_SIZE-2,(LEFT_XOFFS-80),(int)(tel*afstand-TOP_YOFFS-5),ch); 
  }

  sprintf(ch,"%%");
  text(&Window_Diag(vp),(char)FONT_NUMBER,FONT_SIZE,FONT_SIZE,(LEFT_XOFFS),(-TOP_YOFFS+10),ch); 
  
  set_draw_colour(MED_GREY);
  for(tel=1;tel < aantaltxt-1;tel++)
  {
    line1(&Window_Diag(vp),LEFT_XOFFS+1,(tel*afstand-TOP_YOFFS),lengte+LEFT_XOFFS-1,(tel*afstand-TOP_YOFFS)); 
  }

  lose_font();

  if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
  {
    draw_show_error("gen_hist_background",&err);
  }
}

/********************************************************************************/

void gen_hist_plot(VENSTER *vp)
{ 
  int   i,nul_offs,hoogte;
  draw_error err;
  double vscale,hscale,cscale;
  SAMPLE *s;                         /* pointer naar te displayen data */
  SAMPLE *temp,*cum,*tempadres;                  /* tijdelijke copy voor scalen */

  

  vscale=Window_VScale(vp);
  hscale=Window_HScale(vp);
  hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;


  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_hist_plot: heap_alloc failed\r");
  

  cum = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (cum == NULL)
  werr (1,"Error in gen_hist_plot: heap_alloc failed\r");
 

  tempadres = temp; 
  s = DataReal(vp);     /* display real data */

/* Welk record displayen? */

   s = s + (Window_Channel(vp)*DataRecords(vp) + Window_Record(vp))*DataLength(vp);
  
   for(i=0;i < (DataLength(vp));i++)
      {
       *temp=*s;
       temp++;
       s++;
      }
   
   temp = tempadres;


   cum[0]=temp[0];
   for(i=0; i < (DataLength(vp));i++)
     {
      if (i > 0)
        cum[i]=cum[i-1]+temp[i];
      temp[i]= (temp[i]/vscale);
     }
  cscale=cum[DataLength(vp)-1]/hoogte;

  nul_offs = hoogte+TOP_YOFFS;
  set_draw_colour(BLUE);
 for(i=0;i < (DataLength(vp));i++)
   {
   line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
   }

 set_draw_colour(GREEN);
 for(i=0;i < (DataLength(vp)-1);i++)
   {
  line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)((cum[i]/cscale)-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)((cum[i+1]/cscale)-nul_offs));
   }


if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
 {
    draw_show_error("gen_hist_plot",&err);
 }
heap_free(cum);
heap_free(temp); 

}


/**************************************************************************************/
/* Genereer het DRAW-Object voor het te plotten signaal                               */
/**************************************************************************************/


void gen_signal_plot(VENSTER *vp)
{ 
  int   i,nul_offs,hoogte;
  draw_error err;
  double vscale,hscale;
  SAMPLE *s;                     /* pointer naar te displayen data */
  SAMPLE *temp,*tempadres;                  /* tijdelijke copy voor scalen */

  

  vscale=Window_VScale(vp);
  hscale=Window_HScale(vp);
  hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;


  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_signal_plot: heap_alloc failed\r");
  
  tempadres = temp; 

  if ((Window_Mode(vp)==REAL_M) || (Window_Mode(vp)==MAGN_M))
     { 
     s = DataReal(vp);     /* display real data */
     }

  if (Window_Mode(vp)==IMAG_M)
     {
     s = DataImag(vp);     /* display imaginary data */
     }   

/* Welk record displayen? */

   s = s + (Window_Channel(vp)*DataRecords(vp) + Window_Record(vp))*DataLength(vp);
  
/*   wprintf("Signal %s, Channel %d, Record %d\n",DataSignalName(vp),Window_Channel(vp),Window_Record(vp)); */

   for(i=0;i < (DataLength(vp));i++)
      {
       *temp=*s;
       temp++;
       s++;
      }
   
   temp = tempadres;

   for(i=0; i < (DataLength(vp));i++)
     {
      temp[i]= (temp[i]/vscale);
     }

switch (DataDomain(vp))
{
case TIME:  
  nul_offs = hoogte/2+TOP_YOFFS;
  set_draw_colour(RED);

  if (!bon)
  {
    for(i=0;i < (DataLength(vp)-1);i++)
    {
      line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(temp[i+1]-nul_offs));
    }
  }
  else
  {
  for(i=0;i < (DataLength(vp));i++)
    {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
    }
  }
  break;

case FREQ:
  nul_offs = TOP_YOFFS+(Window_Max(vp)/Window_VScale(vp));
  set_draw_colour(GREEN);

  if (!bon)
  {
  for(i=0;i < (DataLength(vp)-1);i++)
    {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(temp[i+1]-nul_offs));   
    } 
  }
  else
  for(i=0;i < (DataLength(vp));i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
  }

  break;
case MAGN:
  nul_offs = hoogte/2+TOP_YOFFS;
  set_draw_colour(RED);

  if(!bon)
  {
    for(i=0;i < (DataLength(vp)-1);i++)
    {
      line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(temp[i+1]-nul_offs));
    }
   }
   else
   {
     for(i=0;i < (DataLength(vp));i++)
     {
     line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
     }
   }
   break;
default:
  break;
}

if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
 {
    draw_show_error("gen_signal_plot",&err);
 }

heap_free(temp); 

}

/***************************************************************************/
/* gen_bode_plot(VENSTER *vp,int mid_type)
 * plot de signalen voor het bodediagram                                   */

void gen_bode_plot(VENSTER *vp,int mid_type)
{ 
  int   i,j,nul_offs,hoogte, mag_hoogte,phase_hoogte,mag_top_offs,Max_abs;
  unsigned int data_nr, offs;
  draw_error err;
  double vscale,hscale;
  SAMPLE *real_data, *imag_data;       /* pointer naar te displayen data */
  SAMPLE *temp, *cum1, *cum2;                  /* tijdelijke copy voor scalen */

  vscale=Window_VScale(vp);
  hscale=Window_HScale(vp);
  hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;


  mag_hoogte = SIGNAL_HOOGTE;
  phase_hoogte = (int)(SIGNAL_HOOGTE/PH_MAG);  
  mag_top_offs = phase_hoogte + 2*TOP_YOFFS;


  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_bode_plot: heap_alloc failed\r");
  
  cum1 = (SAMPLE *) calloc(DataLength(vp),sizeof(SAMPLE));
  if (cum1 == NULL)
  werr (1,"Error in gen_bode_plot: calloc failed\r");
 
  cum2 = (SAMPLE *) calloc(DataLength(vp),sizeof(SAMPLE));
  if (cum2 == NULL)
  werr (1,"Error in gen_bode_plot: calloc failed\r");   

/* genereer magnitude gedeelte */


  real_data = DataReal(vp);     /* display real data */
  imag_data = DataImag(vp);     /* display imaginary data */

/* Bereken de offset van het te displayen channel */

  offs = Window_Channel(vp)*DataRecords(vp)*DataLength(vp);

/*  wprintf("Signal %s, Channel %d\n",DataSignalName(vp),Window_Channel(vp)); */

  if (mid_type == 0)
  {
  for (j=0; j < DataRecords(vp);j++)

   { 

    for (i=0;i < DataLength(vp);i++)
    { 
      data_nr = offs+i+j*DataLength(vp);                              
      /* Bepaal de magnitude */
      temp[i] = sqrt(pow(real_data[data_nr],2) + pow(imag_data[data_nr],2)); 
      /* Tel de magnitudes bij elkaar op */
      cum1[i] = cum1[i] + temp[i];
    }

   }

  for (i=0;i < DataLength(vp);i++)
  cum1[i]=10*log10(cum1[i]/(double)(DataRecords(vp)))/Window_VScale(vp);

  }

                                              

  if (mid_type == 1)
  {
  for (j=0; j < DataRecords(vp);j++)
    for (i=0;i < DataLength(vp);i++)
    { 
      /* Tel de records bij elkaar op */
      cum1[i] = cum1[i] + (real_data[offs + i+j*DataLength(vp)]); 
      cum2[i] = cum2[i] + (imag_data[offs + i+j*DataLength(vp)]);
    }
    for (i=0;i < DataLength(vp);i++)
    {                                         
      /* Deel door het aantal records */
      cum1[i]=cum1[i]/(double)(DataRecords(vp));
      cum2[i]=cum2[i]/(double)(DataRecords(vp));
      cum1[i]=10*log10( sqrt( pow(cum1[i],2) + pow(cum2[i],2))) / Window_VScale(vp);
    }

  }


nul_offs = mag_top_offs+(Window_Max(vp)/Window_VScale(vp));

set_draw_colour(GREEN);

if (!bon)
{         
  for(i=0;i < (DataLength(vp)-1);i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(cum1[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(cum1[i+1]-nul_offs));   
  }
}
else
{
 for(i=0;i < (DataLength(vp));i++)
 {
   line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)-(hoogte+TOP_YOFFS) ,(int)(hscale*i+LEFT_XOFFS),(int)(cum1[i]-nul_offs));   
 }
}

/* genereer phase gedeelte  */

Window_Max(vp)=PHASE_MAX;
Window_Min(vp)=PHASE_MIN;

Max_abs = Window_Max(vp)-Window_Min(vp); /* verschil tussen minimum en maximum */
Window_VScale(vp) = Max_abs/(double)(phase_hoogte);


/*
wprintf("Max: %d , Window_VS(vp): %f , ph_h %d \n",Max_abs,Window_VScale(vp),phase_hoogte);
*/
for (i=0;i < DataLength(vp);i++) cum1[i] = 0;

 if (mid_type == 0)
  {
  for (j=0; j < DataRecords(vp);j++)

   { 
    for (i=0;i < DataLength(vp);i++)
    { 
      data_nr = offs+i+j*DataLength(vp);                              
      temp[i] = (180/PI)*atan2(imag_data[data_nr],real_data[data_nr]); 
      cum1[i] = cum1[i] + temp[i];
    }
   }

  for (i=0;i < DataLength(vp);i++)
  cum1[i]=(cum1[i]/DataRecords(vp))/Window_VScale(vp);


 }
    if (mid_type == 1)
  {
  for (j=0; j < DataRecords(vp);j++)
    for (i=0;i < DataLength(vp);i++)
    { 
      temp[i] = (real_data[offs + i+j*DataLength(vp)]); 
      cum1[i] = cum1[i] + temp[i];
      temp[i] = (imag_data[offs + i+j*DataLength(vp)]);
      cum2[i] = cum2[i] + temp[i];
    }
    for (i=0;i < DataLength(vp);i++)
    {
      cum1[i] = cum1[i]/DataRecords(vp);
      cum2[i] = cum2[i]/DataRecords(vp);
      
      cum1[i]= (180/PI)*atan2(cum2[i],cum1[i])/Window_VScale(vp);
    }

  }



nul_offs = TOP_YOFFS+(Window_Max(vp)/Window_VScale(vp));

set_draw_colour(GREEN);

if(!bon)
{
  for(i=0;i < (DataLength(vp)-1);i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(cum1[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(cum1[i+1]-nul_offs));   
  }
}
else
{
 for(i=0;i < (DataLength(vp));i++)
 {
   line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(cum1[i]-nul_offs));   
 }
}

if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
 {
    draw_show_error("gen_bode_plot",&err);
 }

free(cum2);                         
free(cum1);
heap_free(temp);                      


}

/*****************************************************************************/

void gen_magnitude_plot(VENSTER *vp,int mid_type)
{ 
  int   i,nul_offs,hoogte;
  draw_error err;
  double vscale,hscale;
  SAMPLE *real_data;       /* pointer naar te displayen data */
  SAMPLE *temp;                  /* tijdelijke copy voor scalen */

  vscale=Window_VScale(vp);
  hscale=Window_HScale(vp);
  hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;

  temp = (SAMPLE *) heap_alloc((unsigned int)DataLength(vp)*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_magnitude_plot: heap_alloc failed\r");

  real_data = DataReal(vp);     /* display real data */

/* Bereken het adres van het channel dat je wil zien. */

  real_data = real_data + (Window_Channel(vp)*DataRecords(vp)+Window_Record(vp))*DataLength(vp); 

/*  wprintf("Signal %s, Channel %d\n",DataSignalName(vp),Window_Channel(vp)); */

  if (Window_Log(vp))
  {
  for (i=0;i < DataLength(vp);i++)
      temp[i]=(10*log10(real_data[i]))/Window_VScale(vp);
  }
  else
  {
  for (i=0;i < DataLength(vp);i++)
      temp[i]=((real_data[i]))/Window_VScale(vp);
  }  

nul_offs = TOP_YOFFS+(Window_Max(vp)/Window_VScale(vp));

set_draw_colour(GREEN);

if (!bon)
{
  for(i=0;i < (DataLength(vp)-1);i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(temp[i+1]-nul_offs));   
  }
}
else
{
  for(i=0;i < (DataLength(vp));i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)-(hoogte+TOP_YOFFS) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
  }
}


if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
 {
    draw_show_error("gen_magnitude_plot",&err);
 }

heap_free(temp);
}

/***************************************************************************/

void gen_phase_plot(VENSTER *vp,int mid_type)
{ 
  int   i,nul_offs,hoogte;
  draw_error err;
  double vscale,hscale;
  SAMPLE *real_data;       /* pointer naar te displayen data */
  SAMPLE *temp;                  /* tijdelijke copy voor scalen */

  vscale=Window_VScale(vp);
  hscale=Window_HScale(vp);
  hoogte=Window_Height(vp) - TOP_YOFFS - BOTTEM_YOFFS;


  temp = (SAMPLE *) heap_alloc((unsigned int)(DataLength(vp)*DataRecords(vp))*sizeof(SAMPLE));
  if (temp == NULL)
  werr (1,"Error in gen_phase_plot: heap_alloc failed\r");
  
   
  real_data = DataReal(vp);     /* display real data */

/* Bereken het adres van het channel dat je wil zien. 
   In het fase domein bevatten channels altijd maar 1 record */

  real_data = real_data + Window_Channel(vp)*DataRecords(vp)*DataLength(vp); 

/*  wprintf("Signal: %s, Channel: %d\n",DataSignalName(vp),Window_Channel(vp));
  wprintf("VSCALE : %g \n",Window_VScale(vp)); */


  for (i=0;i < DataLength(vp);i++)
    temp[i]=(real_data[i])/Window_VScale(vp);


nul_offs = TOP_YOFFS+(Window_Max(vp)/Window_VScale(vp));

set_draw_colour(GREEN);

if (!bon)
{
  for(i=0;i < (DataLength(vp)-1);i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs) ,(int)(hscale*(i+1) + LEFT_XOFFS),(int)(temp[i+1]-nul_offs));   
  }
}
else
{
  for(i=0;i < (DataLength(vp));i++)
  {
    line1(&Window_Diag(vp),(int)(hscale*i+LEFT_XOFFS),(int)(-nul_offs) ,(int)(hscale*i+LEFT_XOFFS),(int)(temp[i]-nul_offs));   
  }
}


if (!draw_verify_diag((draw_diag *)&Window_Diag(vp),&err))
 {
    draw_show_error("gen_phase_plot",&err);
 }

heap_free(temp);
}

/************************************************************************************/

void make_plot(VENSTER *vp)
{
  switch (Window_Mode(vp))
  {
  case REAL_M: 

  case IMAG_M:  if (DataDomain(vp) == TIME)
                  gen_signal_background(vp); 
                if (DataDomain(vp) == FREQ)
                  gen_freq_background(vp);
                gen_signal_plot(vp); 
                break;

  case BODE_M:  gen_bode_background(vp);
                gen_bode_plot(vp,0);
                break;
  case MAGN_M:  gen_magnitude_background(vp); 
                gen_magnitude_plot(vp,0);
                break;  
  case PHAS_M:  gen_phase_background(vp);
                gen_phase_plot(vp,0);
                break;
  case HIST_M:  gen_hist_background(vp);
                gen_hist_plot(vp);
                break;
  default:      break;
  }
}

/******************************************************/

void save_drawfile(char *filename,void *handle)
{
   os_filestr file;
   diag *diagram; 
   VENSTER * vp;
   BOOL ok;

   /* Save the entire file */
   vp=(VENSTER *)handle;
   diagram=(diag *)&Window_Diag(vp);
   draw_shift_diag((draw_diag*)diagram,0,draw_screenToDraw(1024));  

   file.action   = 0x0a;                   /* Save block and date stamp file */
   file.name     = filename;
   file.loadaddr = FILETYPE_DRAWFILE;       /* File type */
   file.start    = (int)diagram->data;
   file.end      = (int)(diagram->data + diagram->length);
   ok=(wimpt_complain(os_file(&file)) == 0);
   draw_shift_diag((draw_diag*)diagram,0,draw_screenToDraw(-1024));  
}


/* routine om een bepaalde font 'current' te maken. De fontnaam staat   */
/* in de globale variabele 'font_name'. De fonthandle wordt in de       */
/* variabele 'current_font_number' terug gezet. Voorgrondkleur is zwart */
/* achtergrond kleur is wit.                                            */


void init_plot_draw(VENSTER *vp)
{
   draw_box   box;

                                     
   plot_grid=TRUE;
   plot_abs=FALSE;
   strcpy(font_name,"Trinity.Medium"); /* zet de te gebruiken fontnaam op 'corpus.medium'.*/

   /* vraag voor de eerste keer geheugen aan voor het diagram           */
   if (Window_Diag(vp).data == NULL)
   {
      Window_Diag(vp).data   = heap_alloc(DIAGRAM_SIZE);
      if (Window_Diag(vp).data ==NULL) werr(TRUE,"Diagram alloc failed");
      Window_Diag(vp).length = 0;
      Window_Diag(vp).size = DIAGRAM_SIZE;
   }

   /* zet de omtrek van het diagram op 0,0 - 0,0. Bij het toevoegen van */
   /* lijnen wordt deze omtrek automatisch aangepast.                   */

   box.x0 = 0;
   box.y0 = 0;
   box.x1 = 0;
   box.y1 = 0;

   /* initialiseer het diagram. 'ProgName' moet de naam van het         */
   /* programma zijn dat de drawfile gegenereerd heeft.                 */

   draw_create_diag((draw_diag *)&Window_Diag(vp),"ASM",box);

   /* tijdens het aanmaken van een diagram mogen er geen fout meldingen */
   /* gegeven worden, omdat anders het scherm weer 'verstoord' wordt en */
   /* dan moet hij weer een 'redraw' gaan doen -> weer drawfile aan-    */
   /* maken -> crash. Doe dit dan ook aan het einde.                    */
}


void redo_signal(wimp_redrawstr r,BOOL more)
{
  draw_error err;
  BOOL more_to_do=more;
  wimp_redrawstr  new_r = r;
  int i,j;

  j=0;
  for (i=0;i<max_signals;i++)
   {
     if (new_r.w == Window_Handle(vp[i])) { j=i; break; }
   }

/*   draw_rebind_diag((draw_diag*)&Window_Diag(vp[j])); */
  if (!draw_verify_diag((draw_diag *)&Window_Diag(vp[j]),&err))
   {
      draw_show_error("redo_signal",&err);
   }



  while (more_to_do)
   {
      draw_render_diag((draw_diag *)&Window_Diag(vp[j]),
                       (draw_redrawstr *)&new_r,zoom,&err);
      wimp_get_rectangle(&new_r,&more_to_do);
   }
}

 void redraw_signal_window(wimp_w handle)
{
  BOOL  more;
  wimp_redrawstr r;
  wimp_winfo      winfo;
  
  winfo.w = handle;
  wimp_get_wind_info(&winfo);
  r.w = handle; 
  wimp_redraw_wind(&r, &more);
  if (more)
    redo_signal(r, more);
}

void update_signal_window(wimp_w handle)
{
  BOOL  more;
  wimp_redrawstr r;
  wimp_winfo      winfo;
  
  winfo.w = handle;
  wimp_get_wind_info(&winfo);
  r.w = handle; 
  wimp_update_wind(&r, &more);
  if (more)
    redo_signal(r, more);

}


  

void open_signal_window(wimp_openstr *o)
{
  static int old_x, old_y;
  
  /* --- force scroll offsets to 0, since the window always --- */
  /* --- represents the whole display                       --- */


  wimp_open_wind(o);

  /* --- only do a redraw if the size of the window has changed --- */

    if (old_x != (o->box.x1 - o->box.x0) || old_y != (o->box.y1 - o->box.y0))
    {
      old_x = o->box.x1 - o->box.x0;
      old_y = o->box.y1 - o->box.y0;
      update_signal_window(o->w);
    }
}  





void display_signal_plot(VENSTER *vp)
 { 
   wimp_wstate state;
   wimp_redrawstr r;
   wimp_winfo winfo;

   winfo.w = Window_Handle(vp);
   wimpt_complain(wimp_get_wind_info(&winfo));
   r.w = Window_Handle(vp);
  
   r.box.x0 = winfo.info.ex.x0;
   r.box.x1 = Window_Width(vp);  
   r.box.y0 = -(Window_Height(vp));
   r.box.y1 = winfo.info.ex.y1;

   wimpt_complain(wimp_set_extent(&r)); 
   wimpt_noerr(wimp_get_wind_state(Window_Handle(vp),&state));
   state.o.behind=-1;
   wimp_open_wind(&state.o);
   redraw_signal_window(state.o.w);


 }

#define HSAVE 2
#define HOPT 1
#define GRID 1
#define Y_AXIS 2
#define Y_ABS 1
#define Y_REL 2


void venster_menu_proc(void *handle,char *hit)
 {
  switch(hit[0])
   {
    case 1:     /* save signal */
         saveas(0xAFF,"Signal",65535,save_drawfile,0,0,handle);
         break;
    default:
         break;
   }
}

void signal_menu_maker(void *handle)
{
  if (event_is_menu_being_recreated()==FALSE)
  {
    hsit=menu_new("ASM",">Save");
  }
}
