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