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