/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#ifndef _ODGILINETYPESEG_INCLUDED_
#define _ODGILINETYPESEG_INCLUDED_


#include "TD_PackPush.h"

#include "OdString.h"
#include "OdArray.h"
#include <math.h>


class OdDbStub;


/** \details

    <group OdGi_Classes> 
*/
class OdGiLinetypeDash
{
public:
  ODRX_HEAP_OPERATORS();

  struct offset
  {
  double            x;
	double            y;
  };
  double            length;
	double            shapeScale;
	double            shapeRotation;
  OdUInt16          flags;
  OdUInt16          shapeNumber;
	offset            shapeOffset;
	OdString          textString;
	OdDbStub*         styleId;

  OdGiLinetypeDash()
  {
    shapeScale = 1.0;
    shapeRotation = shapeScale = length = 0.0;
    flags = shapeNumber = 0;
    shapeOffset.x = shapeOffset.y = 0.0;                                    // MKU 10.03.2004   CR 1690
    styleId = NULL;
  }

  bool isRotationAbsolute() const { return GETBIT(flags, 1); }
	void setRotationAbsolute(bool value = true) { SETBIT(flags, 1, value); }

  bool isRotationUpright() const { return GETBIT(flags, 8); }
	void setRotationUpright(bool value = true) { SETBIT(flags, 8, value); }

  bool isEmbeddedTextString() const { return GETBIT(flags, 2); }
	void setEmbeddedTextString(bool value = true) { SETBIT(flags, 2, value); }

  bool isEmbeddedShape() const { return GETBIT(flags, 4); }
	void setEmbeddedShape(bool value = true) { SETBIT(flags, 4, value); }
};

typedef OdArray<OdGiLinetypeDash> OdGiLinetypeDashArray;
/** \details

    <group OdGi_Classes> 
*/
class OdGiLinetype
{
	enum
	{
		kByBlock            = 1,
		kByLayer            = 2,
		kPatternLengthValid = 4
	};

  mutable OdUInt32          m_flags;
  mutable double            m_patternLength;
  OdGiLinetypeDashArray     m_dashes;
  friend class OdDbLinetypeTableRecord;
  friend class OdDbLinetypeTableRecordImpl;
public:
  OdGiLinetype();

  bool isContinuous() const;

  bool isByBlock() const;
	void setByBlock(bool value);

  bool isByLayer() const;
	void setByLayer(bool value);

  /** \details
      Returns the overall length of this linetype pattern.
  */
  double patternLength() const;

  void setPatternLength(double patternLength);

  /** \details
      Returns the number of dashes of this linetype.
  */
  int numDashes() const;

  /** \details
      Sets the number of dashes for this linetype.
  */
  void setNumDashes(int count);

  void dashAt(int index, OdGiLinetypeDash& dash) const;
  const OdGiLinetypeDash& dashAt(int index) const;

  void setDashAt(int index, double value);
  void setDashAt(int index, const OdGiLinetypeDash& dash);

  void dashes(OdGiLinetypeDashArray& dashes) const;
  void setDashes(const OdGiLinetypeDashArray& dashes);
};


inline bool OdGiLinetype::isByBlock() const     { return GETBIT(m_flags, kByBlock); }
inline void OdGiLinetype::setByBlock(bool value){ SETBIT(m_flags, kByBlock, value); }

inline bool OdGiLinetype::isByLayer() const     { return GETBIT(m_flags, kByLayer); }
inline void OdGiLinetype::setByLayer(bool value){ SETBIT(m_flags, kByLayer, value); }

inline bool OdGiLinetype::isContinuous() const  { return m_dashes.isEmpty(); }

inline void OdGiLinetype::dashes(OdGiLinetypeDashArray& dashes) const { dashes = m_dashes; }
inline void OdGiLinetype::setDashes(const OdGiLinetypeDashArray& dashes)
{
  m_dashes = dashes;
  SETBIT(m_flags, kPatternLengthValid, false);
}

inline OdGiLinetype::OdGiLinetype()
  : m_flags(kPatternLengthValid)
  , m_patternLength(0.)
{
}

inline double OdGiLinetype::patternLength() const
{
  if(!GETBIT(m_flags, kPatternLengthValid))
  {
    int n = m_dashes.size();
    m_patternLength = 0.0;
    while(n--)
    {
      m_patternLength += fabs(m_dashes[n].length);
    }
    SETBIT(m_flags, kPatternLengthValid, true);
  }
  return m_patternLength;
}

inline void OdGiLinetype::setPatternLength(double patternLength)
{
  m_patternLength = patternLength;
  if ( OdZero(patternLength) )
    SETBIT(m_flags, kPatternLengthValid, false);
  else
    SETBIT(m_flags, kPatternLengthValid, true);
}

inline int OdGiLinetype::numDashes() const
{
  return m_dashes.size();
}

inline void OdGiLinetype::setNumDashes(int count)
{
  SETBIT(m_flags, kPatternLengthValid, false);
  m_dashes.setLogicalLength(count);
}

inline void OdGiLinetype::dashAt(int index, OdGiLinetypeDash& dash) const
{
  dash = m_dashes[index];
}

inline const OdGiLinetypeDash& OdGiLinetype::dashAt(int index) const
{
  return m_dashes[index];
}

inline void OdGiLinetype::setDashAt(int index, const OdGiLinetypeDash& dash)
{
  SETBIT(m_flags, kPatternLengthValid, false);
  m_dashes[index] = dash;
}

inline void OdGiLinetype::setDashAt(int index, double dashLength)
{
  SETBIT(m_flags, kPatternLengthValid, false);
  m_dashes[index] = OdGiLinetypeDash();
  m_dashes[index].length = dashLength;
}

#include "TD_PackPop.h"

#endif //_ODGILINETYPESEG_INCLUDED_