Changeset 1160 for trunk


Ignore:
Timestamp:
Nov 9, 2009, 6:57:11 PM (15 years ago)
Author:
garnier
Message:

mise en place de Vis dans UI

Location:
trunk/source/visualization/OpenGL
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/visualization/OpenGL/History

    r1141 r1160  
    1 $Id: History,v 1.158 2009/11/03 11:02:32 lgarnier Exp $
     1$Id: History,v 1.159 2009/11/03 11:18:03 allison Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1818     ----------------------------------------------------------
    1919
    20 3rd November October 2009  Laurent Garnier
     203rd November 2009  John Allison  (opengl-V09-02-09 coworks greps-V09-02-03)
     21- Tagged for system testing.
     22
     233rd November 2009  Laurent Garnier
    2124- G4OpenGLImmediateQtViewer, G4OpenGLStoredQtViewer : Protec Qt4 method
    2225  introduce 13rd october 09 by ifdef
    2326
    24 3rd November October 2009  John Allison
     273rd November 2009  John Allison
    2528- G4OpenGLXmPanningCallbacks: Fixed pView compilation problem.
    2629

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

    r1147 r1160  
    4545
    4646class G4OpenGLSceneHandler;
     47class G4UImanager;
    4748
    4849class QGLWidget;
    … …  
    121122protected:
    122123  QGLWidget* fWindow;
    123   //  QDialog* fGLWindow;
    124124  QWidget* fGLWindow;
    125125  bool hasPendingEvents();

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

    r942 r1160  
    4141#include <map>
    4242#include <vector>
    43 #include "G4Polymarker.hh"
    4443
    4544class G4OpenGLStored;
    … …  
    105104  // A proper implementation would use geometry hierarchy.
    106105  std::map <const G4VSolid*, G4int, std::less <const G4VSolid*> > fSolidMap;
    107 
    108 private:
    109   G4Polymarker fLastPolymarker ;
    110   std::vector<   std::vector< G4Polymarker> > fLastPolymarkers ;
    111   int nbDoublons;
    112106};
    113107

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

    r1049 r1160  
    202202                               XtPointer callData);
    203203 
    204   static void activate_callback (Widget w,
    205                                XtPointer clientData,
    206                                XtPointer callData);
    207  
    208204  static void actions_callback (Widget w,
    209205                                XtPointer clientData,
    … …  
    377373  G4OpenGLXmViewer (const G4OpenGLXmViewer&);
    378374  G4OpenGLXmViewer& operator = (const G4OpenGLXmViewer&);
     375 
    379376};
    380377

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

    r951 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLBitMapStore.cc,v 1.4 2007/11/15 10:14:23 allison Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLBitMapStore.cc,v 1.5 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//

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

    r951 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLFontBaseStore.cc,v 1.3 2006/06/29 21:18:56 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLFontBaseStore.cc,v 1.4 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030

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

    r1049 r1160  
    5050                     G4VGraphicsSystem::threeD)
    5151{
    52 #ifdef G4DEBUG_VIS_OGL
    53   printf("INIT G4OpenGLImmediateXm (after   G4VGraphicsSystem (,,)\n");
    54 #endif
    5552  G4OpenGLViewerMessenger::GetInstance();
    5653  G4OpenGLXmViewerMessenger::GetInstance();

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

    r1109 r1160  
    104104    NeedKernelVisit ();
    105105#ifdef G4DEBUG_VIS_OGL
    106     printf("G4OpenGLImmediateXmViewer::DrawView : change param\n");
     106  printf("G4OpenGLImmediateXmViewer::DrawView : change param\n");
    107107#endif
    108108    ProcessView ();
    109109    glFlush ();
    110    
     110
    111111    HaloingSecondPass ();
    112112

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

    r1152 r1160  
    7979#include <qdialog.h>
    8080#include <qevent.h> //include <qcontextmenuevent.h>
    81 #include <qmainwindow.h>
    82 
    83 #ifdef G4DEBUG_VIS_OGL
    84 #include "G4UImanager.hh"
    85 #include "G4UIsession.hh"
    86 #include "G4UIQt.hh"
    87 #endif
    88 
    89 // #define G4DEBUG_VIS_OGL_QTPARENT
     81
    9082
    9183//////////////////////////////////////////////////////////////////////////////
    … …  
    112104//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
    113105{
    114 
     106#ifdef G4DEBUG_VIS_OGL
     107  printf("G4OpenGLQtViewer::CreateMainWindow :: BEGIN \n");
     108#endif
    115109  if(fWindow) return; //Done.
    116110
    … …  
    118112  //  fWindow->makeCurrent();
    119113
    120   fGLWindow = getParentWidget();
    121   if (fGLWindow != NULL) {
    122 #if QT_VERSION < 0x040000
    123     glWidget->reparent(fGLWindow,0,QPoint(0,0)); 
    124 #else
    125 #ifdef G4DEBUG_VIS_OGL_QTPARENT
    126     G4UImanager* UI = G4UImanager::GetUIpointer();
    127     if(UI!=NULL) {
    128       if (glWidget->thread()) {
    129         if (((G4UIQt*)UI->GetSession())->getMainWindow()) {
    130           if (((G4UIQt*)UI->GetSession())->getMainWindow()->thread()) {
    131             if (glWidget->thread() != ((G4UIQt*)UI->GetSession())->getMainWindow()->thread()) {
    132114#ifdef G4DEBUG_VIS_OGL
    133               printf("G4OpenGLQtViewer::CreateMainWindow not in te same thread ...move to\n");
    134 #endif
    135               glWidget->moveToThread(((G4UIQt*)UI->GetSession())->getMainWindow()->thread());
    136             } else {
    137               printf("G4OpenGLQtViewer::CreateMainWindow 1\n");
    138             }
    139            
    140             glWidget->setParent(fGLWindow); 
    141           } else {
    142             printf("G4OpenGLQtViewer::CreateMainWindow 2\n");
    143           }
    144         } else {
    145           printf("G4OpenGLQtViewer::CreateMainWindow 3 UI:%d session(UIQt):%d\n",UI,((G4UIQt*)UI->GetSession()));
    146         }
    147       } else {
    148         printf("G4OpenGLQtViewer::CreateMainWindow 4\n");
    149       }
    150     }
    151 #else
    152     glWidget->setParent(fGLWindow); 
    153 #endif
    154 #endif
    155   }
    156 
    157   QHBoxLayout *mainLayout = new QHBoxLayout;
    158   mainLayout->setMargin(0);
    159   mainLayout->setSpacing(0);
    160   mainLayout->addWidget(glWidget);
    161 
    162 #if QT_VERSION < 0x040000
    163   fGLWindow->setCaption(name );
    164 #else
    165   fGLWindow->setLayout(mainLayout);
    166   fGLWindow->setWindowTitle( name);
    167 #endif
     115  printf("G4OpenGLQtViewer::CreateMainWindow :: ++++++++++++++ add new TAB %s\n",name.toStdString().c_str());
     116#endif
     117  G4Qt* interactorManager = G4Qt::getInstance ();
     118
     119  // FIXME L.Garnier 9/11/09 Has to be check !!!
     120  // Qt UI with Qt Vis
     121  // Qt UI with X Vis
     122  // X UI with Qt Vis
     123  // X UI with X Vis
     124  // Ne marche pas avec un UIBatch !! (ecran blanc)
     125
     126  // return false if G4UIQt was not launch
     127  bool res = interactorManager->AddTabVisWidget(fWindow,name);
     128 
     129  if (!res) { // we have to do a dialog
     130
     131#ifdef G4DEBUG_VIS_OGL
     132    printf("G4OpenGLQtViewer::CreateMainWindow :: get Parent ? \n");
     133#endif
     134    QWidget *myParent = getParentWidget();
     135#ifdef G4DEBUG_VIS_OGL
     136    printf("G4OpenGLQtViewer::CreateMainWindow :: getParent OK \n");
     137#endif
     138    if (myParent != NULL) {
     139#if QT_VERSION < 0x040000
     140      fWindow->reparent(myParent,0,QPoint(0,0)); 
     141#else
     142      fWindow->setParent(myParent); 
     143#endif
     144    }
     145    QHBoxLayout *mainLayout = new QHBoxLayout(fGLWindow);
     146   
     147    mainLayout->setMargin(0);
     148    mainLayout->setSpacing(0);   
     149    mainLayout->addWidget(fWindow);
     150    if (fGLWindow->inherits("QMainWindow")) {
     151#if QT_VERSION < 0x040000
     152      fGLWindow->setCaption(name );
     153#else
     154      fGLWindow->setWindowTitle( name);
     155#endif
     156    }
     157#if QT_VERSION >= 0x040000
     158    fGLWindow->setLayout(mainLayout);
     159#endif
     160  } else {
     161    fGLWindow = fWindow;
     162  }
     163 
     164 
    168165  ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
    169 
     166 
    170167  //useful for MACOSX, we have to compt the menuBar height
    171168  int offset = QApplication::desktop()->height()
    172                       - QApplication::desktop()->availableGeometry().height();
    173 
     169    - QApplication::desktop()->availableGeometry().height();
     170 
    174171  G4int YPos= fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height());
    175172  if (fVP.GetWindowAbsoluteLocationHintY(QApplication::desktop()->height())< offset) {
    … …  
    181178 
    182179  if(!fWindow) return;
    183 
     180 
    184181  if (!fContextMenu)
    185182    createPopupMenu();
    186 
     183 
     184#ifdef G4DEBUG_VIS_OGL
     185  printf("G4OpenGLQtViewer::CreateMainWindow :: END \n");
     186#endif
    187187}
    188188
    … …  
    241241
    242242#ifdef G4DEBUG_VIS_OGL
     243  G4UImanager* UI = G4UImanager::GetUIpointer();
     244  printf("G4OpenGLQtViewer::getParentWidget :: UImanager %d++++++++++++\n",UI);
     245#endif
     246
     247#ifdef G4DEBUG_VIS_OGL
    243248  printf("G4OpenGLQtViewer::G4OpenGLQtViewer END\n");
    244249#endif
    … …  
    25422547
    25432548
    2544 void G4OpenGLQtViewer::drawText(
    2545 const char * str
    2546 ,int x
    2547 ,int y
    2548 ,int z
    2549 ,int size ) {
    2550  
    2551 #ifdef G4DEBUG_VIS_OGL
    2552   printf ("G4OpenGLStoredQtViewer::drawText-position %d,%d,%d-----------------------------------------\n",x,y,z);
    2553 #endif   
    2554  
    2555   QFont f1 = QFont("Courrier", size, QFont::Bold);
    2556 #if QT_VERSION > 0x040000
    2557   f1.setPointSizeF(20);
    2558 #else
    2559   f1.setPointSizeFloat(20);
    2560 #endif
    2561  
    2562   // FIXME : Interesting border effect : resizing world resize detector
    2563   // but not traces !
    2564   glColor3d (0.123456,0.1234560,0.123456);
    2565   fWindow->renderText (x,y,z,str,f1);
    2566   glColor3d (0.321,0.321,0.321);
    2567 }
    2568  
    2569  
    25702549// FIXME : does not work on Qt3
    25712550void G4OpenGLQtViewer::processEncodeStdout()
    … …  
    26692648  // launch Qt if not
    26702649  G4Qt* interactorManager = G4Qt::getInstance ();
    2671   //  G4UImanager* UI = G4UImanager::GetUIpointer();
    2672  
    2673 
    2674 #ifdef G4DEBUG_VIS_OGL_QTPARENT
    26752650  G4UImanager* UI = G4UImanager::GetUIpointer();
    2676   if(UI!=NULL) {
    2677     if (((G4UIQt*)UI->GetSession())->getViewWidget()) {
    2678       printf("G4OpenGLQtViewer::getParentWidget ok :%d\n",((G4UIQt*)UI->GetSession())->getViewWidget());
    2679       return ((G4UIQt*)UI->GetSession())->getViewWidget();
    2680       //      fGLWindow = new QWidget(((G4UIQt*)UI->GetSession())->getViewWidget(),Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);   
    2681     } else {
    2682       return 0;
    2683     }
    2684     //    fGLWindow = new QWidget(0,Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);   
    2685   }
    2686 #else
    2687 
     2651#ifdef G4DEBUG_VIS_OGL
     2652  //  printf("G4OpenGLQtViewer::getParentWidget :: UImanager %d  G4Qt:%d et via GetUIQt:%d---------------------\n",UI,UI->GetSession(),interactorManager,interactorManager->GetUIVisWidget());
     2653#endif
     2654 
     2655  //   if (interactorManager) {
     2656  //     if (interactorManager->GetUIVisWidget()) {
     2657  //       fGLWindow = interactorManager->GetUIVisWidget();
     2658  //       return interactorManager->GetUIVisWidget();
     2659  //     }
     2660  //   }
     2661  //
    26882662
    26892663
    … …  
    27332707    return NULL;
    27342708  }
    2735 #endif
    27362709}
    27372710

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

    r1140 r1160  
    4444// Also seems to be required for HP's CC and AIX xlC, at least.
    4545
    46 
    47 #include "G4OpenGLQtViewer.hh"
    4846#include "G4OpenGLSceneHandler.hh"
    4947#include "G4OpenGLViewer.hh"
    … …  
    265263  G4int font_base = G4OpenGLFontBaseStore::GetFontBase(fpViewer,size);
    266264  if (font_base < 0) {
    267    
    268 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER
    269     G4OpenGLQtViewer* oGLSQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
    270     if (oGLSQtViewer) {
    271       // FIXME : No font for the moment
    272       const char* textCString = textString.c_str();
    273       oGLSQtViewer->drawText(textCString,position.x(),position.y(),position.z(),size);
    274     }
    275 #endif
    276265    static G4int callCount = 0;
    277266    ++callCount;
    … …  
    294283  const char* textCString = textString.c_str();
    295284  glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
    296 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER
    297   G4OpenGLQtViewer* oGLSQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
    298 
    299   if (oGLSQtViewer) {
    300     // FIXME : No font for the moment
    301     oGLSQtViewer->drawText(textCString,position.x(),position.y(),position.z(),size);
    302   }
    303 #else
    304     glDisable (GL_DEPTH_TEST);
    305     glDisable (GL_LIGHTING);
    306    
    307     glRasterPos3d(position.x(),position.y(),position.z());
    308     // No action on offset or layout at present.
    309     glPushAttrib(GL_LIST_BIT);
    310     glListBase(font_base);
    311     glCallLists(strlen(textCString), GL_UNSIGNED_BYTE, (GLubyte *)textCString);
    312     glPopAttrib();
    313 #endif
    314   //     //////////////
    315   //     makeCurrent();
    316   //     glPushAttrib(GL_LIST_BIT | GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT);
    317   //     glRasterPos3d(x, y, z);
    318   //     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    319   //     glEnable(GL_BLEND);
    320   //     glListBase(fontDisplayListBase(fnt, listBase));
    321   //     glCallLists(str.length(), GL_UNSIGNED_BYTE, str.local8Bit());
    322   //     glPopAttrib();
    323   //     //////////////
     285  glDisable (GL_DEPTH_TEST);
     286  glDisable (GL_LIGHTING);
    324287 
    325 #ifdef G4DEBUG_VIS_OGL
    326   printf ("G4OpenGLSceneHandler::AddPrimitives TEXT\n");
    327 #endif 
     288  glRasterPos3d(position.x(),position.y(),position.z());
     289  // No action on offset or layout at present.
     290   glPushAttrib(GL_LIST_BIT);
     291   glListBase(font_base);
     292   glCallLists(strlen(textCString), GL_UNSIGNED_BYTE, (GLubyte *)textCString);
     293   glPopAttrib();
    328294}
    329295

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

    r1103 r1160  
    8181fMemoryForDisplayLists (true),
    8282fAddPrimitivePreambleNestingDepth (0),
    83 fTopPODL (0),
    84 fLastPolymarker(),
    85 fLastPolymarkers(),
    86 nbDoublons(0)
     83fTopPODL (0)
    8784{}
    8885
    … …  
    195192  if (fReadyForTransients || !fMemoryForDisplayLists) {
    196193    glPopMatrix();
    197 #ifdef G4DEBUG_VIS_OGL
    198     //    printf("G4OpenGLStoredSceneHandler::AddPrimitivePostamble glFlush\n");
    199 #endif
    200194    glFlush ();
    201195    glDrawBuffer (GL_BACK);
    … …  
    213207void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
    214208{
    215 
    216 #ifdef G4DEBUG_VIS_OGL
    217   //  printf("G4OpenGLStoredSceneHandler::AddPrimitive\n");
    218 #endif
    219   std::vector< G4Polymarker > poly;
    220     // 40,83 N03 lancement
    221     // 289,69 10Gev supp doublons   + bitmap 21 frame en 10 sec
    222     // 343,45 10Gev full polymarker + bitmap 15 frame en 10 sec
    223     // 351,67 10Gev full polymarker - bitmap 31 frame en 10 sec
    224     // 257,90 10Gev supp doublons MAX  - bitmap 42 frame en 10 sec 45757 markers et 16243 enleves
    225   // Check
    226   int reste = polymarker.size();
    227   bool res = false;
    228   if (fLastPolymarkers.size() > 0 ) {
    229 
    230     // Loop new point to check
    231     for (unsigned int b=0; b< polymarker.size();b++) {
    232       //      printf("check %d/%d\n",b,polymarker.size());
    233       res= false;
    234 
    235       // Look for stored point list
    236       for (unsigned int a=0; a< fLastPolymarkers.size() ;a++) {
    237         //        printf("against vect %d/%d\n",a,fLastPolymarker.size());
    238         std::vector < G4Polymarker > storedPoly = fLastPolymarkers[a];
    239         int size= storedPoly.size()-1;
    240 
    241         // Look for point
    242         for (int aPoly=0; aPoly< size ;aPoly++) {
    243           //          printf("against poly %d/%d\n",aPoly,storedPoly.size());
    244           if (( storedPoly[size-aPoly].GetPosition().x() == polymarker[b].x()) &&
    245               ( storedPoly[size-aPoly].GetPosition().y() == polymarker[b].y()) &&
    246               ( storedPoly[size-aPoly].GetPosition().z() == polymarker[b].z())) {
    247             reste --;
    248 //            res= true;
    249             nbDoublons++;
    250             //            printf("G4OpenGLStoredSceneHandler::AddPrimitive  PT %d/%d ALREADY FOUND TOT:%d. OLD pos %d/%d in %d PolyMarkerList STILL %d Marker in list. Point is %f %f %f\n",b,polymarker.size(),  nbDoublons,  aPoly,size,a   ,reste,polymarker[b].x(),polymarker[b].y(),polymarker[b].z());
    251           }
    252         }
    253       }
    254       // Add
    255       if (!res) {
    256         G4Polymarker tmp;
    257         tmp.SetPosition(polymarker[b]);
    258         poly.push_back(tmp);
    259       }
    260     }
    261   } else {
    262     for (unsigned int b=0; b< polymarker.size();b++) {
    263       G4Polymarker tmp;
    264       tmp.SetPosition(polymarker[b]);
    265       poly.push_back(tmp);
    266     }
    267   }
    268   fLastPolymarkers.push_back(poly);
    269 #define TEST_MARKER 1
    270 #ifdef TEST_MARKER
    271   // if it is already done
    272   if (poly.size() == 1 ) {
    273     //   if (polymarker.size() >0) {
    274     //     if (( fLastPolymarker.GetPosition().x() == polymarker[0].x()) &&
    275     //         ( fLastPolymarker.GetPosition().y() == polymarker[0].y()) &&
    276     //         ( fLastPolymarker.GetPosition().z() == polymarker[0].z())) {
    277     //       if (fpViewer->GetViewParameters().IsPicking()) {
    278     //         glLoadName(++fPickName);
    279     //         fPickMap[fPickName] = 0;
    280     //       }
    281     //       printf("G4OpenGLStoredSceneHandler::AddPrimitive  SUPPR ----------- point %f %f %f\n",polymarker[0].x(),polymarker[0].y(),polymarker[0].z());
    282     const G4Colour& c = GetColour (polymarker);
    283     glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
    284     G4OpenGLSceneHandler::AddPrimitive(poly[0]);
    285     //    fLastPolymarker.SetPosition(polymarker[poly]);
    286     return;
    287   }
    288 #endif 
    289 #ifdef G4DEBUG_VIS_OGL
    290   //  printf("G4OpenGLStoredSceneHandler::AddPrimitive new marker list\n");
    291 #endif
    292209  AddPrimitivePreamble(polymarker);
    293210  G4OpenGLSceneHandler::AddPrimitive(polymarker);
    294211  AddPrimitivePostamble();
    295 //  fLastPolymarker.SetPosition(polymarker[polymarker.size()-1]);
    296212}
    297213
    … …  
    332248  // gets into the display list
    333249  AddPrimitivePreamble(polyhedron);
    334 #ifdef G4DEBUG_VIS_OGL
    335   printf("G4OpenGLStoredSceneHandler::AddPrimitive (poly?) :\n");
    336 #endif
    337250  G4OpenGLSceneHandler::AddPrimitive(polyhedron);
    338251  AddPrimitivePostamble();
    … …  
    384297void G4OpenGLStoredSceneHandler::EndModeling () {
    385298  // Make a List which calls the other lists.
    386 #ifdef G4DEBUG_VIS_OGL
    387   printf("G4OpenGLStoredSceneHandler::EndModeling Cree une nouvelle liste+++++++++++++++++++++++++++\n");
    388 #endif
    389299  fTopPODL = glGenLists (1);
    390300  if (glGetError() == GL_OUT_OF_MEMORY) {  // Could pre-allocate?
    … …  
    454364  // Make sure screen corresponds to graphical database...
    455365  if (fpViewer) {
    456 #ifdef G4DEBUG_VIS_OGL
    457     printf("G4OpenGLStoredSceneHandler::ClearTransientStore () BEGIN\n");
    458 #endif
    459366    fpViewer -> SetView ();
    460367    fpViewer -> ClearView ();
    461368    fpViewer -> DrawView ();
    462 #ifdef G4DEBUG_VIS_OGL
    463     printf("G4OpenGLStoredSceneHandler::ClearTransientStore () END\n");
    464 #endif
    465369  }
    466370}

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLStoredWin32.cc,v 1.14 2006/08/14 12:07:19 allison Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLStoredWin32.cc,v 1.15 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLStoredX.cc,v 1.14 2007/08/21 14:05:51 allison Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLStoredX.cc,v 1.15 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLTransform3D.cc,v 1.8 2006/06/29 21:19:32 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLTransform3D.cc,v 1.9 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//

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

    r1137 r1160  
    113113  glDisable (GL_POLYGON_SMOOTH);
    114114
    115 #ifdef G4DEBUG_VIS_OGL
    116   printf("G4OpenGLViewer::InitializeGLView %d %d \n",fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
    117 #endif
    118115  fWinSize_x = fVP.GetWindowSizeHintX();
    119116  fWinSize_y = fVP.GetWindowSizeHintY();

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

    r1137 r1160  
    4040
    4141#include "G4Scene.hh"
    42 #include "G4VSceneHandler.hh"
    4342#include "G4UImanager.hh"
    4443#include "G4ios.hh"
    … …  
    6564  //theta spin stuff here
    6665  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
    67   // No callback allowed when no scene
    68   if (!pView->GetSceneHandler()->GetScene()) {
    69     return;
    70   }
    7166
    7267  if (pView->rotate_right) {
    … …  
    144139                                    XtIntervalId* timer_id)
    145140{
    146 
    147141  //phi spin stuff here
    148142  //  G4double delta_alpha;
    149143  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
    150144
    151   // No callback allowed when no scene
    152   if (!pView->GetSceneHandler()->GetScene()) {
    153     return;
    154   }
    155145  if (pView -> rotate_up) {
    156146    pView->rotateScene(0,-(G4double)pView->rot_sens,1);
    … …  
    276266                                            XtIntervalId*)
    277267{
    278 
    279268  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*)clientData;
    280   // No callback allowed when no scene
    281   if (!pView->GetSceneHandler()->GetScene()) {
    282     return;
    283   }
    284269  const G4Vector3D& up = pView->fVP.GetUpVector();
    285270  G4Vector3D third_axis = up.cross(pView->original_vp);
    … …  
    316301                                     XtPointer)
    317302{
    318 
     303 
    319304  G4OpenGLXmViewer* pView;
    320305 
    … …  
    323308                 NULL);
    324309 
    325   // No callback allowed when no scene
    326   if (!pView->GetSceneHandler()->GetScene()) {
    327     return;
    328   }
    329310  pView->fVP.SetCurrentTargetPoint(G4Point3D());
    330311  pView->fVP.SetZoomFactor(1.0);

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLXmSliderBar.cc,v 1.7 2006/06/29 21:20:00 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLXmSliderBar.cc,v 1.8 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//Slider bar class. Inherits from G4OpenGLXmVWidgetComponent

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLXmVWidgetComponent.cc,v 1.5 2006/06/29 21:20:08 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLXmVWidgetComponent.cc,v 1.6 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//Base class for all Motif component widgets

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLXmVWidgetContainer.cc,v 1.5 2006/06/29 21:20:10 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLXmVWidgetContainer.cc,v 1.7 2009/03/13 09:50:03 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//Base class for all Motif container widgets

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLXmVWidgetShell.cc,v 1.5 2006/06/29 21:20:14 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLXmVWidgetShell.cc,v 1.6 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//Base class for all Motif shell widgets

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

    r1125 r1160  
    636636
    637637  win = XtWindow (glxarea);
    638  
    639   /* Change once the bit gravity of the Drawing Area; default
    640      is north west and we want forget, so that resize
    641      always generates exposure events */
    642    XSetWindowAttributes attrs;
    643    attrs.bit_gravity = ForgetGravity ;
    644    XChangeWindowAttributes(XtDisplay(glxarea), win,
    645                                CWBitGravity, &attrs);
    646638
    647639  glXMakeCurrent (dpy, win, cx);
    … …  
    649641  // This should be add AFTER glXMakeCurrent done because it will fire a resizeCallback
    650642  XtAddCallback (glxarea,
    651                  XmNresizeCallback,
    652                  resize_callback,
    653                  this);
    654  
     643                 XmNresizeCallback,
     644                 resize_callback,
     645                 this);
     646
    655647  XtAddCallback (glxarea,
    656648                 XmNexposeCallback,
    657649                 expose_callback,
    658                  this);
    659 
    660   XtAddCallback (glxarea,
    661                  XmNactivateCallback,
    662                  activate_callback,
    663650                 this);
    664651

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

    r1049 r1160  
    2525//
    2626//
    27 // $Id: G4OpenGLXmViewerMessenger.cc,v 1.4 2006/06/29 21:20:18 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4OpenGLXmViewerMessenger.cc,v 1.5 2009/01/19 16:53:42 lgarnier Exp $
     28// GEANT4 tag $Name: $
    2929
    3030#ifdef G4VIS_BUILD_OPENGLXM_DRIVER

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

    r1137 r1160  
    3535
    3636#ifdef G4VIS_BUILD_OPENGLXM_DRIVER
    37 #define RESIZE_TEST
     37
    3838#include "G4OpenGLXmViewer.hh"
     39
     40void G4OpenGLXmViewer::resize_callback (Widget w,
     41                                      XtPointer clientData,
     42                                      XtPointer x)
     43{
     44  expose_callback(w,clientData,x);
     45}
    3946
    4047
    4148
    42 // L. Garnier 20 May 2009
    43 // Each resize event send 2-3-4 expose events. Sequence on MacOsX 10.5 is :
    44 // - Expose(s) callback for pixels top/left from resize button
    45 // - Resize callback
    46 // - Expose for main part of content
    47 // - Expose(s) for new part of content
    48 //
    49 // BUT we want to redraw things only ONE time.
    50 // First expose is send with size=="before resize" size and x,y !=0
    51 // and  x+dw!=w || y+dh !=h
    52 void G4OpenGLXmViewer::resize_callback (Widget w,
     49void G4OpenGLXmViewer::expose_callback (Widget w,
    5350                                      XtPointer clientData,
    54                                       XtPointer callData)
     51                                      XtPointer)
    5552{
    56 #ifdef G4DEBUG_VIS_OGL
    57   printf("G4OpenGLXmViewer::resize_callback \n");
    58 #endif
    59   XmDrawingAreaCallbackStruct *data = (XmDrawingAreaCallbackStruct *)callData;
    60 
    61   XEvent                       event;
    62 
    63   // flush others resize events
    64 #ifdef G4DEBUG_VIS_OGL
    65   while (XCheckWindowEvent(XtDisplay(w), data->window,
    66                            ResizeRedirectMask, &event)) {
    67     printf("G4OpenGLXmViewer::resize_callback ------ next RESIZE !\n");
    68   }
    69 #endif
    70 #ifdef RESIZE_TEST
    7153  G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
    7254  Dimension width, height;
    … …  
    7658                 XmNheight, &height,
    7759                 NULL);
     60
    7861  pView->ResizeWindow(width,height);
    79 #endif
    80 }
    8162
     63  glXMakeCurrent (pView->dpy, XtWindow(pView->glxarea), pView->cx);
    8264
    83 void G4OpenGLXmViewer::activate_callback (Widget,
    84                                       XtPointer,
    85                                       XtPointer)
    86 {
    87 #ifdef G4DEBUG_VIS_OGL
    88   printf("G4OpenGLXmViewer::activate_callback \n");
    89 #endif
    90 }
    91 
    92 void G4OpenGLXmViewer::expose_callback (Widget w,
    93                                       XtPointer clientData,
    94                                       XtPointer callData)
    95 {
    96   /* ensure last expose event in sequence */
    97 #ifdef G4DEBUG_VIS_OGL
    98   printf("G4OpenGLXmViewer::expose_callback ?\n");
    99 #endif
    100   XmDrawingAreaCallbackStruct *data = (XmDrawingAreaCallbackStruct *)callData;
    101 
    102   XEvent                       event;
    103 
    104   Dimension width, height;
    105   G4OpenGLXmViewer* pView = (G4OpenGLXmViewer*) clientData;
    106 
    107   XtVaGetValues (w,
    108                  XmNwidth, &width,
    109                  XmNheight, &height,
    110                  NULL);
    111  
    112   XSetWindowAttributes xswa;
    113   xswa.bit_gravity = ForgetGravity ;
    114   XChangeWindowAttributes(XtDisplay(w), XtWindow(w),
    115                           CWBitGravity, &xswa);
    116  
    117     // look for next
    118     //    while (XCheckTypedWindowEvent(XtDisplay(w), XtWindow(w), ResizeRequest, &event)) {
    119     //    printf("G4OpenGLXmViewer::expose_callback --- event type :%d\n",event.type);
    120     //    printf("G4OpenGLXmViewer::expose_callback --- resize %d\n",event.type);
    121     //  }
    122    
    123   // Several expose events are send for each area to be redraw.
    124   // Because we want to optimise redrawing, we only need to redraw once.
    125     if (((XExposeEvent *) data->event)->count != 0) {
    126 #ifdef G4DEBUG_VIS_OGL
    127       printf("G4OpenGLXmViewer::expose_callback NOOOOO %d %d type:%d number:%d send:%lud x:%d y:%d w:%d h:%d c:%d\n",width,height,
    128            ((XExposeEvent *) data->event)->type,
    129            ((XExposeEvent *) data->event)->serial,
    130            ((XExposeEvent *) data->event)->send_event,
    131            ((XExposeEvent *) data->event)->x,
    132            ((XExposeEvent *) data->event)->y,
    133            ((XExposeEvent *) data->event)->width,
    134            ((XExposeEvent *) data->event)->height,
    135            ((XExposeEvent *) data->event)->count);
    136 
    137 
    138 #endif
    139       return;
    140     }
    141 #ifdef G4DEBUG_VIS_OGL
    142     printf("G4OpenGLXmViewer::expose_callback Should redraw %d %d type:%d number:%d send:%lud x:%d y:%d w:%d h:%d c:%d\n",width,height,
    143            ((XExposeEvent *) data->event)->type,
    144            ((XExposeEvent *) data->event)->serial,
    145            ((XExposeEvent *) data->event)->send_event,
    146            ((XExposeEvent *) data->event)->x,
    147            ((XExposeEvent *) data->event)->y,
    148            ((XExposeEvent *) data->event)->width,
    149            ((XExposeEvent *) data->event)->height,
    150            ((XExposeEvent *) data->event)->count);
    151 #endif
    152    
    153 #ifdef G4DEBUG_VIS_OGL
    154     while (XCheckMaskEvent(XtDisplay(w), ResizeRedirectMask, &event)) {
    155       //       printf("G4OpenGLXmViewer::expose_callback ------ next EXPOSE ! %d\n");
    156       //     }
    157       //     while (XCheckWindowEvent(XtDisplay(w), data->window,
    158       //                              ResizeRedirectMask, &event)) {
    159       printf("G4OpenGLXmViewer::expose_callback ------ next RESIZE ! \n");
    160     }
    161 #endif
    162  
    163 #ifdef RESIZE_TEST
    164     glXMakeCurrent (pView->dpy, XtWindow(pView->glxarea), pView->cx);
    165 #ifdef G4DEBUG_VIS_OGL
    166   G4cout << "G4OpenGLXmViewer::expose_callback" << G4endl;
    167   printf("G4OpenGLXmViewer::expose_callback Call SetView()\n");
    168 #endif
    16965  pView->SetView ();
    170 #ifdef G4DEBUG_VIS_OGL
    171   printf("G4OpenGLXmViewer::expose_callback Call SetView() END \n");
    172   printf("G4OpenGLXmViewer::expose_callback Call ClearView() \n");
    173 #endif
    17466  pView->ClearView ();
    175 #ifdef G4DEBUG_VIS_OGL
    176   printf("G4OpenGLXmViewer::expose_callback Call ClearView() END \n");
    177   printf("G4OpenGLXmViewer::expose_callback Call DrawView() \n");
    178 #endif
    17967  pView->DrawView ();
    180 #ifdef G4DEBUG_VIS_OGL
    181   printf("G4OpenGLXmViewer::expose_callback Call DrawView() END \n");
    182   G4cout << "G4OpenGLXmViewer::expose_callback END" << G4endl;
    183 #endif
    184 #endif
    185   return;
    186    
    187  
    18868}
    18969
Note: See TracChangeset for help on using the changeset viewer.