Changeset 678


Ignore:
Timestamp:
Jan 11, 2008, 3:44:33 PM (16 years ago)
Author:
garnier
Message:

modifs de test pour rubberband et mise en place du button mouse zoom

Location:
trunk/geant4/visualization/OpenGL
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r673 r678  
    103103  QMenu *fContextMenu;
    104104#endif
    105   bool fMouseAction; // 1: rotate 0:move
     105  enum mouseActions {ROTATE, MOVE, ZOOM};
     106  mouseActions fMouseAction; // 1: rotate 0:move
    106107  QPoint lastPos;
    107108#if QT_VERSION < 0x040000
     109  QPopupMenu *fMouseRotate;
     110  QPopupMenu *fMouseMove;
     111  QPopupMenu *fMouseZoom;
    108112  QPopupMenu *fDrawingWireframe;
    109113  QPopupMenu *fDrawingLineRemoval;
    … …  
    111115  QPopupMenu *fDrawingLineSurfaceRemoval;
    112116#else
     117  QAction *fMouseRotate;
     118  QAction *fMouseMove;
     119  QAction *fMouseZoom;
    113120  QAction *fDrawingWireframe;
    114121  QAction *fDrawingLineRemoval;
    … …  
    118125
    119126private slots :
     127  void actionMouseRotate();
     128  void actionMouseMove();
     129  void actionMouseZoom();
    120130  void actionDrawingWireframe();
    121131  void actionDrawingLineRemoval();
    … …  
    127137
    128138  void toggleDrawingAction(int);
    129   void toggleMouseAction(bool);
     139  void toggleMouseAction(mouseActions);
    130140  void toggleRepresentation(bool);
    131141  void toggleBackground(bool);

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

    r675 r678  
    124124  printf("G4OpenGLQtViewer::ShowView  +++++++++++++++++++++\n");
    125125#endif
    126   glFlush ();
    127126  if (!GLWindow) {
    128127    G4cerr << "Visualization window not defined, please choose one before\n" << G4endl;
    … …  
    137136#endif
    138137  }
     138  glFlush ();
    139139  //   // Empty the Windows message queue :
    140140  //   MSG event;
    … …  
    285285  ,fWindow(0)
    286286  ,fContextMenu(0)
    287   ,fMouseAction(true)
     287  ,fMouseAction(ROTATE)
    288288{
    289289#ifdef GEANT4_QT_DEBUG
    … …  
    314314  fContextMenu = new QMenu("All");
    315315#endif
    316   Q_CHECK_PTR( fContextMenu );
     316
     317#if QT_VERSION < 0x040000
     318  QPopupMenu *mMouseAction = new QPopupMenu( fContextMenu );
     319  fContextMenu->insertItem("&Mouse actions");
     320#else
     321  QMenu *mMouseAction = fContextMenu->addMenu("&Mouse actions");
     322#endif
    317323
    318324#if QT_VERSION < 0x040000
    319325  // === Mouse menu ===
    320   QPopupMenu *mMouseAction = new QPopupMenu( fContextMenu );
    321   Q_CHECK_PTR( mMouseAction );
    322 
    323 #if QT_VERSION < 0x030200
    324   QAction *rotate = new QAction("&Rotate scene","&Rotate scene",CTRL+Key_N,mMouseAction);
    325   QAction *move =  new QAction("&Move scene","&Move scene",CTRL+Key_M,mMouseAction);
    326 #else
    327   QAction *rotate = new QAction("&Rotate scene",CTRL+Key_N,mMouseAction);
    328   QAction *move =  new QAction("&Move scene",CTRL+Key_M,mMouseAction);
    329 #endif
    330   rotate->addTo(mMouseAction);
    331   move->addTo(mMouseAction);
    332 
    333   fContextMenu->insertItem( "&Mouse action", mMouseAction);
     326
     327  fMouseRotate = new QPopupMenu(mMouseAction);
     328  mMouseAction->insertItem("&Rotate",fMouseRotate);
     329
     330  mMouseAction->setCheckable(true);
     331  fMouseRotate->setCheckable(true);
     332
     333  fMouseMove = new QPopupMenu(mMouseAction);
     334  mMouseAction->insertItem("&Move",fMouseMove);
     335  fMouseMove->setCheckable(true);
     336
     337  fMouseZoom = new QPopupMenu(mMouseAction);
     338  mMouseAction->insertItem("&Zoom",fMouseZoom);
     339  fMouseZoom->setCheckable(true);
    334340
    335341#else
    336342  // === Mouse menu ===
    337   QMenu *mMouseAction = fContextMenu->addMenu("&Mouse action");
    338 
    339   QAction *rotate = mMouseAction->addAction("&Rotate scene");
    340   QAction *move = mMouseAction->addAction("&Move scene");
     343
     344  fMouseRotate = mMouseAction->addAction("Rotate");
     345  fMouseRotate->setCheckable(true);
     346
     347  fMouseMove = mMouseAction->addAction("Move");
     348  fMouseMove->setCheckable(true);
     349
     350  fMouseZoom = mMouseAction->addAction("Zoom");
     351  fMouseZoom->setCheckable(true);
    341352#endif
    342353
    343354  // INIT mMouse
    344   createRadioAction(rotate,move,SLOT(toggleMouseAction(bool)),1);
     355#if QT_VERSION < 0x040000
     356  fMouseRotate->setItemCheckeded(0,true);
     357
     358  QObject ::connect(fMouseRotate,
     359                    SIGNAL(activated(int)),
     360                    this,
     361                    SLOT(actionMouseRotate()));
     362
     363  QObject ::connect(fMouseMove,
     364                    SIGNAL(activated(int)),
     365                    this,
     366                    SLOT(actionMouseMove()));
     367
     368  QObject ::connect(fMouseZoom,
     369                    SIGNAL(activated(int)),
     370                    this,
     371                    SLOT(actionMouseZoom()));
     372
     373#else
     374  fMouseRotate->setChecked(true);
     375
     376  QObject ::connect(fMouseRotate,
     377                    SIGNAL(triggered(bool)),
     378                    this,
     379                    SLOT(actionMouseRotate()));
     380
     381  QObject ::connect(fMouseMove,
     382                    SIGNAL(triggered(bool)),
     383                    this,
     384                    SLOT(actionMouseMove()));
     385
     386  QObject ::connect(fMouseZoom,
     387                    SIGNAL(triggered(bool)),
     388                    this,
     389                    SLOT(actionMouseZoom()));
     390#endif
    345391
    346392#if QT_VERSION < 0x040000
    … …  
    775821
    776822/**
     823   Slot activate when mouseAction->rotate menu is set
     824 */
     825void G4OpenGLQtViewer::actionMouseRotate() {
     826  emit toggleMouseAction(ROTATE);
     827}
     828
     829/**
     830   Slot activate when mouseAction->move menu is set
     831 */
     832void G4OpenGLQtViewer::actionMouseMove() {
     833  emit toggleMouseAction(MOVE);
     834}
     835
     836/**
     837   Slot activate when mouseAction->zoom menu is set
     838 */
     839void G4OpenGLQtViewer::actionMouseZoom() {
     840#ifdef GEANT4_QT_DEBUG
     841  printf("G4OpenGLQtViewer::actionMouseZoom \n");
     842#endif
     843  emit toggleMouseAction(ZOOM);
     844}
     845
     846/**
    777847   Slot activate when drawing->wireframe menu is set
    778848 */
    … …  
    803873
    804874
     875/**
     876   Slot activated when mouse action is toggle
     877   @param aAction : ROTATE, MOVE, ZOOM
     878 */
     879void G4OpenGLQtViewer::toggleMouseAction(mouseActions aAction) {
     880 
     881
     882#ifdef GEANT4_QT_DEBUG
     883  printf("G4OpenGLQtViewer::toggleMouseAction **** \n");
     884#endif
     885  if (aAction == ROTATE) {
     886#ifdef GEANT4_QT_DEBUG
     887  printf("G4OpenGLQtViewer::toggleMouseAction ROTATE \n");
     888#endif
     889#if QT_VERSION < 0x040000
     890    fMouseRotate->setItemChecked (0,true);
     891    fMouseMove->setItemChecked (0,false);
     892    fMouseZoom->setItemChecked (0,false);
     893#else
     894    fMouseRotate->setChecked (true);
     895    fMouseMove->setChecked (false);
     896    fMouseZoom->setChecked (false);
     897#endif
     898    fMouseAction = ROTATE;
     899  } else  if (aAction == MOVE) {
     900#ifdef GEANT4_QT_DEBUG
     901  printf("G4OpenGLQtViewer::toggleMouseAction MOVE \n");
     902#endif
     903#if QT_VERSION < 0x040000
     904    fMouseRotate->setItemChecked (0,false);
     905    fMouseMove->setItemChecked (0,true);
     906    fMouseZoom->setItemChecked (0,false);
     907#else
     908    fMouseRotate->setChecked (false);
     909    fMouseMove->setChecked (true);
     910    fMouseZoom->setChecked (false);
     911#endif
     912    fMouseAction = MOVE;
     913  } else  if (aAction == ZOOM) {
     914#ifdef GEANT4_QT_DEBUG
     915  printf("G4OpenGLQtViewer::toggleMouseAction ZOOM \n");
     916#endif
     917#if QT_VERSION < 0x040000
     918    fMouseRotate->setItemChecked (0,false);
     919    fMouseMove->setItemChecked (0,false);
     920    fMouseZoom->setItemChecked (0,true);
     921#else
     922    fMouseRotate->setChecked (false);
     923    fMouseMove->setChecked (false);
     924    fMouseZoom->setChecked (true);
     925#endif
     926    fMouseAction = ZOOM;
     927  }
     928
     929#ifdef GEANT4_QT_DEBUG
     930  printf("G4OpenGLQtViewer::toggleMouseAction\n");
     931#endif
     932}
    805933/**
    806934   Slot activated when drawing menu is toggle
    … …  
    10221150  G4cerr << "This version of G4UI Could not generate the selected format\n" << G4endl;
    10231151#endif
    1024 #ifdef GEANT4_QT_DEBUG
    1025   printf("G4OpenGLQtViewer::toggleRepresentation %d\n",check);
    1026 #endif
    1027 }
    1028 
    1029 /**
    1030    SLOT Activate by a click on the mouse action menu
    1031    @param check : 1 , 0
    1032 */
    1033 void G4OpenGLQtViewer::toggleMouseAction(bool check) {
    1034   if (check) { // rotate scene
    1035     fMouseAction = true;
    1036   } else { // move scene
    1037     fMouseAction = false;
    1038   }
    1039 
    10401152#ifdef GEANT4_QT_DEBUG
    10411153  printf("G4OpenGLQtViewer::toggleRepresentation %d\n",check);
    … …  
    12221334  int dx = pos_x - lastPos.x();
    12231335  int dy = pos_y - lastPos.y();
    1224   if (fMouseAction) {  // rotate
     1336  if (fMouseAction == ROTATE) {  // rotate
    12251337    if (mButtons & Qt::LeftButton) {
    12261338      //phi spin stuff here
    … …  
    12811393      //       updateQWidget();
    12821394    }
    1283   } else {  // move
    1284 
     1395  } else   if (fMouseAction == MOVE){  // move
     1396     
    12851397    float dx = pos_x - lastPos.x();
    12861398    float dy = pos_y - lastPos.y();
    … …  
    13011413   
    13021414    updateQWidget();
     1415  } else   if (fMouseAction == ZOOM){  // zoom
     1416    if (mButtons & Qt::LeftButton) {
     1417      Pick(pos_x,pos_y);
     1418      G4cerr << "Zoom not implemented for the moment\n" << G4endl;
     1419    }
     1420  } else   if (fMouseAction == MOVE){  // pick
     1421    if (mButtons & Qt::LeftButton) {
     1422      Pick(pos_x,pos_y);
     1423    }
    13031424  }
    13041425  lastPos = QPoint(pos_x, pos_y);

  • trunk/geant4/visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc

    r677 r678  
    5454 QGLWidget(QGLFormat(QGL::SampleBuffers))             // FIXME : gerer le pb du parent !
    5555 {
    56    zoomAction = false;
    5756   nbPaint =0;
    5857   hasToRepaint =false;
    … …  
    257256void G4OpenGLStoredQtViewer::paintGL()
    258257 {
    259    if (zoomAction) {
    260      glEnable (GL_DEPTH_TEST);
    261      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    262 
    263      setupViewport(width(),height());     
    264      SetView();
    265      ClearView (); //ok, put the background correct
    266 
    267      QPainter painter;
    268      painter.begin(this);
    269      //      painter.setCompositionMode(QPainter::CompositionMode_DestinationOver);
    270      //      painter.setCompositionMode(QPainter::CompositionMode_SourceOver); // diagonale en pointillé
    271      //     painter.setCompositionMode(QPainter::CompositionMode_DestinationOver); // blanc
    272      //     painter.setCompositionMode(QPainter::CompositionMode_Clear);// diagonale noire
    273      //     painter.setCompositionMode(QPainter::CompositionMode_Source); // diagonale en pointillé
    274      //     painter.setCompositionMode(QPainter::CompositionMode_Destination); // blanc
    275      //     painter.setCompositionMode(QPainter::CompositionMode_SourceIn); // blanc ?
    276      //     painter.setCompositionMode(QPainter::CompositionMode_DestinationIn); // blanc
    277      //     painter.setCompositionMode(QPainter::CompositionMode_SourceOut); // digonale noire
    278      //     painter.setCompositionMode(QPainter::CompositionMode_DestinationOut); // diagonale noire
    279      //     painter.setCompositionMode(QPainter::CompositionMode_SourceAtop); // diagonale noire
    280      //     painter.setCompositionMode(QPainter::CompositionMode_DestinationAtop); // blanc
    281      //     painter.setCompositionMode(QPainter::CompositionMode_Xor); // diagonale noire
    282      //     painter.setRenderHint(QPainter::Antialiasing);
    283      //         painter.setBackgroundMode(Qt::OpaqueMode);
    284      //          painter.drawImage(0, 0, glBufferImage);
    285      
    286      //     painter.setRenderHint(QPainter::Antialiasing);
    287      //      QColor bg = QColor(glBufferImage.pixel(0,0));
    288      //      printf("%d+%d+%d+%d %d+%d+%d+%d",bg.red(),bg.green(),bg.blue(),bg.alpha(),qAlpha(glBufferImage.pixel(0,0)),qRed(glBufferImage.pixel(0,0)),qGreen(glBufferImage.pixel(0,0)),qBlue(glBufferImage.pixel(0,0)));
    289      //      painter.setBackground(QBrush(bg));
    290      //      //     painter.drawRect(10,10,50,80);
    291      // //      QImage test = grabFrameBuffer().copy();
    292      // //      painter.drawImage(0, 0,test);
    293      for (int ay=0;ay<glBufferImage.height();ay++) {
    294        for (int ax=0;ax<glBufferImage.width();ax++) {
    295          //         if(QColor(glBufferImage.pixel(ax,ay)) != bg) {
    296          //.           painter.setPen(QColor(glBufferImage.pixel(ax,ay)));
    297          //.           painter.drawPoint(ax,ay);
    298            //          } else {
    299            //            printf("o");
    300            //          }
    301          //          printf("%d+%d+%d+%d ",QColor(glBufferImage.pixel(ax,ay)).red(),QColor(glBufferImage.pixel(ax,ay)).green(),QColor(glBufferImage.pixel(ax,ay)).blue(),QColor(glBufferImage.pixel(ax,ay)).alpha());
    302          //          if (glBufferImage.pixel(ax,ay) == 255) {
    303          //            test.setPixel(ax,ay,1);
    304          //          } else {
    305          //            test.setPixel(ax,ay,0);
    306          //          }
    307        }
    308        //       printf("\n");
    309      }
    310      // //      for (int ay=0;ay<test.height();ay++) {
    311      // //        for (int ax=0;ax<test.width();ax++) {
    312      // //          if (test.pixel(ax,ay) == 1) {
    313      // //            printf(".");
    314      // //          } else if (!test.pixel(ax,ay)) {
    315      // //            printf("X");
    316      // //          } else {
    317      // //            printf("%d",test.pixel(ax,ay));
    318      // //          }
    319      // //        }
    320      // //        printf("\n");
    321      // //      }
    322      
    323      //     painter.drawImage(0, 0, glBufferImage);
    324      //     painter.drawImage(0, 0, test,0,0,-1,-1,Qt::ColorOnly);
    325      
    326 #ifdef GEANT4_QT_DEBUG
    327        printf("G4OpenGLStoredQtViewer::paintGL ============  zoom event\n");
    328 #endif
    329        painter.setBrush(Qt::NoBrush);
    330        painter.setPen(Qt::red);
    331        painter.setPen(Qt::DashLine);
    332        painter.drawRect(beginZoom.x(),beginZoom.y(),endZoom.x()-beginZoom.x(),endZoom.y()-beginZoom.y());
    333      painter.end();
    334    } else {
    335258     
    336259     if (!readyToPaint) {
    … …  
    376299     hasToRepaint =false;
    377300     
    378    }
    379301#ifdef GEANT4_QT_DEBUG
    380302     printf("G4OpenGLStoredQtViewer::paintGL ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ %d ready %d\n",nbPaint,readyToPaint);
    … …  
    391313}
    392314
     315/**
     316 * This function was build in order to make a zoom on double clic event.
     317 * It was think to build a rubberband on the zoom area, but never work fine
     318 */
    393319void G4OpenGLStoredQtViewer::mouseDoubleClickEvent(QMouseEvent *event)
    394320{
    … …  
    396322  printf("G4OpenGLStoredQtViewer::mouseDoubleClickEvent\n");
    397323#endif
    398   setMouseTracking(true);
    399   zoomAction=true;
    400   //  makeCurrent();
    401 //   glBufferImage = QImage( width(), height(), QImage::Format_ARGB32_Premultiplied );
    402 //   glReadPixels( 0, 0, width(), height(), GL_RGBA, GL_UNSIGNED_BYTE, glBufferImage.bits() );
    403   glBufferImage = grabFrameBuffer().convertToFormat(QImage::Format_ARGB32);//_Premultiplied);
    404   QImage acha( glBufferImage.size(), QImage::Format_RGB32 );
    405   acha.fill( Qt::black );
    406   glBufferImage.setAlphaChannel( acha );
    407  
    408 #ifdef GEANT4_QT_DEBUG
    409 //   for (int ay=0;ay<glBufferImage.height();ay++) {
    410 //     for (int ax=0;ax<glBufferImage.width();ax++) {
    411 //       if (glBufferImage.pixel(ax,ay) == 255) {
    412 //         printf(".");
    413 //       } else if (!glBufferImage.pixel(ax,ay)) {
    414 //         printf("X");
    415 //       } else {
    416 //         printf("%d",glBufferImage.pixel(ax,ay));
    417 //       }
    418 //     }
    419 //     printf("\n");
    420 //   }
    421 #endif
    422   beginZoom.setX(event->x());
    423   beginZoom.setY(event->y());
     324//   setMouseTracking(true);
     325//   glBufferImage = grabFrameBuffer().convertToFormat(QImage::Format_ARGB32);//_Premultiplied); 
    424326}
    425327
    … …  
    429331  printf("G4OpenGLStoredQtViewer::mouseReleaseEvent\n");
    430332#endif
    431   setMouseTracking(false);
    432   zoomAction =false;
     333//   setMouseTracking(false);
    433334}
    434335
    435336void G4OpenGLStoredQtViewer::mouseMoveEvent(QMouseEvent *event)
    436337{
    437   // special case of mouse zoom action, it should draw a rect on
    438   // the openGL buffer, so it could only be done in this class
    439   // and sould be reimplemented in G4OpenGLImmediateQtViewer
    440   if (!zoomAction) {
     338
    441339#if QT_VERSION < 0x040000
    442340    G4MouseMoveEvent(event->x(),event->y(),event->state());
    … …  
    444342    G4MouseMoveEvent(event->x(),event->y(),event->buttons());
    445343#endif
    446   } else {
    447 #ifdef GEANT4_QT_DEBUG
    448     printf("G4OpenGLStoredQtViewer::mouseMoveEvent zoom\n");
    449 #endif
    450     endZoom.setX(event->x());
    451     endZoom.setY(event->y());
    452     updateGL();
    453   }
    454   //  DrawView();
    455344}
    456345

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

    r632 r678  
    313313void G4OpenGLViewer::Pick(GLdouble x, GLdouble y)
    314314{
     315  printf("G4OpenGLViewer::Pick\n");
    315316  //G4cout << "X: " << x << ", Y: " << y << G4endl;
    316317  const G4int BUFSIZE = 512;
Note: See TracChangeset for help on using the changeset viewer.