/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, 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-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include "DgCellHeaderGripPoints.h"
#include "DgCellHeader.h"
#include "RxObjectImpl.h"
#include "Ge/GeLine2d.h"
#include "Ge/GeLine3d.h"
#include "Ge/GePlane.h"
#include "Ge/GeInterval.h"
#include "DgGiContext.h"
#include "MemoryStream.h"
#include "Gi/GiBaseVectorizer.h"
#include "DgSharedCellReference.h"

//-----------------------------------------------------------------------------------------------------

bool getCellHeader2dGripPoints(const OdDgCellHeader2d* pEnt, OdGePoint3dArray& gripPoints)
{
  OdGeExtents2d extRange2d;

  if (pEnt->getRangeExtents(extRange2d) != eOk)
    return false;

  OdGePoint2d ptOrigin2d = pEnt->getOrigin();  
  OdGeVector2d vrXAxis2d = OdGeVector2d::kXAxis;
  OdGeVector2d vrYAxis2d = OdGeVector2d::kYAxis;
  vrXAxis2d.transformBy(pEnt->getTransformation());
  vrYAxis2d.transformBy(pEnt->getTransformation());

  OdGePoint3d ptMin(extRange2d.minPoint().x, extRange2d.minPoint().y, 0.0);
  OdGePoint3d ptMax(extRange2d.maxPoint().x, extRange2d.maxPoint().y, 0.0);

  OdGePoint3d ptOrigin(ptOrigin2d.x, ptOrigin2d.y, 0.0);
  OdGeVector3d vrXAxis(vrXAxis2d.x, vrXAxis2d.y, 0.0);
  OdGeVector3d vrYAxis(vrYAxis2d.x, vrYAxis2d.y, 0.0);
  double dLength = ptMax.x - ptMin.x;
  double dHeight = ptMax.y - ptMin.y;

  OdGePoint2d ptMin2d = ptMin.convert2d();
  OdGePoint2d ptMax2d = ptMax.convert2d();
  ptMin2d.transformBy(pEnt->getTransformation());
  ptMax2d.transformBy(pEnt->getTransformation());

  ptMin.set(ptMin2d.x, ptMin2d.y, 0.0);
  ptMax.set(ptMax2d.x, ptMax2d.y, 0.0);

  ptMin += ptOrigin.asVector();
  ptMax += ptOrigin.asVector();

  unsigned int size = gripPoints.size();
  gripPoints.resize(size + 8);

  gripPoints[size] = ptMin;
  gripPoints[size+1] = ptMin + dLength/2.0 * vrXAxis;
  gripPoints[size+2] = ptMin + dLength * vrXAxis;
  gripPoints[size+3] = ptMin + dLength * vrXAxis + dHeight/2.0 * vrYAxis;
  gripPoints[size+4] = ptMax;
  gripPoints[size+5] = ptMax - dLength / 2.0 * vrXAxis;
  gripPoints[size+6] = ptMax - dLength * vrXAxis;
  gripPoints[size+7] = ptMax - dLength * vrXAxis - dHeight / 2.0 * vrYAxis;

  return true;
}

//-----------------------------------------------------------------------------------------------------

bool getCellHeader3dGripPoints(const OdDgCellHeader3d* pEnt, OdGePoint3dArray& gripPoints)
{
  OdGeExtents3d extRange;

  if (pEnt->getRangeExtents(extRange) != eOk)
    return false;

  OdGePoint3d ptOrigin = pEnt->getOrigin();
  OdGeVector3d vrXAxis = OdGeVector3d::kXAxis;
  OdGeVector3d vrYAxis = OdGeVector3d::kYAxis;
  OdGeVector3d vrZAxis = OdGeVector3d::kZAxis;
  vrXAxis.transformBy(pEnt->getTransformation());
  vrYAxis.transformBy(pEnt->getTransformation());
  vrZAxis.transformBy(pEnt->getTransformation());

  OdGePoint3d ptMin = extRange.minPoint();
  OdGePoint3d ptMax = extRange.maxPoint();

  double dLength = ptMax.x - ptMin.x;
  double dHeight = ptMax.y - ptMin.y;
  double dDepth  = ptMax.z - ptMin.z;

  ptMin.transformBy(pEnt->getTransformation());
  ptMax.transformBy(pEnt->getTransformation());
  ptMin += ptOrigin.asVector();
  ptMax += ptOrigin.asVector();

  if( OdZero(dDepth) )
  {
    unsigned int size = gripPoints.size();
    gripPoints.resize(size + 8);

    gripPoints[size] = ptMin;
    gripPoints[size+1] = ptMin + dLength / 2.0 * vrXAxis;
    gripPoints[size+2] = ptMin + dLength * vrXAxis;
    gripPoints[size+3] = ptMin + dLength * vrXAxis + dHeight / 2.0 * vrYAxis;
    gripPoints[size+4] = ptMax;
    gripPoints[size+5] = ptMax - dLength / 2.0 * vrXAxis;
    gripPoints[size+6] = ptMax - dLength * vrXAxis;
    gripPoints[size+7] = ptMax - dLength * vrXAxis - dHeight / 2.0 * vrYAxis;
  }
  else
  {
    unsigned int size = gripPoints.size();
    gripPoints.resize(size + 20);

    gripPoints[size] = ptMin;
    gripPoints[size+1] = ptMin + dLength / 2.0 * vrXAxis;
    gripPoints[size+2] = ptMin + dLength * vrXAxis;
    gripPoints[size+3] = ptMin + dLength * vrXAxis + dHeight/2.0 * vrYAxis;
    gripPoints[size+4] = ptMin + dLength * vrXAxis + dHeight * vrYAxis;
    gripPoints[size+5] = ptMin + dLength / 2.0 * vrXAxis + dHeight * vrYAxis;
    gripPoints[size+6] = ptMin + dHeight * vrYAxis;
    gripPoints[size+7] = ptMin + dHeight/2.0 * vrYAxis;
    gripPoints[size+8] = ptMin + dDepth /2.0 * vrZAxis;
    gripPoints[size+9] = ptMin + dLength * vrXAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+10] = ptMin + dLength * vrXAxis + dHeight * vrYAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+11] = ptMin + dHeight * vrYAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+12] = ptMin + dDepth * vrZAxis;
    gripPoints[size+13] = ptMin + dLength / 2.0 * vrXAxis + dDepth * vrZAxis;
    gripPoints[size+14] = ptMin + dLength * vrXAxis + dDepth * vrZAxis;
    gripPoints[size+15] = ptMin + dLength * vrXAxis + dHeight / 2.0 * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+16] = ptMin + dLength * vrXAxis + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+17] = ptMin + dLength / 2.0 * vrXAxis + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+18] = ptMin + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+19] = ptMin + dHeight / 2.0 * vrYAxis + dDepth * vrZAxis;
  }

  return true;
}

//-----------------------------------------------------------------------------------------------------

OdResult OdDgCellHeaderGripPointsPE::getGripPoints(const OdDgElement* pEnt, OdGePoint3dArray& gripPoints)const
{
	if (pEnt->isKindOf(OdDgCellHeader2d::desc()))
	{
		OdDgCellHeader2dPtr pCell2d = pEnt;
    getCellHeader2dGripPoints( pCell2d, gripPoints );
	}
	else
	{
		OdDgCellHeader3dPtr pCell3d = pEnt;
    getCellHeader3dGripPoints( pCell3d, gripPoints );
	}
	return eOk;
}

//-----------------------------------------------------------------------------------------------------

bool moveCellHeader2dOrigin(OdDgCellHeader2d* pCell2d, const OdGeVector3d& offset)
{
  OdGeVector3d offset2d = offset;
  offset2d.z = 0;
  OdGeMatrix3d matTransform = OdGeMatrix3d::translation(offset2d);
  pCell2d->transformBy(matTransform);
  return true;
}

//-----------------------------------------------------------------------------------------------------

bool moveCellHeader3dOrigin(OdDgCellHeader3d* pCell3d, const OdGeVector3d& offset)
{
  OdGeMatrix3d matTransform = OdGeMatrix3d::translation(offset);
  pCell3d->transformBy(matTransform);
  return true;
}

//-----------------------------------------------------------------------------------------------------

bool scaleCellHeader2d(OdDgCellHeader2d* pCell2d, OdUInt32 uFirstIndex, const OdGeVector3d& offset)
{
  OdGePoint3dArray gripPts;

  if( getCellHeader2dGripPoints(pCell2d, gripPts) )
  {
    OdGePoint3d ptStart, ptEnd;

    bool bRet = true;

    switch( uFirstIndex )
    {
      case 0:
      {
        ptStart = gripPts[4];
        ptEnd   = gripPts[0];
      } break;

      case 1:
      {
        ptStart = gripPts[5];
        ptEnd = gripPts[1];
      } break;

      case 2:
      {
        ptStart = gripPts[6];
        ptEnd = gripPts[2];
      } break;

      case 3:
      {
        ptStart = gripPts[7];
        ptEnd = gripPts[3];
      } break;

      case 4:
      {
        ptStart = gripPts[0];
        ptEnd = gripPts[4];
      } break;

      case 5:
      {
        ptStart = gripPts[1];
        ptEnd = gripPts[5];
      } break;

      case 6:
      {
        ptStart = gripPts[2];
        ptEnd = gripPts[6];
      } break;

      case 7:
      {
        ptStart = gripPts[3];
        ptEnd = gripPts[7];
      } break;

      default:
        bRet = false;
    }

    if( ptStart.isEqualTo(ptEnd) )
      bRet = false;

    if( bRet )
    {
      OdGeLine3d line3d(ptStart, ptEnd);
      OdGePoint3d ptNewEnd = ptEnd + offset;
      ptNewEnd = line3d.closestPointTo(ptNewEnd);

      double dOldLength = ptStart.distanceTo(ptEnd);
      double dNewLength = ptStart.distanceTo(ptNewEnd);
      double dScale = dNewLength / dOldLength;

      if( !OdEqual(dScale, 1.0) )
      {
        OdGeMatrix3d matTransform = OdGeMatrix3d::scaling(dScale, ptStart);
        pCell2d->transformBy(matTransform);
      }
    }

    return bRet;
  }

  return false;
}

//-----------------------------------------------------------------------------------------------------

bool scaleCellHeader3d(OdDgCellHeader3d* pCell3d, OdUInt32 uFirstIndex, const OdGeVector3d& offset)
{
  OdGePoint3dArray gripPts;

  if (getCellHeader3dGripPoints(pCell3d, gripPts))
  {
    if( gripPts.size() < uFirstIndex )
      return false;

    OdGePoint3d ptStart, ptEnd;

    bool bRet = true;

    switch (uFirstIndex)
    {
      case 0:
      {
        if( gripPts.size() < 20 )
        {
          ptStart = gripPts[4];
          ptEnd = gripPts[0];
        }
        else
        {
          ptStart = gripPts[16];
          ptEnd = gripPts[0];
        }
      } break;

      case 1:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[5];
          ptEnd = gripPts[1];
        }
        else
        {
          ptStart = gripPts[17];
          ptEnd = gripPts[1];
        }
      } break;

      case 2:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[6];
          ptEnd = gripPts[2];
        }
        else
        {
          ptStart = gripPts[18];
          ptEnd = gripPts[2];
        }
      } break;

      case 3:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[7];
          ptEnd = gripPts[3];
        }
        else
        {
          ptStart = gripPts[19];
          ptEnd = gripPts[3];
        }
      } break;

      case 4:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[0];
          ptEnd = gripPts[4];
        }
        else
        {
          ptStart = gripPts[12];
          ptEnd = gripPts[4];
        }
      } break;

      case 5:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[1];
          ptEnd = gripPts[5];
        }
        else
        {
          ptStart = gripPts[13];
          ptEnd = gripPts[5];
        }
      } break;

      case 6:
      {
        if (gripPts.size() < 20)
        {
          ptStart = gripPts[2];
          ptEnd = gripPts[6];
        }
        else
        {
          ptStart = gripPts[14];
          ptEnd = gripPts[6];
        }
      } break;

      case 7:
      {
        if( gripPts.size() < 20 )
        {
          ptStart = gripPts[3];
          ptEnd = gripPts[7];
        }
        else
        {
          ptStart = gripPts[15];
          ptEnd = gripPts[7];
        }
      } break;

      case 8:
      {
        ptStart = gripPts[10];
        ptEnd = gripPts[8];
      } break;

      case 9:
      {
        ptStart = gripPts[11];
        ptEnd = gripPts[9];
      } break;

      case 10:
      {
        ptStart = gripPts[8];
        ptEnd = gripPts[10];
      } break;

      case 11:
      {
        ptStart = gripPts[9];
        ptEnd = gripPts[11];
      } break;

      case 12:
      {
        ptStart = gripPts[4];
        ptEnd = gripPts[12];
      } break;

      case 13:
      {
        ptStart = gripPts[5];
        ptEnd = gripPts[13];
      } break;

      case 14:
      {
        ptStart = gripPts[6];
        ptEnd = gripPts[14];
      } break;

      case 15:
      {
        ptStart = gripPts[7];
        ptEnd = gripPts[15];
      } break;

      case 16:
      {
        ptStart = gripPts[0];
        ptEnd = gripPts[16];
      } break;

      case 17:
      {
        ptStart = gripPts[1];
        ptEnd = gripPts[17];
      } break;

      case 18:
      {
        ptStart = gripPts[2];
        ptEnd = gripPts[18];
      } break;

      case 19:
      {
        ptStart = gripPts[3];
        ptEnd = gripPts[19];
      } break;

      default:
        bRet = false;
    }

    if (ptStart.isEqualTo(ptEnd))
      bRet = false;

    if (bRet)
    {
      OdGeLine3d line3d(ptStart, ptEnd);
      OdGePoint3d ptNewEnd = ptEnd + offset;
      ptNewEnd = line3d.closestPointTo(ptNewEnd);

      double dOldLength = ptStart.distanceTo(ptEnd);
      double dNewLength = ptStart.distanceTo(ptNewEnd);
      double dScale = dNewLength / dOldLength;

      if (!OdEqual(dScale, 1.0))
      {
        OdGeMatrix3d matTransform = OdGeMatrix3d::scaling(dScale, ptStart);
        pCell3d->transformBy(matTransform);
      }
    }

    return bRet;
  }

  return false;
}

//-----------------------------------------------------------------------------------------------------

OdResult OdDgCellHeaderGripPointsPE::moveGripPointsAt(OdDgElement* pEnt, const OdIntArray& indices, const OdGeVector3d& offset)
{
	unsigned size = indices.size();

	if (size == 0)
		return eOk;

  OdUInt32 uFirstIndex = indices[0];

  if(pEnt->isKindOf(OdDgCellHeader2d::desc()))
  {
    OdDgCellHeader2dPtr pCell2d = pEnt;
    scaleCellHeader2d(pCell2d, uFirstIndex, offset);
  }
  else
  {
    OdDgCellHeader3dPtr pCell3d = pEnt;
    scaleCellHeader3d(pCell3d, uFirstIndex, offset);
  }

	return eOk;
}

OdResult OdDgCellHeaderGripPointsPE::getStretchPoints(const OdDgElement* pEnt, OdGePoint3dArray& stretchPoints) const
{
	OdResult res = getGripPoints(pEnt, stretchPoints);

	if (res == eOk)
	{
		stretchPoints.resize(stretchPoints.size() - 1);
	}

	return res;
}

OdResult OdDgCellHeaderGripPointsPE::moveStretchPointsAt(OdDgElement* pEnt, const OdIntArray& indices, const OdGeVector3d& offset)
{
	return moveGripPointsAt(pEnt, indices, offset);
}

OdResult OdDgCellHeaderGripPointsPE::getOsnapPoints(const OdDgElement* pEnt,
	OdDgElement::OsnapMode osnapMode,
	OdGsMarker gsSelectionMark,
	const OdGePoint3d& pickPoint,
	const OdGePoint3d& lastPoint,
	const OdGeMatrix3d& xWorldToEye,
	OdGePoint3dArray& snapPoints) const
{
  OdDgElementIteratorPtr pIter;

  if( pEnt->isKindOf(OdDgCellHeader3d::desc()) )
  {
    OdDgCellHeader3dPtr pCell = pEnt;
    pIter = pCell->createIterator();
  }
  else if( pEnt->isKindOf(OdDgCellHeader2d::desc()) )
  {
    OdDgCellHeader2dPtr pCell = pEnt;
    pIter = pCell->createIterator();
  }

  if( !pIter.isNull() )
  {
    for (; !pIter->done(); pIter->step())
    {
      OdDgElementPtr pElm = pIter->item().openObject(OdDg::kForRead);

      OdDgGripPointsPEPtr pGripPointSubitem = OdDgGripPointsPE::cast(pElm);

      if (!pGripPointSubitem.isNull())
      {
        pGripPointSubitem->getOsnapPoints(pElm, osnapMode, gsSelectionMark, pickPoint, lastPoint, xWorldToEye, snapPoints);
      }
    }
  }

	return eOk;
}

//-----------------------------------------------------------------------------------------------------

bool getSharedCellGripPoints(const OdDgSharedCellReference* pEnt, OdGePoint3dArray& gripPoints)
{
  if (!pEnt)
    return false;

  OdDgSharedCellDefinitionPtr pDef = pEnt->findDefinition();

  if( pDef.isNull() )
    return false;

  OdGeExtents3d extDef;
  pDef->getGeomExtents(extDef);

  OdGePoint3d ptMin = extDef.minPoint();
  OdGePoint3d ptMax = extDef.maxPoint();

  double dLength = ptMax.x - ptMin.x;
  double dHeight = ptMax.y - ptMin.y;
  double dDepth = ptMax.z - ptMin.z;

  OdGeVector3d vrXAxis = OdGeVector3d::kXAxis;
  OdGeVector3d vrYAxis = OdGeVector3d::kYAxis;
  OdGeVector3d vrZAxis = OdGeVector3d::kZAxis;

  OdGeMatrix3d transformation = OdGeMatrix3d::translation(pEnt->getOrigin().asVector()) * pEnt->getTransformation();

  if (OdZero(dDepth))
  {
    unsigned int size = gripPoints.size();
    gripPoints.resize(size + 8);

    gripPoints[size] = ptMin;
    gripPoints[size + 1] = ptMin + dLength / 2.0 * vrXAxis;
    gripPoints[size + 2] = ptMin + dLength * vrXAxis;
    gripPoints[size + 3] = ptMin + dLength * vrXAxis + dHeight / 2.0 * vrYAxis;
    gripPoints[size + 4] = ptMax;
    gripPoints[size + 5] = ptMax - dLength / 2.0 * vrXAxis;
    gripPoints[size + 6] = ptMax - dLength * vrXAxis;
    gripPoints[size + 7] = ptMax - dLength * vrXAxis - dHeight / 2.0 * vrYAxis;

    for (OdUInt32 i = 0; i < 8; i++)
      gripPoints[size + i].transformBy(transformation);
  }
  else
  {
    unsigned int size = gripPoints.size();
    gripPoints.resize(size + 20);

    gripPoints[size] = ptMin;
    gripPoints[size+1] = ptMin + dLength / 2.0 * vrXAxis;
    gripPoints[size+2] = ptMin + dLength * vrXAxis;
    gripPoints[size+3] = ptMin + dLength * vrXAxis + dHeight / 2.0 * vrYAxis;
    gripPoints[size+4] = ptMin + dLength * vrXAxis + dHeight * vrYAxis;
    gripPoints[size+5] = ptMin + dLength / 2.0 * vrXAxis + dHeight * vrYAxis;
    gripPoints[size+6] = ptMin + dHeight * vrYAxis;
    gripPoints[size+7] = ptMin + dHeight / 2.0 * vrYAxis;
    gripPoints[size+8] = ptMin + dDepth / 2.0 * vrZAxis;
    gripPoints[size+9] = ptMin + dLength * vrXAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+10] = ptMin + dLength * vrXAxis + dHeight * vrYAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+11] = ptMin + dHeight * vrYAxis + dDepth / 2.0 * vrZAxis;
    gripPoints[size+12] = ptMin + dDepth * vrZAxis;
    gripPoints[size+13] = ptMin + dLength / 2.0 * vrXAxis + dDepth * vrZAxis;
    gripPoints[size+14] = ptMin + dLength * vrXAxis + dDepth * vrZAxis;
    gripPoints[size+15] = ptMin + dLength * vrXAxis + dHeight / 2.0 * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+16] = ptMin + dLength * vrXAxis + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+17] = ptMin + dLength / 2.0 * vrXAxis + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+18] = ptMin + dHeight * vrYAxis + dDepth * vrZAxis;
    gripPoints[size+19] = ptMin + dHeight / 2.0 * vrYAxis + dDepth * vrZAxis;

    for (OdUInt32 i = 0; i < 20; i++)
      gripPoints[size + i].transformBy(transformation);
  }

  return true;
}

//-----------------------------------------------------------------------------------------------------

OdResult OdDgSharedCellGripPointsPE::getGripPoints(const OdDgElement* pEnt, OdGePoint3dArray& gripPoints)const
{
  if (pEnt->isKindOf(OdDgSharedCellReference::desc()))
  {
    OdDgSharedCellReferencePtr pSharedCell = pEnt;
    getSharedCellGripPoints(pSharedCell, gripPoints);
  }
  return eOk;
}

//-----------------------------------------------------------------------------------------------------

bool scaleSharedCellReference(OdDgSharedCellReference* pSharedCell, OdUInt32 uFirstIndex, const OdGeVector3d& offset)
{
  OdGePoint3dArray gripPts;

  if (getSharedCellGripPoints(pSharedCell, gripPts))
  {
    if (gripPts.size() < uFirstIndex)
      return false;

    OdGePoint3d ptStart, ptEnd;

    bool bRet = true;

    switch (uFirstIndex)
    {
    case 0:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[4];
        ptEnd = gripPts[0];
      }
      else
      {
        ptStart = gripPts[16];
        ptEnd = gripPts[0];
      }
    } break;

    case 1:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[5];
        ptEnd = gripPts[1];
      }
      else
      {
        ptStart = gripPts[17];
        ptEnd = gripPts[1];
      }
    } break;

    case 2:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[6];
        ptEnd = gripPts[2];
      }
      else
      {
        ptStart = gripPts[18];
        ptEnd = gripPts[2];
      }
    } break;

    case 3:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[7];
        ptEnd = gripPts[3];
      }
      else
      {
        ptStart = gripPts[19];
        ptEnd = gripPts[3];
      }
    } break;

    case 4:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[0];
        ptEnd = gripPts[4];
      }
      else
      {
        ptStart = gripPts[12];
        ptEnd = gripPts[4];
      }
    } break;

    case 5:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[1];
        ptEnd = gripPts[5];
      }
      else
      {
        ptStart = gripPts[13];
        ptEnd = gripPts[5];
      }
    } break;

    case 6:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[2];
        ptEnd = gripPts[6];
      }
      else
      {
        ptStart = gripPts[14];
        ptEnd = gripPts[6];
      }
    } break;

    case 7:
    {
      if (gripPts.size() < 20)
      {
        ptStart = gripPts[3];
        ptEnd = gripPts[7];
      }
      else
      {
        ptStart = gripPts[15];
        ptEnd = gripPts[7];
      }
    } break;

    case 8:
    {
      ptStart = gripPts[10];
      ptEnd = gripPts[8];
    } break;

    case 9:
    {
      ptStart = gripPts[11];
      ptEnd = gripPts[9];
    } break;

    case 10:
    {
      ptStart = gripPts[8];
      ptEnd = gripPts[10];
    } break;

    case 11:
    {
      ptStart = gripPts[9];
      ptEnd = gripPts[11];
    } break;

    case 12:
    {
      ptStart = gripPts[4];
      ptEnd = gripPts[12];
    } break;

    case 13:
    {
      ptStart = gripPts[5];
      ptEnd = gripPts[13];
    } break;

    case 14:
    {
      ptStart = gripPts[6];
      ptEnd = gripPts[14];
    } break;

    case 15:
    {
      ptStart = gripPts[7];
      ptEnd = gripPts[15];
    } break;

    case 16:
    {
      ptStart = gripPts[0];
      ptEnd = gripPts[16];
    } break;

    case 17:
    {
      ptStart = gripPts[1];
      ptEnd = gripPts[17];
    } break;

    case 18:
    {
      ptStart = gripPts[2];
      ptEnd = gripPts[18];
    } break;

    case 19:
    {
      ptStart = gripPts[3];
      ptEnd = gripPts[19];
    } break;

    default:
      bRet = false;
    }

    if (ptStart.isEqualTo(ptEnd))
      bRet = false;

    if (bRet)
    {
      OdGeLine3d line3d(ptStart, ptEnd);
      OdGePoint3d ptNewEnd = ptEnd + offset;
      ptNewEnd = line3d.closestPointTo(ptNewEnd);

      double dOldLength = ptStart.distanceTo(ptEnd);
      double dNewLength = ptStart.distanceTo(ptNewEnd);
      double dScale = dNewLength / dOldLength;

      if (!OdEqual(dScale, 1.0))
      {
        OdGeMatrix3d matTransform = OdGeMatrix3d::scaling(dScale, ptStart);
        pSharedCell->transformBy(matTransform);
      }
    }

    return bRet;
  }

  return false;
}

//-----------------------------------------------------------------------------------------------------

OdResult OdDgSharedCellGripPointsPE::moveGripPointsAt(OdDgElement* pEnt, const OdIntArray& indices, const OdGeVector3d& offset)
{
  unsigned size = indices.size();

  if (size == 0)
    return eOk;

  OdUInt32 uFirstIndex = indices[0];

  if (pEnt->isKindOf(OdDgSharedCellReference::desc()))
  {
    OdDgSharedCellReferencePtr pSharedCell = pEnt;
    scaleSharedCellReference(pSharedCell, uFirstIndex, offset);
  }

  return eOk;
}

OdResult OdDgSharedCellGripPointsPE::getStretchPoints(const OdDgElement* pEnt, OdGePoint3dArray& stretchPoints) const
{
  OdResult res = getGripPoints(pEnt, stretchPoints);

  if (res == eOk)
  {
    stretchPoints.resize(stretchPoints.size() - 1);
  }

  return res;
}

OdResult OdDgSharedCellGripPointsPE::moveStretchPointsAt(OdDgElement* pEnt, const OdIntArray& indices, const OdGeVector3d& offset)
{
  return moveGripPointsAt(pEnt, indices, offset);
}

OdResult OdDgSharedCellGripPointsPE::getOsnapPoints(const OdDgElement* pEnt,
  OdDgElement::OsnapMode osnapMode,
  OdGsMarker gsSelectionMark,
  const OdGePoint3d& pickPoint,
  const OdGePoint3d& lastPoint,
  const OdGeMatrix3d& xWorldToEye,
  OdGePoint3dArray& snapPoints) const
{
  OdDgSharedCellReferencePtr pSharedCellRef = OdDgSharedCellReference::cast(pEnt);

  if( !pSharedCellRef.isNull() )
  {
    OdDgSharedCellDefinitionPtr pDef = pSharedCellRef->findDefinition();

    OdGeMatrix3d transformation = OdGeMatrix3d::translation(pSharedCellRef->getOrigin().asVector()) * pSharedCellRef->getTransformation();

    if( !pDef.isNull() )
    {
      OdDgElementIteratorPtr pIter = pDef->createIterator();

      if (!pIter.isNull())
      {
        for (; !pIter->done(); pIter->step())
        {
          OdDgElementPtr pElm = pIter->item().openObject(OdDg::kForRead);

          OdDgGripPointsPEPtr pGripPointSubitem = OdDgGripPointsPE::cast(pElm);

          if (!pGripPointSubitem.isNull())
          {
            OdGePoint3dArray arrSubitemSnapPts;
            pGripPointSubitem->getOsnapPoints(pElm, osnapMode, gsSelectionMark, pickPoint, lastPoint, xWorldToEye, arrSubitemSnapPts);

            for( OdUInt32 i = 0; i < arrSubitemSnapPts.size(); i++ )
              arrSubitemSnapPts[i].transformBy(transformation);
            
            snapPoints.append(arrSubitemSnapPts);
          }
        }
      }
    }
  }

  return eOk;
}