src/HYDROGUI/HYDROGUI_ImportGeomObjectOp.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include "HYDROGUI_ImportGeomObjectOp.h"
  24
  25 #include "HYDROGUI_GeomObjectDlg.h"
  26 #include "HYDROGUI_DataObject.h"
  27 #include "HYDROGUI_DataModel.h"
  28 #include "HYDROGUI_Module.h"
  29 #include "HYDROGUI_Tool.h"
  30 #include "HYDROGUI_UpdateFlags.h"
  31
  32 #include <HYDROData_Obstacle.h>
  33 #include <HYDROData_PolylineXY.h>
  34 #include <HYDROData_Iterator.h>
  35
  36 #include <GEOMBase.h>
  37
  38 #include <SalomeApp_Study.h>
  39
  40 #include <LightApp_Application.h>
  41 #include <LightApp_UpdateFlags.h>
  42
  43 #include <SUIT_Desktop.h>
  44 #include <SUIT_MessageBox.h>
  45
  46 #include <QDialog>
  47
  48 HYDROGUI_ImportGeomObjectOp::HYDROGUI_ImportGeomObjectOp( HYDROGUI_Module* theModule,
  49                                                           const int theOpType,
  50                                                           const int theGEOMOp )
  51 : HYDROGUI_Operation( theModule ),
  52   myOpType( theOpType ),
  53   myGEOMOp( theGEOMOp ),
  54   myGEOMOpName( "" ),
  55   myIsToShowPanel( true )
  56 {
  57   if ( myOpType == ImportSelectedAsPolyline ) {
  58     setName( tr( "IMPORT_GEOM_OBJECT_AS_POLYLINE" ) );
  59   } else {
  60     setName( tr( "IMPORT_GEOM_OBJECT_AS_OBSTACLE" ) );
  61   }
  62 }
  63
  64 HYDROGUI_ImportGeomObjectOp::~HYDROGUI_ImportGeomObjectOp()
  65 {
  66 }
  67
  68 void HYDROGUI_ImportGeomObjectOp::startOperation()
  69 {
  70   // Get GEOM objects to import
  71   myGeomObjects.clear();
  72
  73   if ( myOpType == ImportSelectedAsObstacle ) {
  74     myGeomObjects =
  75       HYDROGUI_Tool::GetSelectedGeomObjects( module(), getObstacleTypes() );
  76   } else if ( myOpType == ImportSelectedAsPolyline ) {
  77     myGeomObjects =
  78       HYDROGUI_Tool::GetSelectedGeomObjects( module(), getPolylineTypes() );
  79   }
  80
  81   // Do not show the panel if more than one GEOM objects are selected
  82   myIsToShowPanel = myIsToShowPanel && ( myGeomObjects.count() <= 1 );
  83
  84   HYDROGUI_Operation::startOperation();
  85
  86   HYDROGUI_GeomObjectDlg* aPanel = 0;
  87
  88   if ( myIsToShowPanel ) {
  89     // Get panel
  90     aPanel = ::qobject_cast<HYDROGUI_GeomObjectDlg*>( inputPanel() );
  91
  92     if ( aPanel ) {
  93       // Reset the panel state
  94       aPanel->reset();
  95
  96       // Set default name
  97       updateDefaultName();
  98
  99       // Pass the existing object names to the panel
 100       QStringList anExistingNames;
 101       if ( myOpType == ImportCreatedAsObstacle ||
 102            myOpType == ImportSelectedAsObstacle ) {
 103         anExistingNames = HYDROGUI_Tool::FindExistingObjectsNames( doc(), KIND_OBSTACLE );
 104       } else if ( myOpType == ImportSelectedAsPolyline ) {
 105         anExistingNames = HYDROGUI_Tool::FindExistingObjectsNames( doc(), KIND_POLYLINEXY );
 106       }
 107
 108       aPanel->setObjectNames( anExistingNames );
 109     }
 110   }
 111
 112   if ( !aPanel ) {
 113     onApply();
 114   }
 115
 116   // Activate GEOM module operation in case of the corresponding operation type
 117   if ( myOpType == ImportCreatedAsObstacle && myGEOMOp > 0 ) {
 118     LightApp_Application* anApp = module()->getApp();
 119     if ( anApp ) {
 120       connect( anApp, SIGNAL( operationFinished( const QString&, const QString&, const QStringList& ) ),
 121         this, SLOT( onExternalOperationFinished( const QString&, const QString&, const QStringList& ) ) );
 122
 123       module()->getApp()->activateOperation( "Geometry", myGEOMOp );
 124     }
 125   }
 126 }
 127
 128 void HYDROGUI_ImportGeomObjectOp::abortOperation()
 129 {
 130   LightApp_Application* anApp = module()->getApp();
 131   if ( anApp ) {
 132     anApp->disconnect( this );
 133   }
 134
 135   closeExternalOperationDlg();
 136
 137   HYDROGUI_Operation::abortOperation();
 138 }
 139
 140 void HYDROGUI_ImportGeomObjectOp::commitOperation()
 141 {
 142   closeExternalOperationDlg();
 143
 144   HYDROGUI_Operation::commitOperation();
 145 }
 146
 147 bool HYDROGUI_ImportGeomObjectOp::processApply( int& theUpdateFlags,
 148                                                 QString& theErrorMsg,
 149                                                 QStringList& theBrowseObjectsEntries )
 150 {
 151   // Get active SalomeApp_Study
 152   SalomeApp_Study* aStudy =
 153     dynamic_cast<SalomeApp_Study*>( module()->getApp()->activeStudy() );
 154   if ( !aStudy ) {
 155     return false;
 156   }
 157
 158   // Check that GEOM objects list is not empty
 159   if ( myGeomObjects.isEmpty() ) {
 160     theErrorMsg = tr( "NO_GEOM_OBJECT_TO_IMPORT" );
 161     return false;
 162   }
 163
 164   QString anObjectName;
 165   Handle(HYDROData_Entity) anObjectToEdit;
 166   ObjectKind anObjectKind =
 167     myOpType == ImportSelectedAsPolyline ? KIND_POLYLINEXY : KIND_OBSTACLE;
 168
 169   if ( myGeomObjects.count() == 1 ) {
 170     // Get panel
 171     HYDROGUI_GeomObjectDlg* aPanel = ::qobject_cast<HYDROGUI_GeomObjectDlg*>( inputPanel() );
 172     if ( aPanel ) {
 173       // Check object name
 174       anObjectName = aPanel->getObjectName().simplified();
 175       if ( anObjectName.isEmpty() ) {
 176         theErrorMsg = tr( "INCORRECT_OBJECT_NAME" );
 177         return false;
 178       }
 179
 180       // Get object to edit
 181       QString anEditedName = aPanel->getEditedObjectName().simplified();
 182
 183       if ( !anEditedName.isEmpty() ) {
 184         anObjectToEdit = HYDROGUI_Tool::FindObjectByName( module(), anEditedName, anObjectKind );
 185       }
 186     }
 187
 188     if( anObjectToEdit.IsNull() || anObjectToEdit->GetName() != anObjectName ) {
 189       // check that there are no other objects with the same name in the document
 190       Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anObjectName/*, anObjectKind*/ );
 191       if( !anObject.IsNull() ) {
 192         theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anObjectName );
 193         return false;
 194       }
 195     }
 196   }
 197
 198   bool anIsOk = false;
 199
 200   // Get the GEOM object as SObject
 201   foreach ( const QString& anEntry, myGeomObjects ) {
 202     _PTR(SObject) aSObject( aStudy->studyDS()->FindObjectID( qPrintable(anEntry)) );
 203     if ( aSObject ) {
 204       // Get the corresponding TopoDS_Shape
 205       TopoDS_Shape aShape = GEOMBase::GetShapeFromIOR( aSObject->GetIOR().c_str() );
 206       if ( aShape.IsNull() ) {
 207         continue;
 208       }
 209
 210       // Create/edit an object
 211       Handle(HYDROData_Entity) anObject;
 212
 213       if ( anObjectToEdit.IsNull() ) {
 214         if ( myOpType == ImportCreatedAsObstacle || myOpType == ImportSelectedAsObstacle ) {
 215           anObject = doc()->CreateObject( KIND_OBSTACLE );
 216           Handle(HYDROData_Obstacle) anObstacle = Handle(HYDROData_Obstacle)::DownCast( anObject );
 217           anObstacle->SetFillingColor( HYDROData_Obstacle::DefaultFillingColor() );
 218           anObstacle->SetBorderColor( HYDROData_Obstacle::DefaultBorderColor() );
 219           anObstacle->SetGeomObjectEntry( anEntry.toLatin1().constData() );
 220         } else if ( myOpType == ImportSelectedAsPolyline ) {
 221           anObject = doc()->CreateObject( KIND_POLYLINEXY );
 222           Handle(HYDROData_PolylineXY) aPolylineObj = Handle(HYDROData_PolylineXY)::DownCast( anObject );
 223           aPolylineObj->SetWireColor( HYDROData_PolylineXY::DefaultWireColor() );
 224           aPolylineObj->SetGeomObjectEntry( anEntry.toLatin1().constData() );
 225         }
 226       } else {
 227         anObject = anObjectToEdit;
 228       }
 229
 230       // Set name
 231       if ( anObjectName.isEmpty() ) {
 232         QString aName = QString::fromStdString( aSObject->GetName() );
 233         anObjectName = HYDROGUI_Tool::GenerateObjectName(
 234           module(), aName, QStringList(), true );
 235       }
 236       if ( anObject->GetName() != anObjectName ) {
 237         anObject->SetName( anObjectName );
 238       }
 239
 240       anObjectName.clear();
 241
 242       // Set shape
 243       if ( myOpType == ImportCreatedAsObstacle || myOpType == ImportSelectedAsObstacle ) {
 244         Handle(HYDROData_Obstacle) anObstacle = Handle(HYDROData_Obstacle)::DownCast( anObject );
 245         anObstacle->SetShape3D( aShape );
 246         anIsOk = true;
 247       } else if ( myOpType == ImportSelectedAsPolyline ) {
 248         Handle(HYDROData_PolylineXY) aPolyline = Handle(HYDROData_PolylineXY)::DownCast( anObject );
 249         anIsOk = aPolyline->ImportShape( aShape );
 250
 251         /* TODO: check it before start operation
 252         if ( anIsOk && !aPolyline->IsEditable() )
 253         {
 254           anIsOk = SUIT_MessageBox::question( module()->getApp()->desktop(),
 255                                               tr( "POLYLINE_IS_UNRECOGNIZED_TLT" ),
 256                                               tr( "POLYLINE_IS_UNRECOGNIZED_MSG" ),
 257                                               QMessageBox::Yes | QMessageBox::No,
 258                                               QMessageBox::No ) == QMessageBox::Yes;
 259           setPrintErrorMessage( anIsOk );
 260         }
 261         */
 262       }
 263
 264       // Check operation status
 265       if ( anIsOk ) {
 266         anObject->Update();
 267         module()->setIsToUpdate( anObject );
 268         QString aHydroObjEntry = HYDROGUI_DataObject::dataObjectEntry( anObject );
 269         theBrowseObjectsEntries.append( aHydroObjEntry );
 270         theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer;
 271       }
 272     }
 273   }
 274
 275   return anIsOk;
 276 }
 277
 278 HYDROGUI_InputPanel* HYDROGUI_ImportGeomObjectOp::createInputPanel() const
 279 {
 280   HYDROGUI_InputPanel* aPanel = 0;
 281   if ( myIsToShowPanel ) {
 282     QString anObjectTypeName =
 283       myOpType == ImportSelectedAsPolyline ? tr("DEFAULT_POLYLINE_NAME") :
 284                   tr("DEFAULT_OBSTACLE_NAME");
 285     aPanel = new HYDROGUI_GeomObjectDlg( module(), getName(), anObjectTypeName );
 286   }
 287
 288   return aPanel;
 289 }
 290
 291 void HYDROGUI_ImportGeomObjectOp::updateDefaultName()
 292 {
 293   // Get panel
 294   HYDROGUI_GeomObjectDlg* aPanel = ::qobject_cast<HYDROGUI_GeomObjectDlg*>( inputPanel() );
 295   if ( !aPanel ) {
 296     return;
 297   }
 298
 299   // Set the current GEOM object name to the panel
 300   if ( myGeomObjects.count() == 1 ) {
 301     SalomeApp_Study* aStudy =
 302       dynamic_cast<SalomeApp_Study*>( module()->getApp()->activeStudy() );
 303     if ( aStudy ) {
 304       QString anEntry = myGeomObjects.first();
 305       _PTR(SObject) aSObject( aStudy->studyDS()->FindObjectID( qPrintable(anEntry) ) );
 306       if ( aSObject ) {
 307         aPanel->setDefaultName( QString::fromStdString(aSObject->GetName()) );
 308       }
 309     }
 310   }
 311 }
 312
 313 /**
 314  * Called when the operation perfomed by another module is finished.
 315  * \param theModuleName the name of the module which perfomed the operation
 316  * \param theOperationName the operation name
 317  * \param theEntryList the list of the created objects entries
 318  */
 319 void HYDROGUI_ImportGeomObjectOp::onExternalOperationFinished(
 320   const QString& theModuleName, const QString& theOperationName,
 321   const QStringList& theEntryList )
 322 {
 323   // Process "Geometry" module operations with non-empty list of created objects only
 324   if ( theModuleName != "Geometry" || theEntryList.isEmpty() ) {
 325     return;
 326   }
 327
 328   // Store the operation name
 329   myGEOMOpName = theOperationName;
 330
 331   // Store the geom objects entries list
 332   myGeomObjects = theEntryList;
 333
 334   // Update the default name of the HYDRO object
 335   updateDefaultName();
 336
 337   // Close the dialog corresponding to the external operation
 338   closeExternalOperationDlg();
 339 }
 340
 341 void HYDROGUI_ImportGeomObjectOp::closeExternalOperationDlg()
 342 {
 343   if ( myGEOMOpName.isEmpty() ) {
 344     return;
 345   }
 346
 347   SUIT_Desktop* aDesktop = module()->getApp()->desktop();
 348   if ( aDesktop ) {
 349     QList<QDialog*> aDialogs = aDesktop->findChildren<QDialog*>();
 350     foreach ( QDialog* aDlg, aDialogs ) {
 351       if ( typeid(*aDlg).name() == myGEOMOpName ) {
 352         aDlg->close();
 353         break;
 354       }
 355     }
 356   }
 357 }
 358
 359 QList<GEOM::shape_type> HYDROGUI_ImportGeomObjectOp::getObstacleTypes()
 360 {
 361   QList<GEOM::shape_type> aTypes;
 362
 363   aTypes << GEOM::COMPOUND << GEOM::COMPOUND << GEOM::SOLID <<
 364             GEOM::SHELL << GEOM::FACE << GEOM::SHAPE;
 365
 366   return aTypes;
 367 }
 368
 369 QList<GEOM::shape_type> HYDROGUI_ImportGeomObjectOp::getPolylineTypes()
 370 {
 371   QList<GEOM::shape_type> aTypes;
 372
 373   aTypes << GEOM::WIRE << GEOM::EDGE;
 374
 375   return aTypes;
 376 }