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

Last change on this file since 896 was 896, checked in by garnier, 17 years ago

Modif pour XGeometry complet. Avec debug
  • Property svn:mime-type set to text/cpp
File size: 23.4 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.31 2008/04/04 13:48:53 allison Exp $
28// GEANT4 tag $Name: HEAD $
29//
30//
31// John Allison 19th July 1996
32// View parameters and options.
33
34#include "G4ViewParameters.hh"
35
36#include "G4VisManager.hh"
37#include "G4UnitsTable.hh"
38#include "G4ios.hh"
39
40G4ViewParameters::G4ViewParameters ():
41 fNoValue(0x0000),
42 fXValue(0x0001),
43 fYValue(0x0002),
44 fWidthValue(0x0004),
45 fHeightValue(0x0008),
46 fAllValues(0x000F),
47 fXNegative(0x0010),
48 fYNegative(0x0020),
49 fDrawingStyle (wireframe),
50 fAuxEdgeVisible (false),
51 fRepStyle (polyhedron),
52 fCulling (true),
53 fCullInvisible (true),
54 fDensityCulling (false),
55 fVisibleDensity (0.01 * g / cm3),
56 fCullCovered (false),
57 fSection (false),
58 fSectionPlane (),
59 fCutawayMode (cutawayUnion),
60 fCutawayPlanes (),
61 fExplodeFactor (1.),
62 fNoOfSides (24),
63 fViewpointDirection (G4Vector3D (0., 0., 1.)), // On z-axis.
64 fUpVector (G4Vector3D (0., 1., 0.)), // y-axis up.
65 fFieldHalfAngle (0.), // Orthogonal projection.
66 fZoomFactor (1.),
67 fScaleFactor (G4Vector3D (1., 1., 1.)),
68 fCurrentTargetPoint (),
69 fDolly (0.),
70 fLightsMoveWithCamera (false),
71 fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
72 fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
73 fDefaultVisAttributes (),
74 fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
75 fDefaultMarker (),
76 fGlobalMarkerScale (1.),
77 fGlobalLineWidthScale (1.),
78 fMarkerNotHidden (true),
79 fWindowSizeHintX (600),
80 fWindowSizeHintY (600),
81 fWindowLocationHintX(0),
82 fWindowLocationHintY(0),
83 fWindowLocationHintXNegative(true),
84 fWindowLocationHintYNegative(false),
85 fAutoRefresh (false),
86 fBackgroundColour (G4Colour(0.,0.,0.)), // Black
87 fPicking (false)
88{
89#ifdef G4DEBUG
90 printf("G4ViewParameters::Create \n");
91#endif
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& geomString) {
538
539
540 G4int x,y = 0;
541 unsigned int w,h = 0;
542 G4int m = ParseGeometry( geomString, &x, &y, &w, &h );
543
544 // Check errors
545 if ( ((m & fYValue) == 0) ||
546 ((m & fXValue) == 0) ||
547 ((m & fHeightValue) == 0 ) ||
548 ((m & fWidthValue) == 0 )) {
549 G4cout << "ERROR: Unrecognised geometry string \""
550 << geomString
551 << "\". Using default"
552 << G4endl;
553 } else {
554 // Set the string
555 fXGeometryString = geomString;
556
557 // Set values
558 fWindowSizeHintX = w;
559 fWindowSizeHintY = h;
560 fWindowLocationHintX = x;
561 fWindowLocationHintY = y;
562 if ( (m & fXNegative) ) {
563 fWindowLocationHintXNegative = true;
564 } else {
565 fWindowLocationHintXNegative = false;
566 }
567 if ( (m & fYNegative) ) {
568 fWindowLocationHintYNegative = true;
569 } else {
570 fWindowLocationHintYNegative = false;
571 }
572
573 }
574
575}
576
577G4int G4ViewParameters::GetWindowAbsoluteLocationHintX (G4int sizeX ) const {
578#ifdef G4DEBUG
579 printf("G4ViewParameters::GetWindowLocationHintX () :: %d\n",fWindowLocationHintX);
580#endif
581 if ( fWindowLocationHintXNegative ) {
582 return sizeX + fWindowLocationHintX - fWindowSizeHintX;
583 }
584 return fWindowLocationHintX;
585}
586
587G4int G4ViewParameters::GetWindowAbsoluteLocationHintY (G4int sizeY ) const {
588#ifdef G4DEBUG
589 printf("G4ViewParameters::GetWindowLocationHintY () :: %d\n",fWindowLocationHintY);
590#endif
591 if ( fWindowLocationHintYNegative ) {
592 return sizeY + fWindowLocationHintY - fWindowSizeHintY;
593 }
594 return fWindowLocationHintY;
595}
596
597/* Keep from :
598 * 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
599 *
600 * ParseGeometry parses strings of the form
601 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
602 * width, height, xoffset, and yoffset are unsigned integers.
603 * Example: "=80x24+300-49"
604 * The equal sign is optional.
605 * It returns a bitmask that indicates which of the four values
606 * were actually found in the string. For each value found,
607 * the corresponding argument is updated; for each value
608 * not found, the corresponding argument is left unchanged.
609 */
610
611int G4ViewParameters::ParseGeometry (
612 const char *string,
613 G4int *x,
614 G4int *y,
615 unsigned int *width,
616 unsigned int *height)
617{
618
619 G4int mask = fNoValue;
620 register char *strind;
621 unsigned int tempWidth, tempHeight;
622 G4int tempX, tempY;
623 char *nextCharacter;
624 if ( (string == NULL) || (*string == '\0')) {
625 return(mask);
626 }
627 if (*string == '=')
628 string++; /* ignore possible '=' at beg of geometry spec */
629 strind = (char *)string;
630 if (*strind != '+' && *strind != '-' && *strind != 'x') {
631 tempWidth = ReadInteger(strind, &nextCharacter);
632 if (strind == nextCharacter)
633 return (0);
634 strind = nextCharacter;
635 mask |= fWidthValue;
636 }
637 if (*strind == 'x' || *strind == 'X') {
638 strind++;
639 tempHeight = ReadInteger(strind, &nextCharacter);
640 if (strind == nextCharacter)
641 return (0);
642 strind = nextCharacter;
643 mask |= fHeightValue;
644 }
645
646 if ((*strind == '+') || (*strind == '-')) {
647 if (*strind == '-') {
648 strind++;
649 tempX = -ReadInteger(strind, &nextCharacter);
650 if (strind == nextCharacter)
651 return (0);
652 strind = nextCharacter;
653 mask |= fXNegative;
654
655 }
656 else
657 { strind++;
658 tempX = ReadInteger(strind, &nextCharacter);
659 if (strind == nextCharacter)
660 return(0);
661 strind = nextCharacter;
662 }
663 mask |= fXValue;
664 if ((*strind == '+') || (*strind == '-')) {
665 if (*strind == '-') {
666 strind++;
667 tempY = -ReadInteger(strind, &nextCharacter);
668 if (strind == nextCharacter)
669 return(0);
670 strind = nextCharacter;
671 mask |= fYNegative;
672 }
673 else
674 {
675 strind++;
676 tempY = ReadInteger(strind, &nextCharacter);
677 if (strind == nextCharacter)
678 return(0);
679 strind = nextCharacter;
680 }
681 mask |= fYValue;
682 }
683 }
684 /* If strind isn't at the end of the string the it's an invalid
685 geometry specification. */
686 if (*strind != '\0') return (0);
687 if (mask & fXValue)
688 *x = tempX;
689 if (mask & fYValue)
690 *y = tempY;
691 if (mask & fWidthValue)
692 *width = tempWidth;
693 if (mask & fHeightValue)
694 *height = tempHeight;
695 return (mask);
696}
697
698/* Keep from :
699 * 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
700 *
701 */
702G4int G4ViewParameters::ReadInteger(char *string, char **NextString)
703{
704 register G4int Result = 0;
705 G4int Sign = 1;
706
707 if (*string == '+')
708 string++;
709 else if (*string == '-')
710 {
711 string++;
712 Sign = -1;
713 }
714 for (; (*string >= '0') && (*string <= '9'); string++)
715 {
716 Result = (Result * 10) + (*string - '0');
717 }
718 *NextString = string;
719 if (Sign >= 0)
720 return (Result);
721 else
722 return (-Result);
723}
724
Note: See TracBrowser for help on using the repository browser.