#ifndef __LEDSEDGEUSE_H__
#define __LEDSEDGEUSE_H__

#include "compgeomlib.h"

class CLEDSliteVertex;
class CLEDSliteFace;
class CLEDSVertex;
class CLEDSFace;
class CLEDSContourIter;
class CLEDSGeometry;
//////////////////////////////////////////////////////////////////////////////
// CLEDSliteEdgeUse Class
//

class CLEDSliteEdgeUse : public CPlanar
{
public:
  friend class CLEDSliteContourIter;
  friend class CLEDSliteSiblingIter;

//////////////////////////////////////////////////
// Enumerated Types
//

//////////////////////////////////////////////////
// Initialization
//
public:
  CLEDSliteEdgeUse();
  virtual ~CLEDSliteEdgeUse();
  VOID Init(CLEDSGeometry *pCLEDSGeometry);
  VOID Init(CLEDSliteVertex *, CLEDSliteEdgeUse *, CLEDSliteEdgeUse *,
			CLEDSliteEdgeUse *,  CLEDSliteFace *,  CLEDSGeometry *);
  virtual VOID Uninit();
  virtual VOID Delete();

//////////////////////////////////////////////////
// Geometric Computations
//
public:
  FLOAT GetLength();
protected:

//////////////////////////////////////////////////
// Rendering
//
public:
  VOID Render(BOOL bFacetted, BOOL bTexture);
  VOID RenderNormals(FLOAT fMag);

//////////////////////////////////////////////////
// Output Functions
//
public:
  CGeometryIter *AllocateIter();
  VOID FreeIter(CGeometryIter *pCPlanarIter);
public:
  virtual VOID Display() const;
  VOID WriteSTL(FILE *fpOutputFile);

//////////////////////////////////////////////////
// Accessor Functions
//
public:

  inline  CLEDSliteEdgeUse *GetLEDSSiblingEdgeUse() const;
  inline  VOID SetLEDSSiblingEdgeUse(CLEDSliteEdgeUse *);
  inline  CLEDSliteVertex *GetLEDSRootVtx() const;
  inline  CLEDSliteVertex *GetLEDSOtherVtx() const;
  inline  VOID SetLEDSRootVtx(CLEDSliteVertex *);
  inline  CLEDSliteEdgeUse *GetLEDSNCEdgeUse() const;
  virtual CLEDSliteEdgeUse *GetLEDSPrevCEdgeUse() const;
  inline  VOID SetLEDSNCEdgeUse(CLEDSliteEdgeUse *);
  inline  CLEDSliteEdgeUse *GetLEDSNVEdgeUse() const;
  inline  VOID SetLEDSNVEdgeUse(CLEDSliteEdgeUse *);
  inline  CLEDSliteFace *GetLEDSFace() const;
  inline  VOID SetLEDSFace(CLEDSliteFace *);
  inline VOID SetExtra(VOID *);
  inline CLEDSGeometry *GetLEDSGeometry() const;
  inline VOID *GetExtra();

  UINT_32 GetVertexCount();
//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
protected:
  CLEDSliteVertex *m_pledsRootVtx; 
  CLEDSliteEdgeUse *m_pledsNCEdgeUse; 
  CLEDSliteEdgeUse *m_pledsSiblingEdgeUse; 
  CLEDSliteEdgeUse *m_pledsNVEdgeUse;
  CLEDSliteFace *m_pledsFace;
  CLEDSGeometry *m_pCLEDSGeometry;
  VOID *m_pExtra;
};



inline CLEDSliteEdgeUse *CLEDSliteEdgeUse::GetLEDSSiblingEdgeUse() const
{
  return m_pledsSiblingEdgeUse;
}

inline VOID CLEDSliteEdgeUse::SetLEDSSiblingEdgeUse(CLEDSliteEdgeUse *pleds)
{
 m_pledsSiblingEdgeUse = pleds;
}

inline CLEDSliteVertex *CLEDSliteEdgeUse::GetLEDSRootVtx() const
{
  return m_pledsRootVtx;
}

inline CLEDSliteVertex *CLEDSliteEdgeUse::GetLEDSOtherVtx() const
{
  return GetLEDSNCEdgeUse()->GetLEDSRootVtx();
}

inline VOID CLEDSliteEdgeUse::SetLEDSRootVtx(CLEDSliteVertex *pleds)
{
 m_pledsRootVtx = pleds;
}

inline CLEDSliteEdgeUse *CLEDSliteEdgeUse::GetLEDSNCEdgeUse() const
{
  return m_pledsNCEdgeUse;
}

inline VOID CLEDSliteEdgeUse::SetLEDSNCEdgeUse(CLEDSliteEdgeUse *pleds)
{
 m_pledsNCEdgeUse = pleds;
}

inline CLEDSliteEdgeUse *CLEDSliteEdgeUse::GetLEDSNVEdgeUse() const
{
  return m_pledsNVEdgeUse;
}

inline VOID CLEDSliteEdgeUse::SetLEDSNVEdgeUse(CLEDSliteEdgeUse *pleds)
{
 m_pledsNVEdgeUse = pleds;
}

inline CLEDSliteFace *CLEDSliteEdgeUse::GetLEDSFace() const
{
  return m_pledsFace;
}

inline VOID CLEDSliteEdgeUse::SetLEDSFace(CLEDSliteFace *pleds)
{
 m_pledsFace = pleds;
}

inline VOID CLEDSliteEdgeUse::SetExtra(VOID *pExtra)
{
  m_pExtra = pExtra;
}

inline CLEDSGeometry *CLEDSliteEdgeUse::GetLEDSGeometry() const
{
  return m_pCLEDSGeometry;
}

inline VOID *CLEDSliteEdgeUse::GetExtra()
{
  return m_pExtra;
}

//////////////////////////////////////////////////////////////////////////////
// CLEDSEdgeUse Class
//

//virtual public doesn't work.
class CLEDSEdgeUse : public CLEDSliteEdgeUse
{
public:
  friend class CLEDSContourIter;
  friend class CLEDSSiblingIter;

//////////////////////////////////////////////////
// Enumerated Types
//

//////////////////////////////////////////////////
// Initialization
//
public:
  CLEDSEdgeUse();
  virtual ~CLEDSEdgeUse();
  VOID Init(LID lidLID, LID lidRootVtx, LID lidNCEdgeUse, 
					LID lidSiblingEdgeUse, LID lidNVEdgeUse, LID lidFace,
					CLEDSGeometry *pCG);
  VOID Uninit();

//////////////////////////////////////////////////
// Output Functions
//
public:
  VOID Display() const;

//////////////////////////////////////////////////
// Accessor Functions
//
public:
  inline  LID GetLID() const;
  inline  VOID SetLID(const LID &lid);
  inline  LID GetSiblingEdgeUse() const;
  inline  VOID SetSiblingEdgeUse(const LID &lid);
  inline  LID GetRootVtx() const;
  inline  VOID SetRootVtx(const LID &lid);
  inline  LID GetNCEdgeUse() const;
  inline  VOID SetNCEdgeUse(const LID &lid);
  inline  LID GetNVEdgeUse() const;
  inline  VOID SetNVEdgeUse(const LID &lid);
  inline  LID GetFace() const;
  inline  VOID SetFace(const LID &lid);

  CLEDSEdgeUse *GetSafeLEDSSiblingEdgeUse() const;
  CLEDSVertex *GetSafeLEDSRootVtx() const;
  CLEDSVertex *GetSafeLEDSOtherVtx() const;
  CLEDSEdgeUse *GetSafeLEDSNCEdgeUse() const;
  CLEDSEdgeUse *GetSafeLEDSNVEdgeUse() const;
  CLEDSFace *GetSafeLEDSFace() const;

//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
protected:
  LID m_lidLID;
  LID m_lidRootVtx; 
  LID m_lidNCEdgeUse; 
  LID m_lidSiblingEdgeUse; 
  LID m_lidNVEdgeUse;
  LID m_lidFace;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//
inline LID CLEDSEdgeUse::GetLID() const
{
  return m_lidLID;
}

inline VOID CLEDSEdgeUse::SetLID(const LID &lid)
{
  m_lidLID = lid;
}

inline LID CLEDSEdgeUse::GetSiblingEdgeUse() const
{
  return m_lidSiblingEdgeUse;
}

inline VOID CLEDSEdgeUse::SetSiblingEdgeUse(const LID &lid)
{
 m_lidSiblingEdgeUse = lid;
}

inline LID CLEDSEdgeUse::GetRootVtx() const
{
  return m_lidRootVtx;
}

inline VOID CLEDSEdgeUse::SetRootVtx(const LID &lid)
{
 m_lidRootVtx = lid;
}

inline LID CLEDSEdgeUse::GetNCEdgeUse() const
{
  return m_lidNCEdgeUse;
}

inline VOID CLEDSEdgeUse::SetNCEdgeUse(const LID &lid)
{
 m_lidNCEdgeUse = lid;
}

inline LID CLEDSEdgeUse::GetNVEdgeUse() const
{
  return m_lidNVEdgeUse;
}

inline VOID CLEDSEdgeUse::SetNVEdgeUse(const LID &lid)
{
 m_lidNVEdgeUse = lid;
}

inline LID CLEDSEdgeUse::GetFace() const
{
  return m_lidFace;
}

inline VOID CLEDSEdgeUse::SetFace(const LID &lid)
{
 m_lidFace = lid;
}

class CLEDSEdgeUsePrev : public CLEDSliteEdgeUse
{
public:
  //  friend class CLEDSContourIter;
  //  friend class CLEDSSiblingIter;

//////////////////////////////////////////////////
// Initialization
//
public:
  inline CLEDSEdgeUsePrev();
  virtual inline ~CLEDSEdgeUsePrev();
  inline VOID Uninit();

//////////////////////////////////////////////////
// Accessor Functions
//
public:
  //virtual CLEDSEdgeUsePrev *GetLEDSPrevCEdgeUse() const;
  virtual CLEDSliteEdgeUse *GetLEDSPrevCEdgeUse() const;
//////////////////////////////////////////////////
// Member Variables
//
protected:
  CLEDSEdgeUsePrev *m_pledsPrevCEdgeUse; 
};

inline CLEDSEdgeUsePrev::CLEDSEdgeUsePrev()
{
  m_pledsPrevCEdgeUse = NULL;
}

inline CLEDSEdgeUsePrev::~CLEDSEdgeUsePrev()
{
//  Uninit();
}

inline VOID CLEDSEdgeUsePrev::Uninit()
{
  CLEDSliteEdgeUse::Uninit();
}








//////////////////////////////////////////////////////////////////////////////
// CLEDSContourIter Class
//

class CLEDSliteContourIter: public CGeometryIter
{
public:
  CLEDSliteContourIter();
  virtual ~CLEDSliteContourIter();
  virtual VOID Init(CLEDSliteEdgeUse *pCLEDSContour);

protected:
  virtual VOID Uninit();
  virtual BOOL Valid();

public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekNextContourEU();

protected:
  CLEDSliteEdgeUse *m_pledsEdgeIter;
};

//////////////////////////////////////////////////////////////////////////////
// CLEDSSiblingIter Class
//

class CLEDSliteSiblingIter : public CGeometryIter
{
public:
  CLEDSliteSiblingIter();
  virtual ~CLEDSliteSiblingIter();
  virtual VOID Init(CLEDSliteEdgeUse *pCLEDSSibling);

protected:
  virtual VOID Uninit();
  virtual BOOL Valid();

public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekFirstSiblingEU();
  virtual CLEDSliteEdgeUse *PeekNextSiblingEU();

protected:
  CLEDSliteEdgeUse *m_pledsEdgeIter;
};

//////////////////////////////////////////////////////////////////////////////
// CLEDSSiblingIter Class
//

class CLEDSSiblingIter : public CLEDSliteSiblingIter
{
public:
  CLEDSSiblingIter();
  virtual ~CLEDSSiblingIter();
  /*
  virtual VOID Init(CLEDSEdgeUse *pCLEDSSibling);

protected:
  virtual VOID Uninit();
  virtual BOOL Valid();
  */
public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekFirstSiblingEU();
  virtual CLEDSliteEdgeUse *PeekNextSiblingEU();

protected:
//  CLEDSEdgeUse *m_pledsEdgeIter;
};

//////////////////////////////////////////////////////////////////////////////
// CLEDSContourIter Class
//

class CLEDSContourIter: public CLEDSliteContourIter
{
public:
  CLEDSContourIter();
  virtual ~CLEDSContourIter();

public:
  // Iteration Functions
  virtual CLEDSliteEdgeUse *PeekNextContourEU();

protected:
//  CLEDSEdgeUse *m_pledsEdgeIter;
};



#endif // __LEDSEDGEUSE_H__