← Back to branch summary

~maddevelopers/mg5amcnlo/2.9.4

« back to all changes in this revision

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

pass to v2.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/StdHEP/mcfio/src/mcf_BrowseUtil2.c
 
1
/*******************************************************************************
 
2
*                                                                              *
 
3
* mcf_BrowseUtil2.c -- Utilities and auxillary Panels for NTuple Browser.      *
 
4
*       Gives a short listing of the characteristic of the file header         *
 
5
*                                                                              *
 
6
* Copyright (c) 1995, 1996 Universities Research Association, Inc.             *
 
7
* All rights reserved.                                                         *
 
8
*                                                                              *
 
9
*******************************************************************************/
 
10
#include <stdio.h>
 
11
#include <stdlib.h>
 
12
#include <sys/param.h>
 
13
#include <rpc/types.h>
 
14
#include <sys/types.h>
 
15
#include <rpc/xdr.h>
 
16
#include <ctype.h>
 
17
#include <limits.h>
 
18
#include <X11/Intrinsic.h>
 
19
#include <X11/Shell.h>
 
20
#include <Xm/Xm.h>
 
21
#include <Xm/DialogS.h>
 
22
#include <Xm/SelectioB.h>
 
23
#include <Xm/RowColumn.h>
 
24
#include <Xm/ToggleB.h>
 
25
#include <Xm/Form.h>
 
26
#include <Xm/List.h>
 
27
#include <Xm/Label.h>
 
28
#include <Xm/LabelG.h>
 
29
#include <Xm/PushB.h>
 
30
#include <Xm/PushBG.h>
 
31
#include <Xm/Text.h>
 
32
#include "DialogF.h"
 
33
#include "getfiles.h"
 
34
#include "misc.h"
 
35
#include "mcf_nTupleDescript.h"
 
36
#include "mcf_xdr.h"
 
37
#include "mcfio_Dict.h"
 
38
#include "mcfio_Util1.h"
 
39
#include "mcfio_Direct.h"
 
40
#include "mcf_nTupleBuild.h"
 
41
#include "mcf_NTuIOUtils.h"
 
42
#include "mcf_BrowseUtil1.h"
 
43
#include "mcf_BrowseMainPanel.h"
 
44
#include "mcf_BrowseUtil2.h"
 
45
#ifdef HISTO
 
46
#include "histoscope.h"
 
47
#endif
 
48
 
 
49
extern nTuDDL **NTuDDLList;
 
50
extern int NumOfNTuples;
 
51
extern nTuBrowserInfo *CurrentNTupleBrowserSelected;
 
52
extern Widget McfioHsResetBtnW; /* To reset all existing histograms */
 
53
 
 
54
int HistoIsBrowserNtuInit;
 
55
                /* A flag to state if HistoScope is set */ 
 
56
 
 
57
static Widget DumpHeadTextW = NULL;
 
58
                 /* The text widget to view the header content */
 
59
static Widget DumpHeadFormW = NULL;
 
60
                /*  The form widget to view the header content */
 
61
static Widget DumpHeadShellW = NULL;
 
62
                /*  The shell widget to view the header content */
 
63
static struct timeval TimeSetTimeOut = {0, 0};
 
64
static int TimeOutTime = 0;
 
65
static XtIntervalId TimeOutID = 0;
 
66
 
 
67
/*
 
68
* Widgets and stuff for 1D histogram utilities
 
69
*/
 
70
static Widget OneDHistFormW  = NULL;
 
71
      /* The form widget associated with the panel for 1D histo utilities */       
 
72
static Widget OneDHistShellW  = NULL;
 
73
      /* The form widget associated with the panel for 1D histo utilities */ 
 
74
static Widget OneDHistHistoListW = NULL;
 
75
      /* A list to manipulate to manipulate these histograms */
 
76
static Widget OneDHistNtupleCategoryLabelW;
 
77
      /* To display the Ntuple Category Label */
 
78
static Widget OneDHistNtupleTitleLabelW;
 
79
      /* To display the Ntuple Title  Label */
 
80
static Widget OneDHistVariableListW = NULL;
 
81
      /* The list of variable corresponding to the selected Ntuple */
 
82
static Widget OneDHistCreateW = NULL;
 
83
      /* The button to create a 1D histogram */
 
84
static Widget OneDHistModifyW = NULL; /* To modify a 1D histogram */
 
85
static Widget OneDHistDeleteW = NULL; /* To create a 1D histogram */
 
86
static Widget OneDHistTitleW = NULL; /* The title field for OneDhist */
 
87
static Widget OneDHistNumBinsW = NULL; /* The title field for OneDhist */
 
88
static Widget OneDHistLowBinW = NULL; /* The title field for OneDhist */
 
89
static Widget OneDHistHighBinW = NULL; /* The title field for OneDhist */
 
90
static Widget OneDHistMultW = NULL; /* The title field for OneDhist */
 
91
static int FirstOneDHistogram;
 
92
static int OneDHistNumberListed = 0; 
 
93
        /* The number of 1D histogram managed by this panel */
 
94
        
 
95
static int OneDHistSizeOfList = 0; 
 
96
        
 
97
static int *OneDHistListedIDs = NULL; 
 
98
        /* The hs ids of the listed histograms */
 
99
static int CurrentHistoUID = 0 ; 
 
100
        /* A holding place to kee ptrack of the modified histo UID */
 
101
static void showHeaderData(int all);
 
102
static void createBrowserHeadDump();
 
103
static void dismissHeadDumpCB(Widget w, nTuBrowserInfo *nTuBr,
 
104
                               caddr_t call_data);
 
105
                               
 
106
static void createBrowserHeadDump();
 
107
static void dismissHeadDumpCB(Widget w, nTuBrowserInfo *nTuBr,
 
108
                               caddr_t call_data);
 
109
#ifdef HISTO                               
 
110
static void createOneDHistCB(Widget w, nTuBrowserInfo *nTuBr, 
 
111
                                caddr_t call_data);
 
112
                                
 
113
static void createOneDHistActual(int newHisto);
 
114
static void createBrowserOneDHistPanel(nTuBrowserInfo *nTuBr);
 
115
static void dismissOneDHistCB(Widget w, nTuBrowserInfo *nTuBr,
 
116
                               caddr_t call_data);
 
117
static void modifyOneDHistCB(Widget w, nTuBrowserInfo *nTuBr,
 
118
                               caddr_t call_data);
 
119
                               
 
120
static void deleteOneDHistCB(Widget w, nTuBrowserInfo *nTuBr,
 
121
                               caddr_t call_data);
 
122
static void redisplay1DHistoList();
 
123
static void oneDHistListCB(Widget w, nTuBrowserInfo *nTuBr,
 
124
                               caddr_t call_data);
 
125
static nTuBrowserInfo *oneDHistNTupleSource(int hs_id);
 
126
#endif                               
 
127
static void getVarIndexDialog(int *loc, int nDim, int *maxVal);
 
128
static void setListItems(Widget w, XmString *strings, int nStrings);
 
129
static void      setTimer(int timeInMillis);
 
130
static void      cancelTimer(void);
 
131
static void      timerUpCB(void);
 
132
/*
 
133
** Some scrap space to define histograms
 
134
*/
 
135
static char BrowseUtil2htitle[255];
 
136
                                                              
 
137
/*
 
138
** Remove the white space (blanks and tabs) from a string
 
139
*/
 
140
void mcfioC_RemoveWhiteSpace(char *string)
 
141
{
 
142
    char *outPtr = string;
 
143
    
 
144
    while (TRUE) {
 
145
        if (*string != ' ' && *string != '\t')
 
146
            *(outPtr++) = *(string++);
 
147
        else
 
148
            string++;
 
149
        if (*string == 0) {
 
150
            *outPtr = 0;
 
151
            return;
 
152
        }
 
153
    }
 
154
}
 
155
 
 
156
void mcfioC_ShowBrowserHeadDump() {
 
157
 
 
158
   if (DumpHeadShellW == NULL) createBrowserHeadDump();
 
159
   showHeaderData(False);
 
160
}
 
161
 
 
162
       
 
163
void mcfioC_ShowBrowserEvtHeadDump() {
 
164
 
 
165
   if (DumpHeadShellW == NULL) createBrowserHeadDump();
 
166
   showHeaderData(True);
 
167
}
 
168
#ifdef HISTO
 
169
void mcfioC_ShowBrowserOneDHist()
 
170
{
 
171
 
 
172
   char *text, *t1, *t2;
 
173
   int i, nChar, len, n1, n2, iln,  *blockList;
 
174
   nTuBrowserInfo *nTuBr;
 
175
   
 
176
   nTuBr = CurrentNTupleBrowserSelected;
 
177
   if (OneDHistShellW == NULL) createBrowserOneDHistPanel(nTuBr);
 
178
   if (!XtIsManaged(OneDHistFormW)) XtManageChild(OneDHistFormW);
 
179
   /*
 
180
   ** We have to set the selection in the Main Panel to this requested 
 
181
   ** Ntuple.
 
182
   */
 
183
   if (CurrentNTupleBrowserSelected != nTuBr) {
 
184
      if  (mcfioC_SetSpecificNTupleBr(nTuBr) != True) return;
 
185
   }
 
186
   mcfioC_OneDHistUpdateNTupleContent();
 
187
}
 
188
void mcfioC_OneDHistUpdateNTupleContent()
 
189
{
 
190
/*
 
191
** Update the Data Descriptioon in the 1D Histogram panel
 
192
*/
 
193
   int i, id, nItems, l, uid, k;
 
194
   XmString *stringTable;
 
195
   nTuDDL *ddl;
 
196
   descrGenNtuple *dNTu;
 
197
   varGenNtuple *var;
 
198
   Arg args[2];
 
199
   XmString s1;
 
200
   
 
201
   if (OneDHistShellW == NULL) return;
 
202
   if (!XtIsManaged(OneDHistFormW)) return;
 
203
   ddl = mcf_GetNTuByPtrID(CurrentNTupleBrowserSelected->id);
 
204
   if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
205
            else dNTu = ddl->descrNtu;
 
206
   /*
 
207
   ** Update the Label fields 
 
208
   */
 
209
   XtSetArg(args[0], XmNlabelString, s1 = XmStringCreateSimple(ddl->category));
 
210
   XtSetValues(OneDHistNtupleCategoryLabelW, args, 1);
 
211
   XmStringFree(s1);
 
212
   
 
213
   XtSetArg(args[0], XmNlabelString, s1 = XmStringCreateSimple(ddl->title));
 
214
   XtSetValues(OneDHistNtupleTitleLabelW, args, 1);
 
215
   XmStringFree(s1);
 
216
   
 
217
   nItems = dNTu->numVariables + 1; 
 
218
   stringTable = (XmString *)XtMalloc((nItems+1) * sizeof(XmString));
 
219
   stringTable[0] = XmStringCreateSimple ("Multiplicity");
 
220
   for (k=0; k<dNTu->numVariables; k++) {
 
221
      var = dNTu->variables[k];
 
222
      stringTable[k+1] = XmStringCreateSimple (var->name);
 
223
    }
 
224
    stringTable[nItems] = (XmString ) NULL;
 
225
    setListItems(OneDHistVariableListW, stringTable, nItems);
 
226
    FreeStringTable(stringTable);
 
227
    return;
 
228
}
 
229
#endif
 
230
   
 
231
static void showHeaderData(int all)
 
232
{
 
233
 
 
234
   char *text, *t1, *t2;
 
235
   int i, nChar, len, n1, n2, n11, n12, iln,  *blockList, i1, i2, i3;
 
236
   nTuDDL *ddl;
 
237
   descrGenNtuple *dNTu;
 
238
   nTuBrowserInfo *nTuBr;
 
239
 
 
240
 
 
241
   /*
 
242
   ** set the text widget From, To, to go for a specific track  
 
243
   ** or substructures
 
244
   */
 
245
   mcfioC_InfoStreamInt(1, MCFIO_NUMBLOCKS, &n1);
 
246
   nChar = 2*MCF_XDR_F_TITLE_LENGTH + 81*6 + 80*( n1/10);
 
247
   if (all) {
 
248
       mcfioC_InfoEventInt(1, MCFIO_NUMBLOCKS, &n11);
 
249
       mcfioC_InfoEventInt(1, MCFIO_NUMNTUPLES, &n12);
 
250
      nChar += 800 + 80*n12 + 80*(n11/10);
 
251
   }    
 
252
   text = (char *) malloc(sizeof(char) * nChar);
 
253
   t1 = text;
 
254
   sprintf(t1, "Title : %n",&len); t1+=len;
 
255
   mcfioC_InfoStreamChar(1,MCFIO_TITLE, t1, &len); t1 +=len;
 
256
   sprintf (t1, " \n%n",&len); t1+=len;
 
257
   sprintf (t1, " \n%n",&len); t1+=len;
 
258
   
 
259
   sprintf(t1, "Comment : %n",&len); t1+=len;
 
260
   mcfioC_InfoStreamChar(1,MCFIO_COMMENT, t1, &len); t1 +=len;
 
261
   sprintf (t1, " \n%n",&len); t1+=len;
 
262
   sprintf (t1, " \n%n",&len); t1+=len;
 
263
   
 
264
   sprintf(t1, "Creation Date : %n",&len); t1+=len;
 
265
   mcfioC_InfoStreamChar(1,MCFIO_CREATIONDATE, t1, &len); t1 +=len;
 
266
   sprintf (t1, " \n%n",&len); t1+=len;
 
267
   
 
268
   sprintf(t1, "Closing Date : %n",&len); t1+=len;
 
269
   mcfioC_InfoStreamChar(1,MCFIO_CLOSINGDATE, t1, &len); t1 +=len;
 
270
   sprintf (t1, " \n%n",&len); t1+=len;
 
271
   
 
272
   mcfioC_InfoStreamInt(1, MCFIO_NUMEVTS, &n2);
 
273
   if (n2 <= 0) {
 
274
     sprintf(t1,
 
275
     "The number of events found on the file is 0 or unknown \n%n",&len);
 
276
     t1+=len;
 
277
     sprintf(t1,
 
278
     "  It is likely that this file hasn't been closed properly \n%n",&len);
 
279
     t1+=len;
 
280
    } else 
 
281
     sprintf(t1, "Number of events : %d \n%n", n2, &len); t1+=len;
 
282
   sprintf (t1, " \n%n",&len); t1+=len;
 
283
   
 
284
   sprintf(t1, "Number of private blocks : %d \n%n",n1, &len); t1+=len;
 
285
   blockList = (int *) malloc(sizeof(int) * n1);
 
286
   mcfioC_InfoStreamInt(1, MCFIO_BLOCKIDS, blockList);
 
287
   sprintf(t1, " List of blocks I.D. : %n", &len); t1 +=len;
 
288
   iln = 2;
 
289
   for (i=0; i<n1; i++, iln++) {
 
290
     if (i == (n1-1))
 
291
         sprintf(t1," %d %n", blockList[i], &len); 
 
292
     else 
 
293
         sprintf(t1," %d, %n", blockList[i], &len);
 
294
     t1 +=len; 
 
295
     if (iln % 8 == 0) {
 
296
          sprintf(t1, " \n%n", &len);  t1 +=len;
 
297
     }
 
298
   } 
 
299
   sprintf(t1, " \n%n", &len);  t1 +=len;
 
300
   free(blockList);
 
301
   if (all) {
 
302
     sprintf(t1,
 
303
" ==============================================================\n\n%n",&len);
 
304
     t1 +=len;
 
305
     mcfioC_InfoEventInt(1, MCFIO_EVENTNUMBER, &i1);
 
306
     mcfioC_InfoEventInt(1, MCFIO_STORENUMBER, &i2);
 
307
     mcfioC_InfoEventInt(1, MCFIO_RUNNUMBER, &i3);
 
308
     sprintf(t1,
 
309
  "Header Information for event %d, store %d, run %d \n%n", i1, i2, i3, &len);
 
310
     t1 +=len;
 
311
     mcfioC_InfoEventInt(1, MCFIO_TRIGGERMASK, &i1);
 
312
     sprintf(t1, "Trigger Mask: %d \n%n", i1, &len); t1 +=len;
 
313
     sprintf(t1, "Number of private blocks : %d \n%n", n11, &len); t1+=len;
 
314
     blockList = (int *) malloc(sizeof(int) * n11);
 
315
     mcfioC_InfoEventInt(1, MCFIO_BLOCKIDS, blockList);
 
316
     sprintf(t1, " List of blocks I.D. : %n", &len); t1 +=len;
 
317
     iln = 2;
 
318
     for (i=0; i<n11; i++, iln++) {
 
319
       if (i == (n1-1))
 
320
           sprintf(t1," %d %n", blockList[i], &len); 
 
321
       else 
 
322
           sprintf(t1," %d, %n", blockList[i], &len);
 
323
       t1 +=len; 
 
324
       if (iln % 8 == 0) {
 
325
          sprintf(t1, " \n%n", &len);  t1 +=len;
 
326
       }
 
327
     }
 
328
     free(blockList);
 
329
     
 
330
     sprintf(t1, "Number of Ntuples : %d \n%n", n12, &len); t1+=len;
 
331
     blockList = (int *) malloc(sizeof(int) * n12);
 
332
     mcfioC_InfoEventInt(1, MCFIO_NTUPLESLIST, blockList);
 
333
     sprintf(t1, 
 
334
     " List of Ntuple Category and titles in this event: \n%n", &len); 
 
335
     t1 +=len;
 
336
     for (i=0; i<n12; i++) {
 
337
       ddl = mcf_GetNTuByPtrID(blockList[i]);
 
338
       if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
339
       sprintf(t1,"      %s   :   %s\n%n", ddl->category, ddl->title, &len); 
 
340
       t1 += len;     
 
341
     }
 
342
     free(blockList);
 
343
   }
 
344
    
 
345
   XmTextSetString(DumpHeadTextW,text);
 
346
   XtManageChild(DumpHeadFormW);
 
347
   free(text);
 
348
}
 
349
   static void createBrowserHeadDump()
 
350
{
 
351
    Arg args[50];
 
352
    int ac;
 
353
    XmString s1;
 
354
    Widget dismissBtn;
 
355
 
 
356
    ac = 0;
 
357
    XtSetArg(args[ac], XmNautoUnmanage, False); ac++; 
 
358
    XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++; 
 
359
    DumpHeadFormW = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
 
360
    DumpHeadShellW = XtParent(DumpHeadFormW);
 
361
    XtVaSetValues(DumpHeadShellW, XmNtitle,
 
362
                                "File Header Information", 0);
 
363
    AddMotifCloseCallback(XtParent(DumpHeadFormW),
 
364
                         (XtCallbackProc)dismissHeadDumpCB, NULL);
 
365
                         
 
366
                         
 
367
    dismissBtn = XtVaCreateManagedWidget("dismissBtn",
 
368
            xmPushButtonGadgetClass, DumpHeadFormW,
 
369
            XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
 
370
            XmNbottomAttachment, XmATTACH_FORM,
 
371
            XmNbottomOffset, 4,
 
372
            XmNleftAttachment, XmATTACH_POSITION,
 
373
            XmNleftPosition, 25,
 
374
            XmNrightAttachment, XmATTACH_POSITION,
 
375
            XmNrightPosition, 75, 0);
 
376
    XmStringFree(s1);
 
377
    XtAddCallback(dismissBtn, XmNactivateCallback,
 
378
            (XtCallbackProc)dismissHeadDumpCB, NULL); 
 
379
    
 
380
    ac = 0;
 
381
    XtSetArg(args[ac], XmNrows, 8); ac++;
 
382
    XtSetArg(args[ac], XmNcolumns, 80); ac++;
 
383
    XtSetArg(args[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
 
384
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
 
385
    XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
386
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
387
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
388
    XtSetArg(args[ac], XmNbottomWidget, dismissBtn); ac++;
 
389
    XtSetArg(args[ac], XmNdeleteResponse, XmDO_NOTHING); ac++;
 
390
    DumpHeadTextW = XmCreateScrolledText(DumpHeadFormW,
 
391
                                          "HeaderText", args, ac);
 
392
    XtManageChild(DumpHeadTextW);
 
393
    XtManageChild(DumpHeadFormW);
 
394
}
 
395
    
 
396
static void dismissHeadDumpCB(Widget w, nTuBrowserInfo * nTuBr,
 
397
                               caddr_t call_data)
 
398
{
 
399
    XtUnmanageChild(DumpHeadFormW);
 
400
}
 
401
#ifdef HISTO
 
402
static void createBrowserOneDHistPanel(nTuBrowserInfo *nTuBr)
 
403
{
 
404
    Arg args[50];
 
405
    int ac;
 
406
    XmString s1, *st1;
 
407
    Widget dismissBtn, nbinLabel, lowEdgeLabel, highEdgeLabel, multLabel;
 
408
    Widget histForm, ntupleForm, titleLabel, histLabel, ntupleLabel;
 
409
    Widget ntupleCatLabel, ntupleTitleLabel;
 
410
 
 
411
    ac = 0;
 
412
    XtSetArg(args[ac], XmNautoUnmanage, False); ac++; 
 
413
    XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++; 
 
414
    OneDHistFormW = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
 
415
    OneDHistShellW = XtParent(OneDHistFormW);
 
416
    XtVaSetValues(OneDHistShellW, XmNtitle,
 
417
                                "One Dimensional Histogram Utility", 0);
 
418
    AddMotifCloseCallback(XtParent(OneDHistFormW),
 
419
                         (XtCallbackProc)dismissOneDHistCB, NULL);
 
420
                         
 
421
   OneDHistCreateW = XtVaCreateManagedWidget("create1DBtn",
 
422
            xmPushButtonGadgetClass, OneDHistFormW,
 
423
            XmNlabelString, s1=XmStringCreateSimple("Create"),
 
424
            XmNbottomAttachment, XmATTACH_FORM,
 
425
            XmNbottomOffset, 4,
 
426
            XmNleftAttachment, XmATTACH_POSITION,
 
427
            XmNleftPosition, 2,
 
428
            XmNrightAttachment, XmATTACH_POSITION,
 
429
            XmNrightPosition, 18, 0);
 
430
    XmStringFree(s1);
 
431
    XtAddCallback( OneDHistCreateW, XmNactivateCallback,
 
432
            (XtCallbackProc)createOneDHistCB, (nTuBrowserInfo *) nTuBr );
 
433
                         
 
434
                         
 
435
   OneDHistModifyW = XtVaCreateManagedWidget("modify1DBtn",
 
436
            xmPushButtonGadgetClass, OneDHistFormW,
 
437
            XmNlabelString, s1=XmStringCreateSimple("Modify"),
 
438
            XmNbottomAttachment, XmATTACH_FORM,
 
439
            XmNbottomOffset, 4,
 
440
            XmNleftAttachment, XmATTACH_POSITION,
 
441
            XmNleftPosition, 20,
 
442
            XmNrightAttachment, XmATTACH_POSITION,
 
443
            XmNrightPosition, 40, 0);
 
444
    XmStringFree(s1);
 
445
    XtAddCallback( OneDHistModifyW, XmNactivateCallback,
 
446
            (XtCallbackProc)modifyOneDHistCB, NULL);
 
447
            
 
448
   OneDHistDeleteW = XtVaCreateManagedWidget("delete1DBtn",
 
449
            xmPushButtonGadgetClass, OneDHistFormW,
 
450
            XmNlabelString, s1=XmStringCreateSimple("Delete"),
 
451
            XmNbottomAttachment, XmATTACH_FORM,
 
452
            XmNbottomOffset, 4,
 
453
            XmNleftAttachment, XmATTACH_POSITION,
 
454
            XmNleftPosition, 42,
 
455
            XmNrightAttachment, XmATTACH_POSITION,
 
456
            XmNrightPosition, 60, 0);
 
457
    XmStringFree(s1);
 
458
    XtAddCallback( OneDHistDeleteW, XmNactivateCallback,
 
459
            (XtCallbackProc)deleteOneDHistCB, NULL);
 
460
            
 
461
    dismissBtn = XtVaCreateManagedWidget("dismissBtn",
 
462
            xmPushButtonGadgetClass, OneDHistFormW,
 
463
            XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
 
464
            XmNbottomAttachment, XmATTACH_FORM,
 
465
            XmNbottomOffset, 4,
 
466
            XmNleftAttachment, XmATTACH_POSITION,
 
467
            XmNleftPosition, 80,
 
468
            XmNrightAttachment, XmATTACH_POSITION,
 
469
            XmNrightPosition, 98, 0);
 
470
    XmStringFree(s1);
 
471
    XtAddCallback(dismissBtn, XmNactivateCallback,
 
472
            (XtCallbackProc)dismissOneDHistCB, NULL);
 
473
 
 
474
    ac = 0;
 
475
    XtSetArg(args[ac], XmNlabelString, 
 
476
     (s1=XmStringCreateSimple("Number of bins:"))); ac++;
 
477
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
478
    XtSetArg(args[ac], XmNleftOffset,5); ac++;
 
479
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
480
    XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
 
481
    XtSetArg(args[ac], XmNbottomOffset,3); ac++;
 
482
    nbinLabel = 
 
483
       XmCreateLabelGadget(OneDHistFormW, "num1Dbin", args, ac);
 
484
    XmStringFree(s1);
 
485
    XtManageChild(nbinLabel);
 
486
    
 
487
    OneDHistNumBinsW = XtVaCreateManagedWidget("numBin1D",
 
488
            xmTextWidgetClass, OneDHistFormW,
 
489
            XmNcolumns, 5,
 
490
            XmNmaxLength, 5,
 
491
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
492
            XmNbottomAttachment, XmATTACH_WIDGET,
 
493
            XmNbottomWidget,OneDHistCreateW,
 
494
            XmNbottomOffset,3,
 
495
            XmNleftAttachment, XmATTACH_WIDGET,
 
496
            XmNleftWidget,nbinLabel, 0);
 
497
    RemapDeleteKey(OneDHistNumBinsW);
 
498
    XmTextSetString(OneDHistNumBinsW, "100");
 
499
    
 
500
    
 
501
    ac = 0;
 
502
    XtSetArg(args[ac], XmNlabelString, 
 
503
     (s1=XmStringCreateSimple("Low Edge:"))); ac++;
 
504
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
505
    XtSetArg(args[ac], XmNleftWidget,OneDHistNumBinsW); ac++;
 
506
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
507
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
508
    XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
 
509
    XtSetArg(args[ac], XmNbottomOffset,3); ac++;
 
510
    lowEdgeLabel = 
 
511
       XmCreateLabelGadget(OneDHistFormW, "low1Dbin", args, ac);
 
512
    XmStringFree(s1);
 
513
    XtManageChild(lowEdgeLabel);
 
514
    
 
515
    OneDHistLowBinW = XtVaCreateManagedWidget("lowEdge1D",
 
516
            xmTextWidgetClass, OneDHistFormW,
 
517
            XmNcolumns, 10,
 
518
            XmNmaxLength, 20,
 
519
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
520
            XmNbottomAttachment, XmATTACH_WIDGET,
 
521
            XmNbottomWidget,OneDHistCreateW,
 
522
            XmNbottomOffset,3,
 
523
            XmNleftAttachment, XmATTACH_WIDGET,
 
524
            XmNleftWidget,lowEdgeLabel, 0);
 
525
    RemapDeleteKey(OneDHistLowBinW);
 
526
    XmTextSetString(OneDHistLowBinW, "0.");
 
527
                    
 
528
    ac = 0;
 
529
    XtSetArg(args[ac], XmNlabelString, 
 
530
     (s1=XmStringCreateSimple("High Edge:"))); ac++;
 
531
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
532
    XtSetArg(args[ac], XmNleftWidget,OneDHistLowBinW); ac++;
 
533
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
534
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
535
    XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
 
536
    XtSetArg(args[ac], XmNbottomOffset,3); ac++;
 
537
    highEdgeLabel = 
 
538
       XmCreateLabelGadget(OneDHistFormW, "high1Dbin", args, ac);
 
539
    XmStringFree(s1);
 
540
    XtManageChild(highEdgeLabel);
 
541
    
 
542
    OneDHistHighBinW = XtVaCreateManagedWidget("highEdge1D",
 
543
            xmTextWidgetClass, OneDHistFormW,
 
544
            XmNcolumns, 10,
 
545
            XmNmaxLength, 20,
 
546
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
547
            XmNbottomAttachment, XmATTACH_WIDGET,
 
548
            XmNbottomWidget,OneDHistCreateW,
 
549
            XmNbottomOffset,3,
 
550
            XmNleftAttachment, XmATTACH_WIDGET,
 
551
            XmNleftWidget,highEdgeLabel, 0);
 
552
    RemapDeleteKey(OneDHistHighBinW);
 
553
    XmTextSetString(OneDHistHighBinW, "1.");
 
554
    
 
555
    
 
556
    ac = 0;
 
557
    XtSetArg(args[ac], XmNlabelString, 
 
558
     (s1=XmStringCreateSimple("Instance:"))); ac++;
 
559
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
560
    XtSetArg(args[ac], XmNleftWidget,OneDHistHighBinW); ac++;
 
561
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
562
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
563
    XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
 
564
    XtSetArg(args[ac], XmNbottomOffset,3); ac++;
 
565
    multLabel = 
 
566
       XmCreateLabelGadget(OneDHistFormW, "inst1Dlabel", args, ac);
 
567
    XmStringFree(s1);
 
568
    XtManageChild(multLabel);
 
569
    
 
570
    OneDHistMultW = XtVaCreateManagedWidget("inst1DTw",
 
571
            xmTextWidgetClass, OneDHistFormW,
 
572
            XmNcolumns, 10,
 
573
            XmNmaxLength, 20,
 
574
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
575
            XmNbottomAttachment, XmATTACH_WIDGET,
 
576
            XmNbottomWidget,OneDHistCreateW,
 
577
            XmNbottomOffset,3,
 
578
            XmNleftAttachment, XmATTACH_WIDGET,
 
579
            XmNleftWidget,multLabel, 0);
 
580
    RemapDeleteKey(OneDHistMultW);
 
581
    XmTextSetString(OneDHistMultW, "All");
 
582
    
 
583
    ac = 0;
 
584
    XtSetArg(args[ac], XmNlabelString, 
 
585
     (s1=XmStringCreateSimple("Title:"))); ac++;
 
586
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
587
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
588
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
589
    XtSetArg(args[ac], XmNbottomWidget,OneDHistNumBinsW); ac++;
 
590
    XtSetArg(args[ac], XmNbottomOffset,3); ac++;
 
591
    titleLabel = 
 
592
       XmCreateLabelGadget(OneDHistFormW, "title1Dlabel", args, ac);
 
593
    XmStringFree(s1);
 
594
    XtManageChild(titleLabel);
 
595
    
 
596
    OneDHistTitleW = XtVaCreateManagedWidget("title1DTw",
 
597
            xmTextWidgetClass, OneDHistFormW,
 
598
            XmNcolumns, 80,
 
599
            XmNmaxLength, 255,
 
600
            XmNeditMode, XmSINGLE_LINE_EDIT,
 
601
            XmNbottomAttachment, XmATTACH_WIDGET,
 
602
            XmNbottomWidget,OneDHistNumBinsW,
 
603
            XmNbottomOffset,3,
 
604
            XmNleftAttachment, XmATTACH_WIDGET,
 
605
            XmNleftWidget,titleLabel, 0);
 
606
    RemapDeleteKey(OneDHistTitleW);
 
607
    XmTextSetString(OneDHistTitleW, "Please enter a meaningful title here");
 
608
    /*
 
609
    ** Now the list of 1D histograms.
 
610
    */
 
611
    /* Create a form to hold the list and the top label */
 
612
    ac = 0;
 
613
    XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
 
614
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
615
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
616
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
617
    XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
 
618
    XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
 
619
    XtSetArg(args[ac], XmNleftOffset, 2); ac++;
 
620
    XtSetArg(args[ac], XmNtopOffset, 2); ac++;
 
621
    histForm = XmCreateForm(OneDHistFormW, "hist1DForm", args, ac);
 
622
    XtManageChild(histForm);
 
623
 
 
624
    ac = 0;
 
625
    XtSetArg(args[ac], XmNlabelString, 
 
626
     (s1=XmStringCreateSimple(
 
627
     "One Dimensional Histogram Listing"))); ac++;
 
628
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
629
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
630
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
631
    histLabel = 
 
632
       XmCreateLabelGadget(histForm, "HIST1Dlabel", args, ac);
 
633
    XmStringFree(s1);
 
634
    XtManageChild(histLabel);
 
635
    
 
636
    ac = 0;
 
637
    XtSetArg(args[ac], XmNitems, (st1=StringTable(1,
 
638
     "No histogram defined                        "))); ac++;
 
639
    XtSetArg(args[ac], XmNitemCount, 1); ac++;
 
640
    XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
 
641
    XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
 
642
    XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
 
643
    XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
 
644
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
645
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
646
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
 
647
    XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
648
    XtSetArg(args[ac], XmNtopWidget, histLabel); ac++;
 
649
    XtSetArg(args[ac], XmNtopOffset, 0); ac++;
 
650
    XtSetArg(args[ac], XmNleftOffset, 3); ac++;
 
651
    XtSetArg(args[ac], XmNbottomOffset, 4); ac++;
 
652
    OneDHistHistoListW = XmCreateScrolledList(histForm, "hist1DList", args,ac);
 
653
    FreeStringTable(st1);
 
654
    XtAddCallback(OneDHistHistoListW, XmNbrowseSelectionCallback,
 
655
                  (XtCallbackProc)  oneDHistListCB, NULL);
 
656
    XtManageChild(OneDHistHistoListW);
 
657
    OneDHistSizeOfList = 10;
 
658
    OneDHistNumberListed = 0;
 
659
    OneDHistListedIDs = (int *) malloc(sizeof(int) * OneDHistSizeOfList);
 
660
    /*
 
661
    ** Now the list of Ntuple Variables. Also a few Label to refer to the 
 
662
    ** Ntuple category/title listed on the Main panel.
 
663
    ** 
 
664
    */
 
665
    /* Create a form to hold the list and the top label */
 
666
    ac = 0;
 
667
    XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
 
668
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
669
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
670
    XtSetArg(args[ac], XmNleftWidget, histForm); ac++;
 
671
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
 
672
    XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
 
673
    XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
 
674
    XtSetArg(args[ac], XmNleftOffset, 6); ac++;
 
675
    XtSetArg(args[ac], XmNtopOffset, 2); ac++;
 
676
    ntupleForm = XmCreateForm(OneDHistFormW, "ntu1DForm", args, ac);
 
677
    XtManageChild(ntupleForm);
 
678
 
 
679
    ac = 0;
 
680
    XtSetArg(args[ac], XmNlabelString, 
 
681
     (s1=XmStringCreateSimple("Selected NTuple Synopsis"))); ac++;
 
682
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
683
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
684
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
685
    ntupleLabel = 
 
686
       XmCreateLabelGadget(ntupleForm, "NTU1DDlabel", args, ac);
 
687
    XmStringFree(s1);
 
688
    XtManageChild(ntupleLabel);
 
689
    
 
690
    ac = 0;
 
691
    XtSetArg(args[ac], XmNlabelString, 
 
692
     (s1=XmStringCreateSimple("Category:"))); ac++;
 
693
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
694
    XtSetArg(args[ac], XmNleftOffset, 3); ac++;
 
695
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
696
    XtSetArg(args[ac], XmNtopOffset, 1); ac++;
 
697
    XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
 
698
    ntupleCatLabel = 
 
699
       XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
 
700
    XmStringFree(s1);
 
701
    XtManageChild(ntupleCatLabel);
 
702
    
 
703
    ac = 0;
 
704
    XtSetArg(args[ac], XmNlabelString, 
 
705
     (s1=XmStringCreateSimple("None----------------------"))); ac++;
 
706
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
707
    XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
 
708
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
709
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
710
    XtSetArg(args[ac], XmNtopOffset, 1); ac++;
 
711
    XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
 
712
    OneDHistNtupleCategoryLabelW = 
 
713
       XmCreateLabelGadget(ntupleForm, "NTU1DCatlabel", args, ac);
 
714
    XmStringFree(s1);
 
715
    XtManageChild(OneDHistNtupleCategoryLabelW);
 
716
    
 
717
    ac = 0;
 
718
    XtSetArg(args[ac], XmNlabelString, 
 
719
     (s1=XmStringCreateSimple("Title:"))); ac++;
 
720
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
721
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
722
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
723
    XtSetArg(args[ac], XmNtopWidget, ntupleCatLabel); ac++;
 
724
    XtSetArg(args[ac], XmNtopOffset, 1); ac++;
 
725
    ntupleTitleLabel = 
 
726
       XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
 
727
    XmStringFree(s1);
 
728
    XtManageChild(ntupleTitleLabel);
 
729
    
 
730
    ac = 0;
 
731
    XtSetArg(args[ac], XmNlabelString, 
 
732
     (s1=XmStringCreateSimple("None----------------------"))); ac++;
 
733
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
734
    XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
 
735
    XtSetArg(args[ac], XmNleftOffset,3); ac++;
 
736
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
737
    XtSetArg(args[ac], XmNtopWidget,ntupleCatLabel ); ac++;
 
738
    XtSetArg(args[ac], XmNtopOffset, 1); ac++;
 
739
    OneDHistNtupleTitleLabelW = 
 
740
       XmCreateLabelGadget(ntupleForm, "NTU1DTitlabel", args, ac);
 
741
    XmStringFree(s1);
 
742
    XtManageChild(OneDHistNtupleTitleLabelW);
 
743
    
 
744
    ac = 0;
 
745
    XtSetArg(args[ac], XmNitems, (st1=StringTable(1, " "))); ac++;
 
746
    XtSetArg(args[ac], XmNitemCount, 1); ac++;
 
747
    XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
 
748
    XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
 
749
    XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
 
750
    XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
 
751
    XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
752
    XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
753
    XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
 
754
    XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
755
    XtSetArg(args[ac], XmNtopWidget, OneDHistNtupleTitleLabelW); ac++;
 
756
    XtSetArg(args[ac], XmNtopOffset, 2); ac++;
 
757
    XtSetArg(args[ac], XmNleftOffset, 3); ac++;
 
758
    OneDHistVariableListW = XmCreateScrolledList(ntupleForm, "hist1DList", args,ac);
 
759
    FreeStringTable(st1);
 
760
    XtManageChild(OneDHistVariableListW);
 
761
    FirstOneDHistogram = True;
 
762
    XtManageChild(OneDHistFormW);
 
763
    
 
764
            
 
765
}
 
766
static void createOneDHistCB(Widget w, nTuBrowserInfo * nTuBrDummy,
 
767
                               caddr_t call_data) 
 
768
{
 
769
    createOneDHistActual(True);
 
770
}
 
771
static void createOneDHistActual(int newHisto)
 
772
{
 
773
   int countHisto, countNTu, countVar, ivar, ivarH, nBins, idh, uid, im, jn;
 
774
   int i, index, k, *ivk, ll, lastFixed;
 
775
   float from, to;
 
776
   double dfrom, dto;
 
777
   XmString *selectedItems;
 
778
   int *posListHisto, *posListNTu, *posListVar;
 
779
   char *str, category[24], x_label[20]; 
 
780
   nTuDDL *ddl;
 
781
   descrGenNtuple *dNTu;
 
782
   nTuBrowserInfo *nTuBr;
 
783
   varGenNtuple *var;
 
784
   Arg args[2];
 
785
   nTuBroHs1D *nTuH1;
 
786
   char *cDat;
 
787
   long pp; 
 
788
 
 
789
 
 
790
    if (HistoIsBrowserNtuInit == NULL) {
 
791
       hs_initialize("Mcfio Ntuple Browser");
 
792
       hs_histoscope(1);
 
793
       HistoIsBrowserNtuInit = 1;
 
794
       XtSetSensitive(McfioHsResetBtnW, True);
 
795
       hs_update();
 
796
       setTimer(500);
 
797
    }
 
798
    nTuBr = CurrentNTupleBrowserSelected;
 
799
    ddl = mcf_GetNTuByPtrID(CurrentNTupleBrowserSelected->id);
 
800
    if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
 
801
            else dNTu = ddl->descrNtu;
 
802
    
 
803
    if (!XmListGetSelectedPos(OneDHistVariableListW, &posListVar, &countVar)) {
 
804
        DialogF(DF_WARN, OneDHistShellW, 1, "Please select a Variable",
 
805
                "Acknowledged");
 
806
        return;
 
807
    }
 
808
    ivarH = (*posListVar) - 1; ivar = ivarH -1;
 
809
    /*
 
810
    ** Get how many time we have to histogram the variable
 
811
    */
 
812
    if (ivar < dNTu->firstIndexed) im = -1;
 
813
    else {
 
814
     str = XmTextGetString(OneDHistMultW);
 
815
     if (GetIntText(OneDHistMultW, &im) == TEXT_READ_OK) {
 
816
        if (im > dNTu->maxMultiplicity) {
 
817
             DialogF(DF_WARN, OneDHistShellW, 1, 
 
818
 "Incorrect instance, above maximum Multiplicty.","Acknowledged");
 
819
             return;
 
820
        } else im--;
 
821
      } else {
 
822
        if ((strcmp(str,"All") == 0) || (strcmp(str,"ALL") == 0) ||
 
823
            (strcmp(str,"all") == 0)) im = -1;
 
824
        else if ((strcmp(str,"First") == 0) || (strcmp(str,"FIRST") == 0) ||
 
825
            (strcmp(str,"first") == 0)) im = 0;
 
826
        else if ((strcmp(str,"Second") == 0) || (strcmp(str,"SECOND") == 0) ||
 
827
            (strcmp(str,"second") == 0)) im = 1;
 
828
        else if ((strcmp(str,"Third") == 0) || (strcmp(str,"THIRD") == 0) ||
 
829
            (strcmp(str,"third") == 0)) im = 2;
 
830
        else {
 
831
             DialogF(DF_WARN, OneDHistShellW, 1, 
 
832
 "Incorrect instance, please use a number","Acknowledged");
 
833
             return;
 
834
        }
 
835
      }
 
836
    }     
 
837
/*
 
838
** We now read out the widget and define the histogram
 
839
*/
 
840
     str = XmTextGetString(OneDHistTitleW);
 
841
     if (GetIntTextWarn(OneDHistNumBinsW, &nBins,
 
842
                        "Number of Bins", TRUE) != TEXT_READ_OK) return;
 
843
     if (GetFloatTextWarn(OneDHistLowBinW, &dfrom,
 
844
                        "Low Bin Edge", TRUE) != TEXT_READ_OK) return;
 
845
     if (GetFloatTextWarn(OneDHistHighBinW, &dto,
 
846
                        "High Bin Edge", TRUE) != TEXT_READ_OK) return;
 
847
      from = (float) dfrom; to = (float) dto;
 
848
      /*
 
849
      ** At the beginning, the HistoList has a dummy item
 
850
      */
 
851
      if (FirstOneDHistogram) uid = 1;
 
852
      else if (newHisto) {
 
853
        XtSetArg (args[0], XmNitemCount, &uid);
 
854
        XtGetValues(OneDHistHistoListW, args, 1);
 
855
        uid++;
 
856
      } else uid = CurrentHistoUID; 
 
857
      if (ivarH == 0) 
 
858
          strcpy(x_label,"Multiplicity");
 
859
      else {
 
860
         var = dNTu->variables[ivar];
 
861
         if(strlen(var->name) < 17) strcpy(x_label,var->name);
 
862
         else {
 
863
            strncpy(x_label,var->name,16);
 
864
            strcpy(&x_label[16],"...");
 
865
         }
 
866
     }    
 
867
     idh = hs_create_1d_hist(uid, str,  "OneDHist", x_label, "Yield", 
 
868
                             nBins, from, to);
 
869
     XtFree(str);                        
 
870
     /*
 
871
     ** Store the idh, we need it for filling. Find the first free place on
 
872
     ** the list.
 
873
     */
 
874
    if (nTuBr->nHistoItems == nTuBr->sizeOfLists)
 
875
           mcfioC_ExtendBrowserAnalysis(nTuBr);
 
876
     nTuH1 = (nTuBroHs1D *) malloc(sizeof(nTuBroHs1D));
 
877
     index=0; 
 
878
     while (nTuBr->hsItemList[index] != NULL)  index++;
 
879
     nTuBr->hsItemList[index] =  (nTuBroHsGeneral *) nTuH1;
 
880
     nTuBr->nHistoItems++;
 
881
     nTuBr->nHisto1D++;
 
882
     nTuH1->id = idh;
 
883
     nTuH1->type = HS_1D_HISTOGRAM;
 
884
     nTuH1->varNumber = ivarH;
 
885
     nTuH1->subBlock = im;
 
886
     nTuH1->varIndices = NULL;
 
887
     if(dNTu->firstIndexed == -1) lastFixed = dNTu->numVariables;
 
888
           else lastFixed = dNTu->firstIndexed;
 
889
     if (ivarH != 0) { 
 
890
        var = dNTu->variables[ivar];
 
891
       if (var->numDim >= 1) {
 
892
          nTuH1->varIndices= (int *) malloc(sizeof(int) * var->numDim);
 
893
          ivk = nTuH1->varIndices;
 
894
          getVarIndexDialog(ivk, var->numDim, var->dimensions);
 
895
       } 
 
896
     }  
 
897
     if (nTuBr->data == NULL) mcfioC_createBrowserData(nTuBr);
 
898
     cDat = (char *) nTuBr->data;
 
899
     if (ivarH == 0) {
 
900
        cDat += dNTu->multOffset;
 
901
        nTuH1->lDat = (long *) cDat;
 
902
     } else {
 
903
          if (ivar < lastFixed) { 
 
904
            pp = ((long) nTuBr->data) +  dNTu->variables[ivar]->offset;
 
905
            nTuH1->lDat = (long *) pp;
 
906
          } else  nTuH1->lDat = NULL; 
 
907
               /* A specific subVariable (leaf), we'll compute the 
 
908
                        data pointer at filling time */
 
909
     }                  
 
910
     XtSetSensitive(OneDHistModifyW, True);
 
911
     XtSetSensitive(OneDHistDeleteW, True); 
 
912
     redisplay1DHistoList(); 
 
913
     FirstOneDHistogram = False; 
 
914
     hs_update();
 
915
}
 
916
static void modifyOneDHistCB(Widget w, nTuBrowserInfo * nTuBr,
 
917
                               caddr_t call_data)
 
918
{
 
919
    int *posList, count;
 
920
    if (!XmListGetSelectedPos(OneDHistHistoListW, &posList, &count)) {
 
921
        DialogF(DF_WARN, OneDHistShellW, 1, 
 
922
        "Please select a Histogram", "Acknowledged");
 
923
        return;
 
924
    }
 
925
     deleteOneDHistCB(w, NULL, NULL);
 
926
     createOneDHistActual(False);
 
927
}
 
928
 
 
929
static void deleteOneDHistCB(Widget w, nTuBrowserInfo *nTuBrDummy,
 
930
                               caddr_t call_data)
 
931
{
 
932
    int i, idPos, *posList, count, id, uid, jn;
 
933
    nTuBrowserInfo *nTuBr;
 
934
    nTuBroHs1D *nTuH1;
 
935
     
 
936
                                  
 
937
    if (!XmListGetSelectedPos(OneDHistHistoListW, &posList, &count)) {
 
938
        DialogF(DF_WARN, OneDHistShellW, 1, "Please select a Histogram",
 
939
                "Acknowledged");
 
940
        return;
 
941
    }
 
942
    id = OneDHistListedIDs[((*posList) -1)];
 
943
    CurrentHistoUID = hs_uid(id);
 
944
    nTuBr = oneDHistNTupleSource(id);
 
945
    if (nTuBr == NULL) {
 
946
         DialogF(DF_ERR, OneDHistShellW, 1,
 
947
                 "Internal Error in deleteOneDHist\nPlease report",
 
948
                "Acknowledged");
 
949
         return;
 
950
     }
 
951
    hs_delete(id);
 
952
    hs_update();
 
953
    for (i=0; i<nTuBr->sizeOfLists; i++) { 
 
954
       if (nTuBr->hsItemList[i] == NULL) continue;
 
955
        if (id == nTuBr->hsItemList[i]->id ) {
 
956
             nTuH1 = (nTuBroHs1D *) nTuBr->hsItemList[i];
 
957
             if (nTuH1->varIndices != NULL) free(nTuH1->varIndices);
 
958
             free(nTuH1);
 
959
             nTuBr->hsItemList[i] = NULL;       
 
960
             break;
 
961
         }
 
962
    }
 
963
    nTuBr->nHistoItems--;
 
964
    nTuBr->nHisto1D--;
 
965
    redisplay1DHistoList();
 
966
}
 
967
     
 
968
static void dismissOneDHistCB(Widget w, nTuBrowserInfo * nTuBr,
 
969
                               caddr_t call_data)
 
970
{
 
971
    XtUnmanageChild(OneDHistFormW);
 
972
}
 
973
 
 
974
static void redisplay1DHistoList()
 
975
{
 
976
    int i, id, nItems, l, uid, k, nh, jn, *il;
 
977
    nTuBrowserInfo *nTuBr;
 
978
    XmString *stringTable;
 
979
    
 
980
    for(jn=0, nh=0; jn< NumOfNTuples; jn++)  {
 
981
       nTuBr = NTupleBrowserList[jn];
 
982
       for (i=0; i<nTuBr->sizeOfLists; i++) {
 
983
         if (nTuBr->hsItemList[i] == NULL) continue;
 
984
          id = nTuBr->hsItemList[i]->id;
 
985
          if ( (id != -1) && (hs_type(id) == HS_1D_HISTOGRAM)) nh++;
 
986
       }    
 
987
    }
 
988
    OneDHistNumberListed = nh;
 
989
    if (nh == 0) {
 
990
       stringTable = (XmString *)XtMalloc((1) * sizeof(XmString));
 
991
       stringTable[1] = (XmString)0;
 
992
       setListItems(OneDHistHistoListW, stringTable, 0);
 
993
      /* free the string table */
 
994
       FreeStringTable(stringTable);
 
995
       return;
 
996
    } 
 
997
    if (nh > OneDHistSizeOfList) {
 
998
       il =  (int *) malloc(sizeof(int) * 2 * nh);
 
999
       memcpy((void *) il, (void *) OneDHistListedIDs, (sizeof(int) * nh));
 
1000
       free(OneDHistListedIDs); OneDHistListedIDs = il;
 
1001
       OneDHistSizeOfList = 2*nh;
 
1002
    } 
 
1003
    stringTable = (XmString *)XtMalloc((nh+1) * sizeof(XmString));
 
1004
    for(jn=0, nh=0; jn< NumOfNTuples; jn++)  {
 
1005
       nTuBr = NTupleBrowserList[jn];
 
1006
       for (i=0; i<nTuBr->sizeOfLists; i++) {
 
1007
         if (nTuBr->hsItemList[i] == NULL) continue;
 
1008
         id = nTuBr->hsItemList[i]->id;
 
1009
         if (nTuBr->hsItemList[i]->type == HS_1D_HISTOGRAM) {
 
1010
             l = hs_title(id, BrowseUtil2htitle);
 
1011
             stringTable[nh] = XmStringCreateSimple (BrowseUtil2htitle);
 
1012
             OneDHistListedIDs[nh] = id;
 
1013
             nh++; 
 
1014
          }
 
1015
        }
 
1016
    }
 
1017
    stringTable[nh] =  (XmString ) NULL;
 
1018
    setListItems(OneDHistHistoListW, stringTable, nh);
 
1019
    FreeStringTable(stringTable);
 
1020
    return;
 
1021
    
 
1022
}                  
 
1023
static void oneDHistListCB(Widget w, nTuBrowserInfo *nTuBrDummy,
 
1024
                               caddr_t call_data)
 
1025
{
 
1026
    int i, idPos, *posList, count, id, l, jn, uid, ivar;
 
1027
    float aa, bb;                               
 
1028
    nTuBrowserInfo *nTuBr;
 
1029
    nTuBroHs1D *nTuH1;
 
1030
 
 
1031
    XmListGetSelectedPos(OneDHistHistoListW, &posList, &count);
 
1032
    if (count < 1) return;
 
1033
    id = OneDHistListedIDs[((*posList) -1)];
 
1034
    uid = hs_uid(id);
 
1035
    /*
 
1036
    ** Select the variable associated with this histogram.
 
1037
    */
 
1038
    nTuBr = oneDHistNTupleSource(id);
 
1039
    if (nTuBr != CurrentNTupleBrowserSelected ) 
 
1040
                    if (!mcfioC_SetSpecificNTupleBr(nTuBr)) return;
 
1041
    for(i=0; i<CurrentNTupleBrowserSelected->sizeOfLists; i++) {
 
1042
       nTuH1 = (nTuBroHs1D *) CurrentNTupleBrowserSelected->hsItemList[i];
 
1043
       if (nTuH1 == NULL) continue;
 
1044
       if (nTuH1->id == id) break;
 
1045
    } 
 
1046
    if (nTuH1 == NULL) {
 
1047
         DialogF(DF_ERR, OneDHistShellW, 1,
 
1048
                 "Internal Error in oneDHistListCB\nPlease report",
 
1049
                "Acknowledged");
 
1050
         return;
 
1051
    }     
 
1052
    ivar =  nTuH1->varNumber;
 
1053
    XmListSelectPos(OneDHistVariableListW, (ivar+1), False);
 
1054
    l = hs_title(id, BrowseUtil2htitle);
 
1055
    XmTextSetString(OneDHistTitleW, BrowseUtil2htitle);
 
1056
    l = hs_1d_hist_num_bins(id);
 
1057
    SetIntText(OneDHistNumBinsW, l);
 
1058
    hs_1d_hist_range(id, &aa, &bb);
 
1059
    SetFloatText(OneDHistLowBinW, aa);
 
1060
    SetFloatText(OneDHistHighBinW, bb);
 
1061
    /*
 
1062
    ** We now have to related this histogram to the associated Ntuple 
 
1063
    */
 
1064
    for (i=0; i<nTuBr->sizeOfLists; i++) {
 
1065
       if (nTuBr->hsItemList[i] == NULL) continue;
 
1066
           if (nTuBr->hsItemList[i]->id == id) {
 
1067
               nTuH1 = (nTuBroHs1D *) nTuBr->hsItemList[i];
 
1068
               if (nTuH1->subBlock == -1)  
 
1069
                   XmTextSetString(OneDHistMultW, "All");
 
1070
                else 
 
1071
                   SetIntText(OneDHistMultW, nTuH1->subBlock);
 
1072
            }
 
1073
            break;
 
1074
    }
 
1075
    XtSetSensitive(OneDHistModifyW, True);
 
1076
    XtSetSensitive(OneDHistDeleteW, True);
 
1077
}
 
1078
#endif                                
 
1079
static nTuBrowserInfo *oneDHistNTupleSource(int hs_id) {
 
1080
 
 
1081
    nTuBrowserInfo *nTuBr;
 
1082
    int i, jn;
 
1083
    
 
1084
    for(jn=0; jn< NumOfNTuples; jn++) { 
 
1085
       nTuBr = NTupleBrowserList[jn];
 
1086
       for (i=0; i<nTuBr->sizeOfLists; i++) 
 
1087
         if ((nTuBr->hsItemList[i] != NULL) 
 
1088
             && (nTuBr->hsItemList[i]->id == hs_id)) return nTuBr;
 
1089
    }
 
1090
    return NULL;
 
1091
}
 
1092
/*
 
1093
** Set the contents of a list and compensate for various motif problems
 
1094
** associated with this apparently bizarre act.  (It might be worth
 
1095
** further investigation to better understand why these workarounds
 
1096
** are necessary).
 
1097
*/
 
1098
static void setListItems(Widget w, XmString *strings, int nStrings)
 
1099
{
 
1100
    XmString *st1;
 
1101
    
 
1102
    /* Motif doesn't reset the selection when items are changed */
 
1103
    XmListDeselectAllItems(w);
 
1104
 
 
1105
    /* .. and sometimes leaves stray scroll bars if nothing is in the list */
 
1106
    if (nStrings == 0) {
 
1107
        XtVaSetValues(w, XmNitems, st1=StringTable(1, " "),
 
1108
                XmNitemCount, 1, XmNsensitive, False, 0);
 
1109
        FreeStringTable(st1);
 
1110
    } else {
 
1111
        XtVaSetValues(w, XmNitems, strings, XmNitemCount, nStrings,
 
1112
                XmNsensitive, True, 0);
 
1113
    }
 
1114
}
 
1115
static void   getVarIndexDialog(int *loc, int nDim, int *maxVal)
 
1116
{
 
1117
    int i, valt, ok;
 
1118
    char *endPtr, *t1;
 
1119
        
 
1120
    if (nDim == 1) {
 
1121
        ok = -1;
 
1122
        while (ok == -1) { 
 
1123
        DialogF(DF_PROMPT,OneDHistShellW, 0,
 
1124
           "The variable you wish to histogram is a Vector\n\
 
1125
  Please fill in the requested index", BrowseUtil2htitle);
 
1126
        mcfioC_RemoveWhiteSpace(BrowseUtil2htitle);
 
1127
        valt = strtol(BrowseUtil2htitle, &endPtr, 10);
 
1128
        if ((strlen(BrowseUtil2htitle) == 0) || (*endPtr != '\0'))
 
1129
           DialogF(DF_ERR,OneDHistShellW, 1,
 
1130
            "Please Try again, we need an integer number! ","Acknowledged");
 
1131
        else {
 
1132
          if ((valt < 1) || (valt > maxVal[0]))  
 
1133
           DialogF(DF_ERR,OneDHistShellW, 1,
 
1134
          "Wrong Index Value\nWe need a number between 1 and %d",
 
1135
          "Acknowledged",maxVal[0]);
 
1136
          else {
 
1137
              ok = valt;
 
1138
              loc[0] = valt;
 
1139
          }
 
1140
       }
 
1141
     }
 
1142
   } else {
 
1143
tryagain:  
 
1144
        DialogF(DF_PROMPT,OneDHistShellW, 0,
 
1145
           "The variable you wish to histogram is a Matrix of dimension %d\n\
 
1146
 Please fill in the requested indices\n\
 
1147
 The format is 2,5....\n\Index numbering convention is assumed to be C",
 
1148
  BrowseUtil2htitle, nDim);
 
1149
        mcfioC_RemoveWhiteSpace(BrowseUtil2htitle);
 
1150
        for (i=0, t1=BrowseUtil2htitle; i<nDim; i++) {
 
1151
           valt = strtol(t1, &endPtr, 10);
 
1152
           if (strlen(BrowseUtil2htitle) == 0) {
 
1153
              DialogF(DF_ERR,OneDHistShellW, 1,
 
1154
               "Please Try again, we need integer numbers! ","Acknowledged");
 
1155
               goto tryagain;
 
1156
           }  else {
 
1157
             if ((valt < 1) || (valt > maxVal[i])) { 
 
1158
              DialogF(DF_ERR,OneDHistShellW, 1,
 
1159
              "Wrong Index Value\nWe need a number between 1 and %d",
 
1160
              "Acknowledged",maxVal[i]);
 
1161
               goto tryagain;
 
1162
              } else {
 
1163
                loc[i] = valt;
 
1164
                if (i != (nDim-1)) {
 
1165
                   if (*endPtr == '\0') {
 
1166
                       DialogF(DF_ERR,OneDHistShellW, 1,
 
1167
          "Please Try again, we need more integer numbers! ","Acknowledged");
 
1168
                       goto tryagain;
 
1169
                   }
 
1170
               t1 = endPtr; t1++;
 
1171
              }
 
1172
          }
 
1173
       }
 
1174
     }
 
1175
   }    
 
1176
}
 
1177
          
 
1178
          
 
1179
/*
 
1180
** setTimer - Set the timer
 
1181
*/
 
1182
static void setTimer(int timeInMillis)
 
1183
{
 
1184
    if (TimeOutID == 0) {
 
1185
        gettimeofday(&TimeSetTimeOut, NULL);
 
1186
        TimeOutTime = timeInMillis;
 
1187
        TimeOutID =
 
1188
          XtAppAddTimeOut(XtWidgetToApplicationContext(McfioMainPanelW),
 
1189
                            timeInMillis > 0 ? timeInMillis : 1, 
 
1190
                            (XtTimerCallbackProc)timerUpCB, NULL);
 
1191
    }
 
1192
    else {
 
1193
        cancelTimer();
 
1194
        setTimer(timeInMillis);
 
1195
    }
 
1196
}
 
1197
 
 
1198
/*
 
1199
** cancelTimer - Cancel the timer and reset timer variables.
 
1200
*/
 
1201
static void cancelTimer(void)
 
1202
{
 
1203
    if (TimeOutID != 0) {
 
1204
        XtRemoveTimeOut(TimeOutID);
 
1205
        TimeOutTime = 0;
 
1206
        TimeOutID = 0;
 
1207
        TimeSetTimeOut.tv_sec = 0;
 
1208
        TimeSetTimeOut.tv_usec = 0;
 
1209
    }
 
1210
}
 
1211
 
 
1212
/*
 
1213
** timerUpCB - Timer is up.  Reset timer variables and see if there are updates
 
1214
**           to request
 
1215
*/
 
1216
static void timerUpCB(void)
 
1217
{
 
1218
    TimeOutTime = 0;
 
1219
    TimeOutID = 0;
 
1220
    TimeSetTimeOut.tv_sec = 0;
 
1221
    TimeSetTimeOut.tv_usec = 0;
 
1222
 
 
1223
#ifdef HISTO
 
1224
    hs_update();
 
1225
#endif    
 
1226
    setTimer(500);
 
1227
}
 
1228