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