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