| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // 27 //
28 //Slider bar class. Inherits from G4OpenGLXmVW 28 //Slider bar class. Inherits from G4OpenGLXmVWidgetComponent
29 29
30 #include "G4OpenGLXmVWidgetComponent.hh" 30 #include "G4OpenGLXmVWidgetComponent.hh"
31 #include "G4OpenGLXmVWidgetContainer.hh" 31 #include "G4OpenGLXmVWidgetContainer.hh"
32 #include "G4OpenGLXmSliderBar.hh" 32 #include "G4OpenGLXmSliderBar.hh"
33 #include <X11/Intrinsic.h> 33 #include <X11/Intrinsic.h>
34 #include <Xm/Scale.h> 34 #include <Xm/Scale.h>
35 #include "globals.hh" 35 #include "globals.hh"
36 36
37 G4OpenGLXmSliderBar::G4OpenGLXmSliderBar (cons 37 G4OpenGLXmSliderBar::G4OpenGLXmSliderBar (const char* n,
38 XtCallbackRec* c, 38 XtCallbackRec* c,
39 G4bool sh, 39 G4bool sh,
40 short dp, 40 short dp,
41 G4double v, 41 G4double v,
42 G4double max, 42 G4double max,
43 G4double min, 43 G4double min,
44 unsigned char o, 44 unsigned char o,
45 unsigned char d) 45 unsigned char d)
46 : sliderbar(0) 46 : sliderbar(0)
47 , parent(0) 47 , parent(0)
48 { 48 {
49 name = n; 49 name = n;
50 callback = c; 50 callback = c;
51 show = sh; 51 show = sh;
52 decimal_places = dp; 52 decimal_places = dp;
53 initial_value = int(v * std::pow(10.0, (G4do 53 initial_value = int(v * std::pow(10.0, (G4double)dp));
54 max_value = int(max * std::pow(10.0, (G4doub 54 max_value = int(max * std::pow(10.0, (G4double)dp));
55 min_value = int(min * std::pow(10.0, (G4doub 55 min_value = int(min * std::pow(10.0, (G4double)dp));
56 orientation = o; 56 orientation = o;
57 direction = d; 57 direction = d;
58 } 58 }
59 59
60 G4OpenGLXmSliderBar::~G4OpenGLXmSliderBar () 60 G4OpenGLXmSliderBar::~G4OpenGLXmSliderBar ()
61 {} 61 {}
62 62
63 const char* G4OpenGLXmSliderBar::GetName () 63 const char* G4OpenGLXmSliderBar::GetName ()
64 { 64 {
65 return name; 65 return name;
66 } 66 }
67 67
68 G4bool G4OpenGLXmSliderBar::GetShow () 68 G4bool G4OpenGLXmSliderBar::GetShow ()
69 { 69 {
70 return show; 70 return show;
71 } 71 }
72 72
73 short G4OpenGLXmSliderBar::GetDecimalPlaces () 73 short G4OpenGLXmSliderBar::GetDecimalPlaces ()
74 { 74 {
75 return decimal_places; 75 return decimal_places;
76 } 76 }
77 77
78 G4double G4OpenGLXmSliderBar::GetInitialValue 78 G4double G4OpenGLXmSliderBar::GetInitialValue ()
79 { 79 {
80 return (G4double)initial_value / std::pow(10 80 return (G4double)initial_value / std::pow(10.0, (G4double)GetDecimalPlaces());
81 } 81 }
82 82
83 G4double G4OpenGLXmSliderBar::GetMaxValue () 83 G4double G4OpenGLXmSliderBar::GetMaxValue ()
84 { 84 {
85 return (G4double)max_value / std::pow(10.0, 85 return (G4double)max_value / std::pow(10.0, (G4double)GetDecimalPlaces());
86 } 86 }
87 87
88 G4double G4OpenGLXmSliderBar::GetMinValue () 88 G4double G4OpenGLXmSliderBar::GetMinValue ()
89 { 89 {
90 return (G4double)min_value / std::pow(10.0, 90 return (G4double)min_value / std::pow(10.0, (G4double)GetDecimalPlaces());
91 } 91 }
92 92
93 unsigned char G4OpenGLXmSliderBar::GetOrientat 93 unsigned char G4OpenGLXmSliderBar::GetOrientation ()
94 { 94 {
95 return orientation; 95 return orientation;
96 } 96 }
97 97
98 unsigned char G4OpenGLXmSliderBar::GetDirectio 98 unsigned char G4OpenGLXmSliderBar::GetDirection ()
99 { 99 {
100 return direction; 100 return direction;
101 } 101 }
102 102
103 void G4OpenGLXmSliderBar::SetName (const char* 103 void G4OpenGLXmSliderBar::SetName (const char* n)
104 { 104 {
105 name = n; 105 name = n;
106 XmString sliderbar_string = XmStringCreateLo 106 XmString sliderbar_string = XmStringCreateLocalized ((char*)name);
107 XtVaSetValues (sliderbar, 107 XtVaSetValues (sliderbar,
108 XmNlabelString, sliderbar_string, 108 XmNlabelString, sliderbar_string,
109 NULL); 109 NULL);
110 XmStringFree (sliderbar_string); 110 XmStringFree (sliderbar_string);
111 } 111 }
112 112
113 void G4OpenGLXmSliderBar::SetShow (G4bool sh) 113 void G4OpenGLXmSliderBar::SetShow (G4bool sh)
114 { 114 {
115 show = sh; 115 show = sh;
116 XtVaSetValues (sliderbar, 116 XtVaSetValues (sliderbar,
117 XmNshowValue, show, 117 XmNshowValue, show,
118 NULL); 118 NULL);
119 119
120 } 120 }
121 121
122 void G4OpenGLXmSliderBar::SetDecimalPlaces (sh 122 void G4OpenGLXmSliderBar::SetDecimalPlaces (short dp)
123 { 123 {
124 decimal_places = dp; 124 decimal_places = dp;
125 XtVaSetValues (sliderbar, 125 XtVaSetValues (sliderbar,
126 XmNdecimalPoints, decimal_places, 126 XmNdecimalPoints, decimal_places,
127 NULL); 127 NULL);
128 128
129 } 129 }
130 130
131 void G4OpenGLXmSliderBar::SetInitialValue (G4d 131 void G4OpenGLXmSliderBar::SetInitialValue (G4double v)
132 { 132 {
133 initial_value = int(v * std::pow(10.0, (G4do 133 initial_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
134 XtVaSetValues (sliderbar, 134 XtVaSetValues (sliderbar,
135 XmNvalue, initial_value, 135 XmNvalue, initial_value,
136 NULL); 136 NULL);
137 137
138 } 138 }
139 139
140 void G4OpenGLXmSliderBar::SetMaxValue (G4doubl 140 void G4OpenGLXmSliderBar::SetMaxValue (G4double v)
141 { 141 {
142 max_value = int(v * std::pow(10.0, (G4double 142 max_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
143 XtVaSetValues (sliderbar, 143 XtVaSetValues (sliderbar,
144 XmNmaximum, max_value, 144 XmNmaximum, max_value,
145 NULL); 145 NULL);
146 146
147 } 147 }
148 148
149 void G4OpenGLXmSliderBar::SetMinValue (G4doubl 149 void G4OpenGLXmSliderBar::SetMinValue (G4double v)
150 { 150 {
151 min_value = int(v * std::pow(10.0, (G4double 151 min_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
152 XtVaSetValues (sliderbar, 152 XtVaSetValues (sliderbar,
153 XmNminimum, min_value, 153 XmNminimum, min_value,
154 NULL); 154 NULL);
155 155
156 } 156 }
157 157
158 void G4OpenGLXmSliderBar::SetOrientation (unsi 158 void G4OpenGLXmSliderBar::SetOrientation (unsigned char o)
159 { 159 {
160 orientation = o; 160 orientation = o;
161 XtVaSetValues (sliderbar, 161 XtVaSetValues (sliderbar,
162 XmNorientation, orientation, 162 XmNorientation, orientation,
163 NULL); 163 NULL);
164 164
165 } 165 }
166 166
167 void G4OpenGLXmSliderBar::SetDirection (unsign 167 void G4OpenGLXmSliderBar::SetDirection (unsigned char d)
168 { 168 {
169 direction = d; 169 direction = d;
170 XtVaSetValues (sliderbar, 170 XtVaSetValues (sliderbar,
171 XmNprocessingDirection, direction, 171 XmNprocessingDirection, direction,
172 NULL); 172 NULL);
173 173
174 } 174 }
175 175
176 void G4OpenGLXmSliderBar::AddYourselfTo (G4Ope 176 void G4OpenGLXmSliderBar::AddYourselfTo (G4OpenGLXmVWidgetContainer* container)
177 { 177 {
178 178
179 pView = container->GetView (); 179 pView = container->GetView ();
180 ProcesspView (); 180 ProcesspView ();
181 181
182 parent = container->GetPointerToWidget (); 182 parent = container->GetPointerToWidget ();
183 XmString name_string = XmStringCreateLocaliz 183 XmString name_string = XmStringCreateLocalized ((char*)name);
184 sliderbar = XtVaCreateManagedWidget (name, 184 sliderbar = XtVaCreateManagedWidget (name,
185 xmScaleWidgetClass, 185 xmScaleWidgetClass,
186 *parent, 186 *parent,
187 187
188 XmNtitleString, name_string, 188 XmNtitleString, name_string,
189 XmNmaximum, max_value, 189 XmNmaximum, max_value,
190 XmNminimum, min_value, 190 XmNminimum, min_value,
191 XmNvalue, initial_value, 191 XmNvalue, initial_value,
192 XmNshowValue, show, 192 XmNshowValue, show,
193 XmNdecimalPoints, decimal_place 193 XmNdecimalPoints, decimal_places,
194 XmNorientation, orientation, 194 XmNorientation, orientation,
195 XmNprocessingDirection, directi 195 XmNprocessingDirection, direction,
196 196
197 XtNvisual, visual, 197 XtNvisual, visual,
198 XtNdepth, depth, 198 XtNdepth, depth,
199 XtNcolormap, cmap, 199 XtNcolormap, cmap,
200 XtNborderColor, borcol, 200 XtNborderColor, borcol,
201 XtNbackground, bgnd, 201 XtNbackground, bgnd,
202 202
203 NULL); 203 NULL);
204 204
205 XtAddCallbacks (sliderbar, 205 XtAddCallbacks (sliderbar,
206 XmNvalueChangedCallback, 206 XmNvalueChangedCallback,
207 callback); 207 callback);
208 208
209 XtAddCallbacks (sliderbar, 209 XtAddCallbacks (sliderbar,
210 XmNdragCallback, 210 XmNdragCallback,
211 callback); 211 callback);
212 XmStringFree (name_string); 212 XmStringFree (name_string);
213 } 213 }
214 214
215 Widget* G4OpenGLXmSliderBar::GetPointerToParen 215 Widget* G4OpenGLXmSliderBar::GetPointerToParent ()
216 { 216 {
217 return parent; 217 return parent;
218 } 218 }
219 219
220 Widget* G4OpenGLXmSliderBar::GetPointerToWidge 220 Widget* G4OpenGLXmSliderBar::GetPointerToWidget ()
221 { 221 {
222 return &sliderbar; 222 return &sliderbar;
223 } 223 }
224 224