Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/include/G4ViewParameters.icc

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/management/include/G4ViewParameters.icc (Version 11.3.0) and /visualization/management/include/G4ViewParameters.icc (Version 10.2.p2)


  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: G4ViewParameters.icc 86974 2014-11-21 11:58:31Z gcosmo $
 27 //                                                 28 //
 28 //                                                 29 // 
 29 // John Allison  20th October 1996                 30 // John Allison  20th October 1996
 30 // View parameters and options.                    31 // View parameters and options.
 31                                                    32 
 32 inline G4ViewParameters::DrawingStyle              33 inline G4ViewParameters::DrawingStyle
 33 G4ViewParameters::GetDrawingStyle () const {       34 G4ViewParameters::GetDrawingStyle () const {
 34   return fDrawingStyle;                            35   return fDrawingStyle;
 35 }                                                  36 }
 36                                                    37 
 37 inline G4bool G4ViewParameters::IsAuxEdgeVisib     38 inline G4bool G4ViewParameters::IsAuxEdgeVisible () const {
 38   return fAuxEdgeVisible;                          39   return fAuxEdgeVisible;
 39 }                                                  40 }
 40                                                    41 
 41 inline G4bool G4ViewParameters::IsCulling () c     42 inline G4bool G4ViewParameters::IsCulling () const {
 42   return fCulling;                                 43   return fCulling;
 43 }                                                  44 }
 44                                                    45 
 45 inline G4bool G4ViewParameters::IsCullingInvis     46 inline G4bool G4ViewParameters::IsCullingInvisible () const {
 46   return fCullInvisible;                           47   return fCullInvisible;
 47 }                                                  48 }
 48                                                    49 
 49 inline G4bool G4ViewParameters::IsDensityCulli     50 inline G4bool G4ViewParameters::IsDensityCulling () const {
 50   return fDensityCulling;                          51   return fDensityCulling;
 51 }                                                  52 }
 52                                                    53 
 53 inline G4double G4ViewParameters::GetVisibleDe     54 inline G4double G4ViewParameters::GetVisibleDensity () const {
 54   return fVisibleDensity;                          55   return fVisibleDensity;
 55 }                                                  56 }
 56                                                    57 
 57 inline G4bool G4ViewParameters::IsCullingCover     58 inline G4bool G4ViewParameters::IsCullingCovered () const {
 58   return fCullCovered;                             59   return fCullCovered;
 59 }                                                  60 }
 60                                                    61 
 61 inline G4int G4ViewParameters::GetCBDAlgorithm << 
 62   return fCBDAlgorithmNumber;                  << 
 63 }                                              << 
 64                                                << 
 65 inline const std::vector<G4double>& G4ViewPara << 
 66   return fCBDParameters;                       << 
 67 }                                              << 
 68                                                << 
 69 inline G4bool G4ViewParameters::IsSection () c     62 inline G4bool G4ViewParameters::IsSection () const {
 70   return fSection;                                 63   return fSection;
 71 }                                                  64 }
 72                                                    65 
 73 inline const G4Plane3D& G4ViewParameters::GetS     66 inline const G4Plane3D& G4ViewParameters::GetSectionPlane () const {
 74   return fSectionPlane;                            67   return fSectionPlane;
 75 }                                                  68 }
 76                                                    69 
 77 inline G4bool G4ViewParameters::IsCutaway () c     70 inline G4bool G4ViewParameters::IsCutaway () const {
 78   return fCutawayPlanes.size() > 0;                71   return fCutawayPlanes.size() > 0;
 79 }                                                  72 }
 80                                                    73 
 81 inline G4ViewParameters::CutawayMode G4ViewPar     74 inline G4ViewParameters::CutawayMode G4ViewParameters::GetCutawayMode () const
 82 { return fCutawayMode;}                            75 { return fCutawayMode;}
 83                                                    76 
 84 inline const G4Planes& G4ViewParameters::GetCu     77 inline const G4Planes& G4ViewParameters::GetCutawayPlanes () const {
 85   return fCutawayPlanes;                           78   return fCutawayPlanes;
 86 }                                                  79 }
 87                                                    80 
 88 inline G4bool G4ViewParameters::IsExplode () c     81 inline G4bool G4ViewParameters::IsExplode () const {
 89   return fExplodeFactor > 1.;                      82   return fExplodeFactor > 1.;
 90 }                                                  83 }
 91                                                    84 
 92 inline G4double G4ViewParameters::GetExplodeFa     85 inline G4double G4ViewParameters::GetExplodeFactor () const {
 93   return fExplodeFactor;                           86   return fExplodeFactor;
 94 }                                                  87 }
 95                                                    88 
 96 inline const G4Point3D& G4ViewParameters::GetE     89 inline const G4Point3D& G4ViewParameters::GetExplodeCentre () const {
 97   return fExplodeCentre;                           90   return fExplodeCentre;
 98 }                                                  91 }
 99                                                    92 
100 inline G4int G4ViewParameters::GetNoOfSides ()     93 inline G4int G4ViewParameters::GetNoOfSides () const {
101   return fNoOfSides;                               94   return fNoOfSides;
102 }                                                  95 }
103                                                    96 
104 inline const G4Vector3D& G4ViewParameters::Get     97 inline const G4Vector3D& G4ViewParameters::GetViewpointDirection () const {
105   return fViewpointDirection;                      98   return fViewpointDirection;
106 }                                                  99 }
107                                                   100 
108 inline const G4Vector3D& G4ViewParameters::Get    101 inline const G4Vector3D& G4ViewParameters::GetUpVector () const {
109   return fUpVector;                               102   return fUpVector;
110 }                                                 103 }
111                                                   104 
112 inline G4double G4ViewParameters::GetFieldHalf    105 inline G4double G4ViewParameters::GetFieldHalfAngle () const {
113   return fFieldHalfAngle;                         106   return fFieldHalfAngle;
114 }                                                 107 }
115                                                   108 
116 inline G4double G4ViewParameters::GetZoomFacto    109 inline G4double G4ViewParameters::GetZoomFactor () const {
117   return fZoomFactor;                             110   return fZoomFactor;
118 }                                                 111 }
119                                                   112 
120 inline const G4Vector3D& G4ViewParameters::Get    113 inline const G4Vector3D& G4ViewParameters::GetScaleFactor () const {
121   return fScaleFactor;                            114   return fScaleFactor;
122 }                                                 115 }
123                                                   116 
124 inline const G4Point3D& G4ViewParameters::GetC    117 inline const G4Point3D& G4ViewParameters::GetCurrentTargetPoint () const {
125   return fCurrentTargetPoint;                     118   return fCurrentTargetPoint;
126 }                                                 119 }
127                                                   120 
128 inline G4double G4ViewParameters::GetDolly ()     121 inline G4double G4ViewParameters::GetDolly () const {
129   return fDolly;                                  122   return fDolly;
130 }                                                 123 }
131                                                   124 
132 inline const G4Vector3D& G4ViewParameters::Get    125 inline const G4Vector3D& G4ViewParameters::GetLightpointDirection () const {
133   return fRelativeLightpointDirection;            126   return fRelativeLightpointDirection;
134 }                                                 127 }
135                                                   128 
136 inline G4bool G4ViewParameters::GetLightsMoveW    129 inline G4bool G4ViewParameters::GetLightsMoveWithCamera () const {
137   return fLightsMoveWithCamera;                   130   return fLightsMoveWithCamera;
138 }                                                 131 }
139                                                   132 
140 inline const G4VisAttributes*                     133 inline const G4VisAttributes*
141 G4ViewParameters::GetDefaultVisAttributes () c    134 G4ViewParameters::GetDefaultVisAttributes () const {
142   return &fDefaultVisAttributes;                  135   return &fDefaultVisAttributes;
143 }                                                 136 }
144                                                   137 
145 inline const G4VisAttributes*                     138 inline const G4VisAttributes*
146 G4ViewParameters::GetDefaultTextVisAttributes     139 G4ViewParameters::GetDefaultTextVisAttributes () const {
147   return &fDefaultTextVisAttributes;              140   return &fDefaultTextVisAttributes;
148 }                                                 141 }
149                                                   142 
150 inline const G4VMarker& G4ViewParameters::GetD    143 inline const G4VMarker& G4ViewParameters::GetDefaultMarker () const {
151   return fDefaultMarker;                          144   return fDefaultMarker;
152 }                                                 145 }
153                                                   146 
154 inline G4double G4ViewParameters::GetGlobalMar    147 inline G4double G4ViewParameters::GetGlobalMarkerScale () const {
155   return fGlobalMarkerScale;                      148   return fGlobalMarkerScale;
156 }                                                 149 }
157                                                   150 
158 inline G4double G4ViewParameters::GetGlobalLin    151 inline G4double G4ViewParameters::GetGlobalLineWidthScale () const {
159   return fGlobalLineWidthScale;                   152   return fGlobalLineWidthScale;
160 }                                                 153 }
161                                                   154 
162 inline G4bool G4ViewParameters::IsMarkerNotHid    155 inline G4bool G4ViewParameters::IsMarkerNotHidden () const {
163   return fMarkerNotHidden;                        156   return fMarkerNotHidden;
164 }                                                 157 }
165                                                   158 
166 inline bool G4ViewParameters::IsWindowSizeHint    159 inline bool G4ViewParameters::IsWindowSizeHintX () const {
167   return ((fGeometryMask & fWidthValue) != 0);    160   return ((fGeometryMask & fWidthValue) != 0);
168 }                                                 161 }
169                                                   162 
170 inline bool G4ViewParameters::IsWindowSizeHint    163 inline bool G4ViewParameters::IsWindowSizeHintY () const {
171   return ((fGeometryMask & fHeightValue) != 0)    164   return ((fGeometryMask & fHeightValue) != 0);
172 }                                                 165 }
173                                                   166 
174 inline bool G4ViewParameters::IsWindowLocation    167 inline bool G4ViewParameters::IsWindowLocationHintX () const {
175   return ((fGeometryMask & fXValue) != 0);        168   return ((fGeometryMask & fXValue) != 0);
176 }                                                 169 }
177                                                   170 
178 inline bool G4ViewParameters::IsWindowLocation    171 inline bool G4ViewParameters::IsWindowLocationHintY () const {
179   return ((fGeometryMask & fYValue) != 0);        172   return ((fGeometryMask & fYValue) != 0);
180 }                                                 173 }
181                                                   174 
182 inline unsigned int G4ViewParameters::GetWindo    175 inline unsigned int G4ViewParameters::GetWindowSizeHintX () const {
183   return fWindowSizeHintX;                        176   return fWindowSizeHintX;
184 }                                                 177 }
185                                                   178 
186 inline unsigned int G4ViewParameters::GetWindo    179 inline unsigned int G4ViewParameters::GetWindowSizeHintY () const {
187   return fWindowSizeHintY;                        180   return fWindowSizeHintY;
188 }                                                 181 }
189                                                   182 
190 inline G4int G4ViewParameters::GetWindowLocati    183 inline G4int G4ViewParameters::GetWindowLocationHintX () const {
191   return fWindowLocationHintX;                    184   return fWindowLocationHintX;
192 }                                                 185 }
193                                                   186 
194 inline G4int G4ViewParameters::GetWindowLocati    187 inline G4int G4ViewParameters::GetWindowLocationHintY () const {
195   return fWindowLocationHintY;                    188   return fWindowLocationHintY;
196 }                                                 189 }
197                                                   190 
198 inline G4bool G4ViewParameters::IsWindowLocati << 
199   return fWindowLocationHintXNegative;         << 
200 }                                              << 
201                                                << 
202 inline G4bool G4ViewParameters::IsWindowLocati << 
203   return fWindowLocationHintYNegative;         << 
204 }                                              << 
205                                                << 
206 inline const G4String& G4ViewParameters::GetXG    191 inline const G4String& G4ViewParameters::GetXGeometryString () const {
207   return fXGeometryString;                        192   return fXGeometryString;
208 }                                                 193 }
209                                                   194 
210 inline G4bool G4ViewParameters::IsAutoRefresh     195 inline G4bool G4ViewParameters::IsAutoRefresh () const {
211   return fAutoRefresh;                            196   return fAutoRefresh;
212 }                                                 197 }
213                                                   198 
214 inline const G4Colour& G4ViewParameters::GetBa    199 inline const G4Colour& G4ViewParameters::GetBackgroundColour () const {
215   return fBackgroundColour;                       200   return fBackgroundColour;
216 }                                                 201 }
217                                                   202 
218 inline G4bool G4ViewParameters::IsPicking () c    203 inline G4bool G4ViewParameters::IsPicking () const {
219   return fPicking;                                204   return fPicking;
220 }                                                 205 }
221                                                   206 
222 inline G4ViewParameters::RotationStyle            207 inline G4ViewParameters::RotationStyle
223 G4ViewParameters::GetRotationStyle() const {re    208 G4ViewParameters::GetRotationStyle() const {return fRotationStyle;}
224                                                   209 
225 inline const std::vector<G4ModelingParameters:    210 inline const std::vector<G4ModelingParameters::VisAttributesModifier>&
226 G4ViewParameters::GetVisAttributesModifiers()     211 G4ViewParameters::GetVisAttributesModifiers() const {
227   return fVisAttributesModifiers;                 212   return fVisAttributesModifiers;
228 }                                                 213 }
229                                                   214 
230 inline G4double G4ViewParameters::GetStartTime << 
231   return fStartTime;                           << 
232 }                                              << 
233                                                << 
234 inline G4double G4ViewParameters::GetEndTime ( << 
235   return fEndTime;                             << 
236 }                                              << 
237                                                << 
238 inline G4double G4ViewParameters::GetFadeFacto << 
239   return fFadeFactor;                          << 
240 }                                              << 
241                                                << 
242 inline G4bool G4ViewParameters::IsDisplayHeadT << 
243   return fDisplayHeadTime;                     << 
244 }                                              << 
245                                                << 
246 inline G4double G4ViewParameters::GetDisplayHe << 
247   return fDisplayHeadTimeX;                    << 
248 }                                              << 
249                                                << 
250 inline G4double G4ViewParameters::GetDisplayHe << 
251   return fDisplayHeadTimeY;                    << 
252 }                                              << 
253                                                << 
254 inline G4double G4ViewParameters::GetDisplayHe << 
255   return fDisplayHeadTimeSize;                 << 
256 }                                              << 
257                                                << 
258 inline G4double G4ViewParameters::GetDisplayHe << 
259   return fDisplayHeadTimeRed;                  << 
260 }                                              << 
261                                                << 
262 inline G4double G4ViewParameters::GetDisplayHe << 
263   return fDisplayHeadTimeGreen;                << 
264 }                                              << 
265                                                << 
266 inline G4double G4ViewParameters::GetDisplayHe << 
267   return fDisplayHeadTimeBlue;                 << 
268 }                                              << 
269                                                << 
270 inline G4bool G4ViewParameters::IsDisplayLight << 
271   return fDisplayLightFront;                   << 
272 }                                              << 
273                                                << 
274 inline G4double G4ViewParameters::GetDisplayLi << 
275   return fDisplayLightFrontX;                  << 
276 }                                              << 
277                                                << 
278 inline G4double G4ViewParameters::GetDisplayLi << 
279   return fDisplayLightFrontY;                  << 
280 }                                              << 
281                                                << 
282 inline G4double G4ViewParameters::GetDisplayLi << 
283   return fDisplayLightFrontZ;                  << 
284 }                                              << 
285                                                << 
286 inline G4double G4ViewParameters::GetDisplayLi << 
287   return fDisplayLightFrontT;                  << 
288 }                                              << 
289                                                << 
290 inline G4double G4ViewParameters::GetDisplayLi << 
291   return fDisplayLightFrontRed;                << 
292 }                                              << 
293                                                << 
294 inline G4double G4ViewParameters::GetDisplayLi << 
295   return fDisplayLightFrontGreen;              << 
296 }                                              << 
297                                                << 
298 inline G4double G4ViewParameters::GetDisplayLi << 
299   return fDisplayLightFrontBlue;               << 
300 }                                              << 
301                                                << 
302 inline G4int G4ViewParameters::GetNumberOfClou << 
303   return fNumberOfCloudPoints;                 << 
304 }                                              << 
305                                                << 
306 inline G4bool G4ViewParameters::IsSpecialMeshR << 
307 {return fSpecialMeshRendering;}                << 
308                                                << 
309 inline G4ViewParameters::SMROption G4ViewParam << 
310 {return fSpecialMeshRenderingOption;}          << 
311                                                << 
312 inline const std::vector<G4ModelingParameters: << 
313 G4ViewParameters::GetSpecialMeshVolumes() cons << 
314 {return fSpecialMeshVolumes;}                  << 
315                                                << 
316 inline void                                       215 inline void
317 G4ViewParameters::SetDrawingStyle (G4ViewParam    216 G4ViewParameters::SetDrawingStyle (G4ViewParameters::DrawingStyle style) {
318   fDrawingStyle = style;                          217   fDrawingStyle = style;
319 }                                                 218 }
320                                                   219 
321 inline void G4ViewParameters::SetAuxEdgeVisibl    220 inline void G4ViewParameters::SetAuxEdgeVisible (G4bool vis) {
322   fAuxEdgeVisible = vis;                          221   fAuxEdgeVisible = vis;
323 }                                                 222 }
324                                                   223 
325 inline void G4ViewParameters::SetCulling (G4bo    224 inline void G4ViewParameters::SetCulling (G4bool value) {
326   fCulling = value;                               225   fCulling = value;
327 }                                                 226 }
328                                                   227 
329 inline void G4ViewParameters::SetCullingInvisi    228 inline void G4ViewParameters::SetCullingInvisible (G4bool value) {
330   fCullInvisible = value;                         229   fCullInvisible = value;
331 }                                                 230 }
332                                                   231 
333 inline void G4ViewParameters::SetDensityCullin    232 inline void G4ViewParameters::SetDensityCulling (G4bool value) {
334   fDensityCulling = value;                        233   fDensityCulling = value;
335 }                                                 234 }
336                                                   235 
337 inline void G4ViewParameters::SetCullingCovere    236 inline void G4ViewParameters::SetCullingCovered (G4bool value) {
338   fCullCovered = value;                           237   fCullCovered = value;
339 }                                                 238 }
340                                                   239 
341 inline void G4ViewParameters::SetCBDAlgorithmN << 
342   fCBDAlgorithmNumber = n;                     << 
343 }                                              << 
344                                                << 
345 inline void G4ViewParameters::SetCBDParameters << 
346   fCBDParameters = p;                          << 
347 }                                              << 
348                                                << 
349 inline void G4ViewParameters::SetSectionPlane     240 inline void G4ViewParameters::SetSectionPlane (const G4Plane3D& sectionPlane) {
350   fSection = true;                                241   fSection = true;
351   fSectionPlane = sectionPlane;                   242   fSectionPlane = sectionPlane;
352 }                                                 243 }
353                                                   244 
354 inline void G4ViewParameters::UnsetSectionPlan    245 inline void G4ViewParameters::UnsetSectionPlane () {
355   fSection = false;                               246   fSection = false;
356 }                                                 247 }
357                                                   248 
358 inline void G4ViewParameters::SetCutawayMode      249 inline void G4ViewParameters::SetCutawayMode
359 (G4ViewParameters::CutawayMode cutawayMode) {     250 (G4ViewParameters::CutawayMode cutawayMode) {
360   fCutawayMode = cutawayMode;                     251   fCutawayMode = cutawayMode;
361 }                                                 252 }
362                                                   253 
363 inline void G4ViewParameters::ClearCutawayPlan    254 inline void G4ViewParameters::ClearCutawayPlanes () {
364   fCutawayPlanes.clear ();                        255   fCutawayPlanes.clear ();
365 }                                                 256 }
366                                                   257 
367 inline void G4ViewParameters::SetViewpointDire    258 inline void G4ViewParameters::SetViewpointDirection
368 (const G4Vector3D& viewpointDirection) {          259 (const G4Vector3D& viewpointDirection) {
369   SetViewAndLights (viewpointDirection);          260   SetViewAndLights (viewpointDirection);
370 }                                                 261 }
371                                                   262 
372 inline void G4ViewParameters::SetExplodeFactor    263 inline void G4ViewParameters::SetExplodeFactor (G4double explodeFactor) {
373   fExplodeFactor = explodeFactor;                 264   fExplodeFactor = explodeFactor;
374   if (fExplodeFactor < 1.) fExplodeFactor = 1.    265   if (fExplodeFactor < 1.) fExplodeFactor = 1.;
375 }                                                 266 }
376                                                   267 
377 inline void G4ViewParameters::UnsetExplodeFact    268 inline void G4ViewParameters::UnsetExplodeFactor () {
378   fExplodeFactor = 1.;                            269   fExplodeFactor = 1.;
379 }                                                 270 }
380                                                   271 
381 inline void G4ViewParameters::SetExplodeCentre    272 inline void G4ViewParameters::SetExplodeCentre
382 (const G4Point3D& explodeCentre) {                273 (const G4Point3D& explodeCentre) {
383   fExplodeCentre = explodeCentre;                 274   fExplodeCentre = explodeCentre;
384 }                                                 275 }
385 inline void G4ViewParameters::SetUpVector (con    276 inline void G4ViewParameters::SetUpVector (const G4Vector3D& upVector) {
386   fUpVector = upVector;                           277   fUpVector = upVector;
387 }                                                 278 }
388                                                   279 
389 inline void G4ViewParameters::SetFieldHalfAngl    280 inline void G4ViewParameters::SetFieldHalfAngle (G4double fieldHalfAngle) {
390   fFieldHalfAngle = fieldHalfAngle;               281   fFieldHalfAngle = fieldHalfAngle;
391 }                                                 282 }
392                                                   283 
393 inline void G4ViewParameters::SetOrthogonalPro    284 inline void G4ViewParameters::SetOrthogonalProjection () {
394   SetFieldHalfAngle(0.);                          285   SetFieldHalfAngle(0.);
395 }                                                 286 }
396                                                   287 
397 inline void G4ViewParameters::SetPerspectivePr    288 inline void G4ViewParameters::SetPerspectiveProjection(G4double fieldHalfAngle) {
398   SetFieldHalfAngle(fieldHalfAngle);              289   SetFieldHalfAngle(fieldHalfAngle);
399 }                                                 290 }
400                                                   291 
401 inline void G4ViewParameters::SetZoomFactor (G    292 inline void G4ViewParameters::SetZoomFactor (G4double zoomFactor) {
402   fZoomFactor = zoomFactor;                       293   fZoomFactor = zoomFactor;
403 }                                                 294 }
404                                                   295 
405 inline void                                       296 inline void
406 G4ViewParameters::MultiplyZoomFactor (G4double    297 G4ViewParameters::MultiplyZoomFactor (G4double zoomFactorMultiplier) {
407   fZoomFactor *= zoomFactorMultiplier;            298   fZoomFactor *= zoomFactorMultiplier;
408 }                                                 299 }
409                                                   300 
410 inline void G4ViewParameters::SetScaleFactor (    301 inline void G4ViewParameters::SetScaleFactor (const G4Vector3D& scaleFactor) {
411   fScaleFactor = scaleFactor;                     302   fScaleFactor = scaleFactor;
412 }                                                 303 }
413                                                   304 
414 inline void                                       305 inline void
415 G4ViewParameters::SetCurrentTargetPoint (const    306 G4ViewParameters::SetCurrentTargetPoint (const G4Point3D& currentTargetPoint) {
416   fCurrentTargetPoint = currentTargetPoint;       307   fCurrentTargetPoint = currentTargetPoint;
417 }                                                 308 }
418                                                   309 
419 inline void G4ViewParameters::SetDolly (G4doub    310 inline void G4ViewParameters::SetDolly (G4double dolly) {
420   fDolly = dolly;                                 311   fDolly = dolly;
421 }                                                 312 }
422                                                   313 
423 inline void G4ViewParameters::IncrementDolly (    314 inline void G4ViewParameters::IncrementDolly (G4double dollyIncrement) {
424   fDolly += dollyIncrement;                       315   fDolly += dollyIncrement;
425 }                                                 316 }
426                                                   317 
427 inline void G4ViewParameters::SetLightsMoveWit    318 inline void G4ViewParameters::SetLightsMoveWithCamera (G4bool moves) {
428   fLightsMoveWithCamera = moves;                  319   fLightsMoveWithCamera = moves;
429 }                                                 320 }
430                                                   321 
431 inline void G4ViewParameters::SetDefaultVisAtt    322 inline void G4ViewParameters::SetDefaultVisAttributes
432 (const G4VisAttributes& defaultVisAttributes)     323 (const G4VisAttributes& defaultVisAttributes) {
433   fDefaultVisAttributes = defaultVisAttributes    324   fDefaultVisAttributes = defaultVisAttributes;
434 }                                                 325 }
435                                                   326 
436 inline void G4ViewParameters::SetDefaultColour    327 inline void G4ViewParameters::SetDefaultColour (const G4Colour& colour) {
437   fDefaultVisAttributes.SetColour (colour);       328   fDefaultVisAttributes.SetColour (colour);
438 }                                                 329 }
439                                                   330 
440 inline void G4ViewParameters::SetDefaultTextVi    331 inline void G4ViewParameters::SetDefaultTextVisAttributes
441 (const G4VisAttributes& defaultTextVisAttribut    332 (const G4VisAttributes& defaultTextVisAttributes) {
442   fDefaultTextVisAttributes = defaultTextVisAt    333   fDefaultTextVisAttributes = defaultTextVisAttributes;
443 }                                                 334 }
444                                                   335 
445 inline void G4ViewParameters::SetDefaultTextCo    336 inline void G4ViewParameters::SetDefaultTextColour (const G4Colour& colour) {
446   fDefaultTextVisAttributes.SetColour (colour)    337   fDefaultTextVisAttributes.SetColour (colour);
447 }                                                 338 }
448                                                   339 
449 inline void                                       340 inline void
450 G4ViewParameters::SetDefaultMarker (const G4VM    341 G4ViewParameters::SetDefaultMarker (const G4VMarker& defaultMarker) {
451   fDefaultMarker = defaultMarker;                 342   fDefaultMarker = defaultMarker;
452 }                                                 343 }
453                                                   344 
454 inline void                                       345 inline void
455 G4ViewParameters::SetGlobalMarkerScale (G4doub    346 G4ViewParameters::SetGlobalMarkerScale (G4double globalMarkerScale) {
456   fGlobalMarkerScale = globalMarkerScale;         347   fGlobalMarkerScale = globalMarkerScale;
457 }                                                 348 }
458                                                   349 
459 inline void                                       350 inline void
460 G4ViewParameters::SetGlobalLineWidthScale (G4d    351 G4ViewParameters::SetGlobalLineWidthScale (G4double globalLineWidthScale) {
461   fGlobalLineWidthScale = globalLineWidthScale    352   fGlobalLineWidthScale = globalLineWidthScale;
462 }                                                 353 }
463                                                   354 
464 inline void G4ViewParameters::SetMarkerHidden     355 inline void G4ViewParameters::SetMarkerHidden () {
465   fMarkerNotHidden = false;                       356   fMarkerNotHidden = false;
466 }                                                 357 }
467                                                   358 
468 inline void G4ViewParameters::SetMarkerNotHidd    359 inline void G4ViewParameters::SetMarkerNotHidden () {
469   fMarkerNotHidden = true;                        360   fMarkerNotHidden = true;
470 }                                                 361 }
471                                                   362 
472 inline void G4ViewParameters::SetWindowSizeHin    363 inline void G4ViewParameters::SetWindowSizeHint (G4int xHint, G4int yHint) {
473   fWindowSizeHintX = xHint;                       364   fWindowSizeHintX = xHint;
474   fWindowSizeHintY = yHint;                       365   fWindowSizeHintY = yHint;
475 }                                                 366 }
476                                                   367 
477 inline void G4ViewParameters::SetWindowLocatio    368 inline void G4ViewParameters::SetWindowLocationHint (G4int xHint, G4int yHint) {
478   fWindowLocationHintX = xHint;                   369   fWindowLocationHintX = xHint;
479   fWindowLocationHintY = yHint;                   370   fWindowLocationHintY = yHint;
480 }                                                 371 }
481                                                   372 
482 inline void G4ViewParameters::SetAutoRefresh (    373 inline void G4ViewParameters::SetAutoRefresh (G4bool state) {
483   fAutoRefresh = state;                           374   fAutoRefresh = state;
484 }                                                 375 }
485                                                   376 
486 inline void G4ViewParameters::SetBackgroundCol    377 inline void G4ViewParameters::SetBackgroundColour (const G4Colour& colour) {
487   fBackgroundColour = colour;                     378   fBackgroundColour = colour;
488 }                                                 379 }
489                                                   380 
490 inline void G4ViewParameters::SetPicking (G4bo    381 inline void G4ViewParameters::SetPicking (G4bool picking) {
491   fPicking = picking;                             382   fPicking = picking;
492 }                                                 383 }
493                                                   384 
494 inline void G4ViewParameters::SetRotationStyle    385 inline void G4ViewParameters::SetRotationStyle
495   (G4ViewParameters::RotationStyle style) {       386   (G4ViewParameters::RotationStyle style) {
496   fRotationStyle = style;                         387   fRotationStyle = style;
497 }                                                 388 }
498                                                   389 
499 inline void G4ViewParameters::ClearVisAttribut << 390 inline void G4ViewParameters::AddVisAttributesModifier
500   fVisAttributesModifiers.clear ();            << 391 (const G4ModelingParameters::VisAttributesModifier& vam) {
501 }                                              << 392   fVisAttributesModifiers.push_back(vam);
502                                                << 
503 inline void G4ViewParameters::SetStartTime (G4 << 
504   fStartTime = startTime;                      << 
505 }                                              << 
506                                                << 
507 inline void G4ViewParameters::SetEndTime (G4do << 
508   fEndTime = endTime;                          << 
509 }                                              << 
510                                                << 
511 inline void G4ViewParameters::SetFadeFactor (G << 
512   fFadeFactor = fadeFactor;                    << 
513 }                                              << 
514                                                << 
515 inline void G4ViewParameters::SetDisplayHeadTi << 
516   fDisplayHeadTime = displayHeadTime;          << 
517 }                                              << 
518                                                << 
519 inline void G4ViewParameters::SetDisplayHeadTi << 
520   fDisplayHeadTimeX = displayHeadTimeX;        << 
521 }                                              << 
522                                                << 
523 inline void G4ViewParameters::SetDisplayHeadTi << 
524   fDisplayHeadTimeY = displayHeadTimeY;        << 
525 }                                              << 
526                                                << 
527 inline void G4ViewParameters::SetDisplayHeadTi << 
528   fDisplayHeadTimeSize = displayHeadTimeSize;  << 
529 }                                              << 
530                                                << 
531 inline void G4ViewParameters::SetDisplayHeadTi << 
532   fDisplayHeadTimeRed = displayHeadTimeRed;    << 
533 }                                                 393 }
534                                                << 
535 inline void G4ViewParameters::SetDisplayHeadTi << 
536   fDisplayHeadTimeGreen = displayHeadTimeGreen << 
537 }                                              << 
538                                                << 
539 inline void G4ViewParameters::SetDisplayHeadTi << 
540   fDisplayHeadTimeBlue = displayHeadTimeBlue;  << 
541 }                                              << 
542                                                << 
543 inline void G4ViewParameters::SetDisplayLightF << 
544   fDisplayLightFront = displayLightFront;      << 
545 }                                              << 
546                                                << 
547 inline void G4ViewParameters::SetDisplayLightF << 
548   fDisplayLightFrontX = displayLightFrontX;    << 
549 }                                              << 
550                                                << 
551 inline void G4ViewParameters::SetDisplayLightF << 
552   fDisplayLightFrontY = displayLightFrontY;    << 
553 }                                              << 
554                                                << 
555 inline void G4ViewParameters::SetDisplayLightF << 
556   fDisplayLightFrontZ = displayLightFrontZ;    << 
557 }                                              << 
558                                                << 
559 inline void G4ViewParameters::SetDisplayLightF << 
560   fDisplayLightFrontT = displayLightFrontT;    << 
561 }                                              << 
562                                                << 
563 inline void G4ViewParameters::SetDisplayLightF << 
564   fDisplayLightFrontRed = displayLightFrontRed << 
565 }                                              << 
566                                                << 
567 inline void G4ViewParameters::SetDisplayLightF << 
568   fDisplayLightFrontGreen = displayLightFrontG << 
569 }                                              << 
570                                                << 
571 inline void G4ViewParameters::SetDisplayLightF << 
572   fDisplayLightFrontBlue = displayLightFrontBl << 
573 }                                              << 
574                                                << 
575 inline void G4ViewParameters::SetSpecialMeshRe << 
576 {fSpecialMeshRendering = smr;}                 << 
577                                                << 
578 inline void G4ViewParameters::SetSpecialMeshRe << 
579 {fSpecialMeshRenderingOption = option;}        << 
580                                                << 
581 inline void G4ViewParameters::SetSpecialMeshVo << 
582 (const std::vector<G4ModelingParameters::PVNam << 
583 {fSpecialMeshVolumes = smvs;}                  << 
584                                                   394