Changeset 896


Ignore:
Timestamp:
Dec 3, 2008, 5:31:19 PM (16 years ago)
Author:
garnier
Message:

Modif pour XGeometry complet. Avec debug

Location:
trunk/source/visualization
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/visualization/OpenGL/include/G4OpenGLImmediateQtViewer.hh

    r877 r896  
    5252public:
    5353  G4OpenGLImmediateQtViewer (G4OpenGLImmediateSceneHandler& scene,
    54                                 const G4String& name = "");
     54                             const G4String& name = "",
     55                             G4int x=200,
     56                             G4int y=200,
     57                             unsigned int w=600,
     58                             unsigned int h=600);
    5559  ~G4OpenGLImmediateQtViewer ();
    5660  void Initialise ();

  • trunk/source/visualization/OpenGL/src/G4OpenGLImmediateQt.cc

    r873 r896  
    4747                     G4VGraphicsSystem::threeD)
    4848{
     49#ifdef G4DEBUG
     50  printf("G4OpenGLImmediateQt::Create \n");
     51#endif
    4952  G4OpenGLViewerMessenger::GetInstance();
    5053}

  • trunk/source/visualization/OpenGL/src/G4OpenGLImmediateQtViewer.cc

    r877 r896  
    4040G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer
    4141(G4OpenGLImmediateSceneHandler& sceneHandler,
    42  const G4String&  name):
     42 const G4String&  name
     43,G4int x
     44,G4int y
     45,unsigned int w
     46,unsigned int h):
    4347  G4VViewer (sceneHandler, sceneHandler.IncrementViewCount (), name),
    4448  G4OpenGLViewer (sceneHandler),
    … …  
    4953  //set true to picking
    5054  fVP.SetPicking(true);
     55  fDefaultVP.SetPicking(true);
    5156#if QT_VERSION < 0x040000
    5257  setFocusPolicy(QWidget::StrongFocus); // enable keybord events

  • trunk/source/visualization/OpenGL/src/G4OpenGLImmediateX.cc

    r850 r896  
    4949{
    5050  G4OpenGLViewerMessenger::GetInstance();
     51#ifdef G4DEBUG
     52  printf("G4OpenGLImmediateX::Create \n");
     53#endif
    5154}
    5255

  • trunk/source/visualization/OpenGL/src/G4OpenGLXViewer.cc

    r893 r896  
    258258#endif
    259259
    260   size_hints->width = fVP.GetWindowSizeHintX();
    261   size_hints->height = fVP.GetWindowSizeHintY();
    262   size_hints->flags |= PSize;
     260
     261  Window root_return;
     262  int x_return, y_return;
     263  unsigned int width_return, height_return;
     264  unsigned int border_width_return;
     265  unsigned int depth_return;
     266 
     267#ifdef G4DEBUG
     268  printf("G4OpenGLXViewer::CreateMainWindow 1\n");
     269#endif
     270  // get the parent window's geometry
     271  XGetGeometry(dpy, XRootWindow (dpy, vi -> screen), &root_return, &x_return, &y_return,
     272               &width_return, &height_return, &border_width_return,
     273               &depth_return);
     274 
     275#ifdef G4DEBUG
     276  printf("G4OpenGLXViewer::CreateMainWindow 2 root W :%d H :%d\n",width_return, height_return);
     277#endif
    263278
    264279  //  G4int                             WinSize_x;
    … …  
    266281  WinSize_x = fVP.GetWindowSizeHintX();
    267282  WinSize_y = fVP.GetWindowSizeHintY();
    268   x_origin = fVP.GetWindowLocationHintX();
    269   y_origin = fVP.GetWindowLocationHintY();
    270 
     283  x_origin = fVP.GetWindowAbsoluteLocationHintX(width_return);
     284  y_origin = fVP.GetWindowAbsoluteLocationHintY(height_return);
     285
     286  size_hints->base_width = WinSize_x;
     287  size_hints->base_height = WinSize_y;
     288  size_hints->x = x_origin;
     289  size_hints->y = y_origin;
     290  size_hints->flags |= PSize | PPosition;
    271291#ifdef G4DEBUG
    272292  printf("G4OpenGLXViewer::CreateMainWindow CreateWindow Size:W:%d H:%d X:%d Y:%d \n",WinSize_x,WinSize_y,x_origin,y_origin);
    … …  
    292312  class_hints -> res_class = NewString("G4OpenGL");
    293313
    294   win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin,
    295                        y_origin, WinSize_x, WinSize_y, 0, vi -> depth,
    296                        InputOutput, vi -> visual, 
    297                        CWBorderPixel | CWColormap |
    298                        CWEventMask | CWBackingStore,
    299                        &swa);
    300  
    301   XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0,
    302                     size_hints, wm_hints, class_hints);
     314   win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin,
     315                        y_origin, WinSize_x, WinSize_y, 0, vi -> depth,
     316                        InputOutput, vi -> visual, 
     317                        CWBorderPixel | CWColormap |
     318                        CWEventMask | CWBackingStore,
     319                        &swa);
     320 
     321   XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0,
     322                     size_hints, wm_hints, class_hints);
    303323 
    304324// request X to Draw window on screen.

  • trunk/source/visualization/management/include/G4ViewParameters.hh

    r893 r896  
    154154        G4double         GetGlobalLineWidthScale () const;
    155155        G4bool           IsMarkerNotHidden       () const;
     156        G4int            GetWindowAbsoluteLocationHintX (G4int) const;
     157        G4int            GetWindowAbsoluteLocationHintY (G4int) const;
    156158        G4int            GetWindowSizeHintX      () const;
    157159        G4int            GetWindowSizeHintY      () const;
    … …  
    233235
    234236private:
     237  G4int ParseGeometry ( const char *string, G4int *x, G4int *y, unsigned int *width, unsigned int *height);
     238  G4int ReadInteger(char *string, char **NextString);
     239
     240  G4int fNoValue;
     241  G4int fXValue; // XValue set for XGeometry
     242  G4int fYValue; // YValue set for XGeometry
     243  G4int fWidthValue; // WidthValue set for XGeometry
     244  G4int fHeightValue; // HeightValue set for XGeometry
     245  G4int fAllValues; // AllValues are set for XGeometry
     246  G4int fXNegative; // XValue is from left for XGeometry
     247  G4int fYNegative; // YValue is from top for XGeometry
    235248
    236249  DrawingStyle fDrawingStyle;    // Drawing style.
    … …  
    275288  G4int        fWindowLocationHintX; // Location hints for pixel-based window systems.
    276289  G4int        fWindowLocationHintY;
     290  G4bool       fWindowLocationHintXNegative; //  Reference of location hints for pixel-based window systems.
     291  G4bool       fWindowLocationHintYNegative;
    277292  G4String     fXGeometryString; // If non-null, geometry string for X Windows.
    278293  G4bool       fAutoRefresh;     // ...after change of view parameters.

  • trunk/source/visualization/management/include/G4ViewParameters.icc

    r893 r896  
    350350}
    351351
    352 inline void G4ViewParameters::SetXGeometryString (const G4String& geomString) {
    353   fXGeometryString = geomString;
    354 }
    355 
    356352inline void G4ViewParameters::SetAutoRefresh (G4bool state) {
    357353  fAutoRefresh = state;

  • trunk/source/visualization/management/include/G4VisCommandsViewer.hh

    r891 r896  
    138138  G4VisCommandViewerCreate (const G4VisCommandViewerCreate&);
    139139  G4VisCommandViewerCreate& operator = (const G4VisCommandViewerCreate&);
    140   int ParseGeometry ( const char *string, int *x, int *y, unsigned int *width, unsigned int *height);
    141   int ReadInteger(char *string, char **NextString);
    142140  G4String NextName ();
    143141  G4UIcommand* fpCommand;
    144142  G4int fId;
    145   int NoValue;
    146   int XValue;
    147   int YValue;
    148   int WidthValue;
    149   int HeightValue;
    150   int AllValues;
    151   int XNegative;
    152   int YNegative;
    153143};
    154144

  • trunk/source/visualization/management/include/G4VisManager.hh

    r893 r896  
    313313  // Creates scene handler for the current system.
    314314
    315   void CreateViewer  (G4String name = "");
     315  void CreateViewer  (G4String name = "",G4String XGeometry = "");
    316316  // Creates viewer for the current scene handler.
    317317

  • trunk/source/visualization/management/include/G4VisManager.icc

    r894 r896  
    7373}
    7474
    75 inline void G4VisManager::GetWindowSizeHint
    76  (G4int& xHint, G4int& yHint) const {
    77   xHint = fWindowSizeHintX; yHint = fWindowSizeHintY;
    78 }
    79 
    80 inline void G4VisManager::GetWindowLocationHint
    81  (G4int& xHint, G4int& yHint) const {
    82   xHint = fpViewer->GetViewParameters().GetWindowLocationHintX();
    83   yHint = fpViewer->GetViewParameters().GetWindowLocationHintY();
    84 }
    85 
    86 inline const G4String& G4VisManager::GetXGeometryString () const {
    87   return fXGeometryString;
    88 }
    8975
    9076inline G4bool G4VisManager::GetTransientsDrawnThisEvent() const {
    … …  
    120106}
    121107
    122 inline void G4VisManager::SetWindowSizeHint (G4int xHint, G4int yHint) {
    123   fWindowSizeHintX = xHint; fWindowSizeHintY = yHint;
    124 }
    125 
    126 inline void G4VisManager::SetWindowLocationHint (G4int xHint, G4int yHint) {
    127 #ifdef G4DEBUG
    128         printf("G4VisManager::SetWindowLocationHint () :: %d %d\n",xHint,yHint);
    129 #endif
    130   G4ViewParameters vp = fpViewer->GetViewParameters();
    131   vp.SetWindowLocationHint(xHint,yHint);
    132 #ifdef G4DEBUG
    133         printf("G4VisManager::SetViewParameteres location ()\n");
    134 #endif
    135   fpViewer->SetViewParameters(vp);
    136 }
    137 
    138 inline void G4VisManager::SetXGeometryString (const G4String& geomString) {
    139   fXGeometryString = geomString;
    140 }
    141 
    142108inline void G4VisManager::SetEventRefreshing (G4bool eventRefreshing) {
    143109  fEventRefreshing = eventRefreshing;

  • trunk/source/visualization/management/src/G4VViewer.cc

    r894 r896  
    6161  fShortName = fName (0, fName.find (' '));
    6262  fShortName.strip ();
    63 
    64   G4VisManager* pVisMan = G4VisManager::GetInstance();
    65   G4int xHint, yHint;
    66   pVisMan->GetWindowSizeHint(xHint, yHint);
    67   const G4String& XGeometryString = pVisMan->GetXGeometryString();
    68 #ifdef G4DEBUG
    69     printf("G4VViewer::G4VViewer set geometry of viewer\n");
    70 #endif
    71   fVP.SetWindowSizeHint(xHint,yHint);
    72   fVP.SetXGeometryString(XGeometryString);
    73   fDefaultVP.SetWindowSizeHint(xHint,yHint);
    74   fDefaultVP.SetXGeometryString(XGeometryString);
    7563}
    7664

  • trunk/source/visualization/management/src/G4ViewParameters.cc

    r850 r896  
    3939
    4040G4ViewParameters::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),
    4149  fDrawingStyle (wireframe),
    4250  fAuxEdgeVisible (false),
    … …  
    7179  fWindowSizeHintX (600),
    7280  fWindowSizeHintY (600),
     81  fWindowLocationHintX(0),
     82  fWindowLocationHintY(0),
     83  fWindowLocationHintXNegative(true),
     84  fWindowLocationHintYNegative(false),
    7385  fAutoRefresh (false),
    7486  fBackgroundColour (G4Colour(0.,0.,0.)),         // Black
    7587  fPicking (false)
    7688{
     89#ifdef G4DEBUG
     90  printf("G4ViewParameters::Create \n");
     91#endif
    7792  fDefaultMarker.SetScreenSize (5.);
    7893  // Markers are 5 pixels "overall" size, i.e., diameter.
    … …  
    518533  return false;
    519534}
     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   

  • trunk/source/visualization/management/src/G4VisCommandsViewer.cc

    r894 r896  
    489489
    490490G4VisCommandViewerCreate::G4VisCommandViewerCreate ():
    491   fId (0),
    492   NoValue(0x0000),
    493   XValue(0x0001),
    494   YValue(0x0002),
    495   WidthValue(0x0004),
    496   HeightValue(0x0008),
    497   AllValues(0x000F),
    498   XNegative(0x0010),
    499   YNegative(0x0020) {
     491  fId (0)
     492 {
    500493  G4bool omitable;
    501494  fpCommand = new G4UIcommand ("/vis/viewer/create", this);
    … …  
    689682  // the vis manager until the viewer is contructed - next line...
    690683
    691   ////////
    692 
    693   int x,y = 0;
    694   unsigned int w,h = 0;
    695 
    696   int m = ParseGeometry( windowSizeHintString, &x, &y, &w, &h );
    697   //  QSize minSize = main_widget->minimumSize();
    698   //  QSize maxSize = main_widget->maximumSize();
    699   if ( ((m & YValue) == 0) ||
    700        ((m & XValue) == 0) ||
    701        ((m & HeightValue) == 0 ) ||
    702        ((m & WidthValue)  == 0 )) {
    703     if (verbosity >= G4VisManager::errors) {
    704       G4cout << "ERROR: Unrecognised geometry string \""
    705              << windowSizeHintString
    706              << "\".  Using 100 for X and Y location."
    707              << "\".  Using 600 for Width and Height."
    708              << G4endl;
    709     }
    710     x = 100;
    711     y = 100;
    712     w = 600;
    713     h = 600;
    714   }
    715 
    716 #ifdef G4DEBUG
    717   printf  ("Lecture X:%d Y:%d W:%d H:%d\n",x,y,w,h);
    718 #endif
    719 
    720 
    721 
    722   // Create viewer.
    723   fpVisManager -> CreateViewer (newName);
    724 
    725   // set parameters BEFORE
    726   fpVisManager->SetWindowSizeHint (w,h);
    727   fpVisManager->SetWindowLocationHint (x,y);
    728   fpVisManager->SetXGeometryString(windowSizeHintString);
     684  fpVisManager -> CreateViewer (newName,windowSizeHintString);
    729685
    730686  G4VViewer* newViewer = fpVisManager -> GetCurrentViewer ();
    … …  
    15731529}
    15741530
    1575 /* Keep from :
    1576  * 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
    1577  *
    1578  *    ParseGeometry parses strings of the form
    1579  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
    1580  *   width, height, xoffset, and yoffset are unsigned integers.
    1581  *   Example:  "=80x24+300-49"
    1582  *   The equal sign is optional.
    1583  *   It returns a bitmask that indicates which of the four values
    1584  *   were actually found in the string. For each value found,
    1585  *   the corresponding argument is updated;  for each value
    1586  *   not found, the corresponding argument is left unchanged.
    1587  */
    1588 
    1589 
    1590 int G4VisCommandViewerCreate::ParseGeometry (
    1591  const char *string,
    1592  int *x,
    1593  int *y,
    1594  unsigned int *width,
    1595  unsigned int *height)
    1596 {
    1597 
    1598   int mask = NoValue;
    1599   register char *strind;
    1600   unsigned int tempWidth, tempHeight;
    1601   int tempX, tempY;
    1602   char *nextCharacter;
    1603   if ( (string == NULL) || (*string == '\0')) {
    1604     return(mask);
    1605   }
    1606   if (*string == '=')
    1607     string++;  /* ignore possible '=' at beg of geometry spec */
    1608   strind = (char *)string;
    1609   if (*strind != '+' && *strind != '-' && *strind != 'x') {
    1610     tempWidth = ReadInteger(strind, &nextCharacter);
    1611     if (strind == nextCharacter)
    1612       return (0);
    1613     strind = nextCharacter;
    1614     mask |= WidthValue;
    1615   }
    1616   if (*strind == 'x' || *strind == 'X') {
    1617     strind++;
    1618     tempHeight = ReadInteger(strind, &nextCharacter);
    1619     if (strind == nextCharacter)
    1620       return (0);
    1621     strind = nextCharacter;
    1622     mask |= HeightValue;
    1623   }
    1624 
    1625   if ((*strind == '+') || (*strind == '-')) {
    1626     if (*strind == '-') {
    1627       strind++;
    1628       tempX = -ReadInteger(strind, &nextCharacter);
    1629       if (strind == nextCharacter)
    1630         return (0);
    1631       strind = nextCharacter;
    1632       mask |= XNegative;
    1633 
    1634     }
    1635     else
    1636       { strind++;
    1637         tempX = ReadInteger(strind, &nextCharacter);
    1638         if (strind == nextCharacter)
    1639           return(0);
    1640         strind = nextCharacter;
    1641       }
    1642     mask |= XValue;
    1643     if ((*strind == '+') || (*strind == '-')) {
    1644       if (*strind == '-') {
    1645         strind++;
    1646         tempY = -ReadInteger(strind, &nextCharacter);
    1647         if (strind == nextCharacter)
    1648           return(0);
    1649         strind = nextCharacter;
    1650         mask |= YNegative;
    1651       }
    1652       else
    1653         {
    1654           strind++;
    1655           tempY = ReadInteger(strind, &nextCharacter);
    1656           if (strind == nextCharacter)
    1657             return(0);
    1658           strind = nextCharacter;
    1659         }
    1660       mask |= YValue;
    1661     }
    1662   }
    1663   /* If strind isn't at the end of the string the it's an invalid
    1664      geometry specification. */
    1665   if (*strind != '\0') return (0);
    1666   if (mask & XValue)
    1667     *x = tempX;
    1668   if (mask & YValue)
    1669     *y = tempY;
    1670   if (mask & WidthValue)
    1671     *width = tempWidth;
    1672   if (mask & HeightValue)
    1673     *height = tempHeight;
    1674   return (mask);
    1675 }
    1676 
    1677 /* Keep from :
    1678  * 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
    1679  *
    1680  */
    1681 int G4VisCommandViewerCreate::ReadInteger(char *string, char **NextString)
    1682 {
    1683     register int Result = 0;
    1684     int Sign = 1;
    1685 
    1686     if (*string == '+')
    1687         string++;
    1688     else if (*string == '-')
    1689     {
    1690         string++;
    1691         Sign = -1;
    1692     }
    1693     for (; (*string >= '0') && (*string <= '9'); string++)
    1694     {
    1695         Result = (Result * 10) + (*string - '0');
    1696     }
    1697     *NextString = string;
    1698     if (Sign >= 0)
    1699         return (Result);
    1700     else
    1701         return (-Result);
    1702 }
     1531

  • trunk/source/visualization/management/src/G4VisManager.cc

    r894 r896  
    651651}
    652652
    653 void G4VisManager::CreateViewer (G4String name) {
     653void G4VisManager::CreateViewer (G4String name,G4String XGeometry) {
    654654#ifdef G4DEBUG
    655655  printf("G4VisManager::CreateViewer TOP\n");
    … …  
    667667    G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
    668668#ifdef G4DEBUG
     669
     670    // Viewer is created, now we can set geometry parameters
     671    // Before 12/2008, it was done in G4VViewer.cc but it did not have to be there!
     672
     673    G4ViewParameters vp = p->GetViewParameters();
     674    vp.SetXGeometryString(XGeometry);
     675    p->SetViewParameters(vp);
     676
    669677    printf("G4VisManager::CreateViewer 4\n");
    670678#endif
Note: See TracChangeset for help on using the changeset viewer.