← Back to branch summary

~maddevelopers/mg5amcnlo/2.9.4

« back to all changes in this revision

Viewing changes to vendor/StdHEP/mcfio/src/mcf_BrowseUtil1.c

pass to v2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/StdHEP/mcfio/src/mcf_BrowseUtil1.c
 
1
/*******************************************************************************
 
2
*                                                                              *
 
3
* mcf_BrowseUtil1.c -- Utilities and auxillary Panels for NTuple Browser.      *
 
4
*                                                                              *
 
5
* Copyright (c) 1995, 1996 Universities Research Association, Inc.             *
 
6
* All rights reserved.                                                         *
 
7
*                                                                              *
 
8
*******************************************************************************/
 
9
#include <stdio.h>
 
10
#include <stdlib.h>
 
11
#include <sys/param.h>
 
12
#include <rpc/types.h>
 
13
#include <sys/types.h>
 
14
#include <rpc/xdr.h>
 
15
#include <ctype.h>
 
16
#include <limits.h>
 
17
#include <X11/Intrinsic.h>
 
18
#include <X11/Shell.h>
 
19
#include <Xm/Xm.h>
 
20
#include <Xm/DialogS.h>
 
21
#include <Xm/SelectioB.h>
 
22
#include <Xm/RowColumn.h>
 
23
#include <Xm/ToggleB.h>
 
24
#include <Xm/Form.h>
 
25
#include <Xm/Label.h>
 
26
#include <Xm/LabelG.h>
 
27
#include <Xm/PushB.h>
 
28
#include <Xm/PushBG.h>
 
29
#include <Xm/Text.h>
 
30
#include "DialogF.h"
 
31
#include "getfiles.h"
 
32
#include "misc.h"
 
33
#include "mcf_nTupleDescript.h"
 
34
#include "mcf_xdr.h"
 
35
#include "mcfio_Dict.h"
 
36
#include "mcfio_Util1.h"
 
37
#include "mcfio_Direct.h"
 
38
#include "mcf_nTupleBuild.h"
 
39
#include "mcf_NTuIOUtils.h"
 
40
#include "mcf_BrowseUtil1.h"
 
41
#include "mcf_BrowseMainPanel.h"
 
42
#ifdef HISTO
 
43
#include "histoscope.h"
 
44
#endif
 
45
extern nTuDDL **NTuDDLList;
 
46
extern int NumOfNTuples;
 
47
 
 
48
#define SIZEOFLIST_BROWSERANAL 20
 
49
 
 
50
nTuBrowserInfo **NTupleBrowserList = NULL;
 
51
 
 
52
static void createBrowserDataDump(nTuBrowserInfo * nTuBr);
 
53
static void dismissDataDumpCB(Widget w, nTuBrowserInfo * nTuBr,
 
54
                               caddr_t call_data);
 
55
static void printValuesBrief(char *cDat, int type,
 
56
                             int n_instance, char **text);
 
57
                             
 
58
static void printValuesFull(char *cDat, varGenNtuple *var, char **text);
 
59
 
 
60
static void briefCB(Widget w, nTuBrowserInfo * nTuBr ,
 
61
                             XmToggleButtonCallbackStruct *callData);
 
62
 
 
63
static void modifiedFromDataCB(Widget w,  
 
64
                               nTuBrowserInfo * nTuBr, caddr_t call_data);
 
65
                               
 
66
static void modifiedToDataCB(Widget w,  
 
67
                               nTuBrowserInfo * nTuBr, caddr_t call_data);
 
68
 
 
69
/*
 
70
** Create a list of little Data structure for place holder of analysis 
 
71
** information.
 
72
*/
 
73
void mcfioC_CreateBrowserAnalysis()
 
74
{
 
75
   int i,j;
 
76
     if (NumOfNTuples < 1 ) return;
 
77
     NTupleBrowserList =  
 
78
        (nTuBrowserInfo **) malloc(sizeof(nTuBrowserInfo *) * NumOfNTuples);
 
79
     for (i=0; i<NumOfNTuples; i++) {
 
80
        NTupleBrowserList[i] = 
 
81
           (nTuBrowserInfo *) malloc(sizeof(nTuBrowserInfo));
 
82
        NTupleBrowserList[i]->id = i+1;   
 
83
        NTupleBrowserList[i]->templateW = NULL;
 
84
        NTupleBrowserList[i]->dumpDataW = NULL; 
 
85
        NTupleBrowserList[i]->dumpDataFormW = NULL; 
 
86
        NTupleBrowserList[i]->dumpDataShellW = NULL; 
 
87
        NTupleBrowserList[i]->nHistoItems = 0;
 
88
        NTupleBrowserList[i]->nHisto1D = 0;
 
89
        NTupleBrowserList[i]->nHisto2D = 0;
 
90
        NTupleBrowserList[i]->nHistoNtuples = 0;
 
91
        NTupleBrowserList[i]->sizeOfLists = SIZEOFLIST_BROWSERANAL;
 
92
        NTupleBrowserList[i]->hsItemList =
 
93
             (nTuBroHsGeneral **) malloc(sizeof(nTuBroHsGeneral *) 
 
94
                                              * SIZEOFLIST_BROWSERANAL);
 
95
        for (j=0; j<SIZEOFLIST_BROWSERANAL; j++)
 
96
             NTupleBrowserList[i]->hsItemList[j] = NULL;
 
97
        NTupleBrowserList[i]->currentData = False;    
 
98
        NTupleBrowserList[i]->data = NULL;    
 
99
     }
 
100
}
 
101
 
 
102
void mcfioC_DestroyBrowserAnalysis()
 
103
{
 
104
     int i,j;
 
105
     nTuBroHsGeneral *hsG;
 
106
     nTuBroHs1D *h1;
 
107
     nTuBroHs2D *h2;
 
108
     
 
109
     if (NTupleBrowserList == NULL) return;
 
110
     for (i=0; i<NumOfNTuples; i++) {
 
111
       if (NTupleBrowserList[i]->templateW != NULL) 
 
112
           if (CloseNTuBuildWindow(NTupleBrowserList[i]->templateW) ==
 
113
           GFN_CANCEL) return; 
 
114
       if (NTupleBrowserList[i]->dumpDataW != NULL) 
 
115
            XtDestroyWidget(NTupleBrowserList[i]->dumpDataW);
 
116
       for (j=0; j<NTupleBrowserList[i]->sizeOfLists; j++) {
 
117
          hsG = NTupleBrowserList[i]->hsItemList[j]; 
 
118
          if (hsG != NULL) {
 
119
#ifdef HISTO          
 
120
             if(hsG->id >0) hs_delete(hsG->id); 
 
121
             switch (hsG->type) {
 
122
               case HS_1D_HISTOGRAM:
 
123
                  h1 = (nTuBroHs1D *) hsG;
 
124
                  if (h1->varIndices != NULL) free (h1->varIndices);
 
125
                  free(h1);
 
126
                  break;
 
127
             case  HS_2D_HISTOGRAM:
 
128
                h2 = (nTuBroHs2D *) hsG;
 
129
                if (h2->xVarIndices != NULL) free (h2->xVarIndices);
 
130
                if (h2->yVarIndices != NULL) free (h2->yVarIndices);
 
131
                free(h2);
 
132
                break;
 
133
             default : 
 
134
                printf(" McfioC_DestroyBrowserAnalysis : internal Error\n");
 
135
                break;
 
136
           }
 
137
#endif            
 
138
           free (hsG); NTupleBrowserList[i]->hsItemList[j] = NULL;
 
139
         }
 
140
       }
 
141
       if (NTupleBrowserList[i]->data != NULL)
 
142
           free(NTupleBrowserList[i]->data);
 
143
       free(NTupleBrowserList[i]);
 
144
     }
 
145
     free(NTupleBrowserList);
 
146
     NTupleBrowserList = NULL;
 
147
}
 
148
void mcfioC_createBrowserData(nTuBrowserInfo *nTuBr)
 
149
{
 
150
    int nBytes, lastFixed, i;
 
151
    nTuDDL *ddl;
 
152
    descrGenNtuple *dNTu;
 
153
     
 
154
    if (nTuBr == NULL) return;
 
155
    if (nTuBr->data != NULL) free(nTuBr->data);
 
156
     ddl = mcf_GetNTuByPtrID(nTuBr->id);
 
157
     if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
158
            else dNTu = ddl->descrNtu;
 
159
     /*
 
160
     ** 24 = 8 char. for version +  the mulplicity variable +  Padding + 
 
161
     **       fence (2 short words = 1 long)
 
162
     */
 
163
     nBytes = 8*sizeof(char) + 4 * sizeof(int);
 
164
     if(dNTu->firstIndexed == -1) lastFixed = dNTu->numVariables;
 
165
        else lastFixed = dNTu->firstIndexed;
 
166
     for (i=0; i<lastFixed; i++) 
 
167
        if (dNTu->variables[i]->lengthW != 0) 
 
168
              nBytes += dNTu->variables[i]->lengthB;
 
169
     if (dNTu->firstIndexed != -1) {
 
170
       for (i=dNTu->firstIndexed; i<dNTu->numVariables; i++) 
 
171
        if (dNTu->variables[i]->lengthW != 0)
 
172
             nBytes += (dNTu->maxMultiplicity * dNTu->variables[i] ->lengthB);
 
173
     }
 
174
     nTuBr->data = (void *) malloc(nBytes);       
 
175
}            
 
176
           
 
177
     
 
178
void mcfioC_ExtendBrowserAnalysis(nTuBrowserInfo * nTuBr)
 
179
{
 
180
     int j, nnew, ivar, nn, i;
 
181
     int *il, **ill;
 
182
     nTuDDL *ddl;
 
183
     descrGenNtuple *dNTu;
 
184
     nTuBroHsGeneral **hsGList;
 
185
     
 
186
     if (nTuBr == NULL) return;
 
187
     ddl = mcf_GetNTuByPtrID(nTuBr->id);
 
188
     if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
189
            else dNTu = ddl->descrNtu;
 
190
     nnew = nTuBr->sizeOfLists + SIZEOFLIST_BROWSERANAL;
 
191
     hsGList =
 
192
             (nTuBroHsGeneral **) malloc(sizeof(nTuBroHsGeneral *) 
 
193
                                              * nnew);
 
194
     for (i=0; i<nnew; i++) hsGList[i] = NULL;
 
195
     memcpy((void *) il, (void *) nTuBr->hsItemList,
 
196
               (sizeof(nTuBroHsGeneral *) * nTuBr->nHistoItems));
 
197
     nTuBr->sizeOfLists = nnew;
 
198
     free(nTuBr->hsItemList);
 
199
     nTuBr->hsItemList = hsGList; 
 
200
}              
 
201
void mcfioC_ShowBrowserDataDump(nTuBrowserInfo * nTuBr) {
 
202
 
 
203
   char *text, *t1, *t2;
 
204
   int i, j, in, nChar, len, nMult, n, lastFixed, n1, n2;
 
205
   int iFrom, iTo;
 
206
   char *cDat;
 
207
   char titleW[NTU_MAX_TITLE_LENGTH+15];
 
208
   char version[8];
 
209
    nTuDDL *ddl;
 
210
    descrGenNtuple *dNTu;
 
211
   varGenNtuple *var;
 
212
 
 
213
   if (nTuBr->data == NULL ) {
 
214
      mcfioC_createBrowserData(nTuBr);
 
215
      nTuBr->currentData = False;
 
216
   }   
 
217
   if (nTuBr->currentData == False) {
 
218
      for(i=0, n1=-1; i<NumOfNTuples; i++) 
 
219
        if(NTupleBrowserList[i] == nTuBr) n1 = i;
 
220
      if (n1 == -1) {
 
221
        DialogF(DF_WARN, McfioMainPanelW, 1,
 
222
       "Internal error in ShowBrowserDataDump\nPlease report.",
 
223
       "Acknowledged");
 
224
         return;
 
225
      }   
 
226
      if (mcfioC_NTuple(1, (n1+1), 
 
227
                      (char *) nTuBr->data) == False) {
 
228
       DialogF(DF_WARN, McfioMainPanelW, 1,
 
229
    "No data for this event!.\nPlease choose other Ntuple or skip this event",
 
230
       "Acknowledged");
 
231
       return;
 
232
      }
 
233
      nTuBr->currentData = True;
 
234
   }
 
235
   if (nTuBr->dumpDataShellW == NULL) createBrowserDataDump(nTuBr);
 
236
   ddl = mcf_GetNTuByPtrID(nTuBr->id);
 
237
   sprintf(titleW,"Data for %s",ddl->title); 
 
238
   XtVaSetValues(nTuBr->dumpDataShellW, XmNtitle, titleW, 0);
 
239
   if (nTuBr->currentData == False) {
 
240
       XmTextSetString(nTuBr->dumpDataW,
 
241
    "Undecoded Data, Press View Data again to decode the requested buffer ");
 
242
       XtManageChild(nTuBr->dumpDataFormW);
 
243
       return;
 
244
   }
 
245
   if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
246
            else dNTu = ddl->descrNtu;
 
247
   if(dNTu->firstIndexed == -1) lastFixed = dNTu->numVariables;
 
248
           else lastFixed = dNTu->firstIndexed;
 
249
   cDat = (char *) nTuBr->data;
 
250
   strncpy(version, cDat, 8);  cDat += dNTu->multOffset; 
 
251
   /*
 
252
   ** set the text widget From, To, to go for a specific track  
 
253
   ** or substructures
 
254
   */
 
255
   nMult = *((int *) cDat);
 
256
   iFrom = nTuBr->dumpFrom;
 
257
   if (iFrom > nMult) iFrom = nMult;
 
258
   iFrom--;
 
259
   iTo = nTuBr->dumpTo;
 
260
   if (iTo > nMult) iTo = nMult;
 
261
   /*
 
262
   ** Estimate of the amount of text we have to generate 
 
263
   */
 
264
   if (XmToggleButtonGetState(nTuBr->dumpDataBriefW)) {
 
265
      /*
 
266
      ** Assume 160 char. max. per line 
 
267
      */
 
268
      n2 =  dNTu->numVariables - lastFixed; 
 
269
      text = (char *) malloc(sizeof(char ) * (160*(7 + lastFixed + n2*nMult)));
 
270
   } else {
 
271
      /*
 
272
      ** Assume 32 characters maximum per printed values
 
273
      */
 
274
      if (lastFixed != 0) { 
 
275
          for (i=0, n1=0; i<lastFixed; i++) {
 
276
            var = dNTu->variables[i]; n = 1;
 
277
            for (j=0; j<var->numDim; j++) n = n * var->dimensions[j];
 
278
            n1 += n*32; n1 += 80*var->numDim;  
 
279
          }
 
280
       } else n1 = 0;
 
281
       if (dNTu->firstIndexed != -1) {
 
282
           for (i=dNTu->firstIndexed, n2=0; i<dNTu->numVariables; i++) {
 
283
              var = dNTu->variables[i]; n = 1;
 
284
              for (j=0; j<var->numDim; j++) n = n * var->dimensions[j];
 
285
              n2 += n*32;  n2 += 80*var->numDim;  
 
286
           }
 
287
       } else n2 = 0;   
 
288
       text = (char *) malloc(sizeof(char ) * (1120 + n1 + nMult*n2));
 
289
    }   
 
290
   t1 = text;
 
291
   sprintf(t1,
 
292
             " Version for this Data block instance : %s \n%n", version, &len);
 
293
   t1 += len;
 
294
   if (dNTu->firstIndexed != -1 ) {
 
295
          sprintf(t1, " Multiplicity, %s = %d \n%n", dNTu->nameIndex, nMult,
 
296
          &len); t1+=len;
 
297
   }
 
298
   sprintf(t1, "               -----------------------------\n%n",&len); 
 
299
   t1+=len;
 
300
   if (lastFixed != 0) { 
 
301
       sprintf(t1, " Fixed size part of the block\n\n%n", &len);
 
302
       t1 += len;
 
303
       for (i=0; i<lastFixed; i++) {
 
304
            var = dNTu->variables[i]; n = 1;
 
305
            for (j=0; j<var->numDim; j++) n = n * var->dimensions[j];
 
306
            sprintf (t1, "%s = %n", var->name, &len ); t1 +=len;
 
307
            cDat = (char *) nTuBr->data;
 
308
            cDat += dNTu->variables[i]->offset;
 
309
            if (XmToggleButtonGetState(nTuBr->dumpDataBriefW)) 
 
310
                       printValuesBrief(cDat, var->type, n, &t1);
 
311
            else   printValuesFull(cDat, var, &t1);         
 
312
        } 
 
313
    }
 
314
    sprintf(t1,
 
315
      " ---- End of fixed size part --------------------------------- \n%n",
 
316
        &len);  t1 += len;
 
317
    if (iFrom == -1) { 
 
318
       sprintf(t1,
 
319
      " ---- Multiplicity 0, end of Dump -------- -------------------- \n%n",
 
320
        &len);  t1 += len;
 
321
    } else { 
 
322
    if ((dNTu->firstIndexed != -1) && 
 
323
         (dNTu->orgStyle == PARALLEL_ARRAY_NTU)) {
 
324
            sprintf(t1,
 
325
     " Variable size, organisation is of type parallel arrays \n\n%n", &len); 
 
326
            t1 += len;
 
327
            for (i=dNTu->firstIndexed; i<dNTu->numVariables; i++) {
 
328
              var = dNTu->variables[i]; n = 1;
 
329
              for (j=0; j<var->numDim; j++) n = n * var->dimensions[j];
 
330
              sprintf (t1, "%s :  \n%n", var->name, &len ); t1 +=len;
 
331
              cDat = (char *) nTuBr->data;
 
332
              cDat += var->offset;
 
333
              for (in = iFrom; in< iTo; in++) {
 
334
                 sprintf(t1, "  Index_%s = %d -> %n",dNTu->nameIndex, in, &len);
 
335
                 t1 += len;
 
336
                 if (XmToggleButtonGetState(nTuBr->dumpDataBriefW)) 
 
337
                       printValuesBrief(cDat, var->type, n, &t1);
 
338
                 else  printValuesFull(cDat, var, &t1);         
 
339
                 cDat += var->lengthB;
 
340
             } 
 
341
         }
 
342
     } else if  ((dNTu->firstIndexed != -1) && 
 
343
         (dNTu->orgStyle != PARALLEL_ARRAY_NTU)) {
 
344
            sprintf(t1,
 
345
     " Variable size, organisation is of type substructures \n%n", &len); 
 
346
            t1 += len;
 
347
            for (in = iFrom; in< iTo; in++) {
 
348
              sprintf(t1, "Index_%s = %d : \n%n",dNTu->nameIndex, (in+1), &len);
 
349
              t1 += len;
 
350
              for (i=dNTu->firstIndexed; i<dNTu->numVariables; i++) {
 
351
                var = dNTu->variables[i]; n = 1;
 
352
                for (j=0; j<var->numDim; j++) n = n * var->dimensions[j];
 
353
                cDat = (char *) nTuBr->data;
 
354
                cDat += ( var->offset + dNTu->subOffset[in]);
 
355
                sprintf (t1, "    %s = %n", var->name, &len ); t1 +=len;
 
356
                 if (XmToggleButtonGetState(nTuBr->dumpDataBriefW)) 
 
357
                       printValuesBrief(cDat, var->type, n, &t1);
 
358
                 else   printValuesFull(cDat, var, &t1);         
 
359
              }
 
360
         }
 
361
     }         
 
362
   }    
 
363
   XmTextSetString(nTuBr->dumpDataW,text);
 
364
   XtManageChild(nTuBr->dumpDataFormW);
 
365
   free(text);
 
366
       
 
367
   
 
368
}
 
369
 
 
370
static void createBrowserDataDump(nTuBrowserInfo * nTuBr)
 
371
{
 
372
    Arg args[50];
 
373
    int ac, nMult;
 
374
    Widget form, dismissBtn, fullBtn, radioBox, labelFromW, labelToW;
 
375
    char *cDat;
 
376
    nTuDDL *ddl;
 
377
    descrGenNtuple *dNTu;
 
378
   varGenNtuple *var;
 
379
    XmString s1;
 
380
 
 
381
   ddl = mcf_GetNTuByPtrID(nTuBr->id);
 
382
   if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
383
            else dNTu = ddl->descrNtu;
 
384
    ac = 0;
 
385
    XtSetArg(args[ac], XmNautoUnmanage, False); ac++; 
 
386
    XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++; 
 
387
    form = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
 
388
    nTuBr->dumpDataShellW = XtParent(form);
 
389
    nTuBr->dumpDataFormW = form;
 
390
    XtVaSetValues(nTuBr->dumpDataShellW, XmNtitle,
 
391
                                "Data Dump of an Ntuple", 0);
 
392
    AddMotifCloseCallback(XtParent(form),
 
393
                         (XtCallbackProc)dismissDataDumpCB, nTuBr);
 
394
                         
 
395
                         
 
396
    dismissBtn = XtVaCreateManagedWidget("dismissBtn",
 
397
            xmPushButtonGadgetClass, form,
 
398
            XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
 
399
            XmNbottomAttachment, XmATTACH_FORM,
 
400
            XmNbottomOffset, 4,
 
401
            XmNleftAttachment, XmATTACH_POSITION,
 
402
            XmNleftPosition, 70,
 
403
            XmNrightAttachment, XmATTACH_POSITION,
 
404
            XmNrightPosition, 90, 0);
 
405
    XmStringFree(s1);
 
406
    XtAddCallback(dismissBtn, XmNactivateCallback,
 
407
            (XtCallbackProc)dismissDataDumpCB, (void *)nTuBr); 
 
408
    
 
409
    radioBox = XtVaCreateManagedWidget("radioBox",
 
410
                    xmRowColumnWidgetClass, form,
 
411
                    XmNradioBehavior, True,
 
412
                    XmNradioAlwaysOne, True,
 
413
                    XmNorientation, XmHORIZONTAL,
 
414
                    XmNleftAttachment, XmATTACH_FORM,
 
415
                    XmNbottomAttachment, XmATTACH_FORM, 0);
 
416
 
 
417
     nTuBr->dumpDataBriefW = 
 
418
          XtVaCreateManagedWidget("radioA",xmToggleButtonWidgetClass,
 
419
                    radioBox, 
 
420
                    XmNset, True,
 
421
                    XmNlabelString,s1=XmStringCreateSimple("Brief"),0);
 
422
    XmStringFree(s1);
 
423
    XtAddCallback( nTuBr->dumpDataBriefW, XmNvalueChangedCallback,
 
424
                    (XtCallbackProc)briefCB, (caddr_t) nTuBr);
 
425
            
 
426
    fullBtn = 
 
427
          XtVaCreateManagedWidget("radioB",xmToggleButtonWidgetClass,
 
428
                    radioBox, 
 
429
                    XmNset, False,
 
430
                    XmNlabelString,s1=XmStringCreateSimple("Full"),0);
 
431
    XmStringFree(s1);
 
432
    XtAddCallback(fullBtn, XmNvalueChangedCallback,
 
433
                    (XtCallbackProc)briefCB, (caddr_t) nTuBr);
 
434
    ac = 0;
 
435
    XtSetArg(args[ac], XmNlabelString, 
 
436
     (s1=XmStringCreateSimple("Index Range, From:"))); ac++;
 
437
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
438
    XtSetArg(args[ac], XmNleftOffset,5); ac++;
 
439
    XtSetArg(args[ac], XmNleftWidget, radioBox); ac++;
 
440
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
 
441
    labelFromW = 
 
442
       XmCreateLabelGadget(form, "indexRangeFrom", args,ac);
 
443
    XmStringFree(s1);
 
444
    XtManageChild(labelFromW);
 
445
    
 
446
    nTuBr->fromDataTextW  = XtVaCreateManagedWidget("fromDataText",
 
447
            xmTextWidgetClass, form,
 
448
            XmNcolumns, 5,
 
449
            XmNmaxLength, 5,
 
450
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
451
            XmNbottomAttachment, XmATTACH_FORM,
 
452
            XmNleftAttachment, XmATTACH_WIDGET,
 
453
            XmNleftWidget,labelFromW, 0);
 
454
    RemapDeleteKey(nTuBr->fromDataTextW );
 
455
    XmTextSetString(nTuBr->fromDataTextW, "1");
 
456
    nTuBr->dumpFrom = 1;
 
457
    XtAddCallback(nTuBr->fromDataTextW, XmNvalueChangedCallback,
 
458
            (XtCallbackProc)modifiedFromDataCB, (void *) nTuBr);
 
459
    
 
460
    ac = 0;
 
461
    XtSetArg(args[ac], XmNlabelString, 
 
462
     (s1=XmStringCreateSimple("To:"))); ac++;
 
463
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
464
    XtSetArg(args[ac], XmNleftOffset,1); ac++;
 
465
    XtSetArg(args[ac], XmNleftWidget, nTuBr->fromDataTextW ); ac++;
 
466
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
 
467
    labelToW = 
 
468
       XmCreateLabelGadget(form, "indexRaneTo", args,ac);
 
469
    XmStringFree(s1);
 
470
    XtManageChild(labelToW);
 
471
    
 
472
    nTuBr->toDataTextW  = XtVaCreateManagedWidget("toDataText",
 
473
            xmTextWidgetClass, form,
 
474
            XmNcolumns, 5,
 
475
            XmNmaxLength, 5,
 
476
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
477
            XmNbottomAttachment, XmATTACH_FORM,
 
478
            XmNleftAttachment, XmATTACH_WIDGET,
 
479
            XmNleftWidget,labelToW, 0);
 
480
    RemapDeleteKey(nTuBr->toDataTextW );
 
481
    cDat = (char *) nTuBr->data;
 
482
    cDat +=dNTu->multOffset; 
 
483
    nMult = *((int*) cDat);
 
484
    if (nMult > 3) {
 
485
      XmTextSetString(nTuBr->toDataTextW, "4");
 
486
      nTuBr->dumpTo = 4;
 
487
    } else {
 
488
      SetIntText(nTuBr->toDataTextW, nMult);
 
489
      nTuBr->dumpTo = nMult;
 
490
    }  
 
491
    XtAddCallback(nTuBr->toDataTextW, XmNvalueChangedCallback,
 
492
            (XtCallbackProc)modifiedToDataCB, (void *) nTuBr);
 
493
    
 
494
    ac = 0;
 
495
    XtSetArg(args[ac], XmNrows, 8); ac++;
 
496
    XtSetArg(args[ac], XmNcolumns, 80); ac++;
 
497
    XtSetArg(args[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
 
498
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
 
499
    XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
500
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
501
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
502
    XtSetArg(args[ac], XmNbottomWidget, dismissBtn); ac++;
 
503
    XtSetArg(args[ac], XmNdeleteResponse, XmDO_NOTHING); ac++;
 
504
    nTuBr->dumpDataW = XmCreateScrolledText(form,
 
505
                                          "SolutionText", args, ac);
 
506
    XtManageChild(nTuBr->dumpDataW);
 
507
    XtManageChild(form);
 
508
    
 
509
 
 
510
}    
 
511
static void dismissDataDumpCB(Widget w, nTuBrowserInfo * nTuBr,
 
512
                               caddr_t call_data)
 
513
{
 
514
    XtUnmanageChild(nTuBr->dumpDataFormW);
 
515
}
 
516
static void briefCB(Widget w, nTuBrowserInfo * nTuBr ,
 
517
                             XmToggleButtonCallbackStruct *callData)
 
518
{                             
 
519
    if (!callData->set)
 
520
        return;
 
521
    mcfioC_ShowBrowserDataDump(nTuBr);
 
522
}
 
523
static void modifiedFromDataCB(Widget w,  
 
524
                               nTuBrowserInfo * nTuBr, caddr_t call_data)
 
525
{
 
526
   int ival;
 
527
 
 
528
    if (GetIntText(w, &ival) != TEXT_READ_OK) return;
 
529
    nTuBr->dumpFrom = ival; 
 
530
    mcfioC_ShowBrowserDataDump(nTuBr);
 
531
                                   
 
532
}                               
 
533
static void modifiedToDataCB(Widget w,  
 
534
                               nTuBrowserInfo * nTuBr, caddr_t call_data)
 
535
{
 
536
   int ival;
 
537
 
 
538
    if (GetIntText(w, &ival) != TEXT_READ_OK) return;
 
539
    nTuBr->dumpTo = ival; 
 
540
    mcfioC_ShowBrowserDataDump(nTuBr);
 
541
}
 
542
static void printValuesBrief(char *start, int type, 
 
543
                             int n_instance, char **text) 
 
544
{
 
545
   int *iDat;
 
546
   float *fDat; 
 
547
   double *gDat;
 
548
   char *cDat;
 
549
   short *sDat;
 
550
   void *pDat;
 
551
   int len;
 
552
   int j, n;
 
553
   char *t1 = *text;
 
554
   
 
555
   n = n_instance;
 
556
   switch (type) {
 
557
         case BYTE_NTU:
 
558
            if (n > 10) n = 10;
 
559
             for (j=0, cDat = start; j<n; j++, t1+=len, cDat++) 
 
560
                           sprintf (t1,"%x, %n",(*cDat), &len);
 
561
             break;
 
562
         case CHARACTER_NTU:
 
563
             if (n > 40) n = 40;
 
564
             for (j=0, cDat = start; j<n; j++, cDat++) 
 
565
                if (isgraph(*cDat)) { 
 
566
                     sprintf (t1,"%c%n", *cDat, &len);
 
567
                      t1+=len;
 
568
                 } else if (isspace(*cDat)) {
 
569
                     sprintf (t1," %n", &len);
 
570
                      t1+=len;
 
571
                 }          
 
572
             break;
 
573
         case POINTER_NTU:
 
574
             if (n > 2) n = 2;
 
575
             /* This is a bad idea,
 
576
             * we do not know what kind of pointer that is... Skip!
 
577
             */
 
578
             /*  pDat = (void *) cDat;
 
579
             for (j=0; j<n; j++, t1+=len, pDat++) 
 
580
                           sprintf (t1,"%x, %n", pDat, &len); */
 
581
             break;
 
582
         case LOGICAL_NTU:
 
583
             if (n > 10) n = 10;
 
584
             for (j=0, iDat = (int *) start; j<n; j++, t1+=len, iDat++) {
 
585
                  if (*iDat) sprintf (t1,"T,%n", &len);
 
586
                  else sprintf (t1,"F, %n", &len);
 
587
             }    
 
588
             break;
 
589
         case INTEGER2_NTU:
 
590
             if (n > 8) n = 8;
 
591
             for (j=0, sDat = (short *) start; j<n; j++, t1+=len, sDat++) 
 
592
                           sprintf (t1,"%d, %n",(*sDat), &len);
 
593
             break;
 
594
         case INTEGER_NTU:
 
595
             if (n > 4) n = 4;
 
596
             for (j=0, iDat = (int *) start; j<n; j++, t1+=len, iDat++) 
 
597
                           sprintf (t1,"%d, %n",(*iDat), &len);
 
598
             break;
 
599
         case REAL_NTU:
 
600
             if (n > 4) n = 4;
 
601
             for (j=0, fDat = (float *) start; j<n; j++, t1+=len, fDat++) 
 
602
                           sprintf (t1,"%g, %n",(*fDat), &len);
 
603
             break;
 
604
         case DBL_PRECISION_NTU:
 
605
             if (n > 4) n = 4;
 
606
             for (j=0, gDat = (double *) start; j<n; j++, t1+=len, gDat++) 
 
607
                           sprintf (t1,"%g, %n",(*gDat), &len);
 
608
             break;
 
609
         case COMPLEX_NTU:
 
610
             if (n > 2) n = 2;
 
611
             for (j=0, fDat = (float *) start; j<n; j++) {
 
612
                      sprintf (t1,"(%g, %n",(*fDat), &len);  t1+=len, fDat++;
 
613
                      sprintf (t1,"%g), %n",(*fDat), &len);  t1+=len, fDat++;
 
614
              } 
 
615
              break;
 
616
          case DBL_COMPLEX_NTU:
 
617
              if (n > 2) n = 2;
 
618
               for (j=0, gDat = (double *) start; j<n; j++) {
 
619
                   sprintf (t1,"(%g, %n",(*gDat), &len);  t1+=len, gDat++;
 
620
                   sprintf (t1,"%g), %n",(*gDat), &len);  t1+=len, gDat++;
 
621
               } 
 
622
               break;
 
623
          }
 
624
         if (n_instance != n) sprintf (t1, "...\n%n", &len);
 
625
                 else sprintf (t1, "\n%n", &len);
 
626
          t1 +=len;
 
627
          *text = t1;
 
628
}
 
629
static void printValuesFull(char *start, varGenNtuple *var, char **text)
 
630
{
 
631
   int *iDat;
 
632
   float *fDat; 
 
633
   double *gDat;
 
634
   char *cDat;
 
635
   short *sDat;
 
636
   void *pDat;
 
637
   int len;
 
638
   int idim, j, jl, n, ntot, nlines;
 
639
   char *t1;
 
640
   static char varDimSymbols[] = "ijklmn";
 
641
   
 
642
   t1 = *text;
 
643
   if (var->numDim < 1) {
 
644
         printValuesBrief(start, var->type, 1, text);
 
645
         return;
 
646
   }
 
647
   sprintf (t1,"\n%n",&len); t1 += len;
 
648
   for (idim=0, ntot=1, nlines = 1; idim<var->numDim; idim++) {
 
649
       sprintf (t1, "       Dimension, %c = 0, %d\n%n",varDimSymbols[idim],
 
650
                     var->dimensions[idim], &len ); t1 += len;
 
651
       ntot = ntot *  var->dimensions[idim];
 
652
       if (idim <(var->numDim-1) ) nlines = nlines *   var->dimensions[idim];
 
653
   }
 
654
   for (jl = 0; jl<nlines; jl++) { 
 
655
      sprintf (t1,"          %n",&len); t1 += len;
 
656
      n = var->dimensions[(var->numDim-1)]; 
 
657
      switch (var->type) {
 
658
         case BYTE_NTU:
 
659
             for (j=0, cDat = start; j<n; j++, t1+=len, cDat++) 
 
660
                           sprintf (t1,"%x, %n",(*cDat), &len);
 
661
             break;
 
662
         case CHARACTER_NTU:
 
663
             for (j=0, cDat = start; j<n; j++, cDat++) 
 
664
                if (isgraph(*cDat)) { 
 
665
                     sprintf (t1,"%c%n", *cDat, &len);
 
666
                      t1+=len;
 
667
                 } else if (isspace(*cDat)) {
 
668
                     sprintf (t1," %n", &len);
 
669
                      t1+=len;
 
670
                 }          
 
671
             break;
 
672
         case POINTER_NTU:
 
673
             /* This is a bad idea,
 
674
             * we do not know what kind of pointer that is... Skip!
 
675
             */
 
676
             /*  pDat = (void *) cDat;
 
677
             for (j=0; j<n; j++, t1+=len, pDat++) 
 
678
                           sprintf (t1,"%x, %n", pDat, &len); */
 
679
             break;
 
680
         case LOGICAL_NTU:
 
681
             for (j=0, iDat = (int *) start; j<n; j++, t1+=len, iDat++) {
 
682
                  if (*iDat) sprintf (t1,"T,%n", &len);
 
683
                  else sprintf (t1,"F, %n", &len);
 
684
             }    
 
685
             break;
 
686
         case INTEGER2_NTU:
 
687
             for (j=0, sDat = (short *) start; j<n; j++, t1+=len, sDat++) 
 
688
                           sprintf (t1,"%d, %n",(*sDat), &len);
 
689
             break;
 
690
         case INTEGER_NTU:
 
691
             for (j=0, iDat = (int *) start; j<n; j++, t1+=len, iDat++) 
 
692
                           sprintf (t1,"%d, %n",(*iDat), &len);
 
693
             break;
 
694
         case REAL_NTU:
 
695
             for (j=0, fDat = (float *) start; j<n; j++, t1+=len, fDat++) 
 
696
                           sprintf (t1,"%g, %n",(*fDat), &len);
 
697
             break;
 
698
         case DBL_PRECISION_NTU:
 
699
             for (j=0, gDat = (double *) start; j<n; j++, t1+=len, gDat++) 
 
700
                           sprintf (t1,"%g, %n",(*gDat), &len);
 
701
             break;
 
702
         case COMPLEX_NTU:
 
703
             for (j=0, fDat = (float *) start; j<n; j++) {
 
704
                      sprintf (t1,"(%g, %n",(*fDat), &len);  t1+=len, fDat++;
 
705
                      sprintf (t1,"%g), %n",(*fDat), &len);  t1+=len, fDat++;
 
706
              } 
 
707
              break;
 
708
          case DBL_COMPLEX_NTU:
 
709
               for (j=0, gDat = (double *) start; j<n; j++) {
 
710
                   sprintf (t1,"(%g, %n",(*gDat), &len);  t1+=len, gDat++;
 
711
                   sprintf (t1,"%g), %n",(*gDat), &len);  t1+=len, gDat++;
 
712
               } 
 
713
               break;
 
714
          }
 
715
         sprintf (t1, "\n%n", &len); t1 +=len;
 
716
      }
 
717
      *text = t1;
 
718
}
 
719
 
 
720
 
 
721