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 9.2.p1)


  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,v 1.16.6.1 2009/03/13 09:02:57 gcosmo Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02-patch-01 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // John Allison  20th October 1996                 31 // John Allison  20th October 1996
 30 // View parameters and options.                    32 // View parameters and options.
 31                                                    33 
 32 inline G4ViewParameters::DrawingStyle              34 inline G4ViewParameters::DrawingStyle
 33 G4ViewParameters::GetDrawingStyle () const {       35 G4ViewParameters::GetDrawingStyle () const {
 34   return fDrawingStyle;                            36   return fDrawingStyle;
 35 }                                                  37 }
 36                                                    38 
 37 inline G4bool G4ViewParameters::IsAuxEdgeVisib     39 inline G4bool G4ViewParameters::IsAuxEdgeVisible () const {
 38   return fAuxEdgeVisible;                          40   return fAuxEdgeVisible;
 39 }                                                  41 }
 40                                                    42 
                                                   >>  43 inline G4ViewParameters::RepStyle G4ViewParameters::GetRepStyle () const {
                                                   >>  44   return fRepStyle;
                                                   >>  45 }
                                                   >>  46 
 41 inline G4bool G4ViewParameters::IsCulling () c     47 inline G4bool G4ViewParameters::IsCulling () const {
 42   return fCulling;                                 48   return fCulling;
 43 }                                                  49 }
 44                                                    50 
 45 inline G4bool G4ViewParameters::IsCullingInvis     51 inline G4bool G4ViewParameters::IsCullingInvisible () const {
 46   return fCullInvisible;                           52   return fCullInvisible;
 47 }                                                  53 }
 48                                                    54 
 49 inline G4bool G4ViewParameters::IsDensityCulli     55 inline G4bool G4ViewParameters::IsDensityCulling () const {
 50   return fDensityCulling;                          56   return fDensityCulling;
 51 }                                                  57 }
 52                                                    58 
 53 inline G4double G4ViewParameters::GetVisibleDe     59 inline G4double G4ViewParameters::GetVisibleDensity () const {
 54   return fVisibleDensity;                          60   return fVisibleDensity;
 55 }                                                  61 }
 56                                                    62 
 57 inline G4bool G4ViewParameters::IsCullingCover     63 inline G4bool G4ViewParameters::IsCullingCovered () const {
 58   return fCullCovered;                             64   return fCullCovered;
 59 }                                                  65 }
 60                                                    66 
 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     67 inline G4bool G4ViewParameters::IsSection () const {
 70   return fSection;                                 68   return fSection;
 71 }                                                  69 }
 72                                                    70 
 73 inline const G4Plane3D& G4ViewParameters::GetS     71 inline const G4Plane3D& G4ViewParameters::GetSectionPlane () const {
 74   return fSectionPlane;                            72   return fSectionPlane;
 75 }                                                  73 }
 76                                                    74 
 77 inline G4bool G4ViewParameters::IsCutaway () c     75 inline G4bool G4ViewParameters::IsCutaway () const {
 78   return fCutawayPlanes.size() > 0;                76   return fCutawayPlanes.size() > 0;
 79 }                                                  77 }
 80                                                    78 
 81 inline G4ViewParameters::CutawayMode G4ViewPar     79 inline G4ViewParameters::CutawayMode G4ViewParameters::GetCutawayMode () const
 82 { return fCutawayMode;}                            80 { return fCutawayMode;}
 83                                                    81 
 84 inline const G4Planes& G4ViewParameters::GetCu     82 inline const G4Planes& G4ViewParameters::GetCutawayPlanes () const {
 85   return fCutawayPlanes;                           83   return fCutawayPlanes;
 86 }                                                  84 }
 87                                                    85 
 88 inline G4bool G4ViewParameters::IsExplode () c     86 inline G4bool G4ViewParameters::IsExplode () const {
 89   return fExplodeFactor > 1.;                      87   return fExplodeFactor > 1.;
 90 }                                                  88 }
 91                                                    89 
 92 inline G4double G4ViewParameters::GetExplodeFa     90 inline G4double G4ViewParameters::GetExplodeFactor () const {
 93   return fExplodeFactor;                           91   return fExplodeFactor;
 94 }                                                  92 }
 95                                                    93 
 96 inline const G4Point3D& G4ViewParameters::GetE     94 inline const G4Point3D& G4ViewParameters::GetExplodeCentre () const {
 97   return fExplodeCentre;                           95   return fExplodeCentre;
 98 }                                                  96 }
 99                                                    97 
100 inline G4int G4ViewParameters::GetNoOfSides ()     98 inline G4int G4ViewParameters::GetNoOfSides () const {
101   return fNoOfSides;                               99   return fNoOfSides;
102 }                                                 100 }
103                                                   101 
104 inline const G4Vector3D& G4ViewParameters::Get    102 inline const G4Vector3D& G4ViewParameters::GetViewpointDirection () const {
105   return fViewpointDirection;                     103   return fViewpointDirection;
106 }                                                 104 }
107                                                   105 
108 inline const G4Vector3D& G4ViewParameters::Get    106 inline const G4Vector3D& G4ViewParameters::GetUpVector () const {
109   return fUpVector;                               107   return fUpVector;
110 }                                                 108 }
111                                                   109 
112 inline G4double G4ViewParameters::GetFieldHalf    110 inline G4double G4ViewParameters::GetFieldHalfAngle () const {
113   return fFieldHalfAngle;                         111   return fFieldHalfAngle;
114 }                                                 112 }
115                                                   113 
116 inline G4double G4ViewParameters::GetZoomFacto    114 inline G4double G4ViewParameters::GetZoomFactor () const {
117   return fZoomFactor;                             115   return fZoomFactor;
118 }                                                 116 }
119                                                   117 
120 inline const G4Vector3D& G4ViewParameters::Get    118 inline const G4Vector3D& G4ViewParameters::GetScaleFactor () const {
121   return fScaleFactor;                            119   return fScaleFactor;
122 }                                                 120 }
123                                                   121 
124 inline const G4Point3D& G4ViewParameters::GetC    122 inline const G4Point3D& G4ViewParameters::GetCurrentTargetPoint () const {
125   return fCurrentTargetPoint;                     123   return fCurrentTargetPoint;
126 }                                                 124 }
127                                                   125 
128 inline G4double G4ViewParameters::GetDolly ()     126 inline G4double G4ViewParameters::GetDolly () const {
129   return fDolly;                                  127   return fDolly;
130 }                                                 128 }
131                                                   129 
132 inline const G4Vector3D& G4ViewParameters::Get    130 inline const G4Vector3D& G4ViewParameters::GetLightpointDirection () const {
133   return fRelativeLightpointDirection;            131   return fRelativeLightpointDirection;
134 }                                                 132 }
135                                                   133 
136 inline G4bool G4ViewParameters::GetLightsMoveW    134 inline G4bool G4ViewParameters::GetLightsMoveWithCamera () const {
137   return fLightsMoveWithCamera;                   135   return fLightsMoveWithCamera;
138 }                                                 136 }
139                                                   137 
140 inline const G4VisAttributes*                     138 inline const G4VisAttributes*
141 G4ViewParameters::GetDefaultVisAttributes () c    139 G4ViewParameters::GetDefaultVisAttributes () const {
142   return &fDefaultVisAttributes;                  140   return &fDefaultVisAttributes;
143 }                                                 141 }
144                                                   142 
145 inline const G4VisAttributes*                     143 inline const G4VisAttributes*
146 G4ViewParameters::GetDefaultTextVisAttributes     144 G4ViewParameters::GetDefaultTextVisAttributes () const {
147   return &fDefaultTextVisAttributes;              145   return &fDefaultTextVisAttributes;
148 }                                                 146 }
149                                                   147 
150 inline const G4VMarker& G4ViewParameters::GetD    148 inline const G4VMarker& G4ViewParameters::GetDefaultMarker () const {
151   return fDefaultMarker;                          149   return fDefaultMarker;
152 }                                                 150 }
153                                                   151 
154 inline G4double G4ViewParameters::GetGlobalMar    152 inline G4double G4ViewParameters::GetGlobalMarkerScale () const {
155   return fGlobalMarkerScale;                      153   return fGlobalMarkerScale;
156 }                                                 154 }
157                                                   155 
158 inline G4double G4ViewParameters::GetGlobalLin    156 inline G4double G4ViewParameters::GetGlobalLineWidthScale () const {
159   return fGlobalLineWidthScale;                   157   return fGlobalLineWidthScale;
160 }                                                 158 }
161                                                   159 
162 inline G4bool G4ViewParameters::IsMarkerNotHid    160 inline G4bool G4ViewParameters::IsMarkerNotHidden () const {
163   return fMarkerNotHidden;                        161   return fMarkerNotHidden;
164 }                                                 162 }
165                                                   163 
166 inline bool G4ViewParameters::IsWindowSizeHint    164 inline bool G4ViewParameters::IsWindowSizeHintX () const {
167   return ((fGeometryMask & fWidthValue) != 0); << 165   return (fGeometryMask & fWidthValue);
168 }                                                 166 }
169                                                   167 
170 inline bool G4ViewParameters::IsWindowSizeHint    168 inline bool G4ViewParameters::IsWindowSizeHintY () const {
171   return ((fGeometryMask & fHeightValue) != 0) << 169   return (fGeometryMask & fHeightValue);
172 }                                                 170 }
173                                                   171 
174 inline bool G4ViewParameters::IsWindowLocation    172 inline bool G4ViewParameters::IsWindowLocationHintX () const {
175   return ((fGeometryMask & fXValue) != 0);     << 173   return (fGeometryMask & fXValue);
176 }                                                 174 }
177                                                   175 
178 inline bool G4ViewParameters::IsWindowLocation    176 inline bool G4ViewParameters::IsWindowLocationHintY () const {
179   return ((fGeometryMask & fYValue) != 0);     << 177   return (fGeometryMask & fYValue);
180 }                                                 178 }
181                                                   179 
182 inline unsigned int G4ViewParameters::GetWindo    180 inline unsigned int G4ViewParameters::GetWindowSizeHintX () const {
183   return fWindowSizeHintX;                        181   return fWindowSizeHintX;
184 }                                                 182 }
185                                                   183 
186 inline unsigned int G4ViewParameters::GetWindo    184 inline unsigned int G4ViewParameters::GetWindowSizeHintY () const {
187   return fWindowSizeHintY;                        185   return fWindowSizeHintY;
188 }                                                 186 }
189                                                   187 
190 inline G4int G4ViewParameters::GetWindowLocati    188 inline G4int G4ViewParameters::GetWindowLocationHintX () const {
191   return fWindowLocationHintX;                    189   return fWindowLocationHintX;
192 }                                                 190 }
193                                                   191 
194 inline G4int G4ViewParameters::GetWindowLocati    192 inline G4int G4ViewParameters::GetWindowLocationHintY () const {
195   return fWindowLocationHintY;                    193   return fWindowLocationHintY;
196 }                                                 194 }
197                                                   195 
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    196 inline const G4String& G4ViewParameters::GetXGeometryString () const {
207   return fXGeometryString;                        197   return fXGeometryString;
208 }                                                 198 }
209                                                   199 
210 inline G4bool G4ViewParameters::IsAutoRefresh     200 inline G4bool G4ViewParameters::IsAutoRefresh () const {
211   return fAutoRefresh;                            201   return fAutoRefresh;
212 }                                                 202 }
213                                                   203 
214 inline const G4Colour& G4ViewParameters::GetBa    204 inline const G4Colour& G4ViewParameters::GetBackgroundColour () const {
215   return fBackgroundColour;                       205   return fBackgroundColour;
216 }                                                 206 }
217                                                   207 
218 inline G4bool G4ViewParameters::IsPicking () c    208 inline G4bool G4ViewParameters::IsPicking () const {
219   return fPicking;                                209   return fPicking;
220 }                                                 210 }
221                                                   211 
222 inline G4ViewParameters::RotationStyle         << 
223 G4ViewParameters::GetRotationStyle() const {re << 
224                                                << 
225 inline const std::vector<G4ModelingParameters: << 
226 G4ViewParameters::GetVisAttributesModifiers()  << 
227   return fVisAttributesModifiers;              << 
228 }                                              << 
229                                                << 
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                                       212 inline void
317 G4ViewParameters::SetDrawingStyle (G4ViewParam    213 G4ViewParameters::SetDrawingStyle (G4ViewParameters::DrawingStyle style) {
318   fDrawingStyle = style;                          214   fDrawingStyle = style;
319 }                                                 215 }
320                                                   216 
321 inline void G4ViewParameters::SetAuxEdgeVisibl    217 inline void G4ViewParameters::SetAuxEdgeVisible (G4bool vis) {
322   fAuxEdgeVisible = vis;                          218   fAuxEdgeVisible = vis;
323 }                                                 219 }
324                                                   220 
                                                   >> 221 inline void
                                                   >> 222 G4ViewParameters::SetRepStyle (G4ViewParameters::RepStyle style) {
                                                   >> 223   fRepStyle = style;
                                                   >> 224 }
                                                   >> 225 
325 inline void G4ViewParameters::SetCulling (G4bo    226 inline void G4ViewParameters::SetCulling (G4bool value) {
326   fCulling = value;                               227   fCulling = value;
327 }                                                 228 }
328                                                   229 
329 inline void G4ViewParameters::SetCullingInvisi    230 inline void G4ViewParameters::SetCullingInvisible (G4bool value) {
330   fCullInvisible = value;                         231   fCullInvisible = value;
331 }                                                 232 }
332                                                   233 
333 inline void G4ViewParameters::SetDensityCullin    234 inline void G4ViewParameters::SetDensityCulling (G4bool value) {
334   fDensityCulling = value;                        235   fDensityCulling = value;
335 }                                                 236 }
336                                                   237 
337 inline void G4ViewParameters::SetCullingCovere    238 inline void G4ViewParameters::SetCullingCovered (G4bool value) {
338   fCullCovered = value;                           239   fCullCovered = value;
339 }                                                 240 }
340                                                   241 
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     242 inline void G4ViewParameters::SetSectionPlane (const G4Plane3D& sectionPlane) {
350   fSection = true;                                243   fSection = true;
351   fSectionPlane = sectionPlane;                   244   fSectionPlane = sectionPlane;
352 }                                                 245 }
353                                                   246 
354 inline void G4ViewParameters::UnsetSectionPlan    247 inline void G4ViewParameters::UnsetSectionPlane () {
355   fSection = false;                               248   fSection = false;
356 }                                                 249 }
357                                                   250 
358 inline void G4ViewParameters::SetCutawayMode      251 inline void G4ViewParameters::SetCutawayMode
359 (G4ViewParameters::CutawayMode cutawayMode) {     252 (G4ViewParameters::CutawayMode cutawayMode) {
360   fCutawayMode = cutawayMode;                     253   fCutawayMode = cutawayMode;
361 }                                                 254 }
362                                                   255 
363 inline void G4ViewParameters::ClearCutawayPlan    256 inline void G4ViewParameters::ClearCutawayPlanes () {
364   fCutawayPlanes.clear ();                        257   fCutawayPlanes.clear ();
365 }                                                 258 }
366                                                   259 
367 inline void G4ViewParameters::SetViewpointDire    260 inline void G4ViewParameters::SetViewpointDirection
368 (const G4Vector3D& viewpointDirection) {          261 (const G4Vector3D& viewpointDirection) {
369   SetViewAndLights (viewpointDirection);          262   SetViewAndLights (viewpointDirection);
370 }                                                 263 }
371                                                   264 
372 inline void G4ViewParameters::SetExplodeFactor    265 inline void G4ViewParameters::SetExplodeFactor (G4double explodeFactor) {
373   fExplodeFactor = explodeFactor;                 266   fExplodeFactor = explodeFactor;
374   if (fExplodeFactor < 1.) fExplodeFactor = 1.    267   if (fExplodeFactor < 1.) fExplodeFactor = 1.;
375 }                                                 268 }
376                                                   269 
377 inline void G4ViewParameters::UnsetExplodeFact    270 inline void G4ViewParameters::UnsetExplodeFactor () {
378   fExplodeFactor = 1.;                            271   fExplodeFactor = 1.;
379 }                                                 272 }
380                                                   273 
381 inline void G4ViewParameters::SetExplodeCentre    274 inline void G4ViewParameters::SetExplodeCentre
382 (const G4Point3D& explodeCentre) {                275 (const G4Point3D& explodeCentre) {
383   fExplodeCentre = explodeCentre;                 276   fExplodeCentre = explodeCentre;
384 }                                                 277 }
385 inline void G4ViewParameters::SetUpVector (con    278 inline void G4ViewParameters::SetUpVector (const G4Vector3D& upVector) {
386   fUpVector = upVector;                           279   fUpVector = upVector;
387 }                                                 280 }
388                                                   281 
389 inline void G4ViewParameters::SetFieldHalfAngl    282 inline void G4ViewParameters::SetFieldHalfAngle (G4double fieldHalfAngle) {
390   fFieldHalfAngle = fieldHalfAngle;               283   fFieldHalfAngle = fieldHalfAngle;
391 }                                                 284 }
392                                                   285 
393 inline void G4ViewParameters::SetOrthogonalPro << 
394   SetFieldHalfAngle(0.);                       << 
395 }                                              << 
396                                                << 
397 inline void G4ViewParameters::SetPerspectivePr << 
398   SetFieldHalfAngle(fieldHalfAngle);           << 
399 }                                              << 
400                                                << 
401 inline void G4ViewParameters::SetZoomFactor (G    286 inline void G4ViewParameters::SetZoomFactor (G4double zoomFactor) {
402   fZoomFactor = zoomFactor;                       287   fZoomFactor = zoomFactor;
403 }                                                 288 }
404                                                   289 
405 inline void                                       290 inline void
406 G4ViewParameters::MultiplyZoomFactor (G4double    291 G4ViewParameters::MultiplyZoomFactor (G4double zoomFactorMultiplier) {
407   fZoomFactor *= zoomFactorMultiplier;            292   fZoomFactor *= zoomFactorMultiplier;
408 }                                                 293 }
409                                                   294 
410 inline void G4ViewParameters::SetScaleFactor (    295 inline void G4ViewParameters::SetScaleFactor (const G4Vector3D& scaleFactor) {
411   fScaleFactor = scaleFactor;                     296   fScaleFactor = scaleFactor;
412 }                                                 297 }
413                                                   298 
414 inline void                                       299 inline void
415 G4ViewParameters::SetCurrentTargetPoint (const    300 G4ViewParameters::SetCurrentTargetPoint (const G4Point3D& currentTargetPoint) {
416   fCurrentTargetPoint = currentTargetPoint;       301   fCurrentTargetPoint = currentTargetPoint;
417 }                                                 302 }
418                                                   303 
419 inline void G4ViewParameters::SetDolly (G4doub    304 inline void G4ViewParameters::SetDolly (G4double dolly) {
420   fDolly = dolly;                                 305   fDolly = dolly;
421 }                                                 306 }
422                                                   307 
423 inline void G4ViewParameters::IncrementDolly (    308 inline void G4ViewParameters::IncrementDolly (G4double dollyIncrement) {
424   fDolly += dollyIncrement;                       309   fDolly += dollyIncrement;
425 }                                                 310 }
426                                                   311 
427 inline void G4ViewParameters::SetLightsMoveWit    312 inline void G4ViewParameters::SetLightsMoveWithCamera (G4bool moves) {
428   fLightsMoveWithCamera = moves;                  313   fLightsMoveWithCamera = moves;
429 }                                                 314 }
430                                                   315 
431 inline void G4ViewParameters::SetDefaultVisAtt    316 inline void G4ViewParameters::SetDefaultVisAttributes
432 (const G4VisAttributes& defaultVisAttributes)     317 (const G4VisAttributes& defaultVisAttributes) {
433   fDefaultVisAttributes = defaultVisAttributes    318   fDefaultVisAttributes = defaultVisAttributes;
434 }                                                 319 }
435                                                   320 
436 inline void G4ViewParameters::SetDefaultColour << 
437   fDefaultVisAttributes.SetColour (colour);    << 
438 }                                              << 
439                                                << 
440 inline void G4ViewParameters::SetDefaultTextVi    321 inline void G4ViewParameters::SetDefaultTextVisAttributes
441 (const G4VisAttributes& defaultTextVisAttribut    322 (const G4VisAttributes& defaultTextVisAttributes) {
442   fDefaultTextVisAttributes = defaultTextVisAt    323   fDefaultTextVisAttributes = defaultTextVisAttributes;
443 }                                                 324 }
444                                                   325 
445 inline void G4ViewParameters::SetDefaultTextCo << 
446   fDefaultTextVisAttributes.SetColour (colour) << 
447 }                                              << 
448                                                << 
449 inline void                                       326 inline void
450 G4ViewParameters::SetDefaultMarker (const G4VM    327 G4ViewParameters::SetDefaultMarker (const G4VMarker& defaultMarker) {
451   fDefaultMarker = defaultMarker;                 328   fDefaultMarker = defaultMarker;
452 }                                                 329 }
453                                                   330 
454 inline void                                       331 inline void
455 G4ViewParameters::SetGlobalMarkerScale (G4doub    332 G4ViewParameters::SetGlobalMarkerScale (G4double globalMarkerScale) {
456   fGlobalMarkerScale = globalMarkerScale;         333   fGlobalMarkerScale = globalMarkerScale;
457 }                                                 334 }
458                                                   335 
459 inline void                                       336 inline void
460 G4ViewParameters::SetGlobalLineWidthScale (G4d    337 G4ViewParameters::SetGlobalLineWidthScale (G4double globalLineWidthScale) {
461   fGlobalLineWidthScale = globalLineWidthScale    338   fGlobalLineWidthScale = globalLineWidthScale;
462 }                                                 339 }
463                                                   340 
464 inline void G4ViewParameters::SetMarkerHidden     341 inline void G4ViewParameters::SetMarkerHidden () {
465   fMarkerNotHidden = false;                       342   fMarkerNotHidden = false;
466 }                                                 343 }
467                                                   344 
468 inline void G4ViewParameters::SetMarkerNotHidd    345 inline void G4ViewParameters::SetMarkerNotHidden () {
469   fMarkerNotHidden = true;                        346   fMarkerNotHidden = true;
470 }                                                 347 }
471                                                   348 
472 inline void G4ViewParameters::SetWindowSizeHin    349 inline void G4ViewParameters::SetWindowSizeHint (G4int xHint, G4int yHint) {
473   fWindowSizeHintX = xHint;                       350   fWindowSizeHintX = xHint;
474   fWindowSizeHintY = yHint;                       351   fWindowSizeHintY = yHint;
475 }                                                 352 }
476                                                   353 
477 inline void G4ViewParameters::SetWindowLocatio    354 inline void G4ViewParameters::SetWindowLocationHint (G4int xHint, G4int yHint) {
478   fWindowLocationHintX = xHint;                   355   fWindowLocationHintX = xHint;
479   fWindowLocationHintY = yHint;                   356   fWindowLocationHintY = yHint;
480 }                                                 357 }
481                                                   358 
482 inline void G4ViewParameters::SetAutoRefresh (    359 inline void G4ViewParameters::SetAutoRefresh (G4bool state) {
483   fAutoRefresh = state;                           360   fAutoRefresh = state;
484 }                                                 361 }
485                                                   362 
486 inline void G4ViewParameters::SetBackgroundCol    363 inline void G4ViewParameters::SetBackgroundColour (const G4Colour& colour) {
487   fBackgroundColour = colour;                     364   fBackgroundColour = colour;
488 }                                                 365 }
489                                                   366 
490 inline void G4ViewParameters::SetPicking (G4bo    367 inline void G4ViewParameters::SetPicking (G4bool picking) {
491   fPicking = picking;                             368   fPicking = picking;
492 }                                                 369 }
493                                                << 
494 inline void G4ViewParameters::SetRotationStyle << 
495   (G4ViewParameters::RotationStyle style) {    << 
496   fRotationStyle = style;                      << 
497 }                                              << 
498                                                << 
499 inline void G4ViewParameters::ClearVisAttribut << 
500   fVisAttributesModifiers.clear ();            << 
501 }                                              << 
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 }                                              << 
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                                                   370