Attachment #114651 for bug #155974

View | Details | Raw Unified | Return to bug 155974 | Differences between

and this patch





    /*!
     *  Create a face on the given wire.
     *  \param theWire closed Wire or Edge to build the face on.
     *  \param isPlanarWanted If TRUE, only planar face will be built.
     *                        If impossible, NULL object will be returned.
     *  \return New GEOM_Object, containing the created face.


    /*!
     *  Create a face on the given wires set.
     *  \param theWires List of closed wires or edges to build the face on.
     *  \param isPlanarWanted If TRUE, only planar face will be built.
     *                        If impossible, NULL object will be returned.
     *  \return New GEOM_Object, containing the created face.

			       in long        theShapeType,
			       in GEOM_Object theAx1,
			       in shape_state theState);
    /*!
     *  Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
     *  the specified plane by the certain way, defined through \a theState parameter.
     *  \param theShape Shape to find sub-shapes of.
     *  \param theShapeType Type of sub-shapes to be retrieved.
     *  \param theAx1 Vector (or line, or linear edge), specifying normal
     *                direction of the plane to find shapes on.
     *  \param thePnt Point specifying location of the plane to find shapes on.
     *  \param theState The state of the subshapes to find.
     *  \return List of all found sub-shapes.
     */
    ListOfGO GetShapesOnPlaneWithLocation (in GEOM_Object theShape,
					   in long        theShapeType,
					   in GEOM_Object theAx1,
					   in GEOM_Object thePnt,
					   in shape_state theState);



    /*!
     *  Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively

				    in long        theShapeType,
				    in GEOM_Object theAx1,
				    in shape_state theState);
				    
    /*!
     *  Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
     *  the specified plane by the certain way, defined through \a theState parameter.
     *  \param theShape Shape to find sub-shapes of.
     *  \param theShapeType Type of sub-shapes to be retrieved.
     *  \param theAx1 Vector (or line, or linear edge), specifying normal
     *                direction of the plane to find shapes on.
     *  \param thePnt Point specifying location of the plane to find shapes on.     
     *  \param theState The state of the subshapes to find.
     *  \return List of IDs of all found sub-shapes.
     */
    ListOfLong GetShapesOnPlaneWithLocationIDs (in GEOM_Object theShape,
						in long        theShapeType,
						in GEOM_Object theAx1,
						in GEOM_Object thePnt,
						in shape_state theState);

    /*!
     *  Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively

Lines 28-33 Link Here

(-)GEOM_SRC_3.2.2/src/BuildGUI/BuildGUI_FaceDlg.cxx (-5 / +16 lines)
28		28
29	#include "BuildGUI_FaceDlg.h"	29	#include "BuildGUI_FaceDlg.h"
30	#include "GEOMImpl_Types.hxx"	30	#include "GEOMImpl_Types.hxx"
		31	#include "TColStd_MapOfInteger.hxx"
31		32
32	#include "SUIT_Session.h"	33	#include "SUIT_Session.h"
33	#include "SalomeApp_Application.h"	34	#include "SalomeApp_Application.h"
Lines 64-70 Link Here
64		65
65	GroupWire = new DlgRef_1Sel1Check_QTD(this, "GroupWire");	66	GroupWire = new DlgRef_1Sel1Check_QTD(this, "GroupWire");
66	GroupWire->GroupBox1->setTitle(tr("GEOM_FACE_FFW"));	67	GroupWire->GroupBox1->setTitle(tr("GEOM_FACE_FFW"));
67	GroupWire->TextLabel1->setText(tr("GEOM_WIRES"));	68	GroupWire->TextLabel1->setText(tr("GEOM_OBJECTS"));
68	GroupWire->CheckButton1->setText(tr("GEOM_FACE_OPT"));	69	GroupWire->CheckButton1->setText(tr("GEOM_FACE_OPT"));
69	GroupWire->PushButton1->setPixmap(image1);	70	GroupWire->PushButton1->setPixmap(image1);
70		71
Lines 100-106 Link Here
100		101
101	GroupWire->CheckButton1->setChecked(TRUE);	102	GroupWire->CheckButton1->setChecked(TRUE);
102		103
103	globalSelection( GEOM_WIRE );	104	TColStd_MapOfInteger aMap;
		105	aMap.Add( GEOM_EDGE );
		106	aMap.Add( GEOM_WIRE );
		107	globalSelection( aMap );
104		108
105	/* signals and slots connections */	109	/* signals and slots connections */
106	connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));	110	connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
Lines 160-166 Link Here
160	if (!myWires.length())	164	if (!myWires.length())
161	return;	165	return;
162	if(aNbSel != 1)	166	if(aNbSel != 1)
163	aName = tr("%1_wires").arg(aNbSel);	167	aName = tr("%1_objects").arg(aNbSel);
164		168
165	myEditCurrentArgument->setText( aName );	169	myEditCurrentArgument->setText( aName );
166		170
Lines 178-184 Link Here
178	if (send != GroupWire->PushButton1)	182	if (send != GroupWire->PushButton1)
179	return;	183	return;
180		184
181	globalSelection( GEOM_WIRE );	185	TColStd_MapOfInteger aMap;
		186	aMap.Add( GEOM_EDGE );
		187	aMap.Add( GEOM_WIRE );
		188	globalSelection( aMap );
		189
182	myEditCurrentArgument = GroupWire->LineEdit1;	190	myEditCurrentArgument = GroupWire->LineEdit1;
183		191
184	myEditCurrentArgument->setFocus();	192	myEditCurrentArgument->setFocus();
Lines 195-201 Link Here
195	GEOMBase_Skeleton::ActivateThisDialog();	203	GEOMBase_Skeleton::ActivateThisDialog();
196	connect(((SalomeApp_Application*)(SUIT_Session::session()->activeApplication()))->selectionMgr(),	204	connect(((SalomeApp_Application*)(SUIT_Session::session()->activeApplication()))->selectionMgr(),
197	SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument())) ;	205	SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument())) ;
198	globalSelection( GEOM_WIRE );	206	TColStd_MapOfInteger aMap;
		207	aMap.Add( GEOM_EDGE );
		208	aMap.Add( GEOM_WIRE );
		209	globalSelection( aMap );
199	}	210	}
200		211
201		212




//  GEOM GEOMGUI : GUI for Geometry component
//
//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//
//  File   : EntityGUI_SketcherDlg.cxx
//  Author : Damien COQUERET
//  Module : GEOM
//  $Header$

#include "EntityGUI_SketcherDlg.h"
#include "Sketcher_Profile.hxx"


//=================================================================================
// class    : EntityGUI_SketcherDlg()
// purpose  : Constructs a EntityGUI_SketcherDlg which is a child of 'parent', with the
//            name 'name' and widget flags set to 'f'.
//            The dialog will by default be modeless, unless you set 'modal' to
//            TRUE to construct a modal dialog.

  buttonClose->setText(tr("GEOM_BUT_CLOSE_SKETCH"));
  buttonHelp->setText(tr("GEOM_BUT_HELP"));

  GroupVal->close(TRUE);
  GroupDest2->close(TRUE);
  GroupDest3->close(TRUE);


  Group1Spin->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
  Group1Spin->buttonUndo->setPixmap(image1);
  Group1Spin->buttonRedo->setPixmap(image2);
  QWidget::setTabOrder(Group1Spin->SpinBox_DX , Group1Spin->buttonApply);
  QWidget::setTabOrder(Group1Spin->buttonApply, Group1Spin->buttonUndo);
  QWidget::setTabOrder(Group1Spin->buttonUndo , Group1Spin->buttonRedo);

  Group2Spin = new EntityGUI_2Spin(this, "Group2Spin");
  Group2Spin->GroupBox1->setTitle(tr("GEOM_SKETCHER_VALUES"));
  Group2Spin->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
  Group2Spin->buttonUndo->setPixmap(image1);
  Group2Spin->buttonRedo->setPixmap(image2);
  QWidget::setTabOrder(Group2Spin->SpinBox_DX , Group2Spin->SpinBox_DY);
  QWidget::setTabOrder(Group2Spin->SpinBox_DY , Group2Spin->buttonApply);
  QWidget::setTabOrder(Group2Spin->buttonApply, Group2Spin->buttonUndo);
  QWidget::setTabOrder(Group2Spin->buttonUndo , Group2Spin->buttonRedo);

  Group3Spin = new EntityGUI_3Spin(this, "Group3Spin");
  Group3Spin->GroupBox1->setTitle(tr("GEOM_SKETCHER_VALUES"));
  Group3Spin->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
  Group3Spin->buttonUndo->setPixmap(image1);
  Group3Spin->buttonRedo->setPixmap(image2);
  QWidget::setTabOrder(Group3Spin->SpinBox_DX , Group3Spin->SpinBox_DY);
  QWidget::setTabOrder(Group3Spin->SpinBox_DY , Group3Spin->SpinBox_DZ);
  QWidget::setTabOrder(Group3Spin->SpinBox_DZ , Group3Spin->buttonApply);
  QWidget::setTabOrder(Group3Spin->buttonApply, Group3Spin->buttonUndo);
  QWidget::setTabOrder(Group3Spin->buttonUndo , Group3Spin->buttonRedo);

  Group4Spin = new EntityGUI_4Spin(this, "Group4Spin");
  Group4Spin->GroupBox1->setTitle(tr("GEOM_SKETCHER_VALUES"));
  Group4Spin->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
  Group4Spin->buttonUndo->setPixmap(image1);
  Group4Spin->buttonRedo->setPixmap(image2);
  QWidget::setTabOrder(Group4Spin->SpinBox_DX , Group4Spin->SpinBox_DY);
  QWidget::setTabOrder(Group4Spin->SpinBox_DY , Group4Spin->SpinBox_DZ);
  QWidget::setTabOrder(Group4Spin->SpinBox_DZ , Group4Spin->SpinBox_DS);
  QWidget::setTabOrder(Group4Spin->SpinBox_DS , Group4Spin->buttonApply);
  QWidget::setTabOrder(Group4Spin->buttonApply, Group4Spin->buttonUndo);
  QWidget::setTabOrder(Group4Spin->buttonUndo , Group4Spin->buttonRedo);

  Layout5->addMultiCellWidget(GroupPt, 1, 1, 0, 1);
  Layout5->addWidget(GroupD1, 1, 0);


  connect(myGeometryGUI, SIGNAL(SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
  connect(myGeometryGUI, SIGNAL(SignalCloseAllDialogs()), this, SLOT(ClickOnCancel()));

  // install event filter on spin-boxes to provide Apply action on Return pressed
  Group1Spin->SpinBox_DX->installEventFilter(this);
  Group2Spin->SpinBox_DX->installEventFilter(this);
  Group2Spin->SpinBox_DY->installEventFilter(this);
  Group3Spin->SpinBox_DX->installEventFilter(this);
  Group3Spin->SpinBox_DY->installEventFilter(this);
  Group3Spin->SpinBox_DZ->installEventFilter(this);
  Group4Spin->SpinBox_DX->installEventFilter(this);
  Group4Spin->SpinBox_DY->installEventFilter(this);
  Group4Spin->SpinBox_DZ->installEventFilter(this);
  Group4Spin->SpinBox_DS->installEventFilter(this);

  Init();
}


//=================================================================================
EntityGUI_SketcherDlg::~EntityGUI_SketcherDlg()
{
  myGeometryGUI->SetActiveDialogBox( 0 );
}


//=================================================================================
// function : eventFilter()
// purpose  : event filter for spin-boxes to provide Apply action on Return pressed
//=================================================================================
bool EntityGUI_SketcherDlg::eventFilter (QObject* object, QEvent* event)
{
  if (event->type() == QEvent::KeyPress) {
    QKeyEvent* ke = (QKeyEvent*)event;
    if (ke->key() == Key_Return) {
      if (object == Group1Spin->SpinBox_DX) {
        Group1Spin->buttonApply->animateClick();
        return true;
      } else if (object == Group2Spin->SpinBox_DX ||
                 object == Group2Spin->SpinBox_DY) {
        Group2Spin->buttonApply->animateClick();
        return true;
      } else if (object == Group3Spin->SpinBox_DX ||
                 object == Group3Spin->SpinBox_DY ||
                 object == Group3Spin->SpinBox_DZ) {
        Group3Spin->buttonApply->animateClick();
        return true;
      } else if (object == Group4Spin->SpinBox_DX ||
                 object == Group4Spin->SpinBox_DY ||
                 object == Group4Spin->SpinBox_DZ ||
                 object == Group4Spin->SpinBox_DS) {
        Group4Spin->buttonApply->animateClick();
        return true;
      }
    }
  }

  return EntityGUI_Skeleton_QTD::eventFilter(object, event);
}



//=================================================================================
void EntityGUI_SketcherDlg::InitClick()
{
  disconnect(myGeometryGUI->getApp()->selectionMgr(), 0, this, 0);

  Group1Sel->hide();
  Group1Spin->hide();

{
  InitClick();

  // Get setting of step value from file configuration
  double step = SUIT_Session::session()->resourceMgr()->doubleValue("Geometry", "SettingsGeomStep", 100.0);

  if ( myConstructorId == 0 )
  {  // SEGMENT
    if ( constructorId == 1 )
    {  // XY
      mySketchType = PT_ABS;
      Group2Spin->SpinBox_DX->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group2Spin->TextLabel1->setText(tr("GEOM_SKETCHER_X2"));
      Group2Spin->TextLabel2->setText(tr("GEOM_SKETCHER_Y2"));
      myX = 0.0;

    else if ( constructorId == 0 )
    {  // DXDY
      mySketchType = PT_RELATIVE;
      Group2Spin->SpinBox_DX->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group2Spin->TextLabel1->setText(tr("GEOM_SKETCHER_DX2"));
      Group2Spin->TextLabel2->setText(tr("GEOM_SKETCHER_DY2"));
      myDX = 0.0;

    {  // Selection
      mySketchType = PT_SEL;
      myEditCurrentArgument = Group1Sel->LineEdit1;
      connect(myGeometryGUI->getApp()->selectionMgr(),
	      SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
      Group1Sel->show();
      Group1Sel->buttonApply->setFocus();
      SelectionIntoArgument();

  InitClick();
  myAngle = 0.0;

  // Get setting of step value from file configuration
  double step = SUIT_Session::session()->resourceMgr()->doubleValue("Geometry", "SettingsGeomStep", 100.0);

  if ( myConstructorId == 0 )
  {  // SEGMENT
    myX = 0.0;

    if ( myConstructorDirId == 2 )
    {  // Angle
      Group2Spin->SpinBox_DX->RangeStepAndValidator(COORD_MIN, COORD_MAX, 5., 3);
      Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group2Spin->TextLabel1->setText(tr("GEOM_SKETCHER_ANGLE2"));
      Group2Spin->SpinBox_DX->SetValue(myAngle);
      Group2Spin->buttonApply->setFocus();

				Group2Spin->TextLabel2->setText(tr("GEOM_SKETCHER_Y3"));
				Group2Spin->SpinBox_DY->SetValue(myY);
      }
    }
    else if ( myConstructorDirId == 0 )
    {  // Perpendicular
      Group1Spin->show();

    {  // DXDY
      Group3Spin->SpinBox_DX->RangeStepAndValidator(COORD_MIN, COORD_MAX, 0.1, 3);
      Group3Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, 0.1, 3);
      Group3Spin->SpinBox_DZ->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
      Group3Spin->TextLabel1->setText(tr("GEOM_SKETCHER_VX2"));
      Group3Spin->TextLabel2->setText(tr("GEOM_SKETCHER_VY2"));
      myDX = 0.0;

      {  // Length
				mySketchType = DIR_ANGLE_LENGTH;
				Group3Spin->SpinBox_DX->RangeStepAndValidator(COORD_MIN, COORD_MAX, 5., 3);
				Group3Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
				Group3Spin->SpinBox_DZ->RangeStepAndValidator(COORD_MIN, COORD_MAX, 5., 3);
				Group3Spin->TextLabel1->setText(tr("GEOM_SKETCHER_ANGLE2"));
				Group3Spin->TextLabel2->setText(tr("GEOM_SKETCHER_RADIUS2"));

      if ( constructorId == 2 )
      {  // Length
				mySketchType = DIR_PER_LENGTH;
				Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
				Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, 5., 3);
				Group2Spin->TextLabel1->setText(tr("GEOM_SKETCHER_RADIUS2"));
				Group2Spin->TextLabel2->setText(tr("GEOM_SKETCHER_ANGLE2"));

      if ( constructorId == 2 )
      {  // Length
				mySketchType = DIR_TAN_LENGTH;
				Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, step, 3);
				Group2Spin->SpinBox_DY->RangeStepAndValidator(COORD_MIN, COORD_MAX, 5., 3);
				Group2Spin->TextLabel1->setText(tr("GEOM_SKETCHER_RADIUS2"));
				Group2Spin->TextLabel2->setText(tr("GEOM_SKETCHER_ANGLE2"));

			       tr( "GEOM_ERROR_STATUS" ), tr( "CANNOT_CLOSE" ), tr( "BUT_OK" ) );
      return;
    }

    QString Command = myCommand.join( "" ) + GetNewCommand();
    Sketcher_Profile aProfile (Command.ascii());


    TopoDS_Shape myShape;
    if ( aProfile.IsDone() )
      myShape = aProfile.GetShape();

    if(myShape.ShapeType() != TopAbs_VERTEX)
      myCommand.append( ":WW" );
  }
  else
    myIsAllAdded = true;

  if( myCommand.size() > 2 )

//=================================================================================
bool EntityGUI_SketcherDlg::ClickOnApply()
{
  ((QPushButton*)sender())->setFocus(); // to update value of currently edited spin-box (PAL11948)

  myCommand.append( GetNewCommand() );
  mySketchState = NEXT_POINT;


  GEOMBase_Helper::displayPreview();

  // Set focus to SpinBox_DX
  if (sender() == Group1Spin->buttonApply) {
    (Group1Spin->SpinBox_DX)->setFocus();
    (Group1Spin->SpinBox_DX)->selectAll();
  }
  else if (sender() == Group2Spin->buttonApply) {
    (Group2Spin->SpinBox_DX)->setFocus();
    (Group2Spin->SpinBox_DX)->selectAll();
  }
  else if (sender() == Group3Spin->buttonApply) {
    (Group3Spin->SpinBox_DX)->setFocus();
    (Group3Spin->SpinBox_DX)->selectAll();
  }
  else if (sender() == Group4Spin->buttonApply) {
    (Group4Spin->SpinBox_DX)->setFocus();
    (Group4Spin->SpinBox_DX)->selectAll();
  }

  return true;
}


void EntityGUI_SketcherDlg::ClickOnHelp()
{
  LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
  if (app)
    app->onHelpContextModule(myGeometryGUI ? app->moduleName(myGeometryGUI->moduleName()) : QString(""), myHelpFileName);
  else {
    SUIT_MessageBox::warn1(0, QObject::tr("WRN_WARNING"),


  if(myCommand.count() == 1) {
    mySketchState = FIRST_POINT;

    RadioButton1->setChecked(true);
    TypeClicked(0);



  setEnabled( false );
  globalSelection();
  disconnect(myGeometryGUI->getApp()->selectionMgr(), 0, this, 0);
  myGeometryGUI->SetActiveDialogBox(0);
}


  setEnabled(true);
  myGeometryGUI->SetActiveDialogBox((QDialog*)this);

  connect(myGeometryGUI->getApp()->selectionMgr(),
	  SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));

  //myGeometryGUI->SetState( 0 );
  globalSelection( GEOM_POINT );

void EntityGUI_SketcherDlg::closeEvent(QCloseEvent* e)
{
  //myGeometryGUI->SetState( -1 );
  disconnect(myGeometryGUI->getApp()->selectionMgr(), 0, this, 0);
  QDialog::closeEvent( e );
}


  }

  QString cmd;
  if( ( mySketchState != FIRST_POINT &&
        myLastX1 == myLastX2 && myLastY1 == myLastY2 ) || myIsAllAdded ) {
    cmd = myCommand.join( "" );

    if ( Group1Sel->isVisible() ) {
      Group1Sel->buttonApply->setEnabled(false);
      //Group1Sel->buttonApply->setFocus();
    }
    if ( Group1Spin->isVisible() ) {
      Group1Spin->buttonApply->setEnabled(false);
      //Group1Spin->buttonApply->setFocus();
    }
    if ( Group2Spin->isVisible() ) {
      Group2Spin->buttonApply->setEnabled(false);
      //Group2Spin->buttonApply->setFocus();
    }
    if ( Group3Spin->isVisible() ) {
      Group3Spin->buttonApply->setEnabled(false);
      //Group3Spin->buttonApply->setFocus();
    }
    if ( Group4Spin->isVisible() ) {
      Group4Spin->buttonApply->setEnabled(false);
      //Group4Spin->buttonApply->setFocus();
    }
  }
  else {


    if ( Group1Sel->isVisible() ) {
      Group1Sel->buttonApply->setEnabled(true);
      //Group1Sel->buttonApply->setFocus();
    }
    if ( Group1Spin->isVisible() ) {
      Group1Spin->buttonApply->setEnabled(true);
      //Group1Spin->buttonApply->setFocus();
    }
    if ( Group2Spin->isVisible() ) {
      Group2Spin->buttonApply->setEnabled(true);
      //Group2Spin->buttonApply->setFocus();
    }
    if ( Group3Spin->isVisible() ) {
      Group3Spin->buttonApply->setEnabled(true);
      //Group3Spin->buttonApply->setFocus();
    }
    if ( Group4Spin->isVisible() ) {
      Group4Spin->buttonApply->setEnabled(true);
      //Group4Spin->buttonApply->setFocus();
    }
  }

  gp_Ax3 myWPlane = myGeometryGUI->GetWorkingPlane();
  GEOM::ListOfDouble_var WPlane = new GEOM::ListOfDouble;
  WPlane->length(9);

  WPlane[7] = myWPlane.XDirection().Y();
  WPlane[8] = myWPlane.XDirection().Z();

  GEOM::GEOM_Object_var anObj =
    GEOM::GEOM_ICurvesOperations::_narrow( getOperation() )->MakeSketcher( cmd.latin1(), WPlane );

  if ( !anObj->_is_nil() )
    objects.push_back( anObj._retn() );

      ClickOnHelp();
    }
}








//  GEOM GEOMGUI : GUI for Geometry component
//
//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//

// purpose  :
//=================================================================================
class EntityGUI_SketcherDlg : public EntityGUI_Skeleton_QTD, public GEOMBase_Helper
{
    Q_OBJECT

public:

			  const char* name = 0, bool modal = FALSE, WFlags fl = 0);
    ~EntityGUI_SketcherDlg();

    bool eventFilter (QObject* object, QEvent* event);

protected:
    // redefined from GEOMBase_Helper
    virtual GEOM::GEOM_IOperations_ptr createOperation();

    virtual bool execute( ObjectList& objects );

    void closeEvent( QCloseEvent* e );
    void keyPressEvent( QKeyEvent* e );

private :
    void Init();

Lines 57-62 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMBase/Makefile.in (+1 lines)
57	SALOMEDS.idl \	57	SALOMEDS.idl \
58	SALOMEDS_Attributes.idl \	58	SALOMEDS_Attributes.idl \
59	SALOME_GenericObj.idl \	59	SALOME_GenericObj.idl \
		60	SALOME_Component.idl \
60	GEOM_Gen.idl	61	GEOM_Gen.idl
61		62
62	LIB_SERVER_IDL =	63	LIB_SERVER_IDL =





#: GeometryGUI_FaceDlg.cxx:78
msgid "GEOM_FACE_FFW"
msgstr "Face from a closed wire and edge"

#: GeometryGUI_FaceDlg.cxx:103
msgid "GEOM_FACE_OPT"


msgid "PREF_TAB_SETTINGS"
msgstr "Settings"

msgid "ERROR_SHAPE_TYPE"
msgstr "Object of incorrect type selected!\nPlease, select face, shell or solid and try again"

msgid "DEP_OBJECT"
msgstr "Selected object has been used to create another one\n It can't be deleted "




//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//


//=======================================================================
// function : ClientSObjectToObject
// purpose  :
//=======================================================================
CORBA::Object_var GeometryGUI::ClientSObjectToObject (_PTR(SObject) theSObject)
{


//=======================================================================
// function : ClientStudyToStudy
// purpose  :
//=======================================================================
SALOMEDS::Study_var GeometryGUI::ClientStudyToStudy (_PTR(Study) theStudy)
{

  SalomeApp_Module( "GEOM" )
{
  if ( CORBA::is_nil( myComponentGeom ) )
  {
    SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA( getApp()->namingService() );
    Engines::Component_var comp = ls->FindOrLoad_Component( "FactoryServer", "GEOM" );
    myComponentGeom  = GEOM::GEOM_Gen::_narrow( comp );
  }

  myState           = -1;
  myActiveDialogBox = 0;
  myFatherior       = "";

  bool ViewVTK = ( window && window->getViewManager()->getType() == SVTK_Viewer::Type() );
  // if current viewframe is not of OCC and not of VTK type - return immediately
  // fix for IPAL8958 - allow some commands to execute even when NO viewer is active (rename for example)
  bool NotViewerDependentCommand = ( id == 901 || id == 216 || id == 213 );
  if ( !ViewOCC && !ViewVTK && !NotViewerDependentCommand )
      return;


  else if( id == 503 ||   // MENU OPERATION - PARTITION
	   id == 504 ||   // MENU OPERATION - ARCHIMEDE
	   id == 505 ||   // MENU OPERATION - FILLET
	   id == 506 ||   // MENU OPERATION - CHAMFER
	   id == 507 ) {  // MENU OPERATION - CLIPPING RANGE
#ifndef WNT
	library = getLibrary( "libOperationGUI.so" );

  }

  // call method of corresponding GUI library
  if ( library )
    library->OnGUIEvent( id, desk );
  else
    SUIT_MessageBox::error1( desk, tr( "GEOM_ERROR" ), tr( "GEOM_ERR_LIB_NOT_FOUND" ), tr( "GEOM_BUT_OK" ) );
}


// purpose  : Manages mouse move events [static]
//=================================================================================
void GeometryGUI::OnMouseMove( SUIT_ViewWindow* win, QMouseEvent* pe )
{
  GUIMap::Iterator it;
  bool bOk = true;
  for ( it = myGUIMap.begin(); it != myGUIMap.end(); ++it ) {

{
  QMenuBar*     Mb = parent->getMainMenuBar();
  SUIT_Study*   ActiveStudy = application()->activeStudy();

// Wireframe or Shading
  int DisplayMode = 0;
  SUIT_ViewWindow* window = application()->desktop()->activeWindow();

  //  if(!AddInStudy.isEmpty())
  //    Settings_AddInStudy = AddInStudy.toInt();
  //  else

  Settings_AddInStudy = 1;
  Mb->setItemChecked(411, Settings_AddInStudy);

  // step value
  QString S = QAD_CONFIG->getSetting("Geometry:SettingsGeomStep");
  if(S.isEmpty())
    QAD_CONFIG->addSetting("Geometry:SettingsGeomStep", "100");

  // isos
  int count = ActiveStudy->getStudyFramesCount();
  for(int i = 0; i < count; i++) {
    if(ActiveStudy->getStudyFrame(i)->getTypeView() == VIEW_OCC) {

  GUIMap::Iterator it;
  for ( it = myGUIMap.begin(); it != myGUIMap.end(); ++it )
    bOk = bOk && it.data()->SetSettings( parent );

  // MZN: Enable/disable "Clipping range" menu item(from GEOM_CLIPPING variable)
  if (getenv( "GEOM_CLIPPING" ) == NULL)
    {
      QMenuItem* mi = Mb->findItem(50);
      if (mi && mi->popup())
      mi->popup()->removeItem(507);
    }

  return bOk;
}
*/

//=======================================================================
// function : createGeomAction
// purpose  :
//=======================================================================
void GeometryGUI::createGeomAction( const int id, const QString& po_id, const QString& icon_id, const int key, const bool toggle  )
{

  QWidget* parent = application()->desktop();
  SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  QPixmap pix;
  if ( icon_id.length() )
    pix = resMgr->loadPixmap( "GEOM", tr( icon_id ) );
  else
    pix = resMgr->loadPixmap( "GEOM", tr( QString( "ICO_" )+po_id ), false );

  createGeomAction( 609, "CHECK_FREE_BNDS" );
  createGeomAction( 610, "CHECK_FREE_FACES" );
  createGeomAction( 611, "CHANGE_ORIENTATION" );

  createGeomAction( 708, "POINT_COORDS" );
  createGeomAction( 701, "BASIC_PROPS" );
  createGeomAction( 702, "MASS_CENTER" );

  createGeomAction( 7072, "CHECK_COMPOUND" );

  createGeomAction( 5103, "CHECK_GEOMETRY" );

  createGeomAction( 412, "SHADING_COLOR" );
  createGeomAction( 413, "ISOS" );
  createGeomAction( 414, "STEP_VALUE" );

  createMenu( 4020, basicId, -1 );

  int primId = createMenu( tr( "MEN_PRIMITIVES" ), newEntId, -1 );
  createMenu( 4021, primId, -1 );
  createMenu( 4022, primId, -1 );
  createMenu( 4023, primId, -1 );
  createMenu( 4024, primId, -1 );
  createMenu( 4025, primId, -1 );

  int genId = createMenu( tr( "MEN_GENERATION" ), newEntId, -1 );
  createMenu( 4031, genId, -1 );
  createMenu( 4032, genId, -1 );
  createMenu( 4033, genId, -1 );
  createMenu( 4034, genId, -1 );
  createMenu( separator(), newEntId, -1 );

  int groupId = createMenu( tr( "MEN_GROUP" ), newEntId, -1 );
  createMenu( 800, groupId, -1 );
  createMenu( 801, groupId, -1 );
  createMenu( separator(), newEntId, -1 );

  int blocksId = createMenu( tr( "MEN_BLOCKS" ), newEntId, -1 );
  createMenu( 9997, blocksId, -1 );
  createMenu( 9999, blocksId, -1 );

  createMenu( separator(), newEntId, -1 );
  createMenu( 404, newEntId, -1 );
  createMenu( separator(), newEntId, -1 );
  createMenu( 407, newEntId, -1 );

  int buildId = createMenu( tr( "MEN_BUILD" ), newEntId, -1 );
  createMenu( 4081, buildId, -1 );
  createMenu( 4082, buildId, -1 );
  createMenu( 4083, buildId, -1 );
  createMenu( 4084, buildId, -1 );
  createMenu( 4085, buildId, -1 );
  createMenu( 4086, buildId, -1 );

  int operId = createMenu( tr( "MEN_OPERATIONS" ), -1, -1, 10 );

  int boolId = createMenu( tr( "MEN_BOOLEAN" ), operId, -1 );
  createMenu( 5011, boolId, -1 );
  createMenu( 5012, boolId, -1 );
  createMenu( 5013, boolId, -1 );
  createMenu( 5014, boolId, -1 );

  int transId = createMenu( tr( "MEN_TRANSFORMATION" ), operId, -1 );
  createMenu( 5021, transId, -1 );
  createMenu( 5022, transId, -1 );
  createMenu( 5023, transId, -1 );
  createMenu( 5024, transId, -1 );
  createMenu( 5025, transId, -1 );
  createMenu( 5026, transId, -1 );
  createMenu( separator(), transId, -1 );
  createMenu( 5027, transId, -1 );
  createMenu( 5028, transId, -1 );

  createMenu( 503, operId, -1 );
  createMenu( 504, operId, -1 );
  createMenu( separator(), operId, -1 );
  createMenu( 505, transId, -1 );
  createMenu( 506, transId, -1 );
  //createMenu( 507, transId, -1 );

  int blockId = createMenu( tr( "MEN_BLOCKS" ), operId, -1 );
  createMenu( 9998, blockId, -1 );
  createMenu( 9995, blockId, -1 );
  createMenu( 99991, blockId, -1 );

  int repairId = createMenu( tr( "MEN_REPAIR" ), -1, -1, 10 );
  createMenu( 605, repairId, -1 );
  createMenu( 603, repairId, -1 );
  createMenu( 606, repairId, -1 );
  createMenu( 607, repairId, -1 );
  createMenu( 604, repairId, -1 );
  createMenu( 601, repairId, -1 );
  createMenu( 602, repairId, -1 );
  createMenu( 608, repairId, -1 );
  createMenu( 609, repairId, -1 );
  createMenu( 610, repairId, -1 );
  createMenu( 611, repairId, -1 );

  int measurId = createMenu( tr( "MEN_MEASURES" ), -1, -1, 10 );
  createMenu( 708, measurId, -1 );
  createMenu( 701, measurId, -1 );
  createMenu( separator(), measurId, -1 );
  createMenu( 702, measurId, -1 );
  createMenu( 703, measurId, -1 );
  createMenu( separator(), measurId, -1 );

  int dimId = createMenu( tr( "MEN_DIMENSIONS" ), measurId, -1 );
  createMenu( 7041, dimId, -1 );
  createMenu( 7042, dimId, -1 );
  createMenu( separator(), measurId, -1 );

  createMenu( 705, measurId, -1 );
  createMenu( separator(), measurId, -1 );
  createMenu( 706, measurId, -1 );
  createMenu( 707, measurId, -1 );
  createMenu( 7072, measurId, -1 );

  int toolsId = createMenu( tr( "MEN_TOOLS" ), -1, -1, 50 );
  createMenu( separator(), toolsId, -1 );
  createMenu( 5103, toolsId, -1 );

  //int prefId = createMenu( tr( "MEN_PREFERENCES" ), -1, -1, 50 );
  //createMenu( separator(), prefId, -1 );
  //int geomId = createMenu( tr( "MEN_PREFERENCES_GEOM" ), prefId, -1 );
  //createMenu( 412, geomId, -1 );
  //createMenu( 413, geomId, -1 );
  //createMenu( 414, geomId, -1 );
  //createMenu( separator(), prefId, -1 );

  int viewId = createMenu( tr( "MEN_VIEW" ), -1, -1 );
  createMenu( separator(), viewId, -1 );

  int dispmodeId = createMenu( tr( "MEN_DISPLAY_MODE" ), viewId, -1 );
  createMenu( 211, dispmodeId, -1 );

  createMenu( separator(), viewId, -1 );
  createMenu( 212, viewId, -1 );
  createMenu( 214, viewId, -1 );
  createMenu( separator(), viewId, -1 );

/*

  because of these items are accessible through object browser and viewers
  we have removed they from main menu

  createMenu( 216, viewId, -1 );
  createMenu( 213, viewId, -1 );
  createMenu( 215, viewId, -1 );
*/


  createTool( 4020, basicTbId );

  int primTbId = createTool( tr( "TOOL_PRIMITIVES" ) );
  createTool( 4021, primTbId );
  createTool( 4022, primTbId );
  createTool( 4023, primTbId );
  createTool( 4024, primTbId );
  createTool( 4025, primTbId );

  int boolTbId = createTool( tr( "TOOL_BOOLEAN" ) );
  createTool( 5011, boolTbId );
  createTool( 5012, boolTbId );
  createTool( 5013, boolTbId );
  createTool( 5014, boolTbId );

  int genTbId = createTool( tr( "TOOL_GENERATION" ) );
  createTool( 4031, genTbId );
  createTool( 4032, genTbId );
  createTool( 4033, genTbId );
  createTool( 4034, genTbId );

  int transTbId = createTool( tr( "TOOL_TRANSFORMATION" ) );
  createTool( 5021, transTbId );
  createTool( 5022, transTbId );
  createTool( 5023, transTbId );
  createTool( 5024, transTbId );
  createTool( 5025, transTbId );
  createTool( 5026, transTbId );
  createTool( separator(), transTbId );
  createTool( 5027, transTbId );
  createTool( 5028, transTbId );

  // ---- create popup menus --------------------------

  setMenuShown( false );
  setToolShown( false );

  disconnect( application()->desktop(), SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
	     this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ) );

  EmitSignalCloseAllDialogs();

  GUIMap::Iterator it;
  for ( it = myGUIMap.begin(); it != myGUIMap.end(); ++it )
    it.data()->deactivate();

  // Unset actions accelerator keys
  //action(111)->setAccel(QKeySequence()); // Import

  if( nbSel == 0 ) {
    ////// NOTHING SELECTED
    popup->clear();
  }
  else if ( nbSel == 1 ) {
    ////// SINGLE OBJECT SELECTION
    if ( parentComponent != parent->getActiveComponent() )  {


//=======================================================================
// function : GeometryGUI::BuildPresentation()
// purpose  :
//=======================================================================
void GeometryGUI::BuildPresentation( const Handle(SALOME_InteractiveObject)& io, SUIT_ViewWindow* win )
{


  const bool ViewOCC = ( win->getViewManager()->getType() == OCCViewer_Viewer::Type() );
//  const bool ViewVTK = ( win->getViewManager()->getType() == SVTK_Viewer::Type() );

  // disable non-OCC viewframe menu commands
//  action( 404 )->setEnabled( ViewOCC ); // SKETCHER
  action( 603 )->setEnabled( ViewOCC ); // SuppressFace


  addPreference( tr( "PREF_SHADING_COLOR" ), genGroup,
		 LightApp_Preferences::Color, "Geometry", "shading_color" );

  addPreference( tr( "PREF_WIREFRAME_COLOR" ), genGroup,
		 LightApp_Preferences::Color, "Geometry", "wireframe_color" );

  addPreference( tr( "PREF_FREE_BOUND_COLOR" ), genGroup,
		 LightApp_Preferences::Color, "Geometry", "free_bound_color" );

  addPreference( tr( "PREF_LINE_COLOR"), genGroup,
		 LightApp_Preferences::Color, "Geometry", "line_color" );

  addPreference( tr( "PREF_POINT_COLOR"), genGroup,
		 LightApp_Preferences::Color, "Geometry", "point_color" );

  addPreference( tr( "PREF_ISOS_COLOR" ), genGroup,
		 LightApp_Preferences::Color, "Geometry", "isos_color" );

  int step = addPreference( tr( "PREF_STEP_VALUE" ), genGroup,
			    LightApp_Preferences::IntSpin, "Geometry", "SettingsGeomStep" );


  QStringList aModesList;
  aModesList.append( tr("MEN_WIREFRAME") );
  aModesList.append( tr("MEN_SHADING") );

  QValueList<QVariant> anIndexesList;
  anIndexesList.append(0);
  anIndexesList.append(1);

  setPreferenceProperty( dispmode, "strings", aModesList );
  setPreferenceProperty( dispmode, "indexes", anIndexesList );

  // Set property for step value for spinboxes
  setPreferenceProperty( step, "min", 0.001 );
  setPreferenceProperty( step, "max", 10000 );
  setPreferenceProperty( step, "precision", 3 );

}

void GeometryGUI::preferencesChanged( const QString& section, const QString& param )
{
  if (section == "Geometry") {
    SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
    if (param == QString("SettingsGeomStep")) {
      double spin_step = aResourceMgr->doubleValue(section, param, 100.);
      EmitSignalDefaultStepValueChanged(spin_step);
    }
  }
}

LightApp_Displayer* GeometryGUI::displayer()

Lines 439-445 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMGUI/GeometryGUI_Swig.cxx (-1 / +1 lines)
439	ite.Value()->SetColor(CSFColor);	439	ite.Value()->SetColor(CSFColor);
440	if (ite.Value()->IsKind(STANDARD_TYPE(GEOM_AISShape)))	440	if (ite.Value()->IsKind(STANDARD_TYPE(GEOM_AISShape)))
441	Handle(GEOM_AISShape)::DownCast(ite.Value())->SetShadingColor(CSFColor);	441	Handle(GEOM_AISShape)::DownCast(ite.Value())->SetShadingColor(CSFColor);
442	ite.Value()->Redisplay(Standard_True);	442	ic->Redisplay(ite.Value(), true, true);
443	if (myUpdateViewer)	443	if (myUpdateViewer)
444	occViewer->update();	444	occViewer->update();
445	break;	445	break;




          if (!BO.IsDone()) {
            StdFail_NotDone::Raise("Common operation can not be performed on the given shapes");
          }
          if (isCompound) {
            TopoDS_Shape aStepResult = BO.Shape();

            // check result of this step: if it is a compound (boolean operations
            // allways return a compound), we add all sub-shapes of it.
            // This allows to avoid adding empty compounds,
            // resulting from COMMON on two non-intersecting shapes.
            if (aStepResult.ShapeType() == TopAbs_COMPOUND) {
              TopoDS_Iterator aCompIter (aStepResult);
              for (; aCompIter.More(); aCompIter.Next()) {
                // add shape in a result
                B.Add(C, aCompIter.Value());
              }
            }
            else {
              // add shape in a result
              B.Add(C, aStepResult);
            }
          }
          else
            aShape = BO.Shape();
        }

          }
          aCut = BO.Shape();
        }
        if (isCompound) {
          // check result of this step: if it is a compound (boolean operations
          // allways return a compound), we add all sub-shapes of it.
          // This allows to avoid adding empty compounds,
          // resulting from CUT of parts
          if (aCut.ShapeType() == TopAbs_COMPOUND) {
            TopoDS_Iterator aCompIter (aCut);
            for (; aCompIter.More(); aCompIter.Next()) {
              // add shape in a result
              B.Add(C, aCompIter.Value());
            }
          }
          else {
            // add shape in a result
            B.Add(C, aCut);
          }
        }
        else
          aShape = aCut;
      }

          if (!BO.IsDone()) {
            StdFail_NotDone::Raise("Section operation can not be performed on the given shapes");
          }
          if (isCompound) {
            TopoDS_Shape aStepResult = BO.Shape();

            // check result of this step: if it is a compound (boolean operations
            // allways return a compound), we add all sub-shapes of it.
            // This allows to avoid adding empty compounds,
            // resulting from SECTION on two non-intersecting shapes.
            if (aStepResult.ShapeType() == TopAbs_COMPOUND) {
              TopoDS_Iterator aCompIter (aStepResult);
              for (; aCompIter.More(); aCompIter.Next()) {
                // add shape in a result
                B.Add(C, aCompIter.Value());
              }
            }
            else {
              // add shape in a result
              B.Add(C, aStepResult);
            }
          }
          else
            aShape = BO.Shape();
        }





//=============================================================================
/*!
 *  GetShapesOnPlaneWithLocation
 */
//=============================================================================
Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetShapesOnPlaneWithLocation
                                        (const Handle(GEOM_Object)& theShape,
                                         const Standard_Integer     theShapeType,
                                         const Handle(GEOM_Object)& theAx1,
					 const Handle(GEOM_Object)& thePnt,
                                         const GEOMAlgo_State       theState)
{
  SetErrorCode(KO);

  if (theShape.IsNull() || theAx1.IsNull() || thePnt.IsNull()) return NULL;

  TopoDS_Shape aShape = theShape->GetValue();
  TopoDS_Shape anAx1  = theAx1->GetValue();
  TopoDS_Shape anPnt = thePnt->GetValue();

  if (aShape.IsNull() || anAx1.IsNull() || anPnt.IsNull()) return NULL;

  TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
  if ( !checkTypeShapesOn( theShapeType ))
    return NULL;

  // Create plane
  if ( anAx1.ShapeType() != TopAbs_EDGE || anPnt.ShapeType() != TopAbs_VERTEX ) return NULL;
  TopoDS_Vertex V1, V2, V3;
  TopoDS_Edge anEdge = TopoDS::Edge(anAx1);
  TopExp::Vertices(anEdge, V1, V2, Standard_True);

  if (V1.IsNull() || V2.IsNull()) {
    SetErrorCode("Bad edge given for the plane normal vector");
    return NULL;
  }
  V3 = TopoDS::Vertex(anPnt);

  if(V3.IsNull()) {
    SetErrorCode("Bad vertex given for the plane location");
      return NULL;
  }
  gp_Pnt aLoc = BRep_Tool::Pnt(V3);
  gp_Vec aVec(BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2));

  if (aVec.Magnitude() < Precision::Confusion()) {
     SetErrorCode("Vector with null magnitude given");
    return NULL;
  }
  Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);

  if ( aPlane.IsNull() )
    return NULL;
  
  // Find objects
  TCollection_AsciiString anAsciiList;
  Handle(TColStd_HSequenceOfTransient) aSeq;
  aSeq = getShapesOnSurface( aPlane, theShape, aShapeType, theState, anAsciiList );
  if ( aSeq.IsNull() || aSeq->Length() == 0 )
    return NULL;

  // Make a Python command

  Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast( aSeq->Value( 1 ));
  Handle(GEOM_Function) aFunction = anObj->GetLastFunction();

  GEOM::TPythonDump(aFunction) << "[" << anAsciiList.ToCString()
    << "] = geompy.GetShapesOnPlaneWithLocation(" << theShape << ", "
    << aShapeType << ", " << theAx1 << ", "<< thePnt <<", " << theState << ")";

  SetErrorCode(OK);
  return aSeq;
}

//=============================================================================
/*!
 *  GetShapesOnCylinder
 */
//=============================================================================


//=============================================================================
/*!
 *  GetShapesOnPlaneWithLocationIDs
 */
//=============================================================================
Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::GetShapesOnPlaneWithLocationIDs
                                        (const Handle(GEOM_Object)& theShape,
                                         const Standard_Integer     theShapeType,
                                         const Handle(GEOM_Object)& theAx1,
					 const Handle(GEOM_Object)& thePnt,
                                         const GEOMAlgo_State       theState)
{
  SetErrorCode(KO);

  if (theShape.IsNull() || theAx1.IsNull() || thePnt.IsNull()) return NULL;

  TopoDS_Shape aShape = theShape->GetValue();
  TopoDS_Shape anAx1  = theAx1->GetValue();
  TopoDS_Shape anPnt  = thePnt->GetValue();

  if (aShape.IsNull() || anAx1.IsNull() || anPnt.IsNull()) return NULL;

  TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
  if ( !checkTypeShapesOn( aShapeType ))
    return NULL;

  // Create plane
  if (anAx1.ShapeType() != TopAbs_EDGE || anPnt.ShapeType() != TopAbs_VERTEX) return NULL;
  TopoDS_Edge anEdge = TopoDS::Edge(anAx1);
  TopoDS_Vertex V1, V2, V3;
  TopExp::Vertices(anEdge, V1, V2, Standard_True);
  if (V1.IsNull() || V2.IsNull()) {
    SetErrorCode("Bad edge given for the plane normal vector");
    return NULL;
  }
  V3 = TopoDS::Vertex(anPnt);
  if(V3.IsNull()) {
    SetErrorCode("Bad vertex given for the plane location");
      return NULL;
  }
  gp_Pnt aLoc = BRep_Tool::Pnt(V3);
  gp_Vec aVec(BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2));
  if (aVec.Magnitude() < Precision::Confusion()) {
    SetErrorCode("Vector with null magnitude given");
    return NULL;
  }
  
  Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);  
  if ( aPlane.IsNull() )
    return NULL;

  // Find object IDs
  Handle(TColStd_HSequenceOfInteger) aSeq;
  aSeq = getShapesOnSurfaceIDs( aPlane, aShape, aShapeType, theState );

  // The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
  Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();

  // Make a Python command
  GEOM::TPythonDump(aFunction, /*append=*/true)
    << "listShapesOnPlane = geompy.GetShapesOnPlaneWithLocationIDs"
    << "(" << theShape << ", " << aShapeType << ", " << theAx1 << ", "<< thePnt << ", "  << theState << ")";

  SetErrorCode(OK);
  return aSeq;
}

//=============================================================================
/*!
 *  GetShapesOnCylinderIDs
 */
//=============================================================================

Lines 97-102 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMImpl/GEOMImpl_IShapesOperations.hxx (+13 lines)
97	const Handle(GEOM_Object)& theAx1,	97	const Handle(GEOM_Object)& theAx1,
98	const GEOMAlgo_State theState);	98	const GEOMAlgo_State theState);
99		99
		100	Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnPlaneWithLocation (const Handle(GEOM_Object)& theShape,
		101	const Standard_Integer theShapeType,
		102	const Handle(GEOM_Object)& theAx1,
		103	const Handle(GEOM_Object)& thePnt,
		104	const GEOMAlgo_State theState);
		105
		106
100	Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnCylinder (const Handle(GEOM_Object)& theShape,	107	Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnCylinder (const Handle(GEOM_Object)& theShape,
101	const Standard_Integer theShapeType,	108	const Standard_Integer theShapeType,
102	const Handle(GEOM_Object)& theAxis,	109	const Handle(GEOM_Object)& theAxis,
Lines 114-119 Link Here
114	const Handle(GEOM_Object)& theAx1,	121	const Handle(GEOM_Object)& theAx1,
115	const GEOMAlgo_State theState);	122	const GEOMAlgo_State theState);
116		123
		124	Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnPlaneWithLocationIDs (const Handle(GEOM_Object)& theShape,
		125	const Standard_Integer theShapeType,
		126	const Handle(GEOM_Object)& theAx1,
		127	const Handle(GEOM_Object)& thePnt,
		128	const GEOMAlgo_State theState);
		129
117	Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnCylinderIDs (const Handle(GEOM_Object)& theShape,	130	Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnCylinderIDs (const Handle(GEOM_Object)& theShape,
118	const Standard_Integer theShapeType,	131	const Standard_Integer theShapeType,
119	const Handle(GEOM_Object)& theAxis,	132	const Handle(GEOM_Object)& theAxis,




      if (!MW.IsDone()) {
        Standard_ConstructionError::Raise("Wire construction failed");
      }
          W = MW;
      W = MW;
    }
    else {
      Standard_NullObject::Raise

      Standard_ConstructionError::Raise("No wires given");
    }

    // first wire or edge
    Handle(GEOM_Function) aRefWire = Handle(GEOM_Function)::DownCast(aShapes->Value(1));
    TopoDS_Shape aWire = aRefWire->GetValue();
    if (aWire.IsNull()) Standard_NullObject::Raise("Argument Shape is null");
    TopoDS_Wire W1;
    if(aWire.ShapeType() == TopAbs_WIRE) {
      W1 = TopoDS::Wire(aWire);
    }
    else if(aWire.ShapeType() == TopAbs_EDGE && aWire.Closed()) {
      BRepBuilderAPI_MakeWire MW;
      MW.Add(TopoDS::Edge(aWire));
      if (!MW.IsDone()) {
        Standard_ConstructionError::Raise("Wire construction failed");
      }
          W1 = MW;
    }
    else {
      Standard_NullObject::Raise
        ("Shape for face construction is neither a wire nor closed edge");
    }
    TopoDS_Wire W = TopoDS::Wire(aWire);

    // basic face
    TopoDS_Shape FFace;
    GEOMImpl_Block6Explorer::MakeFace(W1, aCI.GetIsPlanar(), FFace);
    if (FFace.IsNull()) {
      Standard_ConstructionError::Raise("Face construction failed");
    }

        Handle(GEOM_Function) aRefWire_i =
          Handle(GEOM_Function)::DownCast(aShapes->Value(ind));
        TopoDS_Shape aWire_i = aRefWire_i->GetValue();
        if (aWire_i.IsNull()) Standard_NullObject::Raise("Argument Shape is null");
	TopoDS_Wire W_i;
	if(aWire_i.ShapeType() == TopAbs_WIRE) {
	  W_i = TopoDS::Wire(aWire_i);
	}
	else if(aWire_i.ShapeType() == TopAbs_EDGE && aWire_i.Closed()) {
	  BRepBuilderAPI_MakeWire MW1;
	  MW1.Add(TopoDS::Edge(aWire_i));
	  if (!MW1.IsDone()) {
	    Standard_ConstructionError::Raise("Wire construction failed");
	  }
          W_i = MW1;  
	}
	else {
	  Standard_NullObject::Raise
	    ("Shape for face construction is neither a wire nor closed edges");
	}
	FR.Add(W_i);
      }

      FR.Perform();

Lines 288-293 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMToolsGUI/GEOMToolsGUI.cxx (+27 lines)
288	_PTR(GenericAttribute) anAttr;	288	_PTR(GenericAttribute) anAttr;
289	GEOM_Displayer* disp = new GEOM_Displayer( appStudy );	289	GEOM_Displayer* disp = new GEOM_Displayer( appStudy );
290		290
		291	_PTR(SComponent) aGeom ( aStudy->FindComponent("GEOM") );
		292	if ( !aGeom )
		293	return;
		294
291	// MAIN LOOP OF SELECTED OBJECTS	295	// MAIN LOOP OF SELECTED OBJECTS
292	for ( SALOME_ListIteratorOfListIO It( selected ); It.More(); It.Next() ) {	296	for ( SALOME_ListIteratorOfListIO It( selected ); It.More(); It.Next() ) {
293		297
Lines 301-306 Link Here
301	if ( !strcmp( obj->GetIOR().c_str(), geomIOR ) )	305	if ( !strcmp( obj->GetIOR().c_str(), geomIOR ) )
302	continue;	306	continue;
303		307
		308	//If the object has been used to create another one,then it can't be deleted
		309	_PTR(ChildIterator) it (aStudy->NewChildIterator(aGeom));
		310	for ( it->InitEx( true ); it->More(); it->Next() ) {
		311	_PTR(SObject) chobj (it->Value());
		312	CORBA::Object_var corbaObj = GeometryGUI::ClientSObjectToObject(chobj);
		313	GEOM::GEOM_Object_var geomObj = GEOM::GEOM_Object::_narrow( corbaObj );
		314	if( CORBA::is_nil(geomObj) )
		315	continue;
		316	GEOM::ListOfGO_var list = geomObj->GetDependency();
		317	if( list->length() > 1 )
		318	for(int i = 0; i < list->length(); i++ ){
		319	CORBA::Object_var corbaObj_rem = GeometryGUI::ClientSObjectToObject(obj);
		320	GEOM::GEOM_Object_var geomObj_rem = GEOM::GEOM_Object::_narrow( corbaObj_rem );
		321	if( list[i]->_is_equivalent( geomObj_rem ) ){
		322	SUIT_MessageBox::warn1 ( app->desktop(),
		323	QObject::tr("WRN_WARNING"),
		324	QObject::tr("DEP_OBJECT"),
		325	QObject::tr("BUT_OK") );
		326	return;
		327	}
		328	}
		329	}
		330
304	RemoveObjectWithChildren(obj, aStudy, views, disp);	331	RemoveObjectWithChildren(obj, aStudy, views, disp);
305		332
306	// Remove objects from Study	333	// Remove objects from Study




// Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com


  _impl = new ::GEOMImpl_Gen;

  //PAL10867: disable signals catching with "noexcepthandler" option
  char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
  if (!envNoCatchSignals || !atoi(envNoCatchSignals))
  {
    //work around PAL12004, PAL12628
    //OSD::SetSignal( true );
    bool raiseFPE;
#ifdef _DEBUG_
    raiseFPE = true;
    char* envDisableFPE = getenv("DISABLE_FPE");
    if (envDisableFPE && atoi(envDisableFPE))
      raiseFPE = false;
#else
    raiseFPE = false;
#endif
    OSD::SetSignal( raiseFPE );
  }
}

//============================================================================

{
  GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow(_orb->string_to_object(IORString));
  if (!CORBA::is_nil(anObject)) {
    return CORBA::string_dup(anObject->GetEntry());
  }
  return 0;
}

  GEOM::GEOM_Object_var obj = GetObject(anObject->GetDocID(), anEntry.ToCString());

  CORBA::String_var aPersRefString = _orb->object_to_string(obj);
  return CORBA::string_dup(aPersRefString);
}

//============================================================================

  }
  anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");
  SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
  //char *aGeomObjIOR = _orb->object_to_string(theObject);
   CORBA::String_var aGeomObjIOR = _orb->object_to_string(theObject);
  //anIOR->SetValue(CORBA::string_dup(aGeomObjIOR));
  anIOR->SetValue(aGeomObjIOR);

  anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributePixMap");
  SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);

    aShapeName = "Vertex_";
  }
  //if (strlen(theName) == 0) aShapeName += TCollection_AsciiString(aResultSO->Tag());
  //else aShapeName = TCollection_AsciiString(CORBA::string_dup(theName));

  // asv : 11.11.04 Introducing a more sofisticated method of name creation, just as
  //       it is done in GUI in GEOMBase::GetDefaultName() - not just add a Tag() == number

    aShapeName = aNewShapeName;
  }
  else // MOST PROBABLY CALLED FROM GEOM GUI (ALREADY WITH VALID NAME)
    aShapeName = TCollection_AsciiString((char*)theName);

  //Set the study entry as a name of  the published GEOM_Object
  aShape->SetStudyEntry(aResultSO->GetID());

  if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);

  SALOMEDS::Study_var Study = theComponent->GetStudy();
  TCollection_AsciiString name (Study->Name());

  return true;
}

  TDF_Tool::Entry(anObj->GetEntry(), anEntry);
  GEOM::GEOM_Object_var obj = GetObject(anObj->GetDocID(), anEntry.ToCString());

  //Set the study entry of the published GEOM_Object
  obj->SetStudyEntry(aNewSO->GetID());

  // Add IORAttribute to the Study and set IOR of the created GEOM_Object to it
  SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aNewSO, "AttributeIOR");
  SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);

//============================================================================
char* GEOM_Gen_i::ComponentDataType()
{
  return CORBA::string_dup("GEOM");
}

//============================================================================

void GEOM_Gen_i::register_name(char * name)
{
  GEOM::GEOM_Gen_ptr g = GEOM::GEOM_Gen::_narrow(_this());
  name_service->Register(g, CORBA::string_dup(name));
}

//============================================================================





//=============================================================================
/*!
 *  GetShapesOnPlaneWithLocation
 */
//=============================================================================
GEOM::ListOfGO* GEOM_IShapesOperations_i::GetShapesOnPlaneWithLocation
                                                (GEOM::GEOM_Object_ptr   theShape,
						 const CORBA::Long       theShapeType,
						 GEOM::GEOM_Object_ptr   theAx1,
						 GEOM::GEOM_Object_ptr   thePnt,
						 const GEOM::shape_state theState)
{
  GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;

  //Set a not done flag
  GetOperations()->SetNotDone();

  if (theShape == NULL || theAx1 == NULL || thePnt == NULL) return aSeq._retn();

  //Get the reference objects
  Handle(GEOM_Object) aShape = GetOperations()->GetEngine()->GetObject
    (theShape->GetStudyID(), theShape->GetEntry());
  Handle(GEOM_Object) anAx1 = GetOperations()->GetEngine()->GetObject
    (theAx1->GetStudyID(), theAx1->GetEntry());
  Handle(GEOM_Object) anPnt = GetOperations()->GetEngine()->GetObject
    (thePnt->GetStudyID(), thePnt->GetEntry());

  if (aShape.IsNull() || anAx1.IsNull() || anPnt.IsNull()) return aSeq._retn();

  //Get Shapes On Plane
  Handle(TColStd_HSequenceOfTransient) aHSeq =
    GetOperations()->GetShapesOnPlaneWithLocation(aShape, theShapeType, anAx1, anPnt, ShapeState(theState));
  if (!GetOperations()->IsDone() || aHSeq.IsNull())
    return aSeq._retn();

  Standard_Integer aLength = aHSeq->Length();
  aSeq->length(aLength);
  for (Standard_Integer i = 1; i <= aLength; i++)
    aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));

  return aSeq._retn();
}

//=============================================================================
/*!
 *  GetShapesOnCylinder
 */
//=============================================================================


//=============================================================================
/*!
 *  GetShapesOnPlaneWithLocationIDs
 */
//=============================================================================
GEOM::ListOfLong* GEOM_IShapesOperations_i::GetShapesOnPlaneWithLocationIDs
                                                (GEOM::GEOM_Object_ptr   theShape,
						 const CORBA::Long       theShapeType,
						 GEOM::GEOM_Object_ptr   theAx1,
						 GEOM::GEOM_Object_ptr   thePnt,
						 const GEOM::shape_state theState)
{
  GEOM::ListOfLong_var aSeq = new GEOM::ListOfLong;

  //Set a not done flag
  GetOperations()->SetNotDone();

  if (theShape == NULL || theAx1 == NULL || thePnt == NULL) return aSeq._retn();

  //Get the reference objects
  Handle(GEOM_Object) aShape = GetOperations()->GetEngine()->GetObject
    (theShape->GetStudyID(), theShape->GetEntry());
  Handle(GEOM_Object) anAx1 = GetOperations()->GetEngine()->GetObject
    (theAx1->GetStudyID(), theAx1->GetEntry());
  Handle(GEOM_Object) anPnt = GetOperations()->GetEngine()->GetObject
    (thePnt->GetStudyID(), thePnt->GetEntry());

  if (aShape.IsNull() || anAx1.IsNull() || anPnt.IsNull()) return aSeq._retn();

  //Get Shapes On Plane
  Handle(TColStd_HSequenceOfInteger) aHSeq =
    GetOperations()->GetShapesOnPlaneWithLocationIDs(aShape, theShapeType, anAx1, anPnt, ShapeState(theState));
  if (!GetOperations()->IsDone() || aHSeq.IsNull())
    return aSeq._retn();

  Standard_Integer aLength = aHSeq->Length();
  aSeq->length(aLength);
  for (Standard_Integer i = 1; i <= aLength; i++)
    aSeq[i-1] = aHSeq->Value(i);

  return aSeq._retn();
}

//=============================================================================
/*!
 *  GetShapesOnCylinderIDs
 */
//=============================================================================

Lines 97-102 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_I/GEOM_IShapesOperations_i.hh (+12 lines)
97	GEOM::GEOM_Object_ptr theAx1,	97	GEOM::GEOM_Object_ptr theAx1,
98	GEOM::shape_state theState);	98	GEOM::shape_state theState);
99		99
		100	GEOM::ListOfGO* GetShapesOnPlaneWithLocation(GEOM::GEOM_Object_ptr theShape,
		101	CORBA::Long theShapeType,
		102	GEOM::GEOM_Object_ptr theAx1,
		103	GEOM::GEOM_Object_ptr thePnt,
		104	GEOM::shape_state theState);
		105
100	GEOM::ListOfGO* GetShapesOnCylinder (GEOM::GEOM_Object_ptr theShape,	106	GEOM::ListOfGO* GetShapesOnCylinder (GEOM::GEOM_Object_ptr theShape,
101	CORBA::Long theShapeType,	107	CORBA::Long theShapeType,
102	GEOM::GEOM_Object_ptr theAxis,	108	GEOM::GEOM_Object_ptr theAxis,
Lines 122-127 Link Here
122	GEOM::GEOM_Object_ptr theAx1,	128	GEOM::GEOM_Object_ptr theAx1,
123	GEOM::shape_state theState);	129	GEOM::shape_state theState);
124		130
		131	GEOM::ListOfLong* GetShapesOnPlaneWithLocationIDs (GEOM::GEOM_Object_ptr theShape,
		132	CORBA::Long theShapeType,
		133	GEOM::GEOM_Object_ptr theAx1,
		134	GEOM::GEOM_Object_ptr thePnt,
		135	GEOM::shape_state theState);
		136
125	GEOM::ListOfLong* GetShapesOnCylinderIDs (GEOM::GEOM_Object_ptr theShape,	137	GEOM::ListOfLong* GetShapesOnCylinderIDs (GEOM::GEOM_Object_ptr theShape,
126	CORBA::Long theShapeType,	138	CORBA::Long theShapeType,
127	GEOM::GEOM_Object_ptr theAxis,	139	GEOM::GEOM_Object_ptr theAxis,

Lines 55-61 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_I/Makefile.in (-1 / +1 lines)
55	GEOM_DumpPython.cc	55	GEOM_DumpPython.cc
56		56
57	# SALOME_Component.idl	57	# SALOME_Component.idl
58	LIB_CLIENT_IDL = SALOMEDS.idl SALOMEDS_Attributes.idl SALOME_Component.idl SALOME_Exception.idl	58	LIB_CLIENT_IDL = SALOMEDS.idl SALOMEDS_Attributes.idl SALOME_Component.idl SALOME_Exception.idl SALOME_GenericObj.idl
59	#SALOME_Exception.idl SALOME_GenericObj.idl	59	#SALOME_Exception.idl SALOME_GenericObj.idl
60		60
61	LIB_SERVER_IDL = GEOM_Gen.idl	61	LIB_SERVER_IDL = GEOM_Gen.idl





############# MakeSpanner #############

def MakeSpanner (geompy, math, isBlocksTest = 0, isMeshTest = 0, smesh = None):

  ### Variables ###


    Block_new = geompy.MakeHexa2Faces(Face_g_1, Face_g_1_tr)
    id_block_new = geompy.addToStudy(Block_new, "Block New")

  if isMeshTest == 1 and smesh is not None:

    print "##################### Build Mesh #####################"

    import StdMeshers

    # ---- add a middle block of spanner handle in study


    Id_Edge1 = geompy.addToStudyInFather(FaceTop, Edge1, "Edge 1")
    Id_Edge2 = geompy.addToStudyInFather(FaceTop, Edge2, "Edge 2")

    print "-------------------------- Algorithm and Hypothesis"

    print "---- Init a Mesh with the Spanner"
    if hasGUI == 1:
      smeshgui = salome.ImportComponentGUI("SMESH")
      smeshgui.Init(salome.myStudyId)

    print "-------------------------- create Hypothesis"

    print "-------------------------- NumberOfSegments"

    hypNbSeg3 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
    hypNbSeg3.SetNumberOfSegments(3)
    print hypNbSeg3.GetName()
    print hypNbSeg3.GetId()
    print hypNbSeg3.GetNumberOfSegments()

    if hasGUI == 1:
      idseg = salome.ObjectToID(hypNbSeg3)
      smeshgui.SetName(idseg, "NumberOfSegments_3");

    print "-------------------------- LocalLength"

    hypLen1 = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")
    hypLen1.SetLength(10)
    print hypLen1.GetName()
    print hypLen1.GetId()
    print hypLen1.GetLength()

    mesh = smesh.Mesh(Spanner, "Meshed Spanner")
      idlength = salome.ObjectToID(hypLen1)
      smeshgui.SetName(idlength, "Local_Length_10");

    print "-------------------------- Propagation"

    hypProp = smesh.CreateHypothesis("Propagation", "libStdMeshersEngine.so")
    print hypProp.GetName()
    print hypProp.GetId()

    if hasGUI == 1:
      idprop = salome.ObjectToID(hypProp)
      smeshgui.SetName(idprop, "Propagation hypothesis");

    #print "-------------------------- NumberOfSegments"
    #
    #hypNbSeg15 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
    #hypNbSeg15.SetNumberOfSegments(15)
    #print hypNbSeg15.GetName()
    #print hypNbSeg15.GetId()
    #print hypNbSeg15.GetNumberOfSegments()
    #
    #if hasGUI == 1:
    #  idseg15 = salome.ObjectToID(hypNbSeg15)
    #  smeshgui.SetName(idseg15, "NumberOfSegments_15");

    print "-------------------------- add hypothesis to Spanner"

    print "-------------------------- NumberOfSegments"
    algoReg = mesh.Segment()
    listHyp = algoReg.GetCompatibleHypothesis()
    for hyp in listHyp:
      print hyp
    print algoReg.GetName()
    print algoReg.GetId()
    algoReg.SetName("Regular_1D")
      
      
    hypNbSeg3 = algoReg.NumberOfSegments(3)
    print hypNbSeg3.GetName()
    print hypNbSeg3.GetId()
    print hypNbSeg3.GetNumberOfSegments()
    smesh.SetName(hypNbSeg3, "NumberOfSegments_3")

    print "-------------------------- Quadrangle_2D"

    algoQuad = mesh.Quadrangle()
    listHyp = algoQuad.GetCompatibleHypothesis()
    for hyp in listHyp:
        print hyp
    print algoQuad.GetName()
    print algoQuad.GetId()
    algoQuad.SetName("Quadrangle_2D")
    if hasGUI == 1:
      idquad = salome.ObjectToID(algoQuad)
      smeshgui.SetName(idquad, "Quadrangle_2D");

    print "---- Init a Mesh with the Spanner"

    mesh = smesh.CreateMesh(Spanner)
    if hasGUI == 1:
      idmesh = salome.ObjectToID(mesh)
      smeshgui.SetName(idmesh, "Meshed Spanner");

    print "-------------------------- add hypothesis to Spanner"

    mesh.AddHypothesis(Spanner, algoReg)
    mesh.AddHypothesis(Spanner, hypNbSeg3)
    mesh.AddHypothesis(Spanner, algoQuad)

    print "-------------------------- add hypothesis to the Middle Block"
    
    print "-------------------------- LocalLength"
    algoRegMb = mesh.Segment(BlockMh)
    hypLen1 = algoRegMb.LocalLength(10)
    print hypLen1.GetName()
    print hypLen1.GetId()
    print hypLen1.GetLength()
    smesh.SetName(hypLen1, "Local_Length_10")

    print "-------------------------- add hypothesis to the long edges of the Top Face of the Middle Block"

    algoRegE1 = mesh.Segment(Edge1)
    hypPropE1 = algoRegE1.Propagation()
    print hypPropE1.GetName()
    print hypPropE1.GetId()
    smesh.SetName(hypPropE1, "Propagation hypothesis")
    smesh.SetName(algoRegE1.GetSubMesh(), "SubMesh Edge 1 of Top Face")
    
    algoRegE2 = mesh.Segment(Edge2)
    hypPropE2 = algoRegE2.Propagation()
    print hypPropE2.GetName()
    print hypPropE2.GetId()
    smesh.SetName(hypPropE2, "Propagation hypothesis")
    smesh.SetName(algoRegE2.GetSubMesh(), "SubMesh Edge 2 of Top Face")
    
    print "-------------------------- compute the mesh"
    mesh.Compute()

    print "Information about the Mesh:"
    print "Number of nodes       : ", mesh.NbNodes()




  v_n0p = geompy.MakeVectorDXDYDZ(-1,  0,  1)
  v_pp0 = geompy.MakeVectorDXDYDZ( 1,  1,  0)
  v_np0 = geompy.MakeVectorDXDYDZ(-1,  1,  0)
  v_0n0 = geompy.MakeVectorDXDYDZ( 0, -1,  0)

  pln_0pp = geompy.MakePlane(p0, v_0pp, 300)
  pln_0np = geompy.MakePlane(p0, v_0np, 300)

  geompy.UnionIDs(faces_above, faces_above_pln_ids)
  geompy.addToStudy(faces_above, "Group of faces above Plane (N = (0, 1, 1))")

  # GetShapesOnPlaneWithLocation
  Loc = geompy.MakeVertex(0, -50, 0)
  edges_on_pln = geompy.GetShapesOnPlaneWithLocation(blocksComp, geompy.ShapeType["EDGE"],
                                                     v_0n0, Loc, geompy.GEOM.ST_ON)
  for edge_i in edges_on_pln:
    geompy.addToStudy(edge_i, "Edge on Plane (N = (0, -1, 0) & Location = (0, -50, 0)")
    
  # GetShapesOnPlaneWithLocationIDs
  edges_on_pln_ids = geompy.GetShapesOnPlaneWithLocationIDs(blocksComp, geompy.ShapeType["EDGE"],
                                                            v_0n0, Loc, geompy.GEOM.ST_ON)
  group_edges_on_pln = geompy.CreateGroup(blocksComp, geompy.ShapeType["EDGE"])
  geompy.UnionIDs(group_edges_on_pln, edges_on_pln_ids)
  geompy.addToStudy(group_edges_on_pln, "Group of edges on Plane (N = (0, -1, 0) & Location = (0, -50, 0))")
  
  # GetShapesOnCylinder
  edges_out_cyl = geompy.GetShapesOnCylinder(blocksComp, geompy.ShapeType["EDGE"],
                                             vy, 55, geompy.GEOM.ST_OUT)




    return anObj

## Create a face on the given wire.
#  @param theWire closed Wire or Edge to build the face on.
#  @param isPlanarWanted If TRUE, only planar face will be built.
#                        If impossible, NULL object will be returned.
#  @return New GEOM_Object, containing the created face.

    return anObj

## Create a face on the given wires set.
#  @param theWires List of closed wires or edges to build the face on.
#  @param isPlanarWanted If TRUE, only planar face will be built.
#                        If impossible, NULL object will be returned.
#  @return New GEOM_Object, containing the created face.

    return aList

## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
#  the specified plane by the certain way, defined through \a theState parameter.
#  @param theShape Shape to find sub-shapes of.
#  @param theShapeType Type of sub-shapes to be retrieved.
#  @param theAx1 Vector (or line, or linear edge), specifying normal
#                direction of the plane to find shapes on.
#  @param thePnt Point specifying location of the plane to find shapes on.
#  @param theState The state of the subshapes to find. It can be one of
#   ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
#  @return List of all found sub-shapes.
#
#  Example: see GEOM_TestOthers.py
def GetShapesOnPlaneWithLocation(theShape, theShapeType, theAx1, thePnt, theState):
    aList = ShapesOp.GetShapesOnPlaneWithLocation(theShape, theShapeType, theAx1, thePnt, theState)
    if ShapesOp.IsDone() == 0:
      print "GetShapesOnPlaneWithLocation : ", ShapesOp.GetErrorCode()
    return aList

## Works like the above method, but returns list of sub-shapes indices
#
#  Example: see GEOM_TestOthers.py
def GetShapesOnPlaneWithLocationIDs(theShape, theShapeType, theAx1, thePnt, theState):
    aList = ShapesOp.GetShapesOnPlaneWithLocationIDs(theShape, theShapeType, theAx1, thePnt, theState)
    if ShapesOp.IsDone() == 0:
        print "GetShapesOnPlaneWithLocationIDs : ", ShapesOp.GetErrorCode()
    return aList

## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
#  the specified cylinder by the certain way, defined through \a theState parameter.
#  @param theShape Shape to find sub-shapes of.
#  @param theShapeType Type of sub-shapes to be retrieved.




  aNb=myDS->NumberOfShapesOfTheObject();
  //
  for (i=1; i<=aNb; i++) {
    const TopoDS_Shape aF=myDS->Shape(i);
    if (aF.ShapeType()==TopAbs_FACE) {
      TopExp::MapShapesAndAncestors (aF, TopAbs_EDGE, TopAbs_FACE, aMEF);
    }
  }
  //
  for (i=1; i<=aNb; i++) {
    const TopoDS_Shape aS=myDS->Shape(i);
    if (aS.ShapeType()==TopAbs_EDGE) {
      const TopoDS_Edge& aE=TopoDS::Edge(aS);
      

  // Clear aPaveSet, aSplitEdges
  aPaveSet.ChangeSet().Clear();
  //
  const TopoDS_Edge aDE=TopoDS::Edge(myDS->Shape(nED));
  const TopoDS_Face aDF=TopoDS::Face(myDS->Shape(nFD));
  //
  // 2D Curve of degenerated edge on the face aDF
  Handle(Geom2d_Curve) aC2DDE=BRep_Tool::CurveOnSurface(aDE, aDF, aTD1, aTD2);

  for (; anIt.More(); anIt.Next()) {
    const BOPTools_PaveBlock& aPB=anIt.Value();
    nE=aPB.Edge();
    const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
    
    Handle(Geom2d_Curve) aC2D=BRep_Tool::CurveOnSurface(aE, aDF, aT1, aT2);
    //

  TopoDS_Edge aE, aESplit;
  TopoDS_Vertex aV1, aV2;

  const TopoDS_Edge aDE=TopoDS::Edge(myDS->Shape(nED));
  const TopoDS_Face aDF=TopoDS::Face(myDS->Shape(nFD));

  BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);


Lines 78-85 Link Here

(-)GEOM_SRC_3.2.2/src/NMTTools/NMTTools_PaveFiller_1.cxx (-3 / +3 lines)
78	aWith=n2;	78	aWith=n2;
79	SortTypes(aWhat, aWith);	79	SortTypes(aWhat, aWith);
80	if (!bJustAddInterference) {	80	if (!bJustAddInterference) {
81	const TopoDS_Shape& aS1=myDS->GetShape(aWhat);	81	const TopoDS_Shape aS1=myDS->GetShape(aWhat);
82	const TopoDS_Shape& aS2=myDS->GetShape(aWith);	82	const TopoDS_Shape aS2=myDS->GetShape(aWith);
83	//	83	//
84	const TopoDS_Vertex& aV1=TopoDS::Vertex(aS1);	84	const TopoDS_Vertex& aV1=TopoDS::Vertex(aS1);
85	const TopoDS_Vertex& aV2=TopoDS::Vertex(aS2);	85	const TopoDS_Vertex& aV2=TopoDS::Vertex(aS2);
Lines 127-133 Link Here
127	aNbV=aChain.Extent();	127	aNbV=aChain.Extent();
128	for (j=1; j<=aNbV; ++j) {	128	for (j=1; j<=aNbV; ++j) {
129	aIdV=aChain(j);	129	aIdV=aChain(j);
130	const TopoDS_Shape& aV=myDS->Shape(aIdV);	130	const TopoDS_Shape aV=myDS->Shape(aIdV);
131	if (!aM.Contains(aV)) {	131	if (!aM.Contains(aV)) {
132	aM.Add(aV);	132	aM.Add(aV);
133	aLV.Append(aV);	133	aLV.Append(aV);




      continue;
    }
    //
    const TopoDS_Edge aE1=TopoDS::Edge(myDS->Shape(nE1));
    const TopoDS_Edge aE2=TopoDS::Edge(myDS->Shape(nE2));
    //
    if (BRep_Tool::Degenerated(aE1) || BRep_Tool::Degenerated(aE2)){
      continue;

    aNbEdges=aME.Extent();
    for (j=1; j<=aNbEdges; ++j) {
      nE=aME(j);
      const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
      //
      aFlag=myContext.ComputeVE (aNewVertex, aE, aT);
      //

  Standard_Real d1121, d1122, d1222, d1221, aTolSum, aCoeff=1.05;
  gp_Pnt aP11, aP12, aP21, aP22;

  const TopoDS_Vertex aV11=TopoDS::Vertex(myDS->Shape(aPB1.Pave1().Index()));
  const TopoDS_Vertex aV12=TopoDS::Vertex(myDS->Shape(aPB1.Pave2().Index()));
  const TopoDS_Vertex aV21=TopoDS::Vertex(myDS->Shape(aPB2.Pave1().Index()));
  const TopoDS_Vertex aV22=TopoDS::Vertex(myDS->Shape(aPB2.Pave2().Index()));

  aTolV11=BRep_Tool::Tolerance(aV11);
  aTolV12=BRep_Tool::Tolerance(aV12);




      continue;
    }
    // Edge
    const TopoDS_Edge aE=TopoDS::Edge(myDS->GetShape(nE));
    if (BRep_Tool::Degenerated(aE)){
      continue;
    }
    aTolE=BRep_Tool::Tolerance(aE);
    // Face
    const TopoDS_Face aF=TopoDS::Face(myDS->GetShape(nF));
    aTolF=BRep_Tool::Tolerance(aF);
    const Bnd_Box& aBBF=myDS->GetBoundingBox(nF); 
    //

    aNbEdges=aME.Extent();
    for (j=1; j<=aNbEdges; ++j) {
      nE=aME(j);
      const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
      //
      aFlag=myContext.ComputeVE (aNewVertex, aE, aT);
      //

  aNbV=aMVF.Extent();
  for (i=1; i<=aNbV; ++i) {
    nVF=aMVF(i);
    const TopoDS_Vertex aVF=TopoDS::Vertex(myDS->Shape(nVF));
    iFlag=IntTools_Tools::ComputeVV(aNewVertex, aVF);
    if (!iFlag) {
      return nVF;




      continue;
    }
    //
    const TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));
    const TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));
    //
    // FF
    bToApproxC3d     = mySectionAttribute.Approximation();

    // 
    // Faces
    aFFi.Indices(nF1, nF2);
    const TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));
    const TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));
    //
    BOPTools_ListOfPaveBlock aLPB, aLPBC;
    //

	// Make Section Edge  
	TopoDS_Edge aES;
	//
	const TopoDS_Vertex aV1=TopoDS::Vertex(myDS->Shape(nV1));
	const TopoDS_Vertex aV2=TopoDS::Vertex(myDS->Shape(nV2));
	//
	BOPTools_Tools::MakeSectEdge (aIC, aV1, aT1, aV2, aT2, aES);
	//

    for (j=1; j<=aNbSE; ++j) {
      const BOPTools_PaveBlock& aPBSE=aMEPB(j);
      nV1=aPBSE.Pave1().Index();
      const TopoDS_Shape aV1=myDS->Shape(nV1);
      if (aV1.IsSame(aV)) {
	aMNewOld.Add(i, nV1);
	break;
      }
      nV2=aPBSE.Pave2().Index();
      const TopoDS_Shape aV2=myDS->Shape(nV2);
      if (aV2.IsSame(aV)) {
	aMNewOld.Add(i, nV2);
	break;

      BooleanOperations_AncestorsSeqAndSuccessorsSeq anASSeq;
      //
      nV1=aPBSE.Pave1().Index();
      const TopoDS_Shape aV1=myDS->Shape(nV1);
      nV2=aPBSE.Pave2().Index();
      const TopoDS_Shape aV2=myDS->Shape(nV2);
      //
      anASSeq.SetNewSuccessor(nV1);
      anASSeq.SetNewOrientation(aV1.Orientation());

      BOPTools_PaveBlock aPB=aIt.Value();
      //
      ////modified by NIZNHY-PKV Thu Jan 26 10:16:36 2006f
      const TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));
      const TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));
      ////modified by NIZNHY-PKV Thu Jan 26 10:16:39 2006t
      //
      if (aCBAPI.IsCommonBlock(aPB)) {

      aT1=aPave1.Param();
      mV1=aPave1.Index();            // index in tDS
      nV1=aMNewOld.FindFromKey(mV1); // index in myDS
      const TopoDS_Shape aV1=myDS->Shape(nV1);
      //
      const BOPTools_Pave& aPave2=aPB.Pave2();
      aT2=aPave2.Param();
      mV2=aPave2.Index();
      nV2=aMNewOld.FindFromKey(mV2);
      const TopoDS_Shape aV2=myDS->Shape(nV2);
      //
      if (!aMNewOld.Contains(mE)) {
	// add new SE to the myDS

    BOPTools_SSInterference& aFF=aFFs(i);
    aFF.Indices(nF1, nF2);
    //
    const TopoDS_Face aF1=TopoDS::Face(myDS->Shape(nF1));
    const TopoDS_Face aF2=TopoDS::Face(myDS->Shape(nF2));
    //
    aF1FWD=aF1;
    aF1FWD.Orientation(TopAbs_FORWARD);

    for (; anIt.More(); anIt.Next()) {
      const BOPTools_PaveBlock& aPB=anIt.Value();
      nE=aPB.Edge();
      const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
      
      BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aE, aF1FWD);
      BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aE, aF2FWD);

  //
  //Edge
  nE2=aPBR.Edge();
  const TopoDS_Edge aE2=TopoDS::Edge(myDS->GetShape(nE2));
  // VE
  iVM=myContext.ComputeVE(aVM, aE2, aTmp); 
  //

  aFFi.Indices(nF1, nF2);
  aTolR3D=aFFi.TolR3D();
  //
  const TopoDS_Face aF1=TopoDS::Face(myDS->GetShape(nF1));
  const TopoDS_Face aF2=TopoDS::Face(myDS->GetShape(nF2));
  //
  bVF=myContext.IsValidPointForFaces (aP1, aF1, aF2, aTolR3D);
  if (bVF) {

    TColStd_ListOfInteger& aTVs=aBC.TechnoVertices();
    aTVs.Append(nV);
  }
  
  if (bFound1 && !bFound2) {
    nV=aPave1.Index();
    aPave.SetIndex(nV);
    aPave.SetParam(aT);
    aFFiPS.Append(aPave);
    //
    const TopoDS_Vertex aV=TopoDS::Vertex(myDS->Shape(nV));
    BOPTools_Tools::UpdateVertex (aIC, aT, aV);
  }
  

    aPave.SetParam(aT);
    aCPS.Append(aPave);
    //
    const TopoDS_Vertex aV=TopoDS::Vertex(myDS->Shape(nV));
    BOPTools_Tools::UpdateVertex (aIC, aT, aV);
  }
}

  for (; anIt.More(); anIt.Next()) {
    const BOPTools_Pave& aPC=anIt.Value();
    nV=aPC.Index();
    const TopoDS_Vertex aV=TopoDS::Vertex(myDS->Shape(nV));
    bIsVertex=IntTools_Tools::IsVertex (aP, aTolPV, aV);
    if (bIsVertex) {
      aPave=aPC;

    const BOPTools_Pave& aPave=anIt.Value();
    //
    nV=aPave.Index();
    const TopoDS_Vertex aV=TopoDS::Vertex(myDS->Shape(nV));
    //
    Bnd_Box aBBV;
    BRepBndLib::Add(aV, aBBV);

Lines 236-242 Link Here

(-)GEOM_SRC_3.2.2/src/NMTTools/NMTTools_PaveFiller_7.cxx (-1 / +1 lines)
236	for(i=1; i<=aNbF; ++i) {	236	for(i=1; i<=aNbF; ++i) {
237	nF=aMF(i);	237	nF=aMF(i);
238	iRankF=myDS->Rank(nF);	238	iRankF=myDS->Rank(nF);
239	const TopoDS_Shape& aF=myDS->Shape(nF);	239	const TopoDS_Shape aF=myDS->Shape(nF);
240	aExp.Init(aF, TopAbs_EDGE);	240	aExp.Init(aF, TopAbs_EDGE);
241	for(; aExp.More(); aExp.Next()) {	241	for(; aExp.More(); aExp.Next()) {
242	aE=TopoDS::Edge(aExp.Current());	242	aE=TopoDS::Edge(aExp.Current());




//=================================================================================
bool TransformationGUI_OffsetDlg::isValid( QString& msg )
{
  //return !(myObjects.length() == 0);
  if (myObjects.length() == 0) return false;

  for (int i = 0; i < myObjects.length(); i++)
  {
    GEOM::shape_type aType = myObjects[i]->GetShapeType();
    if( aType != GEOM::FACE && aType != GEOM::SHELL && aType != GEOM::SOLID ){
       msg = tr("ERROR_SHAPE_TYPE");
       return false;
    }
  }
  return true;
}



  if (GroupPoints->CheckButton1->isChecked() || IsPreview())
    for (int i = 0; i < myObjects.length(); i++)
      {

	anObj = GEOM::GEOM_ITransformOperations::_narrow( getOperation() )->OffsetShapeCopy( myObjects[i], GetOffset() );
	if ( !anObj->_is_nil() )
	  objects.push_back( anObj._retn() );

Return to bug 155974

Lines 884-890 Link Here

(-)GEOM_SRC_3.2.2/idl/GEOM_Gen.idl (-2 / +37 lines)
884		884
885	/*!	885	/*!
886	* Create a face on the given wire.	886	* Create a face on the given wire.
887	* \param theWire Wire to build the face on.	887	* \param theWire closed Wire or Edge to build the face on.
888	* \param isPlanarWanted If TRUE, only planar face will be built.	888	* \param isPlanarWanted If TRUE, only planar face will be built.
889	* If impossible, NULL object will be returned.	889	* If impossible, NULL object will be returned.
890	* \return New GEOM_Object, containing the created face.	890	* \return New GEOM_Object, containing the created face.
Lines 893-899 Link Here
893		893
894	/*!	894	/*!
895	* Create a face on the given wires set.	895	* Create a face on the given wires set.
896	* \param theWires List of wires to build the face on.	896	* \param theWires List of closed wires or edges to build the face on.
897	* \param isPlanarWanted If TRUE, only planar face will be built.	897	* \param isPlanarWanted If TRUE, only planar face will be built.
898	* If impossible, NULL object will be returned.	898	* If impossible, NULL object will be returned.
899	* \return New GEOM_Object, containing the created face.	899	* \return New GEOM_Object, containing the created face.
Lines 1053-1058 Link Here
1053	in long theShapeType,	1053	in long theShapeType,
1054	in GEOM_Object theAx1,	1054	in GEOM_Object theAx1,
1055	in shape_state theState);	1055	in shape_state theState);
		1056	/*!
		1057	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
		1058	* the specified plane by the certain way, defined through \a theState parameter.
		1059	* \param theShape Shape to find sub-shapes of.
		1060	* \param theShapeType Type of sub-shapes to be retrieved.
		1061	* \param theAx1 Vector (or line, or linear edge), specifying normal
		1062	* direction of the plane to find shapes on.
		1063	* \param thePnt Point specifying location of the plane to find shapes on.
		1064	* \param theState The state of the subshapes to find.
		1065	* \return List of all found sub-shapes.
		1066	*/
		1067	ListOfGO GetShapesOnPlaneWithLocation (in GEOM_Object theShape,
		1068	in long theShapeType,
		1069	in GEOM_Object theAx1,
		1070	in GEOM_Object thePnt,
		1071	in shape_state theState);
		1072
		1073
1056		1074
1057	/*!	1075	/*!
1058	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively	1076	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
Lines 1121-1126 Link Here
1121	in long theShapeType,	1139	in long theShapeType,
1122	in GEOM_Object theAx1,	1140	in GEOM_Object theAx1,
1123	in shape_state theState);	1141	in shape_state theState);
		1142
		1143	/*!
		1144	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
		1145	* the specified plane by the certain way, defined through \a theState parameter.
		1146	* \param theShape Shape to find sub-shapes of.
		1147	* \param theShapeType Type of sub-shapes to be retrieved.
		1148	* \param theAx1 Vector (or line, or linear edge), specifying normal
		1149	* direction of the plane to find shapes on.
		1150	* \param thePnt Point specifying location of the plane to find shapes on.
		1151	* \param theState The state of the subshapes to find.
		1152	* \return List of IDs of all found sub-shapes.
		1153	*/
		1154	ListOfLong GetShapesOnPlaneWithLocationIDs (in GEOM_Object theShape,
		1155	in long theShapeType,
		1156	in GEOM_Object theAx1,
		1157	in GEOM_Object thePnt,
		1158	in shape_state theState);
1124		1159
1125	/*!	1160	/*!
1126	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively	1161	* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively

Lines 903-909 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMGUI/GEOM_msg_en.po (-1 / +7 lines)
903		903
904	#: GeometryGUI_FaceDlg.cxx:78	904	#: GeometryGUI_FaceDlg.cxx:78
905	msgid "GEOM_FACE_FFW"	905	msgid "GEOM_FACE_FFW"
906	msgstr "Face from a wire"	906	msgstr "Face from a closed wire and edge"
907		907
908	#: GeometryGUI_FaceDlg.cxx:103	908	#: GeometryGUI_FaceDlg.cxx:103
909	msgid "GEOM_FACE_OPT"	909	msgid "GEOM_FACE_OPT"
Lines 2958-2960 Link Here
2958		2958
2959	msgid "PREF_TAB_SETTINGS"	2959	msgid "PREF_TAB_SETTINGS"
2960	msgstr "Settings"	2960	msgstr "Settings"
		2961
		2962	msgid "ERROR_SHAPE_TYPE"
		2963	msgstr "Object of incorrect type selected!\nPlease, select face, shell or solid and try again"
		2964
		2965	msgid "DEP_OBJECT"
		2966	msgstr "Selected object has been used to create another one\n It can't be deleted "

Lines 1419-1424 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMImpl/GEOMImpl_IShapesOperations.cxx (+141 lines)
1419		1419
1420	//=============================================================================	1420	//=============================================================================
1421	/*!	1421	/*!
		1422	* GetShapesOnPlaneWithLocation
		1423	*/
		1424	//=============================================================================
		1425	Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetShapesOnPlaneWithLocation
		1426	(const Handle(GEOM_Object)& theShape,
		1427	const Standard_Integer theShapeType,
		1428	const Handle(GEOM_Object)& theAx1,
		1429	const Handle(GEOM_Object)& thePnt,
		1430	const GEOMAlgo_State theState)
		1431	{
		1432	SetErrorCode(KO);
		1433
		1434	if (theShape.IsNull() \|\| theAx1.IsNull() \|\| thePnt.IsNull()) return NULL;
		1435
		1436	TopoDS_Shape aShape = theShape->GetValue();
		1437	TopoDS_Shape anAx1 = theAx1->GetValue();
		1438	TopoDS_Shape anPnt = thePnt->GetValue();
		1439
		1440	if (aShape.IsNull() \|\| anAx1.IsNull() \|\| anPnt.IsNull()) return NULL;
		1441
		1442	TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
		1443	if ( !checkTypeShapesOn( theShapeType ))
		1444	return NULL;
		1445
		1446	// Create plane
		1447	if ( anAx1.ShapeType() != TopAbs_EDGE \|\| anPnt.ShapeType() != TopAbs_VERTEX ) return NULL;
		1448	TopoDS_Vertex V1, V2, V3;
		1449	TopoDS_Edge anEdge = TopoDS::Edge(anAx1);
		1450	TopExp::Vertices(anEdge, V1, V2, Standard_True);
		1451
		1452	if (V1.IsNull() \|\| V2.IsNull()) {
		1453	SetErrorCode("Bad edge given for the plane normal vector");
		1454	return NULL;
		1455	}
		1456	V3 = TopoDS::Vertex(anPnt);
		1457
		1458	if(V3.IsNull()) {
		1459	SetErrorCode("Bad vertex given for the plane location");
		1460	return NULL;
		1461	}
		1462	gp_Pnt aLoc = BRep_Tool::Pnt(V3);
		1463	gp_Vec aVec(BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2));
		1464
		1465	if (aVec.Magnitude() < Precision::Confusion()) {
		1466	SetErrorCode("Vector with null magnitude given");
		1467	return NULL;
		1468	}
		1469	Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);
		1470
		1471	if ( aPlane.IsNull() )
		1472	return NULL;
		1473
		1474	// Find objects
		1475	TCollection_AsciiString anAsciiList;
		1476	Handle(TColStd_HSequenceOfTransient) aSeq;
		1477	aSeq = getShapesOnSurface( aPlane, theShape, aShapeType, theState, anAsciiList );
		1478	if ( aSeq.IsNull() \|\| aSeq->Length() == 0 )
		1479	return NULL;
		1480
		1481	// Make a Python command
		1482
		1483	Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast( aSeq->Value( 1 ));
		1484	Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
		1485
1486	GEOM::TPythonDump(aFunction) << "[" << anAsciiList.ToCString()
1487	<< "] = geompy.GetShapesOnPlaneWithLocation(" << theShape << ", "
1488	<< aShapeType << ", " << theAx1 << ", "<< thePnt <<", " << theState << ")";
1489
1490	SetErrorCode(OK);
1491	return aSeq;
1492	}
1493
1494	//=============================================================================
1495	/*!
1422	* GetShapesOnCylinder	1496	* GetShapesOnCylinder
1423	*/	1497	*/
1424	//=============================================================================	1498	//=============================================================================
Lines 1567-1572 Link Here
1567		1641
1568	//=============================================================================	1642	//=============================================================================
1569	/*!	1643	/*!
		1644	* GetShapesOnPlaneWithLocationIDs
		1645	*/
		1646	//=============================================================================
		1647	Handle(TColStd_HSequenceOfInteger) GEOMImpl_IShapesOperations::GetShapesOnPlaneWithLocationIDs
		1648	(const Handle(GEOM_Object)& theShape,
		1649	const Standard_Integer theShapeType,
		1650	const Handle(GEOM_Object)& theAx1,
		1651	const Handle(GEOM_Object)& thePnt,
		1652	const GEOMAlgo_State theState)
		1653	{
		1654	SetErrorCode(KO);
		1655
		1656	if (theShape.IsNull() \|\| theAx1.IsNull() \|\| thePnt.IsNull()) return NULL;
		1657
		1658	TopoDS_Shape aShape = theShape->GetValue();
		1659	TopoDS_Shape anAx1 = theAx1->GetValue();
		1660	TopoDS_Shape anPnt = thePnt->GetValue();
		1661
		1662	if (aShape.IsNull() \|\| anAx1.IsNull() \|\| anPnt.IsNull()) return NULL;
		1663
		1664	TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(theShapeType);
		1665	if ( !checkTypeShapesOn( aShapeType ))
		1666	return NULL;
		1667
		1668	// Create plane
		1669	if (anAx1.ShapeType() != TopAbs_EDGE \|\| anPnt.ShapeType() != TopAbs_VERTEX) return NULL;
		1670	TopoDS_Edge anEdge = TopoDS::Edge(anAx1);
		1671	TopoDS_Vertex V1, V2, V3;
		1672	TopExp::Vertices(anEdge, V1, V2, Standard_True);
		1673	if (V1.IsNull() \|\| V2.IsNull()) {
		1674	SetErrorCode("Bad edge given for the plane normal vector");
		1675	return NULL;
		1676	}
		1677	V3 = TopoDS::Vertex(anPnt);
		1678	if(V3.IsNull()) {
		1679	SetErrorCode("Bad vertex given for the plane location");
		1680	return NULL;
		1681	}
		1682	gp_Pnt aLoc = BRep_Tool::Pnt(V3);
		1683	gp_Vec aVec(BRep_Tool::Pnt(V1),BRep_Tool::Pnt(V2));
		1684	if (aVec.Magnitude() < Precision::Confusion()) {
		1685	SetErrorCode("Vector with null magnitude given");
		1686	return NULL;
		1687	}
		1688
		1689	Handle(Geom_Surface) aPlane = new Geom_Plane(aLoc, aVec);
		1690	if ( aPlane.IsNull() )
		1691	return NULL;
		1692
		1693	// Find object IDs
		1694	Handle(TColStd_HSequenceOfInteger) aSeq;
		1695	aSeq = getShapesOnSurfaceIDs( aPlane, aShape, aShapeType, theState );
		1696
		1697	// The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
		1698	Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();
		1699
		1700	// Make a Python command
		1701	GEOM::TPythonDump(aFunction, /append=/true)
		1702	<< "listShapesOnPlane = geompy.GetShapesOnPlaneWithLocationIDs"
		1703	<< "(" << theShape << ", " << aShapeType << ", " << theAx1 << ", "<< thePnt << ", " << theState << ")";
		1704
		1705	SetErrorCode(OK);
		1706	return aSeq;
		1707	}
1708
1709	//=============================================================================
1710	/*!
1570	* GetShapesOnCylinderIDs	1711	* GetShapesOnCylinderIDs
1571	*/	1712	*/
1572	//=============================================================================	1713	//=============================================================================

Lines 708-713 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_I/GEOM_IShapesOperations_i.cc (+86 lines)
708		708
709	//=============================================================================	709	//=============================================================================
710	/*!	710	/*!
		711	* GetShapesOnPlaneWithLocation
		712	*/
		713	//=============================================================================
		714	GEOM::ListOfGO* GEOM_IShapesOperations_i::GetShapesOnPlaneWithLocation
		715	(GEOM::GEOM_Object_ptr theShape,
		716	const CORBA::Long theShapeType,
		717	GEOM::GEOM_Object_ptr theAx1,
		718	GEOM::GEOM_Object_ptr thePnt,
		719	const GEOM::shape_state theState)
		720	{
		721	GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
		722
		723	//Set a not done flag
		724	GetOperations()->SetNotDone();
		725
		726	if (theShape == NULL \|\| theAx1 == NULL \|\| thePnt == NULL) return aSeq._retn();
		727
		728	//Get the reference objects
		729	Handle(GEOM_Object) aShape = GetOperations()->GetEngine()->GetObject
		730	(theShape->GetStudyID(), theShape->GetEntry());
		731	Handle(GEOM_Object) anAx1 = GetOperations()->GetEngine()->GetObject
		732	(theAx1->GetStudyID(), theAx1->GetEntry());
		733	Handle(GEOM_Object) anPnt = GetOperations()->GetEngine()->GetObject
		734	(thePnt->GetStudyID(), thePnt->GetEntry());
		735
		736	if (aShape.IsNull() \|\| anAx1.IsNull() \|\| anPnt.IsNull()) return aSeq._retn();
		737
		738	//Get Shapes On Plane
		739	Handle(TColStd_HSequenceOfTransient) aHSeq =
		740	GetOperations()->GetShapesOnPlaneWithLocation(aShape, theShapeType, anAx1, anPnt, ShapeState(theState));
		741	if (!GetOperations()->IsDone() \|\| aHSeq.IsNull())
		742	return aSeq._retn();
		743
		744	Standard_Integer aLength = aHSeq->Length();
		745	aSeq->length(aLength);
		746	for (Standard_Integer i = 1; i <= aLength; i++)
		747	aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
		748
		749	return aSeq._retn();
		750	}
		751
		752	//=============================================================================
		753	/*!
711	* GetShapesOnCylinder	754	* GetShapesOnCylinder
712	*/	755	*/
713	//=============================================================================	756	//=============================================================================
Lines 891-896 Link Here
891		934
892	//=============================================================================	935	//=============================================================================
893	/*!	936	/*!
		937	* GetShapesOnPlaneWithLocationIDs
		938	*/
		939	//=============================================================================
		940	GEOM::ListOfLong* GEOM_IShapesOperations_i::GetShapesOnPlaneWithLocationIDs
		941	(GEOM::GEOM_Object_ptr theShape,
		942	const CORBA::Long theShapeType,
		943	GEOM::GEOM_Object_ptr theAx1,
		944	GEOM::GEOM_Object_ptr thePnt,
		945	const GEOM::shape_state theState)
		946	{
		947	GEOM::ListOfLong_var aSeq = new GEOM::ListOfLong;
		948
		949	//Set a not done flag
		950	GetOperations()->SetNotDone();
		951
		952	if (theShape == NULL \|\| theAx1 == NULL \|\| thePnt == NULL) return aSeq._retn();
		953
		954	//Get the reference objects
		955	Handle(GEOM_Object) aShape = GetOperations()->GetEngine()->GetObject
		956	(theShape->GetStudyID(), theShape->GetEntry());
		957	Handle(GEOM_Object) anAx1 = GetOperations()->GetEngine()->GetObject
		958	(theAx1->GetStudyID(), theAx1->GetEntry());
		959	Handle(GEOM_Object) anPnt = GetOperations()->GetEngine()->GetObject
		960	(thePnt->GetStudyID(), thePnt->GetEntry());
		961
		962	if (aShape.IsNull() \|\| anAx1.IsNull() \|\| anPnt.IsNull()) return aSeq._retn();
		963
		964	//Get Shapes On Plane
		965	Handle(TColStd_HSequenceOfInteger) aHSeq =
		966	GetOperations()->GetShapesOnPlaneWithLocationIDs(aShape, theShapeType, anAx1, anPnt, ShapeState(theState));
		967	if (!GetOperations()->IsDone() \|\| aHSeq.IsNull())
		968	return aSeq._retn();
		969
		970	Standard_Integer aLength = aHSeq->Length();
		971	aSeq->length(aLength);
		972	for (Standard_Integer i = 1; i <= aLength; i++)
		973	aSeq[i-1] = aHSeq->Value(i);
		974
		975	return aSeq._retn();
		976	}
		977
		978	//=============================================================================
		979	/*!
894	* GetShapesOnCylinderIDs	980	* GetShapesOnCylinderIDs
895	*/	981	*/
896	//=============================================================================	982	//=============================================================================

Lines 27-33 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_SWIG/GEOM_Spanner.py (-92 / +42 lines)
27		27
28	############# MakeSpanner #############	28	############# MakeSpanner #############
29		29
30	def MakeSpanner (salome, geompy, math, isBlocksTest = 0, isMeshTest = 0, smesh = None, hasGUI = 0):	30	def MakeSpanner (geompy, math, isBlocksTest = 0, isMeshTest = 0, smesh = None):
31		31
32	### Variables ###	32	### Variables ###
33		33
Lines 355-365 Link Here
355	Block_new = geompy.MakeHexa2Faces(Face_g_1, Face_g_1_tr)	355	Block_new = geompy.MakeHexa2Faces(Face_g_1, Face_g_1_tr)
356	id_block_new = geompy.addToStudy(Block_new, "Block New")	356	id_block_new = geompy.addToStudy(Block_new, "Block New")
357		357
358	if isMeshTest == 1:	358	if isMeshTest == 1 and smesh is not None:
359		359
360	print "##################### Build Mesh #####################"	360	print "##################### Build Mesh #####################"
361		361
362	import StdMeshers
363		362
364	# ---- add a middle block of spanner handle in study	363	# ---- add a middle block of spanner handle in study
365		364
Lines 380-496 Link Here
380	Id_Edge1 = geompy.addToStudyInFather(FaceTop, Edge1, "Edge 1")	379	Id_Edge1 = geompy.addToStudyInFather(FaceTop, Edge1, "Edge 1")
381	Id_Edge2 = geompy.addToStudyInFather(FaceTop, Edge2, "Edge 2")	380	Id_Edge2 = geompy.addToStudyInFather(FaceTop, Edge2, "Edge 2")
382		381
383	# ---- launch SMESH	382	print "-------------------------- Algorithm and Hypothesis"
384		383
385	smeshgui = None	384	print "---- Init a Mesh with the Spanner"
386	if hasGUI == 1:
387	smeshgui = salome.ImportComponentGUI("SMESH")
388	smeshgui.Init(salome.myStudyId)
389
390	print "-------------------------- create Hypothesis"
391
392	print "-------------------------- NumberOfSegments"
393
394	hypNbSeg3 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
395	hypNbSeg3.SetNumberOfSegments(3)
396	print hypNbSeg3.GetName()
397	print hypNbSeg3.GetId()
398	print hypNbSeg3.GetNumberOfSegments()
399
400	if hasGUI == 1:
401	idseg = salome.ObjectToID(hypNbSeg3)
402	smeshgui.SetName(idseg, "NumberOfSegments_3");
403
404	print "-------------------------- LocalLength"
405
406	hypLen1 = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")
407	hypLen1.SetLength(10)
408	print hypLen1.GetName()
409	print hypLen1.GetId()
410	print hypLen1.GetLength()
411		385
412	if hasGUI == 1:	386	mesh = smesh.Mesh(Spanner, "Meshed Spanner")
413	idlength = salome.ObjectToID(hypLen1)
414	smeshgui.SetName(idlength, "Local_Length_10");
415
416	print "-------------------------- Propagation"
417
418	hypProp = smesh.CreateHypothesis("Propagation", "libStdMeshersEngine.so")
419	print hypProp.GetName()
420	print hypProp.GetId()
421
422	if hasGUI == 1:
423	idprop = salome.ObjectToID(hypProp)
424	smeshgui.SetName(idprop, "Propagation hypothesis");
425
426	#print "-------------------------- NumberOfSegments"
427	#
428	#hypNbSeg15 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
429	#hypNbSeg15.SetNumberOfSegments(15)
430	#print hypNbSeg15.GetName()
431	#print hypNbSeg15.GetId()
432	#print hypNbSeg15.GetNumberOfSegments()
433	#
434	#if hasGUI == 1:
435	# idseg15 = salome.ObjectToID(hypNbSeg15)
436	# smeshgui.SetName(idseg15, "NumberOfSegments_15");
437		387
438	print "-------------------------- Regular_1D"	388	print "-------------------------- add hypothesis to Spanner"
439		389
440	algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")	390	print "-------------------------- NumberOfSegments"
		391	algoReg = mesh.Segment()
441	listHyp = algoReg.GetCompatibleHypothesis()	392	listHyp = algoReg.GetCompatibleHypothesis()
442	for hyp in listHyp:	393	for hyp in listHyp:
443	print hyp	394	print hyp
444	print algoReg.GetName()	395	print algoReg.GetName()
445	print algoReg.GetId()	396	print algoReg.GetId()
446		397	algoReg.SetName("Regular_1D")
447	if hasGUI == 1:	398
448	idreg = salome.ObjectToID(algoReg)	399
449	smeshgui.SetName(idreg, "Regular_1D");	400	hypNbSeg3 = algoReg.NumberOfSegments(3)
		401	print hypNbSeg3.GetName()
		402	print hypNbSeg3.GetId()
		403	print hypNbSeg3.GetNumberOfSegments()
		404	smesh.SetName(hypNbSeg3, "NumberOfSegments_3")
450		405
451	print "-------------------------- Quadrangle_2D"	406	print "-------------------------- Quadrangle_2D"
452		407
453	algoQuad = smesh.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")	408	algoQuad = mesh.Quadrangle()
454	listHyp = algoQuad.GetCompatibleHypothesis()	409	listHyp = algoQuad.GetCompatibleHypothesis()
455	for hyp in listHyp:	410	for hyp in listHyp:
456	print hyp	411	print hyp
457	print algoQuad.GetName()	412	print algoQuad.GetName()
458	print algoQuad.GetId()	413	print algoQuad.GetId()
459		414	algoQuad.SetName("Quadrangle_2D")
460	if hasGUI == 1:
461	idquad = salome.ObjectToID(algoQuad)
462	smeshgui.SetName(idquad, "Quadrangle_2D");
463
464	print "---- Init a Mesh with the Spanner"
465
466	mesh = smesh.CreateMesh(Spanner)
467	if hasGUI == 1:
468	idmesh = salome.ObjectToID(mesh)
469	smeshgui.SetName(idmesh, "Meshed Spanner");
470
471	print "-------------------------- add hypothesis to Spanner"
472
473	mesh.AddHypothesis(Spanner, algoReg)
474	mesh.AddHypothesis(Spanner, hypNbSeg3)
475	mesh.AddHypothesis(Spanner, algoQuad)
476		415
477	print "-------------------------- add hypothesis to the Middle Block"	416	print "-------------------------- add hypothesis to the Middle Block"
478		417
479	submesh_bl = mesh.GetSubMesh(BlockMh, "SubMesh Middle Block")	418	print "-------------------------- LocalLength"
480	mesh.AddHypothesis(BlockMh, hypLen1)	419	algoRegMb = mesh.Segment(BlockMh)
		420	hypLen1 = algoRegMb.LocalLength(10)
		421	print hypLen1.GetName()
		422	print hypLen1.GetId()
		423	print hypLen1.GetLength()
		424	smesh.SetName(hypLen1, "Local_Length_10")
481		425
482	print "-------------------------- add hypothesis to the long edges of the Top Face of the Middle Block"	426	print "-------------------------- add hypothesis to the long edges of the Top Face of the Middle Block"
483		427
484	submesh_e1 = mesh.GetSubMesh(Edge1, "SubMesh Edge 1 of Top Face")	428	algoRegE1 = mesh.Segment(Edge1)
485	mesh.AddHypothesis(Edge1, hypProp)	429	hypPropE1 = algoRegE1.Propagation()
486	#mesh.AddHypothesis(Edge1, hypNbSeg15)	430	print hypPropE1.GetName()
487		431	print hypPropE1.GetId()
488	submesh_e2 = mesh.GetSubMesh(Edge2, "SubMesh Edge 2 of Top Face")	432	smesh.SetName(hypPropE1, "Propagation hypothesis")
489	mesh.AddHypothesis(Edge2, hypProp)	433	smesh.SetName(algoRegE1.GetSubMesh(), "SubMesh Edge 1 of Top Face")
490	#mesh.AddHypothesis(Edge2, hypNbSeg15)	434
491		435	algoRegE2 = mesh.Segment(Edge2)
		436	hypPropE2 = algoRegE2.Propagation()
		437	print hypPropE2.GetName()
		438	print hypPropE2.GetId()
		439	smesh.SetName(hypPropE2, "Propagation hypothesis")
		440	smesh.SetName(algoRegE2.GetSubMesh(), "SubMesh Edge 2 of Top Face")
		441
492	print "-------------------------- compute the mesh"	442	print "-------------------------- compute the mesh"
493	smesh.Compute(mesh, Spanner)	443	mesh.Compute()
494		444
495	print "Information about the Mesh:"	445	print "Information about the Mesh:"
496	print "Number of nodes : ", mesh.NbNodes()	446	print "Number of nodes : ", mesh.NbNodes()

Lines 1-23 Link Here

(-)GEOM_SRC_3.2.2/src/EntityGUI/EntityGUI_SketcherDlg.h (-19 / +21 lines)
1	// GEOM GEOMGUI : GUI for Geometry component	1	// GEOM GEOMGUI : GUI for Geometry component
2	//	2	//
3	// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,	3	// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS	4	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5	//	5	//
6	// This library is free software; you can redistribute it and/or	6	// This library is free software; you can redistribute it and/or
7	// modify it under the terms of the GNU Lesser General Public	7	// modify it under the terms of the GNU Lesser General Public
8	// License as published by the Free Software Foundation; either	8	// License as published by the Free Software Foundation; either
9	// version 2.1 of the License.	9	// version 2.1 of the License.
10	//	10	//
11	// This library is distributed in the hope that it will be useful,	11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	// Lesser General Public License for more details.	14	// Lesser General Public License for more details.
15	//	15	//
16	// You should have received a copy of the GNU Lesser General Public	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	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	18	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	//	19	//
20	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com	20	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21	//	21	//
22	//	22	//
23	//	23	//
Lines 58-64 Link Here
58	// purpose :	58	// purpose :
59	//=================================================================================	59	//=================================================================================
60	class EntityGUI_SketcherDlg : public EntityGUI_Skeleton_QTD, public GEOMBase_Helper	60	class EntityGUI_SketcherDlg : public EntityGUI_Skeleton_QTD, public GEOMBase_Helper
61	{	61	{
62	Q_OBJECT	62	Q_OBJECT
63		63
64	public:	64	public:
Lines 66-71 Link Here
66	const char* name = 0, bool modal = FALSE, WFlags fl = 0);	66	const char* name = 0, bool modal = FALSE, WFlags fl = 0);
67	~EntityGUI_SketcherDlg();	67	~EntityGUI_SketcherDlg();
68		68
		69	bool eventFilter (QObject* object, QEvent* event);
		70
69	protected:	71	protected:
70	// redefined from GEOMBase_Helper	72	// redefined from GEOMBase_Helper
71	virtual GEOM::GEOM_IOperations_ptr createOperation();	73	virtual GEOM::GEOM_IOperations_ptr createOperation();
Lines 73-79 Link Here
73	virtual bool execute( ObjectList& objects );	75	virtual bool execute( ObjectList& objects );
74		76
75	void closeEvent( QCloseEvent* e );	77	void closeEvent( QCloseEvent* e );
76	void keyPressEvent( QKeyEvent* e );	78	void keyPressEvent( QKeyEvent* e );
77		79
78	private :	80	private :
79	void Init();	81	void Init();

Lines 127-134 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMImpl/GEOMImpl_BooleanDriver.cxx (-6 / +55 lines)
127	if (!BO.IsDone()) {	127	if (!BO.IsDone()) {
128	StdFail_NotDone::Raise("Common operation can not be performed on the given shapes");	128	StdFail_NotDone::Raise("Common operation can not be performed on the given shapes");
129	}	129	}
130	if (isCompound)	130	if (isCompound) {
131	B.Add(C, BO.Shape());	131	TopoDS_Shape aStepResult = BO.Shape();
		132
		133	// check result of this step: if it is a compound (boolean operations
		134	// allways return a compound), we add all sub-shapes of it.
		135	// This allows to avoid adding empty compounds,
		136	// resulting from COMMON on two non-intersecting shapes.
		137	if (aStepResult.ShapeType() == TopAbs_COMPOUND) {
		138	TopoDS_Iterator aCompIter (aStepResult);
		139	for (; aCompIter.More(); aCompIter.Next()) {
		140	// add shape in a result
		141	B.Add(C, aCompIter.Value());
		142	}
		143	}
		144	else {
		145	// add shape in a result
		146	B.Add(C, aStepResult);
		147	}
		148	}
132	else	149	else
133	aShape = BO.Shape();	150	aShape = BO.Shape();
134	}	151	}
Lines 175-182 Link Here
175	}	192	}
176	aCut = BO.Shape();	193	aCut = BO.Shape();
177	}	194	}
178	if (isCompound)	195	if (isCompound) {
179	B.Add(C, aCut);	196	// check result of this step: if it is a compound (boolean operations
		197	// allways return a compound), we add all sub-shapes of it.
		198	// This allows to avoid adding empty compounds,
		199	// resulting from CUT of parts
		200	if (aCut.ShapeType() == TopAbs_COMPOUND) {
		201	TopoDS_Iterator aCompIter (aCut);
		202	for (; aCompIter.More(); aCompIter.Next()) {
		203	// add shape in a result
		204	B.Add(C, aCompIter.Value());
		205	}
		206	}
		207	else {
		208	// add shape in a result
		209	B.Add(C, aCut);
		210	}
		211	}
180	else	212	else
181	aShape = aCut;	213	aShape = aCut;
182	}	214	}
Lines 229-236 Link Here
229	if (!BO.IsDone()) {	261	if (!BO.IsDone()) {
230	StdFail_NotDone::Raise("Section operation can not be performed on the given shapes");	262	StdFail_NotDone::Raise("Section operation can not be performed on the given shapes");
231	}	263	}
232	if (isCompound)	264	if (isCompound) {
233	B.Add(C, BO.Shape());	265	TopoDS_Shape aStepResult = BO.Shape();
		266
		267	// check result of this step: if it is a compound (boolean operations
		268	// allways return a compound), we add all sub-shapes of it.
		269	// This allows to avoid adding empty compounds,
		270	// resulting from SECTION on two non-intersecting shapes.
		271	if (aStepResult.ShapeType() == TopAbs_COMPOUND) {
		272	TopoDS_Iterator aCompIter (aStepResult);
		273	for (; aCompIter.More(); aCompIter.Next()) {
		274	// add shape in a result
		275	B.Add(C, aCompIter.Value());
		276	}
		277	}
		278	else {
		279	// add shape in a result
		280	B.Add(C, aStepResult);
		281	}
		282	}
234	else	283	else
235	aShape = BO.Shape();	284	aShape = BO.Shape();
236	}	285	}

Lines 170-177 Link Here

(-)GEOM_SRC_3.2.2/src/GEOMImpl/GEOMImpl_ShapeDriver.cxx (-12 / +37 lines)
170	if (!MW.IsDone()) {	170	if (!MW.IsDone()) {
171	Standard_ConstructionError::Raise("Wire construction failed");	171	Standard_ConstructionError::Raise("Wire construction failed");
172	}	172	}
173	//W = TopoDS::Wire(aShapeBase);	173	W = MW;
174	W = MW;
175	}	174	}
176	else {	175	else {
177	Standard_NullObject::Raise	176	Standard_NullObject::Raise
Lines 189-205 Link Here
189	Standard_ConstructionError::Raise("No wires given");	188	Standard_ConstructionError::Raise("No wires given");
190	}	189	}
191		190
192	// first wire	191	// first wire or edge
193	Handle(GEOM_Function) aRefWire = Handle(GEOM_Function)::DownCast(aShapes->Value(1));	192	Handle(GEOM_Function) aRefWire = Handle(GEOM_Function)::DownCast(aShapes->Value(1));
194	TopoDS_Shape aWire = aRefWire->GetValue();	193	TopoDS_Shape aWire = aRefWire->GetValue();
195	if (aWire.IsNull() \|\| aWire.ShapeType() != TopAbs_WIRE) {	194	if (aWire.IsNull()) Standard_NullObject::Raise("Argument Shape is null");
196	Standard_NullObject::Raise("Shape for face construction is null or not a wire");	195	TopoDS_Wire W1;
		196	if(aWire.ShapeType() == TopAbs_WIRE) {
		197	W1 = TopoDS::Wire(aWire);
		198	}
		199	else if(aWire.ShapeType() == TopAbs_EDGE && aWire.Closed()) {
		200	BRepBuilderAPI_MakeWire MW;
		201	MW.Add(TopoDS::Edge(aWire));
		202	if (!MW.IsDone()) {
		203	Standard_ConstructionError::Raise("Wire construction failed");
		204	}
		205	W1 = MW;
		206	}
		207	else {
		208	Standard_NullObject::Raise
		209	("Shape for face construction is neither a wire nor closed edge");
197	}	210	}
198	TopoDS_Wire W = TopoDS::Wire(aWire);
199		211
200	// basic face	212	// basic face
201	TopoDS_Shape FFace;	213	TopoDS_Shape FFace;
202	GEOMImpl_Block6Explorer::MakeFace(W, aCI.GetIsPlanar(), FFace);	214	GEOMImpl_Block6Explorer::MakeFace(W1, aCI.GetIsPlanar(), FFace);
203	if (FFace.IsNull()) {	215	if (FFace.IsNull()) {
204	Standard_ConstructionError::Raise("Face construction failed");	216	Standard_ConstructionError::Raise("Face construction failed");
205	}	217	}
Lines 221-231 Link Here
221	Handle(GEOM_Function) aRefWire_i =	233	Handle(GEOM_Function) aRefWire_i =
222	Handle(GEOM_Function)::DownCast(aShapes->Value(ind));	234	Handle(GEOM_Function)::DownCast(aShapes->Value(ind));
223	TopoDS_Shape aWire_i = aRefWire_i->GetValue();	235	TopoDS_Shape aWire_i = aRefWire_i->GetValue();
224	if (aWire_i.IsNull() \|\| aWire_i.ShapeType() != TopAbs_WIRE) {	236	if (aWire_i.IsNull()) Standard_NullObject::Raise("Argument Shape is null");
225	Standard_NullObject::Raise("Shape for face construction is null or not a wire");	237	TopoDS_Wire W_i;
226	}	238	if(aWire_i.ShapeType() == TopAbs_WIRE) {
227		239	W_i = TopoDS::Wire(aWire_i);
228	FR.Add(TopoDS::Wire(aWire_i));	240	}
		241	else if(aWire_i.ShapeType() == TopAbs_EDGE && aWire_i.Closed()) {
		242	BRepBuilderAPI_MakeWire MW1;
		243	MW1.Add(TopoDS::Edge(aWire_i));
		244	if (!MW1.IsDone()) {
		245	Standard_ConstructionError::Raise("Wire construction failed");
		246	}
		247	W_i = MW1;
		248	}
		249	else {
		250	Standard_NullObject::Raise
		251	("Shape for face construction is neither a wire nor closed edges");
		252	}
		253	FR.Add(W_i);
229	}	254	}
230		255
231	FR.Perform();	256	FR.Perform();

Lines 1-18 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_I/GEOM_Gen_i.cc (-26 / +36 lines)
1	// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,	1	// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS	2	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3	//	3	//
4	// This library is free software; you can redistribute it and/or	4	// This library is free software; you can redistribute it and/or
5	// modify it under the terms of the GNU Lesser General Public	5	// modify it under the terms of the GNU Lesser General Public
6	// License as published by the Free Software Foundation; either	6	// License as published by the Free Software Foundation; either
7	// version 2.1 of the License.	7	// version 2.1 of the License.
8	//	8	//
9	// This library is distributed in the hope that it will be useful	9	// This library is distributed in the hope that it will be useful
10	// but WITHOUT ANY WARRANTY; without even the implied warranty of	10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	// Lesser General Public License for more details.	12	// Lesser General Public License for more details.
13	//	13	//
14	// You should have received a copy of the GNU Lesser General Public	14	// You should have received a copy of the GNU Lesser General Public
15	// License along with this library; if not, write to the Free Software	15	// License along with this library; if not, write to the Free Software
16	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	16	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	//	17	//
18	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com	18	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
Lines 68-85 Link Here
68		68
69	_impl = new ::GEOMImpl_Gen;	69	_impl = new ::GEOMImpl_Gen;
70		70
71	//work around PAL12004, PAL12628	71	//PAL10867: disable signals catching with "noexcepthandler" option
72	//OSD::SetSignal( true );	72	char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
73	bool raiseFPE;	73	if (!envNoCatchSignals \|\| !atoi(envNoCatchSignals))
		74	{
		75	//work around PAL12004, PAL12628
		76	//OSD::SetSignal( true );
		77	bool raiseFPE;
74	#ifdef _DEBUG_	78	#ifdef _DEBUG_
75	raiseFPE = true;	79	raiseFPE = true;
76	char* envDisableFPE = getenv("DISABLE_FPE");	80	char* envDisableFPE = getenv("DISABLE_FPE");
77	if (envDisableFPE && atoi(envDisableFPE))	81	if (envDisableFPE && atoi(envDisableFPE))
78	raiseFPE = false;	82	raiseFPE = false;
79	#else	83	#else
80	raiseFPE = false;	84	raiseFPE = false;
81	#endif	85	#endif
82	OSD::SetSignal( raiseFPE );	86	OSD::SetSignal( raiseFPE );
		87	}
83	}	88	}
84		89
85	//============================================================================	90	//============================================================================
Lines 103-109 Link Here
103	{	108	{
104	GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow(_orb->string_to_object(IORString));	109	GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow(_orb->string_to_object(IORString));
105	if (!CORBA::is_nil(anObject)) {	110	if (!CORBA::is_nil(anObject)) {
106	return strdup(anObject->GetEntry());	111	return CORBA::string_dup(anObject->GetEntry());
107	}	112	}
108	return 0;	113	return 0;
109	}	114	}
Lines 128-134 Link Here
128	GEOM::GEOM_Object_var obj = GetObject(anObject->GetDocID(), anEntry.ToCString());	133	GEOM::GEOM_Object_var obj = GetObject(anObject->GetDocID(), anEntry.ToCString());
129		134
130	CORBA::String_var aPersRefString = _orb->object_to_string(obj);	135	CORBA::String_var aPersRefString = _orb->object_to_string(obj);
131	return strdup(aPersRefString);	136	return CORBA::string_dup(aPersRefString);
132	}	137	}
133		138
134	//============================================================================	139	//============================================================================
Lines 182-189 Link Here
182	}	187	}
183	anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");	188	anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");
184	SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);	189	SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
185	char *aGeomObjIOR = _orb->object_to_string(theObject);	190	//char *aGeomObjIOR = _orb->object_to_string(theObject);
186	anIOR->SetValue(strdup(aGeomObjIOR));	191	CORBA::String_var aGeomObjIOR = _orb->object_to_string(theObject);
		192	//anIOR->SetValue(CORBA::string_dup(aGeomObjIOR));
		193	anIOR->SetValue(aGeomObjIOR);
187		194
188	anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributePixMap");	195	anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributePixMap");
189	SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);	196	SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
Lines 238-244 Link Here
238	aShapeName = "Vertex_";	245	aShapeName = "Vertex_";
239	}	246	}
240	//if (strlen(theName) == 0) aShapeName += TCollection_AsciiString(aResultSO->Tag());	247	//if (strlen(theName) == 0) aShapeName += TCollection_AsciiString(aResultSO->Tag());
241	//else aShapeName = TCollection_AsciiString(strdup(theName));	248	//else aShapeName = TCollection_AsciiString(CORBA::string_dup(theName));
242		249
243	// asv : 11.11.04 Introducing a more sofisticated method of name creation, just as	250	// asv : 11.11.04 Introducing a more sofisticated method of name creation, just as
244	// it is done in GUI in GEOMBase::GetDefaultName() - not just add a Tag() == number	251	// it is done in GUI in GEOMBase::GetDefaultName() - not just add a Tag() == number
Lines 256-262 Link Here
256	aShapeName = aNewShapeName;	263	aShapeName = aNewShapeName;
257	}	264	}
258	else // MOST PROBABLY CALLED FROM GEOM GUI (ALREADY WITH VALID NAME)	265	else // MOST PROBABLY CALLED FROM GEOM GUI (ALREADY WITH VALID NAME)
259	aShapeName = TCollection_AsciiString(strdup(theName));	266	aShapeName = TCollection_AsciiString((char*)theName);
260		267
261	//Set the study entry as a name of the published GEOM_Object	268	//Set the study entry as a name of the published GEOM_Object
262	aShape->SetStudyEntry(aResultSO->GetID());	269	aShape->SetStudyEntry(aResultSO->GetID());
Lines 348-354 Link Here
348	if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);	355	if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);
349		356
350	SALOMEDS::Study_var Study = theComponent->GetStudy();	357	SALOMEDS::Study_var Study = theComponent->GetStudy();
351	TCollection_AsciiString name( strdup(Study->Name()) );	358	TCollection_AsciiString name (Study->Name());
352		359
353	return true;	360	return true;
354	}	361	}
Lines 463-468 Link Here
463	TDF_Tool::Entry(anObj->GetEntry(), anEntry);	470	TDF_Tool::Entry(anObj->GetEntry(), anEntry);
464	GEOM::GEOM_Object_var obj = GetObject(anObj->GetDocID(), anEntry.ToCString());	471	GEOM::GEOM_Object_var obj = GetObject(anObj->GetDocID(), anEntry.ToCString());
465		472
		473	//Set the study entry of the published GEOM_Object
		474	obj->SetStudyEntry(aNewSO->GetID());
		475
466	// Add IORAttribute to the Study and set IOR of the created GEOM_Object to it	476	// Add IORAttribute to the Study and set IOR of the created GEOM_Object to it
467	SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aNewSO, "AttributeIOR");	477	SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aNewSO, "AttributeIOR");
468	SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);	478	SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
Lines 478-484 Link Here
478	//============================================================================	488	//============================================================================
479	char* GEOM_Gen_i::ComponentDataType()	489	char* GEOM_Gen_i::ComponentDataType()
480	{	490	{
481	return strdup("GEOM");	491	return CORBA::string_dup("GEOM");
482	}	492	}
483		493
484	//============================================================================	494	//============================================================================
Lines 529-535 Link Here
529	void GEOM_Gen_i::register_name(char * name)	539	void GEOM_Gen_i::register_name(char * name)
530	{	540	{
531	GEOM::GEOM_Gen_ptr g = GEOM::GEOM_Gen::_narrow(_this());	541	GEOM::GEOM_Gen_ptr g = GEOM::GEOM_Gen::_narrow(_this());
532	name_service->Register(g, strdup(name));	542	name_service->Register(g, CORBA::string_dup(name));
533	}	543	}
534		544
535	//============================================================================	545	//============================================================================

Lines 303-308 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_SWIG/GEOM_TestOthers.py (+15 lines)
303	v_n0p = geompy.MakeVectorDXDYDZ(-1, 0, 1)	303	v_n0p = geompy.MakeVectorDXDYDZ(-1, 0, 1)
304	v_pp0 = geompy.MakeVectorDXDYDZ( 1, 1, 0)	304	v_pp0 = geompy.MakeVectorDXDYDZ( 1, 1, 0)
305	v_np0 = geompy.MakeVectorDXDYDZ(-1, 1, 0)	305	v_np0 = geompy.MakeVectorDXDYDZ(-1, 1, 0)
		306	v_0n0 = geompy.MakeVectorDXDYDZ( 0, -1, 0)
306		307
307	pln_0pp = geompy.MakePlane(p0, v_0pp, 300)	308	pln_0pp = geompy.MakePlane(p0, v_0pp, 300)
308	pln_0np = geompy.MakePlane(p0, v_0np, 300)	309	pln_0np = geompy.MakePlane(p0, v_0np, 300)
Lines 418-423 Link Here
418	geompy.UnionIDs(faces_above, faces_above_pln_ids)	419	geompy.UnionIDs(faces_above, faces_above_pln_ids)
419	geompy.addToStudy(faces_above, "Group of faces above Plane (N = (0, 1, 1))")	420	geompy.addToStudy(faces_above, "Group of faces above Plane (N = (0, 1, 1))")
420		421
		422	# GetShapesOnPlaneWithLocation
		423	Loc = geompy.MakeVertex(0, -50, 0)
		424	edges_on_pln = geompy.GetShapesOnPlaneWithLocation(blocksComp, geompy.ShapeType["EDGE"],
		425	v_0n0, Loc, geompy.GEOM.ST_ON)
		426	for edge_i in edges_on_pln:
		427	geompy.addToStudy(edge_i, "Edge on Plane (N = (0, -1, 0) & Location = (0, -50, 0)")
		428
		429	# GetShapesOnPlaneWithLocationIDs
		430	edges_on_pln_ids = geompy.GetShapesOnPlaneWithLocationIDs(blocksComp, geompy.ShapeType["EDGE"],
		431	v_0n0, Loc, geompy.GEOM.ST_ON)
		432	group_edges_on_pln = geompy.CreateGroup(blocksComp, geompy.ShapeType["EDGE"])
		433	geompy.UnionIDs(group_edges_on_pln, edges_on_pln_ids)
		434	geompy.addToStudy(group_edges_on_pln, "Group of edges on Plane (N = (0, -1, 0) & Location = (0, -50, 0))")
		435
421	# GetShapesOnCylinder	436	# GetShapesOnCylinder
422	edges_out_cyl = geompy.GetShapesOnCylinder(blocksComp, geompy.ShapeType["EDGE"],	437	edges_out_cyl = geompy.GetShapesOnCylinder(blocksComp, geompy.ShapeType["EDGE"],
423	vy, 55, geompy.GEOM.ST_OUT)	438	vy, 55, geompy.GEOM.ST_OUT)

Lines 744-750 Link Here

(-)GEOM_SRC_3.2.2/src/GEOM_SWIG/geompy.py (-2 / +29 lines)
744	return anObj	744	return anObj
745		745
746	## Create a face on the given wire.	746	## Create a face on the given wire.
747	# @param theWire Wire to build the face on.	747	# @param theWire closed Wire or Edge to build the face on.
748	# @param isPlanarWanted If TRUE, only planar face will be built.	748	# @param isPlanarWanted If TRUE, only planar face will be built.
749	# If impossible, NULL object will be returned.	749	# If impossible, NULL object will be returned.
750	# @return New GEOM_Object, containing the created face.	750	# @return New GEOM_Object, containing the created face.
Lines 757-763 Link Here
757	return anObj	757	return anObj
758		758
759	## Create a face on the given wires set.	759	## Create a face on the given wires set.
760	# @param theWires List of wires to build the face on.	760	# @param theWires List of closed wires or edges to build the face on.
761	# @param isPlanarWanted If TRUE, only planar face will be built.	761	# @param isPlanarWanted If TRUE, only planar face will be built.
762	# If impossible, NULL object will be returned.	762	# If impossible, NULL object will be returned.
763	# @return New GEOM_Object, containing the created face.	763	# @return New GEOM_Object, containing the created face.
Lines 901-906 Link Here
901	return aList	901	return aList
902		902
903	## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively	903	## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
		904	# the specified plane by the certain way, defined through \a theState parameter.
		905	# @param theShape Shape to find sub-shapes of.
		906	# @param theShapeType Type of sub-shapes to be retrieved.
		907	# @param theAx1 Vector (or line, or linear edge), specifying normal
		908	# direction of the plane to find shapes on.
		909	# @param thePnt Point specifying location of the plane to find shapes on.
		910	# @param theState The state of the subshapes to find. It can be one of
		911	# ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
		912	# @return List of all found sub-shapes.
		913	#
		914	# Example: see GEOM_TestOthers.py
		915	def GetShapesOnPlaneWithLocation(theShape, theShapeType, theAx1, thePnt, theState):
		916	aList = ShapesOp.GetShapesOnPlaneWithLocation(theShape, theShapeType, theAx1, thePnt, theState)
		917	if ShapesOp.IsDone() == 0:
		918	print "GetShapesOnPlaneWithLocation : ", ShapesOp.GetErrorCode()
		919	return aList
		920
		921	## Works like the above method, but returns list of sub-shapes indices
		922	#
		923	# Example: see GEOM_TestOthers.py
		924	def GetShapesOnPlaneWithLocationIDs(theShape, theShapeType, theAx1, thePnt, theState):
		925	aList = ShapesOp.GetShapesOnPlaneWithLocationIDs(theShape, theShapeType, theAx1, thePnt, theState)
		926	if ShapesOp.IsDone() == 0:
		927	print "GetShapesOnPlaneWithLocationIDs : ", ShapesOp.GetErrorCode()
		928	return aList
		929
		930	## Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
904	# the specified cylinder by the certain way, defined through \a theState parameter.	931	# the specified cylinder by the certain way, defined through \a theState parameter.
905	# @param theShape Shape to find sub-shapes of.	932	# @param theShape Shape to find sub-shapes of.
906	# @param theShapeType Type of sub-shapes to be retrieved.	933	# @param theShapeType Type of sub-shapes to be retrieved.

Lines 137-150 Link Here

(-)GEOM_SRC_3.2.2/src/NMTTools/NMTTools_DEProcessor.cxx (-7 / +7 lines)
137	aNb=myDS->NumberOfShapesOfTheObject();	137	aNb=myDS->NumberOfShapesOfTheObject();
138	//	138	//
139	for (i=1; i<=aNb; i++) {	139	for (i=1; i<=aNb; i++) {
140	const TopoDS_Shape& aF=myDS->Shape(i);	140	const TopoDS_Shape aF=myDS->Shape(i);
141	if (aF.ShapeType()==TopAbs_FACE) {	141	if (aF.ShapeType()==TopAbs_FACE) {
142	TopExp::MapShapesAndAncestors (aF, TopAbs_EDGE, TopAbs_FACE, aMEF);	142	TopExp::MapShapesAndAncestors (aF, TopAbs_EDGE, TopAbs_FACE, aMEF);
143	}	143	}
144	}	144	}
145	//	145	//
146	for (i=1; i<=aNb; i++) {	146	for (i=1; i<=aNb; i++) {
147	const TopoDS_Shape& aS=myDS->Shape(i);	147	const TopoDS_Shape aS=myDS->Shape(i);
148	if (aS.ShapeType()==TopAbs_EDGE) {	148	if (aS.ShapeType()==TopAbs_EDGE) {
149	const TopoDS_Edge& aE=TopoDS::Edge(aS);	149	const TopoDS_Edge& aE=TopoDS::Edge(aS);
150		150
Lines 306-313 Link Here
306	// Clear aPaveSet, aSplitEdges	306	// Clear aPaveSet, aSplitEdges
307	aPaveSet.ChangeSet().Clear();	307	aPaveSet.ChangeSet().Clear();
308	//	308	//
309	const TopoDS_Edge& aDE=TopoDS::Edge(myDS->Shape(nED));	309	const TopoDS_Edge aDE=TopoDS::Edge(myDS->Shape(nED));
310	const TopoDS_Face& aDF=TopoDS::Face(myDS->Shape(nFD));	310	const TopoDS_Face aDF=TopoDS::Face(myDS->Shape(nFD));
311	//	311	//
312	// 2D Curve of degenerated edge on the face aDF	312	// 2D Curve of degenerated edge on the face aDF
313	Handle(Geom2d_Curve) aC2DDE=BRep_Tool::CurveOnSurface(aDE, aDF, aTD1, aTD2);	313	Handle(Geom2d_Curve) aC2DDE=BRep_Tool::CurveOnSurface(aDE, aDF, aTD1, aTD2);
Lines 333-339 Link Here
333	for (; anIt.More(); anIt.Next()) {	333	for (; anIt.More(); anIt.Next()) {
334	const BOPTools_PaveBlock& aPB=anIt.Value();	334	const BOPTools_PaveBlock& aPB=anIt.Value();
335	nE=aPB.Edge();	335	nE=aPB.Edge();
336	const TopoDS_Edge& aE=TopoDS::Edge(myDS->Shape(nE));	336	const TopoDS_Edge aE=TopoDS::Edge(myDS->Shape(nE));
337		337
338	Handle(Geom2d_Curve) aC2D=BRep_Tool::CurveOnSurface(aE, aDF, aT1, aT2);	338	Handle(Geom2d_Curve) aC2D=BRep_Tool::CurveOnSurface(aE, aDF, aT1, aT2);
339	//	339	//
Lines 427-434 Link Here
427	TopoDS_Edge aE, aESplit;	427	TopoDS_Edge aE, aESplit;
428	TopoDS_Vertex aV1, aV2;	428	TopoDS_Vertex aV1, aV2;
429		429
430	const TopoDS_Edge& aDE=TopoDS::Edge(myDS->Shape(nED));	430	const TopoDS_Edge aDE=TopoDS::Edge(myDS->Shape(nED));
431	const TopoDS_Face& aDF=TopoDS::Face(myDS->Shape(nFD));	431	const TopoDS_Face aDF=TopoDS::Face(myDS->Shape(nFD));
432		432
433	BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);	433	BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);
434		434

Lines 270-276 Link Here

(-)GEOM_SRC_3.2.2/src/TransformationGUI/TransformationGUI_OffsetDlg.cxx (-1 / +13 lines)
270	//=================================================================================	270	//=================================================================================
271	bool TransformationGUI_OffsetDlg::isValid( QString& msg )	271	bool TransformationGUI_OffsetDlg::isValid( QString& msg )
272	{	272	{
273	return !(myObjects.length() == 0);	273	//return !(myObjects.length() == 0);
		274	if (myObjects.length() == 0) return false;
		275
		276	for (int i = 0; i < myObjects.length(); i++)
		277	{
		278	GEOM::shape_type aType = myObjects[i]->GetShapeType();
		279	if( aType != GEOM::FACE && aType != GEOM::SHELL && aType != GEOM::SOLID ){
		280	msg = tr("ERROR_SHAPE_TYPE");
		281	return false;
		282	}
		283	}
		284	return true;
274	}	285	}
275		286
276		287
Lines 288-293 Link Here
288	if (GroupPoints->CheckButton1->isChecked() \|\| IsPreview())	299	if (GroupPoints->CheckButton1->isChecked() \|\| IsPreview())
289	for (int i = 0; i < myObjects.length(); i++)	300	for (int i = 0; i < myObjects.length(); i++)
290	{	301	{
		302
291	anObj = GEOM::GEOM_ITransformOperations::_narrow( getOperation() )->OffsetShapeCopy( myObjects[i], GetOffset() );	303	anObj = GEOM::GEOM_ITransformOperations::_narrow( getOperation() )->OffsetShapeCopy( myObjects[i], GetOffset() );
292	if ( !anObj->_is_nil() )	304	if ( !anObj->_is_nil() )
293	objects.push_back( anObj._retn() );	305	objects.push_back( anObj._retn() );