source: SH_SHM/trunk/source/motif/mfexec.c @ 64

Revision 64, 72.2 KB checked in by marcus, 14 years ago (diff)

r49 | svn | 2008-10-14 22:36:40 +0200 (Di, 14 Okt 2008) | 1 line

autoevt: filter depending on distance; appropriate variables in globalparams.h

Line 
1
2/* file mfexec.c
3 *      ========
4 *
5 * $Revision: 49 $, $Date: 2008-10-14 22:36:40 +0200 (Di, 14 Okt 2008) $
6 *
7 * execution of SH commands
8 * K. Stammler, 25-Feb-93
9 */
10
11
12/*
13 *
14 *  SeismicHandler, seismic analysis software
15 *  Copyright (C) 1996,  Klaus Stammler, Federal Institute for Geosciences
16 *                                       and Natural Resources (BGR), Germany
17 *
18 *  This program is free software; you can redistribute it and/or modify
19 *  it under the terms of the GNU General Public License as published by
20 *  the Free Software Foundation; either version 2 of the License, or
21 *  (at your option) any later version.
22 *
23 *  This program is distributed in the hope that it will be useful,
24 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
25 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26 *  GNU General Public License for more details.
27 *
28 *  You should have received a copy of the GNU General Public License
29 *  along with this program; if not, write to the Free Software
30 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
31 *
32 */
33
34
35
36#include <stdio.h>
37#include <string.h>
38#include "basecnst.h"
39#undef BC_DEFINE_TRUE_FALSE
40#ifdef BC_INC_STDLIB
41#include BC_INC_STDLIB
42#endif
43#include <Xm/Xm.h>
44#include <Xm/ToggleB.h>
45#include <Xm/Text.h>
46#include BC_SYSBASE
47#include "erusrdef.h"
48#include "motifgraph.h"
49#include "station_no.h"
50#include "cbutil.h"
51#include "mfexec.h"
52#include "cblib.h"
53#include "cblib3.h"
54#include "callsh.h"
55#include "infoidx.h"
56#include "utusrdef.h"
57#include "shvars.h"
58#include "glusrdef.h"
59#include "earthloc.h"
60#include "phaseinf.h"
61#include "phasemgr.h"
62#include "trcselect.h"
63#include "shm_widgets.h"
64#include "sysext.h"
65#include "seismics.h"
66#include "globalparams.h"
67
68
69/*
70 * the following definitions must match the 'entry define shm_...' commands
71 * in SHM_CMD_STARTUP.SHC
72 */
73#define MXC_NUM_VIEW 0
74#define MXC_NUM_HIDE 1
75#define MXC_NUM_FILTER 2
76#define MXC_NUM_ROT 3
77#define MXC_EF_VIEW   (MXC_NUM_VIEW|EF_TYPE)
78#define MXC_EF_HIDE   (MXC_NUM_HIDE|EF_TYPE)
79#define MXC_EF_FILTER (MXC_NUM_FILTER|EF_TYPE)
80#define MXC_EF_ROT    (MXC_NUM_ROT|EF_TYPE)
81#define MXC_FLAG_VIEW   (1<<MXC_NUM_VIEW)
82#define MXC_FLAG_HIDE   (1<<MXC_NUM_HIDE)
83#define MXC_FLAG_FILTER (1<<MXC_NUM_FILTER)
84#define MXC_FLAG_ROT    (1<<MXC_NUM_ROT)
85
86
87/* imported variables */
88extern Widget       xmv_w[];         /* widget array */
89extern MX_CMD_READG xmv_cmd_readg;   /* to write on it in external_routine */
90
91
92static int mxv_display_state=0;   /* display status */
93
94
95
96/* prototypes of local routines */
97static void mxh_read_file_list( Widget w, MGT_DSPCTRL *ctrl, char filenames[],
98        int format, STATUS *status );
99static void mx_prepare_display( void );
100static void mxh_filter_separately( Widget w, MGT_DSPCTRL *ctrl, char filter[],
101        float autocut, STATUS *status );
102static BOOLEAN mxh_rotation_is_possible( void );
103static void mxh_get_vax_grflist( MX_CMD_READG *rg, char liststr[] );
104static void mxh_read_statlist( char fname[], Widget w[], MX_STATLIST *sl,
105        STATUS *status );
106static void mxh_mount_cdrom( MX_CMD_READG *par, STATUS *status );
107static void mxh_set_entry_name( Widget ew, char text[] );
108void mx_remove_double_elements( char *str );
109void mxh_compute_azimuth( char cstation[], float lat, float lon,
110        float *azim, TSyStatus *status );
111static void mxh_read_stations_from_evt( char autoevt[], char addlist[] );
112static void mxh_read_location_from_evt( char autoevt[], float *lat, float *lon,
113        TSyBoolean *found );
114static void mxh_translate_button_name( char code[], char autoevt[],
115        char addlist[], TSyStatus *status );
116
117
118
119/*--------------------------------------------------------------------------*/
120
121
122
123void mx_readg( MX_CMD_READG *par, Widget wm, Widget ws, MGT_DSPCTRL *ctrl,
124        BOOLEAN keep_phases, char autoevt[], STATUS *status )
125
126/* executes readg command
127 *
128 * parameters of routine
129 * XM_CMD_READG  *par;        input; command parameters
130 * Widget        wm;          input; main DrawingArea Widget
131 * Widget        ws;          input; single trace window
132 * MGT_DSPCTRL   *ctrl;       input; display control parameters
133 * TSyBoolean    keep_phases; input; keep phases in memory
134 * char          *autoevt     input; name of evt file for retrieving stat. names
135 * TSyStatus     *status;     output; return status
136 */
137{
138        /* local variables */
139        static int gse_cnt=0;               /* GSE counter */
140        char     line[cBcVeryLongStrLth+1]; /* command line */
141        char     statlist[cBcVeryLongStrLth+1]; /* station list */
142        char     addlist[cBcLongStrLth+1];  /* parsed station string */
143        int      i;                         /* bit count */
144        char     *eptr;                     /* pointer to char for getenv */
145        TSyBoolean redraw;                  /* dummy */
146        TSyStatus  locstat;                 /* local status */
147        char     gsename[cBcFileLth+1];     /* name of GSE file */
148
149        /* executable code */
150
151        if  (par->channum == 0 && par->format == MXC_FORMAT_SEED)  {
152                *status = MXE_NOCHANNELS;
153                return;
154        } /*endif*/
155
156        mg_do_drag( wm, MGC_DRAG_CLEAR, 0, 0 );
157        mg_plot_drag_window( ws, ctrl->show_phase_acc, status );
158        if  (Severe(status))  return;
159
160        /* translate device name if possible */
161        if  (strcmp(par->device,"CD") == 0)  {
162                mxh_mount_cdrom( par, status );
163                if  (Severe(status))  return;
164        } else {
165                eptr = getenv( par->device );
166                if  (eptr != NULL)  {
167                        if  (strlen(eptr) >= BC_FILELTH)  {
168                                *status = MXE_STROVFL;
169                                return;
170                        } /*endif*/
171                        strcpy( par->device, eptr );
172                        strcat( par->device, "/" );
173                } /*endif*/
174        } /*endif*/
175
176        if  (par->keep)  {
177                mx_exec_sh( wm, ctrl, "nr" );
178                mx_exec_sh( wm, ctrl, "display all_dh" );
179                mx_exec_sh( wm, ctrl, "del _shm_filter(y)" );
180                mx_exec_sh( wm, ctrl, "del _shm_rot(y)" );
181                mx_exec_sh( wm, ctrl, "rd" );
182        } else {
183                mx_exec_sh( wm, ctrl, "del all_dh" );
184        } /*endif*/
185        if  (Severe(status))  return;
186        mx_exec_sh( wm, ctrl, "dtw" );
187        /* mx_exec_sh( wm, ctrl, "rd" ); */
188        /* mx_exec_sh( wm, ctrl, "nr" ); */
189
190        /* create station list and component list */
191        *statlist = '\0';
192        for  (i=0; i<MXC_STATLIST_LTH; i++)  {
193                if  ((1<<i) & par->stations)  {
194                        if  (*statlist != '\0')  strcat( statlist, "," );
195                        mxh_translate_button_name( par->sl.code[i], autoevt, addlist, status );
196                        if  (strlen(statlist)+strlen(addlist) < cBcVeryLongStrLth)  {
197                                strcat( statlist, addlist );
198                        } else {
199                                *status = MXE_STROVFL;
200                                return;
201                        } /*endif*/
202                } /*endif*/
203        } /*endfor*/
204        if  (strlen(statlist) > cBcVeryLongStrLth-55)  {
205                printf( "*SHM: mx_readg: station list too long\n" );
206                printf( "                field length exceeded, abort program\n" );
207                exit( 1 );
208        } /*endif*/
209        if  (*statlist != '\0')
210                mx_remove_double_elements( statlist );
211
212        switch  (par->format)  {
213        case MXC_FORMAT_SEED:
214                if  (par->use_readk)  {
215
216                        /* read from VAX WORMS: (completely outdated code, no more k-files) */
217                        /* check whether GRF or GRSN data are requested */
218                        if  (strncmp(statlist,"GRA",3) == 0
219                                || strncmp(statlist,"GRB",3) == 0
220                                || strncmp(statlist,"GRC",3) == 0)  {
221                                /* these are GRF data ... */
222                                ;
223                        } else {
224                                /* these are GRSN data ... */
225                                if  (par->channum > 1)
226                                        printf( "*SHM: take only first channel selected\n" );
227                                /* generate filename */
228                                sprintf( gsename, "grn2gse_%02d.gse", ++gse_cnt );
229                                strcpy( line, GpGetString(cGpS_defpath_extprog) );
230                                sprintf( line+strlen(line),
231                                        "grn2gse %s %s %f %s %s %s %s",
232                                        par->device, par->start, par->seclth, statlist,
233                                        par->comp, par->chanstr[0], gsename );
234                        } /*endif*/
235                        if  (GpGetInt(cGpI_debug_level) > 1)
236                                printf( "SHM-dbg2: exec: %s\n", line );
237                        system( line );
238                        sprintf( line, "@READGSE %s ALL", gsename );
239                        if  (GpGetInt(cGpI_debug_level) > 1)
240                                printf( "SHM-dbg2: sh exec: %s\n", line );
241                        mx_exec_sh( wm, ctrl, line );
242                        /* now delete input GSE file */
243                        /* sy_fdelete( gsename ); */
244
245                } else {
246
247                        /* read from Mini-SEED files */
248                        /* to be added: check length of line */
249
250                        /* make backslashes out of slashes */
251                        eptr = par->device - 1;
252                        while  (*(++eptr) != '\0')
253                                if  (*eptr == '/')  *eptr = '\\';
254                        /* loop all channels */
255                        for  (i=0; i<(par->channum); i++)  {
256#ifdef SH_SETUP_LINUX
257                                if  (par->reads_invhdr)  {
258                                        sprintf( line, "@READS/NOSWAP/INVHDR/SFD=%s %s %s %f %s %s %s",
259                                                par->sfdfile, par->device, par->start, par->seclth,
260                                                statlist, par->comp, par->chanstr[i] );
261                                } else {
262                                        sprintf( line, "@READS/NOSWAP/SFD=%s %s %s %f %s %s %s",
263                                                par->sfdfile, par->device, par->start, par->seclth,
264                                                statlist, par->comp, par->chanstr[i] );
265                                } /*endif*/
266#else
267                                if  (par->reads_invhdr)  {
268                                        sprintf( line, "@READS/INVHDR/SFD=%s %s %s %f %s %s %s",
269                                                par->sfdfile, par->device, par->start, par->seclth,
270                                                statlist, par->comp, par->chanstr[i] );
271                                } else {
272                                        sprintf( line, "@READS/SFD=%s %s %s %f %s %s %s",
273                                                par->sfdfile, par->device, par->start, par->seclth,
274                                                statlist, par->comp, par->chanstr[i] );
275                                } /*endif*/
276#endif
277                                if  (GpGetInt(cGpI_debug_level) > 1)
278                                        printf( "SHM-dbg2: execute: >%s< length %d\n", line, strlen(line) );
279                                mx_exec_sh( wm, ctrl, line );
280                        } /*endfor*/
281
282                } /*endif*/
283                break;
284
285        case MXC_FORMAT_GSE:
286        case MXC_FORMAT_GSE2:
287        case MXC_FORMAT_AH:
288        case MXC_FORMAT_Q:
289                mxh_read_file_list( wm, ctrl, par->filename, par->format, status );
290                if  (Severe(status))  return;
291                break;
292
293        default:
294
295                printf( "*SHM: mx_readg: program error\n" );
296                *status = MXE_PROG_BUG;
297                return;
298
299        } /*endswitch*/
300
301        cl_set_autofilters();
302
303        mx_exec_sh( wm, ctrl, "SHM_CMD_TIMEAL" );
304
305        if  (keep_phases)  {
306                mg_plot_phases( wm, ctrl->show_phase_acc, status );
307        } /*endif*/
308        cl3_uppercase_names();
309
310} /* end of mx_readg */
311
312
313
314/*--------------------------------------------------------------------------*/
315
316
317static void mxh_translate_button_name( char code[], char autoevt[],
318        char addlist[], TSyStatus *status )
319
320/* Translates button name into a list of stations, returned by addlist
321 *
322 * parameters of routine
323 * char       code[]; input; button name (station code or list abbrev)
324 * char       autoevt[]; input; name of evt file with automatic picks and loc
325 * char       addlist[]; output; resulting station list; max lth cBcLongStrLth
326 * TSyStatus  *status; output; return status
327 */
328{
329        /* local variables */
330        char     varname[MXC_STATSTR_LTH+2]; /* variable name */
331        TSyBoolean ok;                       /* worked ok? */
332        float    epilat, epilon;            /* epicentre location rea from evt */
333        float    vlat1, vlat2, vlon1, vlon2;/* lat and lon area */
334        TSyBoolean epifound;                /* epicentre found in evt */
335        int      locvarcnt;                 /* location variable counter */
336        char     vstr[cBcLongStrLth+1];     /* scratch for variable evaluation */
337
338        /* executable code */
339
340        *addlist = '\0';
341        if  (code[0] == '$')  {
342                /* find list of stations in config file */
343                varname[0] = 'v';
344                strcpy( varname+1, code );
345                GpReadParameter( varname, cBcLongStrLth, addlist, &ok );
346                if  (!ok)  {
347                        *status = MXE_ILL_SUBSET;
348                        err_setcontext( " ## variable: " );
349                        err_setcontext( varname );
350                        *addlist = '\0';
351                        return;
352                } /*endif*/
353        } else if  (strcmp(code,":AE") == 0)  {
354                if  (autoevt == NULL)  {
355                        printf( "*SHM: cannot translate :AE, autoevt is NULL\n" );
356                } else if  (*autoevt == '\0')  {
357                        printf( "*SHM: cannot translate :AE, autoevt is empty\n" );
358                } else {
359                        mxh_read_stations_from_evt( autoevt, addlist );
360                } /*endif*/
361        } else if  (strcmp(code,":LOC") == 0)  {
362                if  (autoevt == NULL)  {
363                        /* if no autoevt file there, then use v$loc setting */
364                        GpReadParameter( "v$loc", cBcLongStrLth, addlist, &ok );
365                        if  (!ok)  {
366                                printf( "*SHM: cannot translate :LOC, autoevt is NULL and no v$loc found\n" );
367                                *status = MXE_CONFIG_SETUP;
368                                err_setcontext( " ## variable: V$LOC not found" );
369                        } /*endif*/
370                } else if  (*autoevt == '\0' || strcmp(autoevt,"None") == 0)  {
371                        /* same as above */
372                        GpReadParameter( "v$loc", cBcLongStrLth, addlist, &ok );
373                        if  (!ok)  {
374                                printf( "*SHM: cannot translate :LOC, autoevt is NULL and no v$loc found\n" );
375                                *status = MXE_CONFIG_SETUP;
376                                err_setcontext( " ## variable: V$LOC not found" );
377                        } /*endif*/
378                } else {
379                        /* get location from evt file */
380                        mxh_read_location_from_evt( autoevt, &epilat, &epilon, &epifound );
381                        if  (!epifound)  {
382                                /* no epicentre in evt file, behave like :AE */
383                                printf( "*SHM: cannot translate :LOC, no epicentre found -> :AE\n" );
384                                mxh_translate_button_name( ":AE", autoevt, addlist, status );
385                                return;
386                        } /*endif*/
387                        if  (GpGetInt(cGpI_debug_level) > 2)
388                                printf( "SHM-dbg3: :LOC found epi %f,%f\n", epilat, epilon );
389                        epifound = FALSE;
390                        locvarcnt = 1;
391                        FOREVER {
392                                /* read through all v$loc* variables and compare with curr. location */
393                                sprintf( varname, "v$loc%d", locvarcnt );
394                                GpReadParameter( varname, cBcLongStrLth, vstr, &ok );
395                                if  (!ok)  break;
396                                if  (GpGetInt(cGpI_debug_level) > 3)
397                                        printf( "SHM-dbg4: %s translated to %s\n", varname, vstr );
398                                if  (sscanf(vstr,"%f,%f,%f,%f %s",
399                                        &vlat1,&vlon1,&vlat2,&vlon2,addlist) != 5)
400                                        continue;
401                                if  (vlat1 <= epilat && epilat <= vlat2 && vlon1 <= epilon
402                                        && epilon <= vlon2)  {
403                                        epifound = TRUE;
404                                        break;
405                                } /*endif*/
406                                locvarcnt++;
407                        } /*endfor*/
408                        if  (!epifound)  {
409                                GpReadParameter("v$loc", cBcLongStrLth, addlist, &ok );
410                                if  (!ok)  {
411                                        printf( "*SHM: no v$loc definition\n" );
412                                        *status = MXE_CONFIG_SETUP;
413                                        err_setcontext( " ## variable: V$LOC not found" );
414                                        return;
415                                } /*endif*/
416                        } /*endif*/
417                } /*endif*/
418        } else {
419                strcpy( addlist, code );
420        } /*endif*/
421
422        /* if addlist is a variable, translate it */
423        if  (addlist[0] == '$')  {
424                vstr[0] = 'v';
425                strcpy( vstr+1, addlist );
426                GpReadParameter( vstr, cBcLongStrLth, addlist, &ok );
427                if  (!ok)  {
428                        printf( "*SHM: no %s definition\n", vstr );
429                        *status = MXE_CONFIG_SETUP;
430                        err_setcontext( " ## variable: not found: " );
431                        err_setcontext( vstr );
432                        return;
433                } /*endif*/
434        } /*endif*/
435        if  (GpGetInt(cGpI_debug_level) > 3)
436                printf( "SHM-dbg4: :LOC addlist: %s\n", addlist );
437
438} /* end of mxh_translate_button_name */
439
440
441
442/*--------------------------------------------------------------------------*/
443
444
445
446void mx_filter_from_autoevt( char autoevt[], char filtername[], float *autocut )
447
448/* Determines filter using distance between autoevt location and reference
449 * station
450 *
451 * parameters of routine
452 * char autoevt[]; input;      name of autoevt file
453 * char filtername[]; output;  name of filter to use
454 * float *autocut; output;     cut off that many seconds after filtering
455 */
456{
457        /* local variables */
458        float    epilat, epilon;         /* location from autoevt */
459        TSyBoolean epifound;             /* epicentre found? */
460        GLT_STATINF *statinf;            /* station info of reference station */
461        TSyStatus locstat;               /* local status variable */
462        double dist, az, baz;            /* for distance computation */
463
464        /* executable code */
465
466        /* preset output vars in case of error returns */
467        *filtername = '\0';
468        *autocut = 5.0;
469
470        /* read the automatic location from the evt text file */
471        mxh_read_location_from_evt( autoevt, &epilat, &epilon, &epifound );
472        if  (!epifound)  return;
473
474        /* get the station location of the reference station */
475        locstat = cBcNoError;
476        statinf = gl_store_station( GpGetString(cGpS_refstation), TRUE, &locstat );
477        if  (SySevere(&locstat))  return;
478
479        /* distance of automatic ocation from reference station */
480        mb_locdiff( statinf->lat, statinf->lon, epilat, epilon, &dist, &az, &baz );
481
482        /* take one of two possible filters, depending on the distance */
483        if  (dist < GpGetFloat(cGpF_autofilter_sepdist))  {
484                strcpy( filtername, GpGetString(cGpS_autofilter_local) );
485        } else {
486                strcpy( filtername, GpGetString(cGpS_autofilter_tele) );
487        } /*endif*/
488
489} /* end of mx_filter_from_autoevt */
490
491
492
493/*--------------------------------------------------------------------------*/
494
495
496
497void mx_filter( MX_CMD_FILTER *filter, Widget w, MGT_DSPCTRL *ctrl,
498        STATUS *status )
499
500/* performs filtering
501 *
502 * parameters of routine
503 * MX_CMD_FILTER *filter;       input; filter command parameters
504 * Widget        w;             input; DrawingArea Widget
505 * MGT_DSPCTRL   *ctrl;         input; display control parameters
506 * TSyStatus     *status;       output; return status
507 */
508{
509        /* local variables */
510        char     str[BC_LINELTH+1];            /* scratch string */
511        char     filprefix[BC_SHORTSTRLTH+1];  /* filter prefix */
512        char     filter_typ;                   /* recursive or FFT, 'R' or 'F' */
513        TSyBoolean same_filter;                /* same filter for all traces */
514        unsigned filent;                       /* filter info entry */
515        int      trcnum;                       /* trace number */
516        void     *trc;                         /* trace pointer */
517
518        /* executable code */
519
520        /* if no traces on display return error status */
521        if  (mg_dsptrcs() == 0)  {
522                *status = MXE_NO_TRACES;
523                return;
524        } /*endif*/
525
526        /* get filter type */
527#ifdef XXX
528        filter_typ = (shv_global.use_rec_filters) ? 'R' : 'F';
529        if  (shv_global.filter_type != ' ')  filter_typ = shv_global.filter_type;
530#endif
531        filter_typ = GpGetChar( cGpC_filter_type );
532
533        /* if filtering is switched off it's quick and easy */
534        if  (filter->name[0] == '\0')  {
535                /* delete filter entry on selected traces */
536                if  (ts_some_trace_selected())  {
537                        /* get index number of filter entry */
538                        db_ident( "FILTER", &filent, status );
539                        if  (SySevere(status))  return;
540                        /* loop all traces and delete filter entry */
541                        trc = NULL;
542                        trcnum = 0;
543                        FOREVER  {
544                                trc = db_getp( trc, EP_NEXT, NULL );
545                                if  (trc == NULL)  break;
546                                trcnum++;
547                                if  (ts_is_selected(trcnum))
548                                        db_sets( trc, filent, "", status );
549                        } /*endfor*/
550                        ts_clear_selections();
551                } /*endif*/
552                /* remove the filter */
553                mxv_display_state &= ~MXC_FLAG_FILTER;
554                sprintf( str, "shm_cmd_filter %c ;; NONE %f %d",
555                        filter_typ, filter->autocut,
556                        (GpGetInt(cGpI_trace_normalisation)==cGp_NORM_CONST) );
557                mx_exec_sh( w, ctrl, str );
558                return;
559        } /*endif*/
560
561        /* filtering is switched on */
562        mxv_display_state |= MXC_FLAG_FILTER;
563
564        /* now let's check which filter(s) must be used */
565        cl3_check_filter( filter->name, (filter_typ == 'R'),
566                filprefix, &same_filter, status );
567        if  (Severe(status))  return;
568
569        /* if all traces need the same filter do it with the old SH-cp and quit */
570        if  (same_filter && !ts_some_trace_selected())  {
571                if  (filter_typ == 'R')  {
572                        sprintf( str, "shm_cmd_filter r;%s;%s %f %d",
573                                filprefix, filter->name, filter->autocut,
574                                (GpGetInt(cGpI_trace_normalisation)==cGp_NORM_CONST) );
575                } else {
576                        sprintf( str, "shm_cmd_filter %c;%s;%s %f %d",
577                                filter_typ, filprefix, filter->name, filter->autocut,
578                                (GpGetInt(cGpI_trace_normalisation)==cGp_NORM_CONST) );
579                } /*endif*/
580                if  (GpGetInt(cGpI_debug_level) > 1)
581                        printf( "SHM-dbg2: execute >%s<\n", str );
582                mx_exec_sh( w, ctrl, str );
583                return;
584        } /*endif*/
585
586        /* now this is the hard way */
587        mxh_filter_separately( w, ctrl, filter->name, filter->autocut, status );
588
589} /* end of mx_filter */
590
591
592
593/*--------------------------------------------------------------------------*/
594
595
596
597void mx_exec_sh( Widget w, MGT_DSPCTRL *ctrl, char line[] )
598
599/* executes command line
600 *
601 * parameters of routine
602 * Widget        w;          input; widget of drawing area
603 * MGT_DSPCTRL   *ctrl;      input; display control parameters
604 * char          line[];     input; command line
605 */
606{
607        /* local variables */
608        TSyStatus   status;             /* return status */
609        TSyBoolean  redraw;             /* redraw flag */
610
611        /* executable code */
612
613        status = BC_NOERROR;
614        callsh( line, &redraw, &status );
615        if  (Severe(&status))  {
616                cu_alert( status );
617        } else {
618                if  (redraw)
619                        mg_tracedisplay( w, ctrl, &status );
620                if  (Severe(&status))  {
621                        cu_alert( status );
622                } /*endif*/
623        } /*endif*/
624
625} /* end of mx_exec_sh */
626
627
628
629/*--------------------------------------------------------------------------*/
630
631
632
633void mx_stw( Widget wm, Widget ws, MGT_DSPCTRL *ctrl )
634
635/* executes stw command
636 *
637 * parameters of routine
638 * Widget        wm;        input; widget ID of main DrawingArea
639 * Widget        ws;        input; widget ID of single trace DrawingArea
640 * MGT_DSPCTRL   *ctrl;     input; display control parameters
641 */
642{
643        /* local variables */
644        char        cmd[BC_LINELTH+1];    /* command line */
645        float       start, end;           /* time window */
646        TSyBoolean  set;                  /* time window set */
647        TSyStatus   locstat=BC_NOERROR;   /* local status */
648
649        /* executable code */
650
651        mg_get_drag_window( &start, &end, &set );
652        if  (!set)  return;
653        sprintf( cmd, "stw %e %e", start, end );
654        mx_exec_sh( wm, ctrl, cmd );
655        mg_do_drag( wm, MGC_DRAG_CLEAR, 0, 0 );
656        mg_plot_drag_window( ws, ctrl->show_phase_acc, &locstat );
657
658} /* end of mx_stw */
659
660
661 
662/*---------------------------------------------------------------------------*/
663
664
665
666void mx_handle_beam( Widget wm, Widget ws, BOOLEAN do_beam, MGT_DSPCTRL *ctrl,
667        CUT_PARAMS *par, char alignphase[], STATUS *status )
668
669/* creates or deletes beam trace (toggle routine)
670 *
671 * parameters of routine
672 * Widget     wm;            input; Widget ID of main window
673 * Widget     ws;            input; Widget ID of single trace window
674 * TSyBoolean do_beam;       input; do beam (not align)
675 * MGT_DSPCTRL *ctrl;        input; display control
676 * CUT_PARAMS *par;          input; analysis parameters
677 * char       alignphase[];  input; name of phase to be aligned
678 * TSyStatus  *status;       output; return status
679 */
680{
681        /* local variables */
682        int        t;                    /* trace counter */
683        TSyStatus  locstat;              /* local status */
684        char       str[BC_LINELTH+1];    /* scratch */
685        char       trcstr[BC_LINELTH+1]; /* trace list string */
686        TSyBoolean create_beam;          /* create or delete beam */
687
688        /* executable code */
689
690        /* look for BEAM trace */
691        create_beam = TRUE;
692        for  (t=1; t<=mg_dsptrcs(); t++)  {
693                locstat = BC_NOERROR;
694                db_gets( mg_trcptr(t), ES_STATION, BC_LINELTH, str, &locstat );
695                if  (locstat == BC_NOERROR && strcmp(str,"BEAM") == 0)  {
696                        create_beam = FALSE;
697                        break;
698                } else if  (locstat == BC_NOERROR && strcmp(str,"ALIGN") == 0)  {
699                        create_beam = FALSE;
700                        break;
701                } /*endif*/
702        } /*endfor*/
703
704        mg_do_drag( wm, MGC_DRAG_CLEAR, 0, 0 );
705        locstat = BC_NOERROR;
706        mg_plot_drag_window( ws, ctrl->show_phase_acc, &locstat );
707        if  (create_beam)  {
708                if  (do_beam)  {
709                        sprintf( str, "shm_cmd_make_beam %e %e %s",
710                                par->b_azimuth, par->b_slowness, GpGetString(cGpS_refstation) );
711                        if  (cu_get_exec_flag(CUC_F_EXEC_RESIDCORR))  strcat( str, " P" );
712                        mx_exec_sh( wm, ctrl, str );
713                } else {
714                        cl_calc_align_times( alignphase, BC_LINELTH-19, trcstr, status );
715                        /* this is the textlength in the sprintf cmd ^ */
716                        if  (Severe(status))  return;
717                        if  (*trcstr == '\0')  {
718                                *status = MXE_NO_TRACES;
719                                return;
720                        } /*endif*/
721                        sprintf( str, "shm_cmd_make_align %s", trcstr );
722                        mx_exec_sh( wm, ctrl, str );
723                } /*endif*/
724        } else {
725                mx_exec_sh( wm, ctrl, "shm_cmd_delete_beam" );
726        } /*endif*/
727
728} /* end of mx_handle_beam */
729
730
731
732/*---------------------------------------------------------------------------*/
733
734
735#define MAX_NEW_TRC 3
736#define NEW_TRC_R 0
737#define NEW_TRC_T 1
738#define NEW_TRC_Z 2
739
740
741
742void mx_rotation( Widget wm, MGT_DSPCTRL *ctrl, float azimuth,
743        float lat, float lon, TSyStatus *status )
744
745/* Performs rotation of traces with given azimuth of, if 0.0, computing
746 * azimuth by given location
747 *
748 * parameters of routine
749 * Widget     wm;        input; widget ID of main window
750 * MGT_DSPCTRL *ctrl;    input; display control
751 * float      azimuth;   input; rotation angle
752 * float      lat, lon;  input; event location
753 * STATUS     *status;   output; return status
754 */
755{
756        /* local variables */
757        void       *trc;                        /* running index */
758        void       *trc_z, *trc_n, *trc_e;      /* trace pointers */
759        char       comp;                        /* component */
760        char       station[BC_SHORTSTRLTH+1];   /* station name */
761        char        cstation[BC_SHORTSTRLTH+1]; /* current station name */
762        TSyBoolean  flush;                      /* do rotation */
763        TSyStatus   locstat;                    /* local status */
764        char        cmd[BC_LINELTH+1];          /* command line for SH */
765        void        *newtrc[MAX_NEW_TRC];       /* new created traces */
766        int         newtrclth;                  /* number of new traces */
767        float       xazim;                      /* local copy of azimuth */
768        TSyBoolean  dmy;                        /* dummy */
769
770        /* executable code */
771
772        /* check whether rotated traces are there */
773        locstat = BC_NOERROR;
774        trc = NULL;
775        FOREVER  {
776                /* get next trace */
777                trc = db_getp( trc, EP_NEXT, NULL );
778                if  (trc == NULL)  break;
779                if  (db_getf(trc,MXC_EF_ROT,&locstat))  {
780                        mxv_display_state &= ~MXC_FLAG_ROT;
781                        mx_exec_sh( wm, ctrl, "shm_cmd_rotate unrotate" );
782                        return;
783                } /*endif*/
784        } /*endfor*/
785        /* no rotated traces there -> continue and make them */
786
787        /* initialize */
788        mxv_display_state |= MXC_FLAG_ROT;
789        trc_z = trc_n = trc_e = NULL;
790        *station = '\0';
791        mx_exec_sh( wm, ctrl, "shm_cmd_rotate begin" );
792
793        /* loop all traces in memory */
794        flush = FALSE;
795        trc = NULL;
796        do  {
797                /* get next trace */
798                trc = db_getp( trc, EP_NEXT, NULL );
799                /* get station and component */
800                locstat = BC_NOERROR;
801                flush = (trc == NULL);
802                if  (!flush)  {
803                        db_gets( trc, ES_STATION, BC_SHORTSTRLTH, cstation, &locstat );
804                        if  (Severe(&locstat))  {*cstation = '\0'; locstat = BC_NOERROR;}
805                        comp = db_getc( trc, EC_COMP, &locstat );
806                        if  (Severe(&locstat))  {comp = ' '; locstat = BC_NOERROR;}
807                        flush = (strcmp(station,cstation) != 0);
808                } /*endif*/
809                if  (flush)  {
810                        /* rotate if traces are there */
811                        if  (trc_n != NULL && trc_e != NULL)  {
812                                /* compute azimuth if equal to 0.0 */
813                                if  (azimuth == 0.0)  {
814                                        mxh_compute_azimuth( cstation, lat, lon, &xazim, status );
815                                        if  (SySevere(status)) return;
816                                        if  (GpGetInt(cGpI_debug_level) > 3)
817                                                printf( "SHM-dbg5: rotate: azimuth %f for %s\n",
818                                                        xazim, cstation );
819                                } else {
820                                        xazim = azimuth;
821                                        if  (GpGetInt(cGpI_debug_level) > 3)
822                                                printf( "SHM-dbg5: rotate: constant azimuth %f for %s\n",
823                                                        xazim, cstation );
824                                } /*endif*/
825                                /* generate SH command line and execute it */
826                                if  (trc_z == NULL)  {
827                                        sprintf( cmd, "shm_cmd_rotate ;; a:%lx a:%lx %g",
828                                                trc_n, trc_e, xazim );
829                                } else {
830                                        sprintf( cmd, "shm_cmd_rotate a:%lx a:%lx a:%lx %g",
831                                                trc_z, trc_n, trc_e, xazim );
832                                } /*endif*/
833                                callsh( cmd, &dmy, status );
834                                if  (Severe(status))  return;
835                                /* get trace pointers of new traces */
836                                db_createdlist( NULL, &newtrclth );
837                                if  (newtrclth != 2)  {
838                                        printf( "*SHM: mx_rotation: this cannot happen (1)\n" );
839                                        *status = MXE_PROG_BUG;
840                                        return;
841                                } /*endif*/
842                                db_createdlist( newtrc, &newtrclth );
843                                newtrc[NEW_TRC_Z] = (trc_z == NULL)
844                                        ? NULL : db_getp(newtrc[NEW_TRC_R],EP_PREV,NULL);
845#                               ifdef XPHASE
846                                /* copy phases to output traces */
847                                if  (trc_z != NULL)
848                                        db_setp( newtrc[NEW_TRC_Z], EP_USRX,
849                                                pi_copy_phaselist(db_getp(trc_z,EP_USRX,NULL),status),status);
850                                if  (Severe(status))  return;
851                                db_setp( newtrc[NEW_TRC_R], EP_USR2,
852                                        pi_copy_phaselist(db_getp(trc_n,EP_USRX,NULL),status), status );
853                                if  (Severe(status))  return;
854                                db_setp( newtrc[NEW_TRC_T], EP_USR2,
855                                        pi_copy_phaselist(db_getp(trc_e,EP_USRX,NULL),status), status );
856                                if  (Severe(status))  return;
857#                               endif
858                        } /*endif*/
859                        /* reset variables for next rotation */
860                        strcpy( station, cstation );
861                        trc_z = trc_n = trc_e = NULL;
862                } /*endif*/
863                if  (Cap(comp) == 'Z')  trc_z = trc;
864                else if  (Cap(comp) == 'N')  trc_n = trc;
865                else if  (Cap(comp) == 'E')  trc_e = trc;
866        }  while (trc != NULL);
867
868        /* cleanup */
869        mx_exec_sh( wm, ctrl, "shm_cmd_rotate finish" );
870
871} /* end of mx_rotation */
872
873
874#undef MAX_NEW_TRC
875#undef NEW_TRC_R
876#undef NEW_TRC_T
877#undef NEW_TRC_Z
878
879
880
881/*---------------------------------------------------------------------------*/
882
883
884
885BOOLEAN mx_need_rotation( void )
886
887/* Returns whether rotation mode is switched on.  If no rotation is possible
888 * it switches off rotation mode.
889 *
890 * no input parameters
891 */
892{
893        /* local variables */
894        TSyBoolean redraw;      /* redraw display (not used) */
895        TSyStatus  locstat;     /* local status */
896
897        /* executable code */
898
899        if  (MXC_FLAG_ROT & mxv_display_state)  {
900                if  (mxh_rotation_is_possible())  {
901                        return TRUE;
902                } else {
903                        mx_clear_rotation();
904                        locstat = BC_NOERROR;
905                        callsh( "external_routine prepare_display", &redraw, &locstat );
906                        callsh( "hide all", &redraw, &locstat );
907                        callsh( "display _shm_view(y)", &redraw, &locstat );
908                        callsh( "rd r", &redraw, &locstat );
909                        if  (GpGetInt(cGpI_debug_level) > 1)
910                                printf( "SHM-dbg2: rotation mode switched off by mx_need_rotation\n" );
911                        return FALSE;
912                } /*endif*/
913        } else {
914                return FALSE;
915        } /*endif*/
916
917} /* end of mx_need_rotation */
918
919
920
921/*---------------------------------------------------------------------------*/
922
923
924
925static BOOLEAN mxh_rotation_is_possible( void )
926
927/* checks whether a rotation is possible on the traces in memory
928 *
929 * no parameters
930 */
931{
932        /* local variables */
933        TPmTrace   *trc;                        /* pointer to current trace */
934        int        t;                           /* trace counter */
935        TSyStatus  locstat;                     /* local status */
936        char       station[BC_SHORTSTRLTH+1];   /* station name */
937        char       c_station[BC_SHORTSTRLTH+1]; /* current station */
938        char       c_comp;                      /* current component */
939        TSyBoolean z_found, n_found, e_found;   /* components found */
940
941        /* executable code */
942
943        /* loop over all traces in memory */
944        trc = NULL;
945        station[0] = '\0';
946        z_found = n_found = e_found = FALSE;
947        for  (t=0; t<db_lstlth(); t++)  {
948                /* get next trace pointer */
949                locstat = BC_NOERROR;
950                trc = db_getp( trc, EP_NEXT, &locstat );
951                if  (Severe(&locstat))  {printf("*SHM: mx-error(10) ***\n"); continue;}
952                /* get current station and component */
953                db_gets( trc, ES_STATION, BC_SHORTSTRLTH, c_station, &locstat );
954                if  (Severe(&locstat))  continue;
955                c_comp = db_getc( trc, EC_COMP, &locstat );
956                if  (Severe(&locstat))  continue;
957                if  (strcmp(station,c_station) != 0)  {
958                        z_found = n_found = e_found = FALSE;
959                        strcpy( station, c_station );
960                } /*endif*/
961                switch (c_comp)  {
962                        case 'z':  case 'Z':  z_found = TRUE; break;
963                        case 'n':  case 'N':  n_found = TRUE; break;
964                        case 'e':  case 'E':  e_found = TRUE; break;
965                } /*endswitch*/
966                if  (z_found && n_found && e_found)  return TRUE;
967        } /*endfor*/
968
969        return FALSE;
970
971} /* end of mxh_rotation_is_possible */
972
973
974
975/*---------------------------------------------------------------------------*/
976
977
978
979void mx_trclist_command( Widget wm, Widget ws, MGT_DSPCTRL *ctrl, char cmd[],
980        STATUS *status )
981
982/* executes SH command on trace list
983 *
984 * parameters of routine
985 * Widget     wm, ws;      input; widget ID's of drawing areas
986 * MGT_DSPCTRL *ctrl;      input; display control
987 * char       cmd[];       input; command to be executed
988 * TSyStatus  *status;     output; return status
989 */
990{
991        /* local variables */
992        char     str[BC_LINELTH+1];     /* scratch string */
993        char     cmdline[BC_LINELTH+1]; /* command string */
994
995        /* executable code */
996
997        ts_get_selection_string( BC_LINELTH, str );
998        if  (*str == '\0' && *cmd >= 'a' && *cmd <= 'z')  return;
999        if  (*str == '\0')  strcpy( str, "all" );
1000
1001        if  (strlen(cmd)+strlen(str) > BC_LINELTH-1)  {
1002                *status = MXE_STROVFL;
1003                return;
1004        } /*endif*/
1005        sprintf( cmdline, cmd, str );
1006
1007        if  (GpGetInt(cGpI_debug_level) > 3)
1008                printf( "SHM-dbg4: executing: >%s<\n", cmdline );
1009        mx_exec_sh( wm, ctrl, cmdline );
1010
1011        ts_clear_selections();
1012
1013        mg_do_drag( wm, MGC_DRAG_CLEAR, 0, 0 );
1014        mg_plot_drag_window( ws, ctrl->show_phase_acc, status );
1015
1016} /* end of mx_trclist_command */
1017
1018
1019
1020/*----------------------------------------------------------------------------*/
1021
1022
1023
1024void mx_trclist_refml( STATUS *status )
1025
1026/* stores reference ml in parameter list
1027 *
1028 * parameters of routine
1029 * TSyStatus     *status;      output; return status
1030 */
1031{
1032        /* local variables */
1033        char       selstr[BC_LINELTH+1];        /* selection string */
1034        int        trcnum;                      /* trace number */
1035        TPmTrace   *trc;                        /* pointer to trace */
1036        char       station[BC_SHORTSTRLTH+1];   /* station name of ref ml */
1037        char       c_station[BC_SHORTSTRLTH+1]; /* current station */
1038        TPiPhaseRoot *proot;                    /* poiner to phase root */
1039        TPiPhaseList *plist;                    /* phase list */
1040        TPiPhase   *phase;                      /* pointer to phase info */
1041        int        p;                           /* phase counter */
1042        TSyStatus  locstat;                     /* local status */
1043        TSyBoolean ml_done;                     /* found ml entry on ref. station */
1044        TSyBoolean is_ml_station;               /* curr. station is ml ref station */
1045
1046        /* executable code */
1047
1048        ts_get_selection_string( BC_LINELTH, selstr );
1049        /* ts_clear_selections(); */  /* clear selection done in shm.c */
1050        if  (*selstr == '\0')  {
1051                *status = MXE_NONE_SELECT;
1052                return;
1053        } else if  (strchr(selstr,',') != NULL)  {
1054                *status = MXE_MANY_SELECT;
1055                err_setcontext( " ## too many traces selected: " );
1056                err_setcontext( selstr );
1057                return;
1058        } /*endif*/
1059
1060        /* get station name of selected trace */
1061        trcnum = 0;
1062        sscanf( selstr, "%d", &trcnum );
1063        trc = mg_trcptr( trcnum );
1064        if  (trc == NULL)  {
1065                *status = MXE_PROG_BUG;
1066                err_setcontext( " ## selected trace resulted in NULL pointer" );
1067                return;
1068        } /*endif*/
1069        db_gets( trc, ES_STATION, BC_SHORTSTRLTH, station, status );
1070        if  (Severe(status))  return;
1071
1072        /* loop all phases and look for ml entries */
1073        ml_done = FALSE;
1074        proot = NULL;
1075        FOREVER  {
1076                /* get next phase root pointer */
1077                proot = PiNextPhaseRoot( proot );
1078                if  (proot == NULL)  break;
1079                /* get phase list and station name */
1080                plist = PiPhaseListOfRoot( proot );
1081                if  (plist == NULL)  continue;
1082                strcpy( c_station, PiStationOfRoot(proot) );
1083                is_ml_station = (strcmp(c_station,station) == 0);
1084                /* loop all phases of trace */
1085                for  (p=0; p<PiPhaseListLength(plist); p++)  {
1086                        phase = PiGetPhase( plist, p, status );
1087                        if  (Severe(status))  return;
1088                        if  (phase->magn_source == cPiMagnMl)  {
1089                                /* found an ml entry */
1090                                if  (is_ml_station)  {
1091                                        /* set magnitude flag */
1092                                        phase->flags |= fPiAttribMagn;
1093                                        ml_done = TRUE;
1094                                } else {
1095                                        /* clear magnitude flag */
1096                                        phase->flags &= ~fPiAttribMagn;
1097                                } /*endif*/
1098                        } /*endif*/
1099                } /*endfor*/
1100        } /*endfor*/
1101
1102        /* no ml entry found */
1103        if  (!ml_done)
1104                *status = MXE_NO_MLENTRY;
1105
1106} /* end of mx_trclist_refml */
1107
1108
1109
1110/*----------------------------------------------------------------------------*/
1111
1112
1113
1114void mx_analyst_name( Widget w[], MGT_DSPCTRL *ctrl, STATUS *status )
1115
1116/* Reads analyst's initials from dialog box checks it and closes dialog
1117 * box if everything is ok.
1118 *
1119 * parameters of routine
1120 * Widget     w[];        input; widget array
1121 * TSyStatus  *status;    output; return status
1122 */
1123{
1124        /* local variables */
1125        char       *initials;                  /* pointer to initials */
1126        char       analyst[BC_SHORTSTRLTH+1];  /* copy of initials */
1127        TSyBoolean found;                      /* name found */
1128        TGpTextList txtlst;                    /* text list with analysts initals */
1129        int        i;                          /* counter */
1130
1131        /* executable code */
1132
1133        initials = cu_get_string( w[k_widget_analyst_name_text] );
1134        if  (initials == NULL)  {*status = MXE_ILL_ANALYST; return;}
1135        if  (*initials == '\0')  {*status = MXE_ILL_ANALYST; return;}
1136        if  (strlen(initials) > 4)  {*status = MXE_ILL_ANALYST; return;}
1137        strcpy( analyst, initials );
1138        /*ut_cap( analyst );*/
1139
1140        /* get list of analysts from setup file */
1141        GpParseTextList( GpGetString(cGpS_list_of_analysts), &txtlst );
1142
1143        found = FALSE;
1144        for  (i=0; i<txtlst.numelem; i++)  {
1145                found = (strcmp(txtlst.elem[i],analyst) == 0);
1146                if  (found)  break;
1147        } /*endwhile*/
1148
1149        GpFreeTextList( &txtlst );
1150
1151        if  (found)  {
1152                XtUnmanageChild( w[k_widget_analyst_box] );
1153                GpSetString( cGpS_analyst, analyst, NULL );
1154        } else {
1155                *status = MXE_ILL_ANALYST;
1156        } /*endif*/
1157
1158} /* end of mx_analyst_name */
1159
1160
1161
1162/*--------------------------------------------------------------------------*/
1163
1164
1165
1166void mx_filter_box_defaults( Widget w[], MX_CMD_FILTER *fil )
1167
1168/* resets filter box
1169 *
1170 * parameters of routine
1171 * Widget     w[];       input; widget array
1172 * MX_CMD_FILTER *fil;   input; filter parameters
1173 */
1174{
1175        /* local variables */
1176        Arg      al[1];        /* argument list */
1177        int      cut_w_no;     /* widget number of cutoff time */
1178        int      i;            /* counter */
1179
1180        /* executable code */
1181
1182        if  (fil->autocut >= 600.0)       cut_w_no = k_widget_filter_autocut_10min;
1183        else if  (fil->autocut >= 300.0)  cut_w_no = k_widget_filter_autocut_5min;
1184        else if  (fil->autocut >= 180.0)  cut_w_no = k_widget_filter_autocut_3min;
1185        else if  (fil->autocut >= 60.0)   cut_w_no = k_widget_filter_autocut_1min;
1186        else if  (fil->autocut >= 20.0)   cut_w_no = k_widget_filter_autocut_20sec;
1187        else if  (fil->autocut >= 5.0)    cut_w_no = k_widget_filter_autocut_5sec;
1188        else                              cut_w_no = k_widget_filter_autocut_0;
1189        XtSetArg( al[0], XmNmenuHistory, w[cut_w_no] );
1190        XtSetValues( w[k_widget_filter_autocut_option], al, 1 );
1191
1192        for  (i=k_widget_filter_none; i<=k_widget_filter_sro_lp; i++)
1193                if  (i != k_widget_filter_lrsm_lp)
1194                        XmToggleButtonSetState( w[i], FALSE, FALSE );
1195        if  (strcmp(fil->name,"GRF_STANDARD_BP") == 0)
1196                XmToggleButtonSetState( w[k_widget_filter_standard_bp], TRUE, FALSE );
1197        else if  (strcmp(fil->name,"WWSSN_SP") == 0)
1198                XmToggleButtonSetState( w[k_widget_filter_wwssn_sp], TRUE, FALSE );
1199        else if  (strcmp(fil->name,"WWSSN_LP") == 0)
1200                XmToggleButtonSetState( w[k_widget_filter_wwssn_lp], TRUE, FALSE );
1201        else if  (strcmp(fil->name,"LRSM_SP") == 0)
1202                XmToggleButtonSetState( w[k_widget_filter_lrsm_sp], TRUE, FALSE );
1203        else if  (strcmp(fil->name,"LRSM_LP") == 0)
1204                XmToggleButtonSetState( w[k_widget_filter_lrsm_lp], TRUE, FALSE );
1205        else if  (strcmp(fil->name,"KIRNOS") == 0)
1206                XmToggleButtonSetState( w[k_widget_filter_kirnos], TRUE, FALSE );
1207        else if  (strcmp(fil->name,"WOODAND") == 0)
1208                XmToggleButtonSetState( w[k_widget_filter_woodand], TRUE, FALSE );
1209        else if  (strcmp(fil->name,"SRO_LP") == 0)
1210                XmToggleButtonSetState( w[k_widget_filter_sro_lp], TRUE, FALSE );
1211
1212        cu_set_string( w[k_widget_filter_edit_text], fil->name );
1213
1214} /* end of mx_filter_box_defaults */
1215
1216
1217
1218/*----------------------------------------------------------------------------*/
1219
1220
1221
1222void mx_sh_external_routine( char cmd[], STATUS *status )
1223
1224/* external routine for SH
1225 *
1226 * parameters of routine
1227 * char       cmd[];         input; switch to subcommands
1228 * TSyStatus  *status;       output; return status
1229 */
1230{
1231        /* local variables */
1232
1233        /* executable code */
1234
1235        if  (strcmp(cmd,"PREPARE_DISPLAY") == 0)  {
1236                mx_prepare_display();
1237        } else if  (strcmp(cmd,"SAVE_DSP_PHASES") == 0)  {
1238                /*cl3_save_phase_display( status );*/
1239                if  (GpGetInt(cGpI_debug_level) > 2)
1240                        printf( "SHM-dbg3: external_routine: SAVE_DSP_PHASES disabled\n" );
1241        } else if  (strcmp(cmd,"RESTORE_DSP_PHASES") == 0)  {
1242                if  (GpGetInt(cGpI_debug_level) > 2)
1243                        printf( "SHM-dbg3: external_routine: RESTORE_DSP_PHASES disabled\n" );
1244        } else if  (strcmp(cmd,"RESET_DISPLAY_FLAGS") == 0)  {
1245                mxv_display_state = 0;
1246        } else if  (strcmp(cmd,"PHASE_CHECK") == 0)  {
1247                PiPhaseDump();
1248        } else if  (strncmp(cmd,"BTN_READS",9) == 0)  {
1249                if  (GpGetInt(cGpI_debug_level) > 2)
1250                        printf( "SHM-dbg3: external_routine: btn_reads ignored\n" );
1251        } else if  (strncmp(cmd,"READ_DIALOG:",12) == 0)  {
1252                mxh_read_statlist( cmd+12, xmv_w, &xmv_cmd_readg.sl, status );
1253        } else if  (strncmp(cmd,"LOC_EXTERNAL:",13) == 0)  {
1254                mxh_set_entry_name( xmv_w[k_widget_param_hypoloc], cmd+13 );
1255        } else if  (strncmp(cmd,"TABLE_ML_SIGMA:",15) == 0)  {
1256                si_read_table( cmd+15, "ml-sigma", status );
1257        } else if  (strcmp(cmd,"DUMP_GLOBALS") == 0)  {
1258                GpDumpParams();
1259        } else if  (strncmp(cmd,"MINMAXFMT:",10) == 0)  {
1260                /* disabled */
1261                if  (GpGetInt(cGpI_debug_level) > 0)
1262                        printf( "SHM-dbg1: function minmaxfmt obsolete\n" );
1263        } else {
1264                *status = MXE_ILL_EXTROUT;
1265                return;
1266        } /*endif*/
1267
1268} /* end of mx_sh_external_routine */
1269
1270
1271
1272/*----------------------------------------------------------------------------*/
1273
1274
1275
1276static void mx_prepare_display( void )
1277
1278/* selects traces to be displayed on next redraw (sets EF_VIEW flag).
1279 *
1280 */
1281{
1282        /* local variables */
1283        int        t;             /* trace counter */
1284        TPmTrace   *trc;          /* pointer to trace info */
1285        TSyStatus  locstat;       /* local status */
1286        TSyBoolean dsp;           /* do display trace */
1287        TSyBoolean dsp_filtered;  /* display filtered traces */
1288        TSyBoolean dsp_rotated;   /* display rotated traces */
1289
1290        /* executable code */
1291
1292        dsp_filtered = (MXC_FLAG_FILTER & mxv_display_state);
1293        dsp_rotated = (MXC_FLAG_ROT & mxv_display_state);
1294
1295        /* loop over all traces in memory */
1296        trc = NULL;
1297        for  (t=0; t<db_lstlth(); t++)  {
1298                /* get next trace pointer */
1299                locstat = BC_NOERROR;
1300                trc = db_getp( trc, EP_NEXT, &locstat );
1301                if  (Severe(&locstat))  {printf("*SHM: mx-error(1) ***\n"); continue;}
1302                dsp = (
1303                        !db_getf(trc,MXC_EF_HIDE,&locstat)
1304                        && db_getf(trc,MXC_EF_FILTER,&locstat) == dsp_filtered
1305                        && db_getf(trc,MXC_EF_ROT,&locstat) == dsp_rotated
1306                );
1307                db_setf( trc, MXC_EF_VIEW, dsp, &locstat );
1308                if  (Severe(&locstat))  {printf("*SHM: mx-error(2) ***\n"); continue;}
1309        } /*endfor*/
1310
1311} /* end of mx_prepare_display */
1312
1313
1314
1315/*----------------------------------------------------------------------------*/
1316
1317
1318
1319void mx_clear_rotation( void )
1320
1321/* resets rotation state
1322 *
1323 * no parameters
1324 */
1325{
1326        /* executable code */
1327
1328        mxv_display_state &= ~MXC_FLAG_ROT;
1329
1330} /* end of mx_clear_rotation */
1331
1332
1333
1334/*----------------------------------------------------------------------------*/
1335
1336
1337
1338void mx_get_chanlist( Widget w[], MX_CMD_READG *rg )
1339
1340
1341/* reads list of channels from dialog box into channel array
1342 *
1343 * parameters of routine
1344 * Widget        w[];          input; widget array
1345 * MX_CMD_READG  *rg;          output; channel array (chanstr)
1346 */
1347{
1348        /* local variables */
1349        int      i;                 /* channel counter */
1350        int      cwno[MXC_MAXCHAN]; /* channel widget numbers */
1351        char     *str;              /* pointer to string */
1352
1353        /* executable code */
1354
1355        cwno[0] = k_widget_read_grsn_1hz;
1356        cwno[1] = k_widget_read_grsn_20hz;
1357        cwno[2] = k_widget_read_grsn_80hz;
1358        cwno[3] = k_widget_read_grsn_edit_hz;
1359
1360        /* reset channel counter */
1361        rg->channum = 0;
1362
1363        for (i=0; i<MXC_MAXCHAN; i++)  {
1364                if  (XmToggleButtonGetState(w[cwno[i]]))  {
1365                        strcpy( rg->chanstr[rg->channum], rg->sl.channel[i] );
1366                        if  (strcmp(rg->chanstr[rg->channum],"ed") == 0)  {
1367                                str = cu_get_string( w[k_widget_read_grsn_hz_text] );
1368                                if  (strlen(str) <= MXC_CHANLTH && strlen(str) > 0)  {
1369                                        strcpy( rg->chanstr[rg->channum], str );
1370                                } else {
1371                                        printf( "*SHM: illegal channel string %s\n", str );
1372                                } /*endif*/
1373                        } /*endif*/
1374                        (rg->channum)++;
1375                } /*endif*/
1376        } /*endfor*/
1377
1378#ifdef XXX
1379        /* check buttons */
1380        if  (XmToggleButtonGetState(w[k_widget_read_grsn_1hz]))  {
1381                strcpy( rg->chanstr[rg->channum], "LH" );
1382                (rg->channum)++;
1383        } /*endif*/
1384        if  (XmToggleButtonGetState(w[k_widget_read_grsn_20hz]))  {
1385                strcpy( rg->chanstr[rg->channum], "BH" );
1386                (rg->channum)++;
1387        } /*endif*/
1388        if  (XmToggleButtonGetState(w[k_widget_read_grsn_80hz]))  {
1389                strcpy( rg->chanstr[rg->channum], "HH" );
1390                (rg->channum)++;
1391        } /*endif*/
1392        if  (XmToggleButtonGetState(w[k_widget_read_grsn_edit_hz]))  {
1393                str = cu_get_string( w[k_widget_read_grsn_hz_text] );
1394                if  (strlen(str) <= MXC_CHANLTH && strlen(str) > 0)  {
1395                        strcpy( rg->chanstr[rg->channum], str );
1396                } else {
1397                        printf( "*SHM: illegal channel string %s\n", str );
1398                } /*endif*/
1399                (rg->channum)++;
1400        } /*endif*/
1401#endif
1402
1403} /* end of mx_get_chanlist */
1404
1405
1406
1407/*----------------------------------------------------------------------------*/
1408
1409
1410
1411static void mxh_read_statlist( char fname[], Widget w[], MX_STATLIST *sl,
1412        STATUS *status )
1413
1414/* reads in station list from file 'fname'
1415 *
1416 * parameters of routine
1417 * char        fname[];        input; name of input file
1418 * Widget      w[];            input; widget array (widgets will be modified)
1419 * MX_STATLIST *sl;            output; station list for dialog box
1420 * TSyStatus   *status;        output; return status
1421 */
1422{
1423        /* local variables */
1424        FILE     *fp;                /* pointer to input file */
1425        char     line[BC_LINELTH+1]; /* current line */
1426        int      s;                  /* station counter */
1427        int      c;                  /* channel counter */
1428        int      cwno[MXC_MAXCHAN];  /* channel widget numbers */
1429        int      slen;               /* string length */
1430        char     *ch;                /* char pointer */
1431        Arg      args[2];            /* argument list */
1432        int      n;                  /* argument counter */
1433        XmString xmstr;              /* Xm string */
1434
1435        /* executable code */
1436
1437        fp = sy_fopen( fname, "r" );
1438        if  (fp == NULL)  {
1439                *status = MXE_OPENREAD;
1440                err_setcontext( " ## file " );  err_setcontext( fname );
1441                return;
1442        } /*endif*/
1443
1444        /* initialize output record */
1445        for  (s=0; s<MXC_STATLIST_LTH; s++)  strcpy( sl->code[s], "---" );
1446        strcpy( sl->set1code, "---" );
1447        strcpy( sl->set2code, "---" );
1448        sl->set1start = sl->set1end = sl->set2start = sl->set2end = 0;
1449        strcpy( sl->channel[0], "LH" );
1450        strcpy( sl->channel[1], "BH" );
1451        strcpy( sl->channel[2], "HH" );
1452        strcpy( sl->channel[3], "ed" );
1453
1454        s = c = 0;
1455        while  (fgets(line,BC_LINELTH,fp) != NULL)  {
1456                if  (*line == '!' || *line == '\n')  continue;
1457                slen = strlen( line ) - 1;
1458                if  (line[slen] == '\n')  line[slen] = '\0';
1459                if  (strncmp(line,"set1:",5) == 0)  {
1460                        if  (sscanf(line+5,"%d %d %s",
1461                                &(sl->set1start),&(sl->set1end),sl->set1code) != 3)
1462                                fprintf( stderr,
1463                                        "*SHM: mx_read_statlist: error reading subset 1\n" );
1464                } else if  (strncmp(line,"set2:",5) == 0)  {
1465                        if  (sscanf(line+5,"%d %d %s",
1466                                &(sl->set2start),&(sl->set2end),sl->set2code) != 3)
1467                                fprintf( stderr,
1468                                        "*SHM: mx_read_statlist: error reading subset 2\n" );
1469                } else if  (*line == '*')  {
1470                        if  (s == MXC_STATLIST_LTH)  {
1471                                fprintf( stderr, "*SHM: mx_read_statlist: too many stations\n" );
1472                        } else {
1473                                ch = line + 1;
1474                                while  (*ch == ' ' && *ch != '\0')  ch++;
1475                                if  (strlen(ch) > MXC_STATSTR_LTH)  {
1476                                        fprintf( stderr,
1477                                                "*SHM: mx_read_statlist: station name %s too long\n", ch );
1478                                } else {
1479                                        strcpy( sl->code[s++], ch );
1480                                } /*endif*/
1481                        } /*endif*/
1482                } else if  (*line == 'c')  {
1483                        if  (c < MXC_MAXCHAN)  {
1484                                sl->channel[c][0] = line[2];
1485                                sl->channel[c][1] = line[3];
1486                                sl->channel[c][2] = '\0';
1487                                c++;
1488                        } else {
1489                                fprintf( stderr, "*SHM: mx_read_statlist: too many channels\n" );
1490                        } /*endif*/
1491                } else {
1492                        fprintf( stderr, "*SHM: mx_read_statlist: illegal line:\n%s", line );
1493                } /*endif*/
1494        } /*endwhile*/
1495
1496        sy_fclose( fp );
1497
1498        /* set dialog box */
1499        for  (s=0; s<MXC_STATLIST_LTH; s++)  {
1500                xmstr = XmStringCreateLtoR( sl->code[s], "" );
1501                n = 0;
1502                XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1503                XtSetValues( w[k_widget_read_grsn_station+s], args, n );
1504                XtSetSensitive( w[k_widget_read_grsn_station+s], (sl->code[s][0] != '-'));
1505        } /*endfor*/
1506
1507        xmstr = XmStringCreateLtoR( sl->set1code, "" );
1508        n = 0;
1509        XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1510        XtSetValues( w[k_widget_read_grsn_grf], args, n );
1511        XtSetSensitive( w[k_widget_read_grsn_grf], (sl->set1code[0] != '-') );
1512        xmstr = XmStringCreateLtoR( sl->set2code, "" );
1513        n = 0;
1514        XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1515        XtSetValues( w[k_widget_read_grsn_grsn], args, n );
1516        XtSetSensitive( w[k_widget_read_grsn_grsn], (sl->set2code[0] != '-') );
1517
1518        cwno[0] = k_widget_read_grsn_1hz;
1519        cwno[1] = k_widget_read_grsn_20hz;
1520        cwno[2] = k_widget_read_grsn_80hz;
1521        cwno[3] = k_widget_read_grsn_edit_hz;
1522        for  (c=0; c<MXC_MAXCHAN; c++)  {
1523                xmstr = XmStringCreateLtoR( sl->channel[c], "" );
1524                n = 0;
1525                XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1526                XtSetValues( w[cwno[c]], args, n );
1527                XtSetSensitive( w[cwno[c]], (sl->channel[c][0] != '-'));
1528        } /*endfor*/
1529
1530} /* end of mxh_read_statlist */
1531
1532
1533
1534/*----------------------------------------------------------------------------*/
1535
1536
1537
1538void mx_name_read_buttons( Widget w[], int dialbox_num, TSyStatus *status )
1539
1540/* reads in station list from parameter file.  Original from mxh_read_statlist.
1541 *
1542 * parameters of routine
1543 * Widget      w[];            input; widget array (widgets will be modified)
1544 * int         dialbox_num;    input; number of dialog box to be modified
1545 * MX_STATLIST *sl;            output; station list for dialog box
1546 * TSyStatus   *status;        output; return status
1547 */
1548{
1549        /* local variables */
1550        char     parname[cBcLineLth+1];   /* name of parameter (dialog box number) */
1551        char     parval[cBcLongStrLth+1]; /* list of stations */
1552        int      ok;                      /* parameter ok? */
1553        TGpTextList slist;                /* parsed station list */
1554        int      s;                       /* station counter */
1555        int      setcnt;                  /* set counter */
1556        int      c;                       /* channel counter */
1557        int      cwno[MXC_MAXCHAN];       /* channel widget numbers */
1558        Arg      args[2];                 /* argument list */
1559        int      n;                       /* argument counter */
1560        XmString xmstr;                   /* Xm string */
1561        MX_STATLIST *sl;                  /* station list for dialog box */
1562        int      slen;                    /* string length */
1563
1564        /* executable code */
1565
1566        sl = &(xmv_cmd_readg.sl);
1567
1568        /* get station parameter from parameter file */
1569        sprintf( parname, "v$read_dialog_stations_%02d", dialbox_num );
1570        GpReadParameter( parname, cBcLongStrLth, parval, &ok );
1571        if  (!ok)  {*status = MXE_NOT_FOUND;return;}
1572        GpParseTextList( parval, &slist );
1573
1574        /* initialize output record */
1575        for  (s=0; s<MXC_STATLIST_LTH; s++)  strcpy( sl->code[s], "---" );
1576        strcpy( sl->set1code, "---" );
1577        strcpy( sl->set2code, "---" );
1578        sl->set1start = sl->set1end = sl->set2start = sl->set2end = 0;
1579        strcpy( sl->channel[0], "LH" );
1580        strcpy( sl->channel[1], "BH" );
1581        strcpy( sl->channel[2], "HH" );
1582        strcpy( sl->channel[3], "ed" );
1583
1584        setcnt = 0;
1585        for  (s=0; s<slist.numelem; s++)  {
1586                slen = strlen( slist.elem[s] );
1587                if  (slen > MXC_STATSTR_LTH)  {
1588                        fprintf( stderr,
1589                                "*SHM: mx_name_read_buttons: station name %s too long\n",
1590                                slist.elem[s] );
1591                        continue;
1592                } /*endif*/
1593                if  (s == MXC_STATLIST_LTH)  {
1594                        strcpy( sl->set1code, slist.elem[s] );
1595                } else if  (s == MXC_STATLIST_LTH+1)  {
1596                        strcpy( sl->set2code, slist.elem[s] );
1597                } else if  (s < MXC_STATLIST_LTH)  {
1598                        if  (slist.elem[s][0] == '[')  {
1599                                setcnt++;
1600                                if  (setcnt == 1)  {
1601                                        sl->set1start = s;
1602                                } else if  (setcnt == 2)  {
1603                                        sl->set2start = s;
1604                                } /*endif*/
1605                                strcpy( sl->code[s], slist.elem[s]+1 );
1606                        } else if  (slist.elem[s][slen-1] == ']')  {
1607                                if  (setcnt == 1)  {
1608                                        sl->set1end = s;
1609                                } else if  (setcnt == 2)  {
1610                                        sl->set2end = s;
1611                                } /*endif*/
1612                                strcpy( sl->code[s], slist.elem[s] );
1613                                sl->code[s][slen-1] = '\0';
1614                        } else {
1615                                strcpy( sl->code[s], slist.elem[s] );
1616                        } /*endif*/
1617                } /*endif*/
1618        } /*endfor*/
1619        if  (setcnt > 0 && sl->set1code[0] == '-')  strcpy( sl->set1code, "SET1" );
1620        if  (setcnt > 1 && sl->set2code[0] == '-')  strcpy( sl->set2code, "SET2" );
1621
1622        GpFreeTextList( &slist );
1623
1624        /* get channel parameter from parameter file */
1625        sprintf( parname, "v$read_dialog_channels_%02d", dialbox_num );
1626        GpReadParameter( parname, cBcLongStrLth, parval, &ok );
1627        if  (ok)  {
1628                GpParseTextList( parval, &slist );
1629                c = 0;
1630                for  (s=0; s<slist.numelem; s++)
1631                        if  (s < MXC_MAXCHAN && strlen(slist.elem[s]) <= MXC_CHANLTH)
1632                                strcpy( sl->channel[c++], slist.elem[s] );
1633                GpFreeTextList( &slist );
1634        } /*endif*/
1635
1636        /* set dialog box */
1637        for  (s=0; s<MXC_STATLIST_LTH; s++)  {
1638                xmstr = XmStringCreateLtoR( sl->code[s], "" );
1639                n = 0;
1640                XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1641                XtSetValues( w[k_widget_read_grsn_station+s], args, n );
1642                XtSetSensitive( w[k_widget_read_grsn_station+s], (sl->code[s][0] != '-'));
1643                XmToggleButtonSetState( w[k_widget_read_grsn_station+s], FALSE, TRUE );
1644        } /*endfor*/
1645
1646        xmstr = XmStringCreateLtoR( sl->set1code, "" );
1647        n = 0;
1648        XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1649        XtSetValues( w[k_widget_read_grsn_grf], args, n );
1650        XtSetSensitive( w[k_widget_read_grsn_grf], (sl->set1code[0] != '-') );
1651        xmstr = XmStringCreateLtoR( sl->set2code, "" );
1652        n = 0;
1653        XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1654        XtSetValues( w[k_widget_read_grsn_grsn], args, n );
1655        XtSetSensitive( w[k_widget_read_grsn_grsn], (sl->set2code[0] != '-') );
1656
1657        cwno[0] = k_widget_read_grsn_1hz;
1658        cwno[1] = k_widget_read_grsn_20hz;
1659        cwno[2] = k_widget_read_grsn_80hz;
1660        cwno[3] = k_widget_read_grsn_edit_hz;
1661        for  (c=0; c<MXC_MAXCHAN; c++)  {
1662                xmstr = XmStringCreateLtoR( sl->channel[c], "" );
1663                n = 0;
1664                XtSetArg( args[n], XmNlabelString, xmstr ); n++;
1665                XtSetValues( w[cwno[c]], args, n );
1666                XtSetSensitive( w[cwno[c]], (sl->channel[c][0] != '-'));
1667        } /*endfor*/
1668
1669} /* end of mx_name_read_buttons */
1670
1671
1672
1673/*----------------------------------------------------------------------------*/
1674
1675
1676
1677static void mxh_read_file_list( Widget w, MGT_DSPCTRL *ctrl, char filenames[],
1678        int format, STATUS *status )
1679
1680/* reads in all GSE files matching the wildcard string "filenames"
1681 *
1682 * parameters of routine
1683 * Widget     w;                 input; widget ID of drawing area
1684 * MGT_DSPCTRL *ctrl;            input; display control params
1685 * char       filenames[];       input; wild card string for filenames
1686 * int        format;            input; format code
1687 * TSyStatus  *status;           output; return status
1688 */
1689{
1690        /* local variables */
1691        char        currfile[BC_FILELTH+1];      /* current file */
1692        char        altfile[cBcFileLth+1];       /* another filename */
1693        int         filecnt;                     /* file counter */
1694        char        cmd[BC_LINELTH+1];           /* comand line */
1695        char        *cp;                         /* moving pointer */
1696        TSyBoolean  redraw;                      /* dummy */
1697        int         i;                           /* counter */
1698
1699        /* executable code */
1700
1701        mx_exec_sh( w, ctrl, "nr" );
1702        filecnt = 0;
1703        FOREVER {
1704
1705                /* try to find next matching file */
1706                sy_findfile( SYC_FF_NAME|SYC_FF_DIR|SYC_FF_EXT, filenames, currfile );
1707                if  (*currfile == '\0')  {
1708                        if  (filecnt == 0)  {
1709                                *status = MXE_NO_GSE_MATCH;
1710                                break;
1711                        } /*endif*/
1712                        break;
1713                } /*endif*/
1714
1715                /* put backslashes instead if slashes because of SH command line */
1716                cp = currfile - 1;
1717                while  (*(++cp) != '\0')
1718                        if  (*cp == '/')
1719                                *cp = '\\';
1720
1721                /* process file currfile */
1722                if  (strlen(currfile)+12 > BC_LINELTH)  {
1723                        *status = MXE_STROVFL;
1724                        break;
1725                } /*endif*/
1726                switch  (format)  {
1727                case MXC_FORMAT_GSE: sprintf( cmd, "@READGSE_MERGE %s ALL", currfile ); break;
1728                case MXC_FORMAT_GSE2: sprintf( cmd, "@READGSE_MERGE %s ALL", currfile ); break;
1729                case MXC_FORMAT_AH: sprintf( cmd, "@READAH %s ALL", currfile ); break;
1730                case MXC_FORMAT_Q:
1731                        strcpy( altfile, currfile );
1732                        i = strlen( altfile ) - 4;
1733                        if  (i > 1 && strcmp(altfile+i,".QBN") == 0)  {
1734                                altfile[i] = '\0';
1735                                sprintf( cmd, "@READ %s ALL", altfile );
1736                        } else {
1737                                sprintf( cmd, "! @READ %s ALL", altfile );
1738                        } /*endif*/
1739                        break;
1740                default:
1741                        printf( "*SHM: mxh_read_file_list: this should not happen\n" );
1742                        break;
1743                } /*endswitch*/
1744                if  (GpGetInt(cGpI_debug_level) > 1)
1745                        printf( "SHM-dbg2: executing command: %s\n", cmd );
1746                callsh( cmd, &redraw, status );
1747                if  (Severe(status))  {
1748                        /* should print out error in a more elaborate way */
1749                        printf( "*SHM: readgse error %d\n", *status );
1750                        *status = BC_NOERROR;
1751                } /*endif*/
1752                /* mx_exec_sh( w, ctrl, cmd ); */
1753
1754                /* increment file counter */
1755                filecnt++;
1756
1757        } /*endfor*/
1758        mx_exec_sh( w, ctrl, "rd" );
1759
1760} /* end of mxh_read_file_list */
1761
1762
1763
1764/*----------------------------------------------------------------------------*/
1765
1766
1767#define MAX_S_LTH 8
1768
1769
1770static void mxh_filter_separately( Widget w, MGT_DSPCTRL *ctrl, char filter[],
1771        float autocut, STATUS *status )
1772
1773/* Filters traces on display separately.
1774 *
1775 * parameters of routine
1776 * Widget     w;             input; widget ID of drawing window
1777 * MGT_DSPCTRL *ctrl;        input; display control
1778 * char       filter[];      input; name of filter (without prefix)
1779 * float      autocut;       input; autocut of traces in sec
1780 * TSyStatus  *status;       output; return status
1781 */
1782{
1783        /* local variables */
1784        void     *trc;                         /* trace pointer */
1785        int      trcnum;                       /* trace number on display */
1786        char     complete_name[BC_FILELTH+1];  /* complete filter name */
1787        char     tfname[BC_FILELTH+1];         /* transfer function name */
1788        char     last_name[BC_FILELTH+1];      /* last filter */
1789        BOOLEAN  simulation;                   /* is simulation filter */
1790        char     station[BC_SHORTSTRLTH+1];    /* station name */
1791        char     cmd[BC_LINELTH+1];            /* SH command */
1792        char     filter_typ, filter_typ_save;  /* filter type */
1793        void     *newtrc;                      /* pointer to new trace */
1794        void     *tmp;                         /* scratch pointer */
1795        void     *lasttrc;                     /* last trace at beginning */
1796        TIME     ttime;                        /* start time of trace */
1797        char     strtime[cBcTimeLth+1];        /* converted start time */
1798        int      trcflags;                     /* trace flags for filtered traces */
1799        TSyStatus locstat;                     /* local status */
1800        BOOLEAN  dmy;                          /* dummy */
1801        unsigned filent;                       /* filter entry */
1802        char     singfilt[BC_FILELTH+1];       /* single filter name */
1803        char     filprefix[BC_FILELTH+1];      /* filter prefix on rec. filters */
1804
1805        /* executable code */
1806
1807        if  (GpGetInt(cGpI_debug_level) > 1)
1808                printf( "SHM-dbg2: mx_filter: different filters used\n" );
1809
1810#ifdef XXX
1811        filter_typ = (shv_global.use_rec_filters) ? 'R' : 'F';
1812        if  (shv_global.filter_type != ' ')  filter_typ = shv_global.filter_type;
1813#endif
1814        filter_typ = GpGetChar(cGpC_filter_type);
1815        filter_typ_save = filter_typ;
1816        simulation = (strchr(filter,'+') != NULL);
1817        if  (strlen(filter) > BC_FILELTH-2*MAX_S_LTH)  {
1818                *status = MXE_STROVFL;
1819                return;
1820        } /*endif*/
1821
1822        /* get index number of filter entry */
1823        db_ident( "FILTER", &filent, status );
1824        if  (SySevere(status))  return;
1825
1826        /* prepare traces */
1827        mx_exec_sh( w, ctrl, "shm_cmd_sepfil_begin" );
1828
1829        /* set newtrc to last trace in memory */
1830        newtrc = NULL;
1831        FOREVER  {
1832                tmp = db_getp( newtrc, EP_NEXT, NULL );
1833                if  (tmp == NULL)  break;
1834                newtrc = tmp;
1835        } /*endfor*/
1836        if  (newtrc == NULL)  {
1837                printf( "*SHM: mx_filter: no traces\n" );
1838                *status = MXE_PROG_BUG;
1839                return;
1840        } /*endif*/
1841        lasttrc = newtrc;
1842
1843        /* loop all traces on display */
1844        trcnum = 0;
1845        *last_name = '\0';
1846        trc = NULL;
1847        do  {
1848                filter_typ = filter_typ_save; /* in case it has been changed by FORCE_T */
1849                trcnum++;
1850                trcflags = 0;
1851                trc = db_getp( trc, EP_NEXT, NULL );
1852                if  (trc == NULL)  {
1853                        printf( "*SHM: mx_filter: this is impossible (10)\n" );
1854                        *status = MXE_PROG_BUG;
1855                        return;
1856                } /*endif*/
1857                if  (!ts_some_trace_selected() || ts_is_selected(trcnum))  {
1858                        *complete_name = '\0';
1859                        if  (filter_typ == 'R')  {
1860                                cl_filter_prefix( trc, MAX_S_LTH, complete_name );
1861                                strcpy( filprefix, complete_name );
1862                        } /*endif*/
1863                        if  (simulation)  {
1864                                /*db_gets( trc, ES_STATION, BC_SHORTSTRLTH, station, status );*/
1865                                /*if  (Severe(status))  return;*/
1866                                locstat = cBcNoError;
1867                                db_gett( trc, ET_START, &ttime, &locstat );
1868                                tc_a2t( &ttime, strtime, &locstat );
1869                                cu_get_stream_string( trc, station, NULL );
1870                                cu_lookup_filter( station, strtime, tfname, &trcflags, status );
1871                                if  (Severe(status))  return;
1872                                if  (trcflags & CUC_F_TRC_FORCE_F)  {
1873                                        strcpy( complete_name, tfname );
1874                                        filter_typ = 'F';
1875                                } else if  (trcflags & CUC_F_TRC_FORCE_T)  {
1876                                        strcpy( complete_name, tfname );
1877                                        filter_typ = 'T';
1878                                } else {
1879                                        strcat( complete_name, tfname );
1880                                } /*endif*/
1881                                strcat( complete_name, "_" );
1882                        } /*endif*/
1883                        strcat( complete_name, filter );
1884                        if  (ts_is_selected(trcnum))  {
1885                                /* take filter from dialog box into filter info entry */
1886                                if  (GpGetInt(cGpI_debug_level) > 3)
1887                                        printf( "shm-dbg4: set single filter %s on trace %d\n",
1888                                                filter, trcnum );
1889                                if  (filter_typ == 'R')  {
1890                                        strcpy( singfilt, filprefix );
1891                                        strcat( singfilt, filter );
1892                                } else {
1893                                        strcpy( singfilt, filter );
1894                                } /*endif*/
1895                                db_sets( trc, filent, singfilt, status );
1896                                if  (Severe(status))  return;
1897                        } else  {
1898                                locstat = cBcNoError;
1899                                db_gets( trc, filent, BC_FILELTH, singfilt, &locstat );
1900                                if  (locstat == cBcNoError && *singfilt != '\0')  {
1901                                        strcat( complete_name, ";" );
1902                                        strcat( complete_name, singfilt );
1903                                } /*endif*/
1904                        } /*endif*/
1905                        if  (strcmp(complete_name,last_name) != 0)  {
1906                                sprintf( cmd, "fili %c %s", filter_typ, complete_name );
1907                                callsh( cmd, &dmy, status );
1908                                if  (Severe(status))  {
1909                                        *status = BC_NOERROR;
1910                                        if  (GpGetInt(cGpI_debug_level) > 1)
1911                                                printf( "SHM-dbg2: filter, %s not available, use dummy filter\n",
1912                                                        complete_name );
1913                                        sprintf( cmd, "fili %c dummy", filter_typ );
1914                                        callsh( cmd, &dmy, status );
1915                                        if  (Severe(status))  return;
1916                                } /*endif*/
1917                                strcpy( last_name, complete_name );
1918                        } /*endif*/
1919                        sprintf( cmd, "filter %c a:%lx", filter_typ, trc );
1920                        callsh( cmd, &dmy, status );
1921                        if  (Severe(status))  return;
1922                        newtrc = db_getp( newtrc, EP_NEXT, NULL );
1923                        if  (newtrc == NULL)  {
1924                                *status = MXE_PROG_BUG;
1925                                printf( "*SHM: mx_filter: no trace created\n" );
1926                                return;
1927                        } /*endif*/
1928                        sprintf( cmd, "flt:%s", filter );
1929                        db_sets( newtrc, ES_COMMENT, cmd, status );
1930                        if  (Severe(status))  return;
1931                        db_setf( newtrc, MXC_EF_FILTER, TRUE, status );
1932                        if  (Severe(status))  return;
1933                } else {
1934                        sprintf( cmd, "copy a:%lx", trc );
1935                        callsh( cmd, &dmy, status );
1936                        if  (Severe(status))  return;
1937                        newtrc = db_getp( newtrc, EP_NEXT, NULL );
1938                        if  (newtrc == NULL)  {
1939                                *status = MXE_PROG_BUG;
1940                                printf( "*SHM: mx_filter: no trace created\n" );
1941                                return;
1942                        } /*endif*/
1943                        sprintf( cmd, "flt:NONE" );
1944                        db_sets( newtrc, ES_COMMENT, cmd, status );
1945                        if  (Severe(status))  return;
1946                        db_setf( newtrc, MXC_EF_FILTER, TRUE, status );
1947                        if  (Severe(status))  return;
1948                } /*endif*/
1949
1950                /* make trace red on alert flag */
1951                if  (CUC_F_TRC_ALERT & trcflags)
1952                        mg_make_alert_trace( w, newtrc, status );
1953
1954        }  while (trc != lasttrc);
1955
1956        /* cleanup */
1957        sprintf( cmd, "shm_cmd_sepfil_finish %s %f %d",
1958                filter, autocut, (GpGetInt(cGpI_trace_normalisation)==cGp_NORM_CONST) );
1959        mx_exec_sh( w, ctrl, cmd );
1960
1961        ts_clear_selections();
1962
1963} /* end of mxh_filter_separately */
1964
1965
1966#undef MAX_S_LTH
1967
1968
1969
1970/*----------------------------------------------------------------------------*/
1971
1972
1973#ifdef XXX
1974
1975#define GRFNUM 19
1976
1977
1978
1979static void mxh_get_vax_grflist( MX_CMD_READG *rg, char liststr[] )
1980
1981/* returns list string for readk command
1982 *
1983 * parameters of routine
1984 * MX_CMD_READG *rg;          input; read parameters
1985 * char       liststr[];      output; list string
1986 */
1987{
1988        /* local variables */
1989        long     statmap;         /* station map */
1990        int      compmap;         /* component map */
1991        int      idx[GRFNUM];     /* list of GRF numbers */
1992        int      cnt;             /* number of stations */
1993        int      i;               /* counter */
1994
1995        /* executable code */
1996
1997        if  (strcmp(rg->sl.code[0],"GRA1") != 0)  {
1998                strcpy( liststr, "NONE" );
1999                return;
2000        } /*endif*/
2001
2002        statmap = 0;
2003        compmap = rg->comp;
2004
2005        /* make own station map */
2006        for  (i=0; i<MXC_STATLIST_LTH; i++)  {
2007                if  ((1<<i) & rg->stations)  {
2008                        if  (strncmp(rg->sl.code[i],"GR",2) != 0)  continue;
2009                        if  (strcmp(rg->sl.code[i],"GRA1") == 0)     statmap |= (1<<STC_GRA1);
2010                        else if (strcmp(rg->sl.code[i],"GRA2") == 0) statmap |= (1<<STC_GRA2);
2011                        else if (strcmp(rg->sl.code[i],"GRA3") == 0) statmap |= (1<<STC_GRA3);
2012                        else if (strcmp(rg->sl.code[i],"GRA4") == 0) statmap |= (1<<STC_GRA4);
2013                        else if (strcmp(rg->sl.code[i],"GRB1") == 0) statmap |= (1<<STC_GRB1);
2014                        else if (strcmp(rg->sl.code[i],"GRB2") == 0) statmap |= (1<<STC_GRB2);
2015                        else if (strcmp(rg->sl.code[i],"GRB3") == 0) statmap |= (1<<STC_GRB3);
2016                        else if (strcmp(rg->sl.code[i],"GRB4") == 0) statmap |= (1<<STC_GRB4);
2017                        else if (strcmp(rg->sl.code[i],"GRB5") == 0) statmap |= (1<<STC_GRB5);
2018                        else if (strcmp(rg->sl.code[i],"GRC1") == 0) statmap |= (1<<STC_GRC1);
2019                        else if (strcmp(rg->sl.code[i],"GRC2") == 0) statmap |= (1<<STC_GRC2);
2020                        else if (strcmp(rg->sl.code[i],"GRC3") == 0) statmap |= (1<<STC_GRC3);
2021                        else if (strcmp(rg->sl.code[i],"GRC4") == 0) statmap |= (1<<STC_GRC4);
2022                } /*endif*/
2023        } /*endfor*/
2024
2025        /* create list of GRF numbers */
2026        cnt = 0;
2027        if  ((1<<STC_GRA1) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 1;
2028        if  ((1<<STC_GRA1) & statmap && (1<<STC_COMP_N) & compmap)  idx[cnt++] = 2;
2029        if  ((1<<STC_GRA1) & statmap && (1<<STC_COMP_E) & compmap)  idx[cnt++] = 3;
2030        if  ((1<<STC_GRA2) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 4;
2031        if  ((1<<STC_GRA3) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 5;
2032        if  ((1<<STC_GRA4) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 6;
2033        if  ((1<<STC_GRB1) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 7;
2034        if  ((1<<STC_GRB1) & statmap && (1<<STC_COMP_N) & compmap)  idx[cnt++] = 8;
2035        if  ((1<<STC_GRB1) & statmap && (1<<STC_COMP_E) & compmap)  idx[cnt++] = 9;
2036        if  ((1<<STC_GRB2) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 10;
2037        if  ((1<<STC_GRB3) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 11;
2038        if  ((1<<STC_GRB4) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 12;
2039        if  ((1<<STC_GRB5) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 13;
2040        if  ((1<<STC_GRC1) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 14;
2041        if  ((1<<STC_GRC1) & statmap && (1<<STC_COMP_N) & compmap)  idx[cnt++] = 15;
2042        if  ((1<<STC_GRC1) & statmap && (1<<STC_COMP_E) & compmap)  idx[cnt++] = 16;
2043        if  ((1<<STC_GRC2) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 17;
2044        if  ((1<<STC_GRC3) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 18;
2045        if  ((1<<STC_GRC4) & statmap && (1<<STC_COMP_Z) & compmap)  idx[cnt++] = 19;
2046
2047        /* put this list into a string */
2048        if  (cnt == 0)  { strcpy( liststr, "NONE" ); return; }
2049        sprintf( liststr, "%d", idx[0] );
2050        for  (i=1; i<cnt; i++)
2051                sprintf( liststr+strlen(liststr), ",%d", idx[i] );
2052
2053} /* end of mxh_get_vax_grflist */
2054
2055#endif
2056
2057/*----------------------------------------------------------------------------*/
2058
2059
2060
2061static void mxh_mount_cdrom( MX_CMD_READG *par, STATUS *status )
2062
2063/* mounts cdrom for reading
2064 *
2065 * parameters of routine
2066 * MX_CMD_READG        *par;    input/modify; read command parameters
2067 * STATUS              *status; output; return status
2068 */
2069{
2070        /* local variables */
2071        int         i;                        /* counter */
2072        char        stream[BC_LINELTH+1];     /* stream string */
2073        char        cmdline[BC_LONGSTRLTH+1]; /* command line */
2074        char        *env;                     /* pointer to environment */
2075        TSyBoolean  redraw;                   /* not used */
2076        TSyStatus   locstat;                  /* not used */
2077        TSyBoolean  is_sol2;                  /* is Solaris 2 machine */
2078
2079        /* executable code */
2080
2081        if  (par->channum == 0)  {
2082                *status = MXE_NOCHANNELS;
2083                return;
2084        } else if  (par->channum > 1)  {
2085                printf( "*SHM: take only first channel selected\n" );
2086        } /*endif*/
2087
2088        /* find first station in list */
2089        for  (i=0; i<MXC_STATLIST_LTH; i++)
2090                if  ((1<<i) & par->stations)  break;
2091
2092        /* if no station selected return */
2093        if  (i == MXC_STATLIST_LTH)  {
2094                *status = MXE_NOSTATIONS;
2095                return;
2096        } /*endif*/
2097
2098        /* build stream name from first station */
2099        strcpy( stream, par->sl.code[i] );
2100        strcat( stream, "-" );
2101        strcat( stream, par->chanstr[0] );
2102        strcat( stream, "-z" );
2103        ut_uncap( stream );
2104
2105        is_sol2 = cl_is_solaris_2();
2106
2107        /* close SEED files */
2108        locstat = BC_NOERROR;
2109        callsh( "reads/close", &redraw, &locstat );
2110
2111        /* build and execute command line */
2112        if  (is_sol2)  {
2113                /* *cmdline = '\0'; */
2114                strcpy( cmdline, "cmdtool " );
2115        } else {
2116                strcpy( cmdline, "cmdtool " );
2117        } /*endif*/
2118        env = getenv( "SEED_PROG" );
2119        if  (env != NULL)  {
2120                strcat( cmdline, env );
2121                strcat( cmdline, "/" );
2122        } /*endif*/
2123        sprintf( cmdline+strlen(cmdline), "szgrf_cd_mount.csh %s %s",
2124                stream, par->start );
2125        system( cmdline );
2126
2127        if  (is_sol2)  {
2128                strcpy( par->device, "/cdrom/cdrom0" );
2129        } else {
2130                strcpy( par->device, "/cdrom" );
2131        } /*endif*/
2132
2133} /* end of mxh_mount_cdrom */
2134
2135
2136
2137/*----------------------------------------------------------------------------*/
2138
2139
2140
2141static void mxh_set_entry_name( Widget ew, char text[] )
2142
2143/* Sets menu entry text
2144 *
2145 * parameters of routine
2146 * Widget     ew;          input; menu entry widget
2147 * char       text[];      input; new text for widget
2148 */
2149{
2150        /* local variables */
2151        char     ltext[cBcLineLth+1]; /* local copy of text to remove '_' */
2152        Arg      args[2];             /* argument list */
2153        int      n;                   /* argument counter */
2154        XmString xmstr;               /* Xm string */
2155
2156        /* executable code */
2157
2158        if  (strlen(text) >= cBcLineLth)  {
2159                fprintf( stderr, "*SHM: mxh_set_entry_name: name too long\n" );
2160                return;
2161        } /*endif*/
2162        strcpy( ltext, text );
2163        for  (n=0; n<strlen(ltext); n++)
2164                if  (ltext[n] == '_')  ltext[n] = ' ';
2165
2166        xmstr = XmStringCreateLtoR( ltext, "" );
2167        n = 0;
2168        XtSetArg( args[n], XmNlabelString, xmstr ); n++;
2169        XtSetValues( ew, args, n );
2170
2171} /* end of mxh_set_entry_name */
2172
2173
2174
2175/*----------------------------------------------------------------------------*/
2176
2177
2178
2179void mx_remove_double_elements( char str[] )
2180
2181/* removes double elements from comma separated list
2182 *
2183 * parameters of routine
2184 * char       str[]; modify; list
2185 */
2186{
2187        /* local variables */
2188        TGpTextList tl;       /* text list */
2189        int      i, j;        /* counters */
2190
2191        /* executable code */
2192
2193        GpParseTextList( str, &tl );
2194
2195        for  (i=0; i<tl.numelem; i++)
2196                for  (j=(i+1); j<tl.numelem; j++)
2197                        if  (strcmp(tl.elem[i],tl.elem[j]) == 0)
2198                                tl.elem[j][0] = '\0';
2199
2200        strcpy( str, tl.elem[0] );
2201        for  (i=1; i<tl.numelem; i++)  {
2202                if  (tl.elem[i][0] != '\0')  {
2203                        strcat( str, "," );
2204                        strcat( str, tl.elem[i] );
2205                } /*endif*/
2206        } /*endfor*/
2207
2208        GpFreeTextList( &tl );
2209
2210} /* end of mx_remove_double_elements */
2211
2212
2213
2214/*----------------------------------------------------------------------------*/
2215
2216
2217
2218void mxh_compute_azimuth( char station[], float lat, float lon,
2219        float *azim, TSyStatus *status )
2220
2221/* Computes azimuth from station and epicentre location
2222 *
2223 * parameters of routine
2224 * char       cstation[];  input; name of station
2225 * float      lat, lon;    input; epicentre location
2226 * float      *azim;       output; azimuth computed
2227 * TSyStatus  *status;     output; return status
2228 */
2229{
2230        /* local variables */
2231        GLT_STATINF *statinf;    /* station info */
2232        double      d_dist, d_azim, d_bazim;
2233
2234        /* executable code */
2235
2236        statinf = gl_store_station( station, TRUE, status );
2237        if  (Severe(status))  return;
2238        mb_locdiff( statinf->lat, statinf->lon, lat, lon,
2239                &d_dist, &d_azim, &d_bazim );
2240        *azim = d_bazim;
2241
2242} /* end of mxh_compute_azimuth */
2243
2244
2245
2246/*----------------------------------------------------------------------------*/
2247
2248
2249static void mxh_read_stations_from_evt( char autoevt[], char addlist[] )
2250
2251/* Reads station list from evtfile
2252 *
2253 * parameters of routine
2254 * char       autoevt[];      input: name of evt file
2255 * char       addlist[];      output; list of station names
2256 */
2257{
2258        /* local variables */
2259        FILE       *fp;                          /* pointer to file */
2260        char       tmpfile[cBcFileLth+1];        /* temporary file */
2261        static int fcnt=1;                       /* temp file counter */
2262        char       shellcmd[cBcLongStrLth+1];    /* shell command */
2263        char       line[cBcLineLth+1];           /* current line in file */
2264        int        i;                            /* counter */
2265
2266        /* executable code */
2267
2268        *addlist = '\0';
2269        sprintf( tmpfile, "/tmp/ae_stations_%d.000", fcnt++ );
2270        sprintf( shellcmd,
2271                "grep 'Station code           :' %s | awk '{print $4}' | sort -u >%s",
2272                autoevt, tmpfile );
2273        printf( "executing: %s\n", shellcmd );
2274        system( shellcmd );
2275        fp = fopen( tmpfile, "r" );
2276        while  (fgets(line,cBcLineLth,fp) != NULL)  {
2277                i = strlen( line );
2278                if  (line[i-1] == '\n')  line[i-1] = '\0';
2279                if  (strlen(addlist) > cBcLongStrLth-2)  {
2280                        fclose( fp );
2281                        printf( "*SHM: evt station list truncated\n" );
2282                        return;
2283                } /*endif*/
2284                if  (*addlist != '\0')  strcat( addlist, "," );
2285                strcat( addlist, line );
2286        } /*endwhile*/
2287        fclose( fp );
2288}
2289
2290
2291/*----------------------------------------------------------------------------*/
2292
2293
2294
2295static void mxh_read_location_from_evt( char autoevt[], float *lat, float *lon,
2296        TSyBoolean *found )
2297
2298/* Reads latitude and longitude from evt file
2299 *
2300 * parameters of routine
2301 * char       autoevt[]; input; name of evt file
2302 * float      *lat, *lon; output; location read from above file
2303 * TSyBoolean *found; output; TRUE if location is found
2304 */
2305{
2306        /* local variables */
2307        FILE     *fp;                  /* pointer to file */
2308        char     line[cBcLineLth+1];   /* current line of file */
2309        TSyBoolean latfound, lonfound; /* latitude and longitude found */
2310        int      i;                    /* counter */
2311
2312        /* executable code */
2313
2314        /* open evt file */
2315        *found = TRUE;
2316        fp = fopen( autoevt, "r" );
2317        if  (fp == NULL)  {
2318                *found = FALSE;
2319                return;
2320        } /*endif*/
2321
2322        /* read through file */
2323        latfound = lonfound = FALSE;
2324        while (fgets(line,cBcLineLth,fp) != NULL)  {
2325                if  (strncmp(line,"Latitude ",9) == 0)  {
2326                        i = 9;  /* length of Latitude string */
2327                        while (line[i] == ' ' || line[i] == ':')
2328                                i++;
2329                        if  (sscanf(line+i,"%f",lat) == 1)
2330                                latfound = TRUE;
2331                } /*endif*/
2332                if  (strncmp(line,"Longitude ",10) == 0)  {
2333                        i = 10;  /* length of Latitude string */
2334                        while (line[i] == ' ' || line[i] == ':')
2335                                i++;
2336                        if  (sscanf(line+i,"%f",lon) == 1)
2337                                lonfound = TRUE;
2338                } /*endif*/
2339                if  (latfound && lonfound)
2340                        break;
2341        } /*endwhile*/
2342
2343        if  (!latfound || !lonfound)  {
2344                *found = FALSE;
2345                return;
2346        } /*endif*/
2347
2348        fclose( fp );
2349
2350} /* end of mxh_read_location_from_evt */
2351
2352
2353
2354/*----------------------------------------------------------------------------*/
Note: See TracBrowser for help on using the repository browser.