/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2024, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 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 _ODDBDIMMULTIMODESGRIPPE_INCLUDED
#define _ODDBDIMMULTIMODESGRIPPE_INCLUDED

#include "DbMultiModesGripPE.h"
#include "GripPointsExports.h"
#include "DbDimension.h"

/************************************************************************/
/* This class is an specialization of the OdDbMultiModesGripPE class for*/
/* OdDbDimension entities.                                              */
/************************************************************************/

class OdDbDimensionMultiModesGripPE : public OdDbMultiModesGripPE
{
public:
  virtual bool getGripModes(const OdDbEntity* pEnt, OdDbGripData* pGripData, OdArray<OdDbMultiModesGripPE::GripMode>& modes, unsigned int& curMode) const ODRX_OVERRIDE;
  virtual unsigned int mode(OdDbEntity* pEnt, OdDbGripData* pGripData) const ODRX_OVERRIDE;
  virtual GripMode modeEx(OdDbEntity* pEnt, OdDbGripData* pGripData) const ODRX_OVERRIDE;
  virtual bool setMode(OdDbEntity* pEnt, OdDbGripData* pGripData, unsigned int newMode) ODRX_OVERRIDE;
  virtual GripType gripType(OdDbEntity* pEnt, OdDbGripData* pGripData) const ODRX_OVERRIDE;
  virtual void reset(OdDbEntity* pEnt) ODRX_OVERRIDE;
};

class GRIPPOINTS_EXPORT OdGripDimMultiModeAppData : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGripDimMultiModeAppData);
  OdGripDimMultiModeAppData() : m_modes(), m_mode(0),
    m_gripType(OdDbMultiModesGripPE::kPrimary) { }

  void getGripModes(OdArray<OdDbMultiModesGripPE::GripMode>& modes);
  const unsigned int mode() const { return m_mode; }
  void setMode(unsigned int mode) { m_mode = mode; }
  OdDbMultiModesGripPE::GripMode gripMode() const { return m_modes.at(m_mode); }
  OdDbMultiModesGripPE::GripType gripType() const { return m_gripType; }
  virtual bool getIndices(OdIntArray& indices) const = 0;
  virtual bool isFirstGrip() const { return false; };
  virtual bool isSecondGrip() const { return false; };
protected:
  std::map<unsigned, OdDbMultiModesGripPE::GripMode> m_modes;
private:
  unsigned int m_mode;
  OdDbMultiModesGripPE::GripType m_gripType;
};

typedef OdSmartPtr<OdGripDimMultiModeAppData> OdGripDimMultiModeAppDataPtr;

/************************************************************************/
/*                       OdDbAlignedDimension                           */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripAlignedDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    POINT1 = 0,
    POINT2 = 1,
    FIRST = 2,
    SECOND = 3,
    TEXT = 4, 
    JOG = 5
  };

  ODRX_DECLARE_MEMBERS(OdGripAlignedDimMultiModeAppData);
  OdGripAlignedDimMultiModeAppData() = delete;
  OdGripAlignedDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripAlignedDimMultiModeAppData> OdGripAlignedDimMultiModeAppDataPtr;

/************************************************************************/
/*                         OdDbRotatedDimension                         */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripRotatedDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    POINT1 = 0,
    POINT2 = 1,
    FIRST = 2,
    SECOND = 3,
    TEXT = 4,
    JOG = 5
  };

public:
  ODRX_DECLARE_MEMBERS(OdGripRotatedDimMultiModeAppData);
  OdGripRotatedDimMultiModeAppData() = delete;
  OdGripRotatedDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripRotatedDimMultiModeAppData> OdGripRotatedDimMultiModeAppDataPtr;

/************************************************************************/
/*                     OdDb3PointAngularDimension                       */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGrip3PointAngularDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    FIRST = 0,
    SECOND = 1,
    CENTER = 2, 
    ARC = 3,
    TEXT = 4
  };

public:
  ODRX_DECLARE_MEMBERS(OdGrip3PointAngularDimMultiModeAppData);
  OdGrip3PointAngularDimMultiModeAppData() = delete;
  OdGrip3PointAngularDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGrip3PointAngularDimMultiModeAppData> OdGrip3PointAngularDimMultiModeAppDataPtr;

/************************************************************************/
/*                      OdDb2LineAngularDimension                       */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGrip2LineAngularDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    LINE1_START = 0,
    LINE1_END = 1, 
    LINE2_START = 2, 
    LINE2_END = 3,
    ARC = 4,
    TEXT = 5
  };

public:
  ODRX_DECLARE_MEMBERS(OdGrip2LineAngularDimMultiModeAppData);
  OdGrip2LineAngularDimMultiModeAppData() = delete;
  OdGrip2LineAngularDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGrip2LineAngularDimMultiModeAppData> OdGrip2LineAngularDimMultiModeAppDataPtr;

/************************************************************************/
/*                          OdDbArcDimension                            */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripArcDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    LINE1 = 0,
    LINE2 = 1,
    ARC = 2,
    TEXT = 3
  };

public:
  ODRX_DECLARE_MEMBERS(OdGripArcDimMultiModeAppData);
  OdGripArcDimMultiModeAppData() = delete;
  OdGripArcDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripArcDimMultiModeAppData> OdGripArcDimMultiModeAppDataPtr;

/************************************************************************/
/*                        OdDbOrdinateDimension                         */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripOrdDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    DEFINING = 0,
    LEADER = 1,
    ORIGIN = 2,
    TEXT = 3
  };

public:
  ODRX_DECLARE_MEMBERS(OdGripOrdDimMultiModeAppData);
  OdGripOrdDimMultiModeAppData() = delete;
  OdGripOrdDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripOrdDimMultiModeAppData> OdGripOrdDimMultiModeAppDataPtr;

/************************************************************************/
/*                         OdDbRadialDimension                          */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripRadialDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    CENTER = 0,
    CHORD = 1,
    TEXT = 2
  };

public:
  ODRX_DECLARE_MEMBERS(OdGripRadialDimMultiModeAppData);
  OdGripRadialDimMultiModeAppData() = delete;
  OdGripRadialDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripRadialDimMultiModeAppData> OdGripRadialDimMultiModeAppDataPtr;

/************************************************************************/
/*                       OdDbDiametricDimension                         */
/************************************************************************/
class GRIPPOINTS_EXPORT OdGripDiametricDimMultiModeAppData : public OdGripDimMultiModeAppData
{
public:
  enum DimGripType
  {
    CHORD = 0,
    FARCHORD = 1,
    TEXT = 2
  };

public:
  ODRX_DECLARE_MEMBERS(OdGripDiametricDimMultiModeAppData);
  OdGripDiametricDimMultiModeAppData() = delete;
  OdGripDiametricDimMultiModeAppData(const DimGripType type) : m_dimType(type) { initGripModes(type); }
  DimGripType dimGripType() const { return m_dimType; }
  bool getIndices(OdIntArray& indices) const ODRX_OVERRIDE;
  bool isFirstGrip() const ODRX_OVERRIDE;
  bool isSecondGrip() const ODRX_OVERRIDE;
private:
  void initGripModes(const DimGripType& type);
  const DimGripType m_dimType;
};

typedef OdSmartPtr<OdGripDiametricDimMultiModeAppData> OdGripDiametricDimMultiModeAppDataPtr;

#endif //_ODDBDIMMULTIMODESGRIPPE_INCLUDED