Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLXmConvenienceRoutines.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenGL/src/G4OpenGLXmConvenienceRoutines.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLXmConvenienceRoutines.cc (Version 8.0.p1)


  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.10 2004/12/07 23:40:59 perl Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-08-00-patch-01 $
 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   XmString button_str = XmStringCreateLocalized((char*) ""); // ...to
203   // initialise to something to avoid pedantic    194   // initialise to something to avoid pedantic warning.
204   Arg** args;                                     195   Arg** args;
205   args = new Arg* [num_buttons];                  196   args = new Arg* [num_buttons];
206   Widget button;                                  197   Widget button;
207                                                   198 
208   G4int i;                                        199   G4int i;
209   for (i = 0; i < num_buttons; i++) {             200   for (i = 0; i < num_buttons; i++) {
210                                                   201 
211     args[i] = new Arg[7];                         202     args[i] = new Arg[7];
212     button_str = XmStringCreateLocalized (butt    203     button_str = XmStringCreateLocalized (button_names[i]);
213                                                   204 
214     XtSetArg (args[i][0], XtNvisual, pView->vi    205     XtSetArg (args[i][0], XtNvisual, pView->vi->visual);
215     XtSetArg (args[i][1], XtNdepth, pView->vi-    206     XtSetArg (args[i][1], XtNdepth, pView->vi->depth);
216     XtSetArg (args[i][2], XtNcolormap, pView->    207     XtSetArg (args[i][2], XtNcolormap, pView->cmap);
217     XtSetArg (args[i][3], XtNborderColor, pVie    208     XtSetArg (args[i][3], XtNborderColor, pView->borcol);
218     XtSetArg (args[i][4], XtNbackground, pView    209     XtSetArg (args[i][4], XtNbackground, pView->bgnd);
219     XtSetArg (args[i][5], XmNlabelString, butt    210     XtSetArg (args[i][5], XmNlabelString, button_str); 
220                                                   211 
221     if (i == default_button) {                    212     if (i == default_button) {
222       XtSetArg (args[i][6], XmNset, True);        213       XtSetArg (args[i][6], XmNset, True);
223     } else {                                      214     } else {
224       XtSetArg (args[i][6], XmNset, False);       215       XtSetArg (args[i][6], XmNset, False);
225     }                                             216     }
226   }                                               217   }
227                                                   218   
228   Widget radio_box = XtVaCreateWidget (radio_b    219   Widget radio_box = XtVaCreateWidget (radio_box_name,
229                xmRowColumnWidgetClass,            220                xmRowColumnWidgetClass,
230                *parent_widget,                    221                *parent_widget,
231                XmNisHomogeneous, False,           222                XmNisHomogeneous, False,
232                XmNradioBehavior, True,            223                XmNradioBehavior, True,
233                XmNradioAlwaysOne, True,           224                XmNradioAlwaysOne, True,
234                XmNuserData, pView,                225                XmNuserData, pView,
235                XtNvisual, pView->vi->visual,      226                XtNvisual, pView->vi->visual,
236                XtNdepth, pView->vi->depth,        227                XtNdepth, pView->vi->depth,
237                XtNcolormap, pView->cmap,          228                XtNcolormap, pView->cmap,
238                XtNborderColor, pView->borcol,     229                XtNborderColor, pView->borcol,
239                XtNbackground, pView->bgnd,        230                XtNbackground, pView->bgnd,
240                NULL);                             231                NULL);
241                                                   232 
242   XmString lab = XmStringCreateLocalized (labe    233   XmString lab = XmStringCreateLocalized (label_string);
243                                                   234 
244   // Unused!                                      235   // Unused!
245   //Widget label = XtVaCreateManagedWidget ("r    236   //Widget label = XtVaCreateManagedWidget ("radio_label",
246   //          xmLabelWidgetClass,                 237   //          xmLabelWidgetClass,
247   //          radio_box,                          238   //          radio_box,
248   //          XmNalignment, XmALIGNMENT_CENTER    239   //          XmNalignment, XmALIGNMENT_CENTER,
249   //          XmNlabelString, lab,                240   //          XmNlabelString, lab,
250   //          XtNvisual, pView->vi->visual,       241   //          XtNvisual, pView->vi->visual,
251   //          XtNdepth, pView->vi->depth,         242   //          XtNdepth, pView->vi->depth,
252   //          XtNcolormap, pView->cmap,           243   //          XtNcolormap, pView->cmap,
253   //          XtNborderColor, pView->borcol,      244   //          XtNborderColor, pView->borcol,
254   //          XtNbackground, pView->bgnd,         245   //          XtNbackground, pView->bgnd,
255   //          NULL);                              246   //          NULL);
256                                                   247 
257   XmStringFree (lab);                             248   XmStringFree (lab);
258                                                   249 
259   for (i = 0; i < num_buttons; i++) {             250   for (i = 0; i < num_buttons; i++) {
260     button = XtCreateManagedWidget (button_nam    251     button = XtCreateManagedWidget (button_names[i],
261             xmToggleButtonWidgetClass,            252             xmToggleButtonWidgetClass,
262             radio_box,                            253             radio_box,
263             args[i],                              254             args[i],
264             7);                                   255             7);
265     XtVaSetValues (button,                        256     XtVaSetValues (button,
266        XmNuserData, i,                            257        XmNuserData, i,
267        NULL);                                     258        NULL);
268                                                   259     
269     XtAddCallbacks (button,                       260     XtAddCallbacks (button,
270        XmNarmCallback,                            261        XmNarmCallback,
271        radio_box_callback);                       262        radio_box_callback);
272   }                                               263   }
273                                                   264 
274   XtManageChild (radio_box);                      265   XtManageChild (radio_box);
275                                                   266 
276   XmStringFree (button_str);                      267   XmStringFree (button_str);
277                                                   268   
278   for (i = 0; i < num_buttons; i++) {             269   for (i = 0; i < num_buttons; i++) {
279                                                   270 
280     delete[] args[i];                             271     delete[] args[i];
281                                                   272 
282   }                                               273   }
283                                                   274 
284   delete[] args;                                  275   delete[] args;
285 }                                                 276 }  
286                                                   277 
287 void G4OpenGLXmViewer::Add_set_field (char* w_    278 void G4OpenGLXmViewer::Add_set_field (char* w_name, 
288             char* w_text,                         279             char* w_text,
289             Widget* row_col_box,                  280             Widget* row_col_box,
290             Widget* wid,                          281             Widget* wid,
291             G4double* val,                        282             G4double* val,
292             G4OpenGLXmViewer* pView)              283             G4OpenGLXmViewer* pView)
293 {                                                 284 {
294                                                   285 
295   char local_w_text[50];                          286   char local_w_text[50];
296   strcpy (local_w_text, w_text);                  287   strcpy (local_w_text, w_text);
297                                                   288 
298   char label_name[50];                            289   char label_name[50];
299   strcpy (label_name, w_name);                    290   strcpy (label_name, w_name);
300   strcat (label_name, "_label");                  291   strcat (label_name, "_label");
301                                                   292   
302   char text_field_name[50];                       293   char text_field_name[50];
303   strcpy (text_field_name, w_name);               294   strcpy (text_field_name, w_name);
304   strcat (text_field_name, "_text_field");        295   strcat (text_field_name, "_text_field");
305                                                   296   
306   XmString local_text = XmStringCreateLocalize    297   XmString local_text = XmStringCreateLocalized (local_w_text);
307                                                   298 
308   // Unused!                                      299   // Unused!
309   //  Widget label = XtVaCreateManagedWidget (    300   //  Widget label = XtVaCreateManagedWidget (label_name, 
310   //          xmLabelWidgetClass,                 301   //          xmLabelWidgetClass,
311   //          *row_col_box,                       302   //          *row_col_box,
312   //          XmNlabelString, local_text,         303   //          XmNlabelString, local_text,
313   //          XtNvisual, pView->vi->visual,       304   //          XtNvisual, pView->vi->visual, 
314   //          XtNdepth, pView->vi->depth,         305   //          XtNdepth, pView->vi->depth, 
315   //          XtNcolormap, pView->cmap,           306   //          XtNcolormap, pView->cmap, 
316   //          XtNborderColor, pView->borcol,      307   //          XtNborderColor, pView->borcol,
317   //          XtNbackground, pView->bgnd,         308   //          XtNbackground, pView->bgnd,
318   //          NULL);                              309   //          NULL);
319                                                   310 
320   XmStringFree (local_text);                      311   XmStringFree (local_text);
321                                                   312 
322   char initial[50];                               313   char initial[50];
323   snprintf (initial, sizeof initial, "%6.2f",  << 314   sprintf (initial, "%6.2f", *val);
324                                                   315   
325   *wid = XtVaCreateManagedWidget (text_field_n    316   *wid = XtVaCreateManagedWidget (text_field_name,
326           xmTextFieldWidgetClass,                 317           xmTextFieldWidgetClass,
327           *row_col_box,                           318           *row_col_box,
328           XmNvalue, (String)initial,              319           XmNvalue, (String)initial,
329           XtNvisual, pView->vi->visual,           320           XtNvisual, pView->vi->visual, 
330           XtNdepth, pView->vi->depth,             321           XtNdepth, pView->vi->depth, 
331           XtNcolormap, pView->cmap,               322           XtNcolormap, pView->cmap, 
332           XtNborderColor, pView->borcol,          323           XtNborderColor, pView->borcol,
333           XtNbackground, pView->bgnd,             324           XtNbackground, pView->bgnd,
334           NULL);                                  325           NULL);
335                                                   326 
336   XtAddCallback (*wid,                            327   XtAddCallback (*wid, 
337      XmNvalueChangedCallback,                     328      XmNvalueChangedCallback,
338      get_double_value_callback,                   329      get_double_value_callback,
339      val);                                        330      val);
340                                                   331 
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",    332   Widget sep = XtVaCreateManagedWidget ("sep",
345           xmSeparatorWidgetClass,                 333           xmSeparatorWidgetClass,
346           *row_col_box,                           334           *row_col_box,
347           XmNorientation, XmHORIZONTAL,           335           XmNorientation, XmHORIZONTAL,
348           XtNvisual, pView->vi->visual,           336           XtNvisual, pView->vi->visual, 
349           XtNdepth, pView->vi->depth,             337           XtNdepth, pView->vi->depth, 
350           XtNcolormap, pView->cmap,               338           XtNcolormap, pView->cmap, 
351           XtNborderColor, pView->borcol,          339           XtNborderColor, pView->borcol,
352           XtNbackground, pView->bgnd,             340           XtNbackground, pView->bgnd,
353           NULL);                                  341           NULL);
                                                   >> 342 
354   sep = XtVaCreateManagedWidget ("sep",           343   sep = XtVaCreateManagedWidget ("sep",
355          xmSeparatorWidgetClass,                  344          xmSeparatorWidgetClass,
356          *row_col_box,                            345          *row_col_box,
357          XmNseparatorType, XmNO_LINE,             346          XmNseparatorType, XmNO_LINE,
358          XmNmargin, 1,                            347          XmNmargin, 1,
359          XmNorientation, XmHORIZONTAL,            348          XmNorientation, XmHORIZONTAL,
360          XtNvisual, pView->vi->visual,            349          XtNvisual, pView->vi->visual, 
361          XtNdepth, pView->vi->depth,              350          XtNdepth, pView->vi->depth, 
362          XtNcolormap, pView->cmap,                351          XtNcolormap, pView->cmap, 
363          XtNborderColor, pView->borcol,           352          XtNborderColor, pView->borcol,
364          XtNbackground, pView->bgnd,              353          XtNbackground, pView->bgnd,
365          NULL);                                   354          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 }                                                 355 }
380                                                   356 
381 void G4OpenGLXmViewer::Add_slider_box (char* l    357 void G4OpenGLXmViewer::Add_slider_box (char* label_string,
382              G4int num_sliders,                   358              G4int num_sliders,
383              char** slider_names,                 359              char** slider_names,
384              G4OpenGLXmViewer* pView,             360              G4OpenGLXmViewer* pView,
385              G4double* min_array,                 361              G4double* min_array,
386              G4double* max_array,                 362              G4double* max_array,
387              G4double* value_array,               363              G4double* value_array,
388              G4bool* show,                        364              G4bool* show,
389              short* decimals,                     365              short* decimals,
390              unsigned char* orientation,          366              unsigned char* orientation,
391              unsigned char* direction,            367              unsigned char* direction,
392              XtCallbackRec** slider_box_callba    368              XtCallbackRec** slider_box_callbacks,
393              Widget* parent_widget)               369              Widget* parent_widget)
394 {                                                 370 {
395   XmString slider_name_str = XmStringCreateLoc << 371   XmString slider_name_str = XmStringCreateLocalized((char*) ""); // ...to
396   // initialise to something to avoid pedantic    372   // initialise to something to avoid pedantic warning.
397   Arg** slider_args;                              373   Arg** slider_args;
398   slider_args = new Arg*[num_sliders];            374   slider_args = new Arg*[num_sliders];
399   Widget slider;                                  375   Widget slider;
400   G4int j = 0;                                    376   G4int j = 0;
401                                                   377 
402   G4int i;                                        378   G4int i;
403   for (i = 0; i < num_sliders; i++) {             379   for (i = 0; i < num_sliders; i++) {
404     j = 0;                                        380     j = 0; 
405     slider_args[i] = new Arg[13];                 381     slider_args[i] = new Arg[13];
406     slider_name_str = XmStringCreateLtoR (slid    382     slider_name_str = XmStringCreateLtoR (slider_names[i], 
407             XmFONTLIST_DEFAULT_TAG);              383             XmFONTLIST_DEFAULT_TAG);
408                                                   384     
409     XtSetArg (slider_args[i][j],                  385     XtSetArg (slider_args[i][j], 
410         XtNvisual, pView->vi->visual); j++;       386         XtNvisual, pView->vi->visual); j++;
411     XtSetArg (slider_args[i][j],                  387     XtSetArg (slider_args[i][j], 
412         XtNdepth, pView->vi->depth); j++;         388         XtNdepth, pView->vi->depth); j++;
413     XtSetArg (slider_args[i][j],                  389     XtSetArg (slider_args[i][j], 
414         XtNcolormap, pView->cmap); j++;           390         XtNcolormap, pView->cmap); j++;
415     XtSetArg (slider_args[i][j],                  391     XtSetArg (slider_args[i][j], 
416         XtNborderColor, pView->borcol); j++;      392         XtNborderColor, pView->borcol); j++;
417     XtSetArg (slider_args[i][j],                  393     XtSetArg (slider_args[i][j], 
418         XtNbackground, pView->bgnd); j++;         394         XtNbackground, pView->bgnd); j++;
419                                                   395     
420     XtSetArg (slider_args[i][j],                  396     XtSetArg (slider_args[i][j], 
421         XmNtitleString, slider_name_str);  j++    397         XmNtitleString, slider_name_str);  j++;
422                                                   398     
423     XtSetArg (slider_args[i][j],                  399     XtSetArg (slider_args[i][j], 
424         XmNmaximum, G4int(max_array[i] * std::    400         XmNmaximum, G4int(max_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
425     XtSetArg (slider_args[i][j],                  401     XtSetArg (slider_args[i][j], 
426         XmNminimum, G4int(min_array[i] * std::    402         XmNminimum, G4int(min_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
427     XtSetArg (slider_args[i][j],                  403     XtSetArg (slider_args[i][j], 
428         XmNvalue, G4int(value_array[i] * std::    404         XmNvalue, G4int(value_array[i] * std::pow(10.0, (G4double)decimals[i]))); j++;
429     XtSetArg (slider_args[i][j],                  405     XtSetArg (slider_args[i][j], 
430         XmNshowValue, show[i]); j++;              406         XmNshowValue, show[i]); j++;
431     XtSetArg (slider_args[i][j],                  407     XtSetArg (slider_args[i][j], 
432         XmNdecimalPoints, decimals[i]); j++;      408         XmNdecimalPoints, decimals[i]); j++;
433                                                   409     
434     XtSetArg (slider_args[i][j],                  410     XtSetArg (slider_args[i][j], 
435         XmNorientation, orientation[i]);  j++;    411         XmNorientation, orientation[i]);  j++;
436     XtSetArg (slider_args[i][j],                  412     XtSetArg (slider_args[i][j], 
437         XmNprocessingDirection, direction[i]);    413         XmNprocessingDirection, direction[i]); j++;
438                                                   414 
439   }                                               415   }
440                                                   416 
441   Widget slider_box = XtVaCreateWidget ("slide    417   Widget slider_box = XtVaCreateWidget ("slider_box",
442           xmRowColumnWidgetClass,                 418           xmRowColumnWidgetClass,
443           *parent_widget,                         419           *parent_widget,
444           XmNisHomogeneous, False,                420           XmNisHomogeneous, False,
445           XtNvisual, pView->vi->visual,           421           XtNvisual, pView->vi->visual,
446           XtNdepth, pView->vi->depth,             422           XtNdepth, pView->vi->depth,
447           XtNcolormap, pView->cmap,               423           XtNcolormap, pView->cmap,
448           XtNborderColor, pView->borcol,          424           XtNborderColor, pView->borcol,
449           XtNbackground, pView->bgnd,             425           XtNbackground, pView->bgnd,
450           NULL);                                  426           NULL);
451                                                   427 
452   XmString lab = XmStringCreateLocalized (labe    428   XmString lab = XmStringCreateLocalized (label_string);
453                                                   429 
454   // Unused!                                      430   // Unused!
455   //Widget label = XtVaCreateManagedWidget ("s    431   //Widget label = XtVaCreateManagedWidget ("slider_label",
456   //          xmLabelWidgetClass,                 432   //          xmLabelWidgetClass,
457   //          slider_box,                         433   //          slider_box,
458   //          XmNlabelString, lab,                434   //          XmNlabelString, lab,
459   //          XmNalignment, XmALIGNMENT_CENTER    435   //          XmNalignment, XmALIGNMENT_CENTER,
460   //          XtNvisual, pView->vi->visual,       436   //          XtNvisual, pView->vi->visual,
461   //          XtNdepth, pView->vi->depth,         437   //          XtNdepth, pView->vi->depth,
462   //          XtNcolormap, pView->cmap,           438   //          XtNcolormap, pView->cmap,
463   //          XtNborderColor, pView->borcol,      439   //          XtNborderColor, pView->borcol,
464   //          XtNbackground, pView->bgnd,         440   //          XtNbackground, pView->bgnd,
465   //          NULL);                              441   //          NULL);
466                                                   442 
467   XmStringFree (lab);                             443   XmStringFree (lab);
468                                                   444   
469   for (i = 0; i < num_sliders; i++) {             445   for (i = 0; i < num_sliders; i++) {
470                                                   446     
471     slider = XtCreateManagedWidget (slider_nam    447     slider = XtCreateManagedWidget (slider_names[i],
472             xmScaleWidgetClass,                   448             xmScaleWidgetClass,
473             slider_box,                           449             slider_box,
474             slider_args[i],                       450             slider_args[i],
475             j);                                   451             j);
476                                                   452 
477     XtAddCallbacks (slider,                       453     XtAddCallbacks (slider,
478        XmNvalueChangedCallback,                   454        XmNvalueChangedCallback,
479        slider_box_callbacks[i]);                  455        slider_box_callbacks[i]);
480                                                   456     
481     XtAddCallbacks (slider,                       457     XtAddCallbacks (slider,
482        XmNdragCallback,                           458        XmNdragCallback,
483        slider_box_callbacks[i]);                  459        slider_box_callbacks[i]);
484                                                   460     
485   }                                               461   }
486                                                   462 
487   XtManageChild (slider_box);                     463   XtManageChild (slider_box);
488   XmStringFree (slider_name_str);                 464   XmStringFree (slider_name_str);
489                                                   465 
490   for (i = 0; i < num_sliders; i++) {             466   for (i = 0; i < num_sliders; i++) {
491                                                   467 
492     delete[] slider_args[i];                      468     delete[] slider_args[i];
493                                                   469 
494   }                                               470   }
495                                                   471 
496   delete[] slider_args;                           472   delete[] slider_args;
497                                                   473 
498 }                                                 474 }
499                                                   475 
500 void G4OpenGLXmViewer::get_double_value_callba    476 void G4OpenGLXmViewer::get_double_value_callback (Widget w, 
501             XtPointer clientData,                 477             XtPointer clientData, 
502             XtPointer)                            478             XtPointer) 
503 {                                                 479 {
504   G4double* val = (G4double*) clientData;         480   G4double* val = (G4double*) clientData;
505   String string;                                  481   String string;
506                                                   482 
507   XtVaGetValues (w,                               483   XtVaGetValues (w,
508      XmNvalue, &string,                           484      XmNvalue, &string,
509      NULL);                                       485      NULL);
510                                                   486 
511 //  sscanf (string, "%lg", val);               << 487   sscanf (string, "%lg", val);
512   std::istringstream iss(string);              << 488 
513   iss >> *val;                                 << 
514 }                                                 489 }
515                                                   490 
516 void G4OpenGLXmViewer::get_text_callback (Widg    491 void G4OpenGLXmViewer::get_text_callback (Widget w, 
517           XtPointer clientData,                   492           XtPointer clientData, 
518           XtPointer)                              493           XtPointer) 
519 {                                                 494 {
520   char* txt = (char*)clientData;                  495   char* txt = (char*)clientData;
521   String string;                                  496   String string;
522                                                   497 
523   XtVaGetValues (w,                               498   XtVaGetValues (w,
524      XmNvalue, &string,                           499      XmNvalue, &string,
525      NULL);                                       500      NULL);
526                                                   501 
527   strcpy(txt, string);                         << 502   sscanf (string, "%s", txt);
528 }                                                 503 }
529                                                   504 
530 G4bool G4OpenGLXmViewer::get_boolean_userData     505 G4bool G4OpenGLXmViewer::get_boolean_userData (Widget w)
531 {                                                 506 {
532   XtPointer userData;                             507   XtPointer userData;
533   XtVaGetValues (w,XmNuserData,&userData,NULL)    508   XtVaGetValues (w,XmNuserData,&userData,NULL);
534   return (G4bool)(((unsigned long)userData)&0x << 509   return (G4bool)(unsigned long)userData;
535 }                                                 510 }
536                                                   511 
537 G4int G4OpenGLXmViewer::get_int_userData (Widg    512 G4int G4OpenGLXmViewer::get_int_userData (Widget w)
538 {                                                 513 {
539   XtPointer userData;                             514   XtPointer userData;
540   XtVaGetValues (w,XmNuserData,&userData,NULL)    515   XtVaGetValues (w,XmNuserData,&userData,NULL);
541   return (G4int)(unsigned long)userData;          516   return (G4int)(unsigned long)userData;
542 }                                                 517 }
                                                   >> 518 
                                                   >> 519 #endif
                                                   >> 520 
                                                   >> 521 
                                                   >> 522 
                                                   >> 523 
                                                   >> 524 
543                                                   525