source: trunk/source/visualization/management/src/G4ViewParameters.cc@ 1354

Last change on this file since 1354 was 1346, checked in by garnier, 15 years ago

before tag
  • Property svn:mime-type set to text/cpp
File size: 24.6 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4ViewParameters.cc,v 1.38 2010/11/05 16:00:11 allison Exp $
28// GEANT4 tag $Name: $
29//
30//
31// John Allison 19th July 1996
32// View parameters and options.
33
34#include <sstream>
35
36#include "G4ViewParameters.hh"
37
38#include "G4VisManager.hh"
39#include "G4UnitsTable.hh"
40#include "G4ios.hh"
41
42G4ViewParameters::G4ViewParameters ():
43 fNoValue(0x0000),
44 fXValue(0x0001),
45 fYValue(0x0002),
46 fWidthValue(0x0004),
47 fHeightValue(0x0008),
48 fAllValues(0x000F),
49 fXNegative(0x0010),
50 fYNegative(0x0020),
51 fGeometryMask(0),
52 fDrawingStyle (wireframe),
53 fAuxEdgeVisible (false),
54 fRepStyle (polyhedron),
55 fCulling (true),
56 fCullInvisible (true),
57 fDensityCulling (false),
58 fVisibleDensity (0.01 * g / cm3),
59 fCullCovered (false),
60 fSection (false),
61 fSectionPlane (),
62 fCutawayMode (cutawayUnion),
63 fCutawayPlanes (),
64 fExplodeFactor (1.),
65 fNoOfSides (24),
66 fViewpointDirection (G4Vector3D (0., 0., 1.)), // On z-axis.
67 fUpVector (G4Vector3D (0., 1., 0.)), // y-axis up.
68 fFieldHalfAngle (0.), // Orthogonal projection.
69 fZoomFactor (1.),
70 fScaleFactor (G4Vector3D (1., 1., 1.)),
71 fCurrentTargetPoint (),
72 fDolly (0.),
73 fLightsMoveWithCamera (false),
74 fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
75 fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
76 fDefaultVisAttributes (),
77 fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
78 fDefaultMarker (),
79 fGlobalMarkerScale (1.),
80 fGlobalLineWidthScale (1.),
81 fMarkerNotHidden (true),
82 fWindowSizeHintX (600),
83 fWindowSizeHintY (600),
84 fWindowLocationHintX(0),
85 fWindowLocationHintY(0),
86 fWindowLocationHintXNegative(true),
87 fWindowLocationHintYNegative(false),
88 fAutoRefresh (false),
89 fBackgroundColour (G4Colour(0.,0.,0.)), // Black
90 fPicking (false)
91{
92 fDefaultMarker.SetScreenSize (5.);
93 // Markers are 5 pixels "overall" size, i.e., diameter.
94}
95
96G4ViewParameters::~G4ViewParameters () {}
97
98void G4ViewParameters::MultiplyScaleFactor
99(const G4Vector3D& scaleFactorMultiplier) {
100 fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
101 fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
102 fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
103}
104
105G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
106 SetViewAndLights (fViewpointDirection);
107 return fActualLightpointDirection;
108}
109
110// Useful quantities - begin snippet.
111// Here Follow functions to evaluate the above algorithms as a
112// function of the radius of the Bounding Sphere of the object being
113// viewed. Call them in the order given - for efficiency, later
114// functions depend on the results of earlier ones (Store the
115// results of earlier functions in your own temporary variables -
116// see, for example, G4OpenGLView::SetView ().)
117
118G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
119 G4double cameraDistance;
120 if (fFieldHalfAngle == 0.) {
121 cameraDistance = radius;
122 }
123 else {
124 cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
125 }
126 return cameraDistance;
127}
128
129G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
130 G4double radius) const {
131 const G4double small = 1.e-6 * radius;
132 G4double nearDistance = cameraDistance - radius;
133 if (nearDistance < small) nearDistance = small;
134 return nearDistance;
135}
136
137G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
138 G4double nearDistance,
139 G4double radius) const {
140 G4double farDistance = cameraDistance + radius;
141 if (farDistance < nearDistance) farDistance = nearDistance;
142 return farDistance;
143}
144
145G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
146 G4double radius) const {
147 G4double frontHalfHeight;
148 if (fFieldHalfAngle == 0.) {
149 frontHalfHeight = radius / fZoomFactor;
150 }
151 else {
152 frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
153 }
154 return frontHalfHeight;
155}
156// Useful quantities - end snippet.
157
158void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
159 if (fCutawayPlanes.size () < 3 ) {
160 fCutawayPlanes.push_back (cutawayPlane);
161 }
162 else {
163 G4cout <<
164 "ERROR: G4ViewParameters::AddCutawayPlane:"
165 "\n A maximum of 3 cutaway planes supported." << G4endl;
166 }
167}
168
169void G4ViewParameters::ChangeCutawayPlane
170(size_t index, const G4Plane3D& cutawayPlane) {
171 if (index >= fCutawayPlanes.size()) {
172 G4cout <<
173 "ERROR: G4ViewParameters::ChangeCutawayPlane:"
174 "\n Plane " << index << " does not exist." << G4endl;
175 } else {
176 fCutawayPlanes[index] = cutawayPlane;
177 }
178}
179
180void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
181 const G4double reasonableMaximum = 10.0 * g / cm3;
182 if (visibleDensity < 0) {
183 G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
184 "density - ignored." << G4endl;
185 }
186 else {
187 if (visibleDensity > reasonableMaximum) {
188 G4cout << "G4ViewParameters::SetVisibleDensity: density > "
189 << G4BestUnit (reasonableMaximum, "Volumic Mass")
190 << " - did you mean this?"
191 << G4endl;
192 }
193 fVisibleDensity = visibleDensity;
194 }
195}
196
197G4int G4ViewParameters::SetNoOfSides (G4int nSides) {
198 const G4int nSidesMin = 12;
199 if (nSides < nSidesMin) {
200 nSides = nSidesMin;
201 G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
202 "\nnumber of sides per circle < " << nSidesMin
203 << "; forced to " << nSides << G4endl;
204 }
205 fNoOfSides = nSides;
206 return fNoOfSides;
207}
208
209void G4ViewParameters::SetViewAndLights
210(const G4Vector3D& viewpointDirection) {
211
212 fViewpointDirection = viewpointDirection;
213
214 // If the requested viewpoint direction is parallel to the up
215 // vector, the orientation of the view is undefined...
216 if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
217 G4cout <<
218 "WARNING: Viewpoint direction is very close to the up vector direction."
219 "\n Consider setting the up vector to obtain definable behaviour."
220 << G4endl;
221 }
222
223 // Move the lights too if requested...
224 if (fLightsMoveWithCamera) {
225 G4Vector3D zprime = fViewpointDirection.unit ();
226 G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
227 G4Vector3D yprime = zprime.cross (xprime);
228 fActualLightpointDirection =
229 fRelativeLightpointDirection.x () * xprime +
230 fRelativeLightpointDirection.y () * yprime +
231 fRelativeLightpointDirection.x () * zprime;
232 } else {
233 fActualLightpointDirection = fRelativeLightpointDirection;
234 }
235}
236
237void G4ViewParameters::SetLightpointDirection
238(const G4Vector3D& lightpointDirection) {
239 fRelativeLightpointDirection = lightpointDirection;
240 SetViewAndLights (fViewpointDirection);
241}
242
243void G4ViewParameters::SetPan (G4double right, G4double up) {
244 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
245 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
246 fCurrentTargetPoint = right * unitRight + up * unitUp;
247}
248
249void G4ViewParameters::IncrementPan (G4double right, G4double up) {
250 IncrementPan (right,up, 0);
251}
252
253void G4ViewParameters::IncrementPan (G4double right, G4double up, G4double distance) {
254 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
255 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
256 fCurrentTargetPoint += right * unitRight + up * unitUp + distance * fViewpointDirection;
257}
258
259void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
260
261 // Put performance-sensitive parameters first.
262 if (
263 // This first to optimise spin, etc.
264 (fViewpointDirection != v.fViewpointDirection) ||
265
266 // No particular order from here on.
267 (fDrawingStyle != v.fDrawingStyle) ||
268 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
269 (fRepStyle != v.fRepStyle) ||
270 (fCulling != v.fCulling) ||
271 (fCullInvisible != v.fCullInvisible) ||
272 (fDensityCulling != v.fDensityCulling) ||
273 (fVisibleDensity != v.fVisibleDensity) ||
274 (fCullCovered != v.fCullCovered) ||
275 (fSection != v.fSection) ||
276 (fNoOfSides != v.fNoOfSides) ||
277 (fUpVector != v.fUpVector) ||
278 (fFieldHalfAngle != v.fFieldHalfAngle) ||
279 (fZoomFactor != v.fZoomFactor) ||
280 (fScaleFactor != v.fScaleFactor) ||
281 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
282 (fDolly != v.fDolly) ||
283 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
284 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
285 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
286 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
287 (fDefaultMarker != v.fDefaultMarker) ||
288 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
289 (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
290 (fMarkerNotHidden != v.fMarkerNotHidden) ||
291 (fWindowSizeHintX != v.fWindowSizeHintX) ||
292 (fWindowSizeHintY != v.fWindowSizeHintY) ||
293 (fXGeometryString != v.fXGeometryString) ||
294 (fAutoRefresh != v.fAutoRefresh) ||
295 (fBackgroundColour != v.fBackgroundColour) ||
296 (fPicking != v.fPicking)
297 )
298 G4cout << "Difference in 1st batch." << G4endl;
299
300 if (fSection) {
301 if (!(fSectionPlane == v.fSectionPlane))
302 G4cout << "Difference in section planes batch." << G4endl;
303 }
304
305 if (IsCutaway()) {
306 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
307 G4cout << "Difference in no of cutaway planes." << G4endl;
308 }
309 else {
310 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
311 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
312 G4cout << "Difference in cutaway plane no. " << i << G4endl;
313 }
314 }
315 }
316
317 if (IsExplode()) {
318 if (fExplodeFactor != v.fExplodeFactor)
319 G4cout << "Difference in explode factor." << G4endl;
320 if (fExplodeCentre != v.fExplodeCentre)
321 G4cout << "Difference in explode centre." << G4endl;
322 }
323}
324
325std::ostream& operator << (std::ostream& os,
326 const G4ViewParameters::DrawingStyle& style) {
327 switch (style) {
328 case G4ViewParameters::wireframe:
329 os << "wireframe"; break;
330 case G4ViewParameters::hlr:
331 os << "hlr - hidden lines removed"; break;
332 case G4ViewParameters::hsr:
333 os << "hsr - hidden surfaces removed"; break;
334 case G4ViewParameters::hlhsr:
335 os << "hlhsr - hidden line, hidden surface removed"; break;
336 default: os << "unrecognised"; break;
337 }
338 return os;
339}
340
341std::ostream& operator << (std::ostream& os, const G4ViewParameters& v) {
342 os << "View parameters and options:";
343
344 os << "\n Drawing style: " << v.fDrawingStyle;
345
346 os << "\n Auxiliary edges: ";
347 if (!v.fAuxEdgeVisible) os << "in";
348 os << "visible";
349
350 os << "\n Representation style: ";
351 switch (v.fRepStyle) {
352 case G4ViewParameters::polyhedron:
353 os << "polyhedron"; break;
354 case G4ViewParameters::nurbs:
355 os << "nurbs"; break;
356 default: os << "unrecognised"; break;
357 }
358
359 os << "\n Culling: ";
360 if (v.fCulling) os << "on";
361 else os << "off";
362
363 os << "\n Culling invisible objects: ";
364 if (v.fCullInvisible) os << "on";
365 else os << "off";
366
367 os << "\n Density culling: ";
368 if (v.fDensityCulling) {
369 os << "on - invisible if density less than "
370 << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
371 }
372 else os << "off";
373
374 os << "\n Culling daughters covered by opaque mothers: ";
375 if (v.fCullCovered) os << "on";
376 else os << "off";
377
378 os << "\n Section flag: ";
379 if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
380 else os << "false";
381
382 if (v.IsCutaway()) {
383 os << "\n Cutaway planes: ";
384 for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
385 os << ' ' << v.fCutawayPlanes[i];
386 }
387 }
388 else {
389 os << "\n No cutaway planes";
390 }
391
392 os << "\n Explode factor: " << v.fExplodeFactor
393 << " about centre: " << v.fExplodeCentre;
394
395 os << "\n No. of sides used in circle polygon approximation: "
396 << v.fNoOfSides;
397
398 os << "\n Viewpoint direction: " << v.fViewpointDirection;
399
400 os << "\n Up vector: " << v.fUpVector;
401
402 os << "\n Field half angle: " << v.fFieldHalfAngle;
403
404 os << "\n Zoom factor: " << v.fZoomFactor;
405
406 os << "\n Scale factor: " << v.fScaleFactor;
407
408 os << "\n Current target point: " << v.fCurrentTargetPoint;
409
410 os << "\n Dolly distance: " << v.fDolly;
411
412 os << "\n Light ";
413 if (v.fLightsMoveWithCamera) os << "moves";
414 else os << "does not move";
415 os << " with camera";
416
417 os << "\n Relative lightpoint direction: "
418 << v.fRelativeLightpointDirection;
419
420 os << "\n Actual lightpoint direction: "
421 << v.fActualLightpointDirection;
422
423 os << "\n Derived parameters for standard view of object of unit radius:";
424 G4ViewParameters tempVP = v;
425 tempVP.fDolly = 0.;
426 tempVP.fZoomFactor = 1.;
427 const G4double radius = 1.;
428 const G4double cameraDistance = tempVP.GetCameraDistance (radius);
429 const G4double nearDistance =
430 tempVP.GetNearDistance (cameraDistance, radius);
431 const G4double farDistance =
432 tempVP.GetFarDistance (cameraDistance, nearDistance, radius);
433 const G4double right = tempVP.GetFrontHalfHeight (nearDistance, radius);
434 os << "\n Camera distance: " << cameraDistance;
435 os << "\n Near distance: " << nearDistance;
436 os << "\n Far distance: " << farDistance;
437 os << "\n Front half height: " << right;
438
439 os << "\n Default VisAttributes:\n " << v.fDefaultVisAttributes;
440
441 os << "\n Default TextVisAttributes:\n " << v.fDefaultTextVisAttributes;
442
443 os << "\n Default marker: " << v.fDefaultMarker;
444
445 os << "\n Global marker scale: " << v.fGlobalMarkerScale;
446
447 os << "\n Global lineWidth scale: " << v.fGlobalLineWidthScale;
448
449 os << "\n Marker ";
450 if (v.fMarkerNotHidden) os << "not ";
451 os << "hidden by surfaces.";
452
453 os << "\n Window size hint: "
454 << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
455
456 os << "\n X geometry string: " << v.fXGeometryString;
457
458 os << "\n Auto refresh: ";
459 if (v.fAutoRefresh) os << "true";
460 else os << "false";
461
462 os << "\n Background colour: " << v.fBackgroundColour;
463
464 os << "\n Picking requested: ";
465 if (v.fPicking) os << "true";
466 else os << "false";
467
468 return os;
469}
470
471G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
472
473 // Put performance-sensitive parameters first.
474 if (
475 // This first to optimise spin, etc.
476 (fViewpointDirection != v.fViewpointDirection) ||
477
478 // No particular order from here on.
479 (fDrawingStyle != v.fDrawingStyle) ||
480 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
481 (fRepStyle != v.fRepStyle) ||
482 (fCulling != v.fCulling) ||
483 (fCullInvisible != v.fCullInvisible) ||
484 (fDensityCulling != v.fDensityCulling) ||
485 (fCullCovered != v.fCullCovered) ||
486 (fSection != v.fSection) ||
487 (IsCutaway() != v.IsCutaway()) ||
488 (IsExplode() != v.IsExplode()) ||
489 (fNoOfSides != v.fNoOfSides) ||
490 (fUpVector != v.fUpVector) ||
491 (fFieldHalfAngle != v.fFieldHalfAngle) ||
492 (fZoomFactor != v.fZoomFactor) ||
493 (fScaleFactor != v.fScaleFactor) ||
494 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
495 (fDolly != v.fDolly) ||
496 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
497 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
498 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
499 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
500 (fDefaultMarker != v.fDefaultMarker) ||
501 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
502 (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
503 (fMarkerNotHidden != v.fMarkerNotHidden) ||
504 (fWindowSizeHintX != v.fWindowSizeHintX) ||
505 (fWindowSizeHintY != v.fWindowSizeHintY) ||
506 (fXGeometryString != v.fXGeometryString) ||
507 (fAutoRefresh != v.fAutoRefresh) ||
508 (fBackgroundColour != v.fBackgroundColour) ||
509 (fPicking != v.fPicking)
510 )
511 return true;
512
513 if (fDensityCulling &&
514 (fVisibleDensity != v.fVisibleDensity)) return true;
515
516 if (fSection &&
517 (!(fSectionPlane == v.fSectionPlane))) return true;
518
519 if (IsCutaway()) {
520 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
521 return true;
522 else {
523 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
524 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
525 }
526 }
527 }
528
529 if (IsExplode() &&
530 ((fExplodeFactor != v.fExplodeFactor) ||
531 (fExplodeCentre != v.fExplodeCentre))) return true;
532
533 return false;
534}
535
536
537void G4ViewParameters::SetXGeometryString (const G4String& geomStringArg) {
538
539
540 G4int x,y = 0;
541 unsigned int w,h = 0;
542 G4String geomString = geomStringArg;
543 // Parse windowSizeHintString for backwards compatibility...
544 const G4String delimiters("xX+-");
545 G4String::size_type i = geomString.find_first_of(delimiters);
546 if (i == G4String::npos) { // Does not contain "xX+-". Assume single number
547 std::istringstream iss(geomString);
548 G4int size;
549 iss >> size;
550 if (!iss) {
551 size = 600;
552 G4cout << "Unrecognised windowSizeHint string: \""
553 << geomString
554 << "\". Asuuming " << size << G4endl;
555 }
556 std::ostringstream oss;
557 oss << size << 'x' << size;
558 geomString = oss.str();
559 }
560
561 fGeometryMask = ParseGeometry( geomString, &x, &y, &w, &h );
562
563 // Handle special case :
564 if ((fGeometryMask & fYValue) == 0)
565 { // Using default
566 y = fWindowLocationHintY;
567 }
568 if ((fGeometryMask & fXValue) == 0)
569 { // Using default
570 x = fWindowLocationHintX;
571 }
572
573 // Check errors
574 // if there is no Width and Height
575 if ( ((fGeometryMask & fHeightValue) == 0 ) &&
576 ((fGeometryMask & fWidthValue) == 0 )) {
577 h = fWindowSizeHintY;
578 w = fWindowSizeHintX;
579 } else if ((fGeometryMask & fHeightValue) == 0 ) {
580
581 // if there is only Width. Special case to be backward compatible
582 // We set Width and Height the same to obtain a square windows.
583
584 G4cout << "Unrecognised geometry string \""
585 << geomString
586 << "\". No Height found. Using Width value instead"
587 << G4endl;
588 h = w;
589 }
590 if ( ((fGeometryMask & fXValue) == 0 ) ||
591 ((fGeometryMask & fYValue) == 0 )) {
592 //Using defaults
593 x = fWindowLocationHintX;
594 y = fWindowLocationHintY;
595 }
596 // Set the string
597 fXGeometryString = geomString;
598
599 // Set values
600 fWindowSizeHintX = w;
601 fWindowSizeHintY = h;
602 fWindowLocationHintX = x;
603 fWindowLocationHintY = y;
604
605 if ( ((fGeometryMask & fXValue)) &&
606 ((fGeometryMask & fYValue))) {
607
608 if ( (fGeometryMask & fXNegative) ) {
609 fWindowLocationHintXNegative = true;
610 } else {
611 fWindowLocationHintXNegative = false;
612 }
613 if ( (fGeometryMask & fYNegative) ) {
614 fWindowLocationHintYNegative = true;
615 } else {
616 fWindowLocationHintYNegative = false;
617 }
618 }
619}
620
621G4int G4ViewParameters::GetWindowAbsoluteLocationHintX (G4int sizeX ) const {
622 if ( fWindowLocationHintXNegative ) {
623 return sizeX + fWindowLocationHintX - fWindowSizeHintX;
624 }
625 return fWindowLocationHintX;
626}
627
628G4int G4ViewParameters::GetWindowAbsoluteLocationHintY (G4int sizeY ) const {
629 if ( fWindowLocationHintYNegative ) {
630 return sizeY + fWindowLocationHintY - fWindowSizeHintY;
631 }
632 return fWindowLocationHintY;
633}
634
635/* Keep from :
636 * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
637 *
638 * ParseGeometry parses strings of the form
639 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
640 * width, height, xoffset, and yoffset are unsigned integers.
641 * Example: "=80x24+300-49"
642 * The equal sign is optional.
643 * It returns a bitmask that indicates which of the four values
644 * were actually found in the string. For each value found,
645 * the corresponding argument is updated; for each value
646 * not found, the corresponding argument is left unchanged.
647 */
648
649int G4ViewParameters::ParseGeometry (
650 const char *string,
651 G4int *x,
652 G4int *y,
653 unsigned int *width,
654 unsigned int *height)
655{
656
657 G4int mask = fNoValue;
658 register char *strind;
659 unsigned int tempWidth = 0;
660 unsigned int tempHeight = 0;
661 G4int tempX = 0;
662 G4int tempY = 0;
663 char *nextCharacter;
664 if ( (string == NULL) || (*string == '\0')) {
665 return(mask);
666 }
667 if (*string == '=')
668 string++; /* ignore possible '=' at beg of geometry spec */
669 strind = (char *)string;
670 if (*strind != '+' && *strind != '-' && *strind != 'x') {
671 tempWidth = ReadInteger(strind, &nextCharacter);
672 if (strind == nextCharacter)
673 return (0);
674 strind = nextCharacter;
675 mask |= fWidthValue;
676 }
677 if (*strind == 'x' || *strind == 'X') {
678 strind++;
679 tempHeight = ReadInteger(strind, &nextCharacter);
680 if (strind == nextCharacter)
681 return (0);
682 strind = nextCharacter;
683 mask |= fHeightValue;
684 }
685
686 if ((*strind == '+') || (*strind == '-')) {
687 if (*strind == '-') {
688 strind++;
689 tempX = -ReadInteger(strind, &nextCharacter);
690 if (strind == nextCharacter)
691 return (0);
692 strind = nextCharacter;
693 mask |= fXNegative;
694
695 }
696 else
697 { strind++;
698 tempX = ReadInteger(strind, &nextCharacter);
699 if (strind == nextCharacter)
700 return(0);
701 strind = nextCharacter;
702 }
703 mask |= fXValue;
704 if ((*strind == '+') || (*strind == '-')) {
705 if (*strind == '-') {
706 strind++;
707 tempY = -ReadInteger(strind, &nextCharacter);
708 if (strind == nextCharacter)
709 return(0);
710 strind = nextCharacter;
711 mask |= fYNegative;
712 }
713 else
714 {
715 strind++;
716 tempY = ReadInteger(strind, &nextCharacter);
717 if (strind == nextCharacter)
718 return(0);
719 strind = nextCharacter;
720 }
721 mask |= fYValue;
722 }
723 }
724 /* If strind isn't at the end of the string the it's an invalid
725 geometry specification. */
726 if (*strind != '\0') return (0);
727 if (mask & fXValue)
728 *x = tempX;
729 if (mask & fYValue)
730 *y = tempY;
731 if (mask & fWidthValue)
732 *width = tempWidth;
733 if (mask & fHeightValue)
734 *height = tempHeight;
735 return (mask);
736}
737
738/* Keep from :
739 * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
740 *
741 */
742G4int G4ViewParameters::ReadInteger(char *string, char **NextString)
743{
744 register G4int Result = 0;
745 G4int Sign = 1;
746
747 if (*string == '+')
748 string++;
749 else if (*string == '-')
750 {
751 string++;
752 Sign = -1;
753 }
754 for (; (*string >= '0') && (*string <= '9'); string++)
755 {
756 Result = (Result * 10) + (*string - '0');
757 }
758 *NextString = string;
759 if (Sign >= 0)
760 return (Result);
761 else
762 return (-Result);
763}
764
Note: See TracBrowser for help on using the repository browser.