new_read_maps.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "prototypes.h"
 
void read_maps(char *sfname,int smonth,int emonth)
{
 
extern int fgbg_number;
extern int contour_topo_flag;
extern int add_topo_flag;
extern int change_map_flag;
extern int off[100];
extern int topo_number;
extern Widget drawing_area;
extern double max_lat,min_lat,cen_lon;
extern char station_list_file[256];
extern int fgbgflag;
extern Widget top_level;
extern int posit;
extern Widget s_text;
extern void topo_select();
extern unsigned car[100];
extern struct maplayer *smaplayer[100];
extern struct MenuItem ktems[100];
extern struct dval dval;
extern void clear_backgrounds();
extern Widget scrollbar;
int i,j,ier,no,zoom,color,ii,lflag,xadd,yadd,type,k,len,jj;
char kbuf[200],*p,*q,*sname[20],nm[50],dbuf[100],fname[50];
char name[50],ebuf[120];
int num[100];
FILE *ft;
long xsize=12800,ysize=9600;
double f1,f2,xo,yo,a,conv=.0174,lat,lon;
struct maplayer *maplayer;
FILE *fp;
int slider_size,scrollm,ivalue,increment,page_increment;
Dimension width,height;
float x_lat,n_lat,x_lon,n_lon;
int XSIZE,YSIZE;
Arg args[10];
struct mappoints points[10000];
int numseg;
char kbuf1[50],kbuf2[50],pchar;
int center;
int raster_flag;
 
  strcpy(kbuf1,"'");
  pchar=kbuf1[0];
 
  /* This will free memory if necessary */
  for(j=0;j<100;j++)
    num[j]=j;
          
  j=0;
  jj=0;
 
  if(!(fp=fopen(sfname,"r")))
  {
    printf("%s does not exist\n",sfname);
    exit(1);
  }
  else
  {
    fgets(kbuf,190,fp);
    p=pars_line(kbuf,"maximum_latitude=",dbuf);
 
    if(p)
      max_lat=atof(dbuf);
    else      
    {
      printf("maximum_latitude not specified\n");
      exit(1);
    }
 
    p=pars_line(kbuf,"minimum_latitude=",dbuf);
    if(p)
      min_lat=atof(dbuf);
    else      
    {
      printf("minimum_latitude not specified\n");
      exit(1);
    }
 
    p=pars_line(kbuf,"center_longitude=",dbuf);
    if(p)
      cen_lon=atof(dbuf);
    else      
    {
      printf("center_longitude not specified\n");
      exit(1);
    }
 
    f1=cos(max_lat*conv)/(1+sin(max_lat*conv));
    f2=cos(min_lat*conv)/(1+sin(min_lat*conv));
 
    a=ysize/(f1-f2);
    yo=a*f1;
    xo=xsize/2;
 
    dval.a=a;
    dval.yo=yo;
    dval.xo=xo;
    dval.lo=cen_lon;
    lflag=0;
 
    XtSetArg(args[0],XtNwidth,&width);
    XtSetArg(args[1],XtNheight,&height);
    XtGetValues(drawing_area,args,2);
 
    XSIZE=width*10;
    YSIZE=height*10;
 
    get_lat_lon(0,0,&x_lat,&x_lon);
    get_lat_lon(12800,9600,&n_lat,&n_lon);
 
    x_lat=max_lat;
    n_lat=min_lat;
 
    for(ii=0;ii<100;ii++) 
    {
      p=fgets(kbuf,190,fp);
      if(!p) 
        break;
 
      ier=strlen(kbuf);
      kbuf[ier-1]=0;
 
      nm[0]=0;
      p=pars_line(kbuf,"name=",nm);
 
      center=0;
      p=pars_line(kbuf,"justify=center",fname);
      if(p)
        center=1;
           
      fname[0]=0;
 
      p=pars_line(kbuf,"topography=",fname);
      if(p) 
      {
        p=pars_line(kbuf,"raster=on",dbuf);
        if(p)
          raster_flag=1;
        else
          raster_flag=-1;
        
        topo_number=j;
        sname[j]=calloc(1,strlen(nm)+1);
        strcpy(sname[j],nm);
        ktems[j].label=sname[j];
        ktems[j].callback=topo_select;
                
        strcat(nm,"\n");
        posit=posit+strlen(nm);
        XmTextInsert(s_text,posit,nm);
 
        XtVaGetValues(scrollbar,XmNmaximum,&scrollm,NULL);
        XmScrollBarGetValues(scrollbar,&ivalue,&slider_size,
                             &increment,&page_increment);
        XmScrollBarSetValues(scrollbar,scrollm-slider_size,
                             slider_size,increment,page_increment,True);
 
        XmUpdateDisplay(top_level);
        get_topo_coord(fname);
                    
        p=pars_line(kbuf,"default=on",dbuf);
        if(p) 
        {
          add_topo_flag=1;
          change_map_flag=1;
          if(raster_flag==1)
            contour_topo_flag=0;
        }
                    
        ktems[j++].callback_data=NULL;   
          continue;
 
      }
 
      type=-1;
      p=pars_line(kbuf,"arc=",fname);
      if(p) 
        type=0;    
 
      p=pars_line(kbuf,"poly=",fname);
      if(p) 
        type=1;
 
      p=pars_line(kbuf,"text=",fname);
        if(p) 
          type=2;
 
      if(type==-1)
        continue;
 
      ft=fopen(fname,"r");
 
      if(!ft) 
      {
        printf("could not open %s\n",fname);
        continue;
      }
 
      p=fgets(ebuf,100,ft);
   
      ier=sscanf(ebuf,"%s %s %s %s %s",dbuf,dbuf,dbuf,dbuf,dbuf);
 
      rewind(ft);
  
      p=pars_line(kbuf,"char=",dbuf);
      if(p) 
      {
        *p=toupper(*p);
        car[j]=*p;
      }
      else
        car[j]=-1;
 
      color=8;
      p=pars_line(kbuf,"color=",dbuf);
      if(p)
        color=atoi(dbuf);
 
      if(lflag==1)
      {
        maplayer->nextseg=(struct maplayer *)calloc(1,sizeof(struct maplayer));
        if(!maplayer->nextseg)
          printf("no memory\n");
        maplayer=maplayer->nextseg;
      }
      else     
      {
        p=pars_line(kbuf,"default=on",fname);
        if(p)
          off[jj]=1;
        else
          off[jj]=-1;
         
        sname[j]=calloc(1,strlen(nm)+1);
        strcpy(sname[j],nm);
        ktems[j].label=sname[j];
        ktems[j].callback=map_select;
        ktems[j].callback_data=(XtPointer)num[jj];
              
        j++;
        maplayer=(struct maplayer *) calloc(1,sizeof(struct maplayer));
        smaplayer[jj++]=maplayer;
 
      }
 
      if(lflag==0) 
      {
        strcat(nm,"\n");
        posit=posit+strlen(nm);
        XmTextInsert(s_text,posit,nm);
        XtVaGetValues(scrollbar,XmNmaximum,&scrollm,NULL);
        XmScrollBarGetValues(scrollbar,&ivalue,&slider_size,
                             &increment,&page_increment);
        XmScrollBarSetValues(scrollbar,scrollm-slider_size,slider_size,
                             increment,page_increment,True);
        XmUpdateDisplay(top_level);
      }             
 
 
      lflag=0;
      p=pars_line(kbuf,"link",dbuf);
      if(p)
        lflag=1;
 
      p=fgets(kbuf,100,ft);
 
      if(!p)
        continue;
 
      for(;;) 
      {
        if(type==0 || type==1) 
        {
          maplayer->name=NULL;
          maplayer->zoom=1;
          maplayer->color=color;
          maplayer->type=type;
          numseg=0;
 
          for(;;) 
          {
            p=fgets(kbuf,100,ft);
            if(!p) 
            {
              maplayer->nextseg=NULL;
              break;
            }
            if(strncmp("END",kbuf,3)==0)
              break;
      
            sscanf(kbuf,"%lf %lf",&lon,&lat);
            lon=-lon;
 
            if((lon < n_lon || lon > x_lon) &&
               ( lat < n_lat || lat > x_lat))
              continue;
 
            points[numseg].x=a * cos(lat*conv)/(1+sin(lat*conv))*
                                 cos((lon-cen_lon-90)*conv) + xo;
            points[numseg].y=a * cos(lat*conv)/(1+sin(lat*conv))*
                                 sin((lon-cen_lon-90)*conv) + yo;
            numseg++;
          }
 
          if(numseg < 2) 
          {
            maplayer->nextseg=NULL;
            p=fgets(kbuf,100,ft);
            if(!p) 
              goto resume;
 
            continue;
          }
               
          maplayer->number=numseg;
          maplayer->points=(struct mappoints *)calloc(numseg,sizeof(struct mappoints));
 
          if(!maplayer->points)
            printf("no memory\n");
 
          memcpy(maplayer->points,&points,numseg*sizeof(struct mappoints));
    }
        else 
        {
          /* text type */
          i=0;
          while(kbuf[i] != 0) 
          {
            if(kbuf[i]==',')
              kbuf[i]=' ';
            i++;
          }
 
          ier=sscanf(kbuf,"%s %s",kbuf1,kbuf2);
          if(ier !=2) 
          {
            printf("error in format %s\n",sname[j]);
            break;
      }
               
          p=strchr(kbuf,pchar);
          if(!p)
          {
            printf("error in format %s\n",sname[j]);
            break;
      }
               
          q=strchr(p+1,pchar);
          if(!q)
          {
            printf("error in format %s\n",sname[j]);
            break;
      }
               
          *q=0;
          strcpy(name,p+1);               
 
          xadd=1;
          yadd=1;
          zoom=1;
              
          ier=sscanf(q+1,"%d %d %d %d",&xadd,&yadd,&zoom);
 
          lon=-atof(kbuf1);
          lat= atof(kbuf2);
            
          maplayer->zoom=zoom;
          maplayer->xmax=xadd;
          maplayer->ymax=yadd;
          maplayer->color=color;
          maplayer->type=type;
          maplayer->number=center;
 
          maplayer->points=(struct mappoints *)calloc(1,sizeof(struct mappoints));
          maplayer->points[0].x=a * cos(lat*conv)/(1+sin(lat*conv))*
                                    cos((lon-cen_lon-90)*conv) + xo;
                         
          maplayer->points[0].y=a * cos(lat*conv)/(1+sin(lat*conv))*
                                    sin((lon-cen_lon-90)*conv) + yo;
         
          len=strlen(name);
 
          maplayer->name=(char *) calloc(len + 1,sizeof(char));
          strcpy(maplayer->name,name);
        }
 
        p=fgets(kbuf,100,ft);
        if(!p) 
        {
           maplayer->nextseg=NULL;
           break;
        }
               
        maplayer->nextseg=(struct maplayer *)calloc(1,sizeof(struct maplayer));
        if(!maplayer->nextseg)
          printf("no memory\n");
        maplayer=maplayer->nextseg;
      }
 
      resume:
      if(ft)
        fclose(ft);
    }
     
    off[jj++]=-1; 
    ktems[j].label="Clear backgrounds";
    ktems[j].callback=clear_backgrounds;
    ktems[j++].callback_data=(XtPointer)0;
 
    off[jj]=1;
    fgbg_number=j;
    ktems[j].label="Maps Foreground";
    ktems[j].callback=foreground_select;
    ktems[j++].callback_data=(XtPointer)fgbgflag;
    ktems[j].label=NULL;
 
  }
  return;
}