typo-fix by Kunda

http://www.salome-platform.org/forum/forum_9/975195177

idl/SMESH_Mesh.idl

@@ -206,7 +206,7 @@ module SMESH
   {
     HYP_OK,
     HYP_MISSING,      // algo misses a hypothesis
-    HYP_CONCURENT,    // several applicable hypotheses
+    HYP_CONCURRENT,   // several applicable hypotheses
     HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
     HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
     HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements

src/DriverGMF/libmesh5.c

@@ -1029,7 +1029,7 @@ static int ScaKwdTab(GmfMshSct *msh)
                         if(isalpha(str[0]))
                         {
                                 /* Search which kwd code this string is associated with, 
-                                        then get its header and save the curent position in file (just before the data) */
+                                        then get its header and save the current position in file (just before the data) */
 
                                 for(KwdCod=1; KwdCod<= GmfMaxKwd; KwdCod++)
                                         if(!strcmp(str, GmfKwdFmt[ KwdCod ][0]))

src/SMESH/SMESH_Gen.cxx

@@ -675,7 +675,7 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh&               aMesh,
           checkConform = false; // no more check conformity
           INFOS( "ERROR: Local <" << algo->GetName() <<
                 "> would produce not conform mesh: "
-                "<Not Conform Mesh Allowed> hypotesis is missing");
+                "<Not Conform Mesh Allowed> hypothesis is missing");
           theErrors.push_back( SMESH_Gen::TAlgoStateError() );
           theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false );
         }

src/SMESH/SMESH_HypoFilter.cxx

@@ -77,7 +77,7 @@ int SMESH_HypoFilter::DimPredicate::Value( const SMESH_Hypothesis* aHyp ) const
 bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
                                                  const TopoDS_Shape&     /*aShape*/) const
 {
-  return SMESH_subMesh::IsApplicableHypotesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
+  return SMESH_subMesh::IsApplicableHypothesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
 };
 
 //=======================================================================

src/SMESH/SMESH_Hypothesis.hxx

@@ -51,7 +51,7 @@ public:
   {
     HYP_OK = 0,
     HYP_MISSING,      // algo misses a hypothesis
-    HYP_CONCURENT,    // several applicable hypotheses assigned to father shapes
+    HYP_CONCURRENT,   // several applicable hypotheses assigned to father shapes
     HYP_BAD_PARAMETER,// hypothesis has a bad parameter value
     HYP_HIDDEN_ALGO,  // an algo is hidden by an upper dim algo generating all-dim elements
     HYP_HIDING_ALGO,  // an algo hides lower dim algos by generating all-dim elements

src/SMESH/SMESH_Mesh.cxx

@@ -661,7 +661,7 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
     string hypName = anHyp->GetName();
     if ( hypName == "NotConformAllowed" )
     {
-      if(MYDEBUG) MESSAGE( "Hypotesis <NotConformAllowed> can be only global" );
+      if(MYDEBUG) MESSAGE( "Hypothesis <NotConformAllowed> can be only global" );
       return SMESH_Hypothesis::HYP_INCOMPATIBLE;
     }
   }
@@ -698,13 +698,13 @@ SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
     }
 
     // check concurrent hypotheses on ancestors
-    if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
+    if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !isGlobalHyp )
     {
       SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
       while ( smIt->more() ) {
         SMESH_subMesh* sm = smIt->next();
-        if ( sm->IsApplicableHypotesis( anHyp )) {
+        if ( sm->IsApplicableHypothesis( anHyp )) {
-          ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() );
+          ret2 = sm->CheckConcurrentHypothesis( anHyp->GetType() );
           if (ret2 > ret) {
             ret = ret2;
             break;
@@ -751,10 +751,10 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
 
   // there may appear concurrent hyps that were covered by the removed hyp
-  if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
+  if (ret < SMESH_Hypothesis::HYP_CONCURRENT &&
-      subMesh->IsApplicableHypotesis( anHyp ) &&
+      subMesh->IsApplicableHypothesis( anHyp ) &&
-      subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
+      subMesh->CheckConcurrentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
-    ret = SMESH_Hypothesis::HYP_CONCURENT;
+    ret = SMESH_Hypothesis::HYP_CONCURRENT;
 
   // sub-shapes
   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
@@ -768,13 +768,13 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
       ret = ret2;
 
     // check concurrent hypotheses on ancestors
-    if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
+    if (ret < SMESH_Hypothesis::HYP_CONCURRENT && !IsMainShape( aSubShape ) )
     {
       SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
       while ( smIt->more() ) {
         SMESH_subMesh* sm = smIt->next();
-        if ( sm->IsApplicableHypotesis( anHyp )) {
+        if ( sm->IsApplicableHypothesis( anHyp )) {
-          ret2 = sm->CheckConcurentHypothesis( anHyp->GetType() );
+          ret2 = sm->CheckConcurrentHypothesis( anHyp->GetType() );
           if (ret2 > ret) {
             ret = ret2;
             break;
@@ -1169,7 +1169,7 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
   SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
 
   // check if anHyp can be used to mesh aSubMesh
-  if ( !aSubMesh || !aSubMesh->IsApplicableHypotesis( hyp ))
+  if ( !aSubMesh || !aSubMesh->IsApplicableHypothesis( hyp ))
     return false;
 
   SMESH_Algo *algo = aSubMesh->GetAlgo();
@@ -1232,7 +1232,7 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
     {
       const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape();
 
-      if (( aSubMesh->IsApplicableHypotesis( hyp )) &&
+      if (( aSubMesh->IsApplicableHypothesis( hyp )) &&
           ( algo = aSubMesh->GetAlgo() )            &&
           ( compatibleHypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() )) &&
           ( compatibleHypoKind->IsOk( hyp, aSubShape )))

src/SMESH/SMESH_subMesh.cxx

@@ -512,25 +512,25 @@ bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) cons
 }
 
 //=======================================================================
-//function : IsApplicableHypotesis
+//function : IsApplicableHypothesis
 //purpose  : check if this sub-mesh can be computed using a hypothesis
 //=======================================================================
 
-bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const
+bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const
 {
   if ( !_father->HasShapeToMesh() && _subShape.ShapeType() == TopAbs_SOLID )
     return true; // true for the PseudoShape
 
-  return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() );
+  return IsApplicableHypothesis( theHypothesis, _subShape.ShapeType() );
 }
 
 //=======================================================================
-//function : IsApplicableHypotesis
+//function : IsApplicableHypothesis
 //purpose  : compare shape type and hypothesis type
 //=======================================================================
 
-bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
+bool SMESH_subMesh::IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis,
-                                          const TopAbs_ShapeEnum  theShapeType)
+                                           const TopAbs_ShapeEnum  theShapeType)
 {
   if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
   {
@@ -622,7 +622,7 @@ SMESH_Hypothesis::Hypothesis_Status
   bool modifiedHyp = (event == MODIF_HYP);  // if set to true, force event MODIF_ALGO_STATE
   SMESH_Algo* algoRequiringCleaning = 0;
 
-  bool isApplicableHyp = IsApplicableHypotesis( anHyp );
+  bool isApplicableHyp = IsApplicableHypothesis( anHyp );
 
   if (event == ADD_ALGO || event == ADD_FATHER_ALGO)
   {
@@ -1072,7 +1072,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
   if ( !theAlgo ) return false;
 
   // Suppose that theAlgo is applicable to _subShape, do not check it here
-  //if ( !IsApplicableHypotesis( theAlgo )) return false;
+  //if ( !IsApplicableHypothesis( theAlgo )) return false;
 
   // check only algo that doesn't NeedDiscreteBoundary(): because mesh made
   // on a sub-shape will be ignored by theAlgo
@@ -2207,13 +2207,13 @@ const SMESH_Hypothesis* SMESH_subMesh::getSimilarAttached(const TopoDS_Shape&
 }
 
 //=======================================================================
-//function : CheckConcurentHypothesis
+//function : CheckConcurrentHypothesis
 //purpose  : check if there are several applicable hypothesis attached to
 //           ancestors
 //=======================================================================
 
 SMESH_Hypothesis::Hypothesis_Status
-  SMESH_subMesh::CheckConcurentHypothesis (const int theHypType)
+  SMESH_subMesh::CheckConcurrentHypothesis (const int theHypType)
 {
   // is there local hypothesis on me?
   if ( getSimilarAttached( _subShape, 0, theHypType ) )
@@ -2235,7 +2235,7 @@ SMESH_Hypothesis::Hypothesis_Status
         aPrevHyp     = hyp;
       }
       else if ( aPrevWithHyp.ShapeType() == ancestor.ShapeType() && aPrevHyp != hyp )
-        return SMESH_Hypothesis::HYP_CONCURENT;
+        return SMESH_Hypothesis::HYP_CONCURRENT;
       else
         return SMESH_Hypothesis::HYP_OK;
     }

src/SMESH/SMESH_subMesh.hxx

@@ -238,14 +238,14 @@ public:
   // return true if theHypothesis can be attached to me:
   // its dimension is checked
 
-  static bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
+  static bool IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis,
                                     const TopAbs_ShapeEnum  theShapeType);
 
-  bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const;
+  bool IsApplicableHypothesis(const SMESH_Hypothesis* theHypothesis) const;
   // return true if theHypothesis can be used to mesh me:
   // its shape type is checked
   
-  SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType);
+  SMESH_Hypothesis::Hypothesis_Status CheckConcurrentHypothesis (const int theHypType);
   // check if there are several applicable hypothesis on fathers
 
   /*!

src/SMESHGUI/SMESHGUI_ComputeDlg.cxx

@@ -1994,7 +1994,7 @@ void SMESHGUI_PrecomputeOp::onPreview()
     {
       computeFailed = false;
       myPreviewDisplayer->SetData( previewRes );
-      // append shape indeces with computed mesh entities
+      // append shape indices with computed mesh entities
       for ( int i = 0, n = aShapesId->length(); i < n; i++ )
         myMapShapeId[ aShapesId[ i ] ] = 0;
     }

src/SMESHGUI/SMESHGUI_CreatePatternDlg.cxx

@@ -622,7 +622,7 @@ void SMESHGUI_CreatePatternDlg::onSelectionDone()
 
 //=======================================================================
 // function : onDeactivate()
-// purpose  : SLOT called when dialog must be deativated
+// purpose  : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_CreatePatternDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_DeleteGroupDlg.cxx

@@ -315,7 +315,7 @@ void SMESHGUI_DeleteGroupDlg::onSelectionDone()
 
 //=================================================================================
 // function : onDeactivate()
-// purpose  : SLOT called when dialog must be deativated
+// purpose  : SLOT called when dialog must be deactivated
 //=================================================================================
 void SMESHGUI_DeleteGroupDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_DuplicateNodesDlg.cxx

@@ -688,7 +688,7 @@ bool SMESHGUI_DuplicateNodesDlg::isValid()
 }
 
 /*!
-  \brief SLOT called when dialog shoud be deativated.
+  \brief SLOT called when dialog should be deactivated.
 */
 void SMESHGUI_DuplicateNodesDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_FilterDlg.cxx

@@ -3073,7 +3073,7 @@ void SMESHGUI_FilterDlg::onHelp()
 
 //=======================================================================
 // name    : SMESHGUI_FilterDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_FilterDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_FilterLibraryDlg.cxx

@@ -517,7 +517,7 @@ void SMESHGUI_FilterLibraryDlg::onHelp()
 
 //=======================================================================
 // name    : SMESHGUI_FilterLibraryDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_FilterLibraryDlg::onDeactivate()
 {
@@ -602,7 +602,7 @@ QStringList SMESHGUI_FilterLibraryDlg::prepareFilters() const
 
 //================================================================
 // Function : onBrowse
-// Purpose  : SLOT. Display "Open file" dialog for chosing library name
+// Purpose  : SLOT. Display "Open file" dialog for choosing library name
 //================================================================
 void SMESHGUI_FilterLibraryDlg::onBrowse()
 {

src/SMESHGUI/SMESHGUI_GroupDlg.cxx

@@ -1197,7 +1197,7 @@ bool SMESHGUI_GroupDlg::onApply()
             anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta ); break;          
             break;
           }
-          // update a visible group accoding to a changed contents
+          // update a visible group according to a changed contents
           if ( !isConversion && anActor->GetVisibility() )
           {
             SMESH::Update( anIO, true );
@@ -2310,7 +2310,7 @@ void SMESHGUI_GroupDlg::onHelp()
 
 //=================================================================================
 // function : SMESHGUI_GroupDlg::onDeactivate
-// purpose  : SLOT called when dialog must be deativated
+// purpose  : SLOT called when dialog must be deactivated
 //=================================================================================
 void SMESHGUI_GroupDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_GroupOnShapeDlg.cxx

@@ -134,7 +134,7 @@ SMESHGUI_GroupOnShapeDlg::~SMESHGUI_GroupOnShapeDlg()
 
 //================================================================================
 /*!
- * \brief slot to enable/diable [Apply]
+ * \brief slot to enable/disable [Apply]
  */
 //================================================================================
 
@@ -505,6 +505,6 @@ void SMESHGUI_GroupOnShapeOp::selectionDone()
     myNodeGeoIDs = goodIds;
   }
 
-  // enable/diable Apply, which can change at selection
+  // enable/disable Apply, which can change at selection
   myDlg->updateButtons();
 }

src/SMESHGUI/SMESHGUI_GroupOpDlg.cxx

@@ -482,7 +482,7 @@ void SMESHGUI_GroupOpDlg::setVisible( bool visible )
 }
 
 /*!
-  \brief SLOT called when dialog must be deativated
+  \brief SLOT called when dialog must be deactivated
 */
 void SMESHGUI_GroupOpDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_MeshDlg.cxx

@@ -692,7 +692,7 @@ void SMESHGUI_MeshDlg::reset()
 
 //================================================================================
 /*!
- * \brief Sets curent tab
+ * \brief Sets current tab
  */
 //================================================================================    
 void SMESHGUI_MeshDlg::setCurrentTab( const int theId  )

src/SMESHGUI/SMESHGUI_MeshOrderDlg.cxx

@@ -122,7 +122,7 @@ static void addMeshItem( QListWidget* theList,
 
 // =========================================================================================
 /*!
- * \brief Clear submesh names and indeces
+ * \brief Clear submesh names and indices
  */
 // =========================================================================================
 
@@ -134,7 +134,7 @@ void SMESHGUI_MeshOrderBox::Clear()
 
 // =========================================================================================
 /*!
- * \brief Set submesh names and indeces
+ * \brief Set submesh names and indices
  */
 // =========================================================================================
 
@@ -159,7 +159,7 @@ void SMESHGUI_MeshOrderBox::SetMeshes(const ListListName& theMeshNames,
 
 // =========================================================================================
 /*!
- * \brief cehck that item exists and not a separator
+ * \brief check that item exists and not a separator
  */
 // =========================================================================================
 
@@ -191,7 +191,7 @@ ListListId SMESHGUI_MeshOrderBox::GetMeshIds() const
 
 // =========================================================================================
 /*!
- * \brief Returns result (ordered by user) mesh indeces
+ * \brief Returns result (ordered by user) mesh indices
  */
 // =========================================================================================
 

src/SMESHGUI/SMESHGUI_MeshOrderDlg.h

@@ -57,7 +57,7 @@ class SMESHGUI_EXPORT SMESHGUI_MeshOrderBox : public QGroupBox
   //! Clear mesh box
   void         Clear();
 
-  //! Set mesh (submesh) names and indeces
+  //! Set mesh (submesh) names and indices
   void         SetMeshes(const ListListName& theMeshNames,
                          const ListListId&   theMeshIds);
 
@@ -66,7 +66,7 @@ class SMESHGUI_EXPORT SMESHGUI_MeshOrderBox : public QGroupBox
 
   //! Returns result (ordered by user) mesh names
   ListListId   GetMeshIds() const;
-  //! Returns result (ordered by user) mesh indeces
+  //! Returns result (ordered by user) mesh indices
   ListListName GetMeshNames() const;
  
  private slots:

src/SMESHGUI/SMESHGUI_MeshOrderOp.cxx

@@ -120,7 +120,7 @@ void SMESHGUI_MeshOrderOp::initDialog()
   if ( !myMgr->GetMeshOrder() ) {
     SUIT_MessageBox::information(desktop(),
                              tr("SMESH_INFORMATION"),
-                             tr("SMESH_NO_CONCURENT_MESH"));
+                             tr("SMESH_NO_CONCURRENT_MESH"));
     
     onCancel();
     return;
@@ -199,7 +199,7 @@ void SMESHGUI_MeshOrderMgr::SetMesh(SMESH::SMESH_Mesh_var& theMesh)
 
 //================================================================================
 /*!
- * \brief Check for concurents between submesh objects
+ * \brief Check for concurrents between submesh objects
  */
 //================================================================================
 
@@ -211,7 +211,7 @@ bool SMESHGUI_MeshOrderMgr::GetMeshOrder()
 
 //================================================================================
 /*!
- * \brief Check for concurents between submesh objects
+ * \brief Check for concurrents between submesh objects
  */
 //================================================================================
 
@@ -300,8 +300,8 @@ bool SMESHGUI_MeshOrderMgr::SetMeshOrder( const  ListListId& theListListIds )
     }
   }
 
-  // is it enought to set modifid attribute on root mesh objects only?
+  // is it enough to set modified attribute on root mesh objects only?
-  //  it is seems that modifaction flag will be set on child submeshes 
+  //  it is seems that modifcation flag will be set on child submeshes 
   //  automatically  (see SMESH::ModifiedMesh for details)
   SMESH::ModifiedMesh( aMeshSObj, false, false );
 

src/SMESHGUI/SMESHGUI_MeshOrderOp.h

@@ -45,9 +45,9 @@ public:
   virtual ~SMESHGUI_MeshOrderMgr();
   //! Set root mesh object
   void                   SetMesh( SMESH::SMESH_Mesh_var& theMesh );
-  //! Check for concurents between submesh objects
+  //! Check for concurrents between submesh objects
   bool                   GetMeshOrder();
-  //! Check for concurents between submesh objects
+  //! Check for concurrents between submesh objects
   bool                   GetMeshOrder( ListListId& theIds );
   //! Store submesh priority order
   bool                   SetMeshOrder();

src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx

@@ -723,7 +723,7 @@ void SMESHGUI_MeshPatternDlg::resetSelInput()
 
 //=======================================================================
 // name    : SMESHGUI_MeshPatternDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_MeshPatternDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx

@@ -600,7 +600,7 @@ void SMESHGUI_MultiEditDlg::onSelectionDone()
 
 //=======================================================================
 // name    : SMESHGUI_MultiEditDlg::onDeactivate
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_MultiEditDlg::onDeactivate()
 {
@@ -1628,7 +1628,7 @@ SMESHGUI_SplitVolumesDlg::SMESHGUI_SplitVolumesDlg(SMESHGUI* theModule)
       gb->setTitle( tr("TARGET_ELEM_TYPE"));
   }
 
-  myToAllChk->setChecked( true ); //aplly to the whole mesh by default
+  myToAllChk->setChecked( true ); //apply to the whole mesh by default
 
   bool hasHexa = true;//myMesh->_is_nil() ? false : myMesh->NbHexas();
   if ( hasHexa )

src/SMESHGUI/SMESHGUI_OffsetDlg.cxx

@@ -538,7 +538,7 @@ void SMESHGUI_OffsetDlg::onTextChange (const QString& theNewText)
   buttonOk->setEnabled(false);
   buttonApply->setEnabled(false);
 
-  // hilight entered elements
+  // highlight entered elements
   SMDS_Mesh* aMesh = 0;
   if (myActor)
     aMesh = myActor->GetObject()->GetMesh();

src/SMESHGUI/SMESHGUI_Operation.h

@@ -20,7 +20,7 @@
 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
 // File   : SMESHGUI_Operation.h
 // Author : Sergey LITONIN, Open CASCADE S.A.S.
 //

src/SMESHGUI/SMESHGUI_SingleEditDlg.cxx

@@ -439,7 +439,7 @@ void SMESHGUI_SingleEditDlg::onSelectionDone()
 
 //=======================================================================
 // name    : onDeactivate()
-// Purpose : SLOT called when dialog must be deativated
+// Purpose : SLOT called when dialog must be deactivated
 //=======================================================================
 void SMESHGUI_SingleEditDlg::onDeactivate()
 {

src/SMESHGUI/SMESHGUI_TransparencyDlg.cxx

@@ -191,7 +191,7 @@ void SMESHGUI_TransparencyDlg::ClickOnHelp()
 //=================================================================================
 // function : SetTransparency()
 // purpose  : Called when value of slider change
-//          : or the first time as initilisation
+//          : or the first time as initialisation
 //=================================================================================
 void SMESHGUI_TransparencyDlg::SetTransparency()
 {

src/SMESHGUI/SMESHGUI_XmlHandler.cxx

@@ -85,7 +85,7 @@ bool SMESHGUI_XmlHandler::startElement (const QString&, const QString&,
       myPluginName = atts.value("name");
       myServerLib  = atts.value("server-lib");
       myClientLib  = atts.value("gui-lib");
-      /* It's Need to tranlate lib name for WIN32 or X platform
+      /* It's Need to translate lib name for WIN32 or X platform
        * (only client lib, because server lib translates in SMESH_Gen_i::createHypothesis
        *  for normal work of *.py files )
        */

src/SMESHGUI/SMESH_msg_en.ts

@@ -7107,7 +7107,7 @@ It is impossible to read point coordinates from file</translation>
     <name>SMESHGUI_MeshOrderOp</name>
     <message>
         <source>SMESH_NO_CONCURENT_MESH</source>
-        <translation>No concurent sub-meshes detected</translation>
+        <translation>No concurrent sub-meshes detected</translation>
     </message>
 </context>
 <context>

src/SMESHUtils/SMESH_Tree.hxx

@@ -268,14 +268,14 @@ int SMESH_Tree<BND_BOX,NB_CHILDREN>::getHeight(const bool full) const
   if ( isLeaf() )
     return 1;
 
-  int heigth = 0;
+  int height = 0;
   for (int i = 0; i<NB_CHILDREN; i++)
   {
     int h = myChildren[i]->getHeight( false );
-    if ( h > heigth )
+    if ( h > height )
-      heigth = h;
+      height = h;
   }
-  return heigth + 1;
+  return height + 1;
 }
 
 #endif

src/SMESH_I/SMESH_2smeshpy.cxx

@@ -5056,7 +5056,7 @@ bool _pyStringFamily::Add( const char* str )
 
     _strings.erase( itLess, ++itMore );
   }
-  else // to few string to make a family fot them
+  else // too few string to make a family for them
   {
     _strings.insert( itStr, str );
   }

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -564,7 +564,7 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::ConvertHypothesisStatus
   switch (theStatus) {
   RETURNCASE( HYP_OK            );
   RETURNCASE( HYP_MISSING       );
-  RETURNCASE( HYP_CONCURENT     );
+  RETURNCASE( HYP_CONCURRENT    );
   RETURNCASE( HYP_BAD_PARAMETER );
   RETURNCASE( HYP_HIDDEN_ALGO   );
   RETURNCASE( HYP_HIDING_ALGO   );

src/SMESH_SWIG/smeshBuilder.py

@@ -231,7 +231,7 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh):
         reason = hypType + " of the same dimension is already assigned to this shape"
     elif status == HYP_BAD_DIM :
         reason = hypType + " mismatches the shape"
-    elif status == HYP_CONCURENT :
+    elif status == HYP_CONCURRENT :
         reason = "there are concurrent hypotheses on sub-shapes"
     elif status == HYP_BAD_SUBSHAPE :
         reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"

src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx

@@ -669,7 +669,7 @@ public:
     return true;
   }
   // -----------------------------------------------------------------------------
-  //! Make mesh on an adge using assigned 1d hyp or default nb of segments
+  //! Make mesh on an edge using assigned 1d hyp or default nb of segments
   bool ComputeCircularEdge( SMESH_Mesh&                   aMesh,
                             const StdMeshers_FaceSidePtr& aSide )
   {
@@ -697,7 +697,7 @@ public:
     return ok;
   }
   // -----------------------------------------------------------------------------
-  //! Make mesh on an adge using assigned 1d hyp or default nb of segments
+  //! Make mesh on an edge using assigned 1d hyp or default nb of segments
   bool EvaluateCircularEdge(SMESH_Mesh&                  aMesh,
                             const StdMeshers_FaceSidePtr aSide,
                             MapShapeNbElems&             aResMap)

src/StdMeshers/StdMeshers_ViscousLayers.cxx

@@ -8771,7 +8771,7 @@ void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
       }
     }
 
-    // // this coice is done only if ( !concaveVertices.empty() ) for Grids/smesh/bugs_19/X1
+    // // this choice is done only if ( !concaveVertices.empty() ) for Grids/smesh/bugs_19/X1
     // // where the nodes are smoothed too far along a sphere thus creating
     // // inverted _simplices
     // double dist[theNbSmooFuns];