| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // 27 //
28 // 28 //
29 // Andrew Walkden 16th April 1997 29 // Andrew Walkden 16th April 1997
30 // G4OpenGLXmConvenienceRoutines : 30 // G4OpenGLXmConvenienceRoutines :
31 // Collection of routine 31 // Collection of routines to facilitate
32 // the addition of simpl 32 // the addition of simple push button boxes,
33 // and slider bars to th 33 // and slider bars to the control panel.
>> 34 //
>> 35 // See G4OpenGLXmConvenienceRoutines.hh for more information.
>> 36
>> 37 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER
34 38
35 #include "G4OpenGLXmViewer.hh" 39 #include "G4OpenGLXmViewer.hh"
36 40
37 #include <Xm/Form.h> 41 #include <Xm/Form.h>
38 #include <Xm/ToggleB.h> 42 #include <Xm/ToggleB.h>
39 #include <Xm/ArrowBG.h> 43 #include <Xm/ArrowBG.h>
40 #include <Xm/RowColumn.h> 44 #include <Xm/RowColumn.h>
41 #include <Xm/TextF.h> 45 #include <Xm/TextF.h>
42 #include <Xm/Separator.h> 46 #include <Xm/Separator.h>
43 #include <Xm/Scale.h> 47 #include <Xm/Scale.h>
44 48
45 #include <sstream> 49 #include <sstream>
46 50
47 const G4String G4OpenGLXmViewer::e_str = ""; <<
48 <<
49 void G4OpenGLXmViewer::Add_four_arrow_buttons 51 void G4OpenGLXmViewer::Add_four_arrow_buttons (G4OpenGLXmViewer* pView,
50 XtCallbackRec** arrow_callbacks 52 XtCallbackRec** arrow_callbacks,
51 Widget* parent_widget) { 53 Widget* parent_widget) {
52 54
53 Widget arrow_form = XtVaCreateWidget 55 Widget arrow_form = XtVaCreateWidget
54 ("arrow_form", 56 ("arrow_form",
55 xmFormWidgetClass, 57 xmFormWidgetClass,
56 *parent_widget, 58 *parent_widget,
57 XmNfractionBase, 3, 59 XmNfractionBase, 3,
58 XtNvisual, pView->vi->visual, 60 XtNvisual, pView->vi->visual,
59 XtNdepth, pView->vi->depth, 61 XtNdepth, pView->vi->depth,
60 XtNcolormap, pView->cmap, 62 XtNcolormap, pView->cmap,
61 XtNborderColor, pView->borcol, 63 XtNborderColor, pView->borcol,
62 XtNbackground, pView->bgnd, 64 XtNbackground, pView->bgnd,
63 NULL); 65 NULL);
64 66
65 Widget arrow = XtVaCreateManagedWidget 67 Widget arrow = XtVaCreateManagedWidget
66 ("up_arrow", 68 ("up_arrow",
67 xmArrowButtonGadgetClass, 69 xmArrowButtonGadgetClass,
68 arrow_form, 70 arrow_form,
69 XmNtopAttachment, XmATTACH_POSITION, 71 XmNtopAttachment, XmATTACH_POSITION,
70 XmNtopPosition, 0, 72 XmNtopPosition, 0,
71 XmNbottomAttachment, XmATTACH_POSITION, 73 XmNbottomAttachment, XmATTACH_POSITION,
72 XmNbottomPosition, 1, 74 XmNbottomPosition, 1,
73 XmNleftAttachment, XmATTACH_POSITION, 75 XmNleftAttachment, XmATTACH_POSITION,
74 XmNleftPosition, 1, 76 XmNleftPosition, 1,
75 XmNrightAttachment, XmATTACH_POSITION, 77 XmNrightAttachment, XmATTACH_POSITION,
76 XmNrightPosition, 2, 78 XmNrightPosition, 2,
77 XmNarrowDirection, XmARROW_UP, 79 XmNarrowDirection, XmARROW_UP,
78 NULL); 80 NULL);
79 81
80 XtVaSetValues (arrow, 82 XtVaSetValues (arrow,
81 XmNuserData, True, 83 XmNuserData, True,
82 NULL); 84 NULL);
83 85
84 XtAddCallbacks (arrow, 86 XtAddCallbacks (arrow,
85 XmNactivateCallback, 87 XmNactivateCallback,
86 arrow_callbacks[0]); 88 arrow_callbacks[0]);
87 89
88 XtAddCallbacks (arrow, 90 XtAddCallbacks (arrow,
89 XmNarmCallback, 91 XmNarmCallback,
90 arrow_callbacks[0]); 92 arrow_callbacks[0]);
91 93
92 XtAddCallbacks (arrow, 94 XtAddCallbacks (arrow,
93 XmNdisarmCallback, 95 XmNdisarmCallback,
94 arrow_callbacks[0]); 96 arrow_callbacks[0]);
95 97
96 arrow = XtVaCreateManagedWidget 98 arrow = XtVaCreateManagedWidget
97 ("down_arrow", 99 ("down_arrow",
98 xmArrowButtonGadgetClass, 100 xmArrowButtonGadgetClass,
99 arrow_form, 101 arrow_form,
100 XmNtopAttachment, XmATTACH_POSITION, 102 XmNtopAttachment, XmATTACH_POSITION,
101 XmNtopPosition, 2, 103 XmNtopPosition, 2,
102 XmNbottomAttachment, XmATTACH_POSITION, 104 XmNbottomAttachment, XmATTACH_POSITION,
103 XmNbottomPosition, 3, 105 XmNbottomPosition, 3,
104 XmNleftAttachment, XmATTACH_POSITION, 106 XmNleftAttachment, XmATTACH_POSITION,
105 XmNleftPosition, 1, 107 XmNleftPosition, 1,
106 XmNrightAttachment, XmATTACH_POSITION, 108 XmNrightAttachment, XmATTACH_POSITION,
107 XmNrightPosition, 2, 109 XmNrightPosition, 2,
108 XmNarrowDirection, XmARROW_DOWN, 110 XmNarrowDirection, XmARROW_DOWN,
109 NULL); 111 NULL);
110 112
111 XtVaSetValues (arrow, 113 XtVaSetValues (arrow,
112 XmNuserData, False, 114 XmNuserData, False,
113 NULL); 115 NULL);
114 116
115 XtAddCallbacks (arrow, 117 XtAddCallbacks (arrow,
116 XmNactivateCallback, 118 XmNactivateCallback,
117 arrow_callbacks[1]); 119 arrow_callbacks[1]);
118 120
119 XtAddCallbacks (arrow, 121 XtAddCallbacks (arrow,
120 XmNarmCallback, 122 XmNarmCallback,
121 arrow_callbacks[1]); 123 arrow_callbacks[1]);
122 124
123 XtAddCallbacks (arrow, 125 XtAddCallbacks (arrow,
124 XmNdisarmCallback, 126 XmNdisarmCallback,
125 arrow_callbacks[1]); 127 arrow_callbacks[1]);
126 128
127 arrow = XtVaCreateManagedWidget 129 arrow = XtVaCreateManagedWidget
128 ("left_arrow", 130 ("left_arrow",
129 xmArrowButtonGadgetClass, 131 xmArrowButtonGadgetClass,
130 arrow_form, 132 arrow_form,
131 XmNtopAttachment, XmATTACH_POSITION, 133 XmNtopAttachment, XmATTACH_POSITION,
132 XmNtopPosition, 1, 134 XmNtopPosition, 1,
133 XmNbottomAttachment, XmATTACH_POSITION, 135 XmNbottomAttachment, XmATTACH_POSITION,
134 XmNbottomPosition, 2, 136 XmNbottomPosition, 2,
135 XmNleftAttachment, XmATTACH_POSITION, 137 XmNleftAttachment, XmATTACH_POSITION,
136 XmNleftPosition, 0, 138 XmNleftPosition, 0,
137 XmNrightAttachment, XmATTACH_POSITION, 139 XmNrightAttachment, XmATTACH_POSITION,
138 XmNrightPosition, 1, 140 XmNrightPosition, 1,
139 XmNarrowDirection, XmARROW_LEFT, 141 XmNarrowDirection, XmARROW_LEFT,
140 NULL); 142 NULL);
141 143
142 XtVaSetValues (arrow, 144 XtVaSetValues (arrow,
143 XmNuserData, False, 145 XmNuserData, False,
144 NULL); 146 NULL);
145 147
146 XtAddCallbacks (arrow, 148 XtAddCallbacks (arrow,
147 XmNactivateCallback, 149 XmNactivateCallback,
148 arrow_callbacks[2]); 150 arrow_callbacks[2]);
149 151
150 XtAddCallbacks (arrow, 152 XtAddCallbacks (arrow,
151 XmNarmCallback, 153 XmNarmCallback,
152 arrow_callbacks[2]); 154 arrow_callbacks[2]);
153 155
154 XtAddCallbacks (arrow, 156 XtAddCallbacks (arrow,
155 XmNdisarmCallback, 157 XmNdisarmCallback,
156 arrow_callbacks[2]); 158 arrow_callbacks[2]);
157 159
158 arrow = XtVaCreateManagedWidget 160 arrow = XtVaCreateManagedWidget
159 ("right_arrow", 161 ("right_arrow",
160 xmArrowButtonGadgetClass, 162 xmArrowButtonGadgetClass,
161 arrow_form, 163 arrow_form,
162 XmNtopAttachment, XmATTACH_POSITION, 164 XmNtopAttachment, XmATTACH_POSITION,
163 XmNtopPosition, 1, 165 XmNtopPosition, 1,
164 XmNbottomAttachment, XmATTACH_POSITION, 166 XmNbottomAttachment, XmATTACH_POSITION,
165 XmNbottomPosition, 2, 167 XmNbottomPosition, 2,
166 XmNleftAttachment, XmATTACH_POSITION, 168 XmNleftAttachment, XmATTACH_POSITION,
167 XmNleftPosition, 2, 169 XmNleftPosition, 2,
168 XmNrightAttachment, XmATTACH_POSITION, 170 XmNrightAttachment, XmATTACH_POSITION,
169 XmNrightPosition, 3, 171 XmNrightPosition, 3,
170 XmNarrowDirection, XmARROW_RIGHT, 172 XmNarrowDirection, XmARROW_RIGHT,
171 NULL); 173 NULL);
172 174
173 XtVaSetValues (arrow, 175 XtVaSetValues (arrow,
174 XmNuserData, True, 176 XmNuserData, True,
175 NULL); 177 NULL);
176 178
177 XtAddCallbacks (arrow, 179 XtAddCallbacks (arrow,
178 XmNactivateCallback, 180 XmNactivateCallback,
179 arrow_callbacks[3]); 181 arrow_callbacks[3]);
180 182
181 XtAddCallbacks (arrow, 183 XtAddCallbacks (arrow,
182 XmNarmCallback, 184 XmNarmCallback,
183 arrow_callbacks[3]); 185 arrow_callbacks[3]);
184 186
185 XtAddCallbacks (arrow, 187 XtAddCallbacks (arrow,
186 XmNdisarmCallback, 188 XmNdisarmCallback,
187 arrow_callbacks[3]); 189 arrow_callbacks[3]);
188 190
189 XtManageChild (arrow_form); 191 XtManageChild (arrow_form);
190 192
191 } 193 }
192 194
193 void G4OpenGLXmViewer::Add_radio_box (char* la 195 void G4OpenGLXmViewer::Add_radio_box (char* label_string,
194 Widget* parent_widget, 196 Widget* parent_widget,
195 XtCallbackRec* radio_box_callback, 197 XtCallbackRec* radio_box_callback,
196 G4int num_buttons, 198 G4int num_buttons,
197 G4int default_button, 199 G4int default_button,
198 char* radio_box_name, 200 char* radio_box_name,
199 char** button_names, 201 char** button_names,
200 G4OpenGLXmViewer* pView) 202 G4OpenGLXmViewer* pView)
201 { 203 {
202 XmString button_str = XmStringCreateLocalize << 204 XmString button_str = XmStringCreateLocalized((char*) ""); // ...to
203 // initialise to something to avoid pedantic 205 // initialise to something to avoid pedantic warning.
204 Arg** args; 206 Arg** args;
205 args = new Arg* [num_buttons]; 207 args = new Arg* [num_buttons];
206 Widget button; 208 Widget button;
207 209
208 G4int i; 210 G4int i;
209 for (i = 0; i < num_buttons; i++) { 211 for (i = 0; i < num_buttons; i++) {
210 212
211 args[i] = new Arg[7]; 213 args[i] = new Arg[7];
212 button_str = XmStringCreateLocalized (butt 214 button_str = XmStringCreateLocalized (button_names[i]);
213 215
214 XtSetArg (args[i][0], XtNvisual, pView->vi 216 XtSetArg (args[i][0], XtNvisual, pView->vi->visual);
215 XtSetArg (args[i][1], XtNdepth, pView->vi- 217 XtSetArg (args[i][1], XtNdepth, pView->vi->depth);
216 XtSetArg (args[i][2], XtNcolormap, pView-> 218 XtSetArg (args[i][2], XtNcolormap, pView->cmap);
217 XtSetArg (args[i][3], XtNborderColor, pVie 219 XtSetArg (args[i][3], XtNborderColor, pView->borcol);
218 XtSetArg (args[i][4], XtNbackground, pView 220 XtSetArg (args[i][4], XtNbackground, pView->bgnd);
219 XtSetArg (args[i][5], XmNlabelString, butt 221 XtSetArg (args[i][5], XmNlabelString, button_str);
220 222
221 if (i == default_button) { 223 if (i == default_button) {
222 XtSetArg (args[i][6], XmNset, True); 224 XtSetArg (args[i][6], XmNset, True);
223 } else { 225 } else {
224 XtSetArg (args[i][6], XmNset, False); 226 XtSetArg (args[i][6], XmNset, False);
225 } 227 }
226 } 228 }
227 229
228 Widget radio_box = XtVaCreateWidget (radio_b 230 Widget radio_box = XtVaCreateWidget (radio_box_name,
229 xmRowColumnWidgetClass, 231 xmRowColumnWidgetClass,
230 *parent_widget, 232 *parent_widget,
231 XmNisHomogeneous, False, 233 XmNisHomogeneous, False,
232 XmNradioBehavior, True, 234 XmNradioBehavior, True,
233 XmNradioAlwaysOne, True, 235 XmNradioAlwaysOne, True,
234 XmNuserData, pView, 236 XmNuserData, pView,
235 XtNvisual, pView->vi->visual, 237 XtNvisual, pView->vi->visual,
236 XtNdepth, pView->vi->depth, 238 XtNdepth, pView->vi->depth,
237 XtNcolormap, pView->cmap, 239 XtNcolormap, pView->cmap,
238 XtNborderColor, pView->borcol, 240 XtNborderColor, pView->borcol,
239 XtNbackground, pView->bgnd, 241 XtNbackground, pView->bgnd,
240 NULL); 242 NULL);
241 243
242 XmString lab = XmStringCreateLocalized (labe 244 XmString lab = XmStringCreateLocalized (label_string);
243 245
244 // Unused! 246 // Unused!
245 //Widget label = XtVaCreateManagedWidget ("r 247 //Widget label = XtVaCreateManagedWidget ("radio_label",
246 // xmLabelWidgetClass, 248 // xmLabelWidgetClass,
247 // radio_box, 249 // radio_box,
248 // XmNalignment, XmALIGNMENT_CENTER 250 // XmNalignment, XmALIGNMENT_CENTER,
249 // XmNlabelString, lab, 251 // XmNlabelString, lab,
250 // XtNvisual, pView->vi->visual, 252 // XtNvisual, pView->vi->visual,
251 // XtNdepth, pView->vi->depth, 253 // XtNdepth, pView->vi->depth,
252 // XtNcolormap, pView->cmap, 254 // XtNcolormap, pView->cmap,
253 // XtNborderColor, pView->borcol, 255 // XtNborderColor, pView->borcol,
254 // XtNbackground, pView->bgnd, 256 // XtNbackground, pView->bgnd,
255 // NULL); 257 // NULL);
256 258
257 XmStringFree (lab); 259 XmStringFree (lab);
258 260
259 for (i = 0; i < num_buttons; i++) { 261 for (i = 0; i < num_buttons; i++) {
260 button = XtCreateManagedWidget (button_nam 262 button = XtCreateManagedWidget (button_names[i],
261 xmToggleButtonWidgetClass, 263 xmToggleButtonWidgetClass,
262 radio_box, 264 radio_box,
263 args[i], 265 args[i],
264 7); 266 7);
265 XtVaSetValues (button, 267 XtVaSetValues (button,
266 XmNuserData, i, 268 XmNuserData, i,
267 NULL); 269 NULL);
268 270
269 XtAddCallbacks (button, 271 XtAddCallbacks (button,
270 XmNarmCallback, 272 XmNarmCallback,
271 radio_box_callback); 273 radio_box_callback);
272 } 274 }
273 275
274 XtManageChild (radio_box); 276 XtManageChild (radio_box);
275 277
276 XmStringFree (button_str); 278 XmStringFree (button_str);
277 279
278 for (i = 0; i < num_buttons; i++) { 280 for (i = 0; i < num_buttons; i++) {
279 281
280 delete[] args[i]; 282 delete[] args[i];
281 283
282 } 284 }
283 285
284 delete[] args; 286 delete[] args;
285 } 287 }
286 288
287 void G4OpenGLXmViewer::Add_set_field (char* w_ 289 void G4OpenGLXmViewer::Add_set_field (char* w_name,
288 char* w_text, 290 char* w_text,
289 Widget* row_col_box, 291 Widget* row_col_box,
290 Widget* wid, 292 Widget* wid,
291 G4double* val, 293 G4double* val,
292 G4OpenGLXmViewer* pView) 294 G4OpenGLXmViewer* pView)
293 { 295 {
294 296
295 char local_w_text[50]; 297 char local_w_text[50];
296 strcpy (local_w_text, w_text); 298 strcpy (local_w_text, w_text);
297 299
298 char label_name[50]; 300 char label_name[50];
299 strcpy (label_name, w_name); 301 strcpy (label_name, w_name);
300 strcat (label_name, "_label"); 302 strcat (label_name, "_label");
301 303
302 char text_field_name[50]; 304 char text_field_name[50];
303 strcpy (text_field_name, w_name); 305 strcpy (text_field_name, w_name);
304 strcat (text_field_name, "_text_field"); 306 strcat (text_field_name, "_text_field");
305 307
306 XmString local_text = XmStringCreateLocalize 308 XmString local_text = XmStringCreateLocalized (local_w_text);
307 309
308 // Unused! 310 // Unused!
309 // Widget label = XtVaCreateManagedWidget ( 311 // Widget label = XtVaCreateManagedWidget (label_name,
310 // xmLabelWidgetClass, 312 // xmLabelWidgetClass,
311 // *row_col_box, 313 // *row_col_box,
312 // XmNlabelString, local_text, 314 // XmNlabelString, local_text,
313 // XtNvisual, pView->vi->visual, 315 // XtNvisual, pView->vi->visual,
314 // XtNdepth, pView->vi->depth, 316 // XtNdepth, pView->vi->depth,
315 // XtNcolormap, pView->cmap, 317 // XtNcolormap, pView->cmap,
316 // XtNborderColor, pView->borcol, 318 // XtNborderColor, pView->borcol,
317 // XtNbackground, pView->bgnd, 319 // XtNbackground, pView->bgnd,
318 // NULL); 320 // NULL);
319 321
320 XmStringFree (local_text); 322 XmStringFree (local_text);
321 323
322 char initial[50]; 324 char initial[50];
323 snprintf (initial, sizeof initial, "%6.2f", << 325 sprintf (initial, "%6.2f", *val);
324 326
325 *wid = XtVaCreateManagedWidget (text_field_n 327 *wid = XtVaCreateManagedWidget (text_field_name,
326 xmTextFieldWidgetClass, 328 xmTextFieldWidgetClass,
327 *row_col_box, 329 *row_col_box,
328 XmNvalue, (String)initial, 330 XmNvalue, (String)initial,
329 XtNvisual, pView->vi->visual, 331 XtNvisual, pView->vi->visual,
330 XtNdepth, pView->vi->depth, 332 XtNdepth, pView->vi->depth,
331 XtNcolormap, pView->cmap, 333 XtNcolormap, pView->cmap,
332 XtNborderColor, pView->borcol, 334 XtNborderColor, pView->borcol,
333 XtNbackground, pView->bgnd, 335 XtNbackground, pView->bgnd,
334 NULL); 336 NULL);
335 337
336 XtAddCallback (*wid, 338 XtAddCallback (*wid,
337 XmNvalueChangedCallback, 339 XmNvalueChangedCallback,
338 get_double_value_callback, 340 get_double_value_callback,
339 val); 341 val);
340 342
341 /* Not actually used - comment out to preven 343 /* Not actually used - comment out to prevent compiler warnings.
342 Instead, just in case it matters, just in 344 Instead, just in case it matters, just invoke
343 XtVaCreateManagedWidget (JA) 345 XtVaCreateManagedWidget (JA)
344 Widget sep = XtVaCreateManagedWidget ("sep", 346 Widget sep = XtVaCreateManagedWidget ("sep",
345 xmSeparatorWidgetClass, 347 xmSeparatorWidgetClass,
346 *row_col_box, 348 *row_col_box,
347 XmNorientation, XmHORIZONTAL, 349 XmNorientation, XmHORIZONTAL,
348 XtNvisual, pView->vi->visual, 350 XtNvisual, pView->vi->visual,
349 XtNdepth, pView->vi->depth, 351 XtNdepth, pView->vi->depth,
350 XtNcolormap, pView->cmap, 352 XtNcolormap, pView->cmap,
351 XtNborderColor, pView->borcol, 353 XtNborderColor, pView->borcol,
352 XtNbackground, pView->bgnd, 354 XtNbackground, pView->bgnd,
353 NULL); 355 NULL);
354 sep = XtVaCreateManagedWidget ("sep", 356 sep = XtVaCreateManagedWidget ("sep",
355 xmSeparatorWidgetClass, 357 xmSeparatorWidgetClass,
356 *row_col_box, 358 *row_col_box,
357 XmNseparatorType, XmNO_LINE, 359 XmNseparatorType, XmNO_LINE,
358 XmNmargin, 1, 360 XmNmargin, 1,
359 XmNorientation, XmHORIZONTAL, 361 XmNorientation, XmHORIZONTAL,
360 XtNvisual, pView->vi->visual, 362 XtNvisual, pView->vi->visual,
361 XtNdepth, pView->vi->depth, 363 XtNdepth, pView->vi->depth,
362 XtNcolormap, pView->cmap, 364 XtNcolormap, pView->cmap,
363 XtNborderColor, pView->borcol, 365 XtNborderColor, pView->borcol,
364 XtNbackground, pView->bgnd, 366 XtNbackground, pView->bgnd,
365 NULL); 367 NULL);
366 */ 368 */
367 XtVaCreateManagedWidget ("sep", 369 XtVaCreateManagedWidget ("sep",
368 xmSeparatorWidgetClass, 370 xmSeparatorWidgetClass,
369 *row_col_box, 371 *row_col_box,
370 XmNseparatorType, XmNO_LINE, 372 XmNseparatorType, XmNO_LINE,
371 XmNmargin, 1, 373 XmNmargin, 1,
372 XmNorientation, XmHORIZONTAL, 374 XmNorientation, XmHORIZONTAL,
373 XtNvisual, pView->vi->visual, 375 XtNvisual, pView->vi->visual,
374 XtNdepth, pView->vi->depth, 376 XtNdepth, pView->vi->depth,
375 XtNcolormap, pView->cmap, 377 XtNcolormap, pView->cmap,
376 XtNborderColor, pView->borcol, 378 XtNborderColor, pView->borcol,
377 XtNbackground, pView->bgnd, 379 XtNbackground, pView->bgnd,
378 NULL); 380 NULL);
379 } 381 }
380 382
381 void G4OpenGLXmViewer::Add_slider_box (char* l 383 void G4OpenGLXmViewer::Add_slider_box (char* label_string,
382 G4int num_sliders, 384 G4int num_sliders,
383 char** slider_names, 385 char** slider_names,
384 G4OpenGLXmViewer* pView, 386 G4OpenGLXmViewer* pView,
385 G4double* min_array, 387 G4double* min_array,
386 G4double* max_array, 388 G4double* max_array,
387 G4double* value_array, 389 G4double* value_array,
388 G4bool* show, 390 G4bool* show,
389 short* decimals, 391 short* decimals,
390 unsigned char* orientation, 392 unsigned char* orientation,
391 unsigned char* direction, 393 unsigned char* direction,
392 XtCallbackRec** slider_box_callba 394 XtCallbackRec** slider_box_callbacks,
393 Widget* parent_widget) 395 Widget* parent_widget)
394 { 396 {
395 XmString slider_name_str = XmStringCreateLoc << 397 XmString slider_name_str = XmStringCreateLocalized((char*) ""); // ...to
396 // initialise to something to avoid pedantic 398 // initialise to something to avoid pedantic warning.
397 Arg** slider_args; 399 Arg** slider_args;
398 slider_args = new Arg*[num_sliders]; 400 slider_args = new Arg*[num_sliders];
399 Widget slider; 401 Widget slider;
400 G4int j = 0; 402 G4int j = 0;
401 403
402 G4int i; 404 G4int i;
403 for (i = 0; i < num_sliders; i++) { 405 for (i = 0; i < num_sliders; i++) {
404 j = 0; 406 j = 0;
405 slider_args[i] = new Arg[13]; 407 slider_args[i] = new Arg[13];
406 slider_name_str = XmStringCreateLtoR (slid 408 slider_name_str = XmStringCreateLtoR (slider_names[i],
407 XmFONTLIST_DEFAULT_TAG); 409 XmFONTLIST_DEFAULT_TAG);
408 410
409 XtSetArg (slider_args[i][j], 411 XtSetArg (slider_args[i][j],
410 XtNvisual, pView->vi->visual); j++; 412 XtNvisual, pView->vi->visual); j++;
411 XtSetArg (slider_args[i][j], 413 XtSetArg (slider_args[i][j],
412 XtNdepth, pView->vi->depth); j++; 414 XtNdepth, pView->vi->depth); j++;
413 XtSetArg (slider_args[i][j], 415 XtSetArg (slider_args[i][j],
414 XtNcolormap, pView->cmap); j++; 416 XtNcolormap, pView->cmap); j++;
415 XtSetArg (slider_args[i][j], 417 XtSetArg (slider_args[i][j],
416 XtNborderColor, pView->borcol); j++; 418 XtNborderColor, pView->borcol); j++;
417 XtSetArg (slider_args[i][j], 419 XtSetArg (slider_args[i][j],
418 XtNbackground, pView->bgnd); j++; 420 XtNbackground, pView->bgnd); j++;
419 421
420 XtSetArg (slider_args[i][j], 422 XtSetArg (slider_args[i][j],
421 XmNtitleString, slider_name_str); j++ 423 XmNtitleString, slider_name_str); j++;
422 424
423 XtSetArg (slider_args[i][j], 425 XtSetArg (slider_args[i][j],
424 XmNmaximum, G4int(max_array[i] * std:: 426 XmNmaximum, G4int(max_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
425 XtSetArg (slider_args[i][j], 427 XtSetArg (slider_args[i][j],
426 XmNminimum, G4int(min_array[i] * std:: 428 XmNminimum, G4int(min_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
427 XtSetArg (slider_args[i][j], 429 XtSetArg (slider_args[i][j],
428 XmNvalue, G4int(value_array[i] * std:: 430 XmNvalue, G4int(value_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
429 XtSetArg (slider_args[i][j], 431 XtSetArg (slider_args[i][j],
430 XmNshowValue, show[i]); j++; 432 XmNshowValue, show[i]); j++;
431 XtSetArg (slider_args[i][j], 433 XtSetArg (slider_args[i][j],
432 XmNdecimalPoints, decimals[i]); j++; 434 XmNdecimalPoints, decimals[i]); j++;
433 435
434 XtSetArg (slider_args[i][j], 436 XtSetArg (slider_args[i][j],
435 XmNorientation, orientation[i]); j++; 437 XmNorientation, orientation[i]); j++;
436 XtSetArg (slider_args[i][j], 438 XtSetArg (slider_args[i][j],
437 XmNprocessingDirection, direction[i]); 439 XmNprocessingDirection, direction[i]); j++;
438 440
439 } 441 }
440 442
441 Widget slider_box = XtVaCreateWidget ("slide 443 Widget slider_box = XtVaCreateWidget ("slider_box",
442 xmRowColumnWidgetClass, 444 xmRowColumnWidgetClass,
443 *parent_widget, 445 *parent_widget,
444 XmNisHomogeneous, False, 446 XmNisHomogeneous, False,
445 XtNvisual, pView->vi->visual, 447 XtNvisual, pView->vi->visual,
446 XtNdepth, pView->vi->depth, 448 XtNdepth, pView->vi->depth,
447 XtNcolormap, pView->cmap, 449 XtNcolormap, pView->cmap,
448 XtNborderColor, pView->borcol, 450 XtNborderColor, pView->borcol,
449 XtNbackground, pView->bgnd, 451 XtNbackground, pView->bgnd,
450 NULL); 452 NULL);
451 453
452 XmString lab = XmStringCreateLocalized (labe 454 XmString lab = XmStringCreateLocalized (label_string);
453 455
454 // Unused! 456 // Unused!
455 //Widget label = XtVaCreateManagedWidget ("s 457 //Widget label = XtVaCreateManagedWidget ("slider_label",
456 // xmLabelWidgetClass, 458 // xmLabelWidgetClass,
457 // slider_box, 459 // slider_box,
458 // XmNlabelString, lab, 460 // XmNlabelString, lab,
459 // XmNalignment, XmALIGNMENT_CENTER 461 // XmNalignment, XmALIGNMENT_CENTER,
460 // XtNvisual, pView->vi->visual, 462 // XtNvisual, pView->vi->visual,
461 // XtNdepth, pView->vi->depth, 463 // XtNdepth, pView->vi->depth,
462 // XtNcolormap, pView->cmap, 464 // XtNcolormap, pView->cmap,
463 // XtNborderColor, pView->borcol, 465 // XtNborderColor, pView->borcol,
464 // XtNbackground, pView->bgnd, 466 // XtNbackground, pView->bgnd,
465 // NULL); 467 // NULL);
466 468
467 XmStringFree (lab); 469 XmStringFree (lab);
468 470
469 for (i = 0; i < num_sliders; i++) { 471 for (i = 0; i < num_sliders; i++) {
470 472
471 slider = XtCreateManagedWidget (slider_nam 473 slider = XtCreateManagedWidget (slider_names[i],
472 xmScaleWidgetClass, 474 xmScaleWidgetClass,
473 slider_box, 475 slider_box,
474 slider_args[i], 476 slider_args[i],
475 j); 477 j);
476 478
477 XtAddCallbacks (slider, 479 XtAddCallbacks (slider,
478 XmNvalueChangedCallback, 480 XmNvalueChangedCallback,
479 slider_box_callbacks[i]); 481 slider_box_callbacks[i]);
480 482
481 XtAddCallbacks (slider, 483 XtAddCallbacks (slider,
482 XmNdragCallback, 484 XmNdragCallback,
483 slider_box_callbacks[i]); 485 slider_box_callbacks[i]);
484 486
485 } 487 }
486 488
487 XtManageChild (slider_box); 489 XtManageChild (slider_box);
488 XmStringFree (slider_name_str); 490 XmStringFree (slider_name_str);
489 491
490 for (i = 0; i < num_sliders; i++) { 492 for (i = 0; i < num_sliders; i++) {
491 493
492 delete[] slider_args[i]; 494 delete[] slider_args[i];
493 495
494 } 496 }
495 497
496 delete[] slider_args; 498 delete[] slider_args;
497 499
498 } 500 }
499 501
500 void G4OpenGLXmViewer::get_double_value_callba 502 void G4OpenGLXmViewer::get_double_value_callback (Widget w,
501 XtPointer clientData, 503 XtPointer clientData,
502 XtPointer) 504 XtPointer)
503 { 505 {
504 G4double* val = (G4double*) clientData; 506 G4double* val = (G4double*) clientData;
505 String string; 507 String string;
506 508
507 XtVaGetValues (w, 509 XtVaGetValues (w,
508 XmNvalue, &string, 510 XmNvalue, &string,
509 NULL); 511 NULL);
510 512
511 // sscanf (string, "%lg", val); 513 // sscanf (string, "%lg", val);
512 std::istringstream iss(string); 514 std::istringstream iss(string);
513 iss >> *val; 515 iss >> *val;
514 } 516 }
515 517
516 void G4OpenGLXmViewer::get_text_callback (Widg 518 void G4OpenGLXmViewer::get_text_callback (Widget w,
517 XtPointer clientData, 519 XtPointer clientData,
518 XtPointer) 520 XtPointer)
519 { 521 {
520 char* txt = (char*)clientData; 522 char* txt = (char*)clientData;
521 String string; 523 String string;
522 524
523 XtVaGetValues (w, 525 XtVaGetValues (w,
524 XmNvalue, &string, 526 XmNvalue, &string,
525 NULL); 527 NULL);
526 528
527 strcpy(txt, string); << 529 // sscanf (string, "%s", txt);
>> 530 std::istringstream iss(string);
>> 531 iss >> txt;
528 } 532 }
529 533
530 G4bool G4OpenGLXmViewer::get_boolean_userData 534 G4bool G4OpenGLXmViewer::get_boolean_userData (Widget w)
531 { 535 {
532 XtPointer userData; 536 XtPointer userData;
533 XtVaGetValues (w,XmNuserData,&userData,NULL) 537 XtVaGetValues (w,XmNuserData,&userData,NULL);
534 return (G4bool)(((unsigned long)userData)&0x 538 return (G4bool)(((unsigned long)userData)&0xffff);
535 } 539 }
536 540
537 G4int G4OpenGLXmViewer::get_int_userData (Widg 541 G4int G4OpenGLXmViewer::get_int_userData (Widget w)
538 { 542 {
539 XtPointer userData; 543 XtPointer userData;
540 XtVaGetValues (w,XmNuserData,&userData,NULL) 544 XtVaGetValues (w,XmNuserData,&userData,NULL);
541 return (G4int)(unsigned long)userData; 545 return (G4int)(unsigned long)userData;
542 } 546 }
>> 547
>> 548 #endif
>> 549
>> 550
>> 551
>> 552
>> 553
543 554