home *** CD-ROM | disk | FTP | other *** search
/ ftp.eri.u-tokyo.ac.jp / 2014.03.ftp.eri.u-tokyo.ac.jp.zip / ftp.eri.u-tokyo.ac.jp / pub / seisv / src / 3.02 / seisv.c < prev    next >
C/C++ Source or Header  |  1999-11-10  |  22KB  |  718 lines
  1. /********************************************************
  2.  *   SeisView client/alone                              *
  3.  *                                                      *
  4.  *   Copyright (C) 1992,1999  K.Koketsu                 *
  5.  *   Earthquake Research Institute, University of Tokyo *
  6.  *                                                      *
  7.  *                       Update History                 *
  8.  *                       1999.11.12 (3.02)  K.Koketsu   *
  9.  *                       1999.01.08 (3.01)  K.Koketsu   *
  10.  *                       1998.09.29 (3.00b) K.Koketsu   *
  11.  *                       1998.02.25 (3.00a) K.Koketsu   *
  12.  *                       1998.02.06 (3.00)  K.Koketsu   *
  13.  *                       1996.10.08 (2.02a) K.Koketsu   *
  14.  *                       1996.06.19 (2.02)  K.Koketsu   *
  15.  *                       1994.01.04 (2.01)  K.Koketsu   *
  16.  *                       1993.06.02 (2.00)  K.Koketsu   *
  17.  *                       1992.12.08 (1.03c) K.Koketsu   *
  18.  *                       1992.08.17 (1.03b) K.Koketsu   *
  19.  *                       1992.08.11 (1.03)  K.Koketsu   *
  20.  *                       1992.06.23 (1.02)  K.Koketsu   *
  21.  *                       1992.06.04 (1.01)  K.Koketsu   *
  22.  *                       1992.05.19 (1.00)  K.Koketsu   *
  23. /********************************************************/
  24. char     VERSION[] = "SeisView (Version 3.02  November 12, 1999)";
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <ctype.h>
  29. #include "ctlname.h"
  30. #include "seis.h"
  31.  
  32. char    *strupr();
  33. int      prompt();
  34. void     init(), dump_setup(), panel_input();
  35.  
  36. short    nmax, nmax2;                 /* maximum numbers of selected events  */
  37. char     fk[49*3+1];                  /* display strings for function keys   */
  38. char     help[64*11];                 /* help messages for function selection*/
  39.  
  40. int      itot;                                    /* total # selected events */
  41. short    isort;                                   /* flag for sorting        */
  42. char     drv$[65], prn$[5], port$[65], drvo$[65]; /* parameters for disk,prn */
  43. char     z$[11], w$[81];                          /* work string             */
  44. /***************************** variables for menu ****************************/
  45. char     em$[71];                                 /* error message on menu   */
  46. int     mx[42], my[42], ml[42];                  /* field variables         */
  47. char     mc$[42][9], md$[65], me$[65], mf$[65];   /* field strings           */
  48. short    isr = 0;                                 /* initial cursor position */
  49. short    kd[13];                                  /* function key definitions*/
  50. int     err = 0;                  /* error code             */
  51. int      mn, lm;     /* mn:number of fields, lm:row position of message area */
  52. extern char menuitem[10][10];
  53. /**************************** variables for retrieval ************************/
  54. extern char   f2$[6];
  55. extern char   y1$[5], m1$[3], d1$[3], h1$[3], n1$[3], s1$[5];
  56. extern char   y2$[5], m2$[3], d2$[3], h2$[3], n2$[3], s2$[5];
  57. extern char   dst$[11];
  58. extern char   so1$[4], som1$[3], so2$[4], som2$[3];
  59. extern char   sa1$[3], sam1$[3], sa2$[3], sam2$[3];
  60. extern char   sew1$[2], sew2$[2], sns1$[2], sns2$[2];
  61. extern char   dp1$[6], dp2$[6], mg1$[5], mg2$[5];
  62. extern char   ynh$[2], ynm$[2];
  63. /********************* parameters for map, graphics **************************/
  64. extern char   mps$[9], ync$[4];
  65. extern int    cdp[7], icd[7], ndp, nmg;
  66. extern double cmg[8], ro, ru;
  67.  
  68. void main(argc, argv)
  69. int  argc;
  70. char *argv[];
  71. {
  72.     int  fc;
  73.  
  74.     init();
  75.  
  76.     for(;;) {
  77.     fc = prompt(err);
  78.     err = 0;
  79.     switch( fc ) {
  80.         case CtlS: err = select_seis(); break;
  81.         case CtlB: err = browse()     ; break;
  82.         case CtlP: err = print()      ; break;
  83.         case CtlV: err = save()      ; break;
  84.         case CtlR: err = sort()       ; break;
  85.         case CtlM: err = map()      ; break;
  86.         case CtlT: err = time_seisv() ; break;
  87.         case CtlG: err = magnitude()  ; break;
  88.         case CtlO: err = option()      ; break;
  89.         default  : beep()             ; break;
  90.     }
  91.     }
  92. }
  93.  
  94. /*************************** INIT ***************** (Initialization process) */
  95. void init()
  96. {
  97.     short   n;
  98.  
  99.     if(getenv("SEIS") == NULL)  *drvo$ = 0;
  100.     else  strcpy(drvo$, getenv("SEIS"));
  101.  
  102.     map_init();         /* Initialize some values for mapping. */
  103.     win_init();
  104.     menu_init();
  105.     n = alloc_mem();    /* Allocate work memories. */
  106.  
  107.     nmax2 =  n / 2    * 4095;
  108.     nmax  = (n - n/2) * 4095;
  109.     itot = 0;  isort = 0;
  110.  
  111.     panel( INIT );
  112.     load_setup();       /* Load setup file. */
  113. }
  114.  
  115. /************************* FINISH ***************** (Termination of process) */
  116. void finish()
  117. {
  118.     dump_setup();
  119.     win_finish();
  120.     exit( 0 );
  121. }
  122.  
  123. /************* PANEL ************ (Draw a panel and construct an input menu) */
  124. char  *pan, init_pan[], option_pan[];
  125. extern char select_pan[], save_pan[], map_pan[], map1_pan[], map2_pan[],
  126.             maps2_pan[], maps3_pan[], maps4_pan[], maps5_pan[], maps6_pan[],
  127.             sort_pan[], help_pan[], time_pan[], magnit_pan[];
  128.  
  129. int panel( func )
  130. int  func;
  131. {
  132.     short  i, j, k, c;
  133.     char   pname[9], pxname[78], s[11], *mc;
  134.  
  135.     switch( func ) {
  136.     case INIT   : strcpy(pname, "INIT"   ); break;
  137.     case SELECT : strcpy(pname, "SELECT" ); break;
  138.     case SAVE   : strcpy(pname, "SAVE"   ); break;
  139.     case SORT   : strcpy(pname, "SORT"   ); break;
  140.     case MAP    : strcpy(pname, "MAP"    ); break;
  141.     case TIME   : strcpy(pname, "TIME"   ); break;
  142.     case MAGNIT : strcpy(pname, "MAGNIT" ); break;
  143.     case OPTION : strcpy(pname, "OPTION" ); break;
  144.     case HELP   : strcpy(pname, "HELP"   ); break;
  145.     case MAP1   : strcpy(pname, "MAP1"   ); break;
  146.     case MAP2   : strcpy(pname, "MAP2"   ); break;
  147.     case MAPS2  : strcpy(pname, "MAPS2"  ); break;
  148.     case MAPS3  : strcpy(pname, "MAPS3"  ); break;
  149.     case MAPS4  : strcpy(pname, "MAPS4"  ); break;
  150.     case MAPS5  : strcpy(pname, "MAPS5"  ); break;
  151.     case MAPS6  : strcpy(pname, "MAPS6"  ); break;
  152.     }
  153.     strcpy(pxname, drvo$);  add_separator( pxname );
  154.     strcpy(s, pname);  strcat(s, ".pan");  strlwr( s );
  155.     strcat(pxname, s);
  156.     windows_menu( func );
  157.  
  158. j100:
  159.     clear( 9 );
  160.     _normal_font();
  161.  
  162.     if(nmax==0 || nmax2==0) {
  163.     wblink();
  164.     mvaddstr( 9, 20, "Available memory is less than 128KB!");
  165.     mvaddstr(10, 20, "Click 'Exit' to exit.");
  166.     return( -1 );
  167.     }
  168.  
  169.     if(func == PRINT) {
  170.     mn = 0;
  171.     fkey( 0 ); /* Display function key definition.*/
  172.     wblink();
  173.     mvaddstr(5, 10, "Power on your printer and press Enter.");
  174.     standend();
  175.     }
  176.     else {
  177.     if(func!=INIT && func !=HELP) _wide_spacing();
  178.  
  179.     standend();
  180.     switch( func ) {
  181.         case INIT  : pan = init_pan  ; mn =  0; lm = 15; break;
  182.         case SELECT: pan = select_pan; mn = 32; lm = 14; break;
  183.         case SAVE  : pan = save_pan  ; mn =  1; lm =  8; break;
  184.         case SORT  : pan = sort_pan  ; mn =  4; lm = 11; break;
  185.         case MAP   : pan = map_pan   ; mn = 16; lm = 11; break;
  186.         case TIME  : pan = time_pan  ; mn = 18; lm = 13; break;
  187.         case MAGNIT: pan = magnit_pan; mn =  6; lm = 11; break;
  188.         case OPTION: pan = option_pan; mn =  3; lm = 17; break;
  189.         case HELP  : pan = help_pan  ; mn =  0; lm = 21; break;
  190.         case MAP1  : pan = map1_pan  ; mn = 24; lm = 23; break;
  191.         case MAP2  : pan = map2_pan  ; mn = 15; lm = 14; break;
  192.         case MAPS2 : pan = maps2_pan ; mn = 31; lm = 12; break;
  193.         case MAPS3 : pan = maps3_pan ; mn = 22; lm = 13; break;
  194.         case MAPS4 : pan = maps4_pan ; mn = 33; lm = 14; break;
  195.         case MAPS5 : pan = maps5_pan ; mn =  5; lm = 12; break;
  196.         case MAPS6 : pan = maps6_pan ; mn =  2; lm =  6; break;
  197.     }
  198.     for(i=0; i<lm; i++) {
  199.         strncpy(w$, pan+i*77, 77);
  200.         w$[77] = 0;
  201.         if(func == INIT) {
  202.         if(i == 8) show_machine();
  203.         if(i == 9) strcpy(w$+22, VERSION+9);
  204.         }
  205.         mvaddstr(i, 0, w$);
  206.     }
  207.     if(func!=INIT && func!=HELP) mvaddstr(lm, 0, " --->");
  208.  
  209.     if(mn == 0) {
  210.         fkey( -1 );
  211.         wrblink();
  212.         if(func == INIT)
  213.           mvaddstr(18, 22, "Press any key or button to begin.");
  214.         else
  215.           mvaddstr(22, 22, "Press any key or button to return.");
  216.         while(getcchr() == CtlE) check_exit();
  217.     }/* mn == 0 */
  218.  
  219.     else {
  220.         for(j=0; j<mn; j++) {
  221.         sscanf(pan+i*77+j*11,"%d, %d, %d",&mx[j],&my[j],&ml[j]);
  222.         }
  223.  
  224.         fkey( 0 ); /* Display function key definition.*/
  225.         standend();
  226.         /* Write menu headers. */
  227.         if(func!=MAPS6 && func!=OPTION) {
  228.         if(func == SELECT) {
  229.             move(0, 28);  clrtoeol();
  230.             printw(" Memory available for %d/%d events.", nmax, nmax2);
  231.         }
  232.         else {
  233.             move(0, 32);  clrtoeol();
  234.             printw("for %d events from %s.", itot, f2$);
  235.         }
  236.         }
  237.  
  238.         /* Write error message if exits */
  239.         if(*em$ != 0)  show_error_message( lm );
  240.  
  241.         _small_font();
  242.         for(i=0; i<mn; i++) {   /* Set defaults to fields */
  243.         if((k=ml[i]) > 100) k = k - 100;
  244.         if(k > 0) {
  245.             inputarea(mx[i], my[i], k);
  246.             wreverse();
  247.             if(k > 8) {
  248.             if(func == OPTION) {
  249.                 switch( i ) {
  250.                 case 0: mc = md$; break;
  251.                 case 1: mc = me$; break;
  252.                 case 2: mc = mf$; break;
  253.                 }
  254.             }
  255.             else  mc = md$;
  256.             }
  257.             else  mc = mc$[i];
  258.             j = strlen( mc );
  259.             for(c=j; c<k; c++)  mc[c] = ' ';
  260.             mc[k] = 0;
  261.             for(c=0; c<k; c++)  set_writable(my[i],mx[i]+c);
  262.             mvaddstr(my[i], mx[i], mc);
  263.         }
  264.         else {
  265.             if(k < -8) mvaddstr(my[i], mx[i], md$);
  266.             else  mvaddstr(my[i], mx[i], mc$[i]);
  267.         }
  268.         }
  269.         move(my[isr], mx[isr]);    /* Set cursor at initial position. */
  270.         wreverse();
  271.     } /* mn != 0 */
  272.     } /* func != PRINT */
  273.  
  274.     if(func==PRINT || mn>0) {
  275.     for(;;) {
  276.         c = getchr();
  277.         if(c == cr)  break;
  278.         switch( c ) {
  279.         case F1   : if(tcopy() == 0) show_error_message(lm);
  280.                     fkey(0); break;
  281.         case F3   : standend(); return(3);
  282.         case F6   : standend(); return(6);
  283.         case F9   : panel(HELP); goto j100;
  284.         case CtlE : check_exit(); break;
  285.         case ht   : mvtonext(mn); break;
  286.         case bs   : backspace() ; break;
  287.         case LEFT : move_left() ;
  288.                     if(! iswritable()) mvtoprevious(mn); break;
  289.         case RIGHT: move_right();
  290.                 if(! iswritable()) mvtonext(mn); break;
  291.         case DOWN : move_down(); break;
  292.         case UP   : move_up()  ; break;
  293.         case Home : mvhome()   ; break;
  294.         case End  : mvend()    ; break;
  295.         default:
  296.             if(c >= 0x200) {
  297.             c = c - 0x200;  move(c/80, c%80);
  298.             }
  299.             else if( isprint(c) ) {
  300.             if( iswritable() ) {
  301.                 addch( c );
  302.                 if( !iswritable() )  mvtonext( mn );
  303.             }
  304.             else  beep();
  305.             }
  306.             else  beep();
  307.             break;
  308.         }
  309.     }
  310.     for(i=0; i<mn; i++) {              /* Get values from fields */
  311.         if((k=ml[i]) > 100) k = k - 100;
  312.         if(k > 8) {
  313.         if(func == OPTION) {
  314.             switch( i ) {
  315.             case 0: mc = md$; break;
  316.             case 1: mc = me$; break;
  317.             case 2: mc = mf$; break;
  318.             }
  319.         }
  320.         else  mc = md$;
  321.         for(j=0; j<k; j++)  mc[j] = mvinch(my[i], mx[i]+j);
  322.         mc[k] = 0;
  323.         if(ml[i] <= 100) strupr( mc );
  324.         }
  325.         else if(k > 0) {
  326.         for(j=0; j<k; j++)  mc$[i][j] = mvinch(my[i], mx[i]+j);
  327.         mc$[i][k] = 0;
  328.         if(ml[i] <= 100) strupr( mc$[i] );
  329.         }
  330.     }
  331.     } /* func==PRINT || mn>0 */
  332.  
  333.     standend();
  334.     return( 0 );
  335. }
  336.  
  337. void show_error_message( row )
  338. int  row;
  339. {
  340.     _normal_font();
  341.     wblink();
  342.     xouttext(row, 6, em$);
  343.     beep();
  344.     *em$ = 0;
  345.     standend();
  346. }
  347.  
  348. void mvtonext()
  349. {
  350.     int  i;
  351. j10:
  352.     for(i=0; i<mn; i++) {
  353.         if(mx[i]+my[i]*80>get_position() && ml[i]>0)  break;
  354.     }
  355.     if(i == mn) { move(0,0); goto j10; }
  356.     move(my[i], mx[i]);
  357. }
  358.  
  359. void mvtoprevious()
  360. {
  361.     int  i;
  362.  
  363.     for(i=mn-1; i>=0; i--) {
  364.     if(mx[i]+my[i]*80+ml[i]-1<get_position() && ml[i]>0)  break;
  365.     }
  366.     if(i == -1)  i = mn - 1;
  367.     move(my[i], mx[i]+ml[i]-1);
  368. }
  369.  
  370. void mvhome() { move(my[0], mx[0]); }
  371. void mvend()  { move(my[mn-1], mx[mn-1]); }
  372.  
  373. /********* PROMPT **********/
  374. int prompt( err )
  375. int  err;
  376. {
  377.     int  i, fc;
  378.  
  379.     clear( 9 );
  380.     _normal_font();
  381.     _normal_spacing();
  382.  
  383.     wrblink();
  384.     mvaddstr(2, 5, "Click one of the commands on the menubar," );
  385.     mvaddstr(3, 5, "or Press Ctrl+(Capital Letter).          " );
  386.  
  387.     standend();
  388.     for(i=0; i<11; i++) {
  389.     mvaddstr(i+6, 5, help+i*64);
  390.     }
  391.     if( isort )  strcpy(w$, "special order");
  392.     else         strcpy(w$, "chronological");
  393.     move(0, 5);
  394.     if(itot == 0)  addstr( "No events selected.");
  395.     else  printw("%d events [%s] selected from %s.", itot, w$, f2$);
  396.     move(1, 5);
  397.     printw("Memory available for %d/%d events.", nmax, nmax2);
  398.  
  399.     mvaddstr(5, 5, "--->");
  400.     if( err ) {
  401.     wblink();
  402.         move(5, 10);
  403.     switch( err ) {
  404.         case  1: addstr("Invalid command or number!"); break;
  405.         case  2: printw("Number of events exceeds %d!",nmax); break;
  406.         case  3: addstr("No event has been selected!"); break;
  407.         case  4: printw("Events more than %d cannot be sorted!",nmax2);
  408.                  break;
  409.         default: addstr("Error!");
  410.     }
  411.     beep();
  412.     }
  413.  
  414.     windows_menu( PROMPT );
  415.     fkey( -1 );
  416.     while((fc = getcchr()) == CtlE)  check_exit();
  417.     return( fc );
  418. }
  419.  
  420. /********* FKEY ********** (Display function key definition.) */
  421. void fkey( key )
  422. short key;
  423. {
  424.     char  s[61];
  425.  
  426.     if(key < 0)  *s = 0;
  427.     else {
  428.         strncpy(s, fk+key*49, 49);
  429.     if(key == 2)  strcpy(s+48, "            ");
  430.     else { strcpy(s+48, " help "); strcat(s, "Enter "); }
  431.     }
  432.     windows_toolbar( s );
  433.     _normal_font();
  434. }
  435.  
  436. /********* LOAD_SETUP ********** (Read the setup file.) */
  437. #define   SETUP    "_seis"
  438. void mksetup( s )
  439. char  *s;
  440. {
  441.     if(getenv("HOME") == NULL)  *s = 0;
  442.     else { strcpy(s, getenv("HOME"));  add_separator( s ); }
  443.     strcat(s, SETUP);
  444. }
  445.  
  446. void load_setup()
  447. {
  448.     FILE  *fp;
  449.     int   i;
  450.  
  451.     mksetup( w$ );
  452.     fp = fopen(w$, "r");
  453.     if( fp ) {
  454.     ffgets(w$, 81, fp);
  455.     if(strchr(w$,' '))  *(strchr(w$,' ')) = 0;
  456.     if(*w$ != 0)  strcpy(drv$, w$);
  457.     ffgets(prn$, 81, fp); ffgets(port$, 81, fp);ffgets(f2$, 81, fp);
  458.     ffgets(y1$, 81, fp);  ffgets(m1$, 81, fp);  ffgets(d1$, 81, fp);
  459.     ffgets(h1$, 81, fp);  ffgets(n1$, 81, fp);  ffgets(s1$, 81, fp);
  460.     ffgets(y2$, 81, fp);  ffgets(m2$, 81, fp);  ffgets(d2$, 81, fp);
  461.     ffgets(h2$, 81, fp);  ffgets(n2$, 81, fp);  ffgets(s2$, 81, fp);
  462.     ffgets(dst$, 81, fp);
  463.     ffgets(so1$, 81, fp); ffgets(som1$, 81, fp); ffgets(sew1$, 81, fp);
  464.     ffgets(so2$, 81, fp); ffgets(som2$, 81, fp); ffgets(sew2$, 81, fp);
  465.     ffgets(sa1$, 81, fp); ffgets(sam1$, 81, fp); ffgets(sns1$, 81, fp);
  466.     ffgets(sa2$, 81, fp); ffgets(sam2$, 81, fp); ffgets(sns2$, 81, fp);
  467.     ffgets(dp1$, 81, fp); ffgets(dp2$, 81, fp);
  468.     ffgets(mg1$, 81, fp); ffgets(mg2$, 81, fp);
  469.     ffgets(ynh$, 81, fp); ffgets(ynm$, 81, fp);
  470.     ffgets(mps$, 81, fp);
  471.  
  472.     if( ffgets(w$, 81, fp) ) {
  473.         sscanf(w$, "%d %d %lf %lf", &ndp, &nmg, &ro, &ru);
  474.         ffgets(w$, 81, fp);
  475.         for(i=0; i<ndp; i++) {
  476.         if(i == 0)  cdp[i] = atoi(strtok(w$, " ")); 
  477.         else  cdp[i] = atoi(strtok(NULL, " "));
  478.         }
  479.         ffgets(w$, 81, fp);
  480.         for(i=0; i<ndp; i++) {
  481.         if(i == 0)  icd[i] = atoi(strtok(w$, " "));
  482.         else  icd[i] = atoi(strtok(NULL, " "));
  483.         }
  484.         ffgets(w$, 81, fp);
  485.         for(i=0; i<nmg; i++) {
  486.         if(i == 0)  cmg[i] = atof(strtok(w$, " "));
  487.         else  cmg[i] = atof(strtok(NULL, " "));
  488.         }
  489.         ffgets(ync$, 81, fp);
  490.         ffgets(w$, 81, fp);
  491.         if(strchr(w$,' '))  *(strchr(w$,' ')) = 0;
  492.         if(*w$ != 0)  strcpy(drvo$, w$);
  493.     }
  494.     else  dpmg_init();
  495.  
  496.     fclose( fp );
  497.     }
  498.     else {
  499.     get_printer_defaults(prn$, port$);
  500.     strcpy(f2$, "PDE  ");
  501.     strcpy(y1$, "1979");  strcpy(m1$, "01");  strcpy(d1$, "01");
  502.     strcpy(h1$, "00");  strcpy(n1$, "00");  strcpy(s1$, "00.00");
  503.     strcpy(y2$, "1979");  strcpy(m2$, "12");  strcpy(d2$, "31");
  504.     strcpy(h2$, "23");  strcpy(n2$, "59");  strcpy(s2$, "59.99");
  505.     strcpy(dst$, "NWPAC");
  506.     strcpy(so1$, "120"); strcpy(som1$, "00"); strcpy(sew1$, "E");
  507.     strcpy(so2$, "180"); strcpy(som2$, "00"); strcpy(sew2$, "E");
  508.     strcpy(sa1$, "00" ); strcpy(sam1$, "00"); strcpy(sns1$, "N");
  509.     strcpy(sa2$, "60" ); strcpy(sam2$, "00"); strcpy(sns2$, "N");
  510.     strcpy(dp1$, "000.0"); strcpy(dp2$, "999.9");
  511.     strcpy(mg1$, "+0.0"); strcpy(mg2$, "+9.9");
  512.     strcpy(ynh$, "Y"); strcpy(ynm$, "Y");
  513.     *mps$ == 0;
  514.     dpmg_init();
  515.  
  516.     strcpy(em$, w$);
  517.     strcat(em$, " is not found. Check the above options.");
  518.     option();
  519.     }
  520. }
  521.  
  522. /********* DUMP_SETUP ********** (Write setup file.) */
  523. void dump_setup()
  524. {
  525.     FILE  *fp;
  526.     int   i;
  527.  
  528.     mksetup( w$ );
  529.     fp = fopen(w$, "w");
  530.     if(*drv$ == 0) ffputs(" ", fp);
  531.     else ffputs(drv$, fp);
  532.     ffputs(prn$, fp);  ffputs(port$, fp); ffputs(f2$, fp);
  533.     ffputs(y1$, fp);  ffputs(m1$, fp);  ffputs(d1$, fp);
  534.     ffputs(h1$, fp);  ffputs(n1$, fp);  ffputs(s1$, fp);
  535.     ffputs(y2$, fp);  ffputs(m2$, fp);  ffputs(d2$, fp);
  536.     ffputs(h2$, fp);  ffputs(n2$, fp);  ffputs(s2$, fp);
  537.     ffputs(dst$, fp);
  538.     ffputs(so1$, fp); ffputs(som1$, fp); ffputs(sew1$, fp);
  539.     ffputs(so2$, fp); ffputs(som2$, fp); ffputs(sew2$, fp);
  540.     ffputs(sa1$, fp); ffputs(sam1$, fp); ffputs(sns1$, fp);
  541.     ffputs(sa2$, fp); ffputs(sam2$, fp); ffputs(sns2$, fp);
  542.     ffputs(dp1$, fp); ffputs(dp2$, fp);
  543.     ffputs(mg1$, fp); ffputs(mg2$, fp);
  544.     ffputs(ynh$, fp); ffputs(ynm$, fp);
  545.     ffputs(mps$, fp);
  546.  
  547.     sprintf(w$, "%d %d %f %f", ndp, nmg, ro, ru);
  548.     ffputs(w$, fp);
  549.     *w$ = 0;
  550.     for(i=0; i<ndp; i++) {
  551.     sprintf(z$, "%d ", cdp[i]);
  552.     strcat(w$, z$);
  553.     }
  554.     ffputs(w$, fp);
  555.     *w$ = 0;
  556.     for(i=0; i<ndp; i++) {
  557.     sprintf(z$, "%d ", icd[i]);
  558.     strcat(w$, z$);
  559.     }
  560.     ffputs(w$, fp);
  561.     *w$ = 0;
  562.     for(i=0; i<nmg; i++) {
  563.     sprintf(z$, "%f ", cmg[i]);
  564.     strcat(w$, z$);
  565.     }
  566.     ffputs(w$, fp);
  567.     ffputs(ync$, fp);
  568.     if(*drvo$ == 0) ffputs(" ", fp);
  569.     else ffputs(drvo$, fp);
  570.  
  571.     fclose( fp );
  572. }
  573.  
  574. ffgets(s, n, fp)    /* n <= 81 */
  575. unsigned char    *s;
  576. unsigned     n;
  577. FILE         *fp;
  578. {
  579.     char  t[82];
  580.  
  581.     fgets(t, n+1, fp);
  582.     if(feof(fp) || *t==0) { *s = 0; return( 0 ); }
  583.     /* strncpy() never put NULL at the end of string!
  584.     if(t[strlen(t)-1] == lf)  strncpy(s, t, strlen(t)-1);
  585.     else  strcpy(s, t); */
  586.     if(t[strlen(t)-1] == lf)  t[strlen(t)-1] = 0;
  587.     strcpy(s, t);
  588.     return( 1 );
  589. }
  590.  
  591. ffputs(s, fp)
  592. unsigned char  *s;
  593. FILE           *fp;
  594. {
  595.     int  err;
  596.  
  597.     err = fputs(s, fp);
  598.     fputs("\n", fp);
  599.     return( err );
  600. }
  601.  
  602. char *ggcvt(f, len, s)
  603. double f;
  604. short  len;
  605. char   *s;
  606. {
  607.     char  t[4];
  608.     int   i;
  609.  
  610.     sprintf(t, "%%%1ug", len);
  611.     sprintf(s, t, f);
  612.     for(i=0; s[i]==' '; i++);
  613.     if(i > 0)  strcpy(s, s+i);
  614.     return( s );
  615. }
  616.  
  617. char *hcvt(f, s)
  618. double  f;
  619. char   *s;
  620. {
  621.     ggcvt(f, 6, s);
  622.     if(s[strlen(s)-1] == '.')  strcat(s, "0");
  623.     return( s );
  624. }
  625.  
  626. /*************************** OPTION *******************/
  627. int option()
  628. {
  629.     isr = 0;
  630.     strcpy(md$, drv$);
  631.     strcpy(me$, drvo$);
  632.     strcpy(mf$, port$);
  633.     if(panel(OPTION) == 3)  return( 0 );
  634.     strxcpy(drv$ , md$);
  635.     strxcpy(drvo$, me$);
  636.     strxcpy(port$, mf$);
  637.     return( 0 );
  638. }
  639.  
  640. void add_separator( s )
  641. char  *s;
  642. {
  643.     short  i;
  644.     if(*s != 0) {
  645.     i = strlen( s ) - 1;
  646.     if(s[i]!='/' && s[i]!='\\' && s[i]!=':')  strcat(s, "/");
  647.     }
  648. }
  649.  
  650. void strxcpy(s, t)
  651. char  *s, *t;
  652. {
  653.     int  i;
  654.  
  655.     strcpy(s, t);
  656.     /* Remove trailing blanks, but keep blanks within a string. */
  657.     for(i=strlen(s)-1; i>=0; i--) {
  658.     if( isgraph(s[i]) )  break;
  659.     }
  660.     s[i+1] = 0;
  661. }
  662.  
  663. /************************ Panel Definitions **********************/
  664. char fk[] = "\
  665. hcopy        quit             return            \0\
  666. hcopy        quit             return      functn\0\
  667. hcopy        quit  top  bottomreturn back forwrd";
  668.  
  669. char help[] = "\
  670. SELECT......Select events.                                     \0\
  671. BROWSE......Browse data of the selected events.                \0\
  672. PRINT.......Print data of the selected events.                 \0\
  673. SAVE........Save data of the selected events.                  \0\
  674. SORT........Sort the selected events.                          \0\
  675. MAP.........Plot the selected events on a map.                 \0\
  676. TIME........Draw a time-frequency diagram for the events.      \0\
  677. MAGNITUDE...Draw a magnitude-frequency diagram for the events. \0\
  678. OPTION......Specify options for directories and a printer.     \0\
  679. END.........Exit.                                              ";
  680. char init_pan[] ="\
  681.                                                                              \
  682.                                                                              \
  683.                                                                              \
  684.                                                                              \
  685.                                                                              \
  686.                                                                              \
  687.                                                                              \
  688.                                   SeisView                                   \
  689.                                                                              \
  690.                                                                              \
  691.                                                                              \
  692.                                      by                                      \
  693.                                                                              \
  694.                              K.Koketsu & T.Yoshii                            \
  695.               Earthquake Research Institute, University of Tokyo             ";
  696.  
  697. char option_pan[] = "\
  698.     Request : OPTION                                                         \
  699.     Specify options in () as you like and press Enter.                       \
  700.                                                                              \
  701.     Pathname of the directory for data files                                 \
  702.     (                                                                  )     \
  703.     Pathname of the directory for auxiliary files                            \
  704.     (                                                                  )     \
  705.          Examples: /home/kk/seis, c:\\data\\seis (Windows), @hostname (server) \
  706.          If you keep this blank, the value of the SEIS environment variable  \
  707.          will be taken.  If both this and the variable are blank, a current  \
  708.          working directory will be assumed.                                  \
  709.                                                                              \
  710.     Printer Name                                                             \
  711.     (                                                                  )     \
  712.          A printcap entry on UNIX, or a name in My Computer/Printers of      \
  713.          Windows.                                                            \
  714.                                                                              \
  715. 6,   4,164 \
  716. 6,   6,164 \
  717. 6,  13,164 ";
  718.