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

#include "Gi/Gi.h"
#include "Gi/GiBaseVectorizer.h"
#include "Gi/GiViewportGeometry.h"
#include "OdStack.h"
#include "StaticRxObject.h"
#include "DbBaseSubentId.h" 

#include "ModelerMarkers.h"

#include "TD_PackPush.h"

/** \details
This class is a dummy template for OdGiGeometry.
Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiWrapperGeometry : public T
{
  OdGiGeometry        *m_Geom;
protected:
  void setGeom(OdGiGeometry &Geom) { m_Geom = &Geom; }
  OdGiGeometry &getGeom() { return *m_Geom; }
public:
  virtual void pline(const OdGiPolyline& p, OdUInt32 i, OdUInt32 n)
  {
    m_Geom->pline(p, i, n);
  }

  virtual OdGeMatrix3d getModelToWorldTransform() const
  {
    return m_Geom->getModelToWorldTransform();
  }
  virtual OdGeMatrix3d getWorldToModelTransform() const
  {
    return m_Geom->getWorldToModelTransform();
  }

  virtual void pushModelTransform(const OdGeVector3d& vNormal)
  {
    m_Geom->pushModelTransform(vNormal);
  }
  virtual void pushModelTransform(const OdGeMatrix3d& xMat)
  {
    m_Geom->pushModelTransform(xMat);
  }
  virtual void popModelTransform()
  {
    m_Geom->popModelTransform();
  }

  // For drawing various primitives.
  //
  virtual void circle(const OdGePoint3d& center, double radius, const OdGeVector3d& normal)
  {
    m_Geom->circle(center, radius, normal);
  }

  virtual void circle(const OdGePoint3d& p1, const OdGePoint3d& p2, const OdGePoint3d& p3)
  {
    m_Geom->circle(p1, p2, p3);
  }

  virtual void circularArc(const OdGePoint3d& center,
    double radius,
    const OdGeVector3d& normal,
    const OdGeVector3d& startVector,
    double sweepAngle,
    OdGiArcType arcType = kOdGiArcSimple)
  {
    m_Geom->circularArc(center, radius, normal, startVector, sweepAngle, arcType);
  }

  virtual void circularArc(const OdGePoint3d& start,
    const OdGePoint3d& point,
    const OdGePoint3d& end,
    OdGiArcType arcType = kOdGiArcSimple)
  {
    m_Geom->circularArc(start, point, end, arcType);
  }

  virtual void polyline(OdInt32 nbPoints,
    const OdGePoint3d* pVertexList,
    const OdGeVector3d* pNormal = NULL,
    OdGsMarker lBaseSubEntMarker = -1)
  {
    m_Geom->polyline(nbPoints, pVertexList, pNormal, lBaseSubEntMarker);
  }

  virtual void polygon(OdInt32 nbPoints, const OdGePoint3d* pVertexList)
  {
    m_Geom->polygon(nbPoints, pVertexList);
  }

  virtual void mesh(OdInt32 rows,
    OdInt32 columns,
    const OdGePoint3d* pVertexList,
    const OdGiEdgeData* pEdgeData = NULL,
    const OdGiFaceData* pFaceData = NULL,
    const OdGiVertexData* pVertexData = NULL)
  {
    m_Geom->mesh(rows, columns, pVertexList,  pEdgeData, pFaceData, pVertexData);
  }

  virtual void shell(OdInt32 nbVertex,
    const OdGePoint3d* pVertexList,
    OdInt32 faceListSize,
    const OdInt32* pFaceList,
    const OdGiEdgeData* pEdgeData = NULL,
    const OdGiFaceData* pFaceData = NULL,
    const OdGiVertexData* pVertexData = NULL)
  {
    m_Geom->shell(nbVertex, pVertexList, faceListSize, pFaceList, pEdgeData, pFaceData, pVertexData);
  }

  virtual void text(const OdGePoint3d& position,
    const OdGeVector3d& normal, const OdGeVector3d& direction,
    double height, double width, double oblique, const OdString& msg)
  {
    m_Geom->text(position, normal, direction, height, width, oblique, msg);
  }

  virtual void text(const OdGePoint3d& position,
    const OdGeVector3d& normal, const OdGeVector3d& direction,
    const OdChar* msg, OdInt32 length, bool raw, const OdGiTextStyle* pTextStyle)
  {
    m_Geom->text(position, normal, direction, msg, length, raw, pTextStyle);
  }

  void ray(const OdGePoint3d& first, const OdGePoint3d& second)
  {
    m_Geom->ray(first, second);
  }

  virtual void nurbs(const OdGeNurbCurve3d& nurbs)
  {
    m_Geom->nurbs(nurbs);
  }

  virtual void xline(const OdGePoint3d& p1, const OdGePoint3d& p2)
  {
    m_Geom->xline(p1, p2);
  }

  virtual void ellipArc(const OdGeEllipArc3d& arc,
    const OdGePoint3d* pEndPointsOverrides = 0,
    OdGiArcType arcType = kOdGiArcSimple)
  {
    m_Geom->ellipArc(arc, pEndPointsOverrides, arcType);
  }

  virtual void draw(const OdGiDrawable* pD)
  {
    m_Geom->draw(pD);
  }

  virtual void pushClipBoundary(OdGiClipBoundary* pBoundary)
  {
    m_Geom->pushClipBoundary(pBoundary);
  }
  virtual void popClipBoundary()
  {
    m_Geom->popClipBoundary();
  }

  virtual void worldLine(const OdGePoint3d pnts[2])
  {
    m_Geom->worldLine(pnts);
  }

  virtual void image(const OdGiImageBGRA32& img,
                     const OdGePoint3d& origin,
                     const OdGeVector3d& uVec,
                     const OdGeVector3d& vVec,
                     OdGiRasterImage::TransparencyMode trpMode = OdGiRasterImage::kTransparency8Bit)
  {
    m_Geom->image(img, origin, uVec, vVec, trpMode);
  }

  virtual void edge(const OdGiEdge2dArray& edges)
  {
    m_Geom->edge(edges);
  }

  virtual void polypoint(OdInt32 numPoints, const OdGePoint3d* vertexList, const OdCmEntityColor* pColors, const OdCmTransparency* pTransparency,
                         const OdGeVector3d* pNormals, const OdGsMarker* pSubEntMarkers, OdInt32 nPointSize)
  {
    m_Geom->polypoint(numPoints, vertexList, pColors, pTransparency, pNormals, pSubEntMarkers, nPointSize);
  }

  virtual void rowOfDots(OdInt32 numPoints, const OdGePoint3d& startPoint, const OdGeVector3d& dirToNextPoint)
  {
    m_Geom->rowOfDots(numPoints, startPoint, dirToNextPoint);
  }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiWrapperWorldGeometry : public OdGiWrapperGeometry< T >
{
public:
  virtual void setExtents(const OdGePoint3d *newExtents) { ((OdGiWorldGeometry&)(OdGiWrapperGeometry< T >::getGeom())).setExtents(newExtents); }
  virtual void startAttributesSegment() { ((OdGiWorldGeometry&)(OdGiWrapperGeometry< T >::getGeom())).startAttributesSegment(); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiWrapperViewportGeometry : public OdGiWrapperGeometry< T >
{
public:
  virtual void polylineEye(
    OdUInt32 numVertices, 
    const OdGePoint3d* vertexList) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).polylineEye(numVertices, vertexList); }

  virtual void polygonEye(
    OdUInt32 numVertices, 
    const OdGePoint3d* vertexList) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).polygonEye(numVertices, vertexList); }

  virtual void polylineDc(
    OdUInt32 numVertices, 
    const OdGePoint3d* vertexList) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).polylineDc(numVertices, vertexList); }

  virtual void polygonDc(
    OdUInt32 numVertices, 
    const OdGePoint3d* vertexList) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).polygonDc(numVertices, vertexList); }

  virtual void rasterImageDc(
    const OdGePoint3d& origin,
    const OdGeVector3d& u,
    const OdGeVector3d& v,
    const OdGiRasterImage* pImage, 
    const OdGePoint2d* uvBoundary, 
    OdUInt32 numBoundPts,
    bool transparency = false,
    double brightness = 50.0,
    double contrast = 50.0,
    double fade = 0.0) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).rasterImageDc(origin,u,v,pImage, uvBoundary, numBoundPts,transparency,brightness,contrast,fade); }

  virtual void  metafileDc(
    const OdGePoint3d& origin,
    const OdGeVector3d& u,
    const OdGeVector3d& v,
    const OdGiMetafile* pMetafile,
    bool dcAligned = true,
    bool allowClipping = false) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).metafileDc(origin,u,v,pMetafile,dcAligned,allowClipping); }

  virtual void ownerDrawDc(
    const OdGePoint3d& origin,
    const OdGeVector3d& u,
    const OdGeVector3d& v,
    const OdGiSelfGdiDrawable* pDrawable,
    bool dcAligned = true,
    bool allowClipping = false) { ((OdGiViewportGeometry&)(OdGiWrapperGeometry< T >::getGeom())).ownerDrawDc(origin,u,v,pDrawable,dcAligned,allowClipping); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T> class OdGiSubEntityTraitsWrapper : public T
{
  OdGiSubEntityTraits *m_pTraits;
protected:
  void setTraits(OdGiSubEntityTraits &pTraits) { m_pTraits = &pTraits; }
  OdGiSubEntityTraits &getTraits() { return *m_pTraits; }
public:
  OdGiSubEntityTraitsWrapper() : m_pTraits(0) { }

  // no refcounting
  void addRef() { m_pTraits->addRef(); }
  // no refcounting
  void release() { m_pTraits->release(); }

  void setColor(OdUInt16 n) { m_pTraits->setColor(n); }
  void setTrueColor(const OdCmEntityColor& n) { m_pTraits->setTrueColor(n); }
  void setLayer(OdDbStub* n) { m_pTraits->setLayer(n); }
  void setLineType(OdDbStub* n) { m_pTraits->setLineType(n); }
  void setSelectionMarker(OdGsMarker n) { m_pTraits->setSelectionMarker(n); }
  void setFillType(OdGiFillType n) { m_pTraits->setFillType(n); }
  void setFillPlane(const OdGeVector3d* n= 0) { m_pTraits->setFillPlane(n); }
  void setLineWeight(OdDb::LineWeight n) { m_pTraits->setLineWeight(n); }
  void setLineTypeScale(double n = 1.0) { m_pTraits->setLineTypeScale(n); }
  void setThickness(double n) { m_pTraits->setThickness(n); }
  void setPlotStyleName(OdDb::PlotStyleNameType n, OdDbStub* m= 0) { m_pTraits->setPlotStyleName(n,m); }
  void setMaterial(OdDbStub* n) { m_pTraits->setMaterial(n); }
  void setMapper(const OdGiMapper * n) { m_pTraits->setMapper(n); }
  void setVisualStyle(const OdDbStub* n) { m_pTraits->setVisualStyle(n); }
  void setTransparency(const OdCmTransparency& transparency) { m_pTraits->setTransparency(transparency); }
  void setDrawFlags(OdUInt32 drawFlags) { m_pTraits->setDrawFlags(drawFlags); }
  void setSelectionGeom(bool bSelectionFlag) { m_pTraits->setSelectionGeom(bSelectionFlag); }
  void setShadowFlags(OdGiSubEntityTraits::ShadowFlags shadowFlags) { m_pTraits->setShadowFlags(shadowFlags); }
  void setSectionable(bool bSectionableFlag) { m_pTraits->setSectionable(bSectionableFlag); }
  void setSelectionFlags(OdGiSubEntityTraits::SelectionFlags selectionFlags) { m_pTraits->setSelectionFlags(selectionFlags); }
  void setSecondaryTrueColor(const OdCmEntityColor& n) { m_pTraits->setSecondaryTrueColor(n); }
  void setLineStyleModifiers(const OdGiDgLinetypeModifiers* pLSMod) { m_pTraits->setLineStyleModifiers(pLSMod); }
  void setFill(const OdGiFill* pFill) { m_pTraits->setFill(pFill); }

  OdUInt16 color() const  { return  m_pTraits->color(); }
  OdCmEntityColor trueColor() const  { return  m_pTraits->trueColor(); }
  OdDbStub* layer() const  { return  m_pTraits->layer(); }
  OdDbStub* lineType() const  { return  m_pTraits->lineType(); }
  OdGiFillType fillType() const  { return  m_pTraits->fillType(); }
  bool fillPlane(OdGeVector3d& n) { return  m_pTraits->fillPlane(n); }
  OdDb::LineWeight lineWeight() const  { return  m_pTraits->lineWeight(); }
  double lineTypeScale() const  { return  m_pTraits->lineTypeScale(); }
  double thickness() const  { return m_pTraits->thickness(); }
  OdDb::PlotStyleNameType plotStyleNameType() const  { return m_pTraits->plotStyleNameType(); }
  OdDbStub* plotStyleNameId() const  { return  m_pTraits->plotStyleNameId(); }
  OdDbStub* material() const  { return  m_pTraits->material(); }
  const OdGiMapper* mapper() const  { return  m_pTraits->mapper(); }
  OdDbStub* visualStyle() const  { return  m_pTraits->visualStyle(); }
  OdCmTransparency transparency() const  {  return m_pTraits->transparency(); }
  OdUInt32 drawFlags() const  {  return m_pTraits->drawFlags(); }
  bool selectionGeom() const  { return m_pTraits->selectionGeom(); }
  OdGiSubEntityTraits::ShadowFlags shadowFlags() const  { return m_pTraits->shadowFlags(); }
  bool sectionable() const  { return m_pTraits->sectionable(); }
  OdGiSubEntityTraits::SelectionFlags selectionFlags() const  { return m_pTraits->selectionFlags(); }
  OdCmEntityColor secondaryTrueColor() const  { return m_pTraits->secondaryTrueColor(); }
  const OdGiDgLinetypeModifiers* lineStyleModifiers() const { return m_pTraits->lineStyleModifiers(); }
  const OdGiFill* fill() const { return m_pTraits->fill(); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T> class OdGiWrapperCommonDraw : public T
{
  OdGiCommonDraw *m_pD;
protected:
  void setDraw(OdGiCommonDraw &pD) { m_pD = &pD; }
  OdGiCommonDraw *getDraw() const { return m_pD; }
public:
  OdGiWrapperCommonDraw() : m_pD(0) {}
  virtual OdGiGeometry& rawGeometry() const            { return m_pD->rawGeometry(); }
  virtual OdGiRegenType regenType() const              { return m_pD->regenType(); }
  virtual bool regenAbort() const                      { return m_pD->regenAbort(); }
  virtual OdGiSubEntityTraits& subEntityTraits() const { return m_pD->subEntityTraits(); }
  virtual bool isDragging() const                      { return m_pD->isDragging(); }
  virtual OdGiContext* context() const                 { return m_pD->context(); }
  virtual OdUInt32 numberOfIsolines() const            { return m_pD->numberOfIsolines(); }
  virtual const OdGiPathNode* currentGiPath() const    { return m_pD->currentGiPath(); }
  virtual double deviation(const OdGiDeviationType t, const OdGePoint3d& p) const { return m_pD->deviation(t, p); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T> class OdGiWrapperViewportDraw : public OdGiWrapperCommonDraw< T >
{
public:
  virtual OdGiViewport& viewport() const { return ((OdGiViewportDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->viewport(); }
  virtual OdGiViewportGeometry& geometry() const  { return ((OdGiViewportDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->geometry(); }
  virtual OdUInt32 sequenceNumber() const  { return ((OdGiViewportDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->sequenceNumber(); }
  virtual bool isValidId(const OdUInt32 viewportId) const { return ((OdGiViewportDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->isValidId(viewportId); }
  virtual OdDbStub* viewportObjectId() const { return ((OdGiViewportDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->viewportObjectId(); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T> class OdGiWrapperWorldDraw : public OdGiWrapperCommonDraw< T >
{
public:
  virtual OdGiWorldGeometry& geometry() const  { return ((OdGiWorldDraw*)(OdGiWrapperCommonDraw< T >::getDraw()))->geometry(); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
class OdGiViewportDraw_Stub : public OdGiWrapperViewportDraw<OdGiViewportDraw>
                            , public OdGiWrapperViewportGeometry<OdGiViewportGeometry>
                            , public OdGiSubEntityTraitsWrapper<OdGiSubEntityTraits>
{
public:
  ODRX_USING_HEAP_OPERATORS( OdGiWrapperViewportDraw<OdGiViewportDraw> );

  OdGiViewportDraw_Stub(OdGiViewportDraw &pVD, OdGiViewportGeometry &pVG, OdGiSubEntityTraits &pST)
  {
    setDraw(pVD);
    setGeom(pVG);
    setTraits(pST);
  }

  virtual OdGiGeometry& rawGeometry() const   { return *static_cast<OdGiGeometry*>(const_cast<OdGiViewportDraw_Stub*>(this)); }
  virtual OdGiSubEntityTraits& subEntityTraits() const { return *static_cast<OdGiSubEntityTraits*>(const_cast<OdGiViewportDraw_Stub*>(this)); }
  virtual OdGiViewportGeometry& geometry() const  { return *static_cast<OdGiViewportGeometry*>(const_cast<OdGiViewportDraw_Stub*>(this)); }

  void addRef() { }
  void release() { }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
class OdGiWorldDraw_Stub : public OdGiWrapperWorldDraw<OdGiWorldDraw>
                         , public OdGiWrapperWorldGeometry<OdGiWorldGeometry>
                         , public OdGiSubEntityTraitsWrapper<OdGiSubEntityTraits>
{
public:
  ODRX_USING_HEAP_OPERATORS( OdGiWrapperWorldDraw<OdGiWorldDraw> );

  OdGiWorldDraw_Stub(OdGiWorldDraw &pVD, OdGiWorldGeometry &pVG, OdGiSubEntityTraits &pST)
  {
    setDraw(pVD);
    setGeom(pVG);
    setTraits(pST);
  }

  virtual OdGiGeometry& rawGeometry() const   { return *static_cast<OdGiGeometry*>(const_cast<OdGiWorldDraw_Stub*>(this)); }
  virtual OdGiSubEntityTraits& subEntityTraits() const { return *static_cast<OdGiSubEntityTraits*>(const_cast<OdGiWorldDraw_Stub*>(this)); }
  virtual OdGiWorldGeometry& geometry() const  { return *static_cast<OdGiWorldGeometry*>(const_cast<OdGiWorldDraw_Stub*>(this)); }

  void addRef() { }
  void release() { }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyGeometry : public T
{
public:
  void circle(const OdGePoint3d& /*center*/, double /*radius*/, const OdGeVector3d& /*normal*/) {}

  void circle(const OdGePoint3d& /*firstPoint*/, const OdGePoint3d& /*secondPoint*/, const OdGePoint3d& /*thirdPoint*/) {}

  void circularArc(const OdGePoint3d& /*center*/,
    double /*radius*/,
    const OdGeVector3d& /*normal*/,
    const OdGeVector3d& /*startVector*/,
    double /*sweepAngle*/,
    OdGiArcType /*arcType*/ = kOdGiArcSimple) {}

  void circularArc(const OdGePoint3d& /*firstPoint*/,
    const OdGePoint3d& /*secondPoint*/,
    const OdGePoint3d& /*thirdPoint*/,
    OdGiArcType /*arcType */= kOdGiArcSimple) {}

  void polyline(OdInt32 /*numVertices*/,
    const OdGePoint3d* /*vertexList*/,
    const OdGeVector3d* /*pNormal */= 0,
     OdGsMarker /*baseSubEntMarker */= -1) {}

  void polygon(OdInt32 /*numVertices*/, const OdGePoint3d* /*vertexList*/) {}

  void pline(const OdGiPolyline& /*polylPine*/, OdUInt32 /*fromIndex */= 0, OdUInt32 /*numSegs */= 0) {}

  void shape(const OdGePoint3d& /*position*/,
    const OdGeVector3d& /*normal*/, const OdGeVector3d& /*direction*/,
    int /*shapeNumber*/, const OdGiTextStyle* /*pTextStyle*/) {}

  void text(const OdGePoint3d& /*position*/,
    const OdGeVector3d& /*normal*/, const OdGeVector3d& /*direction*/,
    double /*height*/, double /*width*/, double /*oblique*/, const OdString& /*msg*/) {}

  void text(const OdGePoint3d& /*position*/,
    const OdGeVector3d& /*normal*/, const OdGeVector3d& /*direction*/,
    const OdChar* /*msg*/, OdInt32 /*length*/, bool /*raw*/, const OdGiTextStyle* /*pTextStyle*/) {}


  void xline(const OdGePoint3d& /*firstPoint*/, const OdGePoint3d& /*secondPoint*/) {}

  void ray(const OdGePoint3d& /*basePoint*/, const OdGePoint3d& /*throughPoint */) {}

  void nurbs(const OdGeNurbCurve3d& /*nurbsCurve*/) {}

  void ellipArc(const OdGeEllipArc3d& /*ellipArc*/,
    const OdGePoint3d* /*endPointsOverrides */= 0,
    OdGiArcType /*arcType */= kOdGiArcSimple) {}

  void mesh(OdInt32 /*numRows*/,
    OdInt32 /*numColumns*/,
    const OdGePoint3d* /*vertexList*/,
    const OdGiEdgeData* /*pEdgeData */= 0,
    const OdGiFaceData* /*pFaceData */= 0,
    const OdGiVertexData* /*pVertexData */= 0) {}

  void shell(OdInt32 /*numVertices*/,
    const OdGePoint3d* /*vertexList*/,
    OdInt32 /*faceListSize*/,
    const OdInt32* /*faceList*/,
    const OdGiEdgeData* /*pEdgeData */= 0,
    const OdGiFaceData* /*pFaceData */= 0,
    const OdGiVertexData* /*pVertexData */= 0) {}

  void worldLine(const OdGePoint3d /*points*/[2]) {}

  void image(const OdGiImageBGRA32& /*img*/,
    const OdGePoint3d& /*origin*/,
    const OdGeVector3d& /*uVec*/,
    const OdGeVector3d& /*vVec*/,
    OdGiRasterImage::TransparencyMode /*trpMode*/ = OdGiRasterImage::kTransparency8Bit) {}

  virtual void edge(const OdGiEdge2dArray& /*edges*/) {}

  void polypoint(OdInt32 /*numPoints*/, const OdGePoint3d* /*vertexList*/, const OdCmEntityColor* /*pColors*/, const OdCmTransparency* /*pTransparency*/,
                 const OdGeVector3d* /*pNormals*/, const OdGsMarker* /*pSubEntMarkers*/, OdInt32 /*nPointSize*/) {}

  void rowOfDots(OdInt32 /*numPoints*/, const OdGePoint3d& /*startPoint*/, const OdGeVector3d& /*dirToNextPoint*/) {}

  void setExtents(const OdGePoint3d * /*newExtents*/) {}

  void pushClipBoundary(OdGiClipBoundary* /*pBoundary*/) {}
  void popClipBoundary() {}
  void draw(const OdGiDrawable* /*pDrawable*/) {}

  void pushModelTransform(const OdGeMatrix3d& /*xMat*/) { }

  void pushModelTransform(const OdGeVector3d& /*normal*/) { }

  void popModelTransform() { }

  OdGeMatrix3d getModelToWorldTransform() const { return OdGeMatrix3d::kIdentity; }

  OdGeMatrix3d getWorldToModelTransform() const { return OdGeMatrix3d::kIdentity; }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyWorldGeometry : public OdGiDummyGeometry< T >
{
public:
  virtual void setExtents(
    const OdGePoint3d * /*newExtents*/) { }

  virtual void startAttributesSegment() {}
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyViewportGeometry : public OdGiDummyGeometry< T >
{
public:
  virtual void polylineEye(
    OdUInt32 , 
    const OdGePoint3d* ) { }

  virtual void polygonEye(
    OdUInt32 , 
    const OdGePoint3d* ) {  }

  virtual void polylineDc(
    OdUInt32 , 
    const OdGePoint3d* ) {  }

  virtual void polygonDc(
    OdUInt32 , 
    const OdGePoint3d* ) {  }

  virtual void rasterImageDc(
    const OdGePoint3d& ,
    const OdGeVector3d& ,
    const OdGeVector3d& ,
    const OdGiRasterImage* , 
    const OdGePoint2d* , 
    OdUInt32 ,
    bool  = false,
    double  = 50.0,
    double  = 50.0,
    double  = 0.0) {  }

  virtual void  metafileDc(
    const OdGePoint3d& ,
    const OdGeVector3d& ,
    const OdGeVector3d& ,
    const OdGiMetafile* ,
    bool  = true,
    bool  = false) {  }

  virtual void ownerDrawDc(
    const OdGePoint3d& ,
    const OdGeVector3d& ,
    const OdGeVector3d& ,
    const OdGiSelfGdiDrawable* ,
    bool  = true,
    bool  = false) {  }
};

// OdGiSubEntityTraits dummy template

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummySubEntityTraits : public T
{
public:
  void setColor(OdUInt16 ) { }
  void setTrueColor(const OdCmEntityColor& ) { }
  void setLayer(OdDbStub* ) { }
  void setLineType(OdDbStub* ) { }
  void setSelectionMarker(OdGsMarker ) { }
  void setFillType(OdGiFillType ) { }
  void setFillPlane(const OdGeVector3d* = 0) {}
  void setLineWeight(OdDb::LineWeight ) { }
  void setLineTypeScale(double  = 1.0) { }
  void setThickness(double ) { }
  void setPlotStyleName(OdDb::PlotStyleNameType, OdDbStub* = 0) { }
  void setMaterial(OdDbStub* ) { }
  void setMapper(const OdGiMapper * /*pMapper*/) { }
  void setVisualStyle(const OdDbStub* /*visualStyleId*/) { }
  void setTransparency(const OdCmTransparency& /*transparency*/) { }
  void setDrawFlags(OdUInt32 /*drawFlags*/) { }
  void setSelectionGeom(bool /*bSelectionFlag*/) { }
  void setShadowFlags(OdGiSubEntityTraits::ShadowFlags /*shadowFlags*/) { }
  void setSectionable(bool /*bSectionableFlag*/) { }
  void setSelectionFlags(OdGiSubEntityTraits::SelectionFlags /*selectionFlags*/) { }

  OdUInt16 color() const { return 0; }
  OdCmEntityColor trueColor() const { return OdCmEntityColor(); }
  OdDbStub* layer() const { return NULL; }
  OdDbStub* lineType() const { return NULL; }
  OdGiFillType fillType() const { return kOdGiFillNever; }
  bool fillPlane(OdGeVector3d& /*normal*/) { return false; }
  OdDb::LineWeight lineWeight() const { return OdDb::kLnWt000; }
  double lineTypeScale() const { return 0.0; }
  double thickness() const { return 0.0; }
  OdDb::PlotStyleNameType plotStyleNameType() const { return OdDb::kPlotStyleNameByBlock; }
  OdDbStub* plotStyleNameId() const { return NULL; }
  OdDbStub* material() const { return NULL; }
  const OdGiMapper* mapper() const { return NULL; }
  void addLight(const OdDbStub* /*lightId*/) { }
  OdCmTransparency transparency() const { return OdCmTransparency(); }
  OdUInt32 drawFlags() const { return 0; }
  bool selectionGeom() const { return false; }
  OdGiSubEntityTraits::ShadowFlags shadowFlags() const { return OdGiSubEntityTraits::kShadowsCastAndReceive; }
  bool sectionable() const { return false; }
  OdGiSubEntityTraits::SelectionFlags selectionFlags() const { return OdGiSubEntityTraits::kNoSelectionFlags; }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T> class OdGiDummyCommonDraw : public T
{
public:
  virtual OdGiRegenType regenType() const              { return kOdGiStandardDisplay; } // dont change from kOdGiStandardDisplay
  virtual bool regenAbort() const                      { return false; }
  virtual bool isDragging() const                      { return false; }
  virtual OdUInt32 numberOfIsolines() const { return 4; }
  virtual double deviation(const OdGiDeviationType t, const OdGePoint3d& p) const { return 0.; }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyViewportDraw : public OdGiDummyCommonDraw< T >
{
public:
  virtual OdUInt32 sequenceNumber() const  { return 0; }
  virtual bool isValidId(const OdUInt32 viewportId) const { return false; }
  virtual OdDbStub* viewportObjectId() const { return (OdDbStub*)1; } // something non NULL
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyWorldDraw : public OdGiDummyCommonDraw< T >
{
public:
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyContext : public T
{
public:
  virtual OdDbBaseDatabase* database() const { return 0;}
  virtual OdGiDrawablePtr openDrawable(OdDbStub* ) { return OdGiDrawablePtr(); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiDummyViewport : public T
{
public:
  virtual OdGeMatrix3d getModelToEyeTransform() const { return OdGeMatrix3d::kIdentity; }
  virtual OdGeMatrix3d getEyeToModelTransform() const { return OdGeMatrix3d::kIdentity; }
  virtual OdGeMatrix3d getWorldToEyeTransform() const { return OdGeMatrix3d::kIdentity; }
  virtual OdGeMatrix3d getEyeToWorldTransform() const { return OdGeMatrix3d::kIdentity; }
  virtual bool isPerspective() const { return false; }
  virtual bool doPerspective(OdGePoint3d& /*p*/) const { return false; }
  virtual bool doInversePerspective(OdGePoint3d& /*p*/) const  { return false; }
  virtual void getNumPixelsInUnitSquare(const OdGePoint3d& /*givenWorldpt*/, OdGePoint2d& /*pixelArea*/, bool /*includePerspective*/ = true) const {  }
  virtual OdGePoint3d getCameraLocation() const { return OdGePoint3d::kOrigin; }
  virtual OdGePoint3d getCameraTarget() const { return OdGePoint3d::kOrigin + OdGeVector3d::kZAxis; }
  virtual OdGeVector3d getCameraUpVector() const { return OdGeVector3d::kYAxis; }
  virtual OdGeVector3d viewDir() const { return getCameraTarget() - getCameraLocation();  }
  virtual OdUInt32 viewportId() const { return 0xFFFFFFFF; }
  virtual OdInt16  acadWindowId() const { return -1; }
  virtual void getViewportDcCorners(OdGePoint2d& lower_left, OdGePoint2d& upper_right) const { lower_left.set(0,0); upper_right.set(100,100); }
  virtual bool getFrontAndBackClipValues(bool& clip_front, bool& clip_back, double& /*front*/, double& /*back*/) const { clip_front = clip_back = false; return false; }
  virtual double linetypeScaleMultiplier() const { return 1.0; }
  virtual double linetypeGenerationCriteria() const { return 1.0; }
  virtual bool layerVisible(OdDbStub* /*idLayer*/) const { return true; }
};

/** \details
This class is a dummy template for OdGiViewport.
Library: TD_Gi
<group OdGi_Classes>
*/
template <class T> class OdGiWrapperViewport : public T
{
  const OdGiViewport* m_ref;
protected:
  void set(const OdGiViewport& ref) { m_ref = &ref; }
  const OdGiViewport &get() const { return *m_ref; }
public:
  virtual OdGeMatrix3d getModelToEyeTransform() const { return get().getModelToEyeTransform(); }
  virtual OdGeMatrix3d getEyeToModelTransform() const { return get().getEyeToModelTransform(); }
  virtual OdGeMatrix3d getWorldToEyeTransform() const { return get().getWorldToEyeTransform(); }
  virtual OdGeMatrix3d getEyeToWorldTransform() const { return get().getEyeToWorldTransform(); }
  virtual bool isPerspective() const { return get().isPerspective(); }
  virtual bool doPerspective(OdGePoint3d& p) const { return get().doPerspective(p); }
  virtual bool doInversePerspective(OdGePoint3d& p) const  { return get().doInversePerspective(p); }
  virtual void getNumPixelsInUnitSquare(const OdGePoint3d& givenWorldpt,
    OdGePoint2d& pixelArea, bool includePerspective = true) const
  {
    get().getNumPixelsInUnitSquare(givenWorldpt, pixelArea, includePerspective);
  }
  virtual OdGePoint3d getCameraLocation() const { return get().getCameraLocation(); }
  virtual OdGePoint3d getCameraTarget() const { return get().getCameraTarget(); }
  virtual OdGeVector3d getCameraUpVector() const { return get().getCameraUpVector(); }
  virtual OdGeVector3d viewDir() const { return get().viewDir();  }
  virtual OdUInt32 viewportId() const { return get().viewportId(); }
  virtual OdInt16  acadWindowId() const { return get().acadWindowId(); }
  virtual void getViewportDcCorners(OdGePoint2d& lower_left, OdGePoint2d& upper_right) const
  { get().getViewportDcCorners(lower_left, upper_right); }
  virtual bool getFrontAndBackClipValues(bool& clip_front, bool& clip_back, double& front, double& back) const
  { return get().getFrontAndBackClipValues(clip_front, clip_back, front, back); }
  virtual double linetypeScaleMultiplier() const { return get().linetypeScaleMultiplier(); }
  virtual double linetypeGenerationCriteria() const { return get().linetypeGenerationCriteria(); }
  virtual bool layerVisible(OdDbStub* idLayer) const { return get().layerVisible(idLayer); }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
class OdGiViewportDraw_Dummy : public OdGiDummySubEntityTraits< OdGiSubEntityTraits >
                             , public OdGiDummyViewportDraw< OdGiViewportDraw >
                             , public OdGiDummyViewportGeometry< OdGiViewportGeometry >
                             , public OdGiDummyContext< OdGiContext >
                             , public OdGiDummyViewport< OdGiViewport >
{
  OdDbBaseDatabase *m_pDb;
public:
  ODRX_USING_HEAP_OPERATORS( OdGiDummySubEntityTraits< OdGiSubEntityTraits > );

  OdGiViewportDraw_Dummy(OdDbBaseDatabase *pDb = 0) : m_pDb(pDb) { }
  virtual OdDbBaseDatabase* database() const { return m_pDb; }

  virtual OdGiGeometry& rawGeometry() const   { return *static_cast<OdGiGeometry*>(const_cast<OdGiViewportDraw_Dummy*>(this)); }
  virtual OdGiSubEntityTraits& subEntityTraits() const { return *static_cast<OdGiSubEntityTraits*>(const_cast<OdGiViewportDraw_Dummy*>(this)); }
  virtual OdGiViewport& viewport() const { return *static_cast<OdGiViewport*>(const_cast<OdGiViewportDraw_Dummy*>(this)); }
  virtual OdGiViewportGeometry& geometry() const  { return *static_cast<OdGiViewportGeometry*>(const_cast<OdGiViewportDraw_Dummy*>(this)); }
  virtual OdGiContext* context() const            { return static_cast<OdGiContext*>(const_cast<OdGiViewportDraw_Dummy*>(this)); }

  void addRef() { }
  void release() { }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
class OdGiWorldDraw_Dummy : public OdGiDummySubEntityTraits< OdGiSubEntityTraits >
  , public OdGiDummyWorldDraw< OdGiWorldDraw >
  , public OdGiDummyWorldGeometry< OdGiWorldGeometry >
  , public OdGiDummyContext< OdGiContext >
{
  OdDbBaseDatabase *m_pDb;
public:
  ODRX_USING_HEAP_OPERATORS( OdGiDummySubEntityTraits< OdGiSubEntityTraits > );

  OdGiWorldDraw_Dummy(OdDbBaseDatabase *pDb = 0) : m_pDb(pDb) { }
  virtual OdDbBaseDatabase* database() const { return m_pDb; }

  virtual OdGiGeometry& rawGeometry() const   { return *static_cast<OdGiGeometry*>(const_cast<OdGiWorldDraw_Dummy*>(this)); }
  virtual OdGiSubEntityTraits& subEntityTraits() const { return *static_cast<OdGiSubEntityTraits*>(const_cast<OdGiWorldDraw_Dummy*>(this)); }
  virtual OdGiWorldGeometry& geometry() const  { return *static_cast<OdGiWorldGeometry*>(const_cast<OdGiWorldDraw_Dummy*>(this)); }
  virtual OdGiContext* context() const            { return static_cast<OdGiContext*>(const_cast<OdGiWorldDraw_Dummy*>(this)); }

  void addRef() { }
  void release() { }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T, class DRAW, class WR, class WRA> class OdGeomGrabber : public T
{
  OdGsMarker m_curSelMarker;
  WRA &wires;

  OdGeomGrabber();
protected:
  virtual OdGsMarker getCurSelMarker() const {
    return m_curSelMarker;
  }

public:

  OdGeomGrabber(WRA &pW, DRAW &pVd)
    : T(pVd, pVd.geometry(), pVd.subEntityTraits())
    , m_curSelMarker(0)
    , wires(pW)
  { }

  virtual void setSelectionMarker(OdGsMarker n) { m_curSelMarker = n; T::setSelectionMarker(n); }

  virtual WR *appendWire()
  {
    WR *pWire = wires.append();
    pWire->selMarker = OdIntToGsMarker(-getFaceIndex(m_curSelMarker));
    pWire->color = T::subEntityTraits().trueColor();
    return pWire;
  }

  virtual void circle(const OdGePoint3d& center, double radius, const OdGeVector3d& normal)
  {
    appendWire()->circle(center, radius, normal);
    T::circle(center, radius, normal);
  }

  virtual void circle(const OdGePoint3d& p1, const OdGePoint3d& p2, const OdGePoint3d& p3)
  {
    appendWire()->circle(p1, p2, p3);
    T::circle(p1, p2, p3);
  }

  virtual void circularArc(const OdGePoint3d& center,
    double radius,
    const OdGeVector3d& normal,
    const OdGeVector3d& startVector,
    double sweepAngle,
    OdGiArcType arcType = kOdGiArcSimple)
  {
    appendWire()->circularArc(center, radius, normal, startVector, sweepAngle);
    T::circularArc(center, radius, normal, startVector, sweepAngle, arcType);
  }

  virtual void circularArc(const OdGePoint3d& start,
    const OdGePoint3d& point,
    const OdGePoint3d& end,
    OdGiArcType arcType = kOdGiArcSimple)
  {
    appendWire()->circularArc(start, point, end);
    T::circularArc(start, point, end, arcType);
  }

  virtual void polyline(OdInt32 nbPoints,
    const OdGePoint3d* pVertexList,
    const OdGeVector3d* pNormal = NULL,
    OdGsMarker lBaseSubEntMarker = -1)
  {
    appendWire()->polyline(nbPoints, pVertexList);
    T::polyline(nbPoints, pVertexList, pNormal, lBaseSubEntMarker);
  }

  virtual void nurbs(const OdGeNurbCurve3d& nurbs)
  {
    appendWire()->nurbs(nurbs);
    T::nurbs(nurbs);
  }
};

/** \details

Library: TD_Gi
<group OdGi_Classes>
*/
template<class T, class DRAW, class WR, class WRA> class OdShellGrabber : public T
{
  OdGsMarker m_curSelMarker;
  WRA &wires;

  OdShellGrabber();
public:

  OdShellGrabber(WRA &pW, DRAW &pVd) : T(pVd, pVd.geometry(), pVd.subEntityTraits())
    , m_curSelMarker(0)
    , wires(pW)
  { }

  virtual OdGiRegenType regenType() const              { return kOdGiHideOrShadeCommand; }

  virtual void setSelectionMarker(OdGsMarker n) { m_curSelMarker = n; T::setSelectionMarker(n); }

  virtual void shell(
    OdInt32 numVertices,
    const OdGePoint3d* vertexList,
    OdInt32 faceListSize,
    const OdInt32* faceList,
    const OdGiEdgeData* pEdgeData = 0,
    const OdGiFaceData* pFaceData = 0,
    const OdGiVertexData* pVertexData = 0)
  {
    WR *pWire = wires.append();
    pWire->selMarker = m_curSelMarker;
    pWire->color = T::subEntityTraits().trueColor();
    pWire->shell(
      numVertices,
      vertexList,
      faceListSize,
      faceList,
      pEdgeData,
      pFaceData,
      pVertexData);

    T::shell(
      numVertices,
      vertexList,
      faceListSize,
      faceList,
      pEdgeData,
      pFaceData,
      pVertexData);
  }
};

typedef  OdStaticRxObject< OdGiDummySubEntityTraits< OdGiSubEntityTraits > > OdGiSubEntityTraits_Stub;

#include "TD_PackPop.h"

#endif // #ifndef _ODGIDUMMYGEOM_INCLUDED_