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