/////////////////////////////////////////////////////////////////////////////// 
// 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.
///////////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* These classes are implementations of the OdDbGripPointsPE interface  */
/* for their respective OdDbDimension derived entities.                 */
/************************************************************************/
#include "StdAfx.h"
#include "DbDimMultiModesGripPE.h"
#include "DbAlignedDimension.h"
#include "DbRotatedDimension.h"
#include "DbArcDimension.h"
#include "Db2LineAngularDimension.h"
#include "Db3PointAngularDimension.h"
#include "DbDiametricDimension.h"
#include "DbRadialDimension.h"
#include "DbOrdinateDimension.h"
#include "DbCommandContext.h"
#include "Gs/Gs.h"

ODRX_NO_CONS_DEFINE_MEMBERS(OdGripDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripAlignedDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripRotatedDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGrip3PointAngularDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGrip2LineAngularDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripArcDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripOrdDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripRadialDimMultiModeAppData, OdRxObject);
ODRX_NO_CONS_DEFINE_MEMBERS(OdGripDiametricDimMultiModeAppData, OdRxObject);

bool OdDbDimensionMultiModesGripPE::getGripModes(const OdDbEntity* pEnt, OdDbGripData* pGripData, OdArray<OdDbMultiModesGripPE::GripMode>& modes, unsigned int& curMode) const
{
  if (!pEnt)
    return false;

  if (!pGripData)
    return false;

  OdGripDimMultiModeAppDataPtr appData = static_cast<OdGripDimMultiModeAppData*>(pGripData->appData());
  if (!appData)
    return false;

  appData->getGripModes(modes);
  curMode = appData->mode();
  return true;
}

unsigned int OdDbDimensionMultiModesGripPE::mode(OdDbEntity*, OdDbGripData* pGripData) const
{
  OdGripDimMultiModeAppDataPtr appData = static_cast<OdGripDimMultiModeAppData*>(pGripData->appData());
  return appData->mode();
}

OdDbMultiModesGripPE::GripMode OdDbDimensionMultiModesGripPE::modeEx(OdDbEntity*, OdDbGripData* pGripData) const
{
  OdGripDimMultiModeAppDataPtr appData = static_cast<OdGripDimMultiModeAppData*>(pGripData->appData());
  return appData->gripMode();
}

class MoveGripDimTracker : public OdStaticRxObject<OdEdPointTracker>
{
private:
  const OdDbDimensionPtr m_pOrg;
  OdDbDimensionPtr m_pDim;
  const OdIntArray m_indices;
  const OdGePoint3d m_gripPnt;
public:
  MoveGripDimTracker() = delete;
  MoveGripDimTracker(const OdDbDimensionPtr& org, const OdIntArray& indices, const OdGePoint3d& pnt)
    : m_pOrg(org), m_pDim(org->clone()), m_indices(indices), m_gripPnt(pnt) { }
  virtual void setValue(const OdGePoint3d& value)
  {
    m_pDim->copyFrom(m_pOrg);
    m_pDim->moveGripPointsAt(m_indices, value - m_gripPnt);
  }
  virtual int addDrawables(OdGsView* pView)
  {
    pView->add(m_pDim, 0);
    return 1;
  }
  virtual void removeDrawables(OdGsView* pView)
  {
    pView->erase(m_pDim);
  }
};

bool OdDbDimensionMultiModesGripPE::setMode(OdDbEntity* pEnt, OdDbGripData* pGripData, unsigned int newMode)
{
  OdDbDimensionPtr pDim = pEnt;
  OdDbDatabase* pDb = pDim->database();
  OdDbCommandContextPtr pCmdCtx = OdDbCommandContext::registredCommandContext(pDb);
  OdDbUserIO* pIO = pCmdCtx->dbUserIO();

  if (!pGripData)
    return false;

  OdGripDimMultiModeAppDataPtr appData = static_cast<OdGripDimMultiModeAppData*>(pGripData->appData());
  if (!appData)
    return false;

  appData->setMode(newMode);
  const OdDbMultiModesGripPE::GripMode curMode = appData->gripMode();

  try
  {
    switch (newMode)
    {
      case 101: { // "Stretch"
        int nKeyword = 0;
        bool bKeyword = false;
        OdIntArray indices;
        if (!appData->getIndices(indices))
          return false;

        try 
        {
          MoveGripDimTracker tracker(pEnt, indices, pGripData->gripPoint());
          OdGePoint3d pnt = pIO->getPoint(curMode.CLIPromptString, OdEd::kGptRubberBand,
            &pGripData->gripPoint(), curMode.CLIKeywordList, &tracker);
          pDim->moveGripPointsAt(indices, pnt - pGripData->gripPoint());
        }
        catch (const OdEdKeyword& kwd)
        {
          bKeyword = true;
          nKeyword = kwd.keywordIndex();
        }
        catch (...)
        {
          throw;
        }
        if (bKeyword && nKeyword == 0)
          return false;
        break;
      }
      case 103: { // "Move with Dim Line"
        pDim->setDimtmove(0);
        OdIntArray indices;
        if (!appData->getIndices(indices))
          return false;
        MoveGripDimTracker tracker(pDim, indices, pGripData->gripPoint());
        OdGePoint3d pnt = pIO->getPoint(curMode.CLIPromptString, OdEd::kGptRubberBand,
          &pGripData->gripPoint(), curMode.CLIKeywordList, &tracker);
        pDim->moveGripPointsAt(indices, pnt - pGripData->gripPoint());
        break;
      }
      case 104: { // "Move Text Only"
        pDim->useSetTextPosition();
        pDim->setDimtmove(2);
        OdIntArray indices;
        if (!appData->getIndices(indices))
          return false;

        MoveGripDimTracker tracker(pDim, indices, pGripData->gripPoint());
        OdGePoint3d pnt = pIO->getPoint(curMode.CLIPromptString, OdEd::kGptRubberBand,
          &pGripData->gripPoint(), curMode.CLIKeywordList, &tracker);
        pDim->moveGripPointsAt(indices, pnt - pGripData->gripPoint());
        break;
      }
      case 105: { // "Move with Leader"
        pDim->setDimtmove(1);
        OdIntArray indices;
        if (!appData->getIndices(indices))
          return false;
        MoveGripDimTracker tracker(pDim, indices, pGripData->gripPoint());
        OdGePoint3d pnt = pIO->getPoint(curMode.CLIPromptString, OdEd::kGptRubberBand,
          &pGripData->gripPoint(), curMode.CLIKeywordList, &tracker);
        pDim->moveGripPointsAt(indices, pnt - pGripData->gripPoint());
        break;
      }
      case 106: { // "Above Dim Line"
        pIO->putString(curMode.CLIPromptString);
        pDim->setDimtih(0);
        pDim->setDimtad(1);
        break;
      }
      case 107: { // "Center Vertically"
        pIO->putString(curMode.CLIPromptString);
        pDim->setDimtih(1);
        pDim->setDimtad(0);
        break;
      }
      case 108: { // "Reset Text Position"
        pIO->putString(curMode.CLIPromptString);
        pDim->useDefaultTextPosition();
        pDim->setDimtih(1);
        pDim->setDimtad(0);
        pDim->setDimtmove(0);
        break;
      }
      case 111: { // "Flip Arrow"
        pIO->putString(curMode.CLIPromptString);
        if (appData->isFirstGrip())
          pDim->setArrowFirstIsFlipped(!pDim->getArrowFirstIsFlipped());
        if (appData->isSecondGrip())
          pDim->setArrowSecondIsFlipped(!pDim->getArrowSecondIsFlipped());
        break;
      }
      default: {
        return false;
      }
    }
  }
  catch (const OdEdCancel&)
  {
    return false;
  }
  return true;
}

OdDbMultiModesGripPE::GripType OdDbDimensionMultiModesGripPE::gripType(OdDbEntity*, OdDbGripData* pGripData) const
{
  if (pGripData)
  {
    OdGripDimMultiModeAppDataPtr appData = static_cast<OdGripDimMultiModeAppData*>(pGripData->appData());
    if (appData)
    {
      return appData->gripType();
    }
  }
  return OdDbMultiModesGripPE::kPrimary;
}

void OdDbDimensionMultiModesGripPE::reset(OdDbEntity*) {}

void OdGripAlignedDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != FIRST && type != SECOND ))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == FIRST || type == SECOND)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 111;
      mode.DisplayString = "Flip Arrow";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** FLIP ARROW **";
      mode.CLIPromptString = "Pick to flip arrowhead:";
      m_modes[mode.Mode] = mode;
    }
  }
}

bool OdGripAlignedDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == POINT1 || m_dimType == POINT2 ||
      m_dimType == FIRST || m_dimType == SECOND ||
      m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGripAlignedDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == FIRST);
}

bool OdGripAlignedDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == SECOND);
}

void OdGripRotatedDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != FIRST && type != SECOND))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == FIRST || type == SECOND)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 111;
      mode.DisplayString = "Flip Arrow";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** FLIP ARROW **";
      mode.CLIPromptString = "Pick to flip arrowhead:";
      m_modes[mode.Mode] = mode;
    }
  }
}

bool OdGripRotatedDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == POINT1 || m_dimType == POINT2 ||
      m_dimType == FIRST || m_dimType == SECOND ||
      m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGripRotatedDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == FIRST);
}

bool OdGripRotatedDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == SECOND);
}

void OdGrip3PointAngularDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != FIRST && type != SECOND))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }
    
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == FIRST || type == SECOND)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 111;
      mode.DisplayString = "Flip Arrow";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** FLIP ARROW **";
      mode.CLIPromptString = "Pick to flip arrowhead:";
      m_modes[mode.Mode] = mode;
    }
  }
}

bool OdGrip3PointAngularDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == FIRST || m_dimType == SECOND ||
      m_dimType == CENTER || m_dimType == ARC || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGrip3PointAngularDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == FIRST);
}

bool OdGrip3PointAngularDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == SECOND);
}

void OdGrip2LineAngularDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != LINE1_START && type != LINE1_END
                                        && type != LINE2_START && type != LINE2_END))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }
    
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == LINE1_START || type == LINE2_START || type == LINE1_END|| type == LINE2_END)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 111;
      mode.DisplayString = "Flip Arrow";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** FLIP ARROW **";
      mode.CLIPromptString = "Pick to flip arrowhead:";
      m_modes[mode.Mode] = mode;
    }
  }
}

bool OdGrip2LineAngularDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == LINE1_START || m_dimType == LINE1_END ||
      m_dimType == LINE2_START || m_dimType == LINE2_END ||
      m_dimType == ARC || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGrip2LineAngularDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == LINE1_START || m_dimType == LINE1_END);
}

bool OdGrip2LineAngularDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == LINE2_START || m_dimType == LINE2_END);
}

void OdGripArcDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != LINE1 && type != LINE2))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == LINE1 || type == LINE2)
  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 111;
    mode.DisplayString = "Flip Arrow";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** FLIP ARROW **";
    mode.CLIPromptString = "Pick to flip arrowhead:";
    m_modes[mode.Mode] = mode;
  }
}

bool OdGripArcDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == LINE1 || m_dimType == LINE2 ||
      m_dimType == ARC || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGripArcDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == LINE1);
}

bool OdGripArcDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == LINE2);
}

void OdGripOrdDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != LEADER))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 105;
      mode.DisplayString = "Move with Leader";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH LEADER **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
}

bool OdGripOrdDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == DEFINING || m_dimType == LEADER || 
      m_dimType == ORIGIN || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

void OdGripRadialDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != CHORD))
    return;
  
  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == CHORD)
  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 111;
    mode.DisplayString = "Flip Arrow";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** FLIP ARROW **";
    mode.CLIPromptString = "Pick to flip arrowhead:";
    m_modes[mode.Mode] = mode;
  }
}

bool OdGripRadialDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == CENTER || m_dimType == CHORD || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGripRadialDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == CHORD);
}

void OdGripDiametricDimMultiModeAppData::initGripModes(const DimGripType& type)
{
  if (!m_modes.empty() || (type != TEXT && type != CHORD && type != FARCHORD))
    return;

  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 101;
    mode.DisplayString = "Stretch";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** STRETCH **";
    mode.CLIPromptString = "Specify stretch point or [eXit]:";
    mode.CLIKeywordList = "eXit";
    m_modes[mode.Mode] = mode;
  }

  if (type == TEXT)
  {
    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 103;
      mode.DisplayString = "Move with Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE WITH DIM LINE **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 104;
      mode.DisplayString = "Move Text Only";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** MOVE TEXT ONLY **";
      mode.CLIPromptString = "Specify destination point:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 106;
      mode.DisplayString = "Above Dim Line";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** ABOVE DIMENSION LINE **";
      mode.CLIPromptString = "Pick to place text above dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 107;
      mode.DisplayString = "Center Vertically";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** CENTER VERTICALLY **";
      mode.CLIPromptString = "Pick to center text vertically with dimension line:";
      m_modes[mode.Mode] = mode;
    }

    {
      OdDbMultiModesGripPE::GripMode mode;
      mode.Mode = 108;
      mode.DisplayString = "Reset Text Position";
      mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
      mode.CLIDisplayString = "** RESET TEXT POSITION **";
      mode.CLIPromptString = "Pick to reset text to default location:";
      m_modes[mode.Mode] = mode;
    }
  }
  else if (type == FARCHORD || type == CHORD)
  {
    OdDbMultiModesGripPE::GripMode mode;
    mode.Mode = 111;
    mode.DisplayString = "Flip Arrow";
    mode.ActionType = OdDbMultiModesGripPE::GripActionType::kImmediate;
    mode.CLIDisplayString = "** FLIP ARROW **";
    mode.CLIPromptString = "Pick to flip arrowhead:";
    m_modes[mode.Mode] = mode;
  }
}

bool OdGripDiametricDimMultiModeAppData::getIndices(OdIntArray& indices) const
{
  if (m_dimType == CHORD || m_dimType == FARCHORD || m_dimType == TEXT)
    indices.append(m_dimType);
  else
    return false;
  return true;
}

bool OdGripDiametricDimMultiModeAppData::isFirstGrip() const
{
  return (m_dimType == FARCHORD);
}

bool OdGripDiametricDimMultiModeAppData::isSecondGrip() const
{
  return (m_dimType == CHORD);
}

void OdGripDimMultiModeAppData::getGripModes(OdArray<OdDbMultiModesGripPE::GripMode>& modes)
{
  for (const auto& mode : m_modes)
    modes.append(mode.second);
}