0022048: Visualization, AIS_InteractiveContext - single object selection should alway...

[occt.git] / src / TopOpeBRep / TopOpeBRep_Point2d.lxx

// Created on: 1998-10-29
// Created by: Jean Yves LEBEY
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <TopOpeBRep_define.hxx>

//=======================================================================
//function : SetPint
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetPint(const IntRes2d_IntersectionPoint& P)
{
  mypint = P;
  myhaspint = Standard_True;
}

//=======================================================================
//function : HasPint
//purpose  : 
//=======================================================================
inline Standard_Boolean TopOpeBRep_Point2d::HasPint() const
{
  return myhaspint;
}

//=======================================================================
//function : Pint
//purpose  : 
//=======================================================================
inline const IntRes2d_IntersectionPoint& TopOpeBRep_Point2d::Pint() const
{
  if (!HasPint()) throw Standard_Failure("TopOpeBRep_Point2d::Pint");
  return mypint;
}

//=======================================================================
//function : SetIsVertex
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetIsVertex(const Standard_Integer Index,const Standard_Boolean B)
{
  if      (Index == 1) myisvertex1 = B;
  else if (Index == 2) myisvertex2 = B;
  else throw Standard_Failure("TopOpeBRep_Point2d::SetIsVertex");
}

//=======================================================================
//function : IsVertex
//purpose  : 
//=======================================================================
inline Standard_Boolean TopOpeBRep_Point2d::IsVertex(const Standard_Integer Index) const
{
  if      (Index == 1) return myisvertex1;
  else if (Index == 2) return myisvertex2;
  else throw Standard_Failure("TopOpeBRep_Point2d::IsVertex");
}

//=======================================================================
//function : SetVertex
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetVertex(const Standard_Integer Index,const TopoDS_Vertex& V)
{
  if      (Index == 1) {myvertex1 = V; myisvertex1 = Standard_True;}
  else if (Index == 2) {myvertex2 = V; myisvertex2 = Standard_True;}
  else throw Standard_Failure("TopOpeBRep_Point2d::SetVertex");
}

//=======================================================================
//function : SetTransition
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetTransition(const Standard_Integer Index,const TopOpeBRepDS_Transition& T)
{
  if      (Index == 1) mytransition1 = T;
  else if (Index == 2) mytransition2 = T;
  else throw Standard_Failure("TopOpeBRep_Point2d::SetTransition");
}

//=======================================================================
//function : SetParameter
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetParameter(const Standard_Integer Index,const Standard_Real P)
{
  if      (Index == 1) myparameter1 = P;
  else if (Index == 2) myparameter2 = P;
  else throw Standard_Failure("TopOpeBRep_Point2d::SetParameter");
}

//=======================================================================
//function : Parameter
//purpose  : 
//=======================================================================
inline Standard_Real TopOpeBRep_Point2d::Parameter(const Standard_Integer Index) const
{
  if      (Index == 1) return myparameter1;
  else if (Index == 2) return myparameter2;
  else throw Standard_Failure("TopOpeBRep_Point2d::Parameter");
}

//=======================================================================
//function : SetIsPointOfSegment
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetIsPointOfSegment(const Standard_Boolean B)
{
  myispointofsegment = B;
}

//=======================================================================
//function : IsPointOfSegment
//purpose  : 
//=======================================================================
inline Standard_Boolean TopOpeBRep_Point2d::IsPointOfSegment() const
{
  return myispointofsegment;
}

//=======================================================================
//function : SetSegmentAncestors
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetSegmentAncestors(const Standard_Integer IP1,const Standard_Integer IP2)
{
  myips1 = IP1;
  myips2 = IP2;
  myhasancestors = (myips1 != 0 && myips2 != 0);
  if (myhasancestors) mystatus = TopOpeBRep_P2DNEW; 
}

//=======================================================================
//function : SegmentAncestors
//purpose  : 
//=======================================================================
inline Standard_Boolean TopOpeBRep_Point2d::SegmentAncestors(Standard_Integer& IP1,Standard_Integer& IP2) const
{
  IP1 = myips1;
  IP2 = myips2;
  return myhasancestors;
}

//=======================================================================
//function : SetStatus
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetStatus(const TopOpeBRep_P2Dstatus I)
{
  mystatus = I;
}

//=======================================================================
//function : Status
//purpose  : 
//=======================================================================
inline TopOpeBRep_P2Dstatus TopOpeBRep_Point2d::Status() const
{
  return mystatus;
}

//=======================================================================
//function : SetIndex
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetIndex(const Standard_Integer I)
{
  myindex = I;
}

//=======================================================================
//function : Index
//purpose  : 
//=======================================================================
inline Standard_Integer TopOpeBRep_Point2d::Index() const
{
  return myindex;
}

//=======================================================================
//function : SetValue
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetValue(const gp_Pnt& P)
{
  mypnt = P;
}

//=======================================================================
//function : Value
//purpose  : 
//=======================================================================
inline const gp_Pnt& TopOpeBRep_Point2d::Value() const
{
  return mypnt;
}

//=======================================================================
//function : SetValue2d
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetValue2d(const gp_Pnt2d& P)
{
  mypnt2d = P;
}

//=======================================================================
//function : Value2d
//purpose  : 
//=======================================================================
inline const gp_Pnt2d& TopOpeBRep_Point2d::Value2d() const
{
  return mypnt2d;
}

//=======================================================================
//function : SetKeep
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetKeep(const Standard_Boolean B)
{
  mykeep = B;
}

//=======================================================================
//function : Keep
//purpose  : 
//=======================================================================
inline Standard_Boolean TopOpeBRep_Point2d::Keep() const
{
  return mykeep;
}

//=======================================================================
//function : SetEdgesConfig
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetEdgesConfig(const TopOpeBRepDS_Config B)
{
  myedgesconfig = B;
}

//=======================================================================
//function : EdgesConfig
//purpose  : 
//=======================================================================
inline TopOpeBRepDS_Config TopOpeBRep_Point2d::EdgesConfig() const
{
  return myedgesconfig;
}

//=======================================================================
//function : SetTolerance
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetTolerance(const Standard_Real t)
{
  mytolerance = t;
}

//=======================================================================
//function : Tolerance
//purpose  : 
//=======================================================================
inline Standard_Real TopOpeBRep_Point2d::Tolerance() const
{
  return mytolerance;
}

//=======================================================================
//function : SetHctxff2d
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetHctxff2d(const Handle(TopOpeBRep_Hctxff2d)& h)
{
  myctxff2d = h;
}

//=======================================================================
//function : Hctxff2d
//purpose  : 
//=======================================================================
inline Handle(TopOpeBRep_Hctxff2d) TopOpeBRep_Point2d::Hctxff2d() const
{
  return myctxff2d;
}

//=======================================================================
//function : SetHctxee2d
//purpose  : 
//=======================================================================
inline void TopOpeBRep_Point2d::SetHctxee2d(const Handle(TopOpeBRep_Hctxee2d)& h)
{
  myctxee2d = h;
}

//=======================================================================
//function : Hctxee2d
//purpose  : 
//=======================================================================
inline Handle(TopOpeBRep_Hctxee2d) TopOpeBRep_Point2d::Hctxee2d() const
{
  return myctxee2d;
}