subdisplay.c

Go to the documentation of this file.

#include "prototypes.h"
#include <math.h>
 
extern int future_time_series_days;
extern int past_time_series_days;
extern int print_flag;
extern Widget mpbutton[10];
extern struct sensor_rec *sensor_rec;
struct stn_values etn_values[5000];
struct stn_values btn_values[5000];
extern unsigned int sensortype;
extern struct sensor_type *stype;
extern unsigned int sensortype;
extern int init_subdisplay;
extern struct database dbase;
extern struct sindx *sdx;
extern struct number_rec *number_rec;
extern struct stn_values *stn_values;
extern XFontStruct *info_font[10];
extern Font font[10];
extern Display *display;
extern struct save_rec save_rec[10];
extern Widget top_level;
extern Widget draw_dialog[10];
extern unsigned long mmap[16];
extern Widget bmain_window;
extern Widget bdrawing_area[10];
extern Window bwindow[20],root_win;
extern struct sensor_file *sfile;
struct stim btim;
struct stim etim;
struct stn_values values[10000];
char qual[10];
int display_method;
static int bmax_width,bmax_height,depth;
extern int defscale;
extern int deflinear;
extern int defrain;
extern int debug;
 
void options_rain();
void options_draw();
void quit_draw();
void get_new_values();
void bhandle_expose();
void print_bdraw(int);
void print_me();
Widget BuildPulldownsubPushMenu(Widget parent,char *menu_title,char menu_mnemonic,struct MenuItem *items);
Widget BuildPulldownsubToggleMenu(Widget parent,char *menu_title,char menu_mnemonic,struct MenuItem *items);
 
GC gc1;
char *fontname;
int report_limit=5000;
 
void subdisplay(char *id, char *pc,int month,int day,int year,int hour,int min)
{
 
time_t tim;
struct tm *gmtim;
Cardinal argcount;
Arg args[10];
int rec_size,num_recs;
int i;
 
bmax_width=400;
bmax_height=325;
 
  if(init_subdisplay == 0) 
  {
    strcpy(qual,"VSFCQDA");
    stn_values=calloc(5000,sizeof(struct stn_values));
    report_limit=3000;
 
/*
    dbread(NDATABASE, 0L, sizeof(struct database), 1L, &dbase.recs_allocated);
 
    rec_size = sizeof(struct sindx);
    num_recs = dbase.recs_used;
    sdx = (struct sindx *)calloc(num_recs, rec_size);
    dbread(NTSINDX, 0L, rec_size, num_recs, &sdx[0].sid);
*/
 
    number_rec=(struct number_rec *)calloc(1,sizeof(struct number_rec));
    sfile=(struct sensor_file *)calloc(1,sizeof(struct sensor_file));
    sensor_rec=(struct sensor_rec *)calloc(50,sizeof(struct sensor_rec));
 
    for(i=0;i<10;i++) 
    {
      draw_dialog[i]=0;
      save_rec[i].inum=-1;
      save_rec[i].volume=0;
    } 
 
    gc1= XCreateGC(display,root_win,0,0);
 
/*
    rec_size = sizeof(struct sensor_type);
    num_recs = dbase.sensor_types;
    stype = (struct sensor_type *)calloc(num_recs, rec_size);
    dbread(NSENSOR_TYPE, 0L,rec_size,num_recs, &stype[0].number);
*/
 
    init_subdisplay=1;
  }
 
  btim.year=year;
  btim.month=month;
  btim.day=day;
  btim.hour=hour;
  btim.minute=min;
 
  tim=ouptime(year,month,day,hour,min,0);
  if(!strncmp(pc,"PPM",3))
    tim=tim-365*86400L;
  else
    tim=tim-past_time_series_days*86400L;
  gmtim=gmtime(&tim);
 
  etim.year=gmtim->tm_year+1900;
  etim.month=gmtim->tm_mon+1;
  etim.day=gmtim->tm_mday;
  etim.hour=gmtim->tm_hour;
  etim.minute=gmtim->tm_min;
/*
  printf("btim= %02d/%02d/%04d @ %02d %02d\n",btim.month,btim.day,btim.year,btim.hour,btim.minute);
  printf("etim= %02d/%02d/%04d @ %02d %02d\n",etim.month,etim.day,etim.year,etim.hour,etim.minute);
*/
  get_new_values(etim,btim,id,pc);
}
 
void get_new_values(struct stim etim,struct stim btim,char *id, char *pc)
{
struct MenuItem items[10];
int j,inum,i,ier,ierr,qflow,len,jj;
int month,day,year,hour,min;
char *text,buf[300],sbuf[150],hbuf[10];
char *spaces;
Cardinal argcount;
Dimension width,height;
Arg args[10];
Widget menu_bar,main_bar,jwidget;
XmString cancel,file_string,print_string;
RatingTable rate_table;
double qstage;
char *p;
int num;
int mnum;
char quality;
unsigned long index;
Display *disp;
int ennum,bnnum;
struct tm *gm;
time_t otim;
int savesensortype;
struct stim btim1;
struct stim etim1;
Widget shell;
Atom WM_DELETE_WINDOW;
time_t timnow;
time_t etime,btime;
int degug=1;
 
spaces="                  ";
 
file_string=XmStringCreateLocalized("file");
print_string=XmStringCreateLocalized("print");
cancel=XmStringCreateLocalized("quit");
 
/*
inum=number_search(snum,&dbase,number_rec);
index=number_rec[0].index;
mnum=station_search(index,sfile);
inum=values_search(index,&dbase,report_limit,btim,etim,
                                   qual,stn_values);
*/
 
/* rkh 5/10/2016
if(!strncmp(pc,"PPM",3))
{
  *(pc+1)='C';
  *(pc+2)='I';
  *(pc+3)='R';
  printf("switched\n");
}
*/
 
etime=ouptime(etim.year,etim.month,etim.day,etim.hour,0,0);
btime=ouptime(btim.year,btim.month,btim.day,btim.hour,0,0);
mnum=get_sensor_info(id,pc,sfile);
 
if(!strncmp(pc,"PPM",3))
{
  inum=get_stn_valuesM(id,pc,btime,12,stn_values);
}
else
  inum=get_stn_values(id,pc,btime,etime,stn_values);
 
display_method=1;
 
savesensortype=sensortype;
 
if(!strncmp(sfile->pc,"HGIR",4) || !strncmp(sfile->pc,"QIIR",4)) 
{
  memcpy(&etn_values,stn_values,
         inum*sizeof(struct stn_values));
        
  ennum=inum;
  mnum=check_sens(id,pc);
 
  if(mnum > 0 && future_time_series_days) 
  {
    memcpy(&etn_values,stn_values,
           inum*sizeof(struct stn_values));
    ennum=inum;
    otim=ouptime(btim.year,btim.month,btim.day,btim.hour,0,0);                                                                
    timnow=otim;                
    if(inum == 0 || (inum > 0 && timnow-stn_values[0].clock > 9*3600)) 
    {
      gm=gmtime(&timnow);
      etim1.hour=gm->tm_hour;
      etim1.day=gm->tm_mday;
      etim1.month=gm->tm_mon+1;
      etim1.year=gm->tm_year+1900;
      etim1.minute=0;
    }
    else 
    {
      timnow=stn_values[0].clock+3600;
      gm=gmtime(&timnow);
                      
      etim1.hour=gm->tm_hour;
      etim1.day=gm->tm_mday;
      etim1.month=gm->tm_mon+1;
      etim1.year=gm->tm_year+1900;
      etim1.minute=0;
    }     
    etime=ouptime(etim1.year,etim1.month,etim1.day,etim1.hour,0,0);                                                                
    otim=otim+future_time_series_days*86400;
    gm=gmtime(&otim);
                   
    btim1.hour=gm->tm_hour;
    btim1.day=gm->tm_mday;
    btim1.month=gm->tm_mon+1;
    btim1.year=gm->tm_year+1900;
    btim1.minute=0;
    btime=ouptime(btim1.year,btim1.month,btim1.day,btim1.hour,0,0);                                                                
 
    inum=get_fcst_values(id,pc,btime,etime,stn_values);
/*
    inum=values_search(sensor_rec[0].index,&dbase,
                       report_limit,btim1,etim1,"",stn_values);                    
*/
                      
    if(inum > 0) 
    {
      btim.hour=btim1.hour;
      btim.day=btim1.day;
      btim.month=btim1.month;
      btim.year=btim1.year;
      btim.minute=0;
    }
                      
    for(i=0;i<inum;i++)
      stn_values[i].qual='O';
               
    memcpy(&btn_values,stn_values,
           inum*sizeof(struct stn_values));
                       
    bnnum=inum;
    memcpy(stn_values,&btn_values,
           bnnum*sizeof(struct stn_values));
                
    memcpy(&stn_values[bnnum],&etn_values,
           ennum*sizeof(struct stn_values));
               
    inum=ennum+bnnum;                 
          
  }
}
 
for(j=0;j<10;j++)
{
  if(draw_dialog[j]==0)
    break;
}
 
if(j==10) 
{
  return;
}
 
if(display_method==1) 
{
 
  disp=XtDisplay(top_level);
  argcount=0;
            
  draw_dialog[j]=XmCreateMessageDialog(top_level,"Time series",
                          args,argcount);
 
  XtUnmanageChild(XmMessageBoxGetChild(draw_dialog[j],
    XmDIALOG_OK_BUTTON)); 
  XtUnmanageChild(XmMessageBoxGetChild(draw_dialog[j],
    XmDIALOG_HELP_BUTTON));
  XtUnmanageChild(XmMessageBoxGetChild(draw_dialog[j],
    XmDIALOG_CANCEL_BUTTON));
  XtUnmanageChild(XmMessageBoxGetChild(draw_dialog[j],
    XmDIALOG_SEPARATOR));
 
  argcount=0;
  XtSetArg(args[argcount],XmNwidth,bmax_width);argcount++;
  XtSetArg(args[argcount],XmNheight,bmax_height);argcount++;
  XtSetArg(args[argcount],XmNbackground,0);argcount++;
  bmain_window=XmCreateMainWindow(draw_dialog[j],"Main",
              args,argcount);
 
  XtManageChild(bmain_window);
 
  argcount=0;
  XtSetArg(args[argcount],XmNbackground,mmap[1]);argcount++;
  XtSetArg(args[argcount],XmNforeground,mmap[0]);argcount++;
  menu_bar=XmCreateMenuBar(bmain_window,"Menubar",args,argcount);
  XtManageChild(menu_bar);
 
  argcount=0;
  XtSetArg(args[argcount],XmNwidth, bmax_width);argcount++;
  XtSetArg(args[argcount],XmNheight,bmax_height);argcount++;
  XtSetArg(args[argcount],XmNresizePolicy,XmRESIZE_ANY);argcount++;
  XtSetArg(args[argcount],XmNbackground,0);argcount++;
  bdrawing_area[j]=XmCreateDrawingArea(bmain_window,"bdrawing_area",
               args,argcount);
 
  XtManageChild(bdrawing_area[j]);
 
  XmMainWindowSetAreas(bmain_window,menu_bar,NULL,NULL,NULL,
             bdrawing_area[j]);
 
  items[0].label="Print";
  items[0].callback=print_me;
  items[0].callback_data=(XtPointer)j;
  items[0].accel=NULL;
           
  items[1].label="Quit";
  items[1].callback=quit_draw;
  items[1].accel_text=XmStringCreateLocalized("Ctrl+Q");
  items[1].accel="Ctrl<Key>Q";
  items[1].callback_data=(XtPointer)j;
  items[2].label=NULL;
 
  main_bar=BuildPulldownsubPushMenu(menu_bar,"File",'M',items);
  jwidget=AttachToCascade(menu_bar,"File",main_bar);
                  
  save_rec[j].linear=0;
  save_rec[j].rain=-1;
  save_rec[j].scale=0;
 
  ier=-1;
 
  if(sfile->rating != NOT_USED)   
  {
    if((toupper(sfile->pc[0])=='H' || toupper(sfile->pc[0])=='Q')  
        && sfile->pc[2] != 'M')
    {
      rate_table=getrc(id,pc,&ier);
      printf("rating table: %s %s %d\n",id,pc,ier);
    }
  }  
 
  if(ier!=1)
    rate_table.AryMax=ier;
 
  jj=0;
 
  if(!strncasecmp(sfile->pc,"PCI",3) || 
     !strncasecmp(sfile->pc,"PCH",3) )
  {
               
    items[jj].label="Hourly rain";
    items[jj].callback=options_rain;
              
    if(defrain==0)
      items[jj].def=1;
    else
      items[jj].def=-1;
                   
    items[jj].accel=NULL;
    items[jj++].callback_data=(XtPointer)(0+j*100);
               
    if(defrain==1)
      items[jj].def=1;
    else
      items[jj].def=-1;
                   
    items[jj].label="6 hourly rain";
    items[jj].callback=options_rain;
              
    items[jj].accel=NULL;
    items[jj++].callback_data=(XtPointer)(1+j*100);
               
    items[jj].label="24 hourly rain";
    items[jj].callback=options_rain;
               
    if(defrain==2)
      items[jj].def=1;
    else
      items[jj].def=-1;
                   
    items[jj].accel=NULL;
    items[jj++].callback_data=(XtPointer)(2+j*100);
               
    if(defrain==-1)
      items[jj].def=1;
    else
      items[jj].def=-1;
                   
    items[jj].label="rain bar off";
    items[jj].callback=options_rain;
               
    items[jj].accel=NULL;
    items[jj++].callback_data=(XtPointer)(3+j*100);
  }             
            
  if(sfile->pc[0]=='H') 
  {
 
    if(rate_table.AryMax > 0) 
    {
      items[jj].label="Linear stage";
      items[jj].callback=options_draw;
               
      if(deflinear==0)
        items[jj].def=1;
      else
        items[jj].def=-1;
                  
      items[jj].accel_text=XmStringCreateLocalized("Ctrl+S");
      items[jj].accel="Ctrl<Key>S";
      items[jj++].callback_data=(XtPointer)(0+j*100);
      
      items[jj].label="Linear flow";
      items[jj].callback=options_draw;
               
      if(deflinear==1)
        items[jj].def=1;
      else
        items[jj].def=-1;
                   
      items[jj].accel_text=XmStringCreateLocalized("Ctrl+O");
      items[jj].accel="Ctrl<Key>O";
      items[jj++].callback_data=(XtPointer)(1+j*100);
    }                            
 
    if(rate_table.wrn >= 0 || rate_table.fld >= 0) 
    {
      items[jj].label="Scale to data";
      items[jj].callback=options_draw;
                
      if(defscale==0)
         items[jj].def=1;
      else
         items[jj].def=-1;
                   
      items[jj].accel_text=XmStringCreateLocalized("Ctrl+D");
      items[jj].accel="Ctrl<Key>D";
      items[jj++].callback_data=(XtPointer)(2+j*100);
                
      items[jj].label="Scale to flood";
      items[jj].callback=options_draw; 
      
      if(defscale==1)
         items[jj].def=1;
      else
         items[jj].def=-1;
                   
      items[jj].accel_text=XmStringCreateLocalized("Ctrl+F");
      items[jj].accel="Ctrl<Key>F";
      items[jj++].callback_data=(XtPointer)(3+j*100);  
 
    }
  }
 
  items[jj].label=NULL;
          
  if(jj) 
  {
    main_bar=BuildPulldownsubToggleMenu(menu_bar,"Options",'M',items);
    jwidget=AttachToCascade(menu_bar,"Options",main_bar);
  }
 
  for(jj=0;jj<10;jj++)
    save_rec[j].mbutton[jj]=NULL;
 
  jj=0;
 
  if(!strncmp(sfile->pc,"PCI",3) || !strncmp(sfile->pc,"PPH",3))
  {
    save_rec[j].mbutton[0]=mpbutton[jj++];             
    save_rec[j].mbutton[1]=mpbutton[jj++];             
    save_rec[j].mbutton[2]=mpbutton[jj++];
    save_rec[j].mbutton[3]=mpbutton[jj++];
    save_rec[j].rain=defrain;
  } 
 
/*
  if(!strncmp(sfile->pc,"PPQ",3))
    save_rec[j].rain=1;
 
  if(!strncmp(sfile->pc,"PPD",3))
    save_rec[j].rain=2;
*/
 
  if(sfile->pc[0]=='H') 
  {
    if(rate_table.AryMax > 0) 
    {
      save_rec[j].mbutton[4]=mpbutton[jj++];             
      save_rec[j].mbutton[5]=mpbutton[jj++];             
      save_rec[j].linear=deflinear;
    }                            
 
    if(rate_table.wrn >= 0 || rate_table.fld >= 0) 
    {
      save_rec[j].mbutton[6]=mpbutton[jj++];             
      save_rec[j].mbutton[7]=mpbutton[jj++];             
      save_rec[j].scale=defscale;
    }
  }
 
  XtManageChild(draw_dialog[j]);
 
  bwindow[j]=XtWindow(bdrawing_area[j]);
 
  XmUpdateDisplay(bdrawing_area[j]);
 
  save_rec[j].is_realized=-1;
 
/* uncommented */
  memcpy(&save_rec[j].sfile,sfile,sizeof(struct sensor_file));
  memcpy(&save_rec[j].parm,sfile->pc,10);
/* uncommented */
 
  memcpy(&save_rec[j].btim,&btim,sizeof(struct stim));
  memcpy(&save_rec[j].etim,&etim,sizeof(struct stim));
  memcpy(&save_rec[j].stn_values,stn_values,
         inum*sizeof(struct stn_values));
  memcpy(&save_rec[j].rate_table,&rate_table,sizeof(RatingTable));
 
  save_rec[j].inum=inum;
  save_rec[j].volume=0;
  save_rec[j].sensortype=sensortype;
 
  if(save_rec[j].parm[2]=='M')
        save_rec[j].volume=24*30;
 
  if(save_rec[j].parm[2]=='D')
        save_rec[j].volume=24;
 
  else if(save_rec[j].parm[2]=='Q')
        save_rec[j].volume=6;
 
  else if(save_rec[j].parm[2]=='H')
        save_rec[j].volume=1;
 
  if(!strncmp(save_rec[j].parm,"PCI",3) || !strncmp(save_rec[j].parm,"PPH",3))
    get_hourly(j);
               
  XSetFunction(display,gc1,GXcopy);
  XSetForeground(display,gc1,mmap[0]);
  XSetBackground(display,gc1,mmap[0]);
  XFillRectangle(display,bwindow[j],gc1,0,0,
                 bmax_width,bmax_height);
 
  XtSetArg(args[0],XtNwidth,&width);
  XtSetArg(args[1],XtNheight,&height);
  XtGetValues(bdrawing_area[j],args,2);
 
  draw_area(j,j,0,0,width,height);
 
  XmStringFree(file_string);
  XmStringFree(print_string);
  XmStringFree(cancel);
 
  XtAddCallback(bdrawing_area[j],XmNexposeCallback,bhandle_expose,
                (XtPointer)j);
 
  XtAddCallback(bdrawing_area[j],XmNresizeCallback,bhandle_expose,
                (XtPointer)j);
 
  shell=XtParent(draw_dialog[j]);
  WM_DELETE_WINDOW=XmInternAtom(XtDisplay(top_level),
  "WM_DELETE_WINDOW",False);
            
  XmAddWMProtocolCallback(shell,WM_DELETE_WINDOW,quit_draw,(XtPointer)j);
 
  return;            
}
}
 
 
void draw_area(int k,int m,int xs,int ys,int xz,int yz)
{
extern float hr1_rainfall_max;
extern float hr6_rainfall_max;
extern float hr24_rainfall_max;
int xparm1,yparm1,xparm2,yparm2;
int width,height;
int debug=0;
struct tm tm;
time_t lbtim,letim,stim,otim;
char abuf[100],tbuf[100],next[10];
int xmax,ymax,xmin,ymin,maxtimes,maxvalues,yheight;
struct max_min max_min;
int deltat,i,text_width,j,h,qflag,ier;
float deltav,fminv;
float fxvalue,fyvalue,svalue,dxvalue;
int maxv,minv,smaxv,sminv,dvalue;
int xvalue,oday,yvalue,xvalue1,yvalue1,totlin,totdays,hour,ierr,flow,ilinear;
struct tm *gm;
char buf[200],ubuf[50],xbuf[50];
int inum,merr,ybegin,len;
XRectangle rect[1];
double stage,wrn,fld,abs1,abs2;
int htflag;
int line_width,line_style,cap_style,join_style,lines;
int totyears;
char oqual;
int scale;
int irain;
float dval;
int hnum;
int vol;
int off;
float rminv,rmaxv;
int nnum;
int savex;
int ix1,ix2,dx;
float fxvalue1;
int idval;
int odx;
 
ilinear=save_rec[k].linear;
 
 
scale=save_rec[k].scale;
irain=save_rec[k].rain;
 
if(save_rec[k].rate_table.AryMax <=0)
  ilinear=0;
 
rminv=0;
if(!irain) 
{
  dval=hr1_rainfall_max/15.;
  idval=dval*10;
  dval=(float)idval/10;
  off=5000;
  nnum=save_rec[k].hnum;
}
else if(irain==1) 
{
  dval=hr6_rainfall_max/15.;
  idval=dval*10;
  dval=(float)idval/10;
  off=7000;
  nnum=save_rec[k].snum;
}        
else if(irain==2) 
{
  dval=hr24_rainfall_max/15.;
  idval=dval*10;
  dval=(float)idval/10;
  off=8000;
  nnum=save_rec[k].dnum;
}
 
line_width=1;
line_style=LineSolid;
cap_style=CapRound;
join_style=JoinRound;
 
XSetLineAttributes(display,gc1,line_width,line_style,
                   cap_style,join_style);
 
inum=save_rec[k].inum;
 
memcpy(&values,&save_rec[k].stn_values,
               10000*sizeof(struct stn_values));
 
XSetFont(display,gc1,font[1]);
yheight=info_font[1]->ascent;
 
rect[0].x=xs;
rect[0].y=ys;
rect[0].width=xz;
rect[0].height=yz;
 
XSetFunction(display,gc1,GXcopy);
XSetForeground(display,gc1,mmap[0]);
XSetBackground(display,gc1,mmap[0]);
XSetClipRectangles(display,gc1,0,0,rect,1,Unsorted);
 
width=xs+xz;
height=ys+yz;
 
xparm1=75;
yparm1=yheight*7;
xparm2=75;
yparm2=yheight*3;
 
XSetForeground(display,gc1,mmap[3]);
 
XDrawLine(display,bwindow[m],gc1,xs+xparm1,height-yparm2,width-xparm1,
          height-yparm2);
 
XDrawLine(display,bwindow[m],gc1,xs+xparm1,ys+yparm1,width-xparm1,
          ys+yparm1);
 
XDrawLine(display,bwindow[m],gc1,xs+xparm1,ys+yparm1,xs+xparm1,
          height-yparm2);
XDrawLine(display,bwindow[m],gc1,width-xparm1,ys+yparm1,width-xparm1,
          height-yparm2);
 
xmin=xs+xparm1+10;
xmax=width-xparm1-10;
ymin=ys+yparm1+10;
ymax=height-yparm2-10;
 
XSetForeground(display,gc1,mmap[7]);
 
if(inum==-1) 
{
  sprintf(buf,"%s %s not found in database",
  save_rec[k].sfile.sid,save_rec[k].sfile.hb5_id,save_rec[k].parm);
  XDrawString(display,bwindow[m],gc1,(xmax+xmin-200)/2,
             (ymax+ymin)/2,buf,strlen(buf));
  return;
}
 
XSetForeground(display,gc1,mmap[3]);
sprintf(buf,"%s",save_rec[k].sfile.name);
 
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight*6,
            buf,strlen(buf));
 
strcpy(tbuf,save_rec[k].parm);
 
/*
strcpy(abuf,stype[save_rec[k].sensortype].name);
*/
 
if(!strncmp(save_rec[k].parm,"HG",2) ||
   !strncmp(save_rec[k].parm,"HP",2) ||
   !strncmp(save_rec[k].parm,"PC",2) ||
   !strncmp(save_rec[k].parm,"TA",2) ||
   !strncmp(save_rec[k].parm,"QI",2) ||
   !strncmp(save_rec[k].parm,"SW",2))
{
  next_report(save_rec[k].sfile.hb5_id,save_rec[k].parm,next,debug);
  sprintf(abuf,"     (NEXT: %s)",next);
  strcat(tbuf,abuf);
}
 
sprintf(buf,"%s  %s",save_rec[k].sfile.hb5_id,tbuf);
 
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight*5,
            buf,strlen(buf));
 
sprintf(buf,"Elevation %d",(int)save_rec[k].sfile.elevation);
 
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight*4,
            buf,strlen(buf));
 
if(inum==0) 
{
  strcpy(buf,"NO DATA");
  XDrawString(display,bwindow[m],gc1,(xmax+xmin)/2,(ymax+ymin)/2,
                   buf,strlen(buf));
 
  save_rec[k].is_realized=1; 
  return;
}      
 
tm.tm_sec=0;
tm.tm_min=0;
tm.tm_hour=save_rec[k].btim.hour;
tm.tm_mday=save_rec[k].btim.day;
tm.tm_mon=save_rec[k].btim.month;
tm.tm_year=save_rec[k].btim.year;
 
lbtim=ouptime(tm.tm_year,tm.tm_mon,tm.tm_mday,tm.tm_hour,tm.tm_min,0);
 
tm.tm_sec=0;
tm.tm_min=0;
tm.tm_hour=save_rec[k].etim.hour;
tm.tm_mday=save_rec[k].etim.day;
tm.tm_mon=save_rec[k].etim.month;
tm.tm_year=save_rec[k].etim.year;
 
letim=ouptime(tm.tm_year,tm.tm_mon,tm.tm_mday,tm.tm_hour,tm.tm_min,0);
 
if(save_rec[k].parm[2]=='M') 
{
  totlin=(lbtim-letim)/(24L*3600L)+1;
  deltat=24;
  totyears=(lbtim-letim)/(24L*3600L*365L)+1;
  hour=0;
}
else 
{
  hour=0;
  if(tm.tm_hour > 0 && tm.tm_hour <=6)
                              hour=6-tm.tm_hour;    
  else if(tm.tm_hour > 6 && tm.tm_hour <=12)
                              hour=12-tm.tm_hour;    
  else if(tm.tm_hour > 12 && tm.tm_hour <=18)
                              hour=18-tm.tm_hour;    
  else if(tm.tm_hour > 18)
                              hour=24-tm.tm_hour;    
  deltat=get_delta_time(lbtim,letim);
  hour=24-tm.tm_hour;
  htflag=0;
 
  if(deltat>=24)
    htflag=1;
 
 maxtimes=(lbtim-letim)/(deltat*3600L);
 totdays=(lbtim-letim)/(24L*3600L)+1;
 totlin=totdays*24/deltat+4;
}
 
oday=-1;
savex=-1;
 
XSetForeground(display,gc1,mmap[2]);
 
 
for(i=0;i<=totlin;i++) {
 
             stim=letim+((i-4)*deltat*3600L) + hour*3600L;
 
             fxvalue=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
                     (float)(letim-stim);
 
             xvalue=fxvalue;
 
             if(xvalue > width-xparm1)
                                 break;
 
             if(xvalue < xs+xparm1)
                                 continue;
 
             if(savex==-1)
                      savex=xvalue;
 
             gm=gmtime(&stim);             
 
             if(save_rec[k].parm[2]=='M'){
 
                 if(gm->tm_mday==1 && gm->tm_mon==0) {
 
                XDrawLine(display,bwindow[m],gc1,xvalue,ys+yparm1,
                       xvalue,height-yparm2);
 
                if(totyears < 5)
                sprintf(buf,"%d/%d",gm->tm_mon+1,gm->tm_year);
 
                else
                sprintf(buf,"%d",gm->tm_year);
 
                text_width=XTextWidth(info_font[1],buf,strlen(buf));
                XDrawString(display,bwindow[m],gc1,xvalue-text_width/2,
                         height-yparm2+yheight*2,buf,strlen(buf));
  
                              }
 
                else if(gm->tm_mday==1 && totyears < 2) {
 
                sprintf(buf,"%d",gm->tm_mon+1);
                text_width=XTextWidth(info_font[1],buf,strlen(buf));
                XDrawString(display,bwindow[m],gc1,xvalue-text_width/2,
                         height-yparm2+yheight*2,buf,strlen(buf));
 
  
                              }
 
 
                            continue;
     
 
                   }
 
             XDrawLine(display,bwindow[m],gc1,xvalue,ys+yparm1,
                       xvalue,height-yparm2);
 
             if(oday != gm->tm_mday) {
             
                   if(gm->tm_hour==0 || htflag==1) {
 
                sprintf(buf,"%d/%d",gm->tm_mon+1,gm->tm_mday);
                text_width=XTextWidth(info_font[1],buf,strlen(buf));
                XDrawString(display,bwindow[m],gc1,xvalue-text_width/2,
                         height-yparm2+yheight*2,buf,strlen(buf));
 
                oday=gm->tm_mday;
 
                               }
 
                         }
 
             h=gm->tm_hour;
 
             qflag=0;
 
             if(deltat==1) {
 
                         if(h==0 || h==2 || h==4 || h==6 || h==8 ||   
                            h==10 || h==12 || h==14 || h==16 || 
                            h==18 || h==20 || h==22)
                                               qflag=1;
 
                          }
 
             else if(deltat==3 && totdays <= 2) {
 
                    
                         if(h==0 || h==3 || h==6 || h==9 || h==12 ||
                            h==15 || h==18 || h==21)
                                               qflag=1;
 
                              }
 
             else if(deltat==3) {
 
                         if(h==0 || h==6 || h==12 || h==18)
                                               qflag=1;
 
                              }
 
             else if(deltat==6) {
 
                         if(h==0 || h==12)
                                               qflag=1;
 
                             }
 
             else if(deltat==24) {
 
                         if(h==12)
                                               qflag=1;
 
                               }
 
             if(qflag==0)
                         continue;
 
             sprintf(buf,"%d",gm->tm_hour);
             text_width=XTextWidth(info_font[1],buf,strlen(buf));
             XDrawString(display,bwindow[m],gc1,xvalue-text_width/2,
                         height-yparm2+yheight,buf,strlen(buf));
 
            }
 
max_min=get_max_min(values,inum);
maxv=max_min.max + 1;
 
minv=max_min.min - 1;
 
if(maxv-max_min.max < .4)
  maxv++;
 
if(minv-max_min.min > .4)
  minv--;
 
if(save_rec[k].volume!=0)
  minv=0;
         
/* get min and max if scale by flood */
               
if(scale==1 && save_rec[k].rate_table.AryMax > 0) 
{
  fminv=getstage(save_rec[k].sfile.hb5_id,save_rec[k].parm,0,&ierr);
  if(ierr >= 0 && ierr <= 2)
    minv=fminv;
  else
    minv=save_rec[k].rate_table.RatStg[0]; 
}
                        
if(scale==1 && save_rec[k].rate_table.AryMax >= 0) 
{
  if(save_rec[k].rate_table.fld > 0 && 
     max_min.max < save_rec[k].rate_table.fld) 
    maxv= save_rec[k].rate_table.fld + 2;
 
  else if(save_rec[k].rate_table.wrn > 0 && 
          max_min.max < save_rec[k].rate_table.wrn) 
    maxv= save_rec[k].rate_table.wrn + 2;
}
 
if(ilinear==1) 
{
  sminv=minv;
  smaxv=maxv;
  minv=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
              (double)minv, &ierr);
  maxv=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
              (double)maxv,&merr);
  if(ierr < 0 || merr < 0) 
  {
    ilinear=0;
    minv=sminv;
    maxv=smaxv;
  }
}
 
deltav=get_delta_valu(maxv-minv);
maxvalues=(maxv-minv)/(deltav);
 
lines=0;
 
for(i=0;i<=maxvalues+2;i++) 
{
  svalue=(float)minv+(i*deltav);
  fyvalue=ymax-(float)(ymin-ymax)/(float)(minv-maxv)*
          (float)(svalue-minv);
 
  yvalue=fyvalue;
  if(yvalue < ys+yparm1 || yvalue > height-yparm2)
    continue;
             
  XSetForeground(display,gc1,mmap[2]);
 
  if(lines==0 && save_rec[k].volume != 0)
    XSetForeground(display,gc1,mmap[9]);
  else
    XSetForeground(display,gc1,mmap[2]);
  lines++;
       
  XDrawLine(display,bwindow[m],gc1,xs+xparm1,yvalue,
            width-xparm1,yvalue);
 
  if(ilinear==0 && save_rec[k].parm[0]!='Q') 
  {
    XSetForeground(display,gc1,mmap[2]);
    sprintf(buf,"%6.1f",svalue);
    xvalue=width-xparm1+2;
  }
 
  else  
  {
    flow=(int)svalue;
    sprintf(buf,"%d",flow);
 
    text_width=XTextWidth(info_font[1],buf,strlen(buf));
    xvalue=xs+xparm1-text_width;
    XSetForeground(display,gc1,mmap[2]);
  }
 
  for(j=0;j<6;j++)
    if(buf[j] != ' ')
      break;
  
  XDrawString(display,bwindow[m],gc1,xvalue,
              yvalue+yheight/2,&buf[j],strlen(&buf[j]));
 
  buf[0]=0;
 
  if(irain >= 0) 
  {
    svalue=i*dval;
    rmaxv=svalue;
    sprintf(buf,"%3.1f",svalue);
    text_width=XTextWidth(info_font[1],buf,strlen(buf));
    xvalue=xs+xparm1-text_width;            
  }
  else if(save_rec[k].rate_table.AryMax <= 0)
    continue;
                                              
  else 
  {
    if(ilinear==0) 
      flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                   (double)svalue,&ierr);
    else 
    {
      stage=getstage(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                     (int)svalue,&ierr);
      svalue=stage;
    }
 
    if(ilinear==1 && save_rec[k].parm[0]!='Q') 
    {
      sprintf(buf,"%6.1f",svalue);
      xvalue=width-xparm1+2;
    }
    else if(ierr>=0) 
    {
      sprintf(buf,"%d",flow);
      text_width=XTextWidth(info_font[1],buf,strlen(buf));
      xvalue=xs+xparm1-text_width;
    }
  }
 
  for(j=0;j<6;j++)
    if(buf[j] != ' ')
      break;
     
  XSetForeground(display,gc1,mmap[2]);
  XDrawString(display,bwindow[m],gc1,xvalue,
              yvalue+yheight/2,&buf[j],strlen(&buf[j]));
}  
 
line_width=1;
line_style=LineOnOffDash;
cap_style=CapRound;
join_style=JoinRound;
 
XSetLineAttributes(display,gc1,line_width,line_style,
                   cap_style,join_style);
 
if(save_rec[k].rate_table.AryMax > 0)
{ 
  if(ilinear==0)
    fld=save_rec[k].rate_table.HMax;
  else     
  {
    flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                 (double)save_rec[k].rate_table.HMax,&ierr);
    fld=(double)flow;
  }
 
  fyvalue=ymax-(float)(ymin-ymax)/(float)(minv-maxv)*(float)(fld-minv);
  yvalue=fyvalue;
             
  XSetForeground(display,gc1,mmap[8]);
 
 if(yvalue > ys+yparm1 && yvalue < height-yparm2)
   XDrawLine(display,bwindow[m],gc1,xs+xparm1,
             yvalue,width-xparm1,yvalue);
}
 
if(save_rec[k].rate_table.AryMax >= 0 && 
   save_rec[k].rate_table.wrn > 0 ) 
{
  if(ilinear==0)
    wrn=save_rec[k].rate_table.wrn;
 
  else     
  {
    flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                 (double)save_rec[k].rate_table.wrn,&ierr);
    wrn=(double)flow;
  }
 
  fyvalue=ymax-(float)(ymin-ymax)/
         (float)(minv-maxv)*(float)(wrn-minv);
  yvalue=fyvalue;
             
  XSetForeground(display,gc1,mmap[5]);
 
  line_width=1;
  line_style=LineOnOffDash;
  cap_style=CapRound;
  join_style=JoinRound;
 
  XSetLineAttributes(display,gc1,line_width,line_style,
                     cap_style,join_style);
 
  if(yvalue > ys+yparm1 && yvalue < height-yparm2)
    XDrawLine(display,bwindow[m],gc1,xs+xparm1,yvalue,
              width-xparm1,yvalue);
 
}
 
if(save_rec[k].rate_table.AryMax >= 0 && 
   save_rec[k].rate_table.fld > 0 ) 
{
                 
  if(ilinear==0)
    fld=save_rec[k].rate_table.fld;
 
  else     
  {
    flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                 (double)save_rec[k].rate_table.fld,&ierr);
    fld=(double)flow;
  }
 
  fyvalue=ymax-(float)(ymin-ymax)/(float)(minv-maxv)*
          (float)(fld-minv);
  yvalue=fyvalue;
             
  XSetForeground(display,gc1,mmap[4]);
 
  if(yvalue > ys+yparm1 && yvalue < height-yparm2)
    XDrawLine(display,bwindow[m],gc1,xs+xparm1,yvalue,
              width-xparm1,yvalue);
}
 
line_width=1;
line_style=LineSolid;
cap_style=CapRound;
join_style=JoinRound;
 
XSetLineAttributes(display,gc1,line_width,line_style,
                   cap_style,join_style);
 
XSetForeground(display,gc1,mmap[3]);
 
if(save_rec[k].rate_table.AryMax >= 0 || save_rec[k].parm[0]=='Q') 
{
  xvalue=xs+10;
 
  if(save_rec[k].parm[1]=='G' || save_rec[k].parm[0]=='Q')                   
    strcpy(ubuf,"CFS");
  else
    strcpy(ubuf,"KAC-FT"); 
  len=strlen(ubuf);
  ybegin=ymin+((ymax-ymin) - len*yheight)/2;
 
  if(ybegin < ymin)
    ybegin=ymin;
 
  for(i=0;i<len;i++) 
  {
    xbuf[0]=ubuf[i];
    xbuf[1]=0;
 
    yvalue=ybegin+i*yheight;
    XDrawString(display,bwindow[m],gc1,xvalue,
                yvalue,xbuf,strlen(xbuf));
  }
}
 
                   
xvalue=width-20;
 
/*
strcpy(ubuf,stype[save_rec[k].sensortype].units_abbr);
 
len=strlen(ubuf);
 
ybegin=ymin+((ymax-ymin) - len*yheight)/2;
 
if(ybegin < ymin)
  ybegin=ymin;
 
for(i=0;i<len;i++) 
{
  xbuf[0]=ubuf[i];
  xbuf[1]=0;
 
  yvalue=ybegin+i*yheight;
  XDrawString(display,bwindow[m],gc1,xvalue,
              yvalue,xbuf,strlen(xbuf));
}
*/
 
XSetForeground(display,gc1,mmap[7]);
 
 
if(irain >=0) 
{
  odx=-1;
  XSetForeground(display,gc1,mmap[3]);
 
  xvalue=xs+10;
 
  strcpy(ubuf,"Inches");
                   
  len=strlen(ubuf);
 
  ybegin=ymin+((ymax-ymin) - len*yheight)/2;
 
  if(ybegin < ymin)
    ybegin=ymin;
 
  for(i=0;i<len;i++) 
  {
    xbuf[0]=ubuf[i];
    xbuf[1]=0;
 
    yvalue=ybegin+i*yheight;
    XDrawString(display,bwindow[m],gc1,xvalue,
                yvalue,xbuf,strlen(xbuf));
  }
 
  for(i=0;i<nnum;i++) 
  {
     stim=values[i+off].clock;
     fxvalue=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
             (float)(letim-stim);
                     
     fxvalue1=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
              (float)(letim-values[i+off+1].clock);
 
     if(fxvalue > xmax || fxvalue1 > xmax)
       continue;
 
     svalue=values[i+off].value;
 
     fyvalue=ymax-(float)(ymin-ymax)/(float)(rminv-rmaxv)*
             (float)(svalue-rminv);
 
     yvalue=fyvalue+.5;
     xvalue=fxvalue+.5;
                            
     dxvalue=fxvalue-fxvalue1;
               
     dvalue=dxvalue+.5;
 
     if(dvalue < 2)
       dvalue=2;
 
     if(svalue < 0) 
     {
       XSetForeground(display,gc1,mmap[9]);
                   
       ix1=xvalue;
       ix2=xvalue-dvalue;
                   
       if(ix1 < savex)
         ix1=savex;
                               
       if(ix2 < savex)
         ix2=savex;
 
       XDrawLine(display,bwindow[m],gc1,ix2,ymax,ix1,ymax);
 
     }
                         
     else if(ymax-yvalue==0) 
     {               
        XSetForeground(display,gc1,mmap[5]);
        ix1=xvalue;
        ix2=xvalue-dvalue;
        if(ix1 < savex)
          ix1=savex;
        if(ix2 < savex)
          ix2=savex;
        XDrawLine(display,bwindow[m],gc1,ix2,ymax,ix1,ymax);
     }
 
     else 
     {
       XSetForeground(display,gc1,mmap[5]);
                   
       ix1=xvalue;
       ix2=xvalue-dvalue;
                   
       if(ix1 < savex)
         ix1=savex;
                               
       if(ix2 < savex)
         ix2=savex;
  
       dx=ix1-ix2-1;
  
       if(odx > 0) 
       {
         if(ix2+dx >= odx)
           dx=odx-ix2-1;
       }
                 
       /* modified from dx==0 rkh 2/01 */
       if(dx<=0)
         dx=1;
       XFillRectangle(display,bwindow[m],gc1,
                      ix2,yvalue,dx,ymax-yvalue+1);
 
     }
          
     odx=ix2;
     xvalue1=xvalue;
     yvalue1=yvalue;
     otim=stim;
     oqual=values[i+off].qual;
  }
}
 
 
if(save_rec[k].volume!= 0) 
{   
  for(i=0;i<inum;i++) 
  {
 
    tm.tm_year=values[i].zdate/10000-1900;
    tm.tm_mon=(values[i].zdate-(tm.tm_year+1900)*10000)/100;
    tm.tm_mday=values[i].zdate-(tm.tm_year+1900)*10000-tm.tm_mon*100;
    tm.tm_hour=values[i].ztime/10000;
    tm.tm_min=(values[i].ztime-tm.tm_hour*10000)/100;
 
    tm.tm_mon=tm.tm_mon;
    stim=ouptime(tm.tm_year+1900,tm.tm_mon,tm.tm_mday,
                 tm.tm_hour,tm.tm_min,0);
               
    fxvalue=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
          (float)(letim-stim);
 
    svalue=values[i].value;
 
    fyvalue=ymax-(float)(ymin-ymax)/(float)(minv-maxv)*
            (float)(svalue-minv);
 
    yvalue=fyvalue+.5;
    xvalue=fxvalue+.5;
              
    dxvalue=-(float)(xmax-xmin)/(float)(letim-lbtim)*
            (float)(3600*save_rec[k].volume);
 
    dvalue=dxvalue+.5;
 
    if(dvalue < 2)
      dvalue=2;
     
    if(ymax - yvalue == 0 && i > 0) 
    {
      if(oqual != 'Q')
        XSetForeground(display,gc1,mmap[7]);
      else
        XSetForeground(display,gc1,mmap[9]);
 
      XDrawLine(display,bwindow[m],gc1,xvalue-dvalue,ymax,
                xvalue,ymax);
    }
 
    else 
    {
      if(ymax-yvalue==0)
        XSetForeground(display,gc1,mmap[3]);
      else
        XSetForeground(display,gc1,mmap[7]);
 
      XFillRectangle(display,bwindow[m],gc1,
                     xvalue-dvalue,yvalue,
                     dvalue-1,ymax-yvalue+1);
    }
    xvalue1=xvalue;
    yvalue1=yvalue;
    otim=stim;
    oqual=values[i].qual;
  }
}
else 
{
  for(i=0;i<inum;i++) 
  {
    tm.tm_year=values[i].zdate/10000-1900;
    tm.tm_mon=(values[i].zdate-(tm.tm_year+1900)*10000)/100;
    tm.tm_mday=values[i].zdate-(tm.tm_year+1900)*10000-tm.tm_mon*100;
    tm.tm_hour=values[i].ztime/10000;
    tm.tm_min=(values[i].ztime-tm.tm_hour*10000)/100;
    tm.tm_mon=tm.tm_mon;
    stim=ouptime(tm.tm_year+1900,tm.tm_mon,tm.tm_mday,tm.tm_hour,tm.tm_min,0);
    fxvalue=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
          (float)(letim-stim);
 
    svalue=values[i].value;
 
    if(ilinear==1) 
    {    
      flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
                   svalue,&ierr);
      svalue=(double)flow;
    }
 
    fyvalue=ymax-(float)(ymin-ymax)/(float)(minv-maxv)*
            (float)(svalue-minv);
 
    yvalue=fyvalue;
    xvalue=fxvalue;
               
    if((oqual=='O' && values[i].qual !='O') ||
       (oqual!='O' && values[i].qual =='O')) 
      goto skippy;
                   
    if(oqual=='Q' || values[i].qual =='Q')
      XSetForeground(display,gc1,mmap[9]);
                   
    else if(oqual=='O' || values[i].qual =='O')
          XSetForeground(display,gc1,mmap[10]);
 
    else 
      XSetForeground(display,gc1,mmap[7]);
              
    if(i > 0) 
    {
      if(otim-stim < 7200L) 
      {
        line_width=1;
        line_style=LineSolid;
        cap_style=CapRound;
        join_style=JoinRound;
 
        XSetLineAttributes(display,gc1,line_width,line_style,
                           cap_style,join_style);
 
        XDrawLine(display,bwindow[m],gc1,xvalue,yvalue,
                  xvalue1,yvalue1);
      }
      else 
      {
        line_width=1;
        line_style=LineOnOffDash;
        cap_style=CapRound;
        join_style=JoinRound;
 
        XSetLineAttributes(display,gc1,line_width,line_style,
                           cap_style,join_style);
 
        XDrawLine(display,bwindow[m],gc1,xvalue,yvalue,
                 xvalue1,yvalue1);
      }
    }
    skippy:
    xvalue1=xvalue;
    yvalue1=yvalue;
    otim=stim;
    oqual=values[i].qual;
  }
}
 
XSetForeground(display,gc1,mmap[3]);
 
if(save_rec[k].rate_table.AryMax > 0) 
  flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
               (double)max_min.omax,&ierr);
 
if(save_rec[k].parm[0]=='Q')
{
  sprintf(buf,"Max=%7d CFS",(int)max_min.omax);
}
else
  sprintf(buf,"Max=%7.1f",max_min.omax);
 
if(save_rec[k].rate_table.AryMax > 0 && ierr >= 0) 
{
  if(save_rec[k].parm[1]=='G')     
    sprintf(abuf," %d CFS",flow); 
  else 
    sprintf(abuf," %6.2f KAC-FT",((float)flow+0.5)/1000.);
  strcat(buf,abuf);
}
 
sprintf(abuf," at %02d/%02d/%04d %02d:%02dZ",
        max_min.otmx.tm_mon,max_min.otmx.tm_mday,max_min.otmx.tm_year+1900,
        max_min.otmx.tm_hour,max_min.otmx.tm_min);
 
strcat(buf,abuf);
 
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight*3,
                 buf,strlen(buf));
 
if(save_rec[k].rate_table.AryMax > 0) 
                      flow=getflow(save_rec[k].sfile.hb5_id,
                                   save_rec[k].parm,
                                   (double)max_min.omin,&ierr);
 
if(save_rec[k].parm[0]=='Q')
{
  sprintf(buf,"Min=%7d CFS",(int)max_min.omin);
}
else
  sprintf(buf,"Min=%7.1f",max_min.omin);
 
if(save_rec[k].rate_table.AryMax > 0 && ierr >=0) 
{
  if(save_rec[k].parm[1]=='G')   
    sprintf(abuf," %d CFS",flow); 
  else
    sprintf(abuf," %6.2f KAC-FT",((float)flow+0.5)/1000.);
  strcat(buf,abuf);
}
 
sprintf(abuf," at %02d/%02d/%04d %02d:%02dZ",
        max_min.otmn.tm_mon,max_min.otmn.tm_mday,max_min.otmn.tm_year+1900,
        max_min.otmn.tm_hour,max_min.otmn.tm_min);
 
strcat(buf,abuf);
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight*2,
                 buf,strlen(buf));
 
for(i=0;i<inum;i++)
                if(values[i].qual != 'O')
                                      break;
 
tm.tm_year=values[i].zdate/10000-1900;
tm.tm_mon=(values[i].zdate-(tm.tm_year+1900)*10000)/100;
tm.tm_mday=values[i].zdate-(tm.tm_year+1900)*10000-tm.tm_mon*100;
tm.tm_hour=values[i].ztime/10000;
tm.tm_min=(values[i].ztime-tm.tm_hour*10000)/100;
svalue=values[i].value;
                                     
if(save_rec[k].parm[0]=='Q')
{
  sprintf(buf,"Last=%7d CFS",(int)svalue);
}
else
sprintf(buf,"Last=%6.1f",svalue);
        
if(save_rec[k].rate_table.AryMax > 0) 
  flow=getflow(save_rec[k].sfile.hb5_id,save_rec[k].parm,
               (double)svalue,&ierr);
 
if(save_rec[k].rate_table.AryMax > 0 && ierr >=0) 
{
  if(save_rec[k].parm[1]=='G')   
    sprintf(abuf," %d CFS",flow); 
  else
    sprintf(abuf," %6.2f KAC-FT",((float)flow+0.5)/1000.);
  strcat(buf,abuf);
}
 
sprintf(abuf," at %02d/%02d/%04d %02d:%02dZ",
        tm.tm_mon,tm.tm_mday,tm.tm_year+1900,tm.tm_hour,tm.tm_min);
 
strcat(buf,abuf);        
XDrawString(display,bwindow[m],gc1,xs+xparm1,ys+yparm1-yheight,
                 buf,strlen(buf));
 
stim=time(NULL);
 
fxvalue=xmin+(float)(xmax-xmin)/(float)(letim-lbtim)*
                     (float)(letim-stim);
 
xvalue=fxvalue;
 
if(xvalue >= xs+xparm1 && xvalue <= width-xparm1) {
 
       line_width=1;
       line_style=LineOnOffDash;
       cap_style=CapRound;
       join_style=JoinRound;
 
       XSetLineAttributes(display,gc1,line_width,line_style,
                          cap_style,join_style);
 
       XDrawLine(display,bwindow[m],gc1,xvalue,ys+yparm1,
                 xvalue,height-yparm2);
 
 
       }
             
 
save_rec[k].is_realized=1; 
 
}
 
 
struct max_min get_max_min(struct stn_values *stn_values,int inum)
 
{
 
struct max_min max_min;
int i,xdate,xtime,ndate,ntime;
double abs1,abs2;
 
max_min.max=-999999;
max_min.min= 999999;
 
for(i=0;i<inum;i++) {
 
           if(stn_values[i].value > max_min.max) {
 
                                     max_min.max=stn_values[i].value;
                                     xdate=stn_values[i].zdate;
                                     xtime=stn_values[i].ztime;
 
                                          }
 
           if(stn_values[i].value < max_min.min) {
 
                                     max_min.min=stn_values[i].value;
                                     ndate=stn_values[i].zdate;
                                     ntime=stn_values[i].ztime;
 
                                                  }
 
 
               }
 
max_min.tmx.tm_year=xdate/10000-1900;
max_min.tmx.tm_mon=(xdate-(max_min.tmx.tm_year+1900)*10000)/100;
max_min.tmx.tm_mday=xdate-(max_min.tmx.tm_year+1900)*10000-max_min.tmx.tm_mon*100;
max_min.tmx.tm_hour=xtime/10000;
max_min.tmx.tm_min=(xtime-max_min.tmx.tm_hour*10000)/100;
max_min.tmx.tm_mon=max_min.tmx.tm_mon;
 
max_min.tmn.tm_year=ndate/10000-1900;
max_min.tmn.tm_mon=(ndate-(max_min.tmn.tm_year+1900)*10000)/100;
max_min.tmn.tm_mday=ndate-(max_min.tmn.tm_year+1900)*10000-max_min.tmn.tm_mon*100;
max_min.tmn.tm_hour=ntime/10000;
max_min.tmn.tm_min=(ntime-max_min.tmn.tm_hour*10000)/100;
max_min.tmn.tm_mon=max_min.tmn.tm_mon;
 
max_min.omax=-999999;
max_min.omin= 999999;
 
for(i=0;i<inum;i++) 
{
  if(stn_values[i].qual=='O')
    continue;
 
  if(stn_values[i].value > max_min.omax) 
  {
     max_min.omax=stn_values[i].value;
     xdate=stn_values[i].zdate;
     xtime=stn_values[i].ztime;
  }
 
  if(stn_values[i].value < max_min.omin) 
  {
     max_min.omin=stn_values[i].value;
     ndate=stn_values[i].zdate;
     ntime=stn_values[i].ztime;
  }
}
 
max_min.otmx.tm_year=xdate/10000-1900;
max_min.otmx.tm_mon=(xdate-(max_min.otmx.tm_year+1900)*10000)/100;
max_min.otmx.tm_mday=xdate-(max_min.otmx.tm_year+1900)*10000-max_min.otmx.tm_mon*100;
max_min.otmx.tm_hour=xtime/10000;
max_min.otmx.tm_min=(xtime-max_min.otmx.tm_hour*10000)/100;
max_min.otmx.tm_mon=max_min.otmx.tm_mon;
 
max_min.otmn.tm_year=ndate/10000-1900;
max_min.otmn.tm_mon=(ndate-(max_min.otmn.tm_year+1900)*10000)/100;
max_min.otmn.tm_mday=ndate-(max_min.otmn.tm_year+1900)*10000-max_min.otmn.tm_mon*100;
max_min.otmn.tm_hour=ntime/10000;
max_min.otmn.tm_min=(ntime-max_min.otmn.tm_hour*10000)/100;
max_min.otmn.tm_mon=max_min.otmn.tm_mon;
 
return(max_min);
            
}
 
int get_delta_time(time_t lbtim,time_t letim)
 
{
 
int hours,dhours;
 
hours=(lbtim-letim)/3600L;
 
if(hours < 24)
        dhours=1;
 
else if(hours < 96)
        dhours=3;
 
else if(hours < 144)
        dhours=6;
 
else if(hours < 288)
        dhours=24;
 
else if(hours < 576)
        dhours=48;
 
else if(hours < 1152)
        dhours=72;
 
else if(hours < 2304)
        dhours=96;
 
else if(hours < 4608)
        dhours=192;
 
else
        dhours=30*24;
 
return(dhours);
 
}
 
float get_delta_valu(int diff)
 
{
 
float dval;
 
if(diff <= 1)
     dval=.1;
 
else if(diff < 4)
     dval=.2;
 
else if(diff < 10)
     dval=.5;
 
else if(diff < 20)
     dval=1;
 
else if(diff < 40)
     dval=2;
 
else if(diff < 100)
     dval=5;
 
else if(diff < 200)
     dval=10;
 
else if(diff < 400)
     dval=20;
 
else if(diff < 1000)
     dval=50;
 
else if(diff < 2000)
     dval=100;
 
else if(diff < 4000)
     dval=200;
 
else if(diff < 10000)
     dval=500;
 
else if(diff < 20000)
     dval=1000;
 
else if(diff < 40000)
     dval=2000;
 
else if(diff < 100000)
     dval=5000;
 
else if(diff < 200000)
     dval=10000;
 
else if(diff < 400000)
     dval=20000;
 
else if(diff < 1000000)
     dval=50000;
 
else if(diff < 2000000)
     dval=100000;
 
else if(diff < 4000000)
     dval=200000;
 
else
     dval=1000000;
 
return(dval);
 
}
 
void options_draw(Widget w,XtPointer data,XmDrawingAreaCallbackStruct *call_data)
 
{
 
int k,j;
Dimension width,height;
Arg args[10];
int i;
int mstart;
int m;
 
j=(int)data/100;
 
k=(int)data-j*100;
 
if(save_rec[j].parm[0]=='H') 
{
  XtSetArg(args[0],XmNset,False);   
 
  if(k==0 || k==1)
    mstart=4;
  else
    mstart=6;
         
  for(m=mstart;m<mstart+2;m++)       
    XtSetValues(save_rec[j].mbutton[m],args,1);
 
  XtSetArg(args[0],XmNset,True);   
  XtSetValues(save_rec[j].mbutton[k+4],args,1);
 
 
  if(k==0)
    save_rec[j].linear=0;
 
  if(k==1)
    save_rec[j].linear=1;
 
  if(k==2)
    save_rec[j].scale=0;
 
  if(k==3)
    save_rec[j].scale=1;
       
}
 
XtSetArg(args[0],XtNwidth,&width);
XtSetArg(args[1],XtNheight,&height);
XtGetValues(bdrawing_area[j],args,2);
 
XSetFunction(display,gc1,GXcopy);
XSetForeground(display,gc1,mmap[0]);
XSetBackground(display,gc1,mmap[0]);
XFillRectangle(display,bwindow[j],gc1,0,0,width,height);
 
draw_area(j,j,0,0,width,height);
  
}
 
void options_rain(Widget w,XtPointer data,XmDrawingAreaCallbackStruct *call_data)
{
int k,j;
Dimension width,height;
Arg args[10];
int i;
int m;
 
j=(int)data/100;
k=(int)data-j*100;
 
if(strncmp(save_rec[j].parm,"PCI",3)==0 ||
               strncmp(save_rec[j].parm,"PCH",3)==0)
{
         
  XtSetArg(args[0],XmNset,False);   
  for(m=0;m<4;m++)       
    XtSetValues(save_rec[j].mbutton[m],args,1);
 
  XtSetArg(args[0],XmNset,True);   
  XtSetValues(save_rec[j].mbutton[k],args,1);
        
  if(k==0)
    save_rec[j].rain=0;
  if(k==1)
    save_rec[j].rain=1;
  if(k==2)
    save_rec[j].rain=2;
  if(k==3)
    save_rec[j].rain=-1;
}
 
XtSetArg(args[0],XtNwidth,&width);
XtSetArg(args[1],XtNheight,&height);
XtGetValues(bdrawing_area[j],args,2);
 
XSetFunction(display,gc1,GXcopy);
XSetForeground(display,gc1,mmap[0]);
XSetBackground(display,gc1,mmap[0]);
XFillRectangle(display,bwindow[j],gc1,0,0,width,height);
 
draw_area(j,j,0,0,width,height);
  
}
 
 
void quit_draw(Widget w,XtPointer data,XmDrawingAreaCallbackStruct *call_data)
 
{
  
int k;
 
k=(int)data;
 
XtDestroyWidget(bdrawing_area[k]);
XtDestroyWidget(draw_dialog[k]);
 
draw_dialog[k]=0;
save_rec[k].inum=-1;
 
}
 
void bhandle_expose(Widget w,XtPointer data,XmDrawingAreaCallbackStruct *call_data)
 
{
 
int k;
Dimension width,height;
Arg args[10];
 
k=(int)data;
 
XtSetArg(args[0],XtNwidth,&width);
XtSetArg(args[1],XtNheight,&height);
XtGetValues(bdrawing_area[k],args,2);
 
XSetFunction(display,gc1,GXcopy);
XSetForeground(display,gc1,mmap[0]);
XSetBackground(display,gc1,mmap[0]);
XFillRectangle(display,bwindow[k],gc1,0,0,
               width,height);
 
if(save_rec[k].is_realized==1) 
     draw_area(k,k,0,0,width,height);
 
XmUpdateDisplay(bdrawing_area[k]);
 
if(print_flag==1)
          print_bdraw(k);
 
}
 
int get_hourly(int k)
 
{
 
int year,mon,mday,hour,min,sec;
time_t lbtim,letim;
struct tm *gm;
int hours;
time_t htime[2000],dtime[1000],xtime[500];
int i,ii,m;
time_t tim2;
struct rainfall r;
struct stim btim;
struct stim etim;
int dhours,shours;
 
sec=0;
min=0;
hour=save_rec[k].btim.hour;
mday=save_rec[k].btim.day;
mon=save_rec[k].btim.month;
year=save_rec[k].btim.year;
 
lbtim=ouptime(year,mon,mday,hour,min,0);
 
hour=save_rec[k].etim.hour;
mday=save_rec[k].etim.day;
mon=save_rec[k].etim.month;
year=save_rec[k].etim.year;
 
letim=ouptime(year,mon,mday,hour,min,0);
 
gm=gmtime(&lbtim);
 
hours=(lbtim-letim)/3600;
 
if(hours > 2000)
           hours=2000;
 
tim2=lbtim-gm->tm_min*60;
                        
htime[0]=lbtim;
 
for(i=0;i<hours;i++)
          htime[i+1]=tim2-i*3600;
 
for(i=0;i<hours;i++) {
 
          etn_values[i].value=-99;
          etn_values[i].clock=htime[i];
          etn_values[i].qual='X';
 
          }
 
ii=0;
 
for(m=0;m<hours;m++) {
 
for (i=ii;i<save_rec[k].inum-1;i++) {
 
              if(htime[m] > save_rec[k].stn_values[i].clock) {
               
                                   etn_values[m].value=-99;
                                
                                   
                                   break;
                                   
                                   }
              
              
              else if(htime[m] <= save_rec[k].stn_values[i].clock &&
                      htime[m] > save_rec[k].stn_values[i+1].clock) {
                 
                 
                  etn_values[m].value=
                  save_rec[k].stn_values[i].value+
                  (save_rec[k].stn_values[i].value-
                  save_rec[k].stn_values[i+1].value)/
                  (save_rec[k].stn_values[i].clock-save_rec[k].stn_values[i+1].clock)
                  *(-save_rec[k].stn_values[i].clock+htime[m]); 
                                
                  etn_values[m].qual='S';
                  
       
                  break;  
                                             
                       }           
 
}
 
ii=i;              
 
}
 
dhours=hours/24+2;
 
if(gm->tm_hour < 12)
              tim2=lbtim-(gm->tm_hour+12)*3600 - gm->tm_min*60;
 
else
              tim2=lbtim-(gm->tm_hour-12)*3600 - gm->tm_min*60;
 
dtime[0]=lbtim;
 
for(i=0;i<dhours;i++) 
          dtime[i+1]=tim2-i*86400;
 
shours=hours/4 +1;
 
xtime[0]=lbtim;
tim2=lbtim-(gm->tm_hour-(gm->tm_hour/6)*6) *3600 - gm->tm_min*60;
 
for(i=0;i<shours;i++)
          xtime[i+1]=tim2-i*3600*6;
          
 
for(i=0;i<hours;i++)  
{                         
  save_rec[k].stn_values[i+5000].value=
  get_rain(etn_values,save_rec[k].parm,
           hours,htime[i],htime[i+1],&r);
  save_rec[k].stn_values[i+5000].clock=htime[i];
}
 
for(i=0;i<dhours;i++)  
{                         
  save_rec[k].stn_values[i+8000].value=
  get_rain(etn_values,save_rec[k].parm,
           hours,dtime[i],dtime[i+1],&r);
  save_rec[k].stn_values[i+8000].clock=dtime[i];
}
 
for(i=0;i<shours;i++)  
{                         
  save_rec[k].stn_values[i+7000].value=
  get_rain(etn_values,save_rec[k].parm,
           hours,xtime[i],xtime[i+1],&r);
  save_rec[k].stn_values[i+7000].clock=xtime[i];
}
 
save_rec[k].hnum=hours;
save_rec[k].dnum=dhours;
save_rec[k].snum=shours;
}
 
Widget BuildPulldownsubToggleMenu(Widget parent,char *menu_title,char menu_mnemonic,struct MenuItem *items)
 
 
{
 
  Widget Pulldown, button;
  int i;
  int argcount;
  Arg args[10];
  
  argcount=0;
 
  XtSetArg(args[argcount],XmNbackground,mmap[1]);argcount++;
  XtSetArg(args[argcount],XmNforeground,mmap[0]);argcount++;
  Pulldown=XmCreatePulldownMenu(parent,"pulldown",args,argcount);
  
  for(i=0;items[i].label!=NULL;i++) {  
  
         argcount=0;
 
         XtSetArg(args[argcount],XmNbackground,mmap[1]);argcount++;
         XtSetArg(args[argcount],XmNforeground,mmap[0]);argcount++; 
         XtSetArg(args[argcount],XmNselectColor,mmap[4]);argcount++;
         
         if(items[i].def==1)  
                    XtSetArg(args[argcount],XmNset,True);         
         
         else  
                    XtSetArg(args[argcount],XmNset,False);
         
         argcount++;           
 
         mpbutton[i]=XmCreateToggleButton(Pulldown,items[i].label,args,argcount);  
         XtAddCallback(mpbutton[i],XmNvalueChangedCallback,items[i].callback,items[i].callback_data);
 
         XtManageChild(mpbutton[i]);
 
       }
 
  return(Pulldown);
 
}
Widget BuildPulldownsubPushMenu(Widget parent,char *menu_title,char menu_mnemonic,struct MenuItem *items)
 
 
{
 
  Widget Pulldown, button;
  int i;
  int argcount;
  Arg args[10];
  
  argcount=0;
 
  XtSetArg(args[argcount],XmNbackground,mmap[1]);argcount++;
  XtSetArg(args[argcount],XmNforeground,mmap[0]);argcount++;
  
  Pulldown=XmCreatePulldownMenu(parent,"pulldown",args,argcount);
 
  for(i=0;items[i].label!=NULL;i++) {
  
         argcount=0;
 
         XtSetArg(args[argcount],XmNbackground,mmap[1]);argcount++;
         XtSetArg(args[argcount],XmNforeground,mmap[0]);argcount++;
  
         if(items[i].accel!=NULL) {
     
             XtSetArg(args[argcount],XmNaccelerator,items[i].accel);argcount++;
             XtSetArg(args[argcount],XmNacceleratorText,items[i].accel_text);argcount++;
         
         }
    
         button=XmCreatePushButton(Pulldown,items[i].label,args,argcount);  
         XtAddCallback(button,XmNactivateCallback,items[i].callback,
                       items[i].callback_data);
         XtManageChild(button);
 
       }
 
return(Pulldown);
 
}
 
 
void print_me(Widget w,XtPointer data,XmDrawingAreaCallbackStruct *call_data)
 
{
 
print_flag=1;
 
bhandle_expose(w,data,call_data);
 
}
 
void print_bdraw(int k)
 
{
 
char cmd[200];
char tbuf[200];
time_t tim;
struct tm *gm;
 
tim=time(NULL);
gm=gmtime(&tim);
 
sprintf(tbuf,"/awips/hydroapps/rfc/local/apps/mapper/data/graph.%02d%02d%02d",
        gm->tm_hour,gm->tm_min,gm->tm_sec);
 
sprintf(cmd,"xwd -id %ld -out %s",bwindow[k],tbuf);
 
system(cmd);
 
sprintf(cmd,"/awips/hydroapps/rfc/local/apps/mapper/bin/print_graph %s &",tbuf);
system(cmd);
 
print_flag=0;
 
}