#ifndef __CAUXENTEX_H
#define __CAUXENTEX_H
//
//  cauxentex.h - These classe will implement drawing and geometry features
//
//  (C) Copyright 1993-2007 by Autodesk, Inc.  All rights reserved.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted, 
// provided that the above copyright notice appears in all copies and 
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting 
// documentation.
//
// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. 
// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  AUTODESK, INC. 
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
//
// Use, duplication, or disclosure by the U.S. Government is subject to 
// restrictions set forth in FAR 52.227-19 (Commercial Computer
// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)
// (Rights in Technical Data and Computer Software), as applicable.
//
#include "AdAChar.h"

/////////////////////////////////////////////////////////////////////
//
// Notes:
// the color of -1 means no color at all. It is than controled be
// the caller entityTraits
//
/////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////
// general polyline - just linear segments
// if it has to be closed, than last point must match
// the first point
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxPline : public AcmCAuxEntity
{
public:
  AcmCAuxPline();
  AcmCAuxPline(const AcGePoint3d& from, const AcGePoint3d& to);
  AcmCAuxPline(const AcGePoint3dArray& points);
  AcmCAuxPline(const AcmCAuxPline& src);
  AcmCAuxPline(const AcDbLine* src);

  virtual ~AcmCAuxPline();

  virtual const AcmCAuxPline& operator=(const AcmCAuxPline& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  void setPlane(const AcGePlane& pl);
  const AcGePlane *plane() const;

  void set(const AcGePoint3d& from,const AcGePoint3d& to);
  void set(const AcGePoint3dArray& points);
  void getPoints(AcGePoint3dArray&);
  void removeAll();

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);
  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};


/////////////////////////////////////////////////////////////////////
// general polygon - just closed linear segments
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxPolygon : public AcmCAuxEntity
{
public:
  AcmCAuxPolygon();
  AcmCAuxPolygon(const AcGePoint3dArray& points,
                 const AcGiFillType fill = kAcGiFillAlways);
  AcmCAuxPolygon(const AcmCAuxPolygon& src);
  virtual ~AcmCAuxPolygon();

  virtual const AcmCAuxPolygon& operator=(const AcmCAuxPolygon& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  void set(const AcGePoint3dArray& points,
           const AcGiFillType fill = kAcGiFillAlways);
  void removeAll();

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);

  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};

/////////////////////////////////////////////////////////////////////
// general circle
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxCircle : public AcmCAuxEntity
{
public:

  AcmCAuxCircle();
  AcmCAuxCircle(const AcGePoint3d& center,
                double radius,
                const AcGeVector3d& normal = AcGeVector3d::kZAxis);
  AcmCAuxCircle(const AcGePoint3d& p1,
                const AcGePoint3d& p2,
                const AcGePoint3d& p3);
  AcmCAuxCircle(const AcmCAuxCircle& src);
  AcmCAuxCircle(const AcDbCircle* src);
  virtual ~AcmCAuxCircle();

  void setFillType(const AcGiFillType fill);

  virtual const AcmCAuxCircle& operator=(const AcmCAuxCircle& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  void set(const AcGePoint3d& center,
           double radius,
           const AcGeVector3d& normal = AcGeVector3d::kZAxis);
  
  void set(const AcGePoint3d& p1,
           const AcGePoint3d& p2,
           const AcGePoint3d& p3);

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw*        mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);

  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};

/////////////////////////////////////////////////////////////////////
// general Arc
// it is considered as planar entity - WCS planar !!
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxArc : public AcmCAuxEntity
{
public:
  AcmCAuxArc();
  AcmCAuxArc( const AcGePoint3d& center,
              double radius,
              double sweepAngle,
              const AcGeVector3d& startVect = AcGeVector3d::kXAxis,
              const AcGeVector3d& normal = AcGeVector3d::kZAxis);
  
  AcmCAuxArc( const AcGePoint3d& startPoint,
              const AcGePoint3d& point,
              const AcGePoint3d& endPoint);
  
  AcmCAuxArc(const AcmCAuxArc& src);
  AcmCAuxArc(const AcDbArc* src);
  virtual ~AcmCAuxArc();

  virtual const AcmCAuxArc& operator=(const AcmCAuxArc& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  void set( const AcGePoint3d& center,
            double radius,
            double sweepAngle,
            const AcGeVector3d& refVect = AcGeVector3d::kXAxis,
            const AcGeVector3d& normal = AcGeVector3d::kZAxis);
  
  void set( const AcGePoint3d& startPoint,
            const AcGePoint3d& point,
            const AcGePoint3d& endPoint);

  void setFillType(const AcGiFillType fill);
  void setArcType(const AcGiArcType arcType);

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* mode);
  virtual void              viewportDraw(AcGiViewportDraw* mode);

  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};


/////////////////////////////////////////////////////////////////////
//General text
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxText : public AcmCAuxEntity
{
public:
  AcmCAuxText();
  AcmCAuxText(const AcGePoint3d& location,
              double txtHeight,
              const ACHAR* contents,
              const AcDbMText::AttachmentPoint attachment = AcDbMText::kBottomLeft,
              const AcDbObjectId& txtStyleId = *(AcDbObjectId*)NULL);
  AcmCAuxText(const AcmCAuxText&);
  AcmCAuxText(const AcDbText* pDef);
  AcmCAuxText(const AcDbMText* pDef);
  virtual ~AcmCAuxText();

  virtual const AcmCAuxText& operator=(const AcmCAuxText& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;
                                          
  void set(const AcGePoint3d& location,
           const ACHAR* contents,
           const AcDbMText::AttachmentPoint attachment = AcDbMText::kBottomLeft);

  void setTextStyle(const AcDbObjectId& txtStyleId);
  void setTextHeight(double height);
  AcDbMText& getMText();
  
  virtual void setProperties(const AcDbObjectId& id,Adesk::Int16 color = -1);
  virtual void setColor(Adesk::Int16 col); 
  virtual void setProperties(const AcDbObjectId& id, const AcCmColor & col);
  virtual void setColor(const AcCmColor & col); 

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents&     extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* pMode);
  virtual void              viewportDraw(AcGiViewportDraw* pMode);

};

class DllImpExp AcmCAuxAcDbText : public AcmCAuxEntity
{
public:
  AcmCAuxAcDbText();
  AcmCAuxAcDbText(const AcmCAuxAcDbText&);
  AcmCAuxAcDbText(const AcDbText* pDef);

  virtual const AcmCAuxAcDbText& operator=(const AcmCAuxAcDbText& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;
                                          
  AcDbText& getText();  
    
  virtual void setProperties(const AcDbObjectId& id,Adesk::Int16 color = -1);
  virtual void setColor(Adesk::Int16 col); 
  
  virtual void setProperties(const AcDbObjectId & id, const AcCmColor & col);
  virtual void setColor(const AcCmColor & col);   

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents&     extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* pMode);
  virtual void              viewportDraw(AcGiViewportDraw* pMode);
};

class DllImpExp AcmCAuxAttribute : public AcmCAuxText
{
public:
  AcmCAuxAttribute();
  AcmCAuxAttribute(const ACHAR*);
  AcmCAuxAttribute(const AcmCAuxAttribute&);
  AcmCAuxAttribute(const AcDbAttributeDefinition* pDef);

  virtual ~AcmCAuxAttribute();

  virtual const AcmCAuxAttribute& operator=(const AcmCAuxAttribute& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  Adesk::Boolean isPreset() const;
  void setPreset(Adesk::Boolean preset);
  Adesk::Boolean isInvisible() const;
  void setInvisible(Adesk::Boolean invisible);
  LPCTSTR tag() const;
  void setTag(LPCTSTR name);
  void setPrompt(LPCTSTR name);
  LPCTSTR prompt() const;
};

class DllImpExp AcmCAuxScaleText : public AcmCAuxText
{
public:
  enum ScaleMode
  {
    kWidthFactor = 0,
    kWidthLimit
  };

public:
  AcmCAuxScaleText();
  AcmCAuxScaleText(const AcGePoint3d& oLocation,
                   double nTextHeight,
                   const ACHAR* strContents,
                   const AcDbMText::AttachmentPoint enAttachment = AcDbMText::kBottomLeft,
                   const AcDbObjectId& oTextStyleId = *(AcDbObjectId*)NULL,
                   double nWidthFactor = 1.0,
                   double nWidthLimit = 0.0,
                   ScaleMode enScaleMode = kWidthFactor);
  AcmCAuxScaleText(const AcmCAuxScaleText&);
  AcmCAuxScaleText(const AcDbText* pDef);
  AcmCAuxScaleText(const AcDbMText* pDef);
  virtual ~AcmCAuxScaleText();

  virtual const AcmCAuxScaleText& operator=(const AcmCAuxScaleText& src);
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  void setWidthFactor(double nWidthFactor);
  double widthFactor() const;

  void setWidthLimit(double nWidthLimit);
  double widthLimit() const;

  void setScaleMode(ScaleMode enScaleMode);
  ScaleMode scaleMode() const;

  double calcWidthFactor() const;
};

/////////////////////////////////////////////////////////////////////
//AcmCAuxHatch
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxHatch : public AcmCAuxEntity
{
public:
  AcmCAuxHatch();
  AcmCAuxHatch(const AcmCAuxHatch& src);
  AcmCAuxHatch(const AcDbHatch* pDbHatch);

  AcmCAuxHatch(AcDbHatch::HatchStyle style,
               double elevation = 0.0,
               AcGeVector3d normal = AcGeVector3d::kZAxis);

  virtual ~AcmCAuxHatch();

  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;
  virtual const AcmCAuxHatch& operator=(const AcmCAuxHatch& src);

  Acad::ErrorStatus appendLoop(Adesk::Int32 loopType,
                               const AcGePoint2dArray& vertices,
                               const AcGeDoubleArray& bulges);

  Acad::ErrorStatus appendLoop(Adesk::Int32 loopType,
                               const AcGeVoidPointerArray& edgePtrs,
                               const AcGeIntArray&  edgeTypes);  
  
  virtual void setProperties(const AcDbObjectId& id,Adesk::Int16 color = -1);
  virtual void setColor(Adesk::Int16 col); 
  
  virtual void setProperties(const AcDbObjectId & id, const AcCmColor & col);
  virtual void setColor(const AcCmColor & col); 

  void set(AcDbHatch::HatchStyle style,
           double elevation = 0.0,
           AcGeVector3d normal = AcGeVector3d::kZAxis);

  void setPattern(AcDbHatch::HatchPatternType patType,
                  const ACHAR* patName);

  void setPatternAngle(double angle);
  void setPatternSpace(double space);
  void setPatternDouble(Adesk::Boolean isDouble);

  Acad::ErrorStatus  evaluateHatch();

  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw* mode);
  virtual void              viewportDraw(AcGiViewportDraw* mode);
};

/////////////////////////////////////////////////////////////////////
// general ellipse
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxEllipse : public AcmCAuxEntity
{
public:
  AcmCAuxEllipse();
  AcmCAuxEllipse(
      const AcGePoint3d& center,
      const AcGeVector3d& normal,
      const AcGeVector3d& majorAxis,
      double radiusRatio,
      double startAngle = 0.0,
      double endAngle = 6.28318530717958647692);
  AcmCAuxEllipse(const AcmCAuxEllipse& src);
  AcmCAuxEllipse(const AcDbEllipse* src);

  virtual ~AcmCAuxEllipse();
  virtual const AcmCAuxEllipse& operator=(const AcmCAuxEllipse& src);

  // access to private data
  AcDbEllipse& getEllipse();
  Acad::ErrorStatus setEllipse(
      const AcGePoint3d& center,
      const AcGeVector3d& normal,
      const AcGeVector3d& majorAxis,
      double radiusRatio,
      double startAngle = 0.0,
      double endAngle = 6.28318530717958647692);
  
  // cloning ellipses
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  // forced interface
  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw*        mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);
  // obligatory interface
  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};

/////////////////////////////////////////////////////////////////////
// general spline
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxSpline : public AcmCAuxEntity
{
public:
  // constructors
  AcmCAuxSpline();
  AcmCAuxSpline(const AcmCAuxSpline& src);
  AcmCAuxSpline(const AcDbSpline* src);

  AcmCAuxSpline(
      const AcGePoint3d& center,
      const AcGeVector3d& normal,
      const AcGeVector3d& majorAxis,
      double radiusRatio,
      double startAngle = 0.0,
      double endAngle = 6.28318530717958647692);
  AcmCAuxSpline(
      const AcGePoint3dArray& fitPoints,
      int order= 4,
      double fitTolerance = 0.0);
  AcmCAuxSpline(
      const AcGePoint3dArray& fitPoints,
      const AcGeVector3d& startTangent,
      const AcGeVector3d& endTangent,
      int order = 4,
      double fitTolerance= 0.0);
  AcmCAuxSpline(
      int degree,
      Adesk::Boolean isRational,
      Adesk::Boolean isClosed,
      Adesk::Boolean isPeriodic,
      const AcGePoint3dArray& controlPoints,
      const AcGeDoubleArray& knots,
      const AcGeDoubleArray& weights,
      double controlPtTol = 0.0,
      double knotTol = 0.0);

  virtual ~AcmCAuxSpline();
  virtual const AcmCAuxSpline& operator=(const AcmCAuxSpline& src);

  // access to private data
  AcDbSpline& getSpline();
  
  // cloning splines
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  // forced interface
  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw*        mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);
  // obligatory interface
  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};

/////////////////////////////////////////////////////////////////////
// Raster Image entity
/////////////////////////////////////////////////////////////////////
class DllImpExp AcmCAuxRasterImage : public AcmCAuxEntity
{
public:
  AcmCAuxRasterImage();
  AcmCAuxRasterImage(const AcmCAuxRasterImage& src);
  AcmCAuxRasterImage(const AcDbRasterImage* src);

  ~AcmCAuxRasterImage();
  virtual const AcmCAuxRasterImage& operator=(const AcmCAuxRasterImage& src);

  // access to private data
  AcDbRasterImage& getRasterImage();
  
  // cloning splines
  virtual AcmCAuxEntity* clone() const;
  virtual AcmCAuxEntity::Type type() const;

  // forced interface
  virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
  virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
  virtual Acad::ErrorStatus explode(AcDbVoidPtrArray& entitySet,const AcDbEntity*) const;
  virtual Adesk::Boolean    worldDraw(AcGiWorldDraw*        mode);
  virtual void              viewportDraw(AcGiViewportDraw*  mode);
  // obligatory interface
  virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode     osnapMode,
                                           const AcGePoint3d&  pickPoint,
                                           const AcGePoint3d&  lastPoint,
                                           const AcGeMatrix3d& viewXform,
                                           AcGePoint3dArray&   snapPoints,
                                           AcDbIntArray&       geomIds) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            AcGePoint3dArray& points,
                                            INT_PTR entGsMarker = 0) const;
  virtual  Acad::ErrorStatus  intersectWith(const AcDbEntity* ent,
                                            AcDb::Intersect intType, 
                                            const AcGePlane& projPlane,
                                            AcGePoint3dArray& points, 
                                            INT_PTR entGsMarker = 0) const;
};

#endif
