/////////////////////////////////////////////////////////////////////////////// 
// 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 __ODGI_DGLINETYPE_H__
#define __ODGI_DGLINETYPE_H__

#include "Gi/GiNonEntityTraits.h"
#include "Gi/GiLinetype.h"
#include "Gi/GiExport.h"

#include "TD_PackPush.h"

/** \details

    <group OdGi_Classes>
*/
struct OdGiDgLinetypeDash
{
  struct DashInfo
  {
    enum StrokeWidthMode
    {
      kLsNoWidth    = 0,
      kLsWidthLeft  = 1,
      kLsWidthRight = 2,
      kLsWidthFull  = 3
    };
    enum StrokeCapsType
    {
      kLsCapsClosed   = 0,
      kLsCapsOpen     = 1,
      kLsCapsExtended = 2,
      kLsCapsHexagon  = 3,
      kLsCapsOctagon  = 4,
      kLsCapsDecagon  = 5,
      kLsCapsArc      = 30
    };
    enum Flags
    {
      kFlagDash                    = (1 << 0),
      kFlagPassCorner              = (1 << 1),
      kFlagCanBeScaled             = (1 << 2),
      kFlagInvertStrokeInFirstCode = (1 << 3),
      kFlagInvertStrokeInLastCode  = (1 << 4),
      kFlagIncreasingTaper         = (1 << 5),
      kFlagDecreasingTaper         = (1 << 6),
      kFlagBaseStrokeDash          = (1 << 7)
    };

    OdUInt32        m_uFlags;
    double          m_dLength;
    double          m_dStartWidth;
    double          m_dEndWidth;
    StrokeWidthMode m_lsWidthMode;
    StrokeCapsType  m_lsCapsType;

    DashInfo()
      : m_uFlags(0)
      , m_dLength(0.0)
      , m_dStartWidth(0.0)
      , m_dEndWidth(0.0)
      , m_lsWidthMode(kLsNoWidth)
      , m_lsCapsType(kLsCapsClosed)
    { }

    double getLength() const { return m_dLength; }
    void setLength(double dLength) { m_dLength = dLength; }

    double getStartWidth() const { return m_dStartWidth; }
    void setStartWidth(double dWidth) { m_dStartWidth = dWidth; }

    double getEndWidth() const { return m_dEndWidth; }
    void setEndWidth(double dWidth) { m_dEndWidth = dWidth; }

    bool getDashFlag() const { return GETBIT(m_uFlags, kFlagDash); }
    void setDashFlag(bool bSet) { SETBIT(m_uFlags, kFlagDash, bSet); }

    bool getByPassCornerFlag() const { return GETBIT(m_uFlags, kFlagPassCorner); }
    void setByPassCornerFlag(bool bSet) { SETBIT(m_uFlags, kFlagPassCorner, bSet); }

    bool getCanBeScaledFlag() const { return GETBIT(m_uFlags, kFlagCanBeScaled); }
    void setCanBeScaledFlag(bool bSet) { SETBIT(m_uFlags, kFlagCanBeScaled, bSet); }

    bool getInvertStrokeInFirstCodeFlag() const { return GETBIT(m_uFlags, kFlagInvertStrokeInFirstCode); }
    void setInvertStrokeInFirstCodeFlag(bool bSet) { SETBIT(m_uFlags, kFlagInvertStrokeInFirstCode, bSet); }

    bool getInvertStrokeInLastCodeFlag() const { return GETBIT(m_uFlags, kFlagInvertStrokeInLastCode); }
    void setInvertStrokeInLastCodeFlag(bool bSet) { SETBIT(m_uFlags, kFlagInvertStrokeInLastCode, bSet); }

    StrokeWidthMode getWidthMode() const { return m_lsWidthMode; }
    void setWidthMode(StrokeWidthMode iMode) { m_lsWidthMode = iMode; }

    bool getIncreasingTaperFlag() const { return GETBIT(m_uFlags, kFlagIncreasingTaper); }
    void setIncreasingTaperFlag(bool bSet) { SETBIT(m_uFlags, kFlagIncreasingTaper, bSet); }

    bool getDecreasingTaperFlag() const { return GETBIT(m_uFlags, kFlagDecreasingTaper); }
    void setDecreasingTaperFlag(bool bSet) { SETBIT(m_uFlags, kFlagDecreasingTaper, bSet); }

    bool getBaseStrokeDashFlag() const { return GETBIT(m_uFlags, kFlagBaseStrokeDash); }
    void setBaseStrokeDashFlag(bool bSet) { SETBIT(m_uFlags, kFlagBaseStrokeDash, bSet); }

    bool isDashOrBaseStrokeDash() const { return GETBIT(m_uFlags, kFlagDash | kFlagBaseStrokeDash); }

    StrokeCapsType getCapsType() const { return m_lsCapsType; }
    void setCapsType(StrokeCapsType iType) { m_lsCapsType = iType; }
  } m_dash;
  struct ShapeInfo
  {
    enum SymbolPosOnStroke
    {
      kLsNoSymbol         = 0,
      kLsAtOriginOfStroke = 1,
      kLsAtEndOfStroke    = 2,
      kLsAtCenterOfStroke = 3
    };
    enum Flags
    {
      kFlagSymbolAtElementOrigin        = (1 << 0),
      kFlagSymbolAtElementEnd           = (1 << 1),
      kFlagSymbolAtEachVertex           = (1 << 2),
      kFlagMirrorSymbolForReversedLines = (1 << 3),
      kFlagAbsoluteRotationAngle        = (1 << 4),
      kFlagDoNotScaleElement            = (1 << 5),
      kFlagDoNotClipElement             = (1 << 6),
      kFlagNoPartialStrokes             = (1 << 7),
      kFlagPartialOriginBeyondEnd       = (1 << 8),
      kFlagUseSymbolColor               = (1 << 9),
      kFlagUseSymbolWeight              = (1 << 10)
    };

    OdUInt32                 m_uFlags;
    OdDbStub                *m_pSymbol;
    SymbolPosOnStroke        m_lsPos;
    OdGiLinetypeDash::offset m_offset;
    double                   m_dRotation;
    double                   m_dScale;

    ShapeInfo()
      : m_uFlags(0)
      , m_pSymbol(NULL)
      , m_lsPos(kLsNoSymbol)
      , m_dRotation(0.0)
      , m_dScale(0.0)
    {
      m_offset.x = m_offset.y = 0.0;
    }

    OdDbStub *getSymbolId() const { return m_pSymbol; }
    void setSymbolId(OdDbStub *pStub) { m_pSymbol = pStub; }

    SymbolPosOnStroke getSymbolPosOnStroke() const { return m_lsPos; }
    void setSymbolPosOnStroke(SymbolPosOnStroke iMode) { m_lsPos = iMode; }

    bool getSymbolAtElementOriginFlag() const { return GETBIT(m_uFlags, kFlagSymbolAtElementOrigin); }
    void setSymbolAtElementOriginFlag(bool bSet) { SETBIT(m_uFlags, kFlagSymbolAtElementOrigin, bSet); }

    bool getSymbolAtElementEndFlag() const { return GETBIT(m_uFlags, kFlagSymbolAtElementEnd); }
    void setSymbolAtElementEndFlag(bool bSet) { SETBIT(m_uFlags, kFlagSymbolAtElementEnd, bSet); }

    bool getSymbolAtEachVertexFlag() const { return GETBIT(m_uFlags, kFlagSymbolAtEachVertex); }
    void setSymbolAtEachVertexFlag(bool bSet) { SETBIT(m_uFlags, kFlagSymbolAtEachVertex, bSet); }

    bool getMirrorSymbolForReversedLinesFlag() const { return GETBIT(m_uFlags, kFlagMirrorSymbolForReversedLines); }
    void setMirrorSymbolForReversedLinesFlag(bool bSet) { SETBIT(m_uFlags, kFlagMirrorSymbolForReversedLines, bSet); }

    bool getAbsoluteRotationAngleFlag() const { return GETBIT(m_uFlags, kFlagAbsoluteRotationAngle); }
    void setAbsoluteRotationAngleFlag(bool bSet) { SETBIT(m_uFlags, kFlagAbsoluteRotationAngle, bSet); }

    bool getDoNotScaleElementFlag() const { return GETBIT(m_uFlags, kFlagDoNotScaleElement); }
    void setDoNotScaleElementFlag(bool bSet) { SETBIT(m_uFlags, kFlagDoNotScaleElement, bSet); }

    bool getDoNotClipElementFlag() const { return GETBIT(m_uFlags, kFlagDoNotClipElement); }
    void setDoNotClipElementFlag(bool bSet) { SETBIT(m_uFlags, kFlagDoNotClipElement, bSet); }

    bool getNoPartialStrokesFlag() const { return GETBIT(m_uFlags, kFlagNoPartialStrokes); }
    void setNoPartialStrokesFlag(bool bSet) { SETBIT(m_uFlags, kFlagNoPartialStrokes, bSet); }

    bool getPartialOriginBeyondEndFlag() const { return GETBIT(m_uFlags, kFlagPartialOriginBeyondEnd); }
    void setPartialOriginBeyondEndFlag(bool bSet) { SETBIT(m_uFlags, kFlagPartialOriginBeyondEnd, bSet); }

    bool getUseSymbolColorFlag() const { return GETBIT(m_uFlags, kFlagUseSymbolColor); }
    void setUseSymbolColorFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseSymbolColor, bSet); }

    bool getUseSymbolWeightFlag() const { return GETBIT(m_uFlags, kFlagUseSymbolWeight); }
    void setUseSymbolWeightFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseSymbolWeight, bSet); }

    void getOffset(double &x, double &y) const { x = m_offset.x; y = m_offset.y; }
    void setOffset(double x, double y) { m_offset.x = x; m_offset.y = y; }

    double getRotationAngle() const { return m_dRotation; }
    void setRotationAngle(double dRotAngle) { m_dRotation = dRotAngle; }

    double getSymbolScale() const { return m_dScale; }
    void setSymbolScale(double dScale) { m_dScale = dScale; }
  } m_shape;

  OdGiDgLinetypeDash()
    : m_dash()
    , m_shape()
  {
  }
};

typedef OdArray<OdGiDgLinetypeDash> OdGiDgLinetypeDashArray;

/** \details

    <group OdGi_Classes>
*/
struct OdGiDgLinetypeItem
{
  enum Flags
  {
    kFlagAutoPhase              = (1 << 0),
    kFlagUseIterationLimit      = (1 << 1),
    kFlagSingleSegmentMode      = (1 << 2),
    kFlagCenterStretchPhaseMode = (1 << 3),
    kFlagStandardLinetype       = (1 << 4),
    kFlagComputeStandardScale   = (1 << 5)
  };

  OdUInt32                m_uFlags;
  double                  m_dLength;
  double                  m_dPhase;
  OdUInt32                m_nMaxIterations;
  double                  m_dOffset;
  OdGiDgLinetypeDashArray m_dashes;

  OdGiDgLinetypeItem()
    : m_uFlags(0)
    , m_dLength(0.0)
    , m_dPhase(0.0)
    , m_nMaxIterations(1)
    , m_dOffset(0.0)
  {
  }

  double getLength() const { return m_dLength; }
  void setLength(double dLen) { m_dLength = dLen; }

  double getPhase() const { return m_dPhase; }
  void setPhase(double dPhase) { m_dPhase = dPhase; }

  bool getAutoPhaseFlag() const { return GETBIT(m_uFlags, kFlagAutoPhase); }
  void setAutoPhaseFlag(bool bSet) { SETBIT(m_uFlags, kFlagAutoPhase, bSet); }

  bool getUseIterationLimitFlag() const { return GETBIT(m_uFlags, kFlagUseIterationLimit); }
  void setUseIterationLimitFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseIterationLimit, bSet); }

  bool getSingleSegmentModeFlag() const { return GETBIT(m_uFlags, kFlagSingleSegmentMode); }
  void setSingleSegmentModeFlag(bool bSet) { SETBIT(m_uFlags, kFlagSingleSegmentMode, bSet); }

  bool getCenterStretchPhaseModeFlag() const { return GETBIT(m_uFlags, kFlagCenterStretchPhaseMode); }
  void setCenterStretchPhaseModeFlag(bool bSet) { SETBIT(m_uFlags, kFlagCenterStretchPhaseMode, bSet); }

  bool getStandardLinetypeFlag() const { return GETBIT(m_uFlags, kFlagStandardLinetype); }
  void setStandardLinetypeFlag(bool bSet) { SETBIT(m_uFlags, kFlagStandardLinetype, bSet); }

  bool getComputeStandardScaleFlag() const { return GETBIT(m_uFlags, kFlagComputeStandardScale); }
  void setComputeStandardScaleFlag(bool bSet) { SETBIT(m_uFlags, kFlagComputeStandardScale, bSet); }

  OdUInt32 getMaxIterations() const { return m_nMaxIterations; }
  void setMaxIterations(OdUInt32 iMaxNum) { m_nMaxIterations = iMaxNum; }

  double getYOffset() const { return m_dOffset; }
  void setYOffset(double dYOffset) { m_dOffset = dYOffset; }

  OdUInt32 numDashes() const { return m_dashes.size(); }
  void setNumDashes(OdUInt32 count) { m_dashes.resize(count); }

  void dashAt(OdUInt32 index, OdGiDgLinetypeDash& dash) const { dash = m_dashes.at(index); }
  const OdGiDgLinetypeDash& dashAt(OdUInt32 index) const { return m_dashes.at(index); }

  // void setDashAt(OdUInt32 /*index*/, double /*value*/) { throw OdError(eNotImplementedYet); }
  void setDashAt(OdUInt32 index, const OdGiDgLinetypeDash& dash) { m_dashes[index] = dash; }

  void dashes(OdGiDgLinetypeDashArray& dashes) const { dashes = m_dashes; }
  void setDashes(const OdGiDgLinetypeDashArray& dashes) { m_dashes = dashes; }
};

typedef OdArray<OdGiDgLinetypeItem> OdGiDgLinetypeItemArray;

/** \details

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

  OdUInt32                m_uFlags;
  OdGiDgLinetypeItemArray m_items;
  double                  m_dPatLength;
public:
  OdGiDgLinetype()
    : m_uFlags(0)
    , m_dPatLength(0.0)
  {
  }

  bool isContinuous() const { return m_items.empty(); }

  bool isByBlock() const { return GETBIT(m_uFlags, kByBlock); }
  void setByBlock(bool value) { SETBIT(m_uFlags, kByBlock, value); }

  bool isByLayer() const { return GETBIT(m_uFlags, kByLayer); }
  void setByLayer(bool value) { SETBIT(m_uFlags, kByLayer, value); }

  double patternLength() const { return m_dPatLength; }
  void setPatternLength(double dPatLen) { m_dPatLength = dPatLen; }

  OdUInt32 numItems() const { return m_items.size(); }
  void setNumItems(OdUInt32 count) { m_items.resize(count); }

  void itemAt(OdUInt32 index, OdGiDgLinetypeItem& item) const { item = m_items.at(index); }
  const OdGiDgLinetypeItem& itemAt(OdUInt32 index) const { return m_items.at(index); }

  void setItemAt(OdUInt32 index, const OdGiDgLinetypeItem& item) { m_items[index] = item; }

  void items(OdGiDgLinetypeItemArray& items) const { items = m_items; }
  void setItems(const OdGiDgLinetypeItemArray& items) { m_items = items; }
};

/** \details

    <group OdGi_Classes>
*/
struct OdGiDgLinetypeModifiers
{
  enum Flags
  {
    kFlagUseDashScale              = (1 << 0),
    kFlagUseGapScale               = (1 << 1),
    kFlagUseWidth                  = (1 << 2),
    kFlagUseEndWidth               = (1 << 3),
    kFlagUseShift                  = (1 << 4),
    kFlagUseFractionShift          = (1 << 5),
    kFlagUseCenteredShift          = (1 << 6),
    kFlagTrueWidth                 = (1 << 7),
    kFlagOverrideBreakAtCorners    = (1 << 8),
    kFlagOverrideRunThroughCorners = (1 << 9),

    kFlagsWidthMask                = (kFlagUseWidth | kFlagUseEndWidth),
    kFlagsShiftMask                = (kFlagUseShift | kFlagUseFractionShift | kFlagUseCenteredShift),
    kFlagsCornersMask              = (kFlagOverrideBreakAtCorners | kFlagOverrideRunThroughCorners)
  };

  enum WidthMode
  {
    kLsNoWidth = 0,
    kLsWidthConstant,
    kLsWidthTapered
  };
  enum ShiftMode
  {
    kLsNoShift = 0,
    kLsShiftDistance,
    kLsShiftFraction,
    kLsShiftCentered
  };
  enum CornersMode
  {
    kLsCornersFromLS = 0,
    kLsBreakAtCorners,
    kLsRunThroughCorners
  };

  OdUInt32 m_uFlags;
  double m_dDashScale;
  double m_dGapScale;
  double m_dWidth;
  double m_dEndWidth;
  double m_dPhase;

  OdGiDgLinetypeModifiers()
    : m_uFlags(0)
    , m_dDashScale(1.0)
    , m_dGapScale(1.0)
    , m_dWidth(0.0)
    , m_dEndWidth(0.0)
    , m_dPhase(0.0)
  {
  }

  bool getDashScaleFlag() const { return GETBIT(m_uFlags, kFlagUseDashScale); }
  void setDashScaleFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseDashScale, bSet); }

  double getDashScale() const { return m_dDashScale; }
  void setDashScale(double dScale) { m_dDashScale = dScale; }

  bool getGapScaleFlag() const { return GETBIT(m_uFlags, kFlagUseGapScale); }
  void setGapScaleFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseGapScale, bSet); }

  double getGapScale() const { return m_dGapScale; }
  void setGapScale(double dScale) { m_dGapScale = dScale; }

  bool getWidthFlag() const { return GETBIT(m_uFlags, kFlagUseWidth); }
  void setWidthFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseWidth, bSet); }

  double getWidth() const { return m_dWidth; }
  void setWidth(double dWidth) { m_dWidth = dWidth; }

  bool getEndWidthFlag() const { return GETBIT(m_uFlags, kFlagUseEndWidth); }
  void setEndWidthFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseEndWidth, bSet); }

  double getEndWidth() const { return m_dEndWidth; }
  void setEndWidth(double dEndWidth) { m_dEndWidth = dEndWidth; }
  
  WidthMode getWidthMode() const;
  void setWidthMode(WidthMode mode);

  bool getShiftFlag() const { return GETBIT(m_uFlags, kFlagUseShift); }
  void setShiftFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseShift, bSet); }

  bool getFractionShiftFlag() const { return GETBIT(m_uFlags, kFlagUseFractionShift); }
  void setFractionShiftFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseFractionShift, bSet); }

  bool getCenteredShiftFlag() const { return GETBIT(m_uFlags, kFlagUseCenteredShift); }
  void setCenteredShiftFlag(bool bSet) { SETBIT(m_uFlags, kFlagUseCenteredShift, bSet); }

  double getPhase() const { return m_dPhase; }
  void setPhase(double dPhase) { m_dPhase = dPhase; }

  ShiftMode getShiftMode() const;
  void setShiftMode(ShiftMode mode);

  bool getTrueWidthFlag() const { return GETBIT(m_uFlags, kFlagTrueWidth); }
  void setTrueWidthFlag(bool bSet) { SETBIT(m_uFlags, kFlagTrueWidth, bSet); }

  bool getBreakAtCornersFlag() const { return GETBIT(m_uFlags, kFlagOverrideBreakAtCorners); }
  void setBreakAtCornersFlag(bool bSet) { SETBIT(m_uFlags, kFlagOverrideBreakAtCorners, bSet); }

  bool getRunThroughCornersFlag() const { return GETBIT(m_uFlags, kFlagOverrideRunThroughCorners); }
  void setRunThroughCornersFlag(bool bSet) { SETBIT(m_uFlags, kFlagOverrideRunThroughCorners, bSet); }

  CornersMode getCornersMode() const;
  void setCornersMode(CornersMode mode);

  bool operator==(const OdGiDgLinetypeModifiers& lsMod) const;
  bool operator!=(const OdGiDgLinetypeModifiers& lsMod) const;
};

inline OdGiDgLinetypeModifiers::WidthMode OdGiDgLinetypeModifiers::getWidthMode() const
{
  switch (m_uFlags & kFlagsWidthMask)
  {
    case kFlagUseWidth:   return kLsWidthConstant;
    case kFlagsWidthMask: return kLsWidthTapered;
    default:              return kLsNoWidth;
  }
}

inline void OdGiDgLinetypeModifiers::setWidthMode(OdGiDgLinetypeModifiers::WidthMode mode)
{
  switch (mode)
  {
    case kLsWidthConstant: SETBIT_1(m_uFlags, kFlagUseWidth); SETBIT_0(m_uFlags, kFlagUseEndWidth); break;
    case kLsWidthTapered:  SETBIT_1(m_uFlags, kFlagsWidthMask); break;
    default: SETBIT_0(m_uFlags, kFlagsWidthMask);
  };
}

inline OdGiDgLinetypeModifiers::ShiftMode OdGiDgLinetypeModifiers::getShiftMode() const
{
  switch (m_uFlags & kFlagsShiftMask)
  {
    case kFlagUseShift:                         return kLsShiftDistance;
    case kFlagUseShift | kFlagUseFractionShift: return kLsShiftFraction;
    case kFlagUseShift | kFlagUseCenteredShift: return kLsShiftCentered;
    default:                                    return kLsNoShift;
  }
}

inline void OdGiDgLinetypeModifiers::setShiftMode(OdGiDgLinetypeModifiers::ShiftMode mode)
{
  switch (mode)
  {
    case kLsShiftDistance: SETBIT_1(m_uFlags, kFlagUseShift); SETBIT_0(m_uFlags, kFlagUseFractionShift | kFlagUseCenteredShift); break;
    case kLsShiftFraction: SETBIT_1(m_uFlags, kFlagUseShift | kFlagUseFractionShift); SETBIT_0(m_uFlags, kFlagUseCenteredShift); break;
    case kLsShiftCentered: SETBIT_1(m_uFlags, kFlagUseShift | kFlagUseCenteredShift); SETBIT_0(m_uFlags, kFlagUseFractionShift); break;
    default: SETBIT_0(m_uFlags, kFlagsShiftMask);
  }
}

inline OdGiDgLinetypeModifiers::CornersMode OdGiDgLinetypeModifiers::getCornersMode() const
{
  switch (m_uFlags & kFlagsCornersMask)
  {
    case kFlagOverrideBreakAtCorners:    return kLsBreakAtCorners;
    case kFlagOverrideRunThroughCorners: return kLsRunThroughCorners;
    default:                             return kLsCornersFromLS;
  }
}

inline void OdGiDgLinetypeModifiers::setCornersMode(OdGiDgLinetypeModifiers::CornersMode mode)
{
  switch (mode)
  {
    case kLsBreakAtCorners:    SETBIT_1(m_uFlags, kFlagOverrideBreakAtCorners); SETBIT_0(m_uFlags, kFlagOverrideRunThroughCorners); break;
    case kLsRunThroughCorners: SETBIT_0(m_uFlags, kFlagOverrideBreakAtCorners); SETBIT_1(m_uFlags, kFlagOverrideRunThroughCorners); break;
    default:                   SETBIT_0(m_uFlags, kFlagsCornersMask);
  }
}

inline bool OdGiDgLinetypeModifiers::operator ==(const OdGiDgLinetypeModifiers& lsMod) const
{
  return (m_uFlags == lsMod.m_uFlags) &&
         (m_dDashScale == lsMod.m_dDashScale) && (m_dGapScale == lsMod.m_dGapScale) &&
         (m_dWidth == lsMod.m_dWidth) && (m_dEndWidth == lsMod.m_dEndWidth) &&
         (m_dPhase == lsMod.m_dPhase);
}

inline bool OdGiDgLinetypeModifiers::operator !=(const OdGiDgLinetypeModifiers& lsMod) const
{
  return (m_uFlags != lsMod.m_uFlags) ||
         (m_dDashScale != lsMod.m_dDashScale) || (m_dGapScale != lsMod.m_dGapScale) ||
         (m_dWidth != lsMod.m_dWidth) || (m_dEndWidth != lsMod.m_dEndWidth) ||
         (m_dPhase != lsMod.m_dPhase);
}

/** \details

    <group OdGi_Classes> 
*/
class ODGI_EXPORT OdGiDgLinetypeTraits : public OdGiDrawableTraits
{
  public:
    ODRX_DECLARE_MEMBERS(OdGiDgLinetypeTraits);

    virtual void items(OdGiDgLinetypeItemArray& items) const = 0;
    virtual void setItems(const OdGiDgLinetypeItemArray& items) const = 0;

    virtual double patternLength() const = 0;
    virtual void setPatternLength(double dPatLen) = 0;

    virtual double scale() const = 0;
    virtual void setScale(double dScale) = 0;
};

/** \details
    This template class is a specialization of the OdSmartPtr class for OdGiDgLinetypeTraits object pointers.
*/
typedef OdSmartPtr<OdGiDgLinetypeTraits> OdGiDgLinetypeTraitsPtr;

#include "TD_PackPop.h"

#endif // __ODGI_DGLINETYPE_H__