src/CurveCreator/CurveCreator_Widget.cxx

   1 // Copyright (C) 2013-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "CurveCreator_Widget.h"
  21 #include "CurveCreator_TreeView.h"
  22 #include "CurveCreator_ICurve.hxx"
  23 #include "CurveCreator.hxx"
  24 #include "CurveCreator_NewSectionDlg.h"
  25 #include "CurveCreator_Utils.hxx"
  26 #include "CurveCreator_UtilsICurve.hxx"
  27 #include "CurveCreator_TableView.h"
  28
  29 #include <SUIT_Session.h>
  30 #include <SUIT_Desktop.h>
  31 #include <SUIT_ResourceMgr.h>
  32 #include <SUIT_ViewManager.h>
  33
  34 #include <OCCViewer_ViewManager.h>
  35 #include <OCCViewer_ViewPort3d.h>
  36 #include <OCCViewer_Utilities.h>
  37
  38 #include <QHBoxLayout>
  39 #include <QVBoxLayout>
  40 #include <QLabel>
  41 #include <QLineEdit>
  42 #include <QGroupBox>
  43 #include <QToolButton>
  44 #include <QToolBar>
  45 #include <QAction>
  46 #include <QMenu>
  47 #include <QMouseEvent>
  48 #include <QApplication>
  49 #include <QTableWidget>
  50 #include <QTime>
  51
  52 //#define MEASURE_TIME
  53
  54 #ifdef MEASURE_TIME
  55
  56   #define START_MEASURE_TIME \
  57     QTime aTimer;            \
  58     aTimer.start();          \
  59
  60   #define END_MEASURE_TIME( theMsg )                      \
  61     double aTime = aTimer.elapsed() * 0.001;              \
  62     FILE* aFile = fopen( "performance", "a" );            \
  63     fprintf( aFile, "%s = %.3lf sec\n", theMsg, aTime );  \
  64     fclose( aFile );                                      \
  65
  66 #else
  67
  68   #define START_MEASURE_TIME
  69   #define END_MEASURE_TIME( theMsg )
  70
  71 #endif
  72
  73
  74
  75
  76
  77
  78 CurveCreator_Widget::CurveCreator_Widget(QWidget* parent,
  79                                          CurveCreator_ICurve *theCurve,
  80                                          const int theActionFlags,
  81                                          const QStringList& theCoordTitles,
  82                                          Qt::WindowFlags fl,
  83                                          int theLocalPointRowLimit )
  84 : QWidget(parent), myNewSectionEditor(NULL), myCurve(theCurve), mySection(0),
  85   myDragStarted( false ), myDragInteractionStyle( SUIT_ViewModel::STANDARD ),
  86   myOCCViewer( 0 ), myLocalPointRowLimit( theLocalPointRowLimit ),
  87   myOld2DMode(OCCViewer_ViewWindow::No2dMode)
  88 {
  89   bool isToEnableClosed = !( theActionFlags & DisableClosedSection );
  90   myNewSectionEditor = new CurveCreator_NewSectionDlg( this, isToEnableClosed );
  91   myNewSectionEditor->hide();
  92   connect( myNewSectionEditor, SIGNAL(addSection()), this, SLOT(onAddNewSection()) );
  93   connect( myNewSectionEditor, SIGNAL(modifySection()), this, SLOT(onModifySection()) );
  94   connect( myNewSectionEditor, SIGNAL(cancelSection()), this, SLOT(onCancelSection()) );
  95
  96   QGroupBox* aSectionGroup = new QGroupBox(tr("SECTION_GROUP_TITLE"),this);
  97
  98   mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup);
  99   mySectionView->setSelectionMode( QTreeView::ExtendedSelection );
 100   connect( mySectionView, SIGNAL(selectionChanged()), this, SLOT( onSelectionChanged() ) );
 101   connect( mySectionView, SIGNAL(sectionEntered(int)), this, SLOT(onEditSection(int)) );
 102   connect( mySectionView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onContextMenu(QPoint)) );
 103
 104   myLocalPointView = new CurveCreator_TableView( myCurve, this, theCoordTitles );
 105   connect( myLocalPointView, SIGNAL( cellChanged( int, int ) ),
 106            this, SLOT( onCellChanged( int, int ) ) );
 107
 108   QToolBar* aTB = new QToolBar(tr("SECTION_GROUP_TITLE"), aSectionGroup);
 109 //    QToolButton* anUndoBtn = new QToolButton(aTB);
 110
 111   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
 112   QPixmap anUndoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_UNDO")));
 113   QPixmap aRedoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_REDO")));
 114   QPixmap aNewSectionPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_SECTION")));
 115   QPixmap aNewPointPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_POINT")));
 116   QPixmap anEditPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
 117   QPixmap aDetectPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
 118   QPixmap aPolylinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
 119   QPixmap aSplinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
 120   QPixmap aRemovePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_DELETE")));
 121   QPixmap aJoinPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_JOIN")));
 122   QPixmap aStepUpPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_UP")));
 123   QPixmap aStepDownPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_DOWN")));
 124
 125   QAction* anAct = createAction( UNDO_ID, tr("UNDO"), anUndoPixmap, tr("UNDO_TLT"),
 126                                  QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
 127   connect(anAct, SIGNAL(triggered()), this, SLOT(onUndo()) );
 128   aTB->addAction(anAct);
 129
 130   anAct = createAction( REDO_ID, tr("REDO"), aRedoPixmap, tr("REDO_TLT"),
 131                         QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
 132   connect(anAct, SIGNAL(triggered()), this, SLOT(onRedo()) );
 133   aTB->addAction(anAct);
 134
 135   aTB->addSeparator();
 136
 137   anAct = createAction( NEW_SECTION_ID, tr("NEW_SECTION"), aNewSectionPixmap, tr("NEW_SECTION_TLT"),
 138                         QKeySequence(Qt::ControlModifier|Qt::Key_N) );
 139   connect(anAct, SIGNAL(triggered()), this, SLOT(onNewSection()) );
 140   if ( !(theActionFlags & DisableNewSection) ) {
 141     aTB->addAction(anAct);
 142     aTB->addSeparator();
 143   }
 144
 145   anAct = createAction( ADDITION_MODE_ID, tr("ADDITION_MODE"), aNewPointPixmap, tr("ADDITION_MODE_TLT"),
 146                         QKeySequence() );
 147   anAct->setCheckable(true);
 148   connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onAdditionMode(bool)) );
 149   connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
 150   aTB->addAction(anAct);
 151
 152   anAct = createAction( MODIFICATION_MODE_ID, tr("MODIFICATION_MODE"), anEditPointsPixmap, tr("MODIFICATION_MODE_TLT"),
 153                         QKeySequence() );
 154   anAct->setCheckable(true);
 155   connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onModificationMode(bool)) );
 156   connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
 157   aTB->addAction(anAct);
 158
 159   anAct = createAction( DETECTION_MODE_ID, tr("DETECTION_MODE"), aDetectPointsPixmap, tr("DETECTION_MODE_TLT"),
 160                         QKeySequence() );
 161   anAct->setCheckable(true);
 162   connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onDetectionMode(bool)) );
 163   connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
 164   if ( !(theActionFlags & DisableDetectionMode) ) {
 165     aTB->addAction(anAct);
 166   }
 167
 168   anAct = createAction( CLOSE_SECTIONS_ID, tr("CLOSE_SECTIONS"), QPixmap(), tr("CLOSE_SECTIONS_TLT"),
 169                         QKeySequence(Qt::ControlModifier|Qt::Key_W) );
 170   connect(anAct, SIGNAL(triggered()), this, SLOT(onCloseSections()) );
 171
 172   anAct = createAction( UNCLOSE_SECTIONS_ID, tr("UNCLOSE_SECTIONS"), QPixmap(),
 173                         tr("UNCLOSE_SECTIONS_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_S) );
 174   connect(anAct, SIGNAL(triggered()), this, SLOT(onUncloseSections()) );
 175
 176   anAct = createAction( SET_SECTIONS_POLYLINE_ID, tr("SET_SECTIONS_POLYLINE"),
 177                         aPolylinePixmap, tr("SET_SECTIONS_POLYLINE_TLT"),
 178                         QKeySequence(Qt::ControlModifier|Qt::Key_E) );
 179   connect(anAct, SIGNAL(triggered()), this, SLOT(onSetPolyline()) );
 180
 181   anAct = createAction( SET_SECTIONS_SPLINE_ID, tr("SET_SECTIONS_SPLINE"), aSplinePixmap,
 182                         tr("SET_SECTIONS_SPLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_R) );
 183   connect(anAct, SIGNAL(triggered()), this, SLOT(onSetSpline()) );
 184
 185   anAct = createAction( REMOVE_ID, tr("REMOVE"), aRemovePixmap, tr("REMOVE_TLT"),
 186                         QKeySequence(Qt::ControlModifier|Qt::Key_Delete ) );
 187   connect(anAct, SIGNAL(triggered()), this, SLOT(onRemove()) );
 188   aTB->addAction(anAct);
 189
 190   aTB->addSeparator();
 191
 192   anAct = createAction( JOIN_ID, tr("JOIN"), aJoinPixmap, tr("JOIN_TLT"),
 193                         QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
 194   connect( anAct, SIGNAL(triggered()), this, SLOT(onJoin()) );
 195   aTB->addAction(anAct);
 196
 197   anAct = createAction( CLEAR_ALL_ID, tr("CLEAR_ALL"), QPixmap(), tr("CLEAR_ALL_TLT"),
 198                         QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Delete ) );
 199   connect( anAct, SIGNAL(triggered()), this, SLOT( onClearAll()) );
 200
 201   anAct = createAction( JOIN_ALL_ID, tr("JOIN_ALL"), QPixmap(), tr("JOIN_ALL_TLT"),
 202                         QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Plus ) );
 203   connect( anAct, SIGNAL(triggered()), this, SLOT(onJoinAll()) );
 204
 205   QVBoxLayout* aSectLayout = new QVBoxLayout();
 206   aSectLayout->setMargin( 5 );
 207   aSectLayout->setSpacing( 5 );
 208   aSectLayout->addWidget(aTB);
 209   aSectLayout->addWidget(mySectionView);
 210   aSectLayout->addWidget( myLocalPointView );
 211   aSectionGroup->setLayout(aSectLayout);
 212   QVBoxLayout* aLay = new QVBoxLayout();
 213   aLay->setMargin( 0 );
 214   aLay->setSpacing( 5 );
 215 //    aLay->addLayout(aNameLayout);
 216   aLay->addWidget(aSectionGroup);
 217   setLayout(aLay);
 218
 219   updateActionsStates();
 220   updateUndoRedo();
 221 }
 222
 223 /**
 224  * Set an OCC viewer
 225  */
 226 void CurveCreator_Widget::setOCCViewer( OCCViewer_Viewer* theViewer )
 227 {
 228   if ( myOCCViewer == theViewer )
 229     return;
 230
 231   if ( myOCCViewer ) {
 232     OCCViewer_ViewManager* aViewManager = dynamic_cast<OCCViewer_ViewManager*>
 233                                                     ( myOCCViewer->getViewManager() );
 234     disconnect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
 235            this, SLOT( onMousePress( SUIT_ViewWindow*, QMouseEvent* ) ) );
 236     disconnect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
 237            this, SLOT( onMouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ) );
 238     disconnect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
 239            this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) );
 240     disconnect( aViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
 241            this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
 242     // restore normal mode in the viewer
 243     SetViewer2DMode(false);
 244     // all local contexts should be closed if the viewer is not more used
 245     setLocalPointContext( false, true );
 246   }
 247
 248   myOCCViewer = theViewer;
 249   if ( myOCCViewer ) {
 250     OCCViewer_ViewManager* aViewManager = dynamic_cast<OCCViewer_ViewManager*>
 251                                                     ( myOCCViewer->getViewManager() );
 252     connect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
 253            this, SLOT( onMousePress( SUIT_ViewWindow*, QMouseEvent* ) ) );
 254     connect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
 255            this, SLOT( onMouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ) );
 256     connect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
 257            this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) );
 258     connect( aViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
 259            this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
 260     SetViewer2DMode(true);
 261   }
 262 }
 263
 264 /**
 265  * Returns current OCC viewer
 266  */
 267 OCCViewer_Viewer* CurveCreator_Widget::getOCCViewer()
 268 {
 269   return myOCCViewer;
 270 }
 271
 272 /**
 273  * Returns OCC viewer context
 274  */
 275 Handle(AIS_InteractiveContext) CurveCreator_Widget::getAISContext()
 276 {
 277   Handle(AIS_InteractiveContext) aContext;
 278   OCCViewer_Viewer* aViewer = getOCCViewer();
 279   if ( aViewer )
 280     aContext = aViewer->getAISContext();
 281
 282   return aContext;
 283 }
 284
 285 /**
 286  * Returns OCC viewer view port
 287  */
 288 OCCViewer_ViewPort3d* CurveCreator_Widget::getViewPort()
 289 {
 290   OCCViewer_ViewPort3d* aViewPort = 0;
 291   OCCViewer_Viewer* aViewer = getOCCViewer();
 292   if ( aViewer )
 293     aViewPort = ((OCCViewer_ViewWindow*)aViewer->getViewManager()->getActiveView())->getViewPort();
 294
 295   return aViewPort;
 296 }
 297
 298 /**
 299  * Set interaction style in the OCC viewer
 300  * \param theStyle a new style
 301  * \return the previous style
 302  */
 303 int CurveCreator_Widget::changeInteractionStyle( int theStyle )
 304 {
 305   OCCViewer_Viewer* aViewer = getOCCViewer();
 306   if ( !aViewer )
 307     return -1;
 308
 309   int aPrevStyle = aViewer->interactionStyle();
 310   aViewer->setInteractionStyle( theStyle );
 311
 312   return aPrevStyle;
 313 }
 314
 315 //=======================================================================
 316 // function: reset
 317 // purpose: reset the widget viewer, close local context, clear selection
 318 //=======================================================================
 319 void CurveCreator_Widget::reset()
 320 {
 321   stopActionMode();
 322 }
 323
 324 void CurveCreator_Widget::setCurve( CurveCreator_ICurve* theCurve )
 325 {
 326   myCurve = theCurve;
 327   mySectionView->setCurve( myCurve );
 328   myLocalPointView->setCurve( myCurve );
 329   updateActionsStates();
 330   updateUndoRedo();
 331 }
 332
 333 void CurveCreator_Widget::onSelectionChanged()
 334 {
 335   updateActionsStates();
 336   updateUndoRedo();
 337   emit selectionChanged();
 338 }
 339
 340 void CurveCreator_Widget::updateActionsStates()
 341 {
 342   QList<ActionId> anEnabledAct;
 343   if( myCurve ){
 344     anEnabledAct << NEW_SECTION_ID << MODIFICATION_MODE_ID;
 345     if ( removeEnabled() )
 346       anEnabledAct << REMOVE_ID;
 347     QList<int> aSelSections = mySectionView->getSelectedSections();
 348     CurveCreator_TreeView::SelectionType aSelType = mySectionView->getSelectionType();
 349     switch( aSelType ){
 350     case CurveCreator_TreeView::ST_NOSEL:{
 351       break;
 352     }
 353     case CurveCreator_TreeView::ST_SECTIONS:{
 354       /*if( aSelSections[0] > 0 ){
 355         anEnabledAct << UP_ID;
 356       }*/
 357       if( aSelSections.size() == 1 ){
 358         anEnabledAct << ADDITION_MODE_ID << DETECTION_MODE_ID;
 359       }
 360       switch ( getActionMode() ) {
 361         case AdditionMode: {
 362           mySection = -1;
 363           myPointNum = -1;
 364           QList<int> aSelSection = mySectionView->getSelectedSections();
 365           if( aSelSection.size() > 0 ){
 366             mySection = aSelSection[0];
 367             myPointNum = myCurve->getNbPoints(mySection);
 368           }
 369         }
 370         break;
 371         case ModificationMode: {
 372           if ( myNewSectionEditor->isEnableClosed() )
 373             anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID;
 374           anEnabledAct << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
 375           int aSectCnt = myCurve->getNbSections();
 376           if( aSectCnt > 0 )
 377             anEnabledAct << CLEAR_ALL_ID;
 378           if( aSectCnt > 1 )
 379             anEnabledAct << JOIN_ALL_ID;
 380           if( aSelSections.size() > 1 ){
 381             anEnabledAct << JOIN_ID;
 382           }
 383         }
 384         break;
 385         case DetectionMode: {
 386         }
 387         break;
 388         case NoneMode:
 389           {
 390             int aSectCnt = myCurve->getNbSections();
 391             if( aSectCnt > 1 )
 392               anEnabledAct << JOIN_ALL_ID;
 393             if( aSelSections.size() > 1 )
 394               anEnabledAct << JOIN_ID;
 395           }
 396           break;
 397         default:
 398         break;
 399       }
 400       /*if( aSelSections[ aSelSections.size() - 1 ] < ( myCurve->getNbSections() - 1 ) ){
 401         anEnabledAct << DOWN_ID;
 402       }*/
 403       break;
 404     }
 405     /*case CurveCreator_TreeView::ST_POINTS_ONE_SECTION:{
 406       if( aSelPoints[0].second > 0 ){
 407         anEnabledAct << UP_ID;
 408       }
 409       int aLastIndex = aSelPoints.size()-1;
 410       int aSect = aSelPoints[0].first;
 411       if( aSelPoints[aLastIndex].second < (myCurve->getNbPoints(aSect) - 1)){
 412         anEnabledAct << DOWN_ID;
 413       }
 414       if( aSelPoints.size() == 1){
 415         anEnabledAct << INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
 416       }
 417       break;
 418     }*/
 419
 420     }
 421
 422     /*int aSelObjsCnt = aSelPoints.size() + aSelSections.size();
 423     if( aSelObjsCnt > 0 ){
 424       anEnabledAct << REMOVE_ID;
 425     }
 426     if( (myCurve->getNbSections() + myCurve->getNbPoints()) > 0 ){
 427       anEnabledAct << REMOVE_ALL_ID;
 428     }*/
 429     if( myCurve->getNbSections() > 1 ){
 430       anEnabledAct << JOIN_ALL_ID;
 431     }
 432   }
 433   QList<ActionId> anIds = myActionMap.keys();
 434   for( int i = 0 ; i < anIds.size() ; i++ ){
 435     if( myActionMap.contains(anIds[i]) ){
 436       if( anEnabledAct.contains(anIds[i]) ){
 437         myActionMap[anIds[i]]->setEnabled(true);
 438       }
 439       else{
 440         myActionMap[anIds[i]]->setEnabled(false);
 441       }
 442     }
 443   }
 444 }
 445
 446 void CurveCreator_Widget::onAdditionMode(bool checked)
 447 {
 448   if (!checked)
 449     return;
 450
 451   Handle(AIS_InteractiveContext) aContext = getAISContext();
 452   if( !myCurve || aContext.IsNull() )
 453     return;
 454
 455   mySection= -1;
 456   myPointNum = -1;
 457   QList<int> aSelSection = mySectionView->getSelectedSections();
 458   if( aSelSection.size() > 0 ){
 459     mySection = aSelSection[0];
 460   }
 461 //  emit subOperationStarted( myNewPointEditor );
 462 }
 463
 464 void CurveCreator_Widget::onModificationMode(bool checked)
 465 {
 466   myLocalPointView->setVisible( checked );
 467 }
 468
 469 void CurveCreator_Widget::onDetectionMode(bool checked)
 470 {
 471 }
 472
 473 void CurveCreator_Widget::onModeChanged(bool checked)
 474 {
 475   ActionMode aMode = NoneMode;
 476   if (checked) {
 477     QAction* anAction = (QAction*)sender();
 478     switch(myActionMap.key(anAction)) {
 479       case ADDITION_MODE_ID:
 480         aMode = AdditionMode;
 481         if (myActionMap[MODIFICATION_MODE_ID]->isChecked())
 482           myActionMap[MODIFICATION_MODE_ID]->trigger();
 483         else if (myActionMap[DETECTION_MODE_ID]->isChecked())
 484           myActionMap[DETECTION_MODE_ID]->trigger();
 485         break;
 486       case MODIFICATION_MODE_ID:
 487         aMode = ModificationMode;
 488         if (myActionMap[ADDITION_MODE_ID]->isChecked())
 489           myActionMap[ADDITION_MODE_ID]->trigger();
 490         else if (myActionMap[DETECTION_MODE_ID]->isChecked())
 491           myActionMap[DETECTION_MODE_ID]->trigger();
 492         break;
 493       case DETECTION_MODE_ID:
 494         aMode = DetectionMode;
 495         if (myActionMap[ADDITION_MODE_ID]->isChecked())
 496           myActionMap[ADDITION_MODE_ID]->trigger();
 497         else if (myActionMap[MODIFICATION_MODE_ID]->isChecked())
 498           myActionMap[MODIFICATION_MODE_ID]->trigger();
 499         break;
 500     }
 501   }
 502   updateActionsStates();
 503   updateUndoRedo();
 504   setLocalPointContext( aMode == ModificationMode, true );
 505 }
 506
 507 void CurveCreator_Widget::onNewSection()
 508 {
 509   if( !myCurve )
 510     return;
 511
 512   stopActionMode();
 513   myNewSectionEditor->clear();
 514   myNewSectionEditor->setEditMode(false);
 515   QString aSectName = QString( CurveCreator_UtilsICurve::getUniqSectionName( myCurve ).c_str() );
 516   myNewSectionEditor->setSectionParameters(aSectName, true, CurveCreator::Polyline );
 517   emit subOperationStarted( myNewSectionEditor, false );
 518 }
 519
 520 void CurveCreator_Widget::onAddNewSection()
 521 {
 522   if( !myCurve )
 523     return;
 524   myCurve->addSection( myNewSectionEditor->getName().toStdString(),
 525                        myNewSectionEditor->getSectionType(),
 526                        myNewSectionEditor->isClosed() );
 527   mySectionView->sectionAdded( -1 ); // add a new section to the end of list
 528   QString aNewName = QString( CurveCreator_UtilsICurve::getUniqSectionName( myCurve ).c_str() );
 529   myNewSectionEditor->setSectionName(aNewName);
 530   updateActionsStates();
 531   updateUndoRedo();
 532   onCancelSection();
 533 }
 534
 535 void CurveCreator_Widget::onCancelSection()
 536 {
 537   emit subOperationFinished( myNewSectionEditor );
 538 }
 539
 540 QAction* CurveCreator_Widget::createAction( ActionId theId, const QString& theName, const QPixmap& theImage,
 541                                             const QString& theToolTip, const QKeySequence& theShortcut )
 542 {
 543   QAction* anAct = new QAction(theName,this);
 544   if( !theImage.isNull() ){
 545     anAct->setIcon(theImage);
 546   }
 547   anAct->setShortcut(theShortcut);
 548   anAct->setToolTip(theToolTip);
 549   myActionMap[theId] = anAct;
 550   return anAct;
 551 }
 552
 553 QAction* CurveCreator_Widget::getAction( ActionId theId )
 554 {
 555   if( myActionMap.contains(theId) )
 556     return myActionMap[theId];
 557   return NULL;
 558 }
 559
 560 QAction* CurveCreator_Widget::getAction( ActionMode theMode )
 561 {
 562   ActionId anActionId = NONE_ID;
 563   switch ( theMode ) {
 564     case AdditionMode:
 565       anActionId = ADDITION_MODE_ID;
 566       break;
 567     case ModificationMode:
 568       anActionId = MODIFICATION_MODE_ID;
 569       break;
 570     case DetectionMode:
 571       anActionId = DETECTION_MODE_ID;
 572       break;
 573     default:
 574       break;
 575   }
 576   QAction* anAction = 0;
 577   if ( anActionId != NONE_ID && myActionMap.contains( anActionId ) )
 578     anAction = myActionMap[anActionId];
 579   return anAction;
 580 }
 581
 582 void CurveCreator_Widget::onEditSection( int theSection )
 583 {
 584   if( !myCurve )
 585     return;
 586
 587   stopActionMode();
 588   mySection = theSection;
 589   QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
 590   bool isClosed = myCurve->isClosed(theSection);
 591   CurveCreator::SectionType aType = myCurve->getSectionType(theSection);
 592   myNewSectionEditor->setEditMode(true);
 593   myNewSectionEditor->setSectionParameters( aSectName, isClosed, aType );
 594
 595   emit subOperationStarted( myNewSectionEditor, true );
 596 }
 597
 598 void CurveCreator_Widget::onModifySection()
 599 {
 600   if( !myCurve )
 601     return;
 602   QString aName = myNewSectionEditor->getName();
 603   bool isClosed = myNewSectionEditor->isClosed();
 604   CurveCreator::SectionType aSectType = myNewSectionEditor->getSectionType();
 605   if( myCurve->getSectionName(mySection) != aName.toStdString() )
 606     myCurve->setSectionName( mySection , aName.toStdString() );
 607
 608   bool isGeomModified = false;
 609
 610   if( myCurve->getSectionType(mySection) != aSectType ) {
 611     myCurve->setSectionType( mySection, aSectType );
 612     isGeomModified = true;
 613   }
 614
 615   if( myCurve->isClosed(mySection) != isClosed ) {
 616     myCurve->setClosed( mySection, isClosed );
 617     isGeomModified = true;
 618   }
 619   mySectionView->sectionChanged(mySection);
 620   updateUndoRedo();
 621   onCancelSection();
 622 }
 623
 624 void CurveCreator_Widget::onJoin()
 625 {
 626   if( !myCurve )
 627     return;
 628   QList<int> aSections = mySectionView->getSelectedSections();
 629   if( aSections.size() == 0 ){
 630     return;
 631   }
 632   stopActionMode();
 633
 634   std::list<int> aSectionsToJoin;
 635   for( int i = 0; i < aSections.size() ; i++ ){
 636     aSectionsToJoin.push_back( aSections[i] );
 637   }
 638   //int aMainSect = aSectionsToJoin.front();
 639   //int aMainSectSize = myCurve->getNbPoints(aMainSect);
 640   if ( myCurve->join( aSectionsToJoin ) )
 641   {
 642     std::list<int>::const_iterator anIt = aSectionsToJoin.begin(),
 643                                    aLast = aSectionsToJoin.end();
 644     // the first section should be skipped. It is not removed, but is modified
 645     anIt++;
 646     for ( ; anIt != aLast; anIt++ )
 647       mySectionView->sectionsRemoved( *anIt );
 648   }
 649
 650   /* The update for the points of the main section
 651   int aNewSectSize = myCurve->getNbPoints(aMainSect);
 652   if( aNewSectSize != aMainSectSize )
 653     mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );*/
 654   updateUndoRedo();
 655 }
 656
 657 void CurveCreator_Widget::onRemove()
 658 {
 659   if( !myCurve )
 660     return;
 661
 662   switch( getActionMode() ) {
 663     case NoneMode:
 664       removeSection();
 665     break;
 666     case ModificationMode:
 667       removePoint();
 668     break;
 669     default:
 670       break;
 671   }
 672 }
 673
 674 void CurveCreator_Widget::onClearAll()
 675 {
 676   if( !myCurve )
 677     return;
 678   stopActionMode();
 679   myCurve->clear();
 680   mySectionView->reset();
 681   updateActionsStates();
 682   updateUndoRedo();
 683 }
 684
 685 void CurveCreator_Widget::onJoinAll()
 686 {
 687   if( !myCurve )
 688     return;
 689   stopActionMode();
 690
 691   std::list<int> aSectionsToJoin;
 692   for( int i = 0, aNb = myCurve->getNbSections(); i < aNb ; i++ ){
 693     aSectionsToJoin.push_back( i );
 694   }
 695   bool aRes = myCurve->join( aSectionsToJoin );
 696
 697   mySectionView->reset();
 698   updateActionsStates();
 699   updateUndoRedo();
 700 }
 701
 702 void CurveCreator_Widget::onUndoSettings()
 703 {
 704
 705 }
 706
 707 void CurveCreator_Widget::onSetSpline()
 708 {
 709   if( !myCurve )
 710     return;
 711   stopActionMode();
 712   QList<int> aSelSections = mySectionView->getSelectedSections();
 713   for( int i = 0 ; i < aSelSections.size() ; i++ ){
 714     myCurve->setSectionType(aSelSections[i], CurveCreator::Spline );
 715     mySectionView->sectionChanged(aSelSections[i]);
 716   }
 717   updateUndoRedo();
 718 }
 719
 720 void CurveCreator_Widget::onSetPolyline()
 721 {
 722   if( !myCurve )
 723     return;
 724   stopActionMode();
 725   QList<int> aSelSections = mySectionView->getSelectedSections();
 726   for( int i = 0 ; i < aSelSections.size() ; i++ ){
 727     myCurve->setSectionType( aSelSections[i], CurveCreator::Polyline );
 728     mySectionView->sectionChanged( aSelSections[i] );
 729   }
 730   updateUndoRedo();
 731 }
 732
 733 void CurveCreator_Widget::onCloseSections()
 734 {
 735   if( !myCurve )
 736     return;
 737   stopActionMode();
 738   QList<int> aSelSections = mySectionView->getSelectedSections();
 739   for( int i = 0 ; i < aSelSections.size() ; i++ ){
 740     myCurve->setClosed(aSelSections[i], true);
 741     mySectionView->sectionChanged(aSelSections[i]);
 742   }
 743   updateUndoRedo();
 744 }
 745
 746 void CurveCreator_Widget::onUncloseSections()
 747 {
 748   if( !myCurve )
 749     return;
 750   stopActionMode();
 751   QList<int> aSelSections = mySectionView->getSelectedSections();
 752   for( int i = 0 ; i < aSelSections.size() ; i++ ){
 753     myCurve->setClosed(aSelSections[i], false);
 754     mySectionView->sectionChanged(aSelSections[i]);
 755   }
 756   updateUndoRedo();
 757 }
 758
 759 void CurveCreator_Widget::onUndo()
 760 {
 761   if( !myCurve )
 762     return;
 763
 764   CurveCreator_ICurve::SectionToPointList aPoints;
 765   startCurveModification( aPoints, false );
 766   myCurve->undo();
 767   finishCurveModification();
 768   mySectionView->reset();
 769 }
 770
 771 void CurveCreator_Widget::onRedo()
 772 {
 773   if( !myCurve )
 774     return;
 775   CurveCreator_ICurve::SectionToPointList aPoints;
 776   startCurveModification( aPoints, false );
 777   myCurve->redo();
 778   finishCurveModification();
 779   mySectionView->reset();
 780 }
 781
 782 void CurveCreator_Widget::updateUndoRedo()
 783 {
 784   if( !myCurve )
 785     return;
 786   QAction* anAct = myActionMap[UNDO_ID];
 787   if( anAct != 0 ){
 788     if( myCurve->getNbUndo() != 0 ){
 789       anAct->setEnabled(true);
 790     }
 791     else{
 792       anAct->setDisabled(true);
 793     }
 794   }
 795   anAct = myActionMap[REDO_ID];
 796   if( anAct != 0 ){
 797     if( myCurve->getNbRedo() != 0 ){
 798       anAct->setEnabled(true);
 799     }
 800     else{
 801       anAct->setDisabled(true);
 802     }
 803   }
 804 }
 805
 806 void CurveCreator_Widget::onContextMenu( QPoint thePoint )
 807 {
 808   QList<ActionId> aContextActions;
 809   aContextActions << CLEAR_ALL_ID << JOIN_ID << JOIN_ALL_ID << SEPARATOR_ID <<
 810                      CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID <<
 811                      SET_SECTIONS_SPLINE_ID;
 812   QPoint aGlPoint = mySectionView->mapToGlobal(thePoint);
 813   bool isVis = false;
 814   QList<ActionId> aResAct;
 815   for( int i = 0 ; i < aContextActions.size() ; i++ ){
 816     if( aContextActions[i] != SEPARATOR_ID ){
 817       if( myActionMap.contains(aContextActions[i]) ){
 818         QAction* anAct = myActionMap[aContextActions[i]];
 819         if( anAct->isEnabled() ){
 820           aResAct << aContextActions[i];
 821           isVis = true;
 822         }
 823       }
 824     }
 825     else{
 826       aResAct << SEPARATOR_ID;
 827     }
 828   }
 829   if( !isVis )
 830     return;
 831
 832   QMenu* aMenu = new QMenu(this);
 833   for( int i = 0 ; i < aResAct.size() ; i++ ){
 834     if( aResAct[i] == SEPARATOR_ID ){
 835       aMenu->addSeparator();
 836     }
 837     else{
 838       QAction* anAct = myActionMap[aResAct[i]];
 839       aMenu->insertAction(NULL, anAct);
 840     }
 841   }
 842   aMenu->exec(aGlPoint);
 843 }
 844
 845 QList<int> CurveCreator_Widget::getSelectedSections()
 846 {
 847   return mySectionView->getSelectedSections();
 848 }
 849
 850 void CurveCreator_Widget::setSelectedSections( const QList<int>& theSections )
 851 {
 852   mySectionView->setSelectedSections( theSections );
 853   updateActionsStates();
 854   updateUndoRedo();
 855 }
 856
 857 /**
 858  * According to the widget state, performs the remove action
 859  */
 860 void CurveCreator_Widget::removeSelected()
 861 {
 862   onRemove();
 863 }
 864
 865 /**
 866  * Checks whether there are some selection to be removed
 867  */
 868 bool CurveCreator_Widget::removeEnabled()
 869 {
 870   bool isEnabled = getActionMode() == ModificationMode;
 871   if ( !isEnabled ) {
 872     QList<int> aSelSections = mySectionView->getSelectedSections();
 873     CurveCreator_TreeView::SelectionType aSelType = mySectionView->getSelectionType();
 874     isEnabled = aSelType == CurveCreator_TreeView::ST_SECTIONS &&
 875                 aSelSections.size() == 1;
 876   }
 877   return isEnabled;
 878 }
 879
 880 void CurveCreator_Widget::setActionMode( const ActionMode& theMode )
 881 {
 882   ActionMode aPrevMode = getActionMode();
 883   QAction* aPrevAction = getAction( aPrevMode );
 884   QAction* anAction = getAction( theMode );
 885   switch ( theMode ) {
 886     case NoneMode:
 887     case AdditionMode: {
 888       if ( aPrevAction ) {
 889         if ( aPrevAction->isChecked() ) {
 890           aPrevAction->setChecked( false );
 891         }
 892       }
 893       if ( aPrevMode == ModificationMode )
 894         onModificationMode( false );
 895       if ( aPrevMode == AdditionMode )
 896         onAdditionMode( false );
 897
 898       if ( theMode == AdditionMode )
 899       {
 900         anAction->setChecked( true );
 901         onModeChanged( true );
 902       }
 903     }
 904     break;
 905     break;
 906     case ModificationMode:
 907     {
 908       //TODO
 909     }
 910     break;
 911     case DetectionMode:
 912       break;
 913   }
 914 }
 915
 916 CurveCreator_Widget::ActionMode CurveCreator_Widget::getActionMode() const
 917 {
 918   ActionMode aMode = NoneMode;
 919
 920   if ( myActionMap[ADDITION_MODE_ID]->isChecked() )
 921     aMode = AdditionMode;
 922   else if ( myActionMap[MODIFICATION_MODE_ID]->isChecked() )
 923     aMode = ModificationMode;
 924   else if ( myActionMap[DETECTION_MODE_ID]->isChecked() )
 925     aMode = DetectionMode;
 926
 927   return aMode;
 928 }
 929
 930 void CurveCreator_Widget::SetViewer2DMode(const bool To2D)
 931 {
 932   if (myOCCViewer) {
 933     if (To2D) {
 934       myOld2DMode = OCCViewer_Utilities::setViewer2DMode
 935                     (myOCCViewer, OCCViewer_ViewWindow::XYPlane);
 936     } else {
 937       OCCViewer_Utilities::setViewer2DMode(myOCCViewer, myOld2DMode);
 938     }
 939   }
 940 }
 941
 942 //=================================================================================
 943 // function : GeometryGUI::addCoordsByClick()
 944 // purpose  : Manage mouse press events in Additon mode
 945 //=================================================================================
 946 void CurveCreator_Widget::addCoordsByClick( QMouseEvent* pe )
 947 {
 948   if (pe->button() != Qt::LeftButton)
 949     return;
 950
 951   if ( pe->modifiers() != Qt::ControlModifier ) {
 952     Handle(AIS_InteractiveContext) ic = getAISContext();
 953     if ( ic.IsNull() )
 954       return;
 955
 956     gp_Pnt aPnt;
 957     OCCViewer_ViewPort3d* vp = getViewPort();
 958
 959     aPnt = CurveCreator_Utils::ConvertClickToPoint( pe->x(), pe->y(), vp->getView() );
 960
 961     // set the coordinates into dialog
 962     CurveCreator::Coordinates aCoords;
 963     aCoords.push_back( aPnt.X() );
 964     aCoords.push_back( aPnt.Y() );
 965     if ( myCurve->getDimension() == 3 ) {
 966       aCoords.push_back( aPnt.Z() );
 967     }
 968     addNewPoint(aCoords);
 969   }
 970 }
 971
 972 /**
 973  * Manage mouse press events
 974  * \param theWindow an owner of the signal
 975  * \param theEvent a mouse event
 976  */
 977 void CurveCreator_Widget::onMousePress( SUIT_ViewWindow*, QMouseEvent* theEvent )
 978 {
 979   if ( theEvent->button() != Qt::LeftButton )
 980     return;
 981
 982   // Initialize the starting point
 983   myStartPoint.setX( theEvent->x() );
 984   myStartPoint.setY( theEvent->y() );
 985
 986   switch( getActionMode() ) {
 987     case ModificationMode: {
 988       //store initial cursor position for Drag&Drop
 989       setDragStarted( true, theEvent->pos() );
 990       break;
 991     }
 992     case AdditionMode: {
 993       addCoordsByClick( theEvent );
 994       break;
 995     }
 996     default:
 997       break;
 998   }
 999 }
1000
1001 /**
1002  * Manage mouse release events in Modification mode
1003  * \param theWindow an owner of the signal
1004  * \param theEvent a mouse event
1005  */
1006 void CurveCreator_Widget::onMouseRelease( SUIT_ViewWindow* theWindow, QMouseEvent* theEvent )
1007 {
1008   if ( getActionMode() != ModificationMode )
1009   {
1010     // Emit selectionChanged() signal
1011     getOCCViewer()->performSelectionChanged();
1012     return;
1013   }
1014   if (theEvent->button() != Qt::LeftButton) return;
1015   if (!theWindow->inherits("OCCViewer_ViewWindow")) return;
1016
1017   // Initialize the ending point
1018   myEndPoint.setX( theEvent->x() );
1019   myEndPoint.setY( theEvent->y() );
1020
1021   bool aHasShift = ( theEvent->modifiers() & Qt::ShiftModifier );
1022
1023   // Highlight detected objects
1024   Handle(AIS_InteractiveContext) aCtx = getAISContext();
1025   if ( !aCtx.IsNull() )
1026   {
1027     OCCViewer_ViewWindow* aView = (OCCViewer_ViewWindow*) theWindow;
1028     if (!aView)
1029       return;
1030
1031     if (!aHasShift)
1032       aCtx->ClearCurrents( false );
1033
1034     Handle(V3d_View) aView3d = aView->getViewPort()->getView();
1035     if ( !aView3d.IsNull() )
1036     {
1037       // Initialize the single selection if start and end points are equal,
1038       // otherwise a rectangular selection.
1039       if ( myStartPoint == myEndPoint )
1040       {
1041         aCtx->MoveTo( myEndPoint.x(), myEndPoint.y(), aView3d );
1042         if ( aHasShift )
1043           aCtx->ShiftSelect();
1044         else
1045           aCtx->Select();
1046       }
1047       else
1048       {
1049         if ( aHasShift )
1050           aCtx->ShiftSelect( myStartPoint.x(), myStartPoint.y(), myEndPoint.x(), myEndPoint.y(),
1051                              aView3d, Standard_False );
1052         else
1053           aCtx->Select( myStartPoint.x(), myStartPoint.y(), myEndPoint.x(), myEndPoint.y(),
1054                         aView3d, Standard_False );
1055       }
1056     }
1057   }
1058
1059   if ( myDragStarted ) {
1060     bool isDragged = myDragged;
1061     CurveCreator_ICurve::SectionToPointList aDraggedPoints;
1062     QMap<CurveCreator_ICurve::SectionToPoint, CurveCreator::Coordinates > anInitialDragPointsCoords;
1063     if ( myDragged ) {
1064       aDraggedPoints = myDragPoints;
1065       anInitialDragPointsCoords = myInitialDragPointsCoords;
1066     }
1067
1068     setDragStarted( false );
1069
1070     if ( aDraggedPoints.size() > 0 ) {
1071       // Collect old coordinates of the dragged points
1072       CurveCreator_ICurve::SectionToPointCoordsList anOldPoints;
1073       foreach ( const CurveCreator_ICurve::SectionToPoint aSectionToPoint, anInitialDragPointsCoords.keys() ) {
1074         CurveCreator::Coordinates aCoords = anInitialDragPointsCoords.value( aSectionToPoint );
1075         anOldPoints.push_back( std::make_pair( aSectionToPoint, aCoords ) );
1076       }
1077
1078       if ( myCurve->canPointsBeSorted() ) {
1079         // Add old coordinates of the curve points (except the dragged points) to the list
1080         for( int aSectionId = 0 ; aSectionId < myCurve->getNbSections() ; aSectionId++ ) {
1081           CurveCreator::Coordinates aCoords;
1082           for ( int aPointId = 0, aNb = myCurve->getNbPoints( aSectionId ); aPointId < aNb; aPointId++ ) {
1083             aCoords = myCurve->getPoint( aSectionId, aPointId );
1084             if ( aCoords.size() < 2 ) {
1085               continue;
1086             }
1087
1088             CurveCreator_ICurve::SectionToPoint aSectionToPoint = std::make_pair( aSectionId, aPointId );
1089
1090             if ( !anInitialDragPointsCoords.contains( aSectionToPoint ) ) {
1091               anOldPoints.push_back( std::make_pair( aSectionToPoint, aCoords ) );
1092             }
1093           }
1094         }
1095
1096         // Apply points sorting
1097         CurveCreator_ICurve::SectionToPointList aPoints;
1098         startCurveModification( aPoints, false );
1099
1100         myCurve->setSkipSorting( false );
1101
1102         CurveCreator_ICurve::SectionToPointCoordsList aCoordList;
1103         CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aDraggedPoints.begin(),
1104                                                                 aLast = aDraggedPoints.end();
1105         for ( ; anIt != aLast; anIt++ ) {
1106           int aSectionId = anIt->first;
1107           int aPointId = anIt->second;
1108           CurveCreator::Coordinates aPos = myCurve->getPoint( aSectionId, aPointId );
1109
1110           aCoordList.push_back(
1111             std::make_pair( std::make_pair( aSectionId, aPointId ), aPos ) );
1112         }
1113
1114         myCurve->setSeveralPoints( aCoordList, false );
1115
1116         finishCurveModification( aDraggedPoints );
1117       } else {
1118         // if the drag of some points has happened, restore the drag selection
1119         START_MEASURE_TIME;
1120         setSelectedPoints( aDraggedPoints );
1121         END_MEASURE_TIME( "drop" );
1122       }
1123
1124       // Save drag difference
1125       myCurve->saveCoordDiff( anOldPoints );
1126     }
1127   }
1128   else // check whether the segment is clicked an a new point should be added to the segment
1129   {
1130     if ( myStartPoint.x() == myEndPoint.x() && myStartPoint.y() == myEndPoint.y() )
1131       insertPointToSelectedSegment( myEndPoint.x(), myStartPoint.y() );
1132   }
1133
1134   // updates the input panel table to show the selected point coordinates
1135   updateLocalPointView();
1136   updateUndoRedo();
1137 }
1138
1139 /**
1140  * Manage mouse move events in Modification mode
1141  * \param theWindow an owner of the signal
1142  * \param theEvent a mouse event
1143  */
1144 void CurveCreator_Widget::onMouseMove( SUIT_ViewWindow*, QMouseEvent* theEvent )
1145 {
1146   if ( getActionMode() != ModificationMode || !myDragStarted )
1147     return;
1148
1149   QPoint aPos = theEvent->pos();
1150   if ( (aPos - myDragStartPosition).manhattanLength() < QApplication::startDragDistance() )
1151     return;
1152
1153   START_MEASURE_TIME;
1154
1155   moveSelectedPoints( aPos.x(), aPos.y() );
1156   myDragStartPosition = aPos;
1157
1158   END_MEASURE_TIME( "drag" );
1159 }
1160
1161 /**
1162  * Set zero viewer by the last view closed in
1163  * \param theManager a viewer manager
1164  */
1165 void CurveCreator_Widget::onLastViewClosed( SUIT_ViewManager* theManager )
1166 {
1167   myOCCViewer = 0;
1168 }
1169
1170 void CurveCreator_Widget::onMousePress( QMouseEvent* theEvent )
1171 {
1172   onMousePress( 0, theEvent );
1173 }
1174
1175 void CurveCreator_Widget::onMouseRelease( QMouseEvent* theEvent )
1176 {
1177   onMouseRelease( 0, theEvent );
1178 }
1179
1180 void CurveCreator_Widget::onMouseMove( QMouseEvent* theEvent )
1181 {
1182   onMouseMove( 0, theEvent );
1183 }
1184
1185 void CurveCreator_Widget::onCellChanged( int theRow, int theColumn )
1186 {
1187   int aCurrSect = myLocalPointView->getSectionId( theRow );
1188   int aPntIndex = myLocalPointView->getPointId( theRow );
1189
1190   if ( aPntIndex < 0 )
1191     return;
1192
1193   CurveCreator_ICurve::SectionToPointList aSelPoints;
1194   startCurveModification( aSelPoints );
1195
1196   double aX  = myLocalPointView->item( theRow, 2 )->data( Qt::UserRole ).toDouble();
1197   double anY = myLocalPointView->item( theRow, 3 )->data( Qt::UserRole ).toDouble();
1198   CurveCreator::Coordinates aChangedPos;
1199   aChangedPos.push_back( aX );
1200   aChangedPos.push_back( anY );
1201   myCurve->setPoint( aCurrSect, aPntIndex, aChangedPos );
1202
1203   finishCurveModification( aSelPoints );
1204 }
1205
1206 /**
1207  * Removes a selected section from the curve. Updates undo/redo status
1208  */
1209 void CurveCreator_Widget::removeSection()
1210 {
1211   stopActionMode();
1212
1213   QList<int> aSections = mySectionView->getSelectedSections();
1214   for( int i = 0 ; i < aSections.size() ; i++ ){
1215     int aSectNum = aSections[i] - (i);
1216     myCurve->removeSection( aSectNum );
1217     mySectionView->sectionsRemoved( aSectNum );
1218   }
1219   mySectionView->clearSelection();
1220   updateUndoRedo();
1221 }
1222
1223 /**
1224  * Removes a selected points from the curve. Updates undo/redo status
1225  */
1226 void CurveCreator_Widget::removePoint()
1227 {
1228   CurveCreator_ICurve::SectionToPointList aPoints;
1229   getSelectedPoints( aPoints );
1230   if ( aPoints.size() == 0 )
1231     return;
1232
1233   CurveCreator_ICurve::SectionToPointList aSelPoints;
1234   startCurveModification( aSelPoints, false );
1235
1236   myCurve->removeSeveralPoints( aPoints );
1237   finishCurveModification( CurveCreator_ICurve::SectionToPointList() );
1238   mySectionView->reset();
1239 }
1240
1241 void CurveCreator_Widget::addNewPoint(const CurveCreator::Coordinates& theCoords)
1242 {
1243   if( !myCurve )
1244     return;
1245   QList<int> aSections = mySectionView->getSelectedSections();
1246   if( aSections.size() == 0 ){
1247     return;
1248   }
1249   int aSection = aSections[0];
1250   myCurve->addPoints(theCoords, aSection); // add to the end of section
1251   mySectionView->pointsAdded( aSection, myCurve->getNbPoints( aSection ) );
1252   updateActionsStates();
1253   updateUndoRedo();
1254 }
1255
1256 void CurveCreator_Widget::insertPointToSelectedSegment( const int theX,
1257                                                         const int theY )
1258 {
1259   Handle(AIS_InteractiveContext) aContext = getAISContext();
1260
1261   OCCViewer_ViewPort3d* aViewPort = getViewPort();
1262   Handle(V3d_View) aView;
1263   if ( aViewPort )
1264     aView = aViewPort->getView();
1265
1266   if ( aContext.IsNull() || aView.IsNull() )
1267     return;
1268   gp_Pnt aPoint;
1269   gp_Pnt aPoint1, aPoint2;
1270   Handle(AIS_InteractiveObject) anAISObject = myCurve->getAISObject();
1271   bool isFoundPoint = CurveCreator_Utils::pointOnObject( aView, anAISObject, theX, theY,
1272                                                          aPoint, aPoint1, aPoint2 );
1273   if ( !isFoundPoint )
1274     return;
1275
1276   // insert the point to the model curve
1277   CurveCreator_ICurve::SectionToPointList aSelPoints;
1278   startCurveModification( aSelPoints );
1279
1280   CurveCreator::Coordinates aCoords;
1281   aCoords.push_back( aPoint.X() );
1282   aCoords.push_back( aPoint.Y() );
1283
1284   CurveCreator_ICurve::SectionToPointList aPoints1, aPoints2;
1285   findSectionsToPoints( aPoint1.X(), aPoint1.Y(), aPoints1 );
1286   findSectionsToPoints( aPoint2.X(), aPoint2.Y(), aPoints2 );
1287   CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aPoints1.begin(),
1288                                                           aLast = aPoints1.end();
1289   int aSectionId = -1;
1290   // find the indices of the neighbour point
1291   // there can be a case when a new point is added into two sections
1292   int aPoint1Id = -1, aPoint2Id = -1;
1293   for ( ; anIt != aLast && aSectionId < 0; anIt++ ) {
1294     int aSectionCur = anIt->first;
1295     CurveCreator_ICurve::SectionToPointList::const_iterator anIt2 = aPoints2.begin(),
1296                                                             aLast2 = aPoints2.end();
1297     for ( ; anIt2 != aLast2 && aSectionId < 0; anIt2++ ) {
1298       if ( anIt2->first == aSectionCur ) {
1299         aSectionId = aSectionCur;
1300         aPoint1Id = anIt->second;
1301         aPoint2Id = anIt2->second;
1302       }
1303     }
1304   }
1305
1306   int anInsertPos = -1;
1307   int aLastPoint = myCurve->getNbPoints( aSectionId )-1;
1308   if ( ( aPoint1Id == aLastPoint && aPoint2Id == 0 ) ||
1309        ( aPoint2Id == aLastPoint && aPoint1Id == 0 ) )
1310     anInsertPos = -1; // if the section happens between first and last points
1311   else
1312     anInsertPos = aPoint1Id < aPoint2Id ? aPoint1Id + 1 : aPoint2Id + 1;
1313
1314   myCurve->addPoints( aCoords, aSectionId, anInsertPos );
1315   mySectionView->pointsAdded( aSectionId, myCurve->getNbPoints( aSectionId ) );
1316
1317   finishCurveModification( aSelPoints );
1318
1319   setSelectedPoints();
1320 }
1321
1322 void CurveCreator_Widget::moveSelectedPoints( const int theXPosition,
1323                                               const int theYPosition )
1324 {
1325   OCCViewer_ViewPort3d* aViewPort = getViewPort();
1326   if ( !aViewPort )
1327     return;
1328
1329   CurveCreator_ICurve::SectionToPointList aPoints;
1330   startCurveModification( aPoints, false );
1331
1332   gp_Pnt aStartPnt = CurveCreator_Utils::ConvertClickToPoint( myDragStartPosition.x(),
1333                                                               myDragStartPosition.y(),
1334                                                               aViewPort->getView() );
1335   gp_Pnt anEndPnt = CurveCreator_Utils::ConvertClickToPoint( theXPosition, theYPosition,
1336                                                              aViewPort->getView() );
1337   double aXDelta = aStartPnt.X() - anEndPnt.X();
1338   double anYDelta = aStartPnt.Y() - anEndPnt.Y();
1339
1340   CurveCreator_ICurve::SectionToPointCoordsList aCoordList;
1341   CurveCreator::Coordinates aChangedPos;
1342   CurveCreator_ICurve::SectionToPointList::const_iterator anIt = myDragPoints.begin(),
1343                                                           aLast = myDragPoints.end();
1344   for ( ; anIt != aLast; anIt++ ) {
1345     int aSectionId = anIt->first;
1346     int aPointId = anIt->second;
1347     aChangedPos = myCurve->getPoint( aSectionId, aPointId );
1348     if ( aChangedPos.size() < 2 )
1349       continue;
1350
1351     // Remember drag points coordinates
1352     if ( !myDragged ) {
1353       myInitialDragPointsCoords.insert( std::make_pair( aSectionId, aPointId ), aChangedPos );
1354     }
1355
1356     aChangedPos[0] = aChangedPos[0] - aXDelta;
1357     aChangedPos[1] = aChangedPos[1] - anYDelta;
1358
1359     aCoordList.push_back(
1360       std::make_pair(std::make_pair( aSectionId, aPointId ),
1361                      aChangedPos ));
1362   }
1363   myCurve->setSeveralPoints( aCoordList, false );
1364
1365   myDragged = true;
1366   finishCurveModification( myDragPoints );
1367 }
1368
1369 void CurveCreator_Widget::updateLocalPointView()
1370 {
1371   if ( myDragStarted )
1372     return;
1373   Handle(AIS_InteractiveContext) aContext = getAISContext();
1374   if ( aContext.IsNull() )
1375     return;
1376
1377   CurveCreator_Utils::getSelectedPoints( aContext, myCurve, myLocalPoints );
1378   int aNbPoints = myLocalPoints.size();
1379
1380   bool isRowLimit = aNbPoints > myLocalPointRowLimit;
1381   myLocalPointView->setVisible( getActionMode() == ModificationMode && !isRowLimit );
1382
1383   if ( !isRowLimit ) {
1384     bool isBlocked = myLocalPointView->blockSignals(true);
1385
1386     myLocalPointView->setLocalPointsToTable( myLocalPoints );
1387
1388     myLocalPointView->blockSignals( isBlocked );
1389   }
1390 }
1391
1392 /**
1393  *
1394  */
1395 void CurveCreator_Widget::setLocalPointContext( const bool theOpen, const bool isUpdateTable )
1396 {
1397   CurveCreator_Utils::setLocalPointContext( myCurve, getAISContext(), theOpen );
1398   if ( !theOpen && isUpdateTable )
1399     updateLocalPointView();
1400 }
1401
1402 /**
1403  * Set drag operation started. Save the position and a list of dragged points
1404  * \param theState the drag operation state: started/finished
1405  * \param thePoint the start drag position
1406  */
1407 void CurveCreator_Widget::setDragStarted( const bool theState, const QPoint& thePoint )
1408 {
1409   if ( theState ) {
1410     getSelectedPoints( myDragPoints );
1411
1412     myDragStarted = myDragPoints.size();
1413     myDragStartPosition = thePoint;
1414     if ( myDragStarted ) {
1415       // change a viewer interaction style in order to avoid a select rectangle build
1416       myDragInteractionStyle = changeInteractionStyle( SUIT_ViewModel::KEY_FREE );
1417       myCurve->setSkipSorting( true );
1418     }
1419   }
1420   else {
1421     if ( myDragStarted )
1422       changeInteractionStyle( myDragInteractionStyle );
1423     myDragStarted = false;
1424     myDragPoints.clear();
1425     myInitialDragPointsCoords.clear();
1426   }
1427   myDragged = false;
1428 }
1429
1430 void CurveCreator_Widget::getSelectedPoints( CurveCreator_ICurve::SectionToPointList& thePoints )
1431 {
1432   thePoints.clear();
1433   thePoints = myLocalPoints;
1434 }
1435
1436 void CurveCreator_Widget::setSelectedPoints( const CurveCreator_ICurve::SectionToPointList& thePoints )
1437 {
1438   if ( myDragStarted )
1439     return;
1440   Handle(AIS_InteractiveContext) aContext = getAISContext();
1441   if ( aContext.IsNull() || !aContext->HasOpenedContext() )
1442     return;
1443
1444   CurveCreator_Utils::setSelectedPoints( aContext, myCurve, thePoints );
1445
1446   updateLocalPointView();
1447 }
1448
1449 void CurveCreator_Widget::stopActionMode()
1450 {
1451   setActionMode( NoneMode );
1452 }
1453
1454 /**
1455  * Get viewer information before perform the curve modification.
1456  * Take a list of selected cuve points an close local context.
1457  * The context should be closed because the curve presentation is
1458  * redisplayed and if it is not closed, when we close the local context
1459  * later, the presentation shown in the local context is disappeared.
1460  * \param thePoints an output list of curve selected points
1461  * \param theFillPoints a flag whether the selection list should be filled
1462  */
1463 void CurveCreator_Widget::startCurveModification(
1464                            CurveCreator_ICurve::SectionToPointList& thePoints,
1465                            const bool theFillPoints )
1466 {
1467   if ( theFillPoints ) {
1468     thePoints.clear();
1469     getSelectedPoints( thePoints );
1470   }
1471   setLocalPointContext( false );
1472 }
1473
1474 /**
1475  * Restore the viewer state after the curve modification is done.
1476  * Open local context and select given points inside it.
1477  * \param thePoints a list of curve selected points
1478  */
1479 void CurveCreator_Widget::finishCurveModification(
1480                            const CurveCreator_ICurve::SectionToPointList& thePoints )
1481 {
1482   if ( getActionMode() == ModificationMode )
1483     setLocalPointContext( true );
1484   setSelectedPoints( thePoints );
1485   updateUndoRedo();
1486 }
1487
1488 /**
1489  * Returns a point index in the model curve by the point coordinates in the viewer
1490  * \param theX the X coordinate of the point
1491  * \param theY the Y coordinate of the point
1492  */
1493 int CurveCreator_Widget::findLocalPointIndex( int theSectionId, double theX, double theY )
1494 {
1495   return CurveCreator_UtilsICurve::findLocalPointIndex( myCurve, theSectionId, theX, theY );
1496 }
1497
1498 void CurveCreator_Widget::findSectionsToPoints( const double theX, const double theY,
1499                                  CurveCreator_ICurve::SectionToPointList& thePoints )
1500 {
1501   return CurveCreator_UtilsICurve::findSectionsToPoints( myCurve, theX, theY, thePoints );
1502 }
1503
1504 void CurveCreator_Widget::convert( const CurveCreator_ICurve::SectionToPointList& thePoints,
1505                                    QMap<int, QList<int> >& theConvPoints )
1506 {
1507   return CurveCreator_UtilsICurve::convert( thePoints, theConvPoints );
1508 }
1509
1510 /**
1511  * Returns whethe the container has the value
1512  * \param theList a container of values
1513  * \param theValue a value
1514  */
1515 bool CurveCreator_Widget::contains( const CurveCreator_ICurve::SectionToPointList& theList,
1516                                     const CurveCreator_ICurve::SectionToPoint& theValue ) const
1517 {
1518   return CurveCreator_UtilsICurve::contains( theList, theValue );
1519 }