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 3.1)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  5 // * The  Geant4 software  is  copyright of th << 
  6 // * the Geant4 Collaboration.  It is provided << 
  7 // * conditions of the Geant4 Software License << 
  8 // * LICENSE and available at  http://cern.ch/ << 
  9 // * include a list of copyright holders.      << 
 10 // *                                           << 
 11 // * Neither the authors of this software syst << 
 12 // * institutes,nor the agencies providing fin << 
 13 // * work  make  any representation or  warran << 
 14 // * regarding  this  software system or assum << 
 15 // * use.  Please see the license in the file  << 
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                           << 
 18 // * This  code  implementation is the result  << 
 19 // * technical work of the GEANT4 collaboratio << 
 20 // * By using,  copying,  modifying or  distri << 
 21 // * any work based  on the software)  you  ag << 
 22 // * use  in  resulting  scientific  publicati << 
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // ******************************************* << 
 25 //                                             << 
 26 //                                                  7 //
                                                   >>   8 // $Id: G4ViewParameters.icc,v 1.4 2001/02/04 20:23:04 johna Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-03-01 $
 27 //                                                 10 //
 28 //                                                 11 // 
 29 // John Allison  20th October 1996                 12 // John Allison  20th October 1996
 30 // View parameters and options.                    13 // View parameters and options.
 31                                                    14 
 32 inline G4ViewParameters::DrawingStyle              15 inline G4ViewParameters::DrawingStyle
 33 G4ViewParameters::GetDrawingStyle () const {       16 G4ViewParameters::GetDrawingStyle () const {
 34   return fDrawingStyle;                            17   return fDrawingStyle;
 35 }                                                  18 }
 36                                                    19 
 37 inline G4bool G4ViewParameters::IsAuxEdgeVisib <<  20 inline G4ViewParameters::RepStyle G4ViewParameters::GetRepStyle () const {
 38   return fAuxEdgeVisible;                      <<  21   return fRepStyle;
 39 }                                                  22 }
 40                                                    23 
 41 inline G4bool G4ViewParameters::IsCulling () c     24 inline G4bool G4ViewParameters::IsCulling () const {
 42   return fCulling;                                 25   return fCulling;
 43 }                                                  26 }
 44                                                    27 
 45 inline G4bool G4ViewParameters::IsCullingInvis     28 inline G4bool G4ViewParameters::IsCullingInvisible () const {
 46   return fCullInvisible;                           29   return fCullInvisible;
 47 }                                                  30 }
 48                                                    31 
 49 inline G4bool G4ViewParameters::IsDensityCulli     32 inline G4bool G4ViewParameters::IsDensityCulling () const {
 50   return fDensityCulling;                          33   return fDensityCulling;
 51 }                                                  34 }
 52                                                    35 
 53 inline G4double G4ViewParameters::GetVisibleDe     36 inline G4double G4ViewParameters::GetVisibleDensity () const {
 54   return fVisibleDensity;                          37   return fVisibleDensity;
 55 }                                                  38 }
 56                                                    39 
 57 inline G4bool G4ViewParameters::IsCullingCover     40 inline G4bool G4ViewParameters::IsCullingCovered () const {
 58   return fCullCovered;                             41   return fCullCovered;
 59 }                                                  42 }
 60                                                    43 
 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     44 inline G4bool G4ViewParameters::IsSection () const {
 70   return fSection;                                 45   return fSection;
 71 }                                                  46 }
 72                                                    47 
 73 inline const G4Plane3D& G4ViewParameters::GetS     48 inline const G4Plane3D& G4ViewParameters::GetSectionPlane () const {
 74   return fSectionPlane;                            49   return fSectionPlane;
 75 }                                                  50 }
 76                                                    51 
 77 inline G4bool G4ViewParameters::IsCutaway () c     52 inline G4bool G4ViewParameters::IsCutaway () const {
 78   return fCutawayPlanes.size() > 0;            <<  53   return fCutaway;
 79 }                                                  54 }
 80                                                    55 
 81 inline G4ViewParameters::CutawayMode G4ViewPar << 
 82 { return fCutawayMode;}                        << 
 83                                                << 
 84 inline const G4Planes& G4ViewParameters::GetCu     56 inline const G4Planes& G4ViewParameters::GetCutawayPlanes () const {
 85   return fCutawayPlanes;                           57   return fCutawayPlanes;
 86 }                                                  58 }
 87                                                    59 
 88 inline G4bool G4ViewParameters::IsExplode () c     60 inline G4bool G4ViewParameters::IsExplode () const {
 89   return fExplodeFactor > 1.;                  <<  61   return fExplode;
 90 }                                                  62 }
 91                                                    63 
 92 inline G4double G4ViewParameters::GetExplodeFa     64 inline G4double G4ViewParameters::GetExplodeFactor () const {
 93   return fExplodeFactor;                           65   return fExplodeFactor;
 94 }                                                  66 }
 95                                                    67 
 96 inline const G4Point3D& G4ViewParameters::GetE << 
 97   return fExplodeCentre;                       << 
 98 }                                              << 
 99                                                << 
100 inline G4int G4ViewParameters::GetNoOfSides ()     68 inline G4int G4ViewParameters::GetNoOfSides () const {
101   return fNoOfSides;                               69   return fNoOfSides;
102 }                                                  70 }
103                                                    71 
104 inline const G4Vector3D& G4ViewParameters::Get     72 inline const G4Vector3D& G4ViewParameters::GetViewpointDirection () const {
105   return fViewpointDirection;                      73   return fViewpointDirection;
106 }                                                  74 }
107                                                    75 
108 inline const G4Vector3D& G4ViewParameters::Get     76 inline const G4Vector3D& G4ViewParameters::GetUpVector () const {
109   return fUpVector;                                77   return fUpVector;
110 }                                                  78 }
111                                                    79 
112 inline G4double G4ViewParameters::GetFieldHalf     80 inline G4double G4ViewParameters::GetFieldHalfAngle () const {
113   return fFieldHalfAngle;                          81   return fFieldHalfAngle;
114 }                                                  82 }
115                                                    83 
116 inline G4double G4ViewParameters::GetZoomFacto     84 inline G4double G4ViewParameters::GetZoomFactor () const {
117   return fZoomFactor;                              85   return fZoomFactor;
118 }                                                  86 }
119                                                    87 
120 inline const G4Vector3D& G4ViewParameters::Get << 
121   return fScaleFactor;                         << 
122 }                                              << 
123                                                << 
124 inline const G4Point3D& G4ViewParameters::GetC     88 inline const G4Point3D& G4ViewParameters::GetCurrentTargetPoint () const {
125   return fCurrentTargetPoint;                      89   return fCurrentTargetPoint;
126 }                                                  90 }
127                                                    91 
128 inline G4double G4ViewParameters::GetDolly ()      92 inline G4double G4ViewParameters::GetDolly () const {
129   return fDolly;                                   93   return fDolly;
130 }                                                  94 }
131                                                    95 
132 inline const G4Vector3D& G4ViewParameters::Get     96 inline const G4Vector3D& G4ViewParameters::GetLightpointDirection () const {
133   return fRelativeLightpointDirection;             97   return fRelativeLightpointDirection;
134 }                                                  98 }
135                                                    99 
136 inline G4bool G4ViewParameters::GetLightsMoveW    100 inline G4bool G4ViewParameters::GetLightsMoveWithCamera () const {
137   return fLightsMoveWithCamera;                   101   return fLightsMoveWithCamera;
138 }                                                 102 }
139                                                   103 
                                                   >> 104 inline G4bool G4ViewParameters::IsViewGeom () const {
                                                   >> 105   return fViewGeom;
                                                   >> 106 }
                                                   >> 107 
                                                   >> 108 inline G4bool G4ViewParameters::IsViewHits () const {
                                                   >> 109   return fViewHits;
                                                   >> 110 }
                                                   >> 111 
                                                   >> 112 inline G4bool G4ViewParameters::IsViewDigis () const {
                                                   >> 113   return fViewDigis;
                                                   >> 114 }
                                                   >> 115 
140 inline const G4VisAttributes*                     116 inline const G4VisAttributes*
141 G4ViewParameters::GetDefaultVisAttributes () c    117 G4ViewParameters::GetDefaultVisAttributes () const {
142   return &fDefaultVisAttributes;                  118   return &fDefaultVisAttributes;
143 }                                                 119 }
144                                                   120 
145 inline const G4VisAttributes*                     121 inline const G4VisAttributes*
146 G4ViewParameters::GetDefaultTextVisAttributes     122 G4ViewParameters::GetDefaultTextVisAttributes () const {
147   return &fDefaultTextVisAttributes;              123   return &fDefaultTextVisAttributes;
148 }                                                 124 }
149                                                   125 
150 inline const G4VMarker& G4ViewParameters::GetD    126 inline const G4VMarker& G4ViewParameters::GetDefaultMarker () const {
151   return fDefaultMarker;                          127   return fDefaultMarker;
152 }                                                 128 }
153                                                   129 
154 inline G4double G4ViewParameters::GetGlobalMar    130 inline G4double G4ViewParameters::GetGlobalMarkerScale () const {
155   return fGlobalMarkerScale;                      131   return fGlobalMarkerScale;
156 }                                                 132 }
157                                                   133 
158 inline G4double G4ViewParameters::GetGlobalLin << 
159   return fGlobalLineWidthScale;                << 
160 }                                              << 
161                                                << 
162 inline G4bool G4ViewParameters::IsMarkerNotHid    134 inline G4bool G4ViewParameters::IsMarkerNotHidden () const {
163   return fMarkerNotHidden;                        135   return fMarkerNotHidden;
164 }                                                 136 }
165                                                   137 
166 inline bool G4ViewParameters::IsWindowSizeHint << 138 inline G4int G4ViewParameters::GetWindowSizeHintX () const {
167   return ((fGeometryMask & fWidthValue) != 0); << 
168 }                                              << 
169                                                << 
170 inline bool G4ViewParameters::IsWindowSizeHint << 
171   return ((fGeometryMask & fHeightValue) != 0) << 
172 }                                              << 
173                                                << 
174 inline bool G4ViewParameters::IsWindowLocation << 
175   return ((fGeometryMask & fXValue) != 0);     << 
176 }                                              << 
177                                                << 
178 inline bool G4ViewParameters::IsWindowLocation << 
179   return ((fGeometryMask & fYValue) != 0);     << 
180 }                                              << 
181                                                << 
182 inline unsigned int G4ViewParameters::GetWindo << 
183   return fWindowSizeHintX;                        139   return fWindowSizeHintX;
184 }                                                 140 }
185                                                   141 
186 inline unsigned int G4ViewParameters::GetWindo << 142 inline G4int G4ViewParameters::GetWindowSizeHintY () const {
187   return fWindowSizeHintY;                        143   return fWindowSizeHintY;
188 }                                                 144 }
189                                                   145 
190 inline G4int G4ViewParameters::GetWindowLocati << 
191   return fWindowLocationHintX;                 << 
192 }                                              << 
193                                                << 
194 inline G4int G4ViewParameters::GetWindowLocati << 
195   return fWindowLocationHintY;                 << 
196 }                                              << 
197                                                << 
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 << 
207   return fXGeometryString;                     << 
208 }                                              << 
209                                                << 
210 inline G4bool G4ViewParameters::IsAutoRefresh     146 inline G4bool G4ViewParameters::IsAutoRefresh () const {
211   return fAutoRefresh;                            147   return fAutoRefresh;
212 }                                                 148 }
213                                                   149 
214 inline const G4Colour& G4ViewParameters::GetBa << 
215   return fBackgroundColour;                    << 
216 }                                              << 
217                                                << 
218 inline G4bool G4ViewParameters::IsPicking () c << 
219   return fPicking;                             << 
220 }                                              << 
221                                                << 
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                                       150 inline void
317 G4ViewParameters::SetDrawingStyle (G4ViewParam    151 G4ViewParameters::SetDrawingStyle (G4ViewParameters::DrawingStyle style) {
318   fDrawingStyle = style;                          152   fDrawingStyle = style;
319 }                                                 153 }
320                                                   154 
321 inline void G4ViewParameters::SetAuxEdgeVisibl << 155 inline void
322   fAuxEdgeVisible = vis;                       << 156 G4ViewParameters::SetRepStyle (G4ViewParameters::RepStyle style) {
                                                   >> 157   fRepStyle = style;
323 }                                                 158 }
324                                                   159 
325 inline void G4ViewParameters::SetCulling (G4bo    160 inline void G4ViewParameters::SetCulling (G4bool value) {
326   fCulling = value;                               161   fCulling = value;
327 }                                                 162 }
328                                                   163 
329 inline void G4ViewParameters::SetCullingInvisi    164 inline void G4ViewParameters::SetCullingInvisible (G4bool value) {
330   fCullInvisible = value;                         165   fCullInvisible = value;
331 }                                                 166 }
332                                                   167 
333 inline void G4ViewParameters::SetDensityCullin    168 inline void G4ViewParameters::SetDensityCulling (G4bool value) {
334   fDensityCulling = value;                        169   fDensityCulling = value;
335 }                                                 170 }
336                                                   171 
337 inline void G4ViewParameters::SetCullingCovere    172 inline void G4ViewParameters::SetCullingCovered (G4bool value) {
338   fCullCovered = value;                           173   fCullCovered = value;
339 }                                                 174 }
340                                                   175 
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     176 inline void G4ViewParameters::SetSectionPlane (const G4Plane3D& sectionPlane) {
350   fSection = true;                                177   fSection = true;
351   fSectionPlane = sectionPlane;                   178   fSectionPlane = sectionPlane;
352 }                                                 179 }
353                                                   180 
354 inline void G4ViewParameters::UnsetSectionPlan    181 inline void G4ViewParameters::UnsetSectionPlane () {
355   fSection = false;                               182   fSection = false;
356 }                                                 183 }
357                                                   184 
358 inline void G4ViewParameters::SetCutawayMode   << 
359 (G4ViewParameters::CutawayMode cutawayMode) {  << 
360   fCutawayMode = cutawayMode;                  << 
361 }                                              << 
362                                                << 
363 inline void G4ViewParameters::ClearCutawayPlan << 
364   fCutawayPlanes.clear ();                     << 
365 }                                              << 
366                                                << 
367 inline void G4ViewParameters::SetViewpointDire    185 inline void G4ViewParameters::SetViewpointDirection
368 (const G4Vector3D& viewpointDirection) {          186 (const G4Vector3D& viewpointDirection) {
369   SetViewAndLights (viewpointDirection);       << 187   fViewpointDirection = viewpointDirection;
370 }                                                 188 }
371                                                   189 
372 inline void G4ViewParameters::SetExplodeFactor    190 inline void G4ViewParameters::SetExplodeFactor (G4double explodeFactor) {
                                                   >> 191   fExplode = true;
373   fExplodeFactor = explodeFactor;                 192   fExplodeFactor = explodeFactor;
374   if (fExplodeFactor < 1.) fExplodeFactor = 1. << 
375 }                                                 193 }
376                                                   194 
377 inline void G4ViewParameters::UnsetExplodeFact    195 inline void G4ViewParameters::UnsetExplodeFactor () {
378   fExplodeFactor = 1.;                         << 196   fExplode = false;
379 }                                                 197 }
380                                                   198 
381 inline void G4ViewParameters::SetExplodeCentre << 
382 (const G4Point3D& explodeCentre) {             << 
383   fExplodeCentre = explodeCentre;              << 
384 }                                              << 
385 inline void G4ViewParameters::SetUpVector (con    199 inline void G4ViewParameters::SetUpVector (const G4Vector3D& upVector) {
386   fUpVector = upVector;                           200   fUpVector = upVector;
387 }                                                 201 }
388                                                   202 
389 inline void G4ViewParameters::SetFieldHalfAngl    203 inline void G4ViewParameters::SetFieldHalfAngle (G4double fieldHalfAngle) {
390   fFieldHalfAngle = fieldHalfAngle;               204   fFieldHalfAngle = fieldHalfAngle;
391 }                                                 205 }
392                                                   206 
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    207 inline void G4ViewParameters::SetZoomFactor (G4double zoomFactor) {
402   fZoomFactor = zoomFactor;                       208   fZoomFactor = zoomFactor;
403 }                                                 209 }
404                                                   210 
405 inline void                                       211 inline void
406 G4ViewParameters::MultiplyZoomFactor (G4double    212 G4ViewParameters::MultiplyZoomFactor (G4double zoomFactorMultiplier) {
407   fZoomFactor *= zoomFactorMultiplier;            213   fZoomFactor *= zoomFactorMultiplier;
408 }                                                 214 }
409                                                   215 
410 inline void G4ViewParameters::SetScaleFactor ( << 
411   fScaleFactor = scaleFactor;                  << 
412 }                                              << 
413                                                << 
414 inline void                                       216 inline void
415 G4ViewParameters::SetCurrentTargetPoint (const    217 G4ViewParameters::SetCurrentTargetPoint (const G4Point3D& currentTargetPoint) {
416   fCurrentTargetPoint = currentTargetPoint;       218   fCurrentTargetPoint = currentTargetPoint;
417 }                                                 219 }
418                                                   220 
419 inline void G4ViewParameters::SetDolly (G4doub    221 inline void G4ViewParameters::SetDolly (G4double dolly) {
420   fDolly = dolly;                                 222   fDolly = dolly;
421 }                                                 223 }
422                                                   224 
423 inline void G4ViewParameters::IncrementDolly (    225 inline void G4ViewParameters::IncrementDolly (G4double dollyIncrement) {
424   fDolly += dollyIncrement;                       226   fDolly += dollyIncrement;
425 }                                                 227 }
426                                                   228 
427 inline void G4ViewParameters::SetLightsMoveWit    229 inline void G4ViewParameters::SetLightsMoveWithCamera (G4bool moves) {
428   fLightsMoveWithCamera = moves;                  230   fLightsMoveWithCamera = moves;
429 }                                                 231 }
430                                                   232 
                                                   >> 233 inline void G4ViewParameters::SetViewGeom () {
                                                   >> 234   fViewGeom = true;
                                                   >> 235 }
                                                   >> 236 
                                                   >> 237 inline void G4ViewParameters::UnsetViewGeom () {
                                                   >> 238   fViewGeom = false;
                                                   >> 239 }
                                                   >> 240 
                                                   >> 241 inline void G4ViewParameters::SetViewHits () {
                                                   >> 242   fViewHits = true;
                                                   >> 243 }
                                                   >> 244 
                                                   >> 245 inline void G4ViewParameters::UnsetViewHits () {
                                                   >> 246   fViewHits = false;
                                                   >> 247 }
                                                   >> 248 
                                                   >> 249 inline void G4ViewParameters::SetViewDigis () {
                                                   >> 250   fViewDigis = true;
                                                   >> 251 }
                                                   >> 252 
                                                   >> 253 inline void G4ViewParameters::UnsetViewDigis () {
                                                   >> 254   fViewDigis = false;
                                                   >> 255 }
                                                   >> 256 
431 inline void G4ViewParameters::SetDefaultVisAtt    257 inline void G4ViewParameters::SetDefaultVisAttributes
432 (const G4VisAttributes& defaultVisAttributes)     258 (const G4VisAttributes& defaultVisAttributes) {
433   fDefaultVisAttributes = defaultVisAttributes    259   fDefaultVisAttributes = defaultVisAttributes;
434 }                                                 260 }
435                                                   261 
436 inline void G4ViewParameters::SetDefaultColour << 
437   fDefaultVisAttributes.SetColour (colour);    << 
438 }                                              << 
439                                                << 
440 inline void G4ViewParameters::SetDefaultTextVi    262 inline void G4ViewParameters::SetDefaultTextVisAttributes
441 (const G4VisAttributes& defaultTextVisAttribut    263 (const G4VisAttributes& defaultTextVisAttributes) {
442   fDefaultTextVisAttributes = defaultTextVisAt    264   fDefaultTextVisAttributes = defaultTextVisAttributes;
443 }                                                 265 }
444                                                   266 
445 inline void G4ViewParameters::SetDefaultTextCo << 
446   fDefaultTextVisAttributes.SetColour (colour) << 
447 }                                              << 
448                                                << 
449 inline void                                       267 inline void
450 G4ViewParameters::SetDefaultMarker (const G4VM    268 G4ViewParameters::SetDefaultMarker (const G4VMarker& defaultMarker) {
451   fDefaultMarker = defaultMarker;                 269   fDefaultMarker = defaultMarker;
452 }                                                 270 }
453                                                   271 
454 inline void                                       272 inline void
455 G4ViewParameters::SetGlobalMarkerScale (G4doub    273 G4ViewParameters::SetGlobalMarkerScale (G4double globalMarkerScale) {
456   fGlobalMarkerScale = globalMarkerScale;         274   fGlobalMarkerScale = globalMarkerScale;
457 }                                                 275 }
458                                                   276 
459 inline void                                    << 
460 G4ViewParameters::SetGlobalLineWidthScale (G4d << 
461   fGlobalLineWidthScale = globalLineWidthScale << 
462 }                                              << 
463                                                << 
464 inline void G4ViewParameters::SetMarkerHidden     277 inline void G4ViewParameters::SetMarkerHidden () {
465   fMarkerNotHidden = false;                       278   fMarkerNotHidden = false;
466 }                                                 279 }
467                                                   280 
468 inline void G4ViewParameters::SetMarkerNotHidd    281 inline void G4ViewParameters::SetMarkerNotHidden () {
469   fMarkerNotHidden = true;                        282   fMarkerNotHidden = true;
470 }                                                 283 }
471                                                   284 
472 inline void G4ViewParameters::SetWindowSizeHin    285 inline void G4ViewParameters::SetWindowSizeHint (G4int xHint, G4int yHint) {
473   fWindowSizeHintX = xHint;                       286   fWindowSizeHintX = xHint;
474   fWindowSizeHintY = yHint;                       287   fWindowSizeHintY = yHint;
475 }                                                 288 }
476                                                   289 
477 inline void G4ViewParameters::SetWindowLocatio << 
478   fWindowLocationHintX = xHint;                << 
479   fWindowLocationHintY = yHint;                << 
480 }                                              << 
481                                                << 
482 inline void G4ViewParameters::SetAutoRefresh (    290 inline void G4ViewParameters::SetAutoRefresh (G4bool state) {
483   fAutoRefresh = state;                           291   fAutoRefresh = state;
484 }                                                 292 }
485                                                << 
486 inline void G4ViewParameters::SetBackgroundCol << 
487   fBackgroundColour = colour;                  << 
488 }                                              << 
489                                                << 
490 inline void G4ViewParameters::SetPicking (G4bo << 
491   fPicking = picking;                          << 
492 }                                              << 
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                                                   293