projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / tas / xtas / xtas_ctk_noise.c
1 /****************************************************************************/
2 /* */
3 /* Produit : XTAS Version 5 */
4 /* Fichier : xtas_ctk_noise.c */
5 /* */
6 /* Author(s) : Caroline BLED Date : 03/24/2003 */
7 /* */
8 /* */
9 /****************************************************************************/
10 #include "xtas.h"
11 #include "xtas_ctk_noise_menu.h"
12 #include "xtas_ctk_noise_button.h"
13 #include "xtas_stb_pbar.h"
14
15
16 #define XTAS_NOISE_NAME_MAX_LENGTH 50
17 #define XTAS_NOISE_NAME_MIN_LENGTH 11
18
19 #define XTAS_NOISE_LABEL_RANK_WIDTH_T 5*7 /* 7 = largeur moyenne d'un caractere */
20 #define XTAS_NOISE_LABEL_RANK_WIDTH_G 5*7 /* 7 = largeur moyenne d'un caractere */
21 #define XTAS_NOISE_LABEL_TRANS_WIDTH_T 5*7 /* Textual Display */
22 #define XTAS_NOISE_LABEL_TRANS_WIDTH_G 5*7 /* Graphical Display */
23 #define XTAS_NOISE_LABEL_NAMES_WIDTH_G 121
24 #define XTAS_NOISE_LABEL_MODEL_WIDTH_T 5*7
25 #define XTAS_NOISE_LABEL_MODEL_WIDTH_G 6*7
26 #define XTAS_NOISE_LABEL_NOISE_WIDTH_T 7*7
27 #define XTAS_NOISE_LABEL_NOISE_WIDTH_G 10*7
28 #define XTAS_NOISE_LABEL_SCORE_WIDTH_T 9*7
29 #define XTAS_NOISE_LABEL_SCORE_WIDTH_G 9*7
30 #define XTAS_NOISE_OFFSET_T 7
31 #define XTAS_NOISE_OFFSET_T2 3
32 #define XTAS_NOISE_OFFSET_G 3
33 #define XTAS_NOISE_OFFSET_GROUP_T 3*7
34 #define XTAS_NOISE_OFFSET_GROUP_G 7
35 #define XTAS_NOISE_LEFT_OFFSET_T 8
36 #define XTAS_NOISE_LEFT_OFFSET_G 8 /* offset a gauche pour le titre de la premiere colonne */
37
38 #define XTAS_NOISE_LABEL_OVR_UND_WIDTH_T ( XTAS_NOISE_LABEL_MODEL_WIDTH_T + \
39 2*XTAS_NOISE_LABEL_NOISE_WIDTH_T + \
40 2*XTAS_NOISE_OFFSET_T )
41
42 #define XTAS_NOISE_LABEL_OVR_UND_WIDTH_G ( XTAS_NOISE_LABEL_MODEL_WIDTH_G + \
43 2*XTAS_NOISE_LABEL_NOISE_WIDTH_G + \
44 2*XTAS_NOISE_OFFSET_G )
45
46 #define XTAS_NOISE_LABEL_SCORES_WIDTH_T ( 5*XTAS_NOISE_LABEL_SCORE_WIDTH_T + \
47 4*XTAS_NOISE_OFFSET_T)
48
49 #define XTAS_NOISE_LABEL_SCORES_WIDTH_G ( 5*XTAS_NOISE_LABEL_SCORE_WIDTH_G + \
50 4*XTAS_NOISE_OFFSET_G)
51
52 #define XTAS_NOISE_WINDOW_WIDTH_T XTAS_NOISE_LEFT_OFFSET_T + \
53 XTAS_NOISE_LABEL_RANK_WIDTH_T + \
54 XTAS_NOISE_LABEL_TRANS_WIDTH_T + \
55 2*XTAS_NOISE_LABEL_OVR_UND_WIDTH_T + \
56 XTAS_NOISE_LABEL_SCORES_WIDTH_T + \
57 3*XTAS_NOISE_OFFSET_T + \
58 4*XTAS_NOISE_OFFSET_GROUP_T + \
59 40 /* ecart fixe a droite du tableau pour
60 le voir entierement */
61
62 #define XTAS_NOISE_WINDOW_WIDTH_G XTAS_NOISE_LEFT_OFFSET_G + \
63 XTAS_NOISE_LABEL_RANK_WIDTH_G + \
64 XTAS_NOISE_LABEL_TRANS_WIDTH_G + \
65 XTAS_NOISE_LABEL_NAMES_WIDTH_G + \
66 2*XTAS_NOISE_LABEL_OVR_UND_WIDTH_G + \
67 XTAS_NOISE_LABEL_SCORES_WIDTH_G + \
68 2*XTAS_NOISE_OFFSET_G + \
69 4*XTAS_NOISE_OFFSET_GROUP_G + \
70 40 /* ecart fixe a droite du tableau pour
71 le voir entierement */
72
73 #define XTAS_NOISE_SORTBUTTON_WIDTH_G (( XTAS_NOISE_LABEL_RANK_WIDTH_G + \
74 XTAS_NOISE_LABEL_TRANS_WIDTH_G + \
75 XTAS_NOISE_LABEL_NAMES_WIDTH_G + \
76 XTAS_NOISE_OFFSET_GROUP_G ) / 2)
77
78 #define XTAS_NOISE_SORTBUTTON_WIDTH_T (( XTAS_NOISE_LABEL_RANK_WIDTH_T + \
79 XTAS_NOISE_LABEL_TRANS_WIDTH_T + \
80 2*XTAS_NOISE_OFFSET_GROUP_T ) / 2)
81
82
83
84 #define XTAS_NOISE_NO_SELECT -1
85
86 #define XTAS_CTK_OFFSET 2
87
88 static int XTAS_NOISE_MAX_NBSIG_WINDOW;
89
90 Widget XtasNoiseParamWidget = NULL;
91 Widget XtasNoiseResultsWidget = NULL;
92 Widget XtasNoiseScoresWidget = NULL;
93 stb_ctk_stat *XtasNoiseTab = NULL;
94 int XtasNoiseLabelSigNameLength = XTAS_NOISE_NAME_MIN_LENGTH ;
95 int XtasNoiseLabelNetNameLength = XTAS_NOISE_NAME_MIN_LENGTH ;
96 int XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
97 int XtasNoiseCurrentTopIndex = 0;
98
99
100 /* functions prototypes */
101 void XtasNoiseFillGraphicalList ( int new, Widget widget, XtasWindowStruct *win_struct);
102 void XtasUpdateNoiseTextualScrollList (Widget list);
103
104
105 /*---------------------------------------------------------------------------*/
106 /* */
107 /* FUNCTION : XtasNoiseColumnsTitleMoveWithHSBCallback */
108 /* */
109 /* IN ARGS : .parent : The widget on which the event occurs. */
110 /* .client_data : */
111 /* .cbs : Toolkit informations. */
112 /* */
113 /* OUT ARGS : ( void ) */
114 /* */
115 /* OBJECT : The callback function for the button "OK" of Crosstalk */
116 /* informations window. */
117 /* */
118 /*---------------------------------------------------------------------------*/
119 void XtasNoiseColumnsTitleMoveWithHSBCallback (hsb, label, call_data)
120 Widget hsb;
121 XtPointer label;
122 XtPointer call_data;
123 {
124 int loffset ;
125 int value;
126
127 if (XTAS_DISPLAY_NEW == 0)
128 loffset = XTAS_NOISE_LEFT_OFFSET_G;
129 else
130 loffset = XTAS_NOISE_LEFT_OFFSET_T;
131
132 XtVaGetValues (hsb, XmNvalue, &value, NULL);
133
134 XtVaSetValues (label, XmNleftOffset, (loffset - value), NULL);
135
136 }
137
138
139 /*---------------------------------------------------------------------------*/
140 /* */
141 /* FUNCTION : XtasNoiseScoreOkCallback */
142 /* */
143 /* IN ARGS : .parent : The widget on which the event occurs. */
144 /* .client_data : */
145 /* .cbs : Toolkit informations. */
146 /* */
147 /* OUT ARGS : ( void ) */
148 /* */
149 /* OBJECT : The callback function for the button "OK" of Crosstalk */
150 /* informations window. */
151 /* */
152 /*---------------------------------------------------------------------------*/
153 void XtasNoiseScoreOkCallback (parent, client_data, call_data)
154 Widget parent;
155 XtPointer client_data;
156 XtPointer call_data;
157 {
158 Widget spinbox, scroll;
159 int pos_coef_noise, pos_coef_interval, pos_coef_ctk, pos_coef_activity;
160 int pos_min_noise, pos_min_interval, pos_min_ctk, pos_min_activity;
161 XtasWindowStruct *tas_winfos = (XtasWindowStruct *)client_data;
162 char *text, *ptend;
163 Widget pan_widget, label;
164 int nb, i;
165 WidgetList widget_list;
166
167 #if XTAS_MOTIF_VERSION >= 20100
168 /**** Spin Boxes ****/
169 /* noise update */
170 spinbox = XtNameToWidget (parent, "*XtasNoiseCoefBox");
171 XtVaGetValues (spinbox, XmNposition, &pos_coef_noise, NULL);
172 spinbox = XtNameToWidget (parent, "*XtasNoiseMinBox");
173 XtVaGetValues (spinbox, XmNposition, &pos_min_noise, NULL);
174
175 /* interval update */
176 spinbox = XtNameToWidget (parent, "*XtasIntervalCoefBox");
177 XtVaGetValues (spinbox, XmNposition, &pos_coef_interval, NULL);
178 spinbox = XtNameToWidget (parent, "*XtasIntervalMinBox");
179 XtVaGetValues (spinbox, XmNposition, &pos_min_interval, NULL);
180
181 /* crosstalk update */
182 spinbox = XtNameToWidget (parent, "*XtasCtkCoefBox");
183 XtVaGetValues (spinbox, XmNposition, &pos_coef_ctk, NULL);
184 spinbox = XtNameToWidget (parent, "*XtasCtkMinBox");
185 XtVaGetValues (spinbox, XmNposition, &pos_min_ctk, NULL);
186
187 /* activity update */
188 spinbox = XtNameToWidget (parent, "*XtasActivityCoefBox");
189 XtVaGetValues (spinbox, XmNposition, &pos_coef_activity, NULL);
190 spinbox = XtNameToWidget (parent, "*XtasActivityMinBox");
191 XtVaGetValues (spinbox, XmNposition, &pos_min_activity, NULL);
192 #else
193 /**** Text Boxes **** -> il faut verifier la valeur */
194 /* noise update */
195 text = XmTextGetString (XtNameToWidget (parent, "*XtasNoiseCoefBox"));
196 if (text) {
197 pos_coef_noise = strtol( text, &ptend, 10);
198 if((*ptend != '\0')||(pos_coef_noise < 0)||(pos_coef_noise > 10)) {
199 XtFree (text);
200 XtManageChild (XtasNoiseScoresWidget);
201 XalDrawMessage(XtasErrorWidget, "Bad value for Noise Coef.\nMust be a positive integer between 0 and 10." );
202 return ;
203 }
204 XtFree (text);
205 }
206 text = XmTextGetString (XtNameToWidget (parent, "*XtasNoiseMinBox"));
207 if (text) {
208 pos_min_noise = strtol( text, &ptend, 10);
209 if((*ptend != '\0')||(pos_min_noise < 0)||(pos_coef_noise > 10)) {
210 XtFree (text);
211 XtManageChild (XtasNoiseScoresWidget);
212 XalDrawMessage(XtasErrorWidget, "Bad value for Noise Min.\nMust be a positive integer between 0 and 10." );
213 return ;
214 }
215 XtFree (text);
216 }
217
218 /* interval update */
219 text = XmTextGetString (XtNameToWidget (parent, "*XtasIntervalCoefBox"));
220 if (text) {
221 pos_coef_interval = strtol( text, &ptend, 10);
222 if((*ptend != '\0')||(pos_coef_interval < 0)||(pos_coef_noise > 10)) {
223 XtFree (text);
224 XtManageChild (XtasNoiseScoresWidget);
225 XalDrawMessage(XtasErrorWidget, "Bad value for Interval Coef.\nMust be a positive integer between 0 and 10." );
226 return ;
227 }
228 XtFree (text);
229 }
230 text = XmTextGetString (XtNameToWidget (parent, "*XtasIntervalMinBox"));
231 if (text) {
232 pos_min_interval = strtol( text, &ptend, 10);
233 if((*ptend != '\0')||(pos_min_interval < 0)||(pos_coef_noise > 10)) {
234 XtFree (text);
235 XtManageChild (XtasNoiseScoresWidget);
236 XalDrawMessage(XtasErrorWidget, "Bad value for Interval Min.\nMust be a positive integer between 0 and 10." );
237 return ;
238 }
239 XtFree (text);
240 }
241
242 /* crosstalk update */
243 text = XmTextGetString (XtNameToWidget (parent, "*XtasCtkCoefBox"));
244 if (text) {
245 pos_coef_ctk = strtol( text, &ptend, 10);
246 if((*ptend != '\0')||(pos_coef_ctk < 0)||(pos_coef_noise > 10)) {
247 XtFree (text);
248 XtManageChild (XtasNoiseScoresWidget);
249 XalDrawMessage(XtasErrorWidget, "Bad value for Crosstalk Coef.\nMust be a positive integer between 0 and 10." );
250 return ;
251 }
252 XtFree (text);
253 }
254 text = XmTextGetString (XtNameToWidget (parent, "*XtasCtkMinBox"));
255 if (text) {
256 pos_min_ctk = strtol( text, &ptend, 10);
257 if((*ptend != '\0')||(pos_min_ctk < 0)||(pos_coef_noise > 10)) {
258 XtFree (text);
259 XtManageChild (XtasNoiseScoresWidget);
260 XalDrawMessage(XtasErrorWidget, "Bad value for Crosstalk Min.\nMust be a positive integer between 0 and 10." );
261 return ;
262 }
263 XtFree (text);
264 }
265
266 /* activity update */
267 text = XmTextGetString (XtNameToWidget (parent, "*XtasActivityCoefBox"));
268 if (text) {
269 pos_coef_activity = strtol( text, &ptend, 10);
270 if((*ptend != '\0')||(pos_coef_activity < 0)||(pos_coef_noise > 10)) {
271 XtFree (text);
272 XtManageChild (XtasNoiseScoresWidget);
273 XalDrawMessage(XtasErrorWidget, "Bad value for Interval Coef.\nMust be a positive integer between 0 and 10." );
274 return ;
275 }
276 XtFree (text);
277 }
278 text = XmTextGetString (XtNameToWidget (parent, "*XtasActivityMinBox"));
279 if (text) {
280 pos_min_activity = strtol( text, &ptend, 10);
281 if((*ptend != '\0')||(pos_min_activity < 0)||(pos_coef_noise > 10)) {
282 XtFree (text);
283 XtManageChild (XtasNoiseScoresWidget);
284 XalDrawMessage(XtasErrorWidget, "Bad value for Noise Min.\nMust be a positive integer. between 0 and 10" );
285 return ;
286 }
287 XtFree (text);
288 }
289 #endif
290
291 stb_ctk_set_coef_score (pos_coef_noise, pos_coef_ctk, pos_coef_interval, pos_coef_activity);
292 stb_ctk_set_min_score (pos_min_noise, pos_min_ctk, pos_min_interval, pos_min_activity);
293 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_TOTAL);
294 if (XTAS_DISPLAY_NEW == 0) {
295 scroll = XtNameToWidget ((Widget)tas_winfos->wrkwidget, "*XtasScrollNoiseWidget");
296 // if (!scroll) {
297 // pan_widget = XtNameToWidget ((Widget)tas_winfos->wrkwidget, "*XtasPanWindow");
298 // XtVaGetValues (pan_widget, XmNnumChildren, &nb, XmNchildren, &widget_list, NULL);
299 //// for (i=0 ; i<nb ; i++)
300 //// XtDestroyWidget (widget_list[i]);
301 // XtDestroyWidget (widget_list[0]);
302 // label = XtNameToWidget ((Widget)tas_winfos->wrkwidget, "*XtasTitlesInsideAlimMax");
303 // if (pan_widget && label)
304 // XtasCreateNoiseGraphicalScrollList (pan_widget, tas_winfos, label);
305 // }
306 // else
307 XtasNoiseTreatTopCallback (NULL, (XtPointer)scroll, NULL);
308 }
309 else {
310 scroll = XtNameToWidget ((Widget)tas_winfos->wrkwidget, "*XtasTextualDisplay");
311 XtasUpdateNoiseTextualScrollList (scroll);
312 }
313
314 }
315
316 /*---------------------------------------------------------------------------*/
317 /* */
318 /* FUNCTION : XtasNoiseScoreConfigCallback */
319 /* */
320 /* IN ARGS : .parent : The widget on which the event occurs. */
321 /* .client_data : */
322 /* .cbs : Toolkit informations. */
323 /* */
324 /* OUT ARGS : ( void ) */
325 /* */
326 /* OBJECT : The callback function for the button "OK" of Crosstalk */
327 /* informations window. */
328 /* */
329 /*---------------------------------------------------------------------------*/
330 void XtasNoiseScoreConfigCallback (parent, client_data, call_data)
331 Widget parent;
332 XtPointer client_data;
333 XtPointer call_data;
334 {
335 Arg args[10];
336 int n;
337 char *spinname, *tname;
338 Widget row, frame_form, form, formsb, label, spinbox, spin_TF;
339 Atom WM_DELETE_WINDOW;
340 XmString text;
341 char buf[64];
342
343 if (!XtasNoiseScoresWidget) {
344 n = 0;
345 XtSetArg ( args[n], XmNtitle, XTAS_NAME": Scores Configuration" ); n++;
346 XtSetArg ( args[n], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); n++;
347 XtSetArg( args[n], XmNwidth, 255) ; n++ ;
348 XtasNoiseScoresWidget = XmCreatePromptDialog(XtasNoiseResultsWidget, "XtasInfosBox",args, n) ;
349 HelpFather = XtasNoiseScoresWidget;
350 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseScoresWidget,XmDIALOG_TEXT)) ;
351 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseScoresWidget,XmDIALOG_PROMPT_LABEL)) ;
352 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseScoresWidget,XmDIALOG_HELP_BUTTON)) ;
353 XtAddCallback( XtasNoiseScoresWidget, XmNokCallback, XtasNoiseScoreOkCallback, (XtPointer)client_data ) ;
354 XtAddCallback( XtasNoiseScoresWidget, XmNcancelCallback, XtasCancelCallback, (XtPointer)XtasNoiseScoresWidget ) ;
355 // XtAddCallback( XtasNoiseScoresWidget, XmNhelpCallback, XtasHelpCallback, (XtPointer)(XTAS_HELP_MAIN|)) ;
356 WM_DELETE_WINDOW = XmInternAtom(XtDisplay(XtasNoiseResultsWidget), "WM_DELETE_WINDOW", False);
357 XmAddWMProtocolCallback(XtParent(XtasNoiseScoresWidget), WM_DELETE_WINDOW, XtasCancelCallback, (XtPointer )XtasNoiseScoresWidget);
358
359
360 n = 0;
361 frame_form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, XtasNoiseScoresWidget, args, n ) ;
362
363 n = 0;
364 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
365 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
366 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
367 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, frame_form, args, n ) ;
368
369 text = XmStringCreateSimple( "MIN" ) ;
370 n = 0;
371 XtSetArg ( args[n], XmNlabelString, text ); n++;
372 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
373 XtSetArg ( args[n], XmNrightOffset, 3 ); n++;
374 XtSetArg ( args[n], XmNwidth, 54 ); n++;
375 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
376
377 text = XmStringCreateSimple( "COEF" ) ;
378 n = 0;
379 XtSetArg ( args[n], XmNlabelString, text ); n++;
380 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
381 XtSetArg ( args[n], XmNrightWidget, label ); n++;
382 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
383 XtSetArg ( args[n], XmNwidth, 54 ); n++;
384 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
385
386 text = XmStringCreateSimple( " " ) ;
387 n = 0;
388 XtSetArg ( args[n], XmNlabelString, text ); n++;
389 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
390 XtSetArg ( args[n], XmNrightWidget, label ); n++;
391 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
392 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
393
394 n = 0;
395 row = XtVaCreateManagedWidget( "XtasRow", xmRowColumnWidgetClass, frame_form, XmNtopAttachment, XmATTACH_WIDGET,
396 XmNtopWidget, form,
397 XmNleftAttachment, XmATTACH_FORM,
398 XmNrightAttachment, XmATTACH_FORM,
399 XmNbottomAttachment,XmATTACH_FORM,
400 XmNpacking, XmPACK_COLUMN,
401 XmNnumColumns, 1,
402 XmNorientation, XmVERTICAL,
403 XmNisAligned, True,
404 NULL) ;
405
406 /* Noise Score */
407 n = 0;
408 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, row, args, n ) ;
409
410 n = 0;
411 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
412 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
413 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
414 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
415
416 #if XTAS_MOTIF_VERSION >= 20100
417 n = 0;
418 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
419 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
420 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
421 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
422 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
423 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
424 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
425 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
426 XtSetArg ( args[n], XmNposition, stb_ctk_get_min_noise() ); n++;
427 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
428 spinbox = XtCreateManagedWidget ("XtasNoiseMinBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
429 spinname = XtName (spinbox);
430 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
431 sprintf (tname, "%s_TF", spinname);
432 spin_TF = XtNameToWidget (spinbox, tname);
433 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
434 XtFree (tname); tname = NULL;
435 #else
436 n = 0;
437 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
438 XtSetArg ( args[n], XmNwidth, 55 ); n++;
439 XtSetArg ( args[n], XmNeditable, True ); n++;
440 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
441 spinbox = XtCreateManagedWidget ("XtasNoiseMinBox", xmTextWidgetClass, formsb, args, n);
442 sprintf (buf, "%d", stb_ctk_get_min_noise());
443 XmTextSetString (spinbox, buf);
444 #endif
445
446 n = 0;
447 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
448 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
449 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
450 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
451 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
452 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
453
454
455 #if XTAS_MOTIF_VERSION >= 20100
456 n = 0;
457 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
458 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
459 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
460 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
461 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
462 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
463 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
464 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
465 XtSetArg ( args[n], XmNposition, stb_ctk_get_coef_noise() ); n++;
466 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
467 spinbox = XtCreateManagedWidget ("XtasNoiseCoefBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
468 spinname = XtName (spinbox);
469 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
470 sprintf (tname, "%s_TF", spinname);
471 spin_TF = XtNameToWidget (spinbox, tname);
472 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
473 XtFree (tname); tname = NULL;
474 #else
475 n = 0;
476 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
477 XtSetArg ( args[n], XmNwidth, 55 ); n++;
478 XtSetArg ( args[n], XmNeditable, True ); n++;
479 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
480 spinbox = XtCreateManagedWidget ("XtasNoiseCoefBox", xmTextWidgetClass, formsb, args, n);
481 sprintf (buf, "%d", stb_ctk_get_coef_noise());
482 XmTextSetString (spinbox, buf);
483 #endif
484
485 text = XmStringCreateSimple( "Noise" ) ;
486 n = 0;
487 XtSetArg ( args[n], XmNlabelString, text ); n++;
488 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
489 XtSetArg ( args[n], XmNtopWidget, formsb ); n++;
490 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_OPPOSITE_WIDGET ); n++;
491 XtSetArg ( args[n], XmNbottomWidget, formsb ); n++;
492 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
493 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
494 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
495 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
496 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
497
498
499 /* Interval Score */
500 n = 0;
501 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, row, args, n ) ;
502
503 n = 0;
504 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
505 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
506 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
507 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
508
509 #if XTAS_MOTIF_VERSION >= 20100
510 n = 0;
511 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
512 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
513 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
514 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
515 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
516 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
517 XtSetArg ( args[n], XmNeditable, False ); n++;
518 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
519 XtSetArg ( args[n], XmNposition, stb_ctk_get_min_interval() ); n++;
520 XtSetArg ( args[n], XmNwrap, False ); n++;
521 spinbox = XtCreateManagedWidget ("XtasIntervalMinBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
522 spinname = XtName (spinbox);
523 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
524 sprintf (tname, "%s_TF", spinname);
525 spin_TF = XtNameToWidget (spinbox, tname);
526 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
527 XtFree (tname);
528 #else
529 n = 0;
530 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
531 XtSetArg ( args[n], XmNwidth, 55 ); n++;
532 XtSetArg ( args[n], XmNeditable, True ); n++;
533 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
534 spinbox = XtCreateManagedWidget ("XtasIntervalMinBox", xmTextWidgetClass, formsb, args, n);
535 sprintf (buf, "%d", stb_ctk_get_min_interval());
536 XmTextSetString (spinbox, buf);
537 #endif
538
539 n = 0;
540 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
541 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
542 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
543 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
544 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
545 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
546
547 #if XTAS_MOTIF_VERSION >= 20100
548 n = 0;
549 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
550 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
551 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
552 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
553 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
554 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
555 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
556 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
557 XtSetArg ( args[n], XmNposition, stb_ctk_get_coef_interval() ); n++;
558 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
559 spinbox = XtCreateManagedWidget ("XtasIntervalCoefBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
560 spinname = XtName (spinbox);
561 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
562 sprintf (tname, "%s_TF", spinname);
563 spin_TF = XtNameToWidget (spinbox, tname);
564 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
565 XtFree (tname); tname = NULL;
566 #else
567 n = 0;
568 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
569 XtSetArg ( args[n], XmNwidth, 55 ); n++;
570 XtSetArg ( args[n], XmNeditable, True ); n++;
571 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
572 spinbox = XtCreateManagedWidget ("XtasIntervalCoefBox", xmTextWidgetClass, formsb, args, n);
573 sprintf (buf, "%d", stb_ctk_get_coef_interval());
574 XmTextSetString (spinbox, buf);
575 #endif
576
577 text = XmStringCreateSimple( "Interval" ) ;
578 n = 0;
579 XtSetArg ( args[n], XmNlabelString, text ); n++;
580 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
581 XtSetArg ( args[n], XmNtopWidget, formsb ); n++;
582 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_OPPOSITE_WIDGET ); n++;
583 XtSetArg ( args[n], XmNbottomWidget, formsb ); n++;
584 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
585 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
586 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
587 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
588 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
589
590 /* Crosstalk Score */
591 n = 0;
592 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, row, args, n ) ;
593
594 n = 0;
595 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
596 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
597 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
598 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
599
600 #if XTAS_MOTIF_VERSION >= 20100
601 n = 0;
602 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
603 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
604 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
605 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
606 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
607 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
608 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
609 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
610 XtSetArg ( args[n], XmNposition, stb_ctk_get_min_ctk() ); n++;
611 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
612 spinbox = XtCreateManagedWidget ("XtasCtkMinBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
613 spinname = XtName (spinbox);
614 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
615 sprintf (tname, "%s_TF", spinname);
616 spin_TF = XtNameToWidget (spinbox, tname);
617 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
618 XtFree (tname);
619 #else
620 n = 0;
621 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
622 XtSetArg ( args[n], XmNwidth, 55 ); n++;
623 XtSetArg ( args[n], XmNeditable, True ); n++;
624 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
625 spinbox = XtCreateManagedWidget ("XtasCtkMinBox", xmTextWidgetClass, formsb, args, n);
626 sprintf (buf, "%d", stb_ctk_get_min_ctk());
627 XmTextSetString (spinbox, buf);
628 #endif
629
630 n = 0;
631 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
632 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
633 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
634 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
635 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
636 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
637
638 #if XTAS_MOTIF_VERSION >= 20100
639 n = 0;
640 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
641 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
642 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
643 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
644 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
645 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
646 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
647 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
648 XtSetArg ( args[n], XmNposition, stb_ctk_get_coef_ctk() ); n++;
649 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
650 spinbox = XtCreateManagedWidget ("XtasCtkCoefBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
651 spinname = XtName (spinbox);
652 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
653 sprintf (tname, "%s_TF", spinname);
654 spin_TF = XtNameToWidget (spinbox, tname);
655 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
656 XtFree (tname); tname = NULL;
657 #else
658 n = 0;
659 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
660 XtSetArg ( args[n], XmNwidth, 55 ); n++;
661 XtSetArg ( args[n], XmNeditable, True ); n++;
662 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
663 spinbox = XtCreateManagedWidget ("XtasCtkCoefBox", xmTextWidgetClass, formsb, args, n);
664 sprintf (buf, "%d", stb_ctk_get_coef_ctk());
665 XmTextSetString (spinbox, buf);
666 #endif
667
668 text = XmStringCreateSimple( "Crosstalk" ) ;
669 n = 0;
670 XtSetArg ( args[n], XmNlabelString, text ); n++;
671 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
672 XtSetArg ( args[n], XmNtopWidget, formsb ); n++;
673 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_OPPOSITE_WIDGET ); n++;
674 XtSetArg ( args[n], XmNbottomWidget, formsb ); n++;
675 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
676 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
677 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
678 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
679 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
680
681 /* Activity Score */
682 n = 0;
683 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, row, args, n ) ;
684
685 n = 0;
686 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
687 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
688 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
689 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
690
691 #if XTAS_MOTIF_VERSION >= 20100
692 n = 0;
693 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
694 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
695 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
696 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
697 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
698 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
699 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
700 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
701 XtSetArg ( args[n], XmNposition, stb_ctk_get_min_activity() ); n++;
702 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
703 spinbox = XtCreateManagedWidget ("XtasActivityMinBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
704 spinname = XtName (spinbox);
705 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
706 sprintf (tname, "%s_TF", spinname);
707 spin_TF = XtNameToWidget (spinbox, tname);
708 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
709 XtFree (tname);
710 #else
711 n = 0;
712 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
713 XtSetArg ( args[n], XmNwidth, 55 ); n++;
714 XtSetArg ( args[n], XmNeditable, True ); n++;
715 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
716 spinbox = XtCreateManagedWidget ("XtasActivityMinBox", xmTextWidgetClass, formsb, args, n);
717 sprintf (buf, "%d", stb_ctk_get_min_activity());
718 XmTextSetString (spinbox, buf);
719 #endif
720
721 n = 0;
722 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
723 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
724 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
725 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
726 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
727 formsb = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, form, args, n ) ;
728
729 #if XTAS_MOTIF_VERSION >= 20100
730 n = 0;
731 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
732 XtSetArg ( args[n], XmNcolumns, 2 ); n++;
733 XtSetArg ( args[n], XmNspinBoxChildType,XmNUMERIC ); n++;
734 XtSetArg ( args[n], XmNminimumValue, 0 ); n++;
735 XtSetArg ( args[n], XmNmaximumValue, 10 ); n++;
736 XtSetArg ( args[n], XmNincrementValue, 1 ); n++;
737 XtSetArg ( args[n], XmNeditable, FALSE ); n++;
738 XtSetArg ( args[n], XmNpositionType, XmPOSITION_VALUE ); n++;
739 XtSetArg ( args[n], XmNposition, stb_ctk_get_coef_activity() ); n++;
740 XtSetArg ( args[n], XmNwrap, FALSE ); n++;
741 spinbox = XtCreateManagedWidget ("XtasActivityCoefBox", xmSimpleSpinBoxWidgetClass, formsb, args, n);
742 spinname = XtName (spinbox);
743 tname = XtMalloc ((unsigned) strlen (spinname) + 4);
744 sprintf (tname, "%s_TF", spinname);
745 spin_TF = XtNameToWidget (spinbox, tname);
746 XtVaSetValues (spin_TF, XmNcursorPositionVisible, False, NULL);
747 XtFree (tname); tname = NULL;
748 #else
749 n = 0;
750 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
751 XtSetArg ( args[n], XmNwidth, 55 ); n++;
752 XtSetArg ( args[n], XmNeditable, True ); n++;
753 XtSetArg ( args[n], XmNcursorPositionVisible, True ); n++;
754 spinbox = XtCreateManagedWidget ("XtasActivityCoefBox", xmTextWidgetClass, formsb, args, n);
755 sprintf (buf, "%d", stb_ctk_get_coef_activity());
756 XmTextSetString (spinbox, buf);
757 #endif
758
759 text = XmStringCreateSimple( "Activity" ) ;
760 n = 0;
761 XtSetArg ( args[n], XmNlabelString, text ); n++;
762 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
763 XtSetArg ( args[n], XmNtopWidget, formsb ); n++;
764 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_OPPOSITE_WIDGET ); n++;
765 XtSetArg ( args[n], XmNbottomWidget, formsb ); n++;
766 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
767 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
768 XtSetArg ( args[n], XmNrightWidget, formsb ); n++;
769 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
770 label = XtCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form, args, n ) ;
771
772
773 }
774
775 XtManageChild (XtasNoiseScoresWidget);
776 }
777
778
779 /*---------------------------------------------------------------------------*/
780 /* */
781 /* FUNCTION : XtasCtkInfoOkCallback */
782 /* */
783 /* IN ARGS : .parent : The widget on which the event occurs. */
784 /* .client_data : */
785 /* .cbs : Toolkit informations. */
786 /* */
787 /* OUT ARGS : ( void ) */
788 /* */
789 /* OBJECT : The callback function for the button "OK" of Crosstalk */
790 /* informations window. */
791 /* */
792 /*---------------------------------------------------------------------------*/
793 void XtasCtkInfoOkCallback(parent, client_data, call_data)
794 Widget parent;
795 XtPointer client_data ;
796 XtPointer call_data ;
797 {
798 XtDestroyWidget( (Widget)client_data ) ;
799 }
800
801 /*---------------------------------------------------------------------------*/
802 /* */
803 /* FUNCTION : XtasCtkInfoOkCallback */
804 /* */
805 /* IN ARGS : .parent : The widget on which the event occurs. */
806 /* .client_data : */
807 /* .cbs : Toolkit informations. */
808 /* */
809 /* OUT ARGS : ( void ) */
810 /* */
811 /* OBJECT : The callback function for the button "OK" of Crosstalk */
812 /* informations window. */
813 /* */
814 /*---------------------------------------------------------------------------*/
815 int XtasSortAgrList (stb_ctk_detail_agr_list **p1, stb_ctk_detail_agr_list **p2)
816 {
817 if ((*p1)->CC > (*p2)->CC) return -1;
818 if ((*p1)->CC < (*p2)->CC) return +1;
819 return 0;
820 }
821
822 void XtasFillAgressorsList(agr_list, nb_agr, list_widget, length1, length2)
823 stb_ctk_detail_agr_list *agr_list;
824 int nb_agr;
825 Widget list_widget;
826 int length1;
827 int length2;
828 {
829 stb_ctk_detail_agr_list *p;
830 char textline[2048];
831 char *name;
832 char *netname;
833 char b, w, r, f;
834 XmString text;
835 int c;
836
837 stb_ctk_detail_agr_list **tab;
838
839 XmListDeleteAllItems(list_widget) ;
840
841
842 if(agr_list == NULL) {
843 text = XmStringCreateSimple ("no aggressor") ;
844 XmListAddItemUnselected (list_widget, text, c) ;
845 XmStringFree (text) ;
846 }
847
848 tab = (stb_ctk_detail_agr_list**)mbkalloc(sizeof(stb_ctk_detail_agr_list*)*nb_agr);
849
850 for ( c=0, p=agr_list ; p ; p=p->NEXT, c++)
851 tab[c] = p;
852
853 qsort (tab, nb_agr, sizeof(stb_ctk_detail_agr_list*), (int (*)(const void *, const void*))XtasSortAgrList);
854
855 for ( c = 0 ; c < nb_agr ; c++) {
856 if(tab[c]->TTVAGR)
857 name = XtasPlaceString(tab[c]->TTVAGR->NAME,length1);
858 else
859 name = XtasPlaceString("",length1);
860
861 netname = XtasPlaceString(tab[c]->NETNAME,length2);
862
863 if( tab[c]->ACT_WORST )
864 w='W';
865 else {
866 if( tab[c]->ACT_MUTEX_WORST )
867 w='w';
868 else
869 w=' ';
870 }
871
872 if( tab[c]->ACT_BEST )
873 b='B';
874 else {
875 if( tab[c]->ACT_MUTEX_BEST )
876 b='b';
877 else
878 b=' ';
879 }
880
881 if( tab[c]->NOISE_RISE_PEAK )
882 r='R';
883 else {
884 if( tab[c]->NOISE_RISE_EXCLUDED )
885 r='r';
886 else
887 r=' ';
888 }
889
890 if( tab[c]->NOISE_FALL_PEAK )
891 f='F';
892 else {
893 if( tab[c]->NOISE_FALL_EXCLUDED )
894 f='f';
895 else
896 f=' ';
897 }
898
899 sprintf(textline,"%s %s %c%c%c%c %.3ffF",name, netname, b, w, r, f, ((tab[c]->CC)*1000.0));
900 mbkfree(name);
901 mbkfree(netname);
902
903 text = XmStringCreateSimple (textline) ;
904 XmListAddItemUnselected (list_widget, text, c+1) ;
905 XmStringFree (text) ;
906
907 }
908 mbkfree(tab);
909
910 }
911
912 /*---------------------------------------------------------------------------*/
913 /* */
914 /* FUNCTION : XtasCtkInfoDetailCallback */
915 /* */
916 /* IN ARGS : .parent : The parent widget id. */
917 /* .path_detail : The path detail description. */
918 /* */
919 /* OUT ARGS : ( void ) */
920 /* */
921 /* OBJECT : Creation de la liste des erreurs de stabilite */
922 /* */
923 /*---------------------------------------------------------------------------*/
924 void XtasCtkInfoDetailCallback(parent, client_data, call_data)
925 Widget parent;
926 XtPointer client_data;
927 XtPointer call_data;
928 {
929 XmListCallbackStruct *cbs = (XmListCallbackStruct *)call_data ;
930 Widget widget = (Widget)client_data;
931 char *s;
932 char *item;
933
934 XalSetCursor( widget, WAIT );
935 XalForceUpdate( widget );
936
937 XmStringGetLtoR( cbs->item, XmSTRING_DEFAULT_CHARSET, &item );
938 s = strchr (item, ' ');
939 if (s) *s = '\0';
940 if (strlen(item) != 0)
941 XtasSignalsDetail( widget, item);
942 else
943 XalDrawMessage (XtasErrorWidget, "Cannot display information on signal: no signame.");
944 XalSetCursor( widget, NORMAL );
945 }
946
947
948
949 /*---------------------------------------------------------------------------*/
950 /* */
951 /* FUNCTION : XtasCtkInfoColumnsTitleMoveWithHSBCallback */
952 /* */
953 /* IN ARGS : .parent : The parent widget. */
954 /* .client_data : */
955 /* .call_data : Toolkit informations. */
956 /* */
957 /* OUT ARGS : ( void ) */
958 /* */
959 /* OBJECT : */
960 /* */
961 /*---------------------------------------------------------------------------*/
962 void XtasCtkInfoColumnsTitleMoveWithHSBCallback( hsb, label, call_data)
963 Widget hsb;
964 XtPointer label;
965 XtPointer call_data;
966 {
967 int loffset ;
968 int value;
969
970 loffset = XTAS_CTK_OFFSET;
971
972 XtVaGetValues (hsb, XmNvalue, &value, NULL);
973
974 XtVaSetValues ((Widget)label, XmNleftOffset, (loffset - value), NULL);
975
976 }
977
978 int XtasAlphaStrCmp (char **s1, char **s2)
979 {
980 return strcmp(*s1, *s2);
981 }
982
983 int XtasReverseAlphaStrCmp (char **s1, char **s2)
984 {
985 return strcmp(*s2, *s1);
986 }
987
988 int XtasAscendCapaValueCmp (char **s1, char **s2)
989 {
990 char *c, *end;
991 float f1, f2;
992
993 c = strrchr (*s1, ' ');
994 f1 = strtod (c, &end);
995 c = strrchr (*s2, ' ');
996 f2 = strtod (c, &end);
997
998 if (f1<f2) return -1;
999 if (f1>f2) return +1;
1000 return 0;
1001 }
1002 int XtasDescendCapaValueCmp (char **s1, char **s2)
1003 {
1004 char *c, *end;
1005 float f1, f2;
1006
1007 c = strrchr (*s1, ' ');
1008 f1 = strtod (c, &end);
1009 c = strrchr (*s2, ' ');
1010 f2 = strtod (c, &end);
1011
1012 if (f1>f2) return -1;
1013 if (f1<f2) return +1;
1014 return 0;
1015 }
1016
1017 void XtasCtkInfoSortByNameCallback (parent, list_w, call_data)
1018 Widget parent;
1019 XtPointer list_w;
1020 XtPointer call_data;
1021 {
1022 char **tabagressors;
1023 char *buf;
1024 int i, c;
1025
1026 XmStringTable itemTable;
1027 XmString motif_string;
1028 static int click = -1;
1029 Widget Arrow;
1030
1031 XtVaGetValues (list_w, XmNitems, &itemTable, XmNitemCount, &c, NULL);
1032 click = -click;
1033
1034 tabagressors = (char**)mbkalloc (sizeof(char *)*c);
1035
1036 for (i=0 ; i<c ; i++) {
1037 XmStringGetLtoR( itemTable[i], XmSTRING_DEFAULT_CHARSET, &tabagressors[i] );
1038 }
1039
1040 if (click > 0) {
1041 qsort( tabagressors, c, sizeof(char*), (int (*)(const void*, const void*))XtasAlphaStrCmp);
1042 // XtVaSetValues (XtNameToWidget (XtParent(parent), "*XtasArrowSigButton"), XmNarrowDirection, XmARROW_DOWN, NULL);
1043 }
1044 else {
1045 qsort( tabagressors, c, sizeof(char*), (int (*)(const void*, const void*))XtasReverseAlphaStrCmp);
1046 // XtVaSetValues (XtNameToWidget (XtParent(parent), "*XtasArrowSigButton"), XmNarrowDirection, XmARROW_UP, NULL);
1047 }
1048
1049 XmListDeleteAllItems (list_w);
1050 for (i=0; i<c ; i++) {
1051 motif_string = XmStringCreateSimple (tabagressors[i]) ;
1052 XmListAddItemUnselected (list_w, motif_string, i+1) ;
1053 XmStringFree ( motif_string ) ;
1054 }
1055
1056 mbkfree (tabagressors);
1057 }
1058
1059 void XtasCtkInfoSortByCapaValueCallback (parent, list_w, call_data)
1060 Widget parent;
1061 XtPointer list_w;
1062 XtPointer call_data;
1063 {
1064 char **tabagressors;
1065 char *buf;
1066 int i, c;
1067
1068 XmStringTable itemTable;
1069 XmString motif_string;
1070 static int click = -1;
1071
1072 XtVaGetValues (list_w, XmNitems, &itemTable, XmNitemCount, &c, NULL);
1073
1074 click = -click;
1075
1076 tabagressors = (char**)mbkalloc (sizeof(char *)*c);
1077
1078 for (i=0 ; i<c ; i++) {
1079 XmStringGetLtoR( itemTable[i], XmSTRING_DEFAULT_CHARSET, &tabagressors[i] );
1080 }
1081
1082 if (click > 0)
1083 qsort( tabagressors, c, sizeof(char*), (int (*)(const void*, const void*))XtasDescendCapaValueCmp);
1084 else
1085 qsort( tabagressors, c, sizeof(char*), (int (*)(const void*, const void*))XtasAscendCapaValueCmp);
1086
1087 XmListDeleteAllItems (list_w);
1088 for (i=0; i<c ; i++) {
1089 motif_string = XmStringCreateSimple (tabagressors[i]) ;
1090 XmListAddItemUnselected (list_w, motif_string, i+1) ;
1091 XmStringFree ( motif_string ) ;
1092 }
1093
1094 mbkfree (tabagressors);
1095 }
1096
1097
1098 /*---------------------------------------------------------------------------*/
1099 /* */
1100 /* FUNCTION : XtasDisplayCtkInfo */
1101 /* */
1102 /* IN ARGS : .parent : The parent widget. */
1103 /* .client_data : */
1104 /* .call_data : Toolkit informations. */
1105 /* */
1106 /* OUT ARGS : ( void ) */
1107 /* */
1108 /* OBJECT : The drawing function for crosstalk informations */
1109 /* */
1110 /*---------------------------------------------------------------------------*/
1111 void XtasDisplayCtkInfo( parent, event, errorWidget)
1112 Widget parent;
1113 ttvevent_list *event;
1114 XalMessageWidgetStruct *errorWidget;
1115 {
1116 int n ;
1117 Arg args[20];
1118 XmString text;
1119 Widget form, sub_form, sub_sub_form, frame, frame2, label_widget ;
1120 Widget ctkInfoWidget, tmp_widget, row_widget ;
1121 Widget paned_window, form1_window, list_widget;
1122 stb_ctk_detail *detail = NULL;
1123 char buf[1024];
1124 int lengthName, lengthNetname, length;
1125 stb_ctk_detail_agr_list *p;
1126 Pixmap r_pixmap, f_pixmap, v_pixmap;
1127 Pixel tas_state_color,tas_backg_color ;
1128 char text_title[128];
1129 Widget SIG_label_widget,/* ARROWSIG_label_widget, */CAPA_label_widget, scrollW;
1130 int nb_agr;
1131 ttvevent_list *stbevent;
1132 ttvfig_list *ttvfig;
1133 ttvline_list *line;
1134
1135 XtasPasqua();
1136 if(sigsetjmp( XtasMyEnv , 1 ) == 0) {
1137 stbevent = event ;
1138 if( ( event->ROOT->TYPE & TTV_SIG_CO ) == TTV_SIG_CO ) {
1139 ttvfig = XtasMainParam->stbfig->FIG ;
1140 ttv_expfigsig( ttvfig, event->ROOT, ttvfig->INFO->LEVEL, ttvfig->INFO->LEVEL, TTV_STS_T, TTV_FILE_DTX);
1141 for( line = event->INLINE ; line ; line = line->NEXT ) {
1142 if ( ( line->TYPE & TTV_LINE_RC) == TTV_LINE_RC )
1143 break;
1144 }
1145 if( line )
1146 stbevent = event->INLINE->NODE ;
1147 }
1148 detail = stb_ctk_get_detail(XtasMainParam->stbfig, stbevent);
1149 }
1150
1151 else {
1152 XtasFirePasqua();
1153 return ;
1154 }
1155 XtasGetWarningMess ();
1156 XtasFirePasqua();
1157
1158 if(detail != NULL) {
1159 n = 0;
1160 sprintf (text_title, XTAS_NAME": Crosstalk Infos - %s", XtasMainParam->ttvfig->INFO->FIGNAME);
1161 // XtSetArg( args[n], XmNtitle, XTAS_NAME": Crosstalk Infos" ); n++;
1162 XtSetArg( args[n], XmNtitle, text_title ); n++;
1163 XtSetArg( args[n], XmNminWidth, 450 ); n++;
1164 XtSetArg( args[n], XmNminHeight, 410 ); n++;
1165 XtSetArg( args[n], XmNmaxHeight, 410 ); n++;
1166 XtSetArg( args[n], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); n++;
1167 ctkInfoWidget = XmCreatePromptDialog( parent, "XtasInfosBox", args, n);
1168 HelpFather = ctkInfoWidget ;
1169 XtUnmanageChild( XmSelectionBoxGetChild( ctkInfoWidget, XmDIALOG_TEXT));
1170 XtUnmanageChild( XmSelectionBoxGetChild( ctkInfoWidget, XmDIALOG_PROMPT_LABEL));
1171 XtUnmanageChild( XmSelectionBoxGetChild( ctkInfoWidget, XmDIALOG_CANCEL_BUTTON ));
1172 XtAddCallback( ctkInfoWidget, XmNokCallback, XtasCtkInfoOkCallback, (XtPointer)ctkInfoWidget );
1173 XtAddCallback( ctkInfoWidget, XmNhelpCallback, XtasHelpCallback, (XtPointer)(XTAS_HELP_MAIN|XTAS_SRC_CTKINFO)) ;
1174 n = 0;
1175 form = XtCreateManagedWidget( "XtasDeskMainForm", xmFormWidgetClass, ctkInfoWidget, args, n );
1176
1177
1178 /*------------- frame Noise -------------*/
1179 n = 0;
1180 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1181 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
1182 frame2 = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n );
1183
1184 n = 0;
1185 #if XTAS_MOTIF_VERSION >= 20000
1186 XtSetArg ( args[n], XmNframeChildType, XmFRAME_WORKAREA_CHILD ); n++;
1187 #else
1188 XtSetArg ( args[n], XmNchildType, XmFRAME_WORKAREA_CHILD ); n++;
1189 #endif
1190 sub_form = XtCreateManagedWidget ("XtasSubForm", xmFormWidgetClass, frame2, args, n );
1191
1192
1193 text = XmStringCreateSimple("Noise");
1194 n = 0;
1195 XtSetArg ( args[n], XmNlabelString, text ); n++;
1196 #if XTAS_MOTIF_VERSION >= 20000
1197 XtSetArg ( args[n], XmNframeChildType, XmFRAME_TITLE_CHILD ); n++;
1198 #else
1199 XtSetArg ( args[n], XmNchildType, XmFRAME_TITLE_CHILD ); n++;
1200 #endif
1201 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, frame2, args, n );
1202 XmStringFree(text);
1203
1204 n = 0;
1205 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1206 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1207 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
1208 sub_sub_form = XtCreateManagedWidget ("XtasSubSubForm", xmFormWidgetClass, sub_form, args, n );
1209
1210
1211 n = 0;
1212 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1213 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1214 XtSetArg( args[n], XmNeditable, False ); n++;
1215 XtSetArg( args[n], XmNcolumns, 8 ); n++;
1216 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
1217 XtSetArg( args[n], XmNrightOffset, 95 ); n++;
1218 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, sub_sub_form, args, n);
1219 sprintf(buf,"%.3f V",(detail->NOISE_VTH));
1220 XmTextSetString( tmp_widget, buf );
1221
1222
1223 text = XmStringCreateSimple("Vth:");
1224 n = 0;
1225 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1226 XtSetArg ( args[n], XmNtopWidget, tmp_widget ); n++;
1227 XtSetArg ( args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1228 XtSetArg ( args[n], XmNbottomWidget, tmp_widget ); n++;
1229 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
1230 XtSetArg ( args[n], XmNrightWidget, tmp_widget ); n++;
1231 XtSetArg ( args[n], XmNrightOffset, 10 ); n++;
1232 XtSetArg ( args[n], XmNlabelString, text ); n++;
1233 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_sub_form, args, n );
1234
1235
1236
1237
1238 row_widget = XtVaCreateManagedWidget( "XtasRow", xmRowColumnWidgetClass, sub_form,
1239 XmNtopAttachment, XmATTACH_WIDGET,
1240 XmNtopWidget, sub_sub_form,
1241 XmNtopOffset, 5,
1242 XmNbottomAttachment,XmATTACH_FORM,
1243 XmNrightAttachment, XmATTACH_FORM,
1244 XmNleftAttachment, XmATTACH_FORM,
1245 XmNpacking, XmPACK_COLUMN,
1246 XmNorientation, XmHORIZONTAL,
1247 XmNentryAlignment, XmALIGNMENT_CENTER,
1248 XmNnumColumns, 4,
1249 XmNisAligned, True,
1250 XmNspacing, 5,
1251 NULL);
1252
1253 n = 0;
1254 sub_sub_form = XtCreateManagedWidget( "XtasForm", xmFormWidgetClass, row_widget, args, n);
1255
1256 n = 0;
1257 text = XmStringCreateSimple("Rise Peak");
1258 XtSetArg( args[n], XmNlabelString, text ); n++;
1259 XtSetArg( args[n], XmNalignment, XmALIGNMENT_CENTER ); n++;
1260 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, row_widget, args, n );
1261 XmStringFree(text);
1262
1263 n = 0;
1264 text = XmStringCreateSimple("Fall Peak");
1265 XtSetArg( args[n], XmNlabelString, text ); n++;
1266 XtSetArg( args[n], XmNalignment, XmALIGNMENT_CENTER ); n++;
1267 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, row_widget, args, n );
1268 XmStringFree(text);
1269
1270 n = 0;
1271 text = XmStringCreateSimple("Model");
1272 XtSetArg( args[n], XmNlabelString, text); n++;
1273 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, row_widget, args, n );
1274 XmStringFree(text);
1275
1276 n = 0;
1277 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1278 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1279 XtSetArg( args[n], XmNeditable, False ); n++;
1280 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_MODEL_WIDTH_G / 7); n++;
1281 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1282 XmTextSetString( tmp_widget, detail->MODEL_OVR );
1283
1284 n = 0;
1285 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1286 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1287 XtSetArg( args[n], XmNeditable, False ); n++;
1288 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_MODEL_WIDTH_G / 7); n++;
1289 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1290 XmTextSetString( tmp_widget, detail->MODEL_UND );
1291
1292 n = 0;
1293 text = XmStringCreateSimple("Max Noise");
1294 XtSetArg( args[n], XmNlabelString, text); n++;
1295 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, row_widget, args, n );
1296 XmStringFree(text);
1297
1298 n = 0;
1299 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1300 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1301 XtSetArg( args[n], XmNeditable, False ); n++;
1302 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_NOISE_WIDTH_G / 7); n++;
1303 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1304 sprintf(buf,"%.0f mV",(detail->NOISE_MAX_OVR*1000.0));
1305 XmTextSetString( tmp_widget, buf );
1306
1307 n = 0;
1308 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1309 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1310 XtSetArg( args[n], XmNeditable, False ); n++;
1311 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_NOISE_WIDTH_G / 7); n++;
1312 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1313 sprintf(buf,"%.0f mV",(detail->NOISE_MAX_UND*1000.0));
1314 XmTextSetString( tmp_widget, buf );
1315
1316 n = 0;
1317 text = XmStringCreateSimple("Real Noise");
1318 XtSetArg( args[n], XmNlabelString, text); n++;
1319 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, row_widget, args, n );
1320 XmStringFree(text);
1321
1322 n = 0;
1323 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1324 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1325 XtSetArg( args[n], XmNeditable, False ); n++;
1326 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_NOISE_WIDTH_G / 7); n++;
1327 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1328 sprintf(buf,"%.0f mV",(detail->NOISE_OVR*1000.0));
1329 XmTextSetString( tmp_widget, buf );
1330
1331 n = 0;
1332 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1333 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1334 XtSetArg( args[n], XmNeditable, False ); n++;
1335 XtSetArg( args[n], XmNcolumns, XTAS_NOISE_LABEL_NOISE_WIDTH_G / 7); n++;
1336 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, row_widget, args, n);
1337 sprintf(buf,"%.0f mV",(detail->NOISE_UND*1000.0));
1338 XmTextSetString( tmp_widget, buf );
1339
1340 /*------------- frame Agressors list -------------*/
1341 n = 0;
1342 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1343 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
1344 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1345 XtSetArg ( args[n], XmNleftWidget, frame2 ); n++;
1346 XtSetArg ( args[n], XmNleftOffset, 5 ); n++;
1347 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_OPPOSITE_WIDGET ); n++;
1348 XtSetArg ( args[n], XmNbottomWidget, frame2 ); n++;
1349 frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n );
1350
1351 n = 0;
1352 #if XTAS_MOTIF_VERSION >= 20000
1353 XtSetArg (args[n], XmNframeChildType, XmFRAME_WORKAREA_CHILD ); n++;
1354 #else
1355 XtSetArg (args[n], XmNchildType, XmFRAME_WORKAREA_CHILD ); n++;
1356 #endif
1357 sub_form = XtCreateManagedWidget("XtasForm",xmFormWidgetClass, frame, args, n);
1358
1359
1360 text = XmStringCreateSimple("Agressors List");
1361 n = 0;
1362 XtSetArg ( args[n], XmNlabelString, text ); n++;
1363 #if XTAS_MOTIF_VERSION >= 20000
1364 XtSetArg ( args[n], XmNframeChildType, XmFRAME_TITLE_CHILD ); n++;
1365 #else
1366 XtSetArg ( args[n], XmNchildType, XmFRAME_TITLE_CHILD ); n++;
1367 #endif
1368 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_CENTER ); n++;
1369 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, frame, args, n );
1370 XmStringFree(text);
1371
1372 /* calcul des largeurs max pour le name et le netname */
1373 lengthName = XTAS_MIN_CARLENGTH;
1374 lengthNetname = XTAS_MIN_CARLENGTH;
1375
1376 for (nb_agr=0, p=detail->AGRLIST ; p ; p=p->NEXT, nb_agr++) {
1377 if(p->TTVAGR)
1378 if((length = strlen(p->TTVAGR->NAME)) >= lengthName)
1379 lengthName = length;
1380 if((length = strlen(p->NETNAME)) >= lengthNetname)
1381 lengthNetname = length;
1382 }
1383
1384 if(lengthName >= XTAS_MAX_CARLENGTH)
1385 lengthName = XTAS_MAX_CARLENGTH;
1386 if(lengthNetname >= XTAS_MAX_CARLENGTH)
1387 lengthNetname = XTAS_MAX_CARLENGTH;
1388
1389
1390 text = XmStringCreateSimple("Signal Name");
1391 n = 0;
1392 XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1393 XtSetArg (args[n], XmNtopOffset, 7 ); n++;
1394 // XtSetArg (args[n], XmNtopWidget, frame2 ); n++;
1395 XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1396 XtSetArg (args[n], XmNleftOffset, XTAS_CTK_OFFSET ); n++;
1397 XtSetArg (args[n], XmNlabelString, text ); n++;
1398 XtSetArg (args[n], XmNwidth, lengthName*7 ); n++; /* 7 = largeur max d'un caractere */
1399 SIG_label_widget = XtCreateManagedWidget("XtasSigButton", xmPushButtonWidgetClass, sub_form, args, n);
1400 XmStringFree(text);
1401 /* n = 0;
1402 XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1403 XtSetArg (args[n], XmNtopWidget, SIG_label_widget ); n++;
1404 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1405 XtSetArg (args[n], XmNbottomWidget, SIG_label_widget ); n++;
1406 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1407 XtSetArg (args[n], XmNleftWidget, SIG_label_widget ); n++;
1408 XtSetArg (args[n], XmNarrowDirection, XmARROW_UP ); n++;
1409 ARROWSIG_label_widget = XtCreateManagedWidget("XtasArrowSigButton", xmArrowButtonWidgetClass, sub_form, args, n);
1410 */
1411 text = XmStringCreateSimple("Net Name");
1412 n = 0;
1413 XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1414 XtSetArg (args[n], XmNtopWidget, SIG_label_widget ); n++;
1415 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1416 XtSetArg (args[n], XmNbottomWidget, SIG_label_widget ); n++;
1417 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1418 XtSetArg (args[n], XmNleftWidget, SIG_label_widget ); n++;
1419 XtSetArg (args[n], XmNleftOffset, 7 ); n++;
1420 XtSetArg (args[n], XmNlabelString, text ); n++;
1421 XtSetArg (args[n], XmNwidth, lengthNetname*7 ); n++; /* 7 = largeur max d'un caractere */
1422 label_widget = XtCreateManagedWidget("XtasLabel", xmLabelWidgetClass, sub_form, args, n);
1423 XmStringFree(text);
1424
1425 text = XmStringCreateSimple(" ");
1426 n = 0;
1427 XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1428 XtSetArg (args[n], XmNtopWidget, label_widget ); n++;
1429 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1430 XtSetArg (args[n], XmNleftWidget, label_widget ); n++;
1431 XtSetArg (args[n], XmNleftOffset, 2*7 ); n++;
1432 XtSetArg (args[n], XmNlabelString, text ); n++;
1433 XtSetArg (args[n], XmNwidth, 4*7 ); n++; /* 7 = largeur max d'un caractere */
1434 label_widget = XtCreateManagedWidget("XtasLabel", xmLabelWidgetClass, sub_form, args, n);
1435 XmStringFree(text);
1436
1437 text = XmStringCreateSimple("Capa");
1438 n = 0;
1439 XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1440 XtSetArg (args[n], XmNtopWidget, label_widget ); n++;
1441 XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1442 XtSetArg (args[n], XmNleftWidget, label_widget ); n++;
1443 XtSetArg (args[n], XmNleftOffset, 2*7 ); n++;
1444 XtSetArg (args[n], XmNlabelString, text ); n++;
1445 XtSetArg (args[n], XmNwidth, 8*7 ); n++; /* 7 = largeur max d'un caractere */
1446 CAPA_label_widget = XtCreateManagedWidget("XtasLabel", xmPushButtonWidgetClass, sub_form, args, n);
1447 XmStringFree(text);
1448
1449 n = 0;
1450 XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ); n++;
1451 XtSetArg( args[n], XmNtopWidget, CAPA_label_widget ); n++;
1452 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
1453 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1454 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
1455 paned_window = XtCreateManagedWidget( "XtasPanedWindow",
1456 xmPanedWindowWidgetClass,
1457 sub_form,
1458 args, n );
1459
1460 form1_window = XtVaCreateManagedWidget ( "XtasSubForm",
1461 xmFormWidgetClass,
1462 paned_window,
1463 NULL) ;
1464
1465 n=0;
1466 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1467 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
1468 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1469 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
1470 XtSetArg( args[n], XmNvisibleItemCount, 15 ); n++;
1471 XtSetArg( args[n], XmNscrollBarPlacement, XmBOTTOM_RIGHT ); n++;
1472 XtSetArg( args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED ); n++;
1473 XtSetArg( args[n], XmNscrollingPolicy, XmAUTOMATIC ); n++;
1474 list_widget = XmCreateScrolledList( form1_window, "XtasTextualDisplay", args, n );
1475
1476 scrollW = XtParent (list_widget); /* on recupere la ScrolledWindow associee a la ScrolledList */
1477 XtVaGetValues (scrollW, XmNhorizontalScrollBar, &tmp_widget, NULL);
1478 XtAddCallback (tmp_widget, XmNvalueChangedCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1479 XtAddCallback (tmp_widget, XmNdragCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1480 XtAddCallback (tmp_widget, XmNincrementCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1481 XtAddCallback (tmp_widget, XmNdecrementCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1482 XtAddCallback (tmp_widget, XmNpageIncrementCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1483 XtAddCallback (tmp_widget, XmNpageDecrementCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1484 XtAddCallback (tmp_widget, XmNtoTopCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1485 XtAddCallback (tmp_widget, XmNtoBottomCallback, XtasCtkInfoColumnsTitleMoveWithHSBCallback, SIG_label_widget);
1486
1487 XtManageChild( list_widget );
1488 XtasFillAgressorsList(detail->AGRLIST, nb_agr, list_widget, lengthName, lengthNetname);
1489 XtAddCallback (list_widget, XmNdefaultActionCallback, XtasCtkInfoDetailCallback, ctkInfoWidget);
1490
1491 XtAddCallback (SIG_label_widget, XmNactivateCallback, XtasCtkInfoSortByNameCallback, list_widget);
1492 // XtAddCallback (ARROWSIG_label_widget, XmNactivateCallback, XtasCtkInfoSortByNameCallback, list_widget);
1493 XtAddCallback (CAPA_label_widget, XmNactivateCallback, XtasCtkInfoSortByCapaValueCallback, list_widget);
1494
1495
1496
1497 /*------------- frame General -------------*/
1498 n = 0;
1499 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1500 XtSetArg ( args[n], XmNtopWidget, frame ); n++;
1501 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1502 XtSetArg ( args[n], XmNleftWidget, frame2 ); n++;
1503 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1504 XtSetArg ( args[n], XmNrightWidget, frame2 ); n++;
1505 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_WIDGET ); n++;
1506 XtSetArg ( args[n], XmNbottomWidget, frame2 ); n++;
1507 XtSetArg ( args[n], XmNbottomOffset, 5 ); n++;
1508 frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n );
1509
1510 text = XmStringCreateSimple ("General");
1511 n= 0;
1512 XtSetArg ( args[n], XmNlabelString, text ); n++;
1513 #if XTAS_MOTIF_VERSION >= 20000
1514 XtSetArg ( args[n], XmNframeChildType, XmFRAME_TITLE_CHILD ); n++;
1515 #else
1516 XtSetArg ( args[n], XmNchildType, XmFRAME_TITLE_CHILD ); n++;
1517 #endif
1518 label_widget = XtCreateManagedWidget ("XatsLabels", xmLabelWidgetClass, frame, args, n);
1519 XmStringFree(text);
1520
1521 n = 0;
1522 #if XTAS_MOTIF_VERSION >= 20000
1523 XtSetArg( args[n], XmNframeChildType, XmFRAME_WORKAREA_CHILD ); n++;
1524 #else
1525 XtSetArg( args[n], XmNchildType, XmFRAME_WORKAREA_CHILD ); n++;
1526 #endif
1527 sub_form = XtCreateManagedWidget ("XtasSubForm", xmFormWidgetClass, frame, args, n );
1528
1529
1530 text = XmStringCreateSimple ("Signal:");
1531 n = 0;
1532 XtSetArg ( args[n], XmNlabelString, text ); n++;
1533 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1534 XtSetArg ( args[n], XmNtopOffset, 7 ); n++;
1535 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1536 XtSetArg ( args[n], XmNleftOffset, 7 ); n++;
1537 XtSetArg ( args[n], XmNlabelString, text ); n++;
1538 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
1539 XtSetArg ( args[n], XmNheight, 25 ); n++;
1540 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_form, args, n );
1541 XmStringFree(text);
1542
1543 XtVaGetValues(sub_form,XmNforeground,&tas_state_color,
1544 XmNbackground,&tas_backg_color,NULL );
1545 r_pixmap = XalGetPixmap( sub_form, XTAS_REDG_MAP, tas_state_color, tas_backg_color );
1546 f_pixmap = XalGetPixmap( sub_form, XTAS_FEDG_MAP, tas_state_color, tas_backg_color );
1547
1548 if ( (r_pixmap == XmUNSPECIFIED_PIXMAP) || (f_pixmap == XmUNSPECIFIED_PIXMAP) )
1549 {
1550 text = ( ( event->TYPE & TTV_NODE_UP ) == TTV_NODE_UP) ? XmStringCreateSimple("(Rising)") : XmStringCreateSimple("(Falling)");
1551 tmp_widget = XtVaCreateManagedWidget( "XtasMainTitles",
1552 xmLabelWidgetClass,
1553 sub_form,
1554 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1555 XmNtopWidget, label_widget,
1556 XmNlabelString, text,
1557 XmNleftAttachment, XmATTACH_WIDGET,
1558 XmNleftWidget, label_widget,
1559 XmNleftOffset, 5,
1560 XmNwidth, 40,
1561 XmNheight, 25,
1562 NULL);
1563 XmStringFree( text );
1564 }
1565 else
1566 {
1567 v_pixmap = ( (event->TYPE & TTV_NODE_UP ) == TTV_NODE_UP) ? r_pixmap : f_pixmap;
1568 tmp_widget = XtVaCreateManagedWidget( "XtasMainTitles",
1569 xmLabelWidgetClass,
1570 sub_form,
1571 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1572 XmNtopWidget, label_widget,
1573 XmNlabelType, XmPIXMAP,
1574 XmNlabelPixmap, v_pixmap,
1575 XmNleftAttachment, XmATTACH_WIDGET,
1576 XmNleftWidget, label_widget,
1577 XmNleftOffset, 5,
1578 XmNwidth, 40,
1579 XmNheight, 25,
1580 NULL);
1581 }
1582
1583 ttv_getsigname (XtasMainParam->stbfig->FIG, buf, event->ROOT);
1584 text = XmStringCreateSimple (buf);
1585 n = 0;
1586 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
1587 XtSetArg ( args[n], XmNtopWidget, tmp_widget ); n++;
1588 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1589 XtSetArg ( args[n], XmNleftWidget, tmp_widget ); n++;
1590 XtSetArg ( args[n], XmNleftOffset, 5 ); n++;
1591 XtSetArg ( args[n], XmNlabelString, text ); n++;
1592 XtSetArg ( args[n], XmNheight, 25 ); n++;
1593 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
1594 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_form, args, n );
1595 XmStringFree(text);
1596
1597 text = XmStringCreateSimple( "Ground Capacitance:" );
1598 n = 0;
1599 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_WIDGET ); n++;
1600 XtSetArg ( args[n], XmNtopWidget, label_widget ); n++;
1601 XtSetArg ( args[n], XmNtopOffset, 5 ); n++;
1602 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1603 XtSetArg ( args[n], XmNleftOffset, 7 ); n++;
1604 XtSetArg ( args[n], XmNlabelString, text ); n++;
1605 XtSetArg ( args[n], XmNheight, 30 ); n++;
1606 XtSetArg ( args[n], XmNwidth, 150 ); n++;
1607 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
1608 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_form, args, n );
1609 XmStringFree(text);
1610
1611 n = 0;
1612 XtSetArg( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1613 XtSetArg( args[n], XmNtopWidget, label_widget ); n++;
1614 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1615 XtSetArg( args[n], XmNbottomWidget, label_widget ); n++;
1616 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1617 XtSetArg( args[n], XmNleftWidget, label_widget ); n++;
1618 XtSetArg( args[n], XmNleftOffset, 5 ); n++;
1619 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1620 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1621 XtSetArg( args[n], XmNeditable, False ); n++;
1622 XtSetArg( args[n], XmNcolumns, 10 ); n++;
1623 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, sub_form, args, n);
1624 sprintf(buf,"%.3f fF",(detail->CM*1000.0));
1625 XmTextSetString( tmp_widget, buf );
1626
1627 text = XmStringCreateSimple( "Crosstalk Capacitance:" );
1628 n = 0;
1629 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_WIDGET ); n++;
1630 XtSetArg ( args[n], XmNtopWidget, label_widget ); n++;
1631 XtSetArg ( args[n], XmNtopOffset, 5 ); n++;
1632 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
1633 XtSetArg ( args[n], XmNleftOffset, 7 ); n++;
1634 XtSetArg ( args[n], XmNlabelString, text ); n++;
1635 XtSetArg ( args[n], XmNheight, 30 ); n++;
1636 XtSetArg ( args[n], XmNwidth, 150 ); n++;
1637 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_BEGINNING ); n++;
1638 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_form, args, n );
1639 XmStringFree(text);
1640
1641
1642 n = 0;
1643 XtSetArg( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1644 XtSetArg( args[n], XmNtopWidget, label_widget ); n++;
1645 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1646 XtSetArg( args[n], XmNbottomWidget, label_widget ); n++;
1647 XtSetArg( args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET ); n++;
1648 XtSetArg( args[n], XmNleftWidget, tmp_widget ); n++;
1649 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
1650 XtSetArg( args[n], XmNcursorPositionVisible,False ); n++;
1651 XtSetArg( args[n], XmNeditable, False ); n++;
1652 XtSetArg( args[n], XmNcolumns, 10 ); n++;
1653 tmp_widget = XtCreateManagedWidget( "XtasUserField", xmTextWidgetClass, sub_form, args, n);
1654 sprintf(buf,"%.3f fF",(detail->CC*1000.0));
1655 XmTextSetString( tmp_widget, buf );
1656
1657
1658 stb_ctk_free_detail(XtasMainParam->stbfig,detail);
1659 XtManageChild( ctkInfoWidget );
1660
1661 }
1662 else
1663 XalDrawMessage(errorWidget,
1664 "Crosstalk informations display impossible:\nno information.");
1665 }
1666
1667 /*---------------------------------------------------------------------------*/
1668 /* */
1669 /* FUNCTION : XtasNoiseCloseCallback */
1670 /* */
1671 /* IN ARGS : .widget : The widget on which the event occurs. */
1672 /* .top : The window toplevel widget id. */
1673 /* .call_data : Not significant. */
1674 /* */
1675 /* OUT ARGS : ( void ) */
1676 /* */
1677 /* OBJECT : */
1678 /* */
1679 /*---------------------------------------------------------------------------*/
1680 void XtasNoiseCloseCallback( widget, client_data , call_data )
1681 Widget widget ;
1682 XtPointer client_data ;
1683 XtPointer call_data ;
1684 {
1685 XtUnmanageChild (XtasNoiseResultsWidget);
1686 XtDestroyWidget (XtasNoiseResultsWidget);
1687 if (XtasNoiseScoresWidget) {
1688 XtDestroyWidget (XtasNoiseScoresWidget);
1689 XtasNoiseScoresWidget = NULL;
1690 }
1691 XtasNoiseResultsWidget = NULL;
1692 }
1693
1694 /*---------------------------------------------------------------------------*/
1695 /* */
1696 /* FUNCTION : XtasNoiseDetailCallback */
1697 /* */
1698 /* IN ARGS : .parent : The parent widget id. */
1699 /* .path_detail : The path detail description. */
1700 /* */
1701 /* OUT ARGS : ( void ) */
1702 /* */
1703 /* OBJECT : Creation de la liste des erreurs de stabilite */
1704 /* */
1705 /*---------------------------------------------------------------------------*/
1706 void XtasNoiseDetailCallback(parent, client_data, call_data)
1707 Widget parent ;
1708 XtPointer client_data ;
1709 XtPointer call_data ;
1710 {
1711 XtasWindowStruct *tas_winfos = (XtasWindowStruct *)client_data;
1712 char buf[1024];
1713
1714 if (XtasNoiseSelectedIndex == XTAS_NOISE_NO_SELECT )
1715 XalDrawMessage( tas_winfos->errwidget, XTAS_NSIGERR );
1716 else {
1717 XalSetCursor( tas_winfos->topwidget, WAIT );
1718 XalForceUpdate( tas_winfos->topwidget );
1719 ttv_getsigname (XtasMainParam->stbfig->FIG, buf, XtasNoiseTab->TAB[XtasNoiseSelectedIndex].NODE->ROOT);
1720 XtasSignalsDetail( tas_winfos->wrkwidget, buf);
1721 XalSetCursor( tas_winfos->topwidget, NORMAL );
1722 }
1723
1724 }
1725
1726 /*---------------------------------------------------------------------------*/
1727 /* */
1728 /* FUNCTION : XtasNoiseButtonsCallback */
1729 /* */
1730 /* IN ARGS : .widget : The widget on which the event occurs. */
1731 /* .widtab : Table of important widgets for the current window. */
1732 /* .call_data : Not significant. */
1733 /* */
1734 /* OUT ARGS : ( void ) */
1735 /* */
1736 /* OBJECT : The callback function for the Options/Button's command */
1737 /* */
1738 /*---------------------------------------------------------------------------*/
1739 void XtasNoiseButtonsCallback( widget, client_data, call_data )
1740 Widget widget;
1741 XtPointer client_data;
1742 XtPointer call_data;
1743 {
1744 XtasWindowStruct *widtab = (XtasWindowStruct *)client_data ;
1745 XtasOptionsButtonsTreat( widtab->wrkwidget, &widtab->butwidget,
1746 XtasNoiseButtonMenus, XtasNoiseButtonOptions );
1747 }
1748
1749
1750
1751 /*---------------------------------------------------------------------------*/
1752 /* */
1753 /* FUNCTION : XtasNoiseCtkInfoCallback */
1754 /* */
1755 /* IN ARGS : .parent : The parent widget id. */
1756 /* .path_detail : The path detail description. */
1757 /* */
1758 /* OUT ARGS : ( void ) */
1759 /* */
1760 /* OBJECT : Creation de la liste des erreurs de stabilite */
1761 /* */
1762 /*---------------------------------------------------------------------------*/
1763 void XtasNoiseCtkInfoCallback(parent, client_data, call_data)
1764 Widget parent ;
1765 XtPointer client_data ;
1766 XtPointer call_data ;
1767 {
1768 XtasWindowStruct *tas_winfos = (XtasWindowStruct *)client_data;
1769
1770 if (XtasNoiseSelectedIndex == XTAS_NOISE_NO_SELECT )
1771 XalDrawMessage( tas_winfos->errwidget, XTAS_NSIGERR );
1772 else {
1773 XalSetCursor( tas_winfos->topwidget, WAIT );
1774 XtasSetLabelString( tas_winfos->meswidget, "Looking for Crosstalk Informations ...");
1775 XalForceUpdate( tas_winfos->topwidget );
1776
1777 XtasDisplayCtkInfo(tas_winfos->topwidget,
1778 XtasNoiseTab->TAB[XtasNoiseSelectedIndex].NODE,
1779 tas_winfos->errwidget);
1780
1781 XalSetCursor( tas_winfos->topwidget, NORMAL );
1782 XtasSetLabelString( tas_winfos->meswidget, " ");
1783 XalForceUpdate( tas_winfos->topwidget );
1784 }
1785
1786 }
1787
1788 /*---------------------------------------------------------------------------*/
1789 /* */
1790 /* FUNCTION : XtasNoiseGetIndexSelectedCallback */
1791 /* */
1792 /* IN ARGS : .parent : The parent widget id. */
1793 /* .path_detail : The path detail description. */
1794 /* */
1795 /* OUT ARGS : ( void ) */
1796 /* */
1797 /* OBJECT : Creation de la liste des erreurs de stabilite */
1798 /* */
1799 /*---------------------------------------------------------------------------*/
1800 void XtasNoiseGetSelectedIndexCallback (parent, client_data, call_data)
1801 Widget parent;
1802 XtPointer client_data;
1803 XtPointer call_data;
1804 {
1805 Widget list_widget = (Widget) client_data;
1806 int *pos_list, pos_count;
1807 if (XmListGetSelectedPos(list_widget, &pos_list, &pos_count))
1808 XtasNoiseSelectedIndex = pos_list[0]-1;
1809 }
1810
1811
1812 /*---------------------------------------------------------------------------*/
1813 /* */
1814 /* FUNCTION : XtasNoiseGetTextualInfoCallback */
1815 /* */
1816 /* IN ARGS : .parent : The parent widget id. */
1817 /* .path_detail : The path detail description. */
1818 /* */
1819 /* OUT ARGS : ( void ) */
1820 /* */
1821 /* OBJECT : Creation de la liste des erreurs de stabilite */
1822 /* */
1823 /*---------------------------------------------------------------------------*/
1824 void XtasNoiseGetTextualInfoCallback (parent, client_data, call_data)
1825 Widget parent;
1826 XtPointer client_data;
1827 XtPointer call_data;
1828 {
1829 char *signame=(char*)mbkalloc(1024);
1830 XmListCallbackStruct *cbs = (XmListCallbackStruct *) call_data;
1831 Arg args[5] ;
1832 int n ;
1833 static Widget info_form = NULL, prev_parent = NULL;
1834
1835
1836 if ((info_form && (prev_parent == (Widget)client_data)) || (info_form && (XtasNoiseTab->NBDISPLAY==0)))
1837 XtDestroyWidget ( info_form ) ;
1838
1839 if (XtasNoiseTab->NBDISPLAY > 0) {
1840 prev_parent = (Widget)client_data;
1841
1842 n = 0 ;
1843 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
1844 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
1845 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
1846 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
1847 info_form = XtCreateManagedWidget( "XtasSubForm",
1848 xmFormWidgetClass,
1849 (Widget)client_data,
1850 args, n ) ;
1851
1852 ttv_getsigname(XtasMainParam->stbfig->FIG, signame, XtasNoiseTab->TAB[(cbs->item_position)-1].NODE->ROOT);
1853 XtasFillInfosForm (info_form, signame);
1854 }
1855 }
1856
1857 /*---------------------------------------------------------------------------*/
1858 /* */
1859 /* FUNCTION : XtasUpdateNoiseTextualScrollList */
1860 /* */
1861 /* IN ARGS : .parent : The parent widget id. */
1862 /* .path_detail : The path detail description. */
1863 /* */
1864 /* OUT ARGS : ( void ) */
1865 /* */
1866 /* OBJECT : Creation de la liste des erreurs de stabilite */
1867 /* */
1868 /*---------------------------------------------------------------------------*/
1869 void XtasUpdateNoiseTextualScrollList (list)
1870 Widget list;
1871 {
1872 char buf[1024];
1873 int i, position = 0 ;
1874 XmString motif_string ;
1875 char *signame;
1876 char *ovrmod, *undmod;
1877 ttvsig_list *ptsig;
1878 char textline[1024];
1879 int score_global, score_noise, score_ctk, score_interval, score_activity;
1880 int width;
1881 Widget labelSIGNAME;
1882
1883 XmListDeleteAllItems (list);
1884
1885 if((XtasNoiseTab == NULL) || (XtasNoiseTab->NBDISPLAY == 0))
1886 {
1887 sprintf(textline,"no noise") ;
1888 motif_string = XmStringCreateSimple(textline) ;
1889
1890 XmListAddItemUnselected( list, motif_string, ++position ) ;
1891 XmStringFree( motif_string ) ;
1892 return ;
1893 }
1894
1895 /* recherche de la longueur max des noms de signaux */
1896 for ( i = 0 ; i < XtasNoiseTab->NBDISPLAY ; i++ ) {
1897 ptsig = XtasNoiseTab->TAB[i].NODE->ROOT;
1898 ttv_getsigname (XtasMainParam->stbfig->FIG, buf, ptsig);
1899 if ((width = strlen(buf)) > XtasNoiseLabelSigNameLength )
1900 XtasNoiseLabelSigNameLength = width;
1901 }
1902 labelSIGNAME = XtNameToWidget (XtParent(XtParent(XtParent(XtParent(list)))), "*XtasNoiseSigName");
1903 XtVaSetValues (labelSIGNAME, XmNwidth, ((XtasNoiseLabelSigNameLength + 1) * 7), NULL);
1904
1905 position = 1 ;
1906 for( i = 0 ; i < XtasNoiseTab->NBDISPLAY ; i++)
1907 {
1908 ptsig = XtasNoiseTab->TAB[i].NODE->ROOT;
1909 ttv_getsigname (XtasMainParam->stbfig->FIG, buf, ptsig);
1910 signame = XtasPlaceString (buf, XtasNoiseLabelSigNameLength+2 );
1911 strcpy ( textline, " " );
1912 strcat ( textline, XtasNoiseTab->TAB[i].NOISE_MODEL);
1913 ovrmod = XtasPlaceString ( textline, (XTAS_NOISE_LABEL_MODEL_WIDTH_T / 7) );
1914 strcpy ( textline, " " );
1915 strcat ( textline, XtasNoiseTab->TAB[i].NOISE_MODEL);
1916 undmod = XtasPlaceString ( textline, (XTAS_NOISE_LABEL_MODEL_WIDTH_T / 7) );
1917
1918 score_global = stb_ctk_get_score_total (&XtasNoiseTab->TAB[i]);
1919 score_noise = stb_ctk_get_score_noise (&XtasNoiseTab->TAB[i]);
1920 score_interval = stb_ctk_get_score_interval (&XtasNoiseTab->TAB[i]);
1921 score_ctk = stb_ctk_get_score_ctk (&XtasNoiseTab->TAB[i]);
1922 score_activity = stb_ctk_get_score_activity (&XtasNoiseTab->TAB[i]);
1923
1924 sprintf(textline, "%5d %5s %s %5s %4.0f mV %4.0f mV %5s %4.0f mV %4.0f mV %9d %9d %9d %9d %9d",
1925 i+1, ((XtasNoiseTab->TAB[i].NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? "Low ":"High",
1926 signame,
1927 ovrmod,XtasNoiseTab->TAB[i].RISE_PEAK_MAX*1000.0, XtasNoiseTab->TAB[i].RISE_PEAK_REAL*1000.0,
1928 undmod,XtasNoiseTab->TAB[i].FALL_PEAK_MAX*1000.0, XtasNoiseTab->TAB[i].FALL_PEAK_REAL*1000.0,
1929 score_global, score_noise, score_interval, score_ctk, score_activity) ;
1930 mbkfree(signame) ;
1931 motif_string = XmStringCreateSimple (textline) ;
1932 XmListAddItemUnselected (list, motif_string, position) ;
1933 XmStringFree ( motif_string ) ;
1934 position++ ;
1935 }
1936
1937 }
1938
1939 /*---------------------------------------------------------------------------*/
1940 /* */
1941 /* FUNCTION : XtasCreateNoiseTextualScrollList */
1942 /* */
1943 /* IN ARGS : .parent : The parent widget id. */
1944 /* .path_detail : The path detail description. */
1945 /* */
1946 /* OUT ARGS : ( void ) */
1947 /* */
1948 /* OBJECT : Creation de la liste des erreurs de stabilite */
1949 /* */
1950 /*---------------------------------------------------------------------------*/
1951 Widget XtasCreateNoiseTextualScrollList(scform, tas_winfos, label_widget)
1952 Widget scform ;
1953 XtasWindowStruct *tas_winfos;
1954 Widget label_widget ;
1955 {
1956 Arg args[10] ;
1957 int i, n, position = 0 ;
1958 Widget list_form , info_form, scroll, scrollW, tmp_widget ;
1959 XmString motif_string ;
1960 char *signame;
1961 char *ovrmod, *undmod;
1962 ttvsig_list *ptsig;
1963 char textline[1024];
1964 int score_global, score_noise, score_interval, score_ctk, score_activity;
1965
1966
1967 n = 0 ;
1968 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM); n++;
1969 list_form = XtCreateManagedWidget( "XtasSubForm",
1970 xmFormWidgetClass,
1971 scform,
1972 args, n ) ;
1973 n = 0 ;
1974 XtSetArg( args[n], XmNheight, 170) ; n++ ;
1975 info_form = XtCreateManagedWidget( "XtasSubForm",
1976 xmFormWidgetClass,
1977 scform,
1978 args, n ) ;
1979
1980 n=0 ;
1981 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
1982 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
1983 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
1984 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
1985 XtSetArg( args[n], XmNscrollingPolicy, XmSTATIC ) ; n++ ;
1986 XtSetArg( args[n], XmNvisibleItemCount, 25 ) ; n++ ;
1987 // XtSetArg( args[n], XmNheight, 250 ) ; n++ ;
1988 scroll = XmCreateScrolledList( list_form, "XtasTextualDisplay", args , n ) ;
1989 XmListDeleteAllItems( scroll ) ;
1990
1991 if((XtasNoiseTab == NULL) || (XtasNoiseTab->NBDISPLAY == 0))
1992 {
1993 sprintf(textline,"no noise") ;
1994 motif_string = XmStringCreateSimple(textline) ;
1995
1996 XmListAddItemUnselected( scroll, motif_string, ++position ) ;
1997 XmStringFree( motif_string ) ;
1998 }
1999
2000 if (XtasNoiseTab == NULL) {
2001 XtManageChild( scroll) ;
2002 return scroll;
2003 }
2004
2005 position = 1 ;
2006 for( i = 0 ; i < XtasNoiseTab->NBDISPLAY ; i++)
2007 {
2008
2009 ptsig = XtasNoiseTab->TAB[i].NODE->ROOT;
2010
2011 ttv_getsigname (XtasMainParam->stbfig->FIG, textline, ptsig);
2012
2013 signame = XtasPlaceString (textline, XtasNoiseLabelSigNameLength+1 );
2014 /* netname = XtasPlaceString (ptsig->NETNAME, XtasNoiseLabelNetNameLength+1 ); */
2015 strcpy ( textline, " " );
2016 strcat ( textline, XtasNoiseTab->TAB[i].NOISE_MODEL);
2017 ovrmod = XtasPlaceString ( textline, (XTAS_NOISE_LABEL_MODEL_WIDTH_T / 7) );
2018 strcpy ( textline, " " );
2019 strcat ( textline, XtasNoiseTab->TAB[i].NOISE_MODEL);
2020 undmod = XtasPlaceString ( textline, (XTAS_NOISE_LABEL_MODEL_WIDTH_T / 7) );
2021
2022 score_global = stb_ctk_get_score_total (&XtasNoiseTab->TAB[i]);
2023 score_noise = stb_ctk_get_score_noise (&XtasNoiseTab->TAB[i]);
2024 score_interval = stb_ctk_get_score_interval (&XtasNoiseTab->TAB[i]);
2025 score_ctk = stb_ctk_get_score_ctk (&XtasNoiseTab->TAB[i]);
2026 score_activity = stb_ctk_get_score_activity (&XtasNoiseTab->TAB[i]);
2027
2028 sprintf(textline, "%5d %5s %s %5s %4.0f mV %4.0f mV %5s %4.0f mV %4.0f mV %9d %9d %9d %9d %9d",
2029 i+1, ((XtasNoiseTab->TAB[i].NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? "Low ":"High",
2030 signame,
2031 ovrmod,XtasNoiseTab->TAB[i].RISE_PEAK_MAX*1000.0, XtasNoiseTab->TAB[i].RISE_PEAK_REAL*1000.0,
2032 undmod,XtasNoiseTab->TAB[i].FALL_PEAK_MAX*1000.0, XtasNoiseTab->TAB[i].FALL_PEAK_REAL*1000.0,
2033 score_global, score_noise, score_interval, score_ctk, score_activity) ;
2034 mbkfree(signame) ;
2035 motif_string = XmStringCreateSimple (textline) ;
2036 XmListAddItemUnselected (scroll, motif_string, position) ;
2037 XmStringFree ( motif_string ) ;
2038 position++ ;
2039 }
2040
2041 // mbkfree(XtasNoiseTab) ;
2042
2043 XtAddCallback (scroll,
2044 XmNbrowseSelectionCallback,
2045 XtasNoiseGetSelectedIndexCallback,
2046 (XtPointer)scroll);
2047
2048 XtAddCallback (scroll,
2049 XmNbrowseSelectionCallback,
2050 XtasNoiseGetTextualInfoCallback,
2051 (XtPointer)info_form);
2052
2053 XtAddCallback (scroll,
2054 XmNdefaultActionCallback,
2055 XtasNoiseCtkInfoCallback,
2056 (XtPointer)tas_winfos);
2057
2058 scrollW = XtParent (scroll); /* on recupere la ScrolledWindow associee a la ScrolledList */
2059 XtVaGetValues (scrollW, XmNhorizontalScrollBar, &tmp_widget, NULL);
2060 XtAddCallback (tmp_widget, XmNvalueChangedCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2061 XtAddCallback (tmp_widget, XmNdragCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2062 XtAddCallback (tmp_widget, XmNincrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2063 XtAddCallback (tmp_widget, XmNdecrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2064 XtAddCallback (tmp_widget, XmNpageIncrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2065 XtAddCallback (tmp_widget, XmNpageDecrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2066 XtAddCallback (tmp_widget, XmNtoTopCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2067 XtAddCallback (tmp_widget, XmNtoBottomCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2068
2069
2070 XtManageChild( scroll) ;
2071 return (scroll);
2072
2073 }
2074 /*---------------------------------------------------------------------------*/
2075 /* */
2076 /* FUNCTION : XtasNoiseFocusCallback */
2077 /* */
2078 /* IN ARGS : .parent : The parent widget id. */
2079 /* .path_detail : The path detail description. */
2080 /* */
2081 /* OUT ARGS : ( void ) */
2082 /* */
2083 /* OBJECT : Creation de la liste des erreurs de stabilite */
2084 /* */
2085 /*---------------------------------------------------------------------------*/
2086 void XtasNoiseFocusCallback (parent, client_data, call_data)
2087 Widget parent ;
2088 XtPointer client_data ;
2089 XtPointer call_data ;
2090 {
2091 XtVaSetValues (parent, XmNcursorPositionVisible, True, NULL);
2092 XtasNoiseSelectedIndex = (int)(long) client_data;
2093 }
2094
2095 /*---------------------------------------------------------------------------*/
2096 /* */
2097 /* FUNCTION : XtasLosingNoiseFocusCallback */
2098 /* */
2099 /* IN ARGS : .parent : The parent widget id. */
2100 /* .path_detail : The path detail description. */
2101 /* */
2102 /* OUT ARGS : ( void ) */
2103 /* */
2104 /* OBJECT : Creation de la liste des erreurs de stabilite */
2105 /* */
2106 /*---------------------------------------------------------------------------*/
2107 void XtasLosingNoiseFocusCallback (parent, client_data, call_data)
2108 Widget parent ;
2109 XtPointer client_data ;
2110 XtPointer call_data ;
2111 {
2112 XtVaSetValues (parent, XmNcursorPositionVisible, False, NULL);
2113 }
2114
2115 /*---------------------------------------------------------------------------*/
2116 /* */
2117 /* FUNCTION : XtasNoiseFillGraphicalList */
2118 /* */
2119 /* IN ARGS : .parent : The parent widget id. */
2120 /* .path_detail : The path detail description. */
2121 /* */
2122 /* OUT ARGS : ( void ) */
2123 /* */
2124 /* OBJECT : Creation de la liste des erreurs de stabilite */
2125 /* */
2126 /*---------------------------------------------------------------------------*/
2127 void XtasNoiseFillGraphicalList ( new, widget, win_struct)
2128 int new ;
2129 Widget widget ;
2130 XtasWindowStruct *win_struct;
2131 {
2132 static Widget row_widget=NULL;
2133 int n, i;
2134 Arg args[10];
2135 Widget sub_form, label_widget, txt_widget;
2136 char text[1024];
2137 XmString motif_string;
2138 static XtasWindowStruct *tas_winfos;
2139 int position = 0;
2140
2141 if (row_widget && (new==0)) {
2142 XtUnmanageChild (row_widget);
2143 XtDestroyWidget (row_widget);
2144 }
2145 else if (new == 1)
2146 tas_winfos = win_struct;
2147 else if (new == 2) {
2148 tas_winfos = win_struct;
2149 return;
2150 }
2151
2152 // if (!row_widget && (new==0)) {
2153 // sub_form = XtNameToWidget (widget, "*XtasUserField");
2154 // if (sub_form) {
2155 // XtUnmanageChild (sub_form);
2156 // XtDestroyWidget (sub_form);
2157 // }
2158 // }
2159
2160
2161 if((XtasNoiseTab == NULL) || (XtasNoiseTab->NBDISPLAY == 0))
2162 {
2163 n=0 ;
2164 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
2165 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
2166 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
2167 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
2168 XtSetArg( args[n], XmNrightOffset, 10 ) ; n++ ;
2169 XtSetArg( args[n], XmNheight, 342 ) ; n++ ;
2170
2171 // XtSetArg( args[n], XmNvisibleItemCount, 25 ) ; n++ ;
2172 row_widget = XmCreateList( widget, "XtasUserField", args , n ) ;
2173 XmListDeleteAllItems( row_widget ) ;
2174
2175 sprintf(text,"no noise \
2176 \
2177 \
2178 ") ;
2179 motif_string = XmStringCreateSimple(text) ;
2180
2181 XmListAddItemUnselected( row_widget, motif_string, ++position ) ;
2182 XmStringFree( motif_string ) ;
2183 }
2184
2185 else {
2186 row_widget = XtVaCreateWidget( "XtasNoiseRow",
2187 xmRowColumnWidgetClass,
2188 widget,
2189 XmNorientation, XmVERTICAL,
2190 NULL);
2191
2192 for ( i = XtasNoiseCurrentTopIndex ; (i < (XtasNoiseCurrentTopIndex+XTAS_NOISE_MAX_NBSIG_WINDOW)) && (i < XtasNoiseTab->NBDISPLAY) ; i++) {
2193 n = 0;
2194 sub_form = XtCreateManagedWidget( "XtasSubForm",
2195 xmFormWidgetClass,
2196 row_widget,
2197 args, n );
2198
2199 sprintf(text, "%d", i+1);
2200 motif_string = XmStringCreateSimple (text);
2201 n = 0;
2202 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
2203 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
2204 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
2205 XtSetArg ( args[n], XmNlabelString, motif_string ); n++;
2206 XtSetArg ( args[n], XmNalignment, XmALIGNMENT_END ); n++;
2207 XtSetArg ( args[n], XmNwidth, XTAS_NOISE_LABEL_RANK_WIDTH_G ); n++;
2208 XtSetArg ( args[n], XmNheight, 25 ); n++;
2209 label_widget = XtCreateManagedWidget ("XtasLabels", xmLabelWidgetClass, sub_form, args, n);
2210 XmStringFree( motif_string );
2211
2212
2213 motif_string = ( ( XtasNoiseTab->TAB[i].NODE->TYPE & TTV_NODE_UP ) == TTV_NODE_UP) ? XmStringCreateSimple("Low ") : XmStringCreateSimple("High");
2214 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
2215 xmLabelWidgetClass,
2216 sub_form,
2217 XmNtopAttachment, XmATTACH_FORM,
2218 XmNbottomAttachment, XmATTACH_FORM,
2219 XmNlabelString, motif_string,
2220 XmNleftAttachment, XmATTACH_WIDGET,
2221 XmNleftWidget, label_widget,
2222 XmNleftOffset, XTAS_NOISE_OFFSET_GROUP_G,
2223 XmNwidth, XTAS_NOISE_LABEL_TRANS_WIDTH_G,
2224 XmNheight, 25,
2225 NULL);
2226 XmStringFree( motif_string );
2227
2228 n = 0;
2229 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2230 XtSetArg( args[n], XmNleftWidget, label_widget ); n++;
2231 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2232 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NAMES_WIDTH_G ); n++;
2233 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2234 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2235 XtSetArg( args[n], XmNeditable, False ); n++;
2236 txt_widget = XtCreateManagedWidget( "XtasUserField",
2237 xmTextWidgetClass,
2238 sub_form,
2239 args, n);
2240 ttv_getsigname (XtasMainParam->stbfig->FIG, text, XtasNoiseTab->TAB[i].NODE->ROOT);
2241 XmTextSetString( txt_widget, text);
2242
2243 XtAddCallback( txt_widget,
2244 XmNactivateCallback,
2245 XtasNoiseCtkInfoCallback,
2246 (XtPointer)tas_winfos );
2247 XtAddCallback( txt_widget,
2248 XmNfocusCallback,
2249 XtasNoiseFocusCallback,
2250 (XtPointer)(long)i );
2251 XtAddCallback( txt_widget,
2252 XmNlosingFocusCallback,
2253 XtasLosingNoiseFocusCallback,
2254 (XtPointer)(long)i );
2255
2256
2257 /*
2258 n = 0;
2259 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2260 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2261 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2262 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NAMES_WIDTH_G ); n++;
2263 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2264 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2265 XtSetArg( args[n], XmNeditable, False ); n++;
2266 txt_widget = XtCreateManagedWidget( "XtasUserField",
2267 xmTextWidgetClass,
2268 sub_form,
2269 args, n);
2270 XmTextSetString( txt_widget, XtasNoiseTab[i].NODE->ROOT->NETNAME );
2271
2272 XtAddCallback( txt_widget,
2273 XmNactivateCallback,
2274 XtasNoiseCtkInfoCallback,
2275 (XtPointer)tas_winfos );
2276 XtAddCallback( txt_widget,
2277 XmNfocusCallback,
2278 XtasNoiseFocusCallback,
2279 (XtPointer)i );
2280 XtAddCallback( txt_widget,
2281 XmNlosingFocusCallback,
2282 XtasLosingNoiseFocusCallback,
2283 (XtPointer)i );
2284 */
2285
2286 n = 0;
2287 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2288 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2289 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_GROUP_G ); n++;
2290 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_MODEL_WIDTH_G ); n++;
2291 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2292 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2293 XtSetArg( args[n], XmNeditable, False ); n++;
2294 txt_widget = XtCreateManagedWidget( "XtasUserField",
2295 xmTextWidgetClass,
2296 sub_form,
2297 args, n);
2298 XmTextSetString( txt_widget, XtasNoiseTab->TAB[i].NOISE_MODEL );
2299
2300 n = 0;
2301 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2302 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2303 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2304 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NOISE_WIDTH_G ); n++;
2305 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2306 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2307 XtSetArg( args[n], XmNeditable, False ); n++;
2308 txt_widget = XtCreateManagedWidget( "XtasUserField",
2309 xmTextWidgetClass,
2310 sub_form,
2311 args, n);
2312 sprintf (text, "%.0f mV",XtasNoiseTab->TAB[i].RISE_PEAK_MAX*1000.0);
2313 XmTextSetString( txt_widget, text);
2314
2315 n = 0;
2316 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2317 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2318 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2319 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NOISE_WIDTH_G ); n++;
2320 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2321 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2322 XtSetArg( args[n], XmNeditable, False ); n++;
2323 txt_widget = XtCreateManagedWidget( "XtasUserField",
2324 xmTextWidgetClass,
2325 sub_form,
2326 args, n);
2327 sprintf (text, "%.0f mV",XtasNoiseTab->TAB[i].RISE_PEAK_REAL*1000.0);
2328 XmTextSetString( txt_widget, text);
2329
2330 n = 0;
2331 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2332 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2333 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_GROUP_G ); n++;
2334 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_MODEL_WIDTH_G ); n++;
2335 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2336 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2337 XtSetArg( args[n], XmNeditable, False ); n++;
2338 txt_widget = XtCreateManagedWidget( "XtasUserField",
2339 xmTextWidgetClass,
2340 sub_form,
2341 args, n);
2342 XmTextSetString( txt_widget, XtasNoiseTab->TAB[i].NOISE_MODEL );
2343
2344 n = 0;
2345 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2346 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2347 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2348 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NOISE_WIDTH_G ); n++;
2349 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2350 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2351 XtSetArg( args[n], XmNeditable, False ); n++;
2352 txt_widget = XtCreateManagedWidget( "XtasUserField",
2353 xmTextWidgetClass,
2354 sub_form,
2355 args, n);
2356 sprintf (text, "%.0f mV",XtasNoiseTab->TAB[i].FALL_PEAK_MAX*1000.0);
2357 XmTextSetString( txt_widget, text);
2358
2359 n = 0;
2360 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2361 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2362 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2363 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_NOISE_WIDTH_G ); n++;
2364 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2365 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2366 XtSetArg( args[n], XmNeditable, False ); n++;
2367 txt_widget = XtCreateManagedWidget( "XtasUserField",
2368 xmTextWidgetClass,
2369 sub_form,
2370 args, n);
2371 sprintf (text, "%.0f mV",XtasNoiseTab->TAB[i].FALL_PEAK_REAL*1000.0);
2372 XmTextSetString( txt_widget, text);
2373
2374
2375 /* SCORES */
2376 n = 0;
2377 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2378 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2379 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_GROUP_G ); n++;
2380 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_SCORE_WIDTH_G ); n++;
2381 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2382 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2383 XtSetArg( args[n], XmNeditable, False ); n++;
2384 txt_widget = XtCreateManagedWidget( "XtasUserField",
2385 xmTextWidgetClass,
2386 sub_form,
2387 args, n);
2388 sprintf (text, "%9d",stb_ctk_get_score_total (&XtasNoiseTab->TAB[i]));
2389 XmTextSetString( txt_widget, text);
2390
2391 n = 0;
2392 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2393 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2394 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2395 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_SCORE_WIDTH_G ); n++;
2396 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2397 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2398 XtSetArg( args[n], XmNeditable, False ); n++;
2399 txt_widget = XtCreateManagedWidget( "XtasUserField",
2400 xmTextWidgetClass,
2401 sub_form,
2402 args, n);
2403 sprintf (text, "%9d",stb_ctk_get_score_noise (&XtasNoiseTab->TAB[i]));
2404 XmTextSetString( txt_widget, text);
2405
2406 n = 0;
2407 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2408 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2409 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2410 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_SCORE_WIDTH_G ); n++;
2411 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2412 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2413 XtSetArg( args[n], XmNeditable, False ); n++;
2414 txt_widget = XtCreateManagedWidget( "XtasUserField",
2415 xmTextWidgetClass,
2416 sub_form,
2417 args, n);
2418 sprintf (text, "%9d",stb_ctk_get_score_interval (&XtasNoiseTab->TAB[i]));
2419 XmTextSetString( txt_widget, text);
2420
2421 n = 0;
2422 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2423 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2424 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2425 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_SCORE_WIDTH_G ); n++;
2426 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2427 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2428 XtSetArg( args[n], XmNeditable, False ); n++;
2429 txt_widget = XtCreateManagedWidget( "XtasUserField",
2430 xmTextWidgetClass,
2431 sub_form,
2432 args, n);
2433 sprintf (text, "%9d",stb_ctk_get_score_ctk (&XtasNoiseTab->TAB[i]));
2434 XmTextSetString( txt_widget, text);
2435
2436 n = 0;
2437 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
2438 XtSetArg( args[n], XmNleftWidget, txt_widget ); n++;
2439 XtSetArg( args[n], XmNleftOffset, XTAS_NOISE_OFFSET_G ); n++;
2440 XtSetArg( args[n], XmNwidth, XTAS_NOISE_LABEL_SCORE_WIDTH_G ); n++;
2441 XtSetArg( args[n], XmNshadowThickness, 1 ); n++;
2442 XtSetArg( args[n], XmNcursorPositionVisible, False ); n++;
2443 XtSetArg( args[n], XmNeditable, False ); n++;
2444 txt_widget = XtCreateManagedWidget( "XtasUserField",
2445 xmTextWidgetClass,
2446 sub_form,
2447 args, n);
2448 sprintf (text, "%9d",stb_ctk_get_score_activity (&XtasNoiseTab->TAB[i]));
2449 XmTextSetString( txt_widget, text);
2450
2451 }
2452 }
2453 XtManageChild(row_widget);
2454
2455
2456
2457
2458 }
2459 /*---------------------------------------------------------------------------*/
2460 /* */
2461 /* FUNCTION : XtasNoiseFillNbVisualizeResults */
2462 /* */
2463 /* IN ARGS : .parent : The parent widget id. */
2464 /* .path_detail : The path detail description. */
2465 /* */
2466 /* OUT ARGS : ( void ) */
2467 /* */
2468 /* OBJECT : Creation de la liste des erreurs de stabilite */
2469 /* */
2470 /*---------------------------------------------------------------------------*/
2471 void XtasNoiseFillNbVisualizeResults (new, label_widget)
2472 int new ;
2473 Widget label_widget;
2474 {
2475 static Widget label ;
2476 char str[50] = "Results " ;
2477 char text[6];
2478 int end;
2479
2480
2481 if (XtasNoiseTab->NBDISPLAY == 0)
2482 strcpy (str, " ");
2483
2484 else {
2485 sprintf (text, "%d", XtasNoiseCurrentTopIndex+1);
2486 strcat (str, text);
2487 strcat (str, " - ");
2488
2489 if ((XtasNoiseCurrentTopIndex + XTAS_NOISE_MAX_NBSIG_WINDOW) <= XtasNoiseTab->NBDISPLAY)
2490 end = XtasNoiseCurrentTopIndex + XTAS_NOISE_MAX_NBSIG_WINDOW;
2491 else
2492 end = XtasNoiseTab->NBDISPLAY;
2493 sprintf (text, "%d", end);
2494 strcat (str, text);
2495 strcat (str, " / ");
2496
2497 sprintf (text, "%d", XtasNoiseTab->NBDISPLAY);
2498 strcat (str, text);
2499 }
2500
2501
2502 if (new == 1) /* une nouvelle fenetre de resultats est en train d'etre creee
2503 c'est le premier appel a cette fonction */
2504 label = label_widget;
2505
2506 XtasSetLabelString (label, str);
2507 }
2508
2509
2510 /*---------------------------------------------------------------------------*/
2511 /* */
2512 /* FUNCTION : XtasCreateNoiseGraphicalScrollList */
2513 /* */
2514 /* IN ARGS : .parent : The parent widget id. */
2515 /* .path_detail : The path detail description. */
2516 /* */
2517 /* OUT ARGS : ( void ) */
2518 /* */
2519 /* OBJECT : Creation de la liste des erreurs de stabilite */
2520 /* */
2521 /*---------------------------------------------------------------------------*/
2522 Widget XtasCreateNoiseGraphicalScrollList(scform, tas_winfos,label_widget)
2523 Widget scform ;
2524 XtasWindowStruct *tas_winfos;
2525 Widget label_widget ;
2526 {
2527 int n, position;
2528 Arg args[10];
2529 Widget list_form, scroll, sc_nonoise;
2530 char text[512];
2531 XmString motif_string;
2532 Widget tmp_widget;
2533
2534 n = 0 ;
2535 list_form = XtCreateManagedWidget( "XtasSubForm",
2536 xmFormWidgetClass,
2537 scform,
2538 args, n ) ;
2539
2540 n=0;
2541 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
2542 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
2543 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
2544 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
2545 XtSetArg( args[n], XmNscrollingPolicy, XmSTATIC ); n++;
2546 XtSetArg( args[n], XmNheight, 350 ); n++;
2547 scroll = XmCreateScrolledWindow( list_form,
2548 "XtasScrollNoiseWidget",
2549 args, n );
2550
2551
2552 // if((XtasNoiseTab == NULL) || (XtasNoiseTab->NBDISPLAY == 0))
2553 // {
2554 // n=0 ;
2555 // XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
2556 // XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
2557 // XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
2558 // XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
2559 // XtSetArg( args[n], XmNrightOffset, 10 ) ; n++ ;
2560 // XtSetArg( args[n], XmNheight, 342 ) ; n++ ;
2561 //
2562 // // XtSetArg( args[n], XmNvisibleItemCount, 25 ) ; n++ ;
2563 // sc_nonoise = XmCreateList( scroll, "XtasUserField", args , n ) ;
2564 // XmListDeleteAllItems( sc_nonoise ) ;
2565 //
2566 // sprintf(text,"no noise \
2567 // \
2568 // \
2569 // ") ;
2570 // motif_string = XmStringCreateSimple(text) ;
2571 //
2572 // XmListAddItemUnselected( sc_nonoise, motif_string, ++position ) ;
2573 // XmStringFree( motif_string ) ;
2574 // XtManageChild( sc_nonoise );
2575 //
2576 // }
2577
2578
2579 XtVaGetValues (scroll, XmNhorizontalScrollBar, &tmp_widget, NULL);
2580 XtAddCallback (tmp_widget, XmNvalueChangedCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2581 XtAddCallback (tmp_widget, XmNdragCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2582 XtAddCallback (tmp_widget, XmNincrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2583 XtAddCallback (tmp_widget, XmNdecrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2584 XtAddCallback (tmp_widget, XmNpageIncrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2585 XtAddCallback (tmp_widget, XmNpageDecrementCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2586 XtAddCallback (tmp_widget, XmNtoTopCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2587 XtAddCallback (tmp_widget, XmNtoBottomCallback, XtasNoiseColumnsTitleMoveWithHSBCallback, label_widget);
2588
2589 // if((XtasNoiseTab == NULL) || (XtasNoiseTab->NBDISPLAY == 0))
2590 // XtasNoiseFillGraphicalList (2, scroll, tas_winfos);
2591 // else
2592 XtasNoiseFillGraphicalList (1, scroll, tas_winfos);
2593
2594 XtManageChild( scroll );
2595
2596 return (scroll);
2597
2598 }
2599
2600 /*---------------------------------------------------------------------------*/
2601 /* */
2602 /* FUNCTION : XtasNoiseTreatEndCallback */
2603 /* */
2604 /* IN ARGS : .parent : The parent widget id. */
2605 /* .path_detail : The path detail description. */
2606 /* */
2607 /* OUT ARGS : ( void ) */
2608 /* */
2609 /* OBJECT : Creation de la liste des erreurs de stabilite */
2610 /* */
2611 /*---------------------------------------------------------------------------*/
2612 void XtasNoiseTreatEndCallback( parent, client_data, call_data)
2613 Widget parent;
2614 XtPointer client_data;
2615 XtPointer call_data;
2616 {
2617 XtasNoiseCurrentTopIndex = XtasNoiseTab->NBDISPLAY - XTAS_NOISE_MAX_NBSIG_WINDOW;
2618 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2619 XtasNoiseFillNbVisualizeResults (0, NULL);
2620 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), False);
2621 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), True);
2622 }
2623
2624 /*---------------------------------------------------------------------------*/
2625 /* */
2626 /* FUNCTION : XtasNoiseTreatFastFwdCallback */
2627 /* */
2628 /* IN ARGS : .parent : The parent widget id. */
2629 /* .path_detail : The path detail description. */
2630 /* */
2631 /* OUT ARGS : ( void ) */
2632 /* */
2633 /* OBJECT : Creation de la liste des erreurs de stabilite */
2634 /* */
2635 /*---------------------------------------------------------------------------*/
2636 void XtasNoiseTreatFastFwdCallback( parent, client_data, call_data)
2637 Widget parent;
2638 XtPointer client_data;
2639 XtPointer call_data;
2640 {
2641 XtasNoiseCurrentTopIndex += 3 * XTAS_NOISE_MAX_NBSIG_WINDOW;
2642 if(XtasNoiseCurrentTopIndex > XtasNoiseTab->NBDISPLAY - XTAS_NOISE_MAX_NBSIG_WINDOW) {
2643 XtasNoiseCurrentTopIndex = XtasNoiseTab->NBDISPLAY - XTAS_NOISE_MAX_NBSIG_WINDOW;
2644 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), False);
2645 }
2646
2647 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), True);
2648 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2649 XtasNoiseFillNbVisualizeResults (0, NULL);
2650 }
2651
2652 /*---------------------------------------------------------------------------*/
2653 /* */
2654 /* FUNCTION : XtasNoiseTreatNextCallback */
2655 /* */
2656 /* IN ARGS : .parent : The parent widget id. */
2657 /* .path_detail : The path detail description. */
2658 /* */
2659 /* OUT ARGS : ( void ) */
2660 /* */
2661 /* OBJECT : Creation de la liste des erreurs de stabilite */
2662 /* */
2663 /*---------------------------------------------------------------------------*/
2664 void XtasNoiseTreatNextCallback( parent, client_data, call_data)
2665 Widget parent;
2666 XtPointer client_data;
2667 XtPointer call_data;
2668 {
2669 XtasNoiseCurrentTopIndex += XTAS_NOISE_MAX_NBSIG_WINDOW;
2670 if(XtasNoiseCurrentTopIndex > XtasNoiseTab->NBDISPLAY - XTAS_NOISE_MAX_NBSIG_WINDOW) {
2671 XtasNoiseCurrentTopIndex = XtasNoiseTab->NBDISPLAY - XTAS_NOISE_MAX_NBSIG_WINDOW;
2672 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), False);
2673 }
2674
2675 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), True);
2676 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2677 XtasNoiseFillNbVisualizeResults (0, NULL);
2678
2679 }
2680
2681 /*---------------------------------------------------------------------------*/
2682 /* */
2683 /* FUNCTION : XtasNoiseTreatPrevCallback */
2684 /* */
2685 /* IN ARGS : .parent : The parent widget id. */
2686 /* .path_detail : The path detail description. */
2687 /* */
2688 /* OUT ARGS : ( void ) */
2689 /* */
2690 /* OBJECT : Creation de la liste des erreurs de stabilite */
2691 /* */
2692 /*---------------------------------------------------------------------------*/
2693 void XtasNoiseTreatPrevCallback( parent, client_data, call_data)
2694 Widget parent;
2695 XtPointer client_data;
2696 XtPointer call_data;
2697 {
2698 XtasNoiseCurrentTopIndex -= XTAS_NOISE_MAX_NBSIG_WINDOW;
2699 if(XtasNoiseCurrentTopIndex < 0) {
2700 XtasNoiseCurrentTopIndex = 0;
2701 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), False);
2702 }
2703
2704 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), True);
2705 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2706 XtasNoiseFillNbVisualizeResults (0, NULL);
2707 }
2708
2709 /*---------------------------------------------------------------------------*/
2710 /* */
2711 /* FUNCTION : XtasNoiseTreatFastRewCallback */
2712 /* */
2713 /* IN ARGS : .parent : The parent widget id. */
2714 /* .path_detail : The path detail description. */
2715 /* */
2716 /* OUT ARGS : ( void ) */
2717 /* */
2718 /* OBJECT : Creation de la liste des erreurs de stabilite */
2719 /* */
2720 /*---------------------------------------------------------------------------*/
2721 void XtasNoiseTreatFastRewCallback( parent, client_data, call_data)
2722 Widget parent;
2723 XtPointer client_data;
2724 XtPointer call_data;
2725 {
2726 XtasNoiseCurrentTopIndex -= 3 * XTAS_NOISE_MAX_NBSIG_WINDOW;
2727 if(XtasNoiseCurrentTopIndex < 0) {
2728 XtasNoiseCurrentTopIndex = 0;
2729 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), False);
2730 }
2731
2732 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), True);
2733 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2734 XtasNoiseFillNbVisualizeResults (0, NULL);
2735
2736 }
2737
2738 /*---------------------------------------------------------------------------*/
2739 /* */
2740 /* FUNCTION : XtasNoiseTreatTopCallback */
2741 /* */
2742 /* IN ARGS : .parent : The parent widget id. */
2743 /* .path_detail : The path detail description. */
2744 /* */
2745 /* OUT ARGS : ( void ) */
2746 /* */
2747 /* OBJECT : Creation de la liste des erreurs de stabilite */
2748 /* */
2749 /*---------------------------------------------------------------------------*/
2750 void XtasNoiseTreatTopCallback( parent, client_data, call_data)
2751 Widget parent;
2752 XtPointer client_data;
2753 XtPointer call_data;
2754 {
2755 XtasNoiseCurrentTopIndex = 0;
2756 XtasNoiseFillGraphicalList (0, (Widget) client_data, NULL);
2757 XtasNoiseFillNbVisualizeResults (0, NULL);
2758 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormPrev"), False);
2759 if(XtasNoiseTab->NBDISPLAY >= XTAS_NOISE_MAX_NBSIG_WINDOW)
2760 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), True);
2761 else
2762 XtSetSensitive (XtNameToWidget (XtasNoiseResultsWidget, "*XtasButtonsFormNext"), False);
2763
2764 }
2765
2766
2767 /*---------------------------------------------------------------------------*/
2768 /* */
2769 /* FUNCTION : XtasCreateNoiseList */
2770 /* */
2771 /* IN ARGS : .parent : The parent widget id. */
2772 /* .path_detail : The path detail description. */
2773 /* */
2774 /* OUT ARGS : ( void ) */
2775 /* */
2776 /* OBJECT : Creation de la liste des erreurs de stabilite */
2777 /* */
2778 /*---------------------------------------------------------------------------*/
2779 void XtasNoiseSortInsideAlimMaxCallback (parent, client_data, call_data)
2780 Widget parent;
2781 XtPointer client_data;
2782 XtPointer call_data;
2783 {
2784 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_INSIDE_ALIM_MAX);
2785 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2786 if (XTAS_DISPLAY_NEW == 0) {
2787 XtasNoiseCurrentTopIndex = 0;
2788 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2789 }
2790 else {
2791 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2792 }
2793 }
2794
2795 void XtasNoiseSortInsideAlimRealCallback (parent, client_data, call_data)
2796 Widget parent;
2797 XtPointer client_data;
2798 XtPointer call_data;
2799 {
2800 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_INSIDE_ALIM_REAL);
2801 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2802 if (XTAS_DISPLAY_NEW == 0) {
2803 XtasNoiseCurrentTopIndex = 0;
2804 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2805 }
2806 else {
2807 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2808 }
2809 }
2810
2811 void XtasNoiseSortRiseMaxCallback (parent, client_data, call_data)
2812 Widget parent;
2813 XtPointer client_data;
2814 XtPointer call_data;
2815 {
2816 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_RISE_MAX);
2817 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2818 if (XTAS_DISPLAY_NEW == 0) {
2819 XtasNoiseCurrentTopIndex = 0;
2820 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2821 }
2822 else {
2823 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2824 }
2825 }
2826
2827 void XtasNoiseSortRiseRealCallback (parent, client_data, call_data)
2828 Widget parent;
2829 XtPointer client_data;
2830 XtPointer call_data;
2831 {
2832 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_RISE_REAL);
2833 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2834 if (XTAS_DISPLAY_NEW == 0) {
2835 XtasNoiseCurrentTopIndex = 0;
2836 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2837 }
2838 else {
2839 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2840 }
2841 }
2842
2843 void XtasNoiseSortFallMaxCallback (parent, client_data, call_data)
2844 Widget parent;
2845 XtPointer client_data;
2846 XtPointer call_data;
2847 {
2848 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_FALL_MAX);
2849 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2850 if (XTAS_DISPLAY_NEW == 0) {
2851 XtasNoiseCurrentTopIndex = 0;
2852 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2853 }
2854 else {
2855 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2856 }
2857 }
2858
2859 void XtasNoiseSortFallRealCallback (parent, client_data, call_data)
2860 Widget parent;
2861 XtPointer client_data;
2862 XtPointer call_data;
2863 {
2864 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_FALL_REAL);
2865 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2866 if (XTAS_DISPLAY_NEW == 0) {
2867 XtasNoiseCurrentTopIndex = 0;
2868 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2869 }
2870 else {
2871 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2872 }
2873 }
2874
2875 void XtasNoiseSortScoreGlobalCallback (parent, client_data, call_data)
2876 Widget parent;
2877 XtPointer client_data;
2878 XtPointer call_data;
2879 {
2880 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_TOTAL);
2881 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2882 if (XTAS_DISPLAY_NEW == 0) {
2883 XtasNoiseCurrentTopIndex = 0;
2884 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2885 }
2886 else {
2887 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2888 }
2889 }
2890
2891 void XtasNoiseSortScoreCrosstalkCallback (parent, client_data, call_data)
2892 Widget parent;
2893 XtPointer client_data;
2894 XtPointer call_data;
2895 {
2896 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_CTK);
2897 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2898 if (XTAS_DISPLAY_NEW == 0) {
2899 XtasNoiseCurrentTopIndex = 0;
2900 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2901 }
2902 else {
2903 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2904 }
2905 }
2906 void XtasNoiseSortScoreNoiseCallback (parent, client_data, call_data)
2907 Widget parent;
2908 XtPointer client_data;
2909 XtPointer call_data;
2910 {
2911 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_NOISE);
2912 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2913 if (XTAS_DISPLAY_NEW == 0) {
2914 XtasNoiseCurrentTopIndex = 0;
2915 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2916 }
2917 else {
2918 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2919 }
2920 }
2921 void XtasNoiseSortScoreIntervalCallback (parent, client_data, call_data)
2922 Widget parent;
2923 XtPointer client_data;
2924 XtPointer call_data;
2925 {
2926 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_INTERVAL);
2927 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2928 if (XTAS_DISPLAY_NEW == 0) {
2929 XtasNoiseCurrentTopIndex = 0;
2930 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2931 }
2932 else {
2933 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2934 }
2935 }
2936 void XtasNoiseSortScoreActivityCallback (parent, client_data, call_data)
2937 Widget parent;
2938 XtPointer client_data;
2939 XtPointer call_data;
2940 {
2941 stb_ctk_sort_stat(XtasNoiseTab, STB_CTK_SORT_SCORE_ACTIVITY);
2942 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
2943 if (XTAS_DISPLAY_NEW == 0) {
2944 XtasNoiseCurrentTopIndex = 0;
2945 XtasNoiseTreatTopCallback (parent, (Widget)client_data, NULL);
2946 }
2947 else {
2948 XtasUpdateNoiseTextualScrollList ((Widget)client_data);
2949 }
2950 }
2951
2952
2953
2954 /*---------------------------------------------------------------------------*/
2955 /* */
2956 /* FUNCTION : XtasCreateNoiseList */
2957 /* */
2958 /* IN ARGS : .parent : The parent widget id. */
2959 /* .path_detail : The path detail description. */
2960 /* */
2961 /* OUT ARGS : ( void ) */
2962 /* */
2963 /* OBJECT : Creation de la liste des erreurs de stabilite */
2964 /* */
2965 /*---------------------------------------------------------------------------*/
2966 Widget XtasCreateNoiseList( parent, tas_winfos)
2967 Widget parent ;
2968 XtasWindowStruct *tas_winfos ;
2969 {
2970 Widget form_widget, form, dbase_form, pan_widget ;
2971 Widget label_widget, button ;
2972 Widget frame ;
2973 Widget buttons_form ;
2974 Widget b_rise_max, b_rise_real, b_fall_max, b_fall_real;
2975 Widget b_ins_max, b_ins_real;
2976 Widget b_score_global, b_score_noise, b_score_int, b_score_ctk, b_score_act;
2977 Widget separator1, separator2 ;
2978 XmString text ;
2979 Arg args[20] ;
2980 int n;
2981
2982 form_widget = XtVaCreateWidget( "XtasMainPan",
2983 xmFormWidgetClass,
2984 parent,
2985 XmNtopAttachment, XmATTACH_FORM,
2986 XmNbottomAttachment, XmATTACH_POSITION,
2987 XmNbottomPosition, 99,
2988 XmNleftAttachment, XmATTACH_POSITION,
2989 XmNleftPosition, 1,
2990 XmNrightAttachment, XmATTACH_POSITION,
2991 XmNrightPosition, 99,
2992 NULL) ;
2993 HelpFather = form_widget ;
2994
2995 n = 0 ;
2996 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
2997 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
2998 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
2999 buttons_form = XtCreateManagedWidget( "XtasNoiseButtons", xmFormWidgetClass, form_widget, args, n ) ;
3000 for ( n=0 ; XtasNoiseButtonMenus[n].pix_file != -1 ; n++ )
3001 XtasNoiseButtonMenus[n].callback_data = (XtPointer) tas_winfos ;
3002 n = 0 ;
3003 XtSetArg( args[n], XmNnumColumns, 1 ) ; n++ ;
3004 XtSetArg( args[n], XmNorientation, XmHORIZONTAL ) ; n++ ;
3005 tas_winfos->butwidget = XalButtonMenus( buttons_form, XtasNoiseButtonMenus, args,
3006 n, 40, 40 ) ;
3007 XtasAddDummyButton( tas_winfos->butwidget ) ;
3008 XtManageChild( tas_winfos->butwidget ) ;
3009
3010 /*---------------------------------------------------------------------------*/
3011 /* creation d'un separateur */
3012 /*---------------------------------------------------------------------------*/
3013 n = 0 ;
3014 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3015 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3016 XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ) ; n++ ;
3017 XtSetArg( args[n], XmNtopWidget, buttons_form ) ; n++ ;
3018 separator1 = XtCreateManagedWidget( "XtasSeparator", xmSeparatorWidgetClass, form_widget, args, n ) ;
3019
3020 n = 0 ;
3021 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3022 XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ) ; n++ ;
3023 XtSetArg( args[n], XmNtopWidget, separator1 ) ; n++ ;
3024 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3025 form = XtCreateManagedWidget( "XtasShellSubForm", xmFormWidgetClass, form_widget, args, n ) ;
3026
3027 /* Max Noise label */
3028 //sprintf(buffer,"Max noise : %.0f mV (rise peak)", XtasNoiseTab[0].OVR_MAX*1000.0) ;
3029 //text = XmStringCreateSimple (buffer);
3030 //n = 0 ;
3031 //XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
3032 //XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3033 //XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3034 //frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n ) ;
3035 //XtSetArg( args[n], XmNrecomputeSize, False ) ; n++ ;
3036 //XtSetArg( args[n], XmNlabelString, text ) ; n++ ;
3037 //XtSetArg( args[n], XmNalignment, XmALIGNMENT_BEGINNING ) ; n++ ;
3038 //label_widget = XtCreateManagedWidget( "XtasSubTitles", xmLabelGadgetClass, frame, args, n ) ;
3039 //XmStringFree (text);
3040
3041 ///* On signal label */
3042 //sprintf(buffer,"On signal : (%s) %s ",((XtasNoiseTab[0].NODE->TYPE & TTV_NODE_UP) == TTV_NODE_UP) ? "Rise":"Fall",
3043 // XtasNoiseTab[0].NODE->ROOT->NAME) ;
3044 //text = XmStringCreateSimple (buffer);
3045 //n = 0 ;
3046 //XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ) ; n++ ;
3047 //XtSetArg( args[n], XmNtopWidget, frame ) ; n++ ;
3048 //XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3049 //XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3050 //frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n ) ;
3051 //XtSetArg( args[n], XmNrecomputeSize, False ) ; n++ ;
3052 //XtSetArg( args[n], XmNlabelString, text ) ; n++ ;
3053 //XtSetArg( args[n], XmNalignment, XmALIGNMENT_BEGINNING ) ; n++ ;
3054 //label_widget = XtCreateManagedWidget( "XtasSubTitles", xmLabelGadgetClass, frame, args, n ) ;
3055 //XmStringFree (text);
3056
3057
3058
3059 /**/
3060 n = 0 ;
3061 XtSetArg( args[n], XmNborderWidth, 0 ) ; n++ ;
3062 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ) ; n++ ;
3063 // XtSetArg( args[n], XmNtopWidget, frame ) ; n++ ;
3064 // XtSetArg( args[n], XmNtopOffset, 10 ) ; n++ ;
3065 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
3066 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3067 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3068 XtSetArg( args[n], XmNrightOffset, 2 ) ; n++ ;
3069 dbase_form = XtCreateManagedWidget( "XtasTitleForm", xmFormWidgetClass, form, args, n ) ;
3070
3071
3072
3073 text = XmStringCreateSimple( "Inside Alim Max" ) ;
3074 b_ins_max = XtVaCreateManagedWidget( "XtasTitlesInsideAlimMax",
3075 xmPushButtonWidgetClass,
3076 dbase_form,
3077 XmNlabelString, text,
3078 XmNtopAttachment, XmATTACH_FORM,
3079 XmNleftAttachment, XmATTACH_FORM,
3080 XmNwidth, XTAS_DISPLAY_NEW ? (XTAS_NOISE_SORTBUTTON_WIDTH_T+(((XtasNoiseLabelSigNameLength + 1) * 7)/2)):XTAS_NOISE_SORTBUTTON_WIDTH_G,
3081 XmNtopOffset, 2,
3082 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_LEFT_OFFSET_T:XTAS_NOISE_LEFT_OFFSET_G,
3083 XmNheight, 25,
3084 NULL) ;
3085 XmStringFree( text ) ;
3086
3087 text = XmStringCreateSimple( "Inside Alim Real" ) ;
3088 b_ins_real = XtVaCreateManagedWidget( "XtasMainTitles",
3089 xmPushButtonWidgetClass,
3090 dbase_form,
3091 XmNlabelString, text,
3092 XmNtopAttachment, XmATTACH_FORM,
3093 XmNleftAttachment, XmATTACH_WIDGET,
3094 XmNleftWidget, b_ins_max,
3095 XmNwidth, XTAS_DISPLAY_NEW ? (XTAS_NOISE_SORTBUTTON_WIDTH_T+(((XtasNoiseLabelSigNameLength + 1) * 7)/2)):XTAS_NOISE_SORTBUTTON_WIDTH_G,
3096 XmNtopOffset, 2,
3097 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T2:XTAS_NOISE_OFFSET_G,
3098 XmNheight, 25,
3099 NULL) ;
3100 XmStringFree( text ) ;
3101
3102 text = XmStringCreateSimple( "Rank" ) ;
3103 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3104 xmLabelWidgetClass,
3105 dbase_form,
3106 XmNlabelString, text,
3107 XmNtopAttachment, XmATTACH_WIDGET,
3108 XmNtopWidget, b_ins_max,
3109 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
3110 XmNleftWidget, b_ins_max,
3111 XmNalignment, XmALIGNMENT_END,
3112 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_RANK_WIDTH_T:XTAS_NOISE_LABEL_RANK_WIDTH_G,
3113 XmNtopOffset, 2,
3114 XmNheight, 25,
3115 NULL) ;
3116 XmStringFree( text ) ;
3117
3118 text = XmStringCreateSimple( "Level" ) ;
3119 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3120 xmLabelWidgetClass,
3121 dbase_form,
3122 XmNlabelString, text,
3123 XmNtopAttachment, XmATTACH_WIDGET,
3124 XmNtopWidget, b_ins_max,
3125 XmNleftAttachment, XmATTACH_WIDGET,
3126 XmNleftWidget, label_widget,
3127 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_TRANS_WIDTH_T : XTAS_NOISE_LABEL_TRANS_WIDTH_G,
3128 XmNtopOffset, 2,
3129 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_GROUP_T:XTAS_NOISE_OFFSET_GROUP_G,
3130 XmNheight, 25,
3131 NULL) ;
3132 XmStringFree( text ) ;
3133
3134 text = XmStringCreateSimple( "Signal Name" ) ;
3135 label_widget = XtVaCreateManagedWidget( "XtasNoiseSigName",
3136 xmLabelWidgetClass,
3137 dbase_form,
3138 XmNlabelString, text,
3139 XmNtopAttachment, XmATTACH_WIDGET,
3140 XmNtopWidget, b_ins_real,
3141 XmNleftAttachment, XmATTACH_WIDGET,
3142 XmNleftWidget, label_widget,
3143 XmNwidth, XTAS_DISPLAY_NEW ? ((XtasNoiseLabelSigNameLength + 1) * 7) :XTAS_NOISE_LABEL_NAMES_WIDTH_G,
3144 XmNtopOffset, 2,
3145 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3146 XmNheight, 25,
3147 NULL) ;
3148 XmStringFree( text ) ;
3149
3150 /* text = XmStringCreateSimple( "Net Name" ) ;
3151 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3152 xmLabelWidgetClass,
3153 dbase_form,
3154 XmNlabelString, text,
3155 XmNtopAttachment, XmATTACH_WIDGET,
3156 XmNtopWidget, b_ins_real,
3157 XmNleftAttachment, XmATTACH_WIDGET,
3158 XmNleftWidget, label_widget,
3159 XmNwidth, XTAS_DISPLAY_NEW ? ((XtasNoiseLabelNetNameLength + 1) * 7) :XTAS_NOISE_LABEL_NAMES_WIDTH_G ,
3160 XmNtopOffset, 2,
3161 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3162 XmNheight, 25,
3163 NULL) ;
3164 XmStringFree( text ) ;
3165 */
3166 text = XmStringCreateSimple( "RISE PEAK" ) ;
3167 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3168 xmLabelWidgetClass,
3169 dbase_form,
3170 XmNlabelString, text,
3171 XmNtopAttachment, XmATTACH_FORM,
3172 XmNleftAttachment, XmATTACH_WIDGET,
3173 XmNleftWidget, label_widget,
3174 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_OVR_UND_WIDTH_T:XTAS_NOISE_LABEL_OVR_UND_WIDTH_G,
3175 XmNtopOffset, 2,
3176 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_GROUP_T+5:XTAS_NOISE_OFFSET_GROUP_G,
3177 XmNheight, 25,
3178 NULL) ;
3179 XmStringFree( text ) ;
3180 text = XmStringCreateSimple( "Model" ) ;
3181 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3182 xmLabelWidgetClass,
3183 dbase_form,
3184 XmNlabelString, text,
3185 XmNtopAttachment, XmATTACH_WIDGET,
3186 XmNtopWidget, label_widget,
3187 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
3188 XmNleftWidget, label_widget,
3189 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_MODEL_WIDTH_T:XTAS_NOISE_LABEL_MODEL_WIDTH_G,
3190 XmNtopOffset, 2,
3191 XmNheight, 25,
3192 NULL) ;
3193 XmStringFree( text ) ;
3194
3195 text = XmStringCreateSimple( "Max" ) ;
3196 b_rise_max = XtVaCreateManagedWidget( "XtasMainTitles",
3197 xmPushButtonWidgetClass,
3198 dbase_form,
3199 XmNlabelString, text,
3200 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3201 XmNtopWidget, label_widget,
3202 XmNleftAttachment, XmATTACH_WIDGET,
3203 XmNleftWidget, label_widget,
3204 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_NOISE_WIDTH_T:XTAS_NOISE_LABEL_NOISE_WIDTH_G,
3205 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3206 XmNheight, 25,
3207 NULL) ;
3208 XmStringFree( text ) ;
3209
3210 text = XmStringCreateSimple( "Real" ) ;
3211 b_rise_real = XtVaCreateManagedWidget( "XtasMainTitles",
3212 xmPushButtonWidgetClass,
3213 dbase_form,
3214 XmNlabelString, text,
3215 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3216 XmNtopWidget, b_rise_max,
3217 XmNleftAttachment, XmATTACH_WIDGET,
3218 XmNleftWidget, b_rise_max,
3219 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_NOISE_WIDTH_T:XTAS_NOISE_LABEL_NOISE_WIDTH_G,
3220 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3221 XmNheight, 25,
3222 NULL) ;
3223 XmStringFree( text ) ;
3224
3225
3226 text = XmStringCreateSimple( "FALL PEAK" ) ;
3227 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3228 xmLabelWidgetClass,
3229 dbase_form,
3230 XmNlabelString, text,
3231 XmNtopAttachment, XmATTACH_FORM,
3232 XmNleftAttachment, XmATTACH_WIDGET,
3233 XmNleftWidget, b_rise_real,
3234 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_OVR_UND_WIDTH_T:XTAS_NOISE_LABEL_OVR_UND_WIDTH_G,
3235 XmNtopOffset, 2,
3236 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_GROUP_T:XTAS_NOISE_OFFSET_GROUP_G,
3237 XmNheight, 25,
3238 NULL) ;
3239 XmStringFree( text ) ;
3240 text = XmStringCreateSimple( "Model" ) ;
3241 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3242 xmLabelWidgetClass,
3243 dbase_form,
3244 XmNlabelString, text,
3245 XmNtopAttachment, XmATTACH_WIDGET,
3246 XmNtopWidget, label_widget,
3247 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
3248 XmNleftWidget, label_widget,
3249 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_MODEL_WIDTH_T:XTAS_NOISE_LABEL_MODEL_WIDTH_G,
3250 XmNtopOffset, 2,
3251 XmNheight, 25,
3252 NULL) ;
3253 XmStringFree( text ) ;
3254
3255 text = XmStringCreateSimple( "Max" ) ;
3256 b_fall_max = XtVaCreateManagedWidget( "XtasMainTitles",
3257 xmPushButtonWidgetClass,
3258 dbase_form,
3259 XmNlabelString, text,
3260 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3261 XmNtopWidget, label_widget,
3262 XmNleftAttachment, XmATTACH_WIDGET,
3263 XmNleftWidget, label_widget,
3264 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_NOISE_WIDTH_T:XTAS_NOISE_LABEL_NOISE_WIDTH_G,
3265 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3266 XmNheight, 25,
3267 NULL) ;
3268 XmStringFree( text ) ;
3269
3270 text = XmStringCreateSimple( "Real" ) ;
3271 b_fall_real = XtVaCreateManagedWidget( "XtasMainTitles",
3272 xmPushButtonWidgetClass,
3273 dbase_form,
3274 XmNlabelString, text,
3275 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3276 XmNtopWidget, b_fall_max,
3277 XmNleftAttachment, XmATTACH_WIDGET,
3278 XmNleftWidget, b_fall_max,
3279 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_NOISE_WIDTH_T:XTAS_NOISE_LABEL_NOISE_WIDTH_G,
3280 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3281 XmNheight, 25,
3282 NULL) ;
3283 XmStringFree( text ) ;
3284
3285 text = XmStringCreateSimple( "SCORES" ) ;
3286 label_widget = XtVaCreateManagedWidget( "XtasMainTitles",
3287 xmLabelWidgetClass,
3288 dbase_form,
3289 XmNlabelString, text,
3290 XmNtopAttachment, XmATTACH_FORM,
3291 XmNleftAttachment, XmATTACH_WIDGET,
3292 XmNleftWidget, b_fall_real,
3293 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORES_WIDTH_T:XTAS_NOISE_LABEL_SCORES_WIDTH_G,
3294 XmNtopOffset, 2,
3295 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_GROUP_T:XTAS_NOISE_OFFSET_GROUP_G,
3296 XmNheight, 25,
3297 NULL) ;
3298 XmStringFree( text ) ;
3299 text = XmStringCreateSimple( "Global" ) ;
3300 b_score_global = XtVaCreateManagedWidget( "XtasMainTitles",
3301 xmPushButtonWidgetClass,
3302 dbase_form,
3303 XmNlabelString, text,
3304 XmNtopAttachment, XmATTACH_WIDGET,
3305 XmNtopWidget, label_widget,
3306 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
3307 XmNleftWidget, label_widget,
3308 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORE_WIDTH_T:XTAS_NOISE_LABEL_SCORE_WIDTH_G,
3309 XmNtopOffset, 2,
3310 XmNheight, 25,
3311 NULL) ;
3312 XmStringFree( text ) ;
3313 text = XmStringCreateSimple( "Noise" ) ;
3314 b_score_noise = XtVaCreateManagedWidget( "XtasMainTitles",
3315 xmPushButtonWidgetClass,
3316 dbase_form,
3317 XmNlabelString, text,
3318 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3319 XmNtopWidget, b_score_global,
3320 XmNleftAttachment, XmATTACH_WIDGET,
3321 XmNleftWidget, b_score_global,
3322 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORE_WIDTH_T:XTAS_NOISE_LABEL_SCORE_WIDTH_G,
3323 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3324 XmNheight, 25,
3325 NULL) ;
3326 XmStringFree( text ) ;
3327 text = XmStringCreateSimple( "Interval" ) ;
3328 b_score_int = XtVaCreateManagedWidget( "XtasMainTitles",
3329 xmPushButtonWidgetClass,
3330 dbase_form,
3331 XmNlabelString, text,
3332 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3333 XmNtopWidget, b_score_noise,
3334 XmNleftAttachment, XmATTACH_WIDGET,
3335 XmNleftWidget, b_score_noise,
3336 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORE_WIDTH_T:XTAS_NOISE_LABEL_SCORE_WIDTH_G,
3337 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3338 XmNheight, 25,
3339 NULL) ;
3340 XmStringFree( text ) ;
3341 text = XmStringCreateSimple( "Crosstalk" ) ;
3342 b_score_ctk = XtVaCreateManagedWidget( "XtasMainTitles",
3343 xmPushButtonWidgetClass,
3344 dbase_form,
3345 XmNlabelString, text,
3346 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3347 XmNtopWidget, b_score_int,
3348 XmNleftAttachment, XmATTACH_WIDGET,
3349 XmNleftWidget, b_score_int,
3350 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORE_WIDTH_T:XTAS_NOISE_LABEL_SCORE_WIDTH_G,
3351 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3352 XmNheight, 25,
3353 NULL) ;
3354 XmStringFree( text ) ;
3355 text = XmStringCreateSimple( "Activity" ) ;
3356 b_score_act = XtVaCreateManagedWidget( "XtasMainTitles",
3357 xmPushButtonWidgetClass,
3358 dbase_form,
3359 XmNlabelString, text,
3360 XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
3361 XmNtopWidget, b_score_ctk,
3362 XmNleftAttachment, XmATTACH_WIDGET,
3363 XmNleftWidget, b_score_ctk,
3364 XmNwidth, XTAS_DISPLAY_NEW ? XTAS_NOISE_LABEL_SCORE_WIDTH_T:XTAS_NOISE_LABEL_SCORE_WIDTH_G,
3365 XmNleftOffset, XTAS_DISPLAY_NEW ? XTAS_NOISE_OFFSET_T:XTAS_NOISE_OFFSET_G,
3366 XmNheight, 25,
3367 NULL) ;
3368 XmStringFree( text ) ;
3369
3370 n = 0 ;
3371 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
3372 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3373 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3374 XtSetArg( args[n], XmNtopOffset, 2 ) ; n++ ;
3375 XtSetArg( args[n], XmNleftOffset, 2 ) ; n++ ;
3376 XtSetArg( args[n], XmNrightOffset, 2 ) ; n++ ;
3377 form = XtCreateManagedWidget( "XtasShellSubForm", xmFormWidgetClass, form_widget, args, n ) ;
3378
3379 /* begin of old display */
3380 label_widget = XtVaCreateManagedWidget( "XtasMainTitles", xmLabelWidgetClass, form,
3381 XmNtopAttachment, XmATTACH_FORM,
3382 XmNleftAttachment, XmATTACH_FORM,
3383 XmNleftOffset, 2,
3384 NULL) ;
3385 XtasSetLabelString( label_widget, "Informations Area" ) ;
3386
3387 n = 0 ;
3388 XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ) ; n++ ;
3389 XtSetArg( args[n], XmNtopWidget, label_widget ) ; n++ ;
3390 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
3391 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3392 XtSetArg( args[n], XmNrightAttachment, XmATTACH_POSITION ) ; n++ ;
3393 XtSetArg( args[n], XmNrightPosition, 48 ) ; n++ ;
3394 frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n ) ;
3395 n = 0 ;
3396 XtSetArg( args[n], XmNheight, 20 ) ; n++ ;
3397 tas_winfos->meswidget = XtCreateManagedWidget( "XtasUserInfo", xmLabelWidgetClass, frame, args, n) ;
3398 XtasSetLabelString( tas_winfos->meswidget, XTAS_NULINFO ) ;
3399
3400
3401 n = 0 ;
3402 XtSetArg( args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ) ; n++ ;
3403 XtSetArg( args[n], XmNtopWidget, frame ) ; n++ ;
3404 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
3405 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3406 XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ) ; n++ ;
3407 XtSetArg( args[n], XmNleftWidget, frame ) ; n++ ;
3408 frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n ) ;
3409 n = 0 ;
3410 XtSetArg( args[n], XmNheight, 20 ) ; n++ ;
3411 tas_winfos->hlpwidget = XtCreateManagedWidget( "XtasHelpInfo", xmLabelWidgetClass, frame, args, n) ;
3412 XtasSetLabelString( tas_winfos->hlpwidget, XTAS_NULINFO ) ;
3413
3414 n = 0 ;
3415 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_WIDGET ) ; n++ ;
3416 XtSetArg( args[n], XmNbottomWidget, form ) ; n++ ;
3417 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3418 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3419 XtSetArg( args[n], XmNleftOffset, 3 ) ; n++ ;
3420 XtSetArg( args[n], XmNrightOffset, 3 ) ; n++ ;
3421 separator2 = XtCreateManagedWidget( "separator2", xmSeparatorWidgetClass, form_widget, args, n ) ;
3422
3423 n = 0 ;
3424 // XtSetArg( args[n], XmNbottomAttachment, XmATTACH_WIDGET ) ; n++ ;
3425 // XtSetArg( args[n], XmNbottomWidget, separator2 ) ; n++ ;
3426 XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ) ; n++ ;
3427 XtSetArg( args[n], XmNtopWidget, dbase_form ) ; n++ ;
3428 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3429 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3430 pan_widget = XtCreateManagedWidget( "XtasPanWindow", xmPanedWindowWidgetClass, form_widget, args, n ) ;
3431
3432 if (XTAS_DISPLAY_NEW == 0)
3433 {
3434 if((form = XtasCreateNoiseGraphicalScrollList(pan_widget, tas_winfos, b_ins_max))) {
3435 XtAddCallback( b_ins_max, XmNactivateCallback, XtasNoiseSortInsideAlimMaxCallback, (XtPointer) form);
3436 XtAddCallback( b_ins_real, XmNactivateCallback, XtasNoiseSortInsideAlimRealCallback, (XtPointer) form);
3437 XtAddCallback( b_rise_max, XmNactivateCallback, XtasNoiseSortRiseMaxCallback, (XtPointer) form);
3438 XtAddCallback( b_rise_real, XmNactivateCallback, XtasNoiseSortRiseRealCallback, (XtPointer) form);
3439 XtAddCallback( b_fall_max, XmNactivateCallback, XtasNoiseSortFallMaxCallback, (XtPointer) form);
3440 XtAddCallback( b_fall_real, XmNactivateCallback, XtasNoiseSortFallRealCallback, (XtPointer) form);
3441 XtAddCallback( b_score_global, XmNactivateCallback, XtasNoiseSortScoreGlobalCallback, (XtPointer) form);
3442 XtAddCallback( b_score_noise, XmNactivateCallback, XtasNoiseSortScoreNoiseCallback, (XtPointer) form);
3443 XtAddCallback( b_score_ctk, XmNactivateCallback, XtasNoiseSortScoreCrosstalkCallback, (XtPointer) form);
3444 XtAddCallback( b_score_int, XmNactivateCallback, XtasNoiseSortScoreIntervalCallback, (XtPointer) form);
3445 XtAddCallback( b_score_act, XmNactivateCallback, XtasNoiseSortScoreActivityCallback, (XtPointer) form);
3446
3447 n = 0;
3448 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_WIDGET ) ; n++ ;
3449 XtSetArg( args[n], XmNbottomWidget, separator2 ) ; n++ ;
3450 XtSetArg( args[n], XmNbottomOffset, 5 ) ; n++ ;
3451 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ) ; n++ ;
3452 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ) ; n++ ;
3453 XtSetArg( args[n], XmNrightOffset, 5 ) ; n++ ;
3454 dbase_form = XtCreateManagedWidget( "XtasFrame", xmFormWidgetClass, form_widget, args, n ) ;
3455
3456 XtVaSetValues (pan_widget, XmNbottomAttachment, XmATTACH_WIDGET, XmNbottomWidget, dbase_form, NULL);
3457
3458 n = 0;
3459 XtSetArg( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
3460 XtSetArg( args[n], XmNleftOffset, 5 ); n++;
3461 label_widget = XtCreateManagedWidget( "XtasLabels", xmLabelWidgetClass, dbase_form, args, n);
3462 XtasNoiseFillNbVisualizeResults (1, label_widget);
3463
3464 n = 0;
3465 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
3466 XtSetArg ( args[n], XmNsensitive, XtasNoiseTab->NBDISPLAY <= XTAS_NOISE_MAX_NBSIG_WINDOW ? False:True ); n++;
3467 buttons_form = XtCreateManagedWidget ("XtasButtonsFormNext", xmFormWidgetClass, dbase_form, args, n);
3468
3469 n = 0;
3470 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
3471 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3472 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3473 XtSetArg ( args[n], XmNwidth, 60 ); n++;
3474 button = XtCreateManagedWidget( "XtasShellSubForm",
3475 xmPushButtonWidgetClass,
3476 buttons_form,
3477 args, n );
3478 XtasSetLabelString( button, " ->| " );
3479
3480 XtAddCallback( button,
3481 XmNactivateCallback,
3482 XtasNoiseTreatEndCallback,
3483 (XtPointer) form);
3484
3485 n = 0;
3486 XtSetArg( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
3487 XtSetArg( args[n], XmNrightWidget, button ); n++;
3488 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3489 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3490 XtSetArg( args[n], XmNwidth, 60 ); n++;
3491 button = XtCreateManagedWidget( "XtasShellSubForm",
3492 xmPushButtonWidgetClass,
3493 buttons_form,
3494 args, n );
3495 XtasSetLabelString( button, " ->-> " );
3496 XtAddCallback( button,
3497 XmNactivateCallback,
3498 XtasNoiseTreatFastFwdCallback,
3499 (XtPointer) form);
3500
3501 n = 0;
3502 XtSetArg( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
3503 XtSetArg( args[n], XmNrightWidget, button ); n++;
3504 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3505 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3506 XtSetArg( args[n], XmNwidth, 60 ); n++;
3507 button = XtCreateManagedWidget( "XtasShellSubForm",
3508 xmPushButtonWidgetClass,
3509 buttons_form,
3510 args, n );
3511 XtasSetLabelString( button, " -> " );
3512 XtAddCallback( button,
3513 XmNactivateCallback,
3514 XtasNoiseTreatNextCallback,
3515 (XtPointer)form);
3516
3517 n = 0;
3518 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
3519 XtSetArg ( args[n], XmNrightWidget, buttons_form ); n++;
3520 XtSetArg ( args[n], XmNsensitive, False ); n++;
3521 buttons_form = XtCreateManagedWidget ("XtasButtonsFormPrev", xmFormWidgetClass, dbase_form, args, n);
3522
3523 n = 0;
3524 XtSetArg( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
3525 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3526 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3527 XtSetArg( args[n], XmNwidth, 60 ); n++;
3528 button = XtCreateManagedWidget( "XtasShellSubForm",
3529 xmPushButtonWidgetClass,
3530 buttons_form,
3531 args, n );
3532 XtasSetLabelString( button, " <- " );
3533 XtAddCallback( button,
3534 XmNactivateCallback,
3535 XtasNoiseTreatPrevCallback,
3536 (XtPointer)form);
3537
3538 n = 0;
3539 XtSetArg( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
3540 XtSetArg( args[n], XmNrightWidget, button ); n++;
3541 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3542 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3543 XtSetArg( args[n], XmNwidth, 60 ); n++;
3544 button = XtCreateManagedWidget( "XtasShellSubForm",
3545 xmPushButtonWidgetClass,
3546 buttons_form,
3547 args, n );
3548 XtasSetLabelString( button, " <-<- " );
3549 XtAddCallback( button,
3550 XmNactivateCallback,
3551 XtasNoiseTreatFastRewCallback,
3552 (XtPointer)form);
3553
3554 n = 0;
3555 XtSetArg( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
3556 XtSetArg( args[n], XmNrightWidget, button ); n++;
3557 XtSetArg( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3558 XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
3559 XtSetArg( args[n], XmNwidth, 60 ); n++;
3560 button = XtCreateManagedWidget( "XtasShellSubForm",
3561 xmPushButtonWidgetClass,
3562 buttons_form,
3563 args, n );
3564 XtasSetLabelString( button, " |<- " );
3565 XtAddCallback( button,
3566 XmNactivateCallback,
3567 XtasNoiseTreatTopCallback,
3568 (XtPointer)form);
3569 }
3570 }
3571 else {
3572 form = XtasCreateNoiseTextualScrollList(pan_widget, tas_winfos, b_ins_max) ;
3573 XtAddCallback( b_ins_max, XmNactivateCallback, XtasNoiseSortInsideAlimMaxCallback, (XtPointer) form);
3574 XtAddCallback( b_ins_real, XmNactivateCallback, XtasNoiseSortInsideAlimRealCallback, (XtPointer) form);
3575 XtAddCallback( b_rise_max, XmNactivateCallback, XtasNoiseSortRiseMaxCallback, (XtPointer) form);
3576 XtAddCallback( b_rise_real, XmNactivateCallback, XtasNoiseSortRiseRealCallback, (XtPointer) form);
3577 XtAddCallback( b_fall_max, XmNactivateCallback, XtasNoiseSortFallMaxCallback, (XtPointer) form);
3578 XtAddCallback( b_fall_real, XmNactivateCallback, XtasNoiseSortFallRealCallback, (XtPointer) form);
3579 XtAddCallback( b_score_global, XmNactivateCallback, XtasNoiseSortScoreGlobalCallback, (XtPointer) form);
3580 XtAddCallback( b_score_noise, XmNactivateCallback, XtasNoiseSortScoreNoiseCallback, (XtPointer) form);
3581 XtAddCallback( b_score_ctk, XmNactivateCallback, XtasNoiseSortScoreCrosstalkCallback, (XtPointer) form);
3582 XtAddCallback( b_score_int, XmNactivateCallback, XtasNoiseSortScoreIntervalCallback, (XtPointer) form);
3583 XtAddCallback( b_score_act, XmNactivateCallback, XtasNoiseSortScoreActivityCallback, (XtPointer) form);
3584 }
3585
3586
3587
3588 XtManageChild( form_widget ) ;
3589 return(form_widget) ;
3590 }
3591
3592
3593 /*---------------------------------------------------------------------------*/
3594 /* */
3595 /* FUNCTION : XtasCreateNoiseMenus */
3596 /* */
3597 /* IN ARGS : .parent : Parent widget for the Menu Bar. */
3598 /* */
3599 /* OUT ARGS : .The value of the Menu Bar widget. */
3600 /* */
3601 /* OBJECT : Creates the menu bar of the detail window. */
3602 /* */
3603 /*---------------------------------------------------------------------------*/
3604 Widget XtasCreateNoiseMenus( parent , tas_winfos )
3605 Widget parent ;
3606 XtasWindowStruct *tas_winfos ;
3607 {
3608 Widget menu_bar ;
3609 Arg args[20] ;
3610 int n ;
3611
3612 for(n = 0 ; XtasNoiseMenuFile[n].label != NULL ; n++)
3613 XtasNoiseMenuFile[n].callback_data = (XtPointer) tas_winfos ;
3614 for(n = 0 ; XtasNoiseMenuView[n].label != NULL ; n++)
3615 XtasNoiseMenuView[n].callback_data = (XtPointer) tas_winfos ;
3616 for(n = 0 ; XtasNoiseMenuOptions[n].label != NULL ; n++)
3617 XtasNoiseMenuOptions[n].callback_data = (XtPointer) tas_winfos ;
3618
3619 n = 0 ;
3620 menu_bar = XmCreateMenuBar( parent, "XtasMenuBar", args, n ) ;
3621 XalBuildMenus( menu_bar, XtasNoiseMenu ) ;
3622 return( menu_bar ) ;
3623 }
3624
3625 /*---------------------------------------------------------------------------*/
3626 /* */
3627 /* FUNCTION : XtasNoiseAnalysis */
3628 /* */
3629 /* IN ARGS : number of item per page */
3630 /* */
3631 /* OUT ARGS : ( void ) */
3632 /* */
3633 /* OBJECT : the noise analysis function. */
3634 /* */
3635 /*---------------------------------------------------------------------------*/
3636 int XtasNoiseAnalysis (void)
3637 {
3638 int n ;
3639 XtasWindowStruct *tas_winfos ;
3640 Arg args[10] ;
3641 Widget main_window ;
3642 int width ;
3643 ttvsig_list *ptsig ;
3644 char buf[1024] ;
3645
3646 XtasPasqua();
3647 if(sigsetjmp( XtasMyEnv , 1 ) == 0) {
3648 ctk_setprogressbar(XtasStbInProgress);
3649 XtasNoiseTab = stb_ctk_get_stat(XtasMainParam->stbfig);
3650 XtasDestroyStbInProgress();
3651 }
3652 else {
3653 XtasFirePasqua();
3654 return 1;
3655 }
3656
3657
3658 XtasFirePasqua();
3659
3660 if (!XtasNoiseTab)
3661 return 1;
3662
3663 if (XTAS_DISPLAY_NEW) {
3664 for ( n = 0 ; n < XtasNoiseTab->NBDISPLAY ; n++ ) {
3665 ptsig = XtasNoiseTab->TAB[n].NODE->ROOT;
3666
3667 ttv_getsigname (XtasMainParam->stbfig->FIG, buf, ptsig);
3668
3669 if ((width = strlen(buf)) > XtasNoiseLabelSigNameLength ) {
3670 /// if (width < XTAS_NOISE_NAME_MAX_LENGTH)
3671 XtasNoiseLabelSigNameLength = width;
3672 /// else
3673 /// XtasNoiseLabelSigNameLength = XTAS_NOISE_NAME_MAX_LENGTH;
3674 }
3675
3676 /* if ((width = strlen(ptsig->NETNAME)) > XtasNoiseLabelNetNameLength ) {
3677 if (width < XTAS_NOISE_NAME_MAX_LENGTH)
3678 XtasNoiseLabelNetNameLength = width;
3679 else
3680 XtasNoiseLabelNetNameLength = XTAS_NOISE_NAME_MAX_LENGTH;
3681 }
3682 */
3683 }
3684 // width = XTAS_NOISE_WINDOW_WIDTH_T + (XtasNoiseLabelSigNameLength*7) + (XtasNoiseLabelNetNameLength*7);
3685
3686 width = XTAS_NOISE_WINDOW_WIDTH_T + (XtasNoiseLabelSigNameLength*7);
3687 }
3688
3689 /* Creation de la structure pour la fenetre de resultats */
3690 tas_winfos = (XtasWindowStruct *) mbkalloc (sizeof(XtasWindowStruct));
3691 tas_winfos->topwidget = XtVaCreatePopupShell (NULL, topLevelShellWidgetClass,
3692 XtasTopLevel,
3693 XmNallowShellResize, False,
3694 XmNdeleteResponse, XmDESTROY,
3695 NULL) ;
3696 XtasNoiseResultsWidget = tas_winfos->topwidget;
3697
3698 n = 0 ;
3699 sprintf (buf, XTAS_NAME": Noise Analysis Results - %s", XtasMainParam->ttvfig->INFO->FIGNAME);
3700 // XtSetArg (args[n], XmNtitle , XTAS_NAME": Noise Analysis Results");n++ ;
3701 XtSetArg (args[n], XmNtitle , buf);n++ ;
3702 XtSetArg (args[n], XmNwidth , XTAS_DISPLAY_NEW ? width:XTAS_NOISE_WINDOW_WIDTH_G); n++ ;
3703 XtSetValues (tas_winfos->topwidget, args, n);
3704
3705 XalCustomIcon (tas_winfos->topwidget, XTAS_NOISE_MAP);
3706 main_window = XmCreateMainWindow (tas_winfos->topwidget, "XtasMain", args, n);
3707 XtManageChild (main_window);
3708 tas_winfos->menwidget = XtasCreateNoiseMenus (main_window, tas_winfos);
3709 XtManageChild (tas_winfos->menwidget);
3710
3711 tas_winfos->wrkwidget = XtasCreateNoiseList (main_window, tas_winfos);
3712
3713 tas_winfos->errwidget = XalCreateErrorBox (tas_winfos->wrkwidget);
3714 tas_winfos->warwidget = XalCreateWarningBox (tas_winfos->wrkwidget);
3715
3716 XmMainWindowSetAreas (main_window,
3717 tas_winfos->menwidget,
3718 (Widget) NULL,
3719 (Widget) NULL,
3720 (Widget) NULL,
3721 tas_winfos->wrkwidget);
3722
3723 XtPopup (tas_winfos->topwidget, XtGrabNone);
3724 return 0;
3725 }
3726
3727 /*---------------------------------------------------------------------------*/
3728 /* */
3729 /* FUNCTION : XtasNoiseOkCallback */
3730 /* */
3731 /* IN ARGS : .parent : The parent widget. */
3732 /* .client_data : */
3733 /* .call_data : Toolkit informations. */
3734 /* */
3735 /* OUT ARGS : ( void ) */
3736 /* */
3737 /* OBJECT : The drawing function for crosstalk informations */
3738 /* */
3739 /*---------------------------------------------------------------------------*/
3740 void XtasNoiseOkCallback ( parent, client_data, call_data)
3741 Widget parent ;
3742 XtPointer client_data ;
3743 XtPointer call_data ;
3744 {
3745 char *text;
3746 char *ptend;
3747 long nb_item;
3748
3749 XtasWindowStruct *stb_result = (XtasWindowStruct*) client_data;
3750
3751 if (XtasNoiseResultsWidget) {
3752 XtDestroyWidget (XtasNoiseResultsWidget) ;
3753 XtasNoiseResultsWidget = NULL;
3754 }
3755
3756 if (XtasNoiseTab) {
3757 // mbkfree (XtasNoiseTab);
3758 XtasNoiseTab = NULL;
3759 }
3760
3761 XtasNoiseSelectedIndex = XTAS_NOISE_NO_SELECT;
3762 XtasNoiseCurrentTopIndex = 0;
3763
3764 if (XTAS_DISPLAY_NEW == 0) {
3765 text = XmTextGetString(XtNameToWidget(parent, "*XtasNoiseNbItemText"));
3766 nb_item = strtol (text, &ptend, 10);
3767 if((*ptend != '\0') || (nb_item < 0)) {
3768 XtManageChild (parent);
3769 XalDrawMessage ( stb_result->errwidget,
3770 "Bad value for Number of items per page:\nMust be a positive integer.");
3771 XtFree (text);
3772 return;
3773 }
3774 XtFree (text);
3775
3776 XTAS_NOISE_MAX_NBSIG_WINDOW = nb_item;
3777
3778 XtUnmanageChild (parent);
3779 }
3780 XalSetCursor( stb_result->topwidget, WAIT );
3781 XtasSetLabelString( stb_result->meswidget, "Noise Analysis is running...");
3782 XalForceUpdate( stb_result->topwidget );
3783
3784 if (XtasNoiseAnalysis () != 0) {
3785 XalSetCursor( stb_result->topwidget, NORMAL );
3786 XtasSetLabelString( stb_result->meswidget, "No Noise");
3787 XalForceUpdate( stb_result->topwidget );
3788 }
3789 else {
3790 XalSetCursor( stb_result->topwidget, NORMAL );
3791 XtasSetLabelString( stb_result->meswidget, "Noise Analysis Completed");
3792 XalForceUpdate( stb_result->topwidget );
3793 }
3794 }
3795
3796
3797 /*---------------------------------------------------------------------------*/
3798 /* */
3799 /* FUNCTION : XtasCancelNoiseCallback */
3800 /* */
3801 /* IN ARGS : .parent : The parent widget. */
3802 /* .client_data : */
3803 /* .call_data : Toolkit informations. */
3804 /* */
3805 /* OUT ARGS : ( void ) */
3806 /* */
3807 /* OBJECT : The drawing function for crosstalk informations */
3808 /* */
3809 /*---------------------------------------------------------------------------*/
3810 void XtasCancelNoiseCallback ( parent, client_data, call_data)
3811 Widget parent ;
3812 XtPointer client_data ;
3813 XtPointer call_data ;
3814 {
3815 XtUnmanageChild ((Widget)client_data);
3816 }
3817
3818
3819 /*---------------------------------------------------------------------------*/
3820 /* */
3821 /* FUNCTION : XtasNoiseCallback */
3822 /* */
3823 /* IN ARGS : .parent : The parent widget. */
3824 /* .client_data : */
3825 /* .call_data : Toolkit informations. */
3826 /* */
3827 /* OUT ARGS : ( void ) */
3828 /* */
3829 /* OBJECT : The drawing function for crosstalk informations */
3830 /* */
3831 /*---------------------------------------------------------------------------*/
3832 void XtasNoiseCallback (parent, client_data, call_data)
3833 Widget parent;
3834 XtPointer client_data;
3835 XtPointer call_data;
3836 {
3837 Arg args[20];
3838 int n ;
3839 Atom WM_DELETE_WINDOW;
3840 Widget form, frame, sub_form, label_widget, text_widget;
3841 XmString text ;
3842 XtasWindowStruct *tas_winfos = (XtasWindowStruct *)client_data;
3843
3844 if (XtasAppNotReady ())
3845 return;
3846
3847 if ((XTAS_CTX_LOADED & XTAS_FROM_ANALYSIS) != XTAS_FROM_ANALYSIS) {
3848 XalDrawMessage(tas_winfos->errwidget,
3849 "Crosstalk Analysis must have been run before");
3850 return;
3851 }
3852
3853 if (XTAS_DISPLAY_NEW == 1) {
3854 XtasNoiseOkCallback (XtasMainWindow, (XtPointer)client_data, NULL);
3855 }
3856 else {
3857 if(!XtasNoiseParamWidget) {
3858 n = 0;
3859 XtSetArg ( args[n], XmNtitle, XTAS_NAME": Noise Parameterization" ); n++;
3860 XtSetArg ( args[n], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); n++;
3861 // XtSetArg ( args[n], XmNminWidth, 200 ); n++;
3862 // XtSetArg ( args[n], XmNmaxWidth, 200 ); n++;
3863 // XtSetArg ( args[n], XmNminHeight, 200 ); n++;
3864 // XtSetArg ( args[n], XmNmaxHeight, 200 ); n++;
3865 XtasNoiseParamWidget = XmCreatePromptDialog (tas_winfos->topwidget, "XtasParamBox", args, n);
3866 HelpFather = XtasNoiseParamWidget;
3867 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseParamWidget,XmDIALOG_TEXT));
3868 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseParamWidget,XmDIALOG_PROMPT_LABEL));
3869 XtUnmanageChild(XmSelectionBoxGetChild(XtasNoiseParamWidget,XmDIALOG_HELP_BUTTON));
3870 XtAddCallback( XtasNoiseParamWidget, XmNokCallback, XtasNoiseOkCallback, (XtPointer)client_data );
3871 XtAddCallback( XtasNoiseParamWidget, XmNcancelCallback, XtasCancelNoiseCallback, (XtPointer)XtasNoiseParamWidget );
3872 WM_DELETE_WINDOW = XmInternAtom(XtDisplay(XtasDeskMainForm), "WM_DELETE_WINDOW", False);
3873 XmAddWMProtocolCallback(XtParent(XtasNoiseParamWidget), WM_DELETE_WINDOW, XtasCancelNoiseCallback, (XtPointer )XtasNoiseParamWidget);
3874
3875 n = 0;
3876 form = XtCreateManagedWidget( "XtasForm", xmFormWidgetClass, XtasNoiseParamWidget, args, n );
3877
3878
3879 /*--------- frame <Number of signals to display> ---------*/
3880 n = 0;
3881 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3882 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
3883 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
3884 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
3885 frame = XtCreateManagedWidget( "XtasFrame", xmFrameWidgetClass, form, args, n );
3886
3887 text = XmStringCreateSimple ("Results Display");
3888 n = 0;
3889 #if XTAS_MOTIF_VERSION >= 20000
3890 XtSetArg ( args[n], XmNframeChildType, XmFRAME_TITLE_CHILD ); n++;
3891 #else
3892 XtSetArg ( args[n], XmNchildType, XmFRAME_TITLE_CHILD ); n++;
3893 #endif
3894 XtSetArg ( args[n], XmNlabelString, text ); n++;
3895 label_widget = XtCreateManagedWidget( "XtasLabels", xmLabelWidgetClass, frame, args, n );
3896 XmStringFree (text);
3897
3898 n = 0;
3899 #if XTAS_MOTIF_VERSION >= 20000
3900 XtSetArg ( args[n], XmNframeChildType, XmFRAME_WORKAREA_CHILD ); n++;
3901 #else
3902 XtSetArg ( args[n], XmNchildType, XmFRAME_WORKAREA_CHILD ); n++;
3903 #endif
3904 sub_form = XtCreateManagedWidget ("XtasForm", xmFormWidgetClass, frame, args, n);
3905
3906 n = 0;
3907 sub_form = XtCreateManagedWidget( "XtasNoiseMaxSigForm", xmFormWidgetClass, sub_form, args, n );
3908
3909 text = XmStringCreateSimple ("Number of items per page");
3910 n = 0;
3911 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3912 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_FORM ); n++;
3913 XtSetArg ( args[n], XmNleftOffset, 5 ); n++;
3914 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
3915 XtSetArg ( args[n], XmNlabelString, text ); n++;
3916 XtSetArg ( args[n], XmNheight, 30 ); n++;
3917 label_widget = XtCreateManagedWidget( "XtasLabel", xmLabelWidgetClass, sub_form, args, n);
3918 XmStringFree (text);
3919
3920 n = 0;
3921 XtSetArg ( args[n], XmNtopAttachment, XmATTACH_FORM ); n++;
3922 XtSetArg ( args[n], XmNbottomAttachment,XmATTACH_FORM ); n++;
3923 XtSetArg ( args[n], XmNbottomOffset, 5 ); n++;
3924 XtSetArg ( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
3925 XtSetArg ( args[n], XmNleftWidget, label_widget ); n++;
3926 XtSetArg ( args[n], XmNrightAttachment, XmATTACH_FORM ); n++;
3927 XtSetArg ( args[n], XmNrightOffset, 5 ); n++;
3928 XtSetArg ( args[n], XmNheight, 30 ); n++;
3929 XtSetArg ( args[n], XmNwidth, 50 ); n++;
3930 text_widget = XtCreateManagedWidget( "XtasNoiseNbItemText", xmTextWidgetClass, sub_form, args, n);
3931 XmTextSetString (text_widget, "15");
3932
3933 }
3934
3935 XtManageChild (XtasNoiseParamWidget);
3936 }
3937
3938 }
3939