// File:	TopoDS_Shape.lxx
// Created:	Wed Mar 20 11:33:14 1991
// Author:	Remi Lequette

#include <TopoDS_TShape.hxx>
#include <TopAbs.hxx>

// The Convex method can conflict with Convex defined as an integer
// in X.h
#ifdef Convex
#undef Convex
#endif

//=======================================================================
//function : TopoDS_Shape
//purpose  : Constructor Null Shape
//=======================================================================

inline TopoDS_Shape::TopoDS_Shape ()
 : myOrient(TopAbs_EXTERNAL)
{
}

//=======================================================================
//function : IsNull
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::IsNull () const
{
  return myTShape.IsNull();
}

//=======================================================================
//function : Nullify
//purpose  : clear the TShape 
//=======================================================================

inline void TopoDS_Shape::Nullify ()
{
  myTShape.Nullify();
}

//=======================================================================
//function : Location
//purpose  : 
//=======================================================================

inline const TopLoc_Location& TopoDS_Shape::Location () const
{
  return myLocation;
}

//=======================================================================
//function : Location
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Location (const TopLoc_Location& Loc)
{
  myLocation = Loc;
}

//=======================================================================
//function : Located
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::Located (const TopLoc_Location& Loc) const
{
  TopoDS_Shape S(*this);
  S.Location(Loc);
  return S;
}

//=======================================================================
//function : Orientation
//purpose  : 
//=======================================================================

inline TopAbs_Orientation TopoDS_Shape::Orientation () const
{
  return myOrient;
}

//=======================================================================
//function : Orientation
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Orientation (const TopAbs_Orientation Orient)
{
  myOrient = Orient;
}

//=======================================================================
//function : Oriented
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::Oriented (const TopAbs_Orientation Or) const
{
  TopoDS_Shape S(*this);
  S.Orientation(Or);
  return S;
}

//=======================================================================
//function : TShape
//purpose  : 
//=======================================================================

inline const Handle(TopoDS_TShape)& TopoDS_Shape::TShape () const
{
  return myTShape;
}

//=======================================================================
//function : ShapeType
//purpose  : 
//=======================================================================

inline TopAbs_ShapeEnum TopoDS_Shape::ShapeType() const
{
  return myTShape->ShapeType();
}

//=======================================================================
//function : Free
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Free () const
{
  return myTShape->Free();
}

//=======================================================================
//function : Free
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Free (const Standard_Boolean B)
{
  myTShape->Free(B);
}

//=======================================================================
//function : Modified
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Modified () const
{
  return myTShape->Modified();
}

//=======================================================================
//function : Modified
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Modified (const Standard_Boolean B)
{
  myTShape->Modified(B);
}

//=======================================================================
//function : Checked
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Checked () const
{
  return myTShape->Checked();
}

//=======================================================================
//function : Checked
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Checked (const Standard_Boolean B)
{
  myTShape->Checked(B);
}

//=======================================================================
//function : Orientable
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Orientable () const
{
  return myTShape->Orientable();
}

//=======================================================================
//function : Orientable
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Orientable (const Standard_Boolean B)
{
  myTShape->Orientable(B);
}

//=======================================================================
//function : Closed
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Closed () const
{
  return myTShape->Closed();
}

//=======================================================================
//function : Closed
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Closed (const Standard_Boolean B)
{
  myTShape->Closed(B);
}

//=======================================================================
//function : Infinite
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Infinite () const
{
  return myTShape->Infinite();
}

//=======================================================================
//function : Infinite
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Infinite (const Standard_Boolean B)
{
  myTShape->Infinite(B);
}

//=======================================================================
//function : Convex
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::Convex () const
{
  return myTShape->Convex();
}

//=======================================================================
//function : Convex
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Convex (const Standard_Boolean B)
{
  myTShape->Convex(B);
}

//=======================================================================
//function : Move
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Move (const TopLoc_Location& position)
{
  myLocation = position * myLocation;
}

//=======================================================================
//function : Moved
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::Moved 
  (const TopLoc_Location& position) const
{
  TopoDS_Shape S(*this);
  S.Move(position);
  return S;
}

//=======================================================================
//function : Reverse
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Reverse()
{
  myOrient = TopAbs::Reverse(myOrient);
}

//=======================================================================
//function : Reversed
//purpose  : 
//=======================================================================

inline TopoDS_Shape  TopoDS_Shape::Reversed() const
{
  TopoDS_Shape S(*this);
  S.Reverse();
  return S;
}

//=======================================================================
//function : Complement
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Complement()
{
  myOrient = TopAbs::Complement(myOrient);
}

//=======================================================================
//function : Complemented
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::Complemented() const
{
  TopoDS_Shape S(*this);
  S.Complement();
  return S;
}

//=======================================================================
//function : Compose
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::Compose(const TopAbs_Orientation Orient)
{
  myOrient = TopAbs::Compose(myOrient,Orient);
}

//=======================================================================
//function : Composed
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::Composed
  (const TopAbs_Orientation Orient) const
{
  TopoDS_Shape S(*this);
  S.Compose(Orient);
  return S;
}

//=======================================================================
//function : IsPartner
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::IsPartner (const TopoDS_Shape& other) const
{
  return (myTShape == other.myTShape);
}

//=======================================================================
//function : IsSame
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::IsSame (const TopoDS_Shape& other) const
{
  return (myTShape == other.myTShape) &&
         (myLocation == other.myLocation);
}

//=======================================================================
//function : IsEqual
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::IsEqual (const TopoDS_Shape& other) const
{
  return (myTShape == other.myTShape) &&
         (myLocation == other.myLocation) &&
         (myOrient == other.myOrient);
}

//=======================================================================
//function : IsNotEqual
//purpose  : 
//=======================================================================

inline Standard_Boolean TopoDS_Shape::IsNotEqual (const TopoDS_Shape& other) const
{
  return !IsEqual(other);
}

//=======================================================================
//function : EmptyCopy
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::EmptyCopy()
{
  myTShape = myTShape->EmptyCopy();
}

//=======================================================================
//function : EmptyCopied
//purpose  : 
//=======================================================================

inline TopoDS_Shape TopoDS_Shape::EmptyCopied() const
{
  TopoDS_Shape S(*this);
  S.EmptyCopy();
  return S;
}
  
//=======================================================================
//function : TShape
//purpose  : 
//=======================================================================

inline void TopoDS_Shape::TShape (const Handle(TopoDS_TShape& TS))
{
  myTShape = TS;
}