Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLXmSliderBar.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/G4OpenGLXmSliderBar.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLXmSliderBar.cc (Version 11.1.3)


  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