| 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$
27 // 28 //
28 //Slider bar class. Inherits from G4OpenGLXmVW 29 //Slider bar class. Inherits from G4OpenGLXmVWidgetComponent
29 30
>> 31 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER
>> 32
30 #include "G4OpenGLXmVWidgetComponent.hh" 33 #include "G4OpenGLXmVWidgetComponent.hh"
31 #include "G4OpenGLXmVWidgetContainer.hh" 34 #include "G4OpenGLXmVWidgetContainer.hh"
32 #include "G4OpenGLXmSliderBar.hh" 35 #include "G4OpenGLXmSliderBar.hh"
33 #include <X11/Intrinsic.h> 36 #include <X11/Intrinsic.h>
34 #include <Xm/Scale.h> 37 #include <Xm/Scale.h>
35 #include "globals.hh" 38 #include "globals.hh"
36 39
37 G4OpenGLXmSliderBar::G4OpenGLXmSliderBar (cons 40 G4OpenGLXmSliderBar::G4OpenGLXmSliderBar (const char* n,
38 XtCallbackRec* c, 41 XtCallbackRec* c,
39 G4bool sh, 42 G4bool sh,
40 short dp, 43 short dp,
41 G4double v, 44 G4double v,
42 G4double max, 45 G4double max,
43 G4double min, 46 G4double min,
44 unsigned char o, 47 unsigned char o,
45 unsigned char d) 48 unsigned char d)
46 : sliderbar(0) <<
47 , parent(0) <<
48 { 49 {
49 name = n; 50 name = n;
50 callback = c; 51 callback = c;
51 show = sh; 52 show = sh;
52 decimal_places = dp; 53 decimal_places = dp;
53 initial_value = int(v * std::pow(10.0, (G4do 54 initial_value = int(v * std::pow(10.0, (G4double)dp));
54 max_value = int(max * std::pow(10.0, (G4doub 55 max_value = int(max * std::pow(10.0, (G4double)dp));
55 min_value = int(min * std::pow(10.0, (G4doub 56 min_value = int(min * std::pow(10.0, (G4double)dp));
56 orientation = o; 57 orientation = o;
57 direction = d; 58 direction = d;
58 } 59 }
59 60
60 G4OpenGLXmSliderBar::~G4OpenGLXmSliderBar () 61 G4OpenGLXmSliderBar::~G4OpenGLXmSliderBar ()
61 {} 62 {}
62 63
63 const char* G4OpenGLXmSliderBar::GetName () 64 const char* G4OpenGLXmSliderBar::GetName ()
64 { 65 {
65 return name; 66 return name;
66 } 67 }
67 68
68 G4bool G4OpenGLXmSliderBar::GetShow () 69 G4bool G4OpenGLXmSliderBar::GetShow ()
69 { 70 {
70 return show; 71 return show;
71 } 72 }
72 73
73 short G4OpenGLXmSliderBar::GetDecimalPlaces () 74 short G4OpenGLXmSliderBar::GetDecimalPlaces ()
74 { 75 {
75 return decimal_places; 76 return decimal_places;
76 } 77 }
77 78
78 G4double G4OpenGLXmSliderBar::GetInitialValue 79 G4double G4OpenGLXmSliderBar::GetInitialValue ()
79 { 80 {
80 return (G4double)initial_value / std::pow(10 81 return (G4double)initial_value / std::pow(10.0, (G4double)GetDecimalPlaces());
81 } 82 }
82 83
83 G4double G4OpenGLXmSliderBar::GetMaxValue () 84 G4double G4OpenGLXmSliderBar::GetMaxValue ()
84 { 85 {
85 return (G4double)max_value / std::pow(10.0, 86 return (G4double)max_value / std::pow(10.0, (G4double)GetDecimalPlaces());
86 } 87 }
87 88
88 G4double G4OpenGLXmSliderBar::GetMinValue () 89 G4double G4OpenGLXmSliderBar::GetMinValue ()
89 { 90 {
90 return (G4double)min_value / std::pow(10.0, 91 return (G4double)min_value / std::pow(10.0, (G4double)GetDecimalPlaces());
91 } 92 }
92 93
93 unsigned char G4OpenGLXmSliderBar::GetOrientat 94 unsigned char G4OpenGLXmSliderBar::GetOrientation ()
94 { 95 {
95 return orientation; 96 return orientation;
96 } 97 }
97 98
98 unsigned char G4OpenGLXmSliderBar::GetDirectio 99 unsigned char G4OpenGLXmSliderBar::GetDirection ()
99 { 100 {
100 return direction; 101 return direction;
101 } 102 }
102 103
103 void G4OpenGLXmSliderBar::SetName (const char* 104 void G4OpenGLXmSliderBar::SetName (const char* n)
104 { 105 {
105 name = n; 106 name = n;
106 XmString sliderbar_string = XmStringCreateLo 107 XmString sliderbar_string = XmStringCreateLocalized ((char*)name);
107 XtVaSetValues (sliderbar, 108 XtVaSetValues (sliderbar,
108 XmNlabelString, sliderbar_string, 109 XmNlabelString, sliderbar_string,
109 NULL); 110 NULL);
110 XmStringFree (sliderbar_string); 111 XmStringFree (sliderbar_string);
111 } 112 }
112 113
113 void G4OpenGLXmSliderBar::SetShow (G4bool sh) 114 void G4OpenGLXmSliderBar::SetShow (G4bool sh)
114 { 115 {
115 show = sh; 116 show = sh;
116 XtVaSetValues (sliderbar, 117 XtVaSetValues (sliderbar,
117 XmNshowValue, show, 118 XmNshowValue, show,
118 NULL); 119 NULL);
119 120
120 } 121 }
121 122
122 void G4OpenGLXmSliderBar::SetDecimalPlaces (sh 123 void G4OpenGLXmSliderBar::SetDecimalPlaces (short dp)
123 { 124 {
124 decimal_places = dp; 125 decimal_places = dp;
125 XtVaSetValues (sliderbar, 126 XtVaSetValues (sliderbar,
126 XmNdecimalPoints, decimal_places, 127 XmNdecimalPoints, decimal_places,
127 NULL); 128 NULL);
128 129
129 } 130 }
130 131
131 void G4OpenGLXmSliderBar::SetInitialValue (G4d 132 void G4OpenGLXmSliderBar::SetInitialValue (G4double v)
132 { 133 {
133 initial_value = int(v * std::pow(10.0, (G4do 134 initial_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
134 XtVaSetValues (sliderbar, 135 XtVaSetValues (sliderbar,
135 XmNvalue, initial_value, 136 XmNvalue, initial_value,
136 NULL); 137 NULL);
137 138
138 } 139 }
139 140
140 void G4OpenGLXmSliderBar::SetMaxValue (G4doubl 141 void G4OpenGLXmSliderBar::SetMaxValue (G4double v)
141 { 142 {
142 max_value = int(v * std::pow(10.0, (G4double 143 max_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
143 XtVaSetValues (sliderbar, 144 XtVaSetValues (sliderbar,
144 XmNmaximum, max_value, 145 XmNmaximum, max_value,
145 NULL); 146 NULL);
146 147
147 } 148 }
148 149
149 void G4OpenGLXmSliderBar::SetMinValue (G4doubl 150 void G4OpenGLXmSliderBar::SetMinValue (G4double v)
150 { 151 {
151 min_value = int(v * std::pow(10.0, (G4double 152 min_value = int(v * std::pow(10.0, (G4double)GetDecimalPlaces()));
152 XtVaSetValues (sliderbar, 153 XtVaSetValues (sliderbar,
153 XmNminimum, min_value, 154 XmNminimum, min_value,
154 NULL); 155 NULL);
155 156
156 } 157 }
157 158
158 void G4OpenGLXmSliderBar::SetOrientation (unsi 159 void G4OpenGLXmSliderBar::SetOrientation (unsigned char o)
159 { 160 {
160 orientation = o; 161 orientation = o;
161 XtVaSetValues (sliderbar, 162 XtVaSetValues (sliderbar,
162 XmNorientation, orientation, 163 XmNorientation, orientation,
163 NULL); 164 NULL);
164 165
165 } 166 }
166 167
167 void G4OpenGLXmSliderBar::SetDirection (unsign 168 void G4OpenGLXmSliderBar::SetDirection (unsigned char d)
168 { 169 {
169 direction = d; 170 direction = d;
170 XtVaSetValues (sliderbar, 171 XtVaSetValues (sliderbar,
171 XmNprocessingDirection, direction, 172 XmNprocessingDirection, direction,
172 NULL); 173 NULL);
173 174
174 } 175 }
175 176
176 void G4OpenGLXmSliderBar::AddYourselfTo (G4Ope 177 void G4OpenGLXmSliderBar::AddYourselfTo (G4OpenGLXmVWidgetContainer* container)
177 { 178 {
178 179
179 pView = container->GetView (); 180 pView = container->GetView ();
180 ProcesspView (); 181 ProcesspView ();
181 182
182 parent = container->GetPointerToWidget (); 183 parent = container->GetPointerToWidget ();
183 XmString name_string = XmStringCreateLocaliz 184 XmString name_string = XmStringCreateLocalized ((char*)name);
184 sliderbar = XtVaCreateManagedWidget (name, 185 sliderbar = XtVaCreateManagedWidget (name,
185 xmScaleWidgetClass, 186 xmScaleWidgetClass,
186 *parent, 187 *parent,
187 188
188 XmNtitleString, name_string, 189 XmNtitleString, name_string,
189 XmNmaximum, max_value, 190 XmNmaximum, max_value,
190 XmNminimum, min_value, 191 XmNminimum, min_value,
191 XmNvalue, initial_value, 192 XmNvalue, initial_value,
192 XmNshowValue, show, 193 XmNshowValue, show,
193 XmNdecimalPoints, decimal_place 194 XmNdecimalPoints, decimal_places,
194 XmNorientation, orientation, 195 XmNorientation, orientation,
195 XmNprocessingDirection, directi 196 XmNprocessingDirection, direction,
196 197
197 XtNvisual, visual, 198 XtNvisual, visual,
198 XtNdepth, depth, 199 XtNdepth, depth,
199 XtNcolormap, cmap, 200 XtNcolormap, cmap,
200 XtNborderColor, borcol, 201 XtNborderColor, borcol,
201 XtNbackground, bgnd, 202 XtNbackground, bgnd,
202 203
203 NULL); 204 NULL);
204 205
205 XtAddCallbacks (sliderbar, 206 XtAddCallbacks (sliderbar,
206 XmNvalueChangedCallback, 207 XmNvalueChangedCallback,
207 callback); 208 callback);
208 209
209 XtAddCallbacks (sliderbar, 210 XtAddCallbacks (sliderbar,
210 XmNdragCallback, 211 XmNdragCallback,
211 callback); 212 callback);
212 XmStringFree (name_string); 213 XmStringFree (name_string);
213 } 214 }
214 215
215 Widget* G4OpenGLXmSliderBar::GetPointerToParen 216 Widget* G4OpenGLXmSliderBar::GetPointerToParent ()
216 { 217 {
217 return parent; 218 return parent;
218 } 219 }
219 220
220 Widget* G4OpenGLXmSliderBar::GetPointerToWidge 221 Widget* G4OpenGLXmSliderBar::GetPointerToWidget ()
221 { 222 {
222 return &sliderbar; 223 return &sliderbar;
223 } 224 }
>> 225
>> 226 #endif
224 227