/* save.c */


/*
 * Vis5D system for visualizing five dimensional gridded data sets.
 * Copyright (C) 1990 - 2000 Bill Hibbard, Johan Kellum, Brian Paul,
 * Dave Santek, and Andre Battaiola.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * As a special exception to the terms of the GNU General Public
 * License, you are permitted to link Vis5D with (and distribute the
 * resulting source and executables) the LUI library (copyright by
 * Stellar Computer Inc. and licensed for distribution with Vis5D),
 * the McIDAS library, and/or the NetCDF library, where those
 * libraries are governed by the terms of their own licenses.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../config.h"


/* Graphics Save & Restore:

   The file is a list of tagged blocks.  A block starts with
   a tag and length.  If the restore function finds an unknown tag, it
   can skip the block and continue.  This provides for backward
   compatibility with future formats.

   Note:  .SAVE files are written with native byte ordering.  That is,
   a .SAVE file made on a little endian computer (DEC) can't be read on
   a big endian computer (SGI), and vice-versa.
*/



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "api.h"
#include "globals.h"
#include "grid.h"
#include "memory.h"
#include "misc.h"
#include "sync.h"
#include "topo.h"
#include "labels.h"


#ifndef SEEK_SET
#  define SEEK_SET 0
#endif
#ifndef SEEK_CUR
#  define SEEK_CUR 1
#endif



#define INT_1_SIZE  sizeof(int_1)
#define UINT_1_SIZE sizeof(uint_1)
#define INT_2_SIZE  sizeof(int_2)
#define UINT_2_SIZE sizeof(uint_2)
#define UINT_4_SIZE sizeof(uint_4)
#define INT_SIZE    sizeof(int)
#define UINT_SIZE   sizeof(unsigned int)
#define FLOAT_SIZE  sizeof(float)


#define TAG_SIZE 4

#define TAG_ISO_COLOR        11
#define TAG_HSLICE_COLOR     12
#define TAG_VSLICE_COLOR     13
#define TAG_CHSLICE_COLORS   14
#define TAG_CVSLICE_COLORS   15
#define TAG_TRAJ_COLOR       16
#define TAG_HWIND_COLOR      18
#define TAG_VWIND_COLOR      19
#define TAG_VOLUME_COLORS    20
#define TAG_HSTREAM_COLOR    21
#define TAG_ISO_COLOR_TABLE  22
#define TAG_VSTREAM_COLOR    23


#define TAG_CTM              30
#define TAG_LABEL            31
#define TAG_TOPO_COLORS      32
#define TAG_CLONE_TABLE      33   /* Obsolete, don't use */
#define TAG_OBS_34           34   /* OBSOLETE */
#define TAG_OBS_35           35   /* OBSOLETE, was TAG_EXT_FUNC */
#define TAG_VAR_TABLE_41     36
#define TAG_EXT_FUNC         37
#define TAG_EXPRESSION       38
#define TAG_VAR_TABLE        39

#define TAG_ISO_LEVEL        40
#define TAG_HSLICE_POS       41
#define TAG_VSLICE_POS       42
#define TAG_CHSLICE_POS      43
#define TAG_CVSLICE_POS      44
#define TAG_HWIND_POS        45
#define TAG_VWIND_POS        46
#define TAG_HSTREAM_POS      47
#define TAG_VSTREAM_POS      48

#define TAG_HSLICE           60
#define TAG_VSLICE           61
#define TAG_CHSLICE          62
#define TAG_CVSLICE          63
#define TAG_HWIND            64
#define TAG_VWIND            65
#define TAG_ISOSURF          66
#define TAG_TRAJ             67
#define TAG_HSTREAM          68
#define TAG_COLORED_ISOSURF  69
#define TAG_VSTREAM          70



/**
*** IMPORTANT:  If you add new tags, use new numbers which are higher than
*** existing tags since lower number ones may have been used in the past
*** and are now obsolete.
***/


#define FWRITE( BUF, SIZE, ITEMS, F )  if (fwrite(BUF,SIZE,ITEMS,F)!=ITEMS) { \
                                          fclose(F);              \
                                          /* unlock graphics */   \
                                          LOCK_OFF( GfxLock );    \
                                          return VIS5D_FAIL;      \
                                       }

#define WRITE_TAG( F, T )        fwrite( &T, sizeof(int), 1, F )
#define WRITE_INTS( F, I, N )    fwrite( I, sizeof(int), N, F )
#define WRITE_FLOATS( F, X, N )  fwrite( X, sizeof(float), N, F )
#define WRITE_BYTES( F, B, N )   fwrite( B, 1, N, f )

#define READ_INTS( F, I, N )     fread( I, sizeof(int), N, F )
#define READ_FLOATS( F, X, N )   fread( X, sizeof(int), N, F )
#define READ_BYTES( F, B, N )    fread( B, 1, N, F )


/* skip 'n' bytes in file 'f' */
static void skip( FILE *f, int n )
{
   if (n>0) {
      fseek( f, n, SEEK_CUR );
   }
}


static long start_pos = 0; /* position in file where block length is stored */



/*
 * Call this function before writing a block of "SAVE/RESTORE" data.
 */
static void begin_block( FILE *f, int tag )
{
   int zero = 0;

   if (start_pos) {
      printf("Error in begin_block()\n");
      return;
   }
   WRITE_INTS( f, &tag, 1 );   /* write the tag */
   start_pos = ftell( f );
   WRITE_INTS( f, &zero, 1 );   /* dummy length field to be filled in later */
}


/*
 * Call this function after writing a block of "SAVE/RESTORE" data.
 * Return:  number of bytes written between begin_block() and end_block()
 */
static int end_block( FILE *f )
{
   long end_pos;
   int length;

   if (start_pos==0) {
      printf("Error in end_block()\n");
      return 0;
   }
   end_pos = ftell( f );
   length = end_pos - start_pos - 4;
   fseek( f, start_pos, SEEK_SET );
   WRITE_INTS( f, &length, 1 );
   fseek( f, end_pos, SEEK_SET );
   start_pos = 0;

   return length;
}




static int save_isosurfaces( Context ctx, FILE *f )
{

   int iv, it;
   int neg_one = -1;

   for (iv=0;iv<ctx->NumVars;iv++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->Variable[iv]->SurfTable[it]->valid) {
            int numverts, numindex;

            begin_block( f, TAG_COLORED_ISOSURF );

            numverts = ctx->Variable[iv]->SurfTable[it]->numverts;
            numindex = ctx->Variable[iv]->SurfTable[it]->numindex;

            /* isosurface data */
            FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
            FWRITE( &it, INT_SIZE, 1, f );  /* time */
            FWRITE( &ctx->Variable[iv]->SurfTable[it]->isolevel, FLOAT_SIZE, 1, f );
            FWRITE( &numverts, INT_SIZE, 1, f );  /* number of vertices */
            FWRITE( &numindex, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->SurfTable[it]->verts, INT_2_SIZE, 3*numverts, f );
            FWRITE( ctx->Variable[iv]->SurfTable[it]->norms, INT_1_SIZE, 3*numverts, f );
#ifdef BIG_GFX
            FWRITE( ctx->Variable[iv]->SurfTable[it]->index, UINT_4_SIZE, numindex, f );
#else
            FWRITE( ctx->Variable[iv]->SurfTable[it]->index, UINT_2_SIZE, numindex, f );
#endif
            if (ctx->Variable[iv]->SurfTable[it]->colors) {
               FWRITE( &ctx->Variable[iv]->SurfTable[it]->colorvar, INT_SIZE, 1, f );
               FWRITE( ctx->Variable[iv]->SurfTable[it]->colors, UINT_1_SIZE,
                       numverts, f );
            }
            else {
               FWRITE( &neg_one, INT_SIZE, 1, f );
            }

            end_block(f);
         }
      }
   }

   return 0;
}

#ifdef LEAVEOUT

static int save_iso_colors( Context ctx, FILE *f )
{
   int iv;

   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_ISO_COLOR );
      FWRITE( &iv, INT_SIZE, 1, f );
/* YO Color and the rest of these! */
      FWRITE( &ctx->dpy_ctx->Color[iv][ISOSURF], UINT_SIZE, 1, f );
      end_block(f);
   }
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_ISO_COLOR_TABLE );
      FWRITE( &iv, INT_SIZE, 1, f );
      FWRITE( &ctx->dpy_ctx->ColorTable[VIS5D_ISOSURF_CT]->Colors[iv], UINT_SIZE, 256, f );
      end_block(f);
   }
   return 0;
}


static int save_iso_level( Context ctx, FILE *f )
{
   int iv;
   
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_ISO_LEVEL );
      WRITE_INTS( f, &iv, 1 );
      WRITE_FLOATS( f, &ctx->IsoLevel[iv], 1 );
      end_block(f);
   }
   return 0;
}

#endif

static int save_hslices( Context ctx, FILE *f )
{
   int iv, it;
   int num1, num2, num3, num4;

   for (iv=0;iv<ctx->NumVars;iv++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->Variable[iv]->HSliceTable[it] && ctx->Variable[iv]->HSliceTable[it]->valid) {
            begin_block( f, TAG_HSLICE );
            num1 = ctx->Variable[iv]->HSliceTable[it]->num1;
            num2 = ctx->Variable[iv]->HSliceTable[it]->num2;
            num3 = ctx->Variable[iv]->HSliceTable[it]->num3;
            num4 = ctx->Variable[iv]->HSliceTable[it]->numboxverts;
            /* contour line data */
            FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
            FWRITE( &it, INT_SIZE, 1, f );  /* time */
            FWRITE( &ctx->Variable[iv]->HSliceTable[it]->interval, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->HSliceTable[it]->lowlimit, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->HSliceTable[it]->highlimit, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->HSliceTable[it]->level, FLOAT_SIZE, 1, f );
            FWRITE( &num1, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->HSliceTable[it]->verts1, INT_2_SIZE, 3*num1, f );
            FWRITE( &num2, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->HSliceTable[it]->verts2, INT_2_SIZE, 3*num2, f );
            FWRITE( &num3, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->HSliceTable[it]->verts3, INT_2_SIZE, 3*num3, f );
            FWRITE( &num4, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->HSliceTable[it]->boxverts, 3*FLOAT_SIZE, num4, f );
            end_block(f);
         }
      }
   }
   return 0;
}

#ifdef LEAVEOUT
static int save_hslice_colors( Context ctx, FILE *f )
{
   int iv;

   /* Save horizontal contour line slice colors */
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_HSLICE_COLOR );
      FWRITE( &iv, INT_SIZE, 1, f );
      FWRITE( &ctx->dpy_ctx->Color[iv][HSLICE], UINT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}


static int save_hslice_pos( Context ctx, FILE *f )
{
   int iv;

   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_HSLICE_POS );
      WRITE_INTS( f, &iv, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->HSliceRequest->Interval, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->HSliceRequest->LowLimit, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->HSliceRequest->HighLimit, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->HSliceRequest->Level, 1 );
      end_block(f);
   }
   return 0;
}
#endif

static int save_vslices( Context ctx, FILE *f )
{
   int iv, it;
   int num1, num2, num3, num4;
   for (iv=0;iv<ctx->NumVars;iv++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->Variable[iv]->VSliceTable[it]->valid) {
            begin_block( f, TAG_VSLICE );
            num1 = ctx->Variable[iv]->VSliceTable[it]->num1;
            num2 = ctx->Variable[iv]->VSliceTable[it]->num2;
            num3 = ctx->Variable[iv]->VSliceTable[it]->num3;
            num4 = ctx->Variable[iv]->VSliceTable[it]->numboxverts;
            /* contour line data */
            FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
            FWRITE( &it, INT_SIZE, 1, f );  /* time */
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->interval, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->lowlimit, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->highlimit, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->r1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->c1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->r2, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->VSliceTable[it]->c2, FLOAT_SIZE, 1, f );
            FWRITE( &num1, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->VSliceTable[it]->verts1, INT_2_SIZE, 3*num1, f );
            FWRITE( &num2, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->VSliceTable[it]->verts2, INT_2_SIZE, 3*num2, f );
            FWRITE( &num3, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->VSliceTable[it]->verts3, INT_2_SIZE, 3*num3, f );
            FWRITE( &num4, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->VSliceTable[it]->boxverts, 3*FLOAT_SIZE, num4, f );
            end_block(f);
         }
      }
   }
   return 0;
}

#ifdef LEAVEOUT

static int save_vslice_colors( Context ctx, FILE *f )
{
   int iv;

   /* save vertical contour slice colors */
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_VSLICE_COLOR );
      FWRITE( &iv, INT_SIZE, 1, f );
      FWRITE( &ctx->dpy_ctx->Color[iv][VSLICE], UINT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}



static int save_vslice_pos( Context ctx, FILE *f )
{
   int iv;
     
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_VSLICE_POS );
      WRITE_INTS( f, &iv, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->Interval, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->LowLimit, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->HighLimit, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->R1, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->R2, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->C1, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->VSliceRequest->C2, 1 );
      end_block(f);
   }
   return 0;
}

#endif

static int save_chslices( Context ctx, FILE *f )
{
   int it, iv;
   for (iv=0;iv<ctx->NumVars;iv++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->Variable[iv]->CHSliceTable[it]->valid) {
            int num;
            begin_block( f, TAG_CHSLICE );
            num = ctx->Variable[iv]->CHSliceTable[it]->rows
                * ctx->Variable[iv]->CHSliceTable[it]->columns;
            FWRITE( &iv, INT_SIZE, 1, f );  
            FWRITE( &it, INT_SIZE, 1, f );  
            FWRITE( &ctx->Variable[iv]->CHSliceTable[it]->level, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CHSliceTable[it]->rows, INT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CHSliceTable[it]->columns, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->CHSliceTable[it]->verts, INT_2_SIZE, 3*num, f );
            FWRITE( ctx->Variable[iv]->CHSliceTable[it]->color_indexes, UINT_1_SIZE, num, f );
            end_block(f);
         }
      }
   }
   return 0;
}

#ifdef LEAVEOUT

static int save_chslice_colors( Context ctx, FILE *f )
{
   int iv, size;

   /* save horizontal color slice colors */
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_CHSLICE_COLORS );
      size = 256;
      /* CHSLICE colors */
      FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
      FWRITE( &ctx->dpy_ctx->Color[iv][CHSLICE], UINT_SIZE, 1, f );
      FWRITE( &size, INT_SIZE, 1, f );
/*Y0
      FWRITE( ctx->ColorTable[VIS5D_CHSLICE_CT]->Colors[iv], UINT_SIZE, size, f );
*/
      end_block(f);
   }
   return 0;
}


static int save_chslice_pos( Context ctx, FILE *f )
{
   int iv;

   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_CHSLICE_POS );
      WRITE_INTS( f, &iv, 1 );  
      WRITE_FLOATS( f, &ctx->Variable[iv]->CHSliceRequest->Level, 1 );
      end_block(f);
   }
   return 0;
}

#endif

static int save_cvslices( Context ctx, FILE *f )
{
   int iv, it;

   for (iv=0;iv<ctx->NumVars;iv++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->Variable[iv]->CVSliceTable[it]->valid) {
            int num;
            begin_block( f, TAG_CVSLICE );
            num = ctx->Variable[iv]->CVSliceTable[it]->rows
                * ctx->Variable[iv]->CVSliceTable[it]->columns;
            FWRITE( &iv, INT_SIZE, 1, f );
            FWRITE( &it, INT_SIZE, 1, f );  
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->r1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->c1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->r2, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->c2, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->rows, INT_SIZE, 1, f );
            FWRITE( &ctx->Variable[iv]->CVSliceTable[it]->columns, INT_SIZE, 1, f );
            FWRITE( ctx->Variable[iv]->CVSliceTable[it]->verts, INT_2_SIZE, 3*num, f );
            FWRITE( ctx->Variable[iv]->CVSliceTable[it]->color_indexes, UINT_1_SIZE, num, f );
            end_block(f);
         }
      }
   }
   return 0;
}
#ifdef LEAVEOUT

static int save_cvslice_colors( Context ctx, FILE *f )
{
   int iv, size;

   /* save vertical color slice colors */
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_CVSLICE_COLORS );
      size = 256;
      /* CVSLICE colors */
      FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
/*Y0
      FWRITE( &ctx->dpy_ctx->Color[iv][CVSLICE], UINT_SIZE, 1, f );

      FWRITE( &size, INT_SIZE, 1, f );
      FWRITE( ctx->ColorTable[VIS5D_CVSLICE_CT]->Colors[iv], UINT_SIZE, size, f );
*/      end_block(f);
   }
   return 0;
}



static int save_cvslice_pos( Context ctx, FILE *f )
{
   int iv;

   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_CVSLICE_POS );
      WRITE_INTS( f, &iv, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->CVSliceRequest->R1, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->CVSliceRequest->R2, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->CVSliceRequest->C1, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->CVSliceRequest->C2, 1 );
      end_block(f);
   }
   return 0;
}


static int save_trajectories( Context ctx, FILE *f )
{
#ifdef LEAVEOUT
   int i;

   /* save trajectories */
   for (i=0;i<ctx->NumTraj;i++) {
      int length = ctx->TrajTable[i].length;
      begin_block( f, TAG_TRAJ );
      FWRITE( &ctx->TrajTable[i].length, INT_SIZE, 1, f );
      FWRITE( &ctx->TrajTable[i].group, INT_SIZE, 1, f );
      FWRITE( &ctx->TrajTable[i].kind, INT_SIZE, 1, f );
      FWRITE( &ctx->NumTimes, INT_SIZE, 1, f );
      FWRITE( ctx->TrajTable[i].verts, INT_2_SIZE, 3*length, f );
      if (ctx->TrajTable[i].kind==1) {
         FWRITE( ctx->TrajTable[i].norms, INT_1_SIZE, 3*length, f );
      }
      FWRITE( ctx->TrajTable[i].start, UINT_2_SIZE, ctx->NumTimes, f );
      FWRITE( ctx->TrajTable[i].len, UINT_2_SIZE, ctx->NumTimes, f );
      end_block(f);
   }
#endif
   return 0;
}


static int save_traj_colors( Context ctx, FILE *f )
{
   int i;

   /* save traj colors */
   for (i=0;i<VIS5D_TRAJ_SETS;i++) {
      begin_block( f, TAG_TRAJ_COLOR );
      FWRITE( &i, INT_SIZE, 1, f );
/*Y0
      FWRITE( &ctx->TrajColor[i], UINT_SIZE, 1, f );
*/
      end_block(f);
   }
   return 0;
}

#endif
/* YO

static int save_hwind( Context ctx, FILE *f )
{
   int it, nb;
   int ws;


   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->HWindTable[ws][it].valid) {
            int nvect;
            begin_block( f, TAG_HWIND );
            nvect = ctx->HWindTable[ws][it].nvectors;
            nb = ctx->HWindTable[ws][it].numboxverts;
            FWRITE( &ws, INT_SIZE, 1, f );
            FWRITE( &it, INT_SIZE, 1, f );
            FWRITE( &ctx->HWindTable[ws][it].level, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->HWindTable[ws][it].density, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->HWindTable[ws][it].scale, FLOAT_SIZE, 1, f );
            FWRITE( &nvect, INT_SIZE, 1, f );
            FWRITE( ctx->HWindTable[ws][it].verts, INT_2_SIZE, 3*4*nvect, f );
            FWRITE( &nb, INT_SIZE, 1, f );
            FWRITE( ctx->HWindTable[ws][it].boxverts, 3*FLOAT_SIZE, nb, f );
            end_block(f);
         }
      }
   }
   return 0;
}



static int save_hwind_colors( Context ctx, FILE *f )
{
   int i;

   * save horizontal wind slice colors *

   for (i=0;i<VIS5D_WIND_SLICES;i++) {
      begin_block( f, TAG_HWIND_COLOR );
      FWRITE( &i, INT_SIZE, 1, f );
      FWRITE( &ctx->HWindColor[i], UINT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}



static int save_hwind_pos( Context ctx, FILE *f )
{
   int ws;

   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      begin_block( f, TAG_HWIND_POS );
      FWRITE( &ws, INT_SIZE, 1, f );
      FWRITE( &ctx->HWindLevel[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->HWindDensity[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->HWindScale[ws], FLOAT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}




static int save_vwind( Context ctx, FILE *f )
{
   int it;
   int ws;

   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->VWindTable[ws][it].valid) {
            int nvect, nb;
            begin_block( f, TAG_VWIND );
            nvect = ctx->VWindTable[ws][it].nvectors;
            nb = ctx->VWindTable[ws][it].numboxverts;
            FWRITE( &ws, INT_SIZE, 1, f );
            FWRITE( &it, INT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].r1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].c1, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].r2, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].c2, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].density, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->VWindTable[ws][it].scale, FLOAT_SIZE, 1, f );
            FWRITE( &nvect, INT_SIZE, 1, f );
            FWRITE( ctx->VWindTable[ws][it].verts, INT_2_SIZE, 3*4*nvect, f );
            FWRITE( &nb, INT_SIZE, 1, f );
            FWRITE( ctx->VWindTable[ws][it].boxverts, 3*FLOAT_SIZE, nb, f );
            end_block(f);
         }
      }
   }
   return 0;
}


static int save_vwind_colors( Context ctx, FILE *f )
{
   int i;

   for (i=0;i<VIS5D_WIND_SLICES;i++) {
      begin_block( f, TAG_VWIND_COLOR );
      FWRITE( &i, INT_SIZE, 1, f );
      FWRITE( &ctx->VWindColor[i], UINT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}


static int save_vwind_pos( Context ctx, FILE *f )
{
   int ws;

   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      begin_block( f, TAG_VWIND_POS );
      FWRITE( &ws, INT_SIZE, 1, f );
      FWRITE( &ctx->VWindR1[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->VWindC1[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->VWindR2[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->VWindC2[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->VWindDensity[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->VWindScale[ws], FLOAT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}



static int save_hstream( Context ctx, FILE *f )
{
   int it, nb;
   int ws;

   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      for (it=0;it<ctx->NumTimes;it++) {
         if (ctx->HStreamTable[ws][it].valid) {
            int nline;
            begin_block( f, TAG_HSTREAM );
            nline = ctx->HStreamTable[ws][it].nlines;
            nb = ctx->HStreamTable[ws][it].numboxverts;
            FWRITE( &ws, INT_SIZE, 1, f );
            FWRITE( &it, INT_SIZE, 1, f );
            FWRITE( &ctx->HStreamTable[ws][it].level, FLOAT_SIZE, 1, f );
            FWRITE( &ctx->HStreamTable[ws][it].density, FLOAT_SIZE, 1, f );
            FWRITE( &nline, INT_SIZE, 1, f );
            FWRITE( ctx->HStreamTable[ws][it].verts, INT_2_SIZE, 3*nline, f );
            FWRITE( &nb, INT_SIZE, 1, f );
            FWRITE( ctx->HStreamTable[ws][it].boxverts, 3*FLOAT_SIZE, nb, f );
            end_block(f);
         }
      }
   }
   return 0;
}


static int save_hstream_colors( Context ctx, FILE *f )
{
   int i;

    save horizontal wind slice colors 
   for (i=0;i<VIS5D_WIND_SLICES;i++) {
      begin_block( f, TAG_HSTREAM_COLOR );
      FWRITE( &i, INT_SIZE, 1, f );
      FWRITE( &ctx->HStreamColor[i], UINT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}



static int save_hstream_pos( Context ctx, FILE *f )
{
   int ws;

   for (ws=0;ws<VIS5D_WIND_SLICES;ws++) {
      begin_block( f, TAG_HSTREAM_POS );
      FWRITE( &ws, INT_SIZE, 1, f );
      FWRITE( &ctx->HStreamLevel[ws], FLOAT_SIZE, 1, f );
      FWRITE( &ctx->HStreamDensity[ws], FLOAT_SIZE, 1, f );
      end_block(f);
   }
   return 0;
}

*/
#ifdef LEAVEOUT
static int save_volume_colors( Context ctx, FILE *f )
{
   int iv, size;

   /* save volume color tables */
   for (iv=0;iv<ctx->NumVars;iv++) {
      begin_block( f, TAG_VOLUME_COLORS );
      size = 256;
      /* CHSLICE colors */
      FWRITE( &iv, INT_SIZE, 1, f );  /* parm */
      FWRITE( &size, INT_SIZE, 1, f );
/* YO      FWRITE( ctx->ColorTable[VIS5D_VOLUME_CT]->Colors[iv], UINT_SIZE, size, f );
   */   end_block(f);
   }
   return 0;
}
#endif

/* YO
static int save_labels( Context ctx, FILE *f, int tag )
{
   struct label *lab;
   int bytes;

   for (lab=ctx->FirstLabel;lab;lab=lab->next) {
      fwrite( &tag, sizeof(int), 1, f );
      bytes = strlen(lab->text)+1 + 3*sizeof(int);
      fwrite( &bytes, 4, 1, f );
      fwrite( &lab->len, sizeof(int), 1, f );     * length of label *
      fwrite( lab->text, lab->len+1, 1, f );   * label text + '\0' *
      fwrite( &lab->x, sizeof(int), 1, f );       * position *
      fwrite( &lab->y, sizeof(int), 1, f );       * position *
   }
   return 0;
}
*/


/*
 * Save current graphics and colors to the 'savefile'
 * Input:  savefile - filename to save to.
 *         save_gfx - if non-zero save graphics, not just colors.
 *         save_traj - if non-zero save trajectories too.
 * Return:  0 for success,
 *          VIS5D_BAD_VALUE - if unable to open output file
 *          VIS5D_FAIL - if error while writing file.
 */
int save( Context ctx, char *savefile, int save_gfx, int save_traj )
{
   FILE *f;
   int it, iv, num;

   f = fopen(savefile,"w");
   if (!f)
      return VIS5D_BAD_VALUE;

   /* lock graphics */
   LOCK_ON( GfxLock );

   /* always save variable information */
   /* Only save information for regular variables and cloned variables. */
   /* When we find something else, stop because restoring the others */
   /* would be a major headache. */
/*
   for (num=0;num<NumVars;num++) {
      if (VarType[num]!=VIS5D_REGULAR && VarType[num]!=VIS5D_CLONE) {
         break;
      }
   }
*/
   num = ctx->NumVars;

   begin_block( f, TAG_VAR_TABLE );
   WRITE_INTS( f, &num, 1 );

   for (iv=0;iv<num;iv++) {
	  /*JPE: loop required for backword compatibility */
	  WRITE_INTS( f, &ctx->Variable[iv]->VarType, 1 );
	}
   for (iv=0;iv<num;iv++) {
	  /*JPE: loop required for backword compatibility */
	  WRITE_INTS( f, &ctx->Variable[iv]->CloneTable, 1 );
	}
   for (iv=0;iv<num;iv++) {
      WRITE_FLOATS( f, &ctx->Variable[iv]->MinVal, 1 );
      WRITE_FLOATS( f, &ctx->Variable[iv]->MaxVal, 1 );
      WRITE_BYTES( f, ctx->Variable[iv]->VarName, 10 );
      WRITE_INTS( f, &ctx->Nl[iv], 1 );
      WRITE_INTS( f, &ctx->Variable[iv]->LowLev, 1 );
   }
   end_block(f);

/*NEW*/
   /* always save external function variables */
   for (iv=0;iv<ctx->NumVars;iv++) {
      if (ctx->Variable[iv]->VarType==VIS5D_EXT_FUNC) {
         begin_block( f, TAG_EXT_FUNC );
         WRITE_INTS( f, &iv, 1 );
         WRITE_INTS( f, &ctx->NumTimes, 1 );
         for (it=0;it<ctx->NumTimes;it++) {
            float *griddata;
            griddata = get_grid( ctx, it, iv );
            WRITE_FLOATS( f, griddata, ctx->Nr*ctx->Nc*ctx->Nl[iv] );
            release_grid( ctx, it, iv, griddata );
         }
         end_block(f);
      }
   }
/*NEW*/
   /* always save type-in function variables */
   for (iv=0;iv<ctx->NumVars;iv++) {
      if (ctx->Variable[iv]->VarType==VIS5D_EXPRESSION) {
         begin_block( f, TAG_EXPRESSION );
         WRITE_INTS( f, &iv, 1 );

			/* JPE: ExpressionList is no longer fixed at 500 bytes */
			/* this may cause an error */
         WRITE_BYTES( f, ctx->Variable[iv]->ExpressionList, 500 );

         WRITE_INTS( f, &ctx->NumTimes, 1 );
         for (it=0;it<ctx->NumTimes;it++) {
            float *griddata;
            griddata = get_grid( ctx, it, iv );
            WRITE_FLOATS( f, griddata, ctx->Nr*ctx->Nc*ctx->Nl[iv] );
            release_grid( ctx, it, iv, griddata );
         }
         end_block(f);
      }
   }


   /* always save colors */
/* YO   save_iso_colors( ctx, f );
   save_hslice_colors( ctx, f );
   save_vslice_colors( ctx, f );
   save_chslice_colors( ctx, f );
   save_cvslice_colors( ctx, f );
   save_traj_colors( ctx, f );
   save_hwind_colors( ctx, f );
   save_vwind_colors( ctx, f );
   save_hstream_colors( ctx, f );
   save_volume_colors( ctx, f );
*/
   if (save_gfx || save_traj) {
      if (save_gfx) {
         /* save isosurfaces and all slices */
         save_isosurfaces( ctx, f );
         save_hslices( ctx, f );
         save_vslices( ctx, f );
         save_chslices( ctx, f );
         save_cvslices( ctx, f );
/* YO
         save_hwind( ctx, f );
         save_vwind( ctx, f );
         save_hstream( ctx, f );
*/      }
      if (save_traj) {
         /* save trajectories */
  /*       save_trajectories( ctx, f ); YO */
      }
   }
   else {
      /* save isolevels, slice positions, etc */
/*YO
      save_iso_level( ctx, f );
      save_hslice_pos( ctx, f );
      save_vslice_pos( ctx, f );
      save_chslice_pos( ctx, f );
      save_cvslice_pos( ctx, f );
      save_hwind_pos( ctx, f );
      save_vwind_pos( ctx, f );
      save_hstream_pos( ctx, f );
*/   }

   /* always save CTM */
   begin_block( f, TAG_CTM );
   /* WRITE_FLOATS( f, ctx->CTM, 16 ); YO */
   end_block( f );

   /* always save text labels */
   /* YO
save_labels( ctx, f, TAG_LABEL );
*/
   /* always save topography color table */
   begin_block( f, TAG_TOPO_COLORS );
/*   FWRITE( ctx->Topo_CT->Colors, UINT_SIZE, 256, f );  YO */
   end_block( f );

   /* unlock graphics */
   LOCK_OFF( GfxLock );

   fclose(f);
   return 0;
}



/*
 * Allocate a buffer of size 'bytes' then fill it by reading from the
 * given file.
 * Input:  ctx - the context
 *         f - the FILE pointer
 *         bytes - how many bytes to allocate and read
 * Return:  pointer to buffer of data read or NULL if error
 */
static void *alloc_and_read( Context ctx, FILE *f, int bytes )
{
   void *p;

   p = allocate( ctx, bytes );
   if (p) {
      if (fread( p, 1, bytes, f ) != bytes) {
         deallocate( ctx, p, bytes );
         p = NULL;
      }
   }
   return p;
}



static void restore_isosurf( Context ctx, FILE *f, int maxparm,
                             int blocklength )
{
   int iv, it, numverts, numindex;
   float level;

   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   fread( &level, FLOAT_SIZE, 1, f );
   fread( &numverts, INT_SIZE, 1, f );
   fread( &numindex, INT_SIZE, 1, f );
   if (iv>=ctx->NumVars || it>=ctx->NumTimes) {
#ifdef BIG_GFX
      skip(f, numverts*3*(INT_2_SIZE+INT_1_SIZE)+numindex*UINT_4_SIZE);
#else
      skip(f, numverts*3*(INT_2_SIZE+INT_1_SIZE)+numindex*UINT_2_SIZE);
#endif
      return;
   }
   recent( ctx, ISOSURF, iv );

   wait_read_lock( &ctx->Variable[iv]->SurfTable[it]->lock );

   /* deallocate old surface, if any */
   free_isosurface( ctx, it, iv );

   /* read isosurface */
   ctx->Variable[iv]->SurfTable[it]->verts = alloc_and_read(ctx,f,3*numverts*INT_2_SIZE);
   ctx->Variable[iv]->SurfTable[it]->norms = alloc_and_read(ctx,f,3*numverts*INT_1_SIZE);

#ifdef BIG_GFX
   ctx->Variable[iv]->SurfTable[it]->index = alloc_and_read(ctx,f,numindex*UINT_4_SIZE);
#else
   ctx->Variable[iv]->SurfTable[it]->index = alloc_and_read(ctx,f,numindex*UINT_2_SIZE);
#endif
   ctx->Variable[iv]->SurfTable[it]->isolevel = level;
   ctx->Variable[iv]->SurfTable[it]->numverts = numverts;
   ctx->Variable[iv]->SurfTable[it]->numindex = numindex;
   ctx->Variable[iv]->SurfTable[it]->colorvar = -1;
   ctx->Variable[iv]->SurfTable[it]->colors = NULL;
   ctx->Variable[iv]->SurfTable[it]->valid = 1;
   ctx->IsoLevel[iv] = level;
     
   done_read_lock( &ctx->Variable[iv]->SurfTable[it]->lock );
   return;
}




static void restore_colored_isosurf( Context ctx, FILE *f, int maxparm,
                                     int blocklength )
{
   int iv, it, numverts, numindex;
   float level;

   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   fread( &level, FLOAT_SIZE, 1, f );
   fread( &numverts, INT_SIZE, 1, f );
   fread( &numindex, INT_SIZE, 1, f );
   if (iv>=ctx->NumVars || it>=ctx->NumTimes) {
#ifdef BIG_GFX
      skip(f, numverts*3*(INT_2_SIZE+INT_1_SIZE)+numindex*UINT_4_SIZE);
#else
      skip(f, numverts*3*(INT_2_SIZE+INT_1_SIZE)+numindex*UINT_2_SIZE);
#endif
      return;
   }
   recent( ctx, ISOSURF, iv );

   wait_read_lock( &ctx->Variable[iv]->SurfTable[it]->lock );

   /* deallocate old surface, if any */
   free_isosurface( ctx, it, iv );

   /* read isosurface */
   ctx->Variable[iv]->SurfTable[it]->verts = alloc_and_read(ctx,f,3*numverts*INT_2_SIZE);
   ctx->Variable[iv]->SurfTable[it]->norms = alloc_and_read(ctx,f,3*numverts*INT_1_SIZE);

#ifdef BIG_GFX
   ctx->Variable[iv]->SurfTable[it]->index = alloc_and_read(ctx,f,numindex*UINT_4_SIZE);
#else
   ctx->Variable[iv]->SurfTable[it]->index = alloc_and_read(ctx,f,numindex*UINT_2_SIZE);
#endif
   fread( &ctx->Variable[iv]->SurfTable[it]->colorvar, INT_SIZE, 1, f );
   if (ctx->Variable[iv]->SurfTable[it]->colorvar>-1) {
      ctx->Variable[iv]->SurfTable[it]->colors = alloc_and_read(ctx,f,numverts*UINT_1_SIZE);
   }
   else {
      ctx->Variable[iv]->SurfTable[it]->colors = NULL;
   }

   ctx->Variable[iv]->SurfTable[it]->isolevel = level;
   ctx->Variable[iv]->SurfTable[it]->numverts = numverts;
   ctx->Variable[iv]->SurfTable[it]->numindex = numindex;
   ctx->Variable[iv]->SurfTable[it]->valid = 1;
   ctx->IsoLevel[iv] = level;
     
   done_read_lock( &ctx->Variable[iv]->SurfTable[it]->lock );
   return;
}




static void restore_hslice( Context ctx, FILE *f, int maxparm,
                            int blocklength )
{

   int iv, it, num1, num2, num3, num4;
   float interval, low, high, level;
   Display_Context dtx;

   
   dtx = ctx->dpy_ctx;
   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   fread( &interval, FLOAT_SIZE, 1, f );
   fread( &low, FLOAT_SIZE, 1, f );
   fread( &high, FLOAT_SIZE, 1, f );
   fread( &level, FLOAT_SIZE, 1, f );

   recent( ctx, HSLICE, iv );

	if(!ctx->Variable[iv]->HSliceTable[it]){
	  printf("Error HSlice not allocated for var=%d time=%d\n",iv,it);
	  return;
	}

   wait_read_lock( &ctx->Variable[iv]->HSliceTable[it]->lock );

   /* deallocate old slice, if any */
   free_hslice( ctx, it, iv );
            
   fread( &num1, INT_SIZE, 1, f );
   ctx->Variable[iv]->HSliceTable[it]->num1 = num1;
   ctx->Variable[iv]->HSliceTable[it]->verts1 = alloc_and_read(ctx,f,3*num1*INT_2_SIZE);

   fread( &num2, INT_SIZE, 1, f );
   ctx->Variable[iv]->HSliceTable[it]->num2 = num2;
   ctx->Variable[iv]->HSliceTable[it]->verts2 = alloc_and_read(ctx,f,3*num2*INT_2_SIZE);
            
   fread( &num3, INT_SIZE, 1, f );
   ctx->Variable[iv]->HSliceTable[it]->num3 = num3;
   ctx->Variable[iv]->HSliceTable[it]->verts3 = alloc_and_read(ctx,f,3*num3*INT_2_SIZE);
            
   fread( &num4, INT_SIZE, 1, f );
   ctx->Variable[iv]->HSliceTable[it]->numboxverts = num4;
   ctx->Variable[iv]->HSliceTable[it]->boxverts = alloc_and_read(ctx,f,num4*3*FLOAT_SIZE);

   ctx->Variable[iv]->HSliceTable[it]->interval = interval;
   ctx->Variable[iv]->HSliceTable[it]->lowlimit = low;
   ctx->Variable[iv]->HSliceTable[it]->highlimit = high;
   ctx->Variable[iv]->HSliceTable[it]->level = level;
   ctx->Variable[iv]->HSliceTable[it]->valid = 1;
   ctx->Variable[iv]->HSliceRequest->Interval = interval;
   ctx->Variable[iv]->HSliceRequest->LowLimit = low;
   ctx->Variable[iv]->HSliceRequest->HighLimit = high;
   ctx->Variable[iv]->HSliceRequest->Level = level;

/* YO     new_hslice_pos( dtx, level, &ctx->Variable[iv]->HSliceRequest->Z, &ctx->Variable[iv]->HSliceRequest->Hgt );*/

   done_read_lock( &ctx->Variable[iv]->HSliceTable[it]->lock );
   return;
}



static void restore_vslice( Context ctx, FILE *f, int maxparm,
                            int blocklength )
{

   int iv, it, num1, num2, num3, num4;
   float interval, low, high, r1,c1, r2,c2;
   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   fread( &interval, FLOAT_SIZE, 1, f );
   fread( &low, FLOAT_SIZE, 1, f );
   fread( &high, FLOAT_SIZE, 1, f );
   fread( &r1, FLOAT_SIZE, 1, f );
   fread( &c1, FLOAT_SIZE, 1, f );
   fread( &r2, FLOAT_SIZE, 1, f );
   fread( &c2, FLOAT_SIZE, 1, f );
             
   recent( ctx, VSLICE, iv );
   wait_read_lock( &ctx->Variable[iv]->VSliceTable[it]->lock );

   /* deallocate old slice, if any */
   free_vslice( ctx, it, iv );
             
   fread( &num1, INT_SIZE, 1, f );
   ctx->Variable[iv]->VSliceTable[it]->num1 = num1;
   ctx->Variable[iv]->VSliceTable[it]->verts1 = alloc_and_read(ctx,f,3*num1*INT_2_SIZE);
     
   fread( &num2, INT_SIZE, 1, f );
   ctx->Variable[iv]->VSliceTable[it]->num2 = num2;
   ctx->Variable[iv]->VSliceTable[it]->verts2 = alloc_and_read(ctx,f,3*num2*INT_2_SIZE);
             
   fread( &num3, INT_SIZE, 1, f );
   ctx->Variable[iv]->VSliceTable[it]->num3 = num3;
   ctx->Variable[iv]->VSliceTable[it]->verts3 = alloc_and_read(ctx,f,3*num3*INT_2_SIZE);

   fread( &num4, INT_SIZE, 1, f );
   ctx->Variable[iv]->VSliceTable[it]->numboxverts = num4;
   ctx->Variable[iv]->VSliceTable[it]->boxverts = alloc_and_read(ctx,f,num4*3*FLOAT_SIZE);

   ctx->Variable[iv]->VSliceTable[it]->r1 = r1;
   ctx->Variable[iv]->VSliceTable[it]->c1 = c1;
   ctx->Variable[iv]->VSliceTable[it]->r2 = r2;
   ctx->Variable[iv]->VSliceTable[it]->c2 = c2;
   ctx->Variable[iv]->VSliceTable[it]->interval = interval;
   ctx->Variable[iv]->VSliceTable[it]->lowlimit = low;
   ctx->Variable[iv]->VSliceTable[it]->highlimit = high;
   ctx->Variable[iv]->VSliceTable[it]->valid = 1;
   ctx->Variable[iv]->VSliceRequest->Interval = interval;
   ctx->Variable[iv]->VSliceRequest->LowLimit = low;
   ctx->Variable[iv]->VSliceRequest->HighLimit = high;
   ctx->Variable[iv]->VSliceRequest->R1 = r1;
   ctx->Variable[iv]->VSliceRequest->R2 = c1;
   ctx->Variable[iv]->VSliceRequest->C1 = r2;
   ctx->Variable[iv]->VSliceRequest->C2 = c2;

   new_vslice_pos( ctx, r1, c1, &ctx->Variable[iv]->VSliceRequest->X1, &ctx->Variable[iv]->VSliceRequest->Y1,
                   &ctx->Variable[iv]->VSliceRequest->Lat1, &ctx->Variable[iv]->VSliceRequest->Lon1 );
   new_vslice_pos( ctx, r2, c2, &ctx->Variable[iv]->VSliceRequest->X2, &ctx->Variable[iv]->VSliceRequest->Y2,
                   &ctx->Variable[iv]->VSliceRequest->Lat2, &ctx->Variable[iv]->VSliceRequest->Lon2 );

   done_read_lock( &ctx->Variable[iv]->VSliceTable[it]->lock );

   return;
}



static void restore_chslice( Context ctx, FILE *f, int maxparm,
                             int blocklength )
{

   int iv, it, num;
   Display_Context dtx;

   dtx = ctx->dpy_ctx;

   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   recent( ctx, CHSLICE, iv );
   wait_read_lock( &ctx->Variable[iv]->CHSliceTable[it]->lock );

   /* deallocate old slice */
   free_chslice( ctx, it, iv );

   fread( &ctx->Variable[iv]->CHSliceTable[it]->level, FLOAT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CHSliceTable[it]->rows, INT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CHSliceTable[it]->columns, INT_SIZE, 1, f );

   num = ctx->Variable[iv]->CHSliceTable[it]->rows * ctx->Variable[iv]->CHSliceTable[it]->columns;
   ctx->Variable[iv]->CHSliceTable[it]->verts = alloc_and_read(ctx,f,3*num*INT_2_SIZE);
   ctx->Variable[iv]->CHSliceTable[it]->color_indexes =
                                       alloc_and_read(ctx,f,num*UINT_1_SIZE);

   ctx->Variable[iv]->CHSliceTable[it]->valid = 1;
   ctx->Variable[iv]->CHSliceRequest->Level = ctx->Variable[iv]->CHSliceTable[it]->level;

   done_read_lock( &ctx->Variable[iv]->CHSliceTable[it]->lock );

   return;
}





static void restore_cvslice( Context ctx, FILE *f, int maxparm,
                             int blocklength )
{

   int iv, it, num;

   fread( &iv, INT_SIZE, 1, f );
   if (iv>=maxparm) {
      skip( f, blocklength-INT_SIZE );
      return;
   }
   fread( &it, INT_SIZE, 1, f );
   recent( ctx, CVSLICE, iv );
   wait_read_lock( &ctx->Variable[iv]->CVSliceTable[it]->lock );

   /* deallocate old slice */
   free_cvslice( ctx, it, iv );

   fread( &ctx->Variable[iv]->CVSliceTable[it]->r1, FLOAT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CVSliceTable[it]->c1, FLOAT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CVSliceTable[it]->r2, FLOAT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CVSliceTable[it]->c2, FLOAT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CVSliceTable[it]->rows, INT_SIZE, 1, f );
   fread( &ctx->Variable[iv]->CVSliceTable[it]->columns, INT_SIZE, 1, f );

   num = ctx->Variable[iv]->CVSliceTable[it]->rows * ctx->Variable[iv]->CVSliceTable[it]->columns;
   ctx->Variable[iv]->CVSliceTable[it]->verts = alloc_and_read(ctx,f,3*num*INT_2_SIZE);
   ctx->Variable[iv]->CVSliceTable[it]->color_indexes =
                                       alloc_and_read(ctx,f,num*UINT_1_SIZE);
   ctx->Variable[iv]->CVSliceTable[it]->valid = 1;
   ctx->Variable[iv]->CVSliceRequest->R1 = ctx->Variable[iv]->CVSliceTable[it]->r1;
   ctx->Variable[iv]->CVSliceRequest->R2 = ctx->Variable[iv]->CVSliceTable[it]->c1;
   ctx->Variable[iv]->CVSliceRequest->C1 = ctx->Variable[iv]->CVSliceTable[it]->r2;
   ctx->Variable[iv]->CVSliceRequest->C2 = ctx->Variable[iv]->CVSliceTable[it]->c2;

   new_vslice_pos( ctx, ctx->Variable[iv]->CVSliceTable[it]->r1,
                   ctx->Variable[iv]->CVSliceTable[it]->c1,
                   &ctx->Variable[iv]->CVSliceRequest->X1, &ctx->Variable[iv]->CVSliceRequest->Y1,
                   &ctx->Variable[iv]->CVSliceRequest->Lat1, &ctx->Variable[iv]->CVSliceRequest->Lon1 );
   new_vslice_pos( ctx, ctx->Variable[iv]->CVSliceTable[it]->r2,
                   ctx->Variable[iv]->CVSliceTable[it]->c2,
                   &ctx->Variable[iv]->CVSliceRequest->X2, &ctx->Variable[iv]->CVSliceRequest->Y2,
                   &ctx->Variable[iv]->CVSliceRequest->Lat2, &ctx->Variable[iv]->CVSliceRequest->Lon2 );

   done_read_lock( &ctx->Variable[iv]->CVSliceTable[it]->lock );
   return;
}



static void restore_traj( Context ctx, FILE *f, int blocklength )
{
   int length, kind, group, bytes;
   struct traj *t;

   if (ctx->dpy_ctx->NumTraj<MAXTRAJ) {
      fread( &length, INT_SIZE, 1, f );
      fread( &group, INT_SIZE, 1, f );
      recent( ctx, TRAJ, group );
      fread( &kind, INT_SIZE, 1, f );
      fread( &ctx->NumTimes, INT_SIZE, 1, f );
/*YO*/
      t = ctx->dpy_ctx->TrajTable[ctx->dpy_ctx->NumTraj];
      t->length = length;
      t->group = group;
      t->kind = kind;
      t->verts = alloc_and_read(ctx,f,3*length*INT_2_SIZE);
      if (kind==1) {
         /* read ribbon normals */
         t->norms = alloc_and_read(ctx,f,3*length*UINT_1_SIZE);
      }
      bytes = ctx->NumTimes * UINT_2_SIZE;
      t->start = alloc_and_read(ctx,f,bytes);
      t->len = alloc_and_read(ctx,f,bytes);
      ctx->dpy_ctx->NumTraj++;
   }
   else {
      skip( f, blocklength );
   }
}




static void restore_hwind( Context ctx, FILE *f, int blocklength )
{
   int ws, it;

   fread( &ws, INT_SIZE, 1, f );  /* which slice */
   fread( &it, INT_SIZE, 1, f );  /* which time */
   if (ws<VIS5D_WIND_SLICES && it<ctx->NumTimes) {
      recent( ctx, HWIND, ws );
/*       wait_read_lock( &ctx->HWindTable[ws][it].lock ); 
      free_hwind( ctx, it, ws );

      fread( &ctx->HWindTable[ws][it].level, FLOAT_SIZE, 1, f );
      fread( &ctx->HWindTable[ws][it].density, FLOAT_SIZE, 1, f );
      fread( &ctx->HWindTable[ws][it].scale, FLOAT_SIZE, 1, f );
      ctx->HWindLevel[ws] = ctx->HWindTable[ws][it].level;
      ctx->HWindDensity[ws] = ctx->HWindTable[ws][it].density;
      ctx->HWindScale[ws] = ctx->HWindTable[ws][it].scale;

      fread( &nvect, INT_SIZE, 1, f );
      ctx->HWindTable[ws][it].nvectors = nvect;

      bytes = 3 * 4 * nvect * INT_2_SIZE;
      ctx->HWindTable[ws][it].verts = alloc_and_read( ctx, f, bytes );

      ctx->HWindTable[ws][it].valid = 1;

      fread( &nb, INT_SIZE, 1, f );
      ctx->HWindTable[ws][it].numboxverts = nb;
      ctx->HWindTable[ws][it].boxverts = alloc_and_read(ctx,f,nb*3*FLOAT_SIZE);

      new_hslice_pos( ctx, ctx->HWindLevel[ws],
                      &ctx->HWindZ[ws], &ctx->HWindHgt[ws] ); 

      done_read_lock( &ctx->HWindTable[ws][it].lock ); */
   }
   else {
      skip( f, blocklength - 2*INT_SIZE );
   }
}




#ifdef LEAVEOUT
static void restore_vwind( Context ctx, FILE *f, int blocklength )
{
   int ws, it;

   fread( &ws, INT_SIZE, 1, f );  /* which slice */
   fread( &it, INT_SIZE, 1, f );  /* which time */
   if (ws<VIS5D_WIND_SLICES && it<ctx->NumTimes) {
/* YO
      recent( ctx, VWIND, ws );
      wait_read_lock( &ctx->VWindTable[ws][it].lock );
      free_vwind( ctx, it, ws );

      fread( &ctx->VWindTable[ws][it].r1, FLOAT_SIZE, 1, f );
      fread( &ctx->VWindTable[ws][it].c1, FLOAT_SIZE, 1, f );
      fread( &ctx->VWindTable[ws][it].r2, FLOAT_SIZE, 1, f );
      fread( &ctx->VWindTable[ws][it].c2, FLOAT_SIZE, 1, f );
      fread( &ctx->VWindTable[ws][it].density, FLOAT_SIZE, 1, f );
      fread( &ctx->VWindTable[ws][it].scale, FLOAT_SIZE, 1, f );
      ctx->VWindR1[ws] = ctx->VWindTable[ws][it].r1;
      ctx->VWindC1[ws] = ctx->VWindTable[ws][it].c1;
      ctx->VWindR2[ws] = ctx->VWindTable[ws][it].r2;
      ctx->VWindC2[ws] = ctx->VWindTable[ws][it].c2;
      ctx->VWindDensity[ws] = ctx->VWindTable[ws][it].density;
      ctx->VWindScale[ws] = ctx->VWindTable[ws][it].scale;

      fread( &nvect, INT_SIZE, 1, f );
      ctx->VWindTable[ws][it].nvectors = nvect;
      bytes = 3 * 4 * nvect * INT_2_SIZE;

      ctx->VWindTable[ws][it].verts = alloc_and_read(ctx,f,bytes);

      fread( &nb, INT_SIZE, 1, f );
      ctx->VWindTable[ws][it].numboxverts = nb;
      ctx->VWindTable[ws][it].boxverts = alloc_and_read(ctx,f,3*FLOAT_SIZE*nb);

      new_vslice_pos( ctx, ctx->VWindR1[ws], ctx->VWindC1[ws],
                      &ctx->VWindX1[ws], &ctx->VWindY1[ws],
                      &ctx->VWindLat1[ws], &ctx->VWindLon1[ws] );
      new_vslice_pos( ctx, ctx->VWindR2[ws], ctx->VWindC2[ws],
                      &ctx->VWindX2[ws], &ctx->VWindY2[ws],
                      &ctx->VWindLat2[ws], &ctx->VWindLon2[ws] );

      done_read_lock( &ctx->VWindTable[ws][it].lock );
*/   }
   else {
      skip( f, blocklength - 2*INT_SIZE );
   }
   return;
}




static void restore_stream( Context ctx, FILE *f, int blocklength )
{
   int ws, it;

   fread( &ws, INT_SIZE, 1, f );  /* which slice */
   fread( &it, INT_SIZE, 1, f );  /* which time */
   if (ws<VIS5D_WIND_SLICES && it<ctx->NumTimes) {
/* YO
      recent( ctx, HSTREAM, ws );
      wait_read_lock( &ctx->HStreamTable[ws][it].lock );
      free_hstream( ctx, it, ws );

      fread( &ctx->HStreamTable[ws][it].level, FLOAT_SIZE, 1, f );
      fread( &ctx->HStreamTable[ws][it].density, FLOAT_SIZE, 1, f );
      ctx->HStreamLevel[ws] = ctx->HStreamTable[ws][it].level;
      ctx->HStreamDensity[ws] = ctx->HStreamTable[ws][it].density;

      fread( &nline, INT_SIZE, 1, f );
      ctx->HStreamTable[ws][it].nlines = nline;

      bytes = 3 * nline * INT_2_SIZE;
      ctx->HStreamTable[ws][it].verts = alloc_and_read( ctx, f, bytes );

      ctx->HStreamTable[ws][it].valid = 1;

      fread( &nb, INT_SIZE, 1, f );
      ctx->HStreamTable[ws][it].numboxverts = nb;
      ctx->HStreamTable[ws][it].boxverts = alloc_and_read(ctx,f,nb*3*FLOAT_SIZE);


      done_read_lock( &ctx->HStreamTable[ws][it].lock );
*/   }
   else {
      skip( f, blocklength - 2*INT_SIZE );
   }
}
#endif

static void restore_label( Context ctx, FILE *f )
{
  printf("WARNING restore_label in file save.c doesnt do anything except print this message\n");
/* YO
   int len, x, y;
   char text[MAX_LABEL];
   fread( &len, sizeof(int), 1, f );
   fread( text, 1, len+1, f );
   fread( &x, sizeof(int), 1, f );
   fread( &y, sizeof(int), 1, f );
   vis5d_make_label( ctx->context_index, x, y, text );
*/
}


/*
 * Restore the graphics saved by save() above.
 * Input:  savefile - filename to restore from.
 * Return:  0 for success,
 *          VIS5D_BAD_VALUE if unable to open file
 *          VIS5D_FAIL if error while reading file.
 */
int restore( Context ctx, char *savefile )
{
   FILE *f;
   int tag, blocklength;
   int maxparm, var, add_parms;
   /*int prevtag;*/  /* for debugging */
   int abort = 0;

   /* Determine which variables (and associated graphics) can be restored. */
   /* We can only restore cloned/computed variables if we haven't made any */
   /* such variables yet in the current session. */
   for (var=0;var<ctx->NumVars;var++) {
      if (ctx->Variable[var]->VarType!=VIS5D_REGULAR) {
         break;
      }
   }
   if (var==ctx->NumVars) {
      maxparm = MAXVARS;
      add_parms = 1;
   }
   else {
      maxparm = var;
      add_parms = 0;
   }

   /* Now, we'll only restore variables whose number is < maxparm. */
   /* i.e. only restore variables of type EXT_REGULAR. */


   f = fopen(savefile,"r");
   if (!f)
     return VIS5D_BAD_VALUE;


   while (!feof(f) && !abort) {
      /*prevtag = tag;*/
      if (READ_INTS( f, &tag, 1) == 0)
        break;
      if (READ_INTS( f, &blocklength, 1 ) == 0)
        break;

      switch (tag) {
         case TAG_CLONE_TABLE:
            /* Obsolete */
            printf("Obsolete tag: %d\n", tag );
            skip( f, blocklength );
            break;

         case TAG_VAR_TABLE_41: {
            /* Vis5D v4.1 */
            int np;
            if (add_parms) {
               READ_INTS( f, &np, 1 );

               for (var=0;var<np;var++) {
					  /* JPE: Loop required for backword compatibility */
					  READ_INTS( f, &ctx->Variable[var]->VarType, 1 );
					}
               for (var=0;var<np;var++) {
					  /* JPE: Loop required for backword compatibility */
					  READ_INTS( f, &ctx->Variable[var]->CloneTable, 1 );
					}
               for (var=0;var<np;var++) {
                  READ_FLOATS( f, &ctx->Variable[var]->MinVal, 1 );
                  READ_FLOATS( f, &ctx->Variable[var]->MaxVal, 1 );
                  READ_BYTES( f, ctx->Variable[var]->VarName, 10 );
                  READ_INTS( f, &ctx->Nl[var], 1 );
                  ctx->Variable[var]->LowLev = 0;
               }
               ctx->NumVars = np;
            }
            else {
               skip( f, blocklength );
            }
         } break;

         case TAG_VAR_TABLE: {
            int np;
            if (add_parms) {
               READ_INTS( f, &np, 1 );
               for (var=0;var<np;var++) {
					  /* JPE: Loop required for backword compatibility */
					  READ_INTS( f, &ctx->Variable[var]->VarType, 1 );
					}
               for (var=0;var<np;var++) {
					  /* JPE: Loop required for backword compatibility */
					  READ_INTS( f, &ctx->Variable[var]->CloneTable, 1 );
					}

               for (var=0;var<np;var++) {
                  READ_FLOATS( f, &ctx->Variable[var]->MinVal, 1 );
                  READ_FLOATS( f, &ctx->Variable[var]->MaxVal, 1 );
                  READ_BYTES( f, ctx->Variable[var]->VarName, 10 );
                  READ_INTS( f, &ctx->Nl[var], 1 );
                  READ_INTS( f, &ctx->Variable[var]->LowLev, 1 );
               }
               ctx->NumVars = np;
            }
            else {
               skip( f, blocklength );
            }
         } break;

/*NEW*/
         case TAG_EXT_FUNC: {
            int var, ntimes, it;
            float *grid;
            if (add_parms) {
               READ_INTS( f, &var, 1 );
               READ_INTS( f, &ntimes, 1 );
               grid = allocate( ctx,ctx->Nr*ctx->Nc*ctx->Nl[var]*FLOAT_SIZE );
               for (it=0;it<ntimes;it++) {
                  READ_FLOATS( f, grid, ctx->Nr*ctx->Nc*ctx->Nl[var] );
                  install_new_grid( ctx, it, var, grid, ctx->Nl[var],
                                    ctx->Variable[var]->LowLev );
               }
               deallocate(ctx,grid,ctx->Nr*ctx->Nc*ctx->Nl[var]*FLOAT_SIZE );
            }
            else {
               skip( f, blocklength );
            }
         } break;

/*NEW*/
         case TAG_EXPRESSION: {
            int var, ntimes, it;
            float *grid;
            if (add_parms) {
               READ_INTS( f, &var, 1 );

					/* needs to be 500 for backward compatibility */
					ctx->Variable[var]->ExpressionList = (char *) malloc(500);
               READ_BYTES( f, ctx->Variable[var]->ExpressionList, 500 );

               READ_INTS( f, &ntimes, 1 );
               grid = allocate( ctx, ctx->Nr*ctx->Nc*ctx->Nl[var]*FLOAT_SIZE );
               for (it=0;it<ntimes;it++) {
                  READ_FLOATS( f, grid, ctx->Nr*ctx->Nc*ctx->Nl[var] );
                  install_new_grid( ctx, it, var, grid, ctx->Nl[var],
                                    ctx->Variable[var]->LowLev);
               }
               deallocate( ctx, grid,
                           ctx->Nr*ctx->Nc*ctx->Nl[var]*FLOAT_SIZE );
            }
            else {
               skip( f, blocklength );
            }
         } break;



         case TAG_ISOSURF:
            restore_isosurf( ctx, f, maxparm, blocklength );
            break;

         case TAG_COLORED_ISOSURF:
            restore_colored_isosurf( ctx, f, maxparm, blocklength );
            break;

         case TAG_ISO_COLOR: {
            int var;
            fread( &var, INT_SIZE, 1, f );
            if (var>=maxparm)
               skip( f, blocklength-INT_SIZE );
            else
               fread( &ctx->dpy_ctx->Color[var][ISOSURF], UINT_SIZE, 1, f );
         } break;

         case TAG_ISO_COLOR_TABLE: {
/*YO            int var;
            fread( &var, INT_SIZE, 1, f );
            if (var>=maxparm)
               skip( f, blocklength-INT_SIZE );
            else

               fread( &ctx->ColorTable[VIS5D_ISOSURF_CT]->Colors[var], UINT_SIZE, 256, f );
*/
         } break;

         case TAG_ISO_LEVEL: {
            int var;
            float x;
            READ_INTS( f, &var, 1 );
            READ_FLOATS( f, &x, 1 );
            if (var<maxparm) {
               ctx->IsoLevel[var] = x;
            }
         } break;

         case TAG_HSLICE:
            restore_hslice( ctx, f, maxparm, blocklength );
            break;

         case TAG_HSLICE_COLOR: {
            int var;
            unsigned int color;
            fread( &var, INT_SIZE, 1, f );
            fread( &color, UINT_SIZE, 1, f );
            if (var<maxparm) {
/*YO
               ctx->Color[var][HSLICE] = color;
*/
            }
         } break;

         case TAG_HSLICE_POS: {
            int var;
            float interval, low, high, level;
            READ_INTS( f, &var, 1 );
            READ_FLOATS( f, &interval, 1 );
            READ_FLOATS( f, &low, 1 );
            READ_FLOATS( f, &high, 1 );
            READ_FLOATS( f, &level, 1 );
            if (var<maxparm) {
               ctx->Variable[var]->HSliceRequest->Interval = interval;
               ctx->Variable[var]->HSliceRequest->LowLimit = low;
               ctx->Variable[var]->HSliceRequest->HighLimit = high;
               ctx->Variable[var]->HSliceRequest->Level = level;
/* YO                 new_hslice_pos( ctx, level, &ctx->Variable[var]->HSliceRequest->Z,*/
/* YO                                 &ctx->Variable[var]->HSliceRequest->Hgt );*/
            }
         } break;

         case TAG_VSLICE:
            restore_vslice( ctx, f, maxparm, blocklength );
            break;

         case TAG_VSLICE_COLOR: {
            int var;
            unsigned int color;
            fread( &var, INT_SIZE, 1, f );
            fread( &color, UINT_SIZE, 1, f );
            if (var<maxparm) {
/*YO
               ctx->Color[var][VSLICE] = color;
*/
            }
         } break;

         case TAG_VSLICE_POS: {
            int var;
            float interval, low, high, r1,c1, r2,c2;
            READ_INTS( f, &var, 1 );
            READ_FLOATS( f, &interval, 1 );
            READ_FLOATS( f, &low, 1 );
            READ_FLOATS( f, &high, 1 );
            READ_FLOATS( f, &r1, 1 );
            READ_FLOATS( f, &c1, 1 );
            READ_FLOATS( f, &r2, 1 );
            READ_FLOATS( f, &c2, 1 );
            if (var<maxparm) {
               ctx->Variable[var]->VSliceRequest->Interval = interval;
               ctx->Variable[var]->VSliceRequest->LowLimit = low;
               ctx->Variable[var]->VSliceRequest->HighLimit = high;
               ctx->Variable[var]->VSliceRequest->R1 = r1;
               ctx->Variable[var]->VSliceRequest->R2 = c1;
               new_vslice_pos( ctx, r1, c1,
                               &ctx->Variable[var]->VSliceRequest->X1, &ctx->Variable[var]->VSliceRequest->Y1,
                               &ctx->Variable[var]->VSliceRequest->Lat1, &ctx->Variable[var]->VSliceRequest->Lon1 );
               ctx->Variable[var]->VSliceRequest->C1 = r2;
               ctx->Variable[var]->VSliceRequest->C2 = c2;
               new_vslice_pos( ctx, r2, c2,
                               &ctx->Variable[var]->VSliceRequest->X2, &ctx->Variable[var]->VSliceRequest->Y2,
                               &ctx->Variable[var]->VSliceRequest->Lat2, &ctx->Variable[var]->VSliceRequest->Lon2 );
            }
         } break;

         case TAG_CHSLICE:
            restore_chslice( ctx, f, maxparm, blocklength );
            break;

         case TAG_CHSLICE_COLORS: {
            int var, size;
            fread( &var, INT_SIZE, 1, f );
            if (var>=maxparm) {
               skip( f, blocklength-INT_SIZE );
            }
            else {
/*YO
               fread( &ctx->Color[var][CHSLICE], UINT_SIZE, 1, f );
*/
               fread( &size, INT_SIZE, 1, f );
/*YO
               fread( ctx->ColorTable[VIS5D_CHSLICE_CT]->Colors[var], UINT_SIZE, size, f );
*/
            }
         } break;

         case TAG_CHSLICE_POS: {
            int var;
            float level;
            READ_INTS( f, &var, 1 );
            READ_FLOATS( f, &level, 1 );
            if (var<maxparm) {
               ctx->Variable[var]->CHSliceRequest->Level = level;
/* YO                 new_hslice_pos( ctx, level, &ctx->Variable[var]->CHSliceRequest->Z,*/
/* YO                                 &ctx->Variable[var]->CHSliceRequest->Hgt );*/
            }
         } break;

         case TAG_CVSLICE:
            restore_cvslice( ctx, f, maxparm, blocklength );
            break;

         case TAG_CVSLICE_COLORS: {
            int var, size;
            fread( &var, INT_SIZE, 1, f );
            if (var>=maxparm) {
               skip( f, blocklength-INT_SIZE );
            }
            else {
/*YO
               fread( &ctx->Color[var][CVSLICE], UINT_SIZE, 1, f );
*/
               fread( &size, INT_SIZE, 1, f );
/*YO
               fread( ctx->ColorTable[VIS5D_CVSLICE_CT]->Colors[var], UINT_SIZE, size, f );
*/
            }
         } break;

         case TAG_CVSLICE_POS: {
            int var;
            float r1,c1, r2,c2;
            READ_INTS( f, &var, 1 );
            READ_FLOATS( f, &r1, 1 );
            READ_FLOATS( f, &c1, 1 );
            READ_FLOATS( f, &r2, 1 );
            READ_FLOATS( f, &c2, 1 );
            if (var<maxparm) {
               ctx->Variable[var]->CVSliceRequest->R1 = r1;
               ctx->Variable[var]->CVSliceRequest->R2 = c1;
               new_vslice_pos( ctx, r1, c1,
                               &ctx->Variable[var]->CVSliceRequest->X1, &ctx->Variable[var]->CVSliceRequest->Y1,
                               &ctx->Variable[var]->CVSliceRequest->Lat1, &ctx->Variable[var]->CVSliceRequest->Lon1 );
               ctx->Variable[var]->CVSliceRequest->C1 = r2;
               ctx->Variable[var]->CVSliceRequest->C2 = c2;
               new_vslice_pos( ctx,r2, c2,
                               &ctx->Variable[var]->CVSliceRequest->X2, &ctx->Variable[var]->CVSliceRequest->Y2,
                               &ctx->Variable[var]->CVSliceRequest->Lat2, &ctx->Variable[var]->CVSliceRequest->Lon2 );
            }
         } break;

         case TAG_TRAJ:
            restore_traj( ctx, f, blocklength );
            break;
         
         case TAG_TRAJ_COLOR: {
            /* restore traj colors */
            int grp;
            fread( &grp, INT_SIZE, 1, f );
            if (grp<VIS5D_TRAJ_SETS) {
/*YO
               fread( &ctx->TrajColor[grp], UINT_SIZE, 1, f );
*/
            }
            else {
               skip( f, UINT_SIZE );
            }
         } break;
         
         case TAG_CTM:
            /* restore ctm */
/*YO
            fread( ctx->CTM, FLOAT_SIZE, 16, f );
*/
            break;
         
         case TAG_LABEL:
            restore_label( ctx, f );
            break;

         case TAG_HWIND:
            restore_hwind( ctx, f, blocklength );
            break;

         case TAG_HWIND_COLOR: {
            int ws;
            fread( &ws, INT_SIZE, 1, f );
            if (ws<VIS5D_WIND_SLICES) {
/*YO
               fread( &ctx->HWindColor[ws], UINT_SIZE, 1, f );
*/
            }
            else {
               skip( f, UINT_SIZE);
            }
         } break;

         case TAG_HWIND_POS: {
            int ws;
            READ_INTS( f, &ws, 1 );
/*YO
            READ_FLOATS( f, &ctx->HWindLevel[ws], 1 );
*/
/*YO
            READ_FLOATS( f, &ctx->HWindDensity[ws], 1 );
*/
/*YO
            READ_FLOATS( f, &ctx->HWindScale[ws], 1 );
*/
/*YO
              new_hslice_pos( ctx, ctx->HWindLevel[ws],
                              &ctx->HWindZ[ws], &ctx->HWindHgt[ws] );
*/
         } break;

         case TAG_VWIND:
/*YO
            restore_vwind( ctx, f, blocklength );
*/
            break;

         case TAG_VWIND_COLOR: {
            int ws;
            fread( &ws, INT_SIZE, 1, f );
            if (ws<VIS5D_WIND_SLICES) {
/*YO
               fread( &ctx->VWindColor[ws], UINT_SIZE, 1, f );
*/
            }
            else {
               skip( f, UINT_SIZE);
            }
         } break;

         case TAG_VWIND_POS: {

/*YO             int ws;
            READ_INTS( f, &ws, 1 );
            READ_FLOATS( f, &ctx->VWindR1[ws], 1 );
            READ_FLOATS( f, &ctx->VWindC1[ws], 1 );
            new_vslice_pos( ctx, ctx->VWindR1[ws], ctx->VWindC1[ws],
                            &ctx->VWindX1[ws], &ctx->VWindY1[ws],
                            &ctx->VWindLat1[ws], &ctx->VWindLon1[ws] );
            READ_FLOATS( f, &ctx->VWindR2[ws], 1 );
            READ_FLOATS( f, &ctx->VWindC2[ws], 1 );
            new_vslice_pos( ctx, ctx->VWindR2[ws], ctx->VWindC2[ws],
                            &ctx->VWindX2[ws], &ctx->VWindY2[ws],
                            &ctx->VWindLat2[ws], &ctx->VWindLon2[ws] );
            READ_FLOATS( f, &ctx->VWindDensity[ws], 1 );
            READ_FLOATS( f, &ctx->VWindScale[ws], 1 );
 */
         } break;

         case TAG_HSTREAM:
/*YO
            restore_stream( ctx, f, blocklength );
*/
            break;

         case TAG_HSTREAM_COLOR: {
            int ws;
            fread( &ws, INT_SIZE, 1, f );
            if (ws<VIS5D_WIND_SLICES) {
/*YO
               fread( &ctx->HStreamColor[ws], UINT_SIZE, 1, f );
*/
            }
            else {
               skip( f, UINT_SIZE);
            }
         } break;

         case TAG_HSTREAM_POS: {

/*YO            int ws;
            READ_INTS( f, &ws, 1 );
            READ_FLOATS( f, &ctx->HStreamLevel[ws], 1 );
            READ_FLOATS( f, &ctx->HStreamDensity[ws], 1 );
 YO              new_hslice_pos( ctx, ctx->HStreamLevel[ws],
 YO                              &ctx->HStreamZ[ws], &ctx->HStreamHgt[ws] );
*/         } break;

         case TAG_TOPO_COLORS:
/*YO
            fread( ctx->Topo_CT->Colors, UINT_SIZE, 256, f );
*/
            break;
        
         case TAG_VOLUME_COLORS: {
            int var, size;
            fread( &var, INT_SIZE, 1, f );
            if (var>=maxparm) {
               skip( f, blocklength-INT_SIZE );
            }
            else {
               fread( &size, INT_SIZE, 1, f );
/*YO
               fread( ctx->ColorTable[VIS5D_VOLUME_CT]->Colors[var], UINT_SIZE, size, f );
*/
            }
         } break;

         default:
            /* skip bytes */
            if (tag<=0 || blocklength<=0) {
               printf("Bad .SAVE file, restore aborted\n");
               abort = 1;
            }
            else {
               printf("skipping block (tag=%d,len=%d)\n", tag, blocklength );
               skip( f, blocklength );
            }

      } /*switch */

   } /*while*/

   fclose(f);
   if (abort) {
      return VIS5D_FAIL;
   }
   else {
      return 0;
   }
}