addclass.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// 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.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
#include "addmacro.h"
#include "AddGlobals.h"
 
#include "AcRTTIObject.h"
#include "AcNonRTTIObject.h"
#include "acad/global func.h"
 
#include "acdb17/AcDbLayerTableRecord.h"
#include "acdb17/AcDbTextStyleTableRecord.h"
#include "acdb17/AcDbLinetypeTableRecord.h"
#include "acdb17/AcDbDimStyleTableRecord.h"
 
#include "acdb17/AcDbTextStyleTable.h"
#include "acdb17/AcDbLinetypeTable.h"
#include "acdb17/AcDbLayerTable.h"
#include "acdb17/AcDbDimStyleTable.h"
#include "FxDynPropManager.h"
 
#include "AutoInitializer.h"
 
inline bool AcRxObject::isKindOf( const AcRxClass* pOtherClass ) const
{
    const AcRxClass * pMyClass = this->isA();
    if ( !pOtherClass )
        return false;
    return pMyClass == NULL ? false : pMyClass->isDerivedFrom( pOtherClass );
}
 
class AcEdUIContext;
class AcEditorReactor;
class AcGsModel;
class AcGsReactor;
class AcDbLayoutManagerReactor;
class AcEdCommandIterator;
class AcGsDevice;
class AcApDocument;
class AcEdInputPointFilter;
class AcEdInputPoint;
class FileIOFormatter_Impl;
class AcRxResourceInstance;
 
class ARX_API AcApDocManagerReactor : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcApDocManagerReactor );
    virtual void documentCreateStarted( AcApDocument* );
    virtual void documentCreated( AcApDocument* );
    virtual void documentToBeDestroyed( AcApDocument* );
    virtual void documentDestroyed( const ACHAR* );
    virtual void documentActivated( AcApDocument* );
    virtual void documentToBeDeactivated( AcApDocument* );
    virtual void documentToBeActivated( AcApDocument* );
    virtual void documentActivationModified( bool );
    virtual void documentBecameCurrent( AcApDocument* );
    virtual void documentLockModeChanged( AcApDocument*, AcAp::DocLockMode, AcAp::DocLockMode, AcAp::DocLockMode, const ACHAR* );
    virtual void documentLockModeChangeVetoed( AcApDocument*, const ACHAR* );
    virtual void documentLockModeWillChange( AcApDocument*, AcAp::DocLockMode, AcAp::DocLockMode, AcAp::DocLockMode, const ACHAR* );
    virtual void documentCreateCanceled( AcApDocument* );
 
protected:
    AcApDocManagerReactor();
    Acad::ErrorStatus veto();
};
 
template < typename Param1 >
class ARX_API AcApDataManager : public AcApDocManagerReactor
{
public:
    AcApDataManager()
    {
        acDocManagerPtr()->addReactor( this );
    }
 
    ~AcApDataManager()
    {
        if ( acDocManagerPtr() != nullptr )
            acDocManagerPtr()->removeReactor( this );
    }
 
    virtual void documentToBeDestroyed( AcApDocument *param_1 )
    {
        m_dataMap.erase( param_1 );
    }
 
    Param1 &docData( AcApDocument *param_1 )
    {
        auto iter = m_dataMap.find( param_1 );
        if ( iter == m_dataMap.end() )
            return ( m_dataMap[ param_1 ] );
        return ( ( *iter ).second );
    }
 
    Param1 &docData()
    {
        return ( docData( acDocManagerPtr()->curDocument() ) );
    }
 
private:
    std::map<AcApDocument*, Param1> m_dataMap;
};
 
class ARX_API AcDbExpressionValue : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcDbExpressionValue );
};
 
class ARX_API AcDbFilerController : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcDbFilerController );
};
 
template < typename Param1 >
class AcDbObjectPointer
{
public:
    AcDbObjectPointer()
    {
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
    }
 
    AcDbObjectPointer( AcDbObjectId param1, AcDb::OpenMode param2, bool = false )
    {
        this->m_ptr = 0;
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2 );
    }
 
    AcDbObjectPointer( ACHAR const* param1, AcDbDatabase* param2, AcDb::OpenMode param3 )
    {
        //ASSERT(0);
    }
    ~AcDbObjectPointer()
    {
        close();
    }
 
    Acad::ErrorStatus open( AcDbObjectId param1, AcDb::OpenMode param2, bool param3 = false )
    {
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2, param3 );
        return this->m_status;
    }
 
    Acad::ErrorStatus acquire( Param1*& pObjToAcquire )
    {
        if ( pObjToAcquire == NULL )
            return Acad::eNullObjectPointer;
        if ( this->m_ptr != NULL )
        {
            assert( this->m_status == Acad::eOk );
            Acad::ErrorStatus closeStatus = close();
            if ( closeStatus != Acad::eOk )
                return closeStatus;
        }
        this->m_ptr = pObjToAcquire;
        this->m_status = Acad::eOk;
        pObjToAcquire = NULL;
        return Acad::eOk;
    }
 
    Acad::ErrorStatus openStatus() const
    {
        return this->m_status;
    }
 
    Acad::ErrorStatus release( Param1*& pReleasedObj )
    {
        if ( this->m_ptr == NULL )
            return Acad::eNullObjectPointer;
        assert( this->m_status == Acad::eOk );
        pReleasedObj = this->m_ptr;
        this->m_ptr = NULL;
        this->m_status = Acad::eNullObjectPointer;
        return Acad::eOk;
    }
 
    Acad::ErrorStatus create()
    {
        Param1* pNew = new Param1;
        if ( this->m_ptr )
            this->m_ptr->close();
 
        this->m_ptr = pNew;
        this->m_status = Acad::eOk;
        return Acad::eOk;
    }
 
    Acad::ErrorStatus close()
    {
        if ( !this->m_ptr )
            return Acad::eOk;
 
        if ( this->m_ptr->objectId().isNull() )
            delete this->m_ptr;
        else if ( this->m_status == Acad::eOk )
            this->m_ptr->close();
 
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
        return Acad::eOk;
    }
 
    Param1* operator->()
    {
        return this->m_ptr;
    }
 
    const Param1* operator->() const
    {
        return this->m_ptr;
    }
 
    Param1* object()
    {
        return this->m_ptr;
    }
 
    const Param1* object() const
    {
        return this->m_ptr;
    }
 
    operator const Param1*( ) const
    {
        return this->m_ptr;
    }
 
    operator Param1*( )
    {
        return this->m_ptr;
    }
 
protected:
    Param1* m_ptr;
    Acad::ErrorStatus m_status;
};
 
typedef AcDbObjectPointer<AcDbDictionary> AcDbDictionaryPointer;
typedef AcDbObjectPointer<AcDbEntity> AcDbEntityPointer;
 
template< typename Param1 >
class AcDbSymbolTablePointer : public AcDbObjectPointer<Param1>
{
public:
    AcDbSymbolTablePointer()
    {
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
    }
 
    AcDbSymbolTablePointer( AcDbObjectId param1, AcDb::OpenMode param2, bool param3 = false )
    {
        this->m_ptr = 0;
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2, param3 );
    }
 
    AcDbSymbolTablePointer( AcDbDatabase* param1, AcDb::OpenMode param2, bool param3 = false )
    {
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
        this->m_status = ( param1 == NULL ) ? Acad::eNullObjectPointer : param1->getSymbolTable( this->m_ptr, param2 );
    }
 
    Acad::ErrorStatus open( AcDbObjectId param1, AcDb::OpenMode param2 )
    {
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2, false );
        return this->m_status;
    }
 
    Acad::ErrorStatus open( AcDbDatabase* param1, AcDb::OpenMode param2 )
    {
        Acad::ErrorStatus es = Acad::eOk;
        if ( !param1 )
            return Acad::eInvalidInput;
        if ( this->m_ptr )
            es = this->close();
 
        es = param1->getSymbolTable( this->m_ptr, param2 );
        this->m_status = es;
        return es;
    }
};
typedef AcDbSymbolTablePointer<AcDbTextStyleTable> AcDbTextStyleTablePointer;
typedef AcDbSymbolTablePointer<AcDbLinetypeTable> AcDbLinetypeTablePointer;
typedef AcDbSymbolTablePointer<AcDbLayerTable> AcDbLayerTablePointer;
typedef AcDbSymbolTablePointer<AcDbDimStyleTable> AcDbDimStyleTablePointer;
typedef AcDbSymbolTablePointer<AcDbBlockTable> AcDbBlockTablePointer;
typedef AcDbSymbolTablePointer<AcDbViewTable> AcDbViewTablePointer;
typedef AcDbSymbolTablePointer<AcDbRegAppTable> AcDbRegAppTablePointer;
typedef AcDbSymbolTablePointer<AcDbUCSTable> AcDbUCSTablePointer;
typedef AcDbSymbolTablePointer<AcDbViewportTable> AcDbViewportTablePointer;
 
template<typename Param1>
class AcDbSymbolTableRecordPointer : public AcDbObjectPointer<Param1>
{
public:
 
    AcDbSymbolTableRecordPointer()
    {
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
    }
 
    AcDbSymbolTableRecordPointer( AcDbObjectId param1, AcDb::OpenMode param2, bool param3 = false )
    {
        this->m_ptr = 0;
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2, param3 );
    }
 
    AcDbSymbolTableRecordPointer( const ACHAR* param1, AcDbDatabase* param2, AcDb::OpenMode param3, bool param4 = false )
    {
        this->m_ptr = 0;
        this->m_status = Acad::eNullObjectPointer;
        if ( param1 == NULL )
        {
            this->m_status = Acad::eInvalidInput;
        }
        else
        {
            AcDbSymbolTablePointer<Param1::TableType> pTable( param2, AcDb::kForRead );
            this->m_status = pTable.openStatus();
            if ( this->m_status == Acad::eOk )
                this->m_status = pTable->getAt( param1, this->m_ptr, param3, param4 );
        }
    }
 
    Acad::ErrorStatus open( AcDbObjectId param1, AcDb::OpenMode param2, bool param3 = false )
    {
        this->m_status = acdbOpenObject( this->m_ptr, param1, param2, param3 );
        return this->m_status;
    }
 
    Acad::ErrorStatus open( const ACHAR* param1, AcDbDatabase* param2, AcDb::OpenMode param3, bool param4 = false )
    {
        Acad::ErrorStatus es = Acad::eOk;
        if ( param1 == NULL )
        {
            return Acad::eInvalidInput;
        }
        else
        {
            AcDbSymbolTablePointer<Param1::TableType> pTable( param2, AcDb::kForRead );
            es = pTable.openStatus();
            if ( es == Acad::eOk )
            {
                if ( this->m_ptr != NULL )
                {
                    es = this->close();
                }
 
                if ( es == Acad::eOk )
                {
                    es = pTable->getAt( param1, this->m_ptr, param3, param4 );
                    this->m_status = es;
                }
            }
            return es;
        }
    }
 
private:
 
    typedef typename Param1::TableType T2;
};
 
typedef AcDbSymbolTableRecordPointer<AcDbBlockTableRecord> AcDbBlockTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbTextStyleTableRecord> AcDbTextStyleTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbLinetypeTableRecord>  AcDbLinetypeTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbDimStyleTableRecord> AcDbDimStyleTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbLayerTableRecord> AcDbLayerTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbDimStyleTableRecord> AcDbDimStyleTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbViewportTableRecord> AcDbViewportTableRecordPointer;
typedef AcDbSymbolTableRecordPointer<AcDbViewTableRecord> AcDbViewTableRecordPointer;
 
//class ARX_API AcDbBlockTableRecordPointer
//{ 
//public:
//      AcDbBlockTableRecordPointer( AcDbObjectId, AcDb::OpenMode );
//      AcDbBlockTableRecordPointer( ACHAR const*, AcDbDatabase*, AcDb::OpenMode );
//      Acad::ErrorStatus openStatus();
//      AcDbBlockTableRecord* operator->();
//      void appendAcDbEntity( AcDbEntity* );
//      operator AcDbBlockTableRecord*();
//};
 
class ARX_API AcDbSoftOwnershipId : public AcDbObjectId
{
public:
    AcDbSoftOwnershipId();
    AcDbSoftOwnershipId( const AcDbObjectId& );
 
};
 
class ARX_API AcDbSoftPointerId : public AcDbObjectId
{
public:
    AcDbSoftPointerId();
    AcDbSoftPointerId( const AcDbObjectId& );
 
};
 
class ARX_API AcEdCommandStack : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdCommandStack );
 
    //  virtual void addCommand( const AcString& sGroupName, const AcString& sGlobalName, const AcString& sLocalName, Adesk::Int32 commandFlags, AcRxFunctionPtr pFunction, AcEdUIContext* = NULL, int = 0, HINSTANCE = NULL, void* = NULL );
    virtual Acad::ErrorStatus addCommand( const ACHAR* sGroupName, const ACHAR* sGlobalName, const ACHAR* sLocalName, Adesk::Int32 commandFlags, AcRxFunctionPtr pFunction, AcEdUIContext* = NULL, int = -1, HINSTANCE = NULL, AcEdCommand** = NULL );
    virtual Acad::ErrorStatus removeCmd( const ACHAR* groupName, const ACHAR* globalName );
    //virtual void removeGroup(  const AcString&  );
    virtual Acad::ErrorStatus removeGroup( const ACHAR* );
    AcEdCommandIterator* iterator();
    virtual AcEdCommand* lookupCmd( const ACHAR*, bool );
    virtual AcEdCommand* lookupCmd( const ACHAR*, bool, bool );
    virtual AcEdCommand* lookupCmd( const ACHAR*, bool, bool, bool );
    virtual Acad::ErrorStatus popGroupToTop( const ACHAR* );
    virtual AcEdCommand* lookupGlobalCmd( const ACHAR * );
    virtual AcEdCommand* lookupLocalCmd( const ACHAR * );
};
 
class ARX_API AcEdUIContext : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdUIContext );
    virtual void  onCommand( Adesk::UInt32 );
    virtual void* getMenuContext( const AcRxClass*, const AcDbObjectIdArray& );
    virtual void  OnUpdateMenu();
};
 
class ARX_API AcEditor : public AcRxEvent
{
public:
    ACRX_DECLARE_MEMBERS( AcEditor );
 
    void addReactor( AcEditorReactor* );
    void removeReactor( AcEditorReactor* );
 
};
 
class ARX_API AcEditorReactor : public AcRxEventReactor
{
public:
    ACRX_DECLARE_MEMBERS( AcEditorReactor );
 
    AcEditorReactor();
    virtual ~AcEditorReactor();
 
    virtual void databaseToBeDestroyed( AcDbDatabase* );
    virtual void beginSave( AcDbDatabase*, const ACHAR* );
    virtual void saveComplete( AcDbDatabase*, const ACHAR* );
    virtual void abortSave( AcDbDatabase* );
    virtual void beginDxfIn( AcDbDatabase* );
    virtual void abortDxfIn( AcDbDatabase* );
    virtual void dxfInComplete( AcDbDatabase* );
    virtual void beginDxfOut( AcDbDatabase* );
    virtual void abortDxfOut( AcDbDatabase* );
    virtual void dxfOutComplete( AcDbDatabase* );
    virtual void beginInsert( AcDbDatabase*, const AcString&, AcDbDatabase* );
    virtual void beginInsert( AcDbDatabase*, const AcGeMatrix3d&, AcDbDatabase* );
    virtual void otherInsert( AcDbDatabase*, AcDbIdMapping&, AcDbDatabase* );
    virtual void abortInsert( AcDbDatabase* );
    virtual void endInsert( AcDbDatabase* );
    virtual void wblockNotice( AcDbDatabase* );
    virtual void beginWblock( AcDbDatabase*, AcDbDatabase*, const AcGePoint3d& );
    virtual void beginWblock( AcDbDatabase*, AcDbDatabase*, AcDbObjectId );
    virtual void beginWblock( AcDbDatabase*, AcDbDatabase* );
    virtual void otherWblock( AcDbDatabase*, AcDbIdMapping&, AcDbDatabase* );
    virtual void abortWblock( AcDbDatabase* );
    virtual void endWblock( AcDbDatabase* );
    virtual void beginWblockObjects( AcDbDatabase*, AcDbIdMapping& );
    virtual void beginDeepClone( AcDbDatabase*, AcDbIdMapping& );
    virtual void beginDeepCloneXlation( AcDbIdMapping&, Acad::ErrorStatus* );
    virtual void abortDeepClone( AcDbIdMapping& );
    virtual void endDeepClone( AcDbIdMapping& );
    virtual void partialOpenNotice( AcDbDatabase* );
    virtual void beginAttach( AcDbDatabase*, const AcString&, AcDbDatabase* );
    virtual void otherAttach( AcDbDatabase*, AcDbDatabase* );
    virtual void abortAttach( AcDbDatabase* );
    virtual void endAttach( AcDbDatabase* );
    virtual void redirected( AcDbObjectId, AcDbObjectId );
    virtual void comandeered( AcDbDatabase*, AcDbObjectId, AcDbDatabase* );
    virtual void beginRestore( AcDbDatabase*, const AcString&, AcDbDatabase* );
    virtual void abortRestore( AcDbDatabase* );
    virtual void endRestore( AcDbDatabase* );
    virtual void unknownCommand( const ACHAR*, class AcArray<void *, AcArrayMemCopyReallocator<void * > > * );
    virtual void commandWillStart( const ACHAR* );
    virtual void commandEnded( const ACHAR* );
    virtual void commandCancelled( const ACHAR* );
    virtual void commandFailed( const ACHAR* );
    virtual void lispWillStart( const ACHAR* );
    virtual void lispEnded();
    virtual void lispCancelled();
    virtual void beginDwgOpen( wchar_t const* );
    virtual void endDwgOpen( const wchar_t*, AcDbDatabase* );
    virtual void beginClose( AcDbDatabase* );
    virtual void sysVarChanged( AcDbDatabase*, const AcString& );
    virtual void sysVarChanged( const ACHAR*, Adesk::Boolean );
    virtual void sysVarWillChange( AcDbDatabase*, const AcString& );
    virtual void sysVarWillChange( const ACHAR* );
    virtual void xrefSubcommandBindItem( int, AcDbObjectId );
    virtual void xrefSubcommandAttachItem( int, const AcString& );
    virtual void xrefSubcommandOverlayItem( int, const AcString& );
    virtual void xrefSubcommandDetachItem( int, AcDbObjectId );
    virtual void xrefSubcommandPathItem( int, AcDbObjectId, const AcString& );
    virtual void xrefSubcommandReloadItem( int, AcDbObjectId );
    virtual void xrefSubcommandUnloadItem( int, AcDbObjectId );
    virtual void undoSubcommandAuto( int, bool );
    virtual void undoSubcommandControl( int, int );
    virtual void undoSubcommandBegin( int );
    virtual void undoSubcommandEnd( int );
    virtual void undoSubcommandMark( int );
    virtual void undoSubcommandBack( int );
    virtual void undoSubcommandNumber( int, int );
    virtual void pickfirstModified();
    virtual void layoutSwitched( wchar_t const * );
    virtual void docFrameMovedOrResized( long, bool );
    virtual void mainFrameMovedOrResized( long, bool );
    virtual void beginDoubleClick( const AcGePoint3d& );
    virtual void beginRightClick( const AcGePoint3d& );
    virtual void toolbarBitmapSizeWillChange( bool );
    virtual void toolbarBitmapSizeChanged( bool );
    virtual void objectsLazyLoaded( const AcDbObjectIdArray& );
    virtual void beginQuit();
    virtual void quitAborted();
    virtual void quitWillStart();
    virtual void modelessOperationWillStart( const AcString& );
    virtual void modelessOperationEnded( const AcString& );
    virtual void cmdIUnkModified( const ACHAR* );
    virtual Acad::ErrorStatus xrefSubCommandStart( AcXrefSubCommand, const AcDbObjectIdArray&, const ACHAR*, const ACHAR* );
    virtual void preXrefLockFile( AcDbObjectId );
    virtual void viewChanged( void );
    virtual void dwgFileOpened( AcDbDatabase*, const AcString& );
    virtual void initialDwgFileOpenComplete( AcDbDatabase* );
    virtual void databaseConstructed( AcDbDatabase * );
 
protected:
    Acad::ErrorStatus veto( void );
};
 
class ARX_API AcGsConfig
{
public:
    bool configure( TCHAR*, bool );
};
 
class ARX_API AcGsClassFactory
{
public:
    void deleteView( AcGsView* );
    void deleteModel( AcGsModel* );
    AcGsView* createView();
    AcGsModel* createModel( AcGsModel::RenderType, int, int, int );
    void addReactor( AcGsReactor* );
    void removeReactor( AcGsReactor* );
    AcGsConfig* getConfig();
    AcGsDevice* createOffScreenDevice();
    void deleteDevice( AcGsDevice* );
};
 
class ARX_API AcGsColor
{
public:
    BYTE m_red;
    BYTE m_green;
    BYTE m_blue;
    BYTE m_filler;
};
 
class ARX_API AcGsDCPoint
{
public:
    long x;
    long y;
 
    AcGsDCPoint( void );
    AcGsDCPoint( long, long );
    void operator=( AcGsDCPoint const & );
    bool operator==( AcGsDCPoint const & ) const;
    bool operator!=( AcGsDCPoint const & ) const;
 
};
 
class ARX_API AcGsDCRect
{
public:
    AcGsDCPoint m_min;
    AcGsDCPoint m_max;
 
    AcGsDCRect();
    AcGsDCRect( int, int, int, int );
};
 
class ARX_API AcGsDevice : public AcRxObject
{
public:
 
    enum RendererType
    {
        kDefault,
        kFullRender,
        kSoftware,
        kSoftwareNewViewsOnly,
        kSelectionRender
    };
    virtual bool erase( AcGsView* ) = 0;
    virtual AcGsColor getBackgroundColor() = 0;
    virtual void setBackgroundColor( AcGsColor ) = 0;
    virtual void onSize( int, int ) = 0;
    virtual void add( AcGsView* ) = 0;
    virtual void setLogicalPalette( AcGsColor*, int ) = 0;
    virtual void setDeviceRenderer( AcGsDevice::RendererType ) = 0;
    virtual void update() = 0;
    virtual void eraseAll() = 0;
    virtual int getMaxDeviceWidth() = 0;
    virtual int getMaxDeviceHeight() = 0;
};
 
class AcGsGraphicsKernel;
class AcGsKernelDescriptor;
 
class ARX_API AcGsManager : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcGsManager );
 
    AcGsClassFactory* getGSClassFactory();
    void destroyAutoCADModel( AcGsModel* );
    void destroyAutoCADDevice( AcGsDevice* );
    AcGsDevice* createAutoCADDevice( AcGsGraphicsKernel &, AcGsWindowingSystemID );
    AcGsModel* createAutoCADModel( AcGsGraphicsKernel & );
    //virtual AcGsDevice* getGUIDevice(AcGsGraphicsKernel & kernel);
    virtual AcGsDevice * getGUIDevice();
 
    static AcGsGraphicsKernel* acquireGraphicsKernel( const AcGsKernelDescriptor& );
    static void releaseGraphicsKernel( AcGsGraphicsKernel * pKernel );
};
 
class ARX_API AcHatchPatternLine
{
public:
    bool operator==( const AcHatchPatternLine& ) const;
    bool operator!=( const AcHatchPatternLine& ) const;
};
 
class ARX_API AcHatchPattern : public AcArray< AcHatchPatternLine, AcArrayMemCopyReallocator<AcHatchPatternLine> >
{
};
 
class ARX_API CurveIntxnPoint
{
};
 
template < typename Param1 >
class HT_Smart_Pointer
{
};
 
class ARX_API HT_String
{
};
 
class ARX_API NmBoundBlock
{
};
 
class ARX_API HT_Float_Rectangle
{
};
 
class ARX_API HT_Float_XY
{
};
 
class ARX_API fsmInput
{
};
ARX_API void acrxBuildClassHierarchy( void );
 
//---------------------------------------------------------------------------------------------------------------------
struct _FXARX_COMMAND_ENTRY
{
    const ACHAR* pszGroup;
    const ACHAR* pszGlobCmd;
    const ACHAR* pszLocCmd;
    Adesk::Int32 cmdFlags;
    AcRxFunctionPtr pCmdFct;
    AcEdUIContext* pUIContext;
};
 
struct _FXARXADSSYMBOL_ENTRY
{
    const ACHAR *pszName;
    int( *fptr )( );
    bool bRegFunc;
    UINT nameID;
};
 
 
 
#if defined(_M_IA64) || defined(_M_IX86) || defined (_M_AMD64)
 
#pragma section("FXARX_COMMAND$__a", read)
#pragma section("FXARX_COMMAND$__z", read)
#pragma section("FXARX_COMMAND$__m", read)
 
#pragma section("FXARX_ADSSYMBOLS$__a", read) 
#pragma section("FXARX_ADSSYMBOLS$__z", read)
#pragma section("FXARX_ADSSYMBOLS$__m", read)
 
extern "C"
{
    __declspec( selectany ) __declspec( allocate( "FXARX_COMMAND$__a" ) ) _FXARX_COMMAND_ENTRY* __pFXARXCommandFirst = NULL;
    __declspec( selectany ) __declspec( allocate( "FXARX_COMMAND$__z" ) ) _FXARX_COMMAND_ENTRY* __pFXARXCommandLast = NULL;
 
    __declspec( selectany ) __declspec( allocate( "FXARX_ADSSYMBOLS$__a" ) ) _FXARXADSSYMBOL_ENTRY* __pFXARXADSSymbolsFirst = NULL;
    __declspec( selectany ) __declspec( allocate( "FXARX_ADSSYMBOLS$__z" ) ) _FXARXADSSYMBOL_ENTRY* __pFXARXADSSymbolsLast = NULL;
}
 
#if !defined(_M_IA64)
#pragma comment(linker, "/merge:FXARX_COMMAND=.rdata")
#pragma comment(linker, "/merge:FXARX_ADSSYMBOLS=.rdata")
#endif
 
#else
 
extern "C"
{
    __declspec( selectany ) _FXARX_COMMAND_ENTRY* __pFXARXCommandFirst = NULL;
    __declspec( selectany ) _FXARX_COMMAND_ENTRY* __pFXARXCommandLast = NULL;
 
    __declspec( selectany ) _FXARX_COMMAND_ENTRY* __pFXARXADSSymbolsFirst = NULL;
    __declspec( selectany ) _FXARX_COMMAND_ENTRY* __pFXARXADSSymbolsLast = NULL;
}
#endif  // defined(_M_IA64) || defined(_M_IX86)
 
struct _FXARX_OBJECT_ENTRY
{
    AcRxFunctionPtr pRxInitFct;
    AcRxFunctionPtr pRxUninitFct;
};
 
 
#if defined(_M_IA64) || defined(_M_IX86) || defined (_M_AMD64)
 
#pragma section("FXARX_OBJECT$__a", read)
#pragma section("FXARX_OBJECT$__z", read)
#pragma section("FXARX_OBJECT$__m", read)
 
extern "C"
{
    __declspec( selectany ) __declspec( allocate( "FXARX_OBJECT$__a" ) ) _FXARX_OBJECT_ENTRY* __pFXARXObjectFirst = NULL;
    __declspec( selectany ) __declspec( allocate( "FXARX_OBJECT$__z" ) ) _FXARX_OBJECT_ENTRY* __pFXARXObjectLast = NULL;
}
 
#if !defined(_M_IA64)
#pragma comment(linker, "/merge:FXARX_OBJECT=.rdata")
#endif
 
#else
 
extern "C"
{
    __declspec( selectany ) _FXARX_OBJECT_ENTRY* __pFXARXObjectFirst = NULL;
    __declspec( selectany ) _FXARX_OBJECT_ENTRY* __pFXARXObjectLast = NULL;
}
 
#endif  // defined(_M_IA64) || defined(_M_IX86)
 
#ifndef ACDB_REGISTER_OBJECT_ENTRY_PRAGMA
 
#if defined(_M_IX86)
#define ACDB_REGISTER_OBJECT_ENTRY_PRAGMA( classname ) __pragma( comment( linker, "/include:___pFXARXObject_" #classname ) );
#elif defined(_M_IA64)
#define ACDB_REGISTER_OBJECT_ENTRY_PRAGMA( classname ) __pragma( comment( linker, "/include:__pFXARXObject_" #classname ) );
#elif defined(_M_AMD64)
#define ACDB_REGISTER_OBJECT_ENTRY_PRAGMA( classname ) __pragma( comment( linker, "/include:__pFXARXObject_" #classname ) );
#else
#error Unknown Platform. define ACDB_REGISTER_OBJECT_ENTRY_PRAGMA
#endif
 
#endif  //ACDB_REGISTER_OBJECT_ENTRY_PRAGMA
 
#ifndef ACDB_REGISTER_OBJECT_ENTRY_AUTO
#define ACDB_REGISTER_OBJECT_ENTRY_AUTO( classname ) \
        __declspec(selectany) _FXARX_OBJECT_ENTRY __FXARXObject_##classname = { classname::rxInit, classname::rxUninit }; \
        extern "C" __declspec(allocate("FXARX_OBJECT$__m")) __declspec(selectany) _FXARX_OBJECT_ENTRY* const __pFXARXObject_##classname = &__FXARXObject_##classname;\
        ACDB_REGISTER_OBJECT_ENTRY_PRAGMA( classname )
#endif
 
class AcRxDbxApp;
typedef AcRx::AppRetCode( *acrxEntryPointPtr )( AcRx::AppMsgCode msg, void* data );
extern "C" HINSTANCE moduledllInstance();
extern HINSTANCE _hdllInstance;
 
AcRxDbxApp *acrxGetApp();
 
// acrxEntryPoint() and acrxGetApiVersion() have to be exported from user's arx
#define IMPLEMENT_ARX_ENTRYPOINT(classname)                                                                         \
    HINSTANCE _hdllInstance = NULL ;                                                                                \
    classname g_Application;                                                                                        \
    AcRxDbxApp *acrxGetApp () { return (&g_Application) ; }                                                         \
    extern "C" __declspec(dllexport) AcRx::AppRetCode acrxEntryPoint( AcRx::AppMsgCode msg, void* data )            \
    {                                                                                                               \
        return( g_Application.entryPoint( msg, data ) );                                                            \
    };                                                                                                              \
    extern "C" __declspec(dllexport) int acrxGetApiVersion() { return 1; };                                         \
    IMPLEMENT_FRX_APIVERSION();                                                                                     \
    extern "C" HINSTANCE moduledllInstance() { return CAcExtensionModule::dllInstance(); };
 
#define IMPLEMENT_ARX_ENTRYPOINT_STD(classname) IMPLEMENT_ARX_ENTRYPOINT(classname)
 
 
 
//---------------------------------------------------------------------------------------------------------------------
 
// AXO: should be commented for ARX.17 project
class AcRxDbxApp
{
public:
    AcRxDbxApp() : m_hdllInstance( NULL )
    {
    }
 
    virtual AcRx::AppRetCode entryPoint( AcRx::AppMsgCode event, void* data )
    {
        AcRx::AppRetCode result = AcRx::kRetError;
        switch ( event )
        {
        case AcRx::kInitAppMsg:
            result = On_kInitAppMsg( data );
            break;
        case AcRx::kUnloadAppMsg:
            result = On_kUnloadAppMsg( data );
            break;
        case AcRx::kSaveMsg:
            result = On_kSaveMsg( data );
            break;
        case AcRx::kLoadDwgMsg:
            result = On_kLoadDwgMsg( data );
            break;
        case AcRx::kEndMsg:
            result = On_kEndMsg( data );
            break;
        case AcRx::kQuitMsg:
            result = On_kQuitMsg( data );
            break;
        case AcRx::kDependencyMsg:
            result = On_kDependencyMsg( data );
            break;
        case AcRx::kNoDependencyMsg:
            result = On_kNoDependencyMsg( data );
            break;
        case AcRx::kOleUnloadAppMsg:
            result = On_kOleUnloadAppMsg( data );
            break;
        case AcRx::kPreQuitMsg:
            result = On_kPreQuitMsg( data );
            break;
        case AcRx::kInitDialogMsg:
        case AcRx::kCfgMsg:
        case AcRx::kEndDialogMsg:
            //ASSERT(0);
            result = AcRx::kRetOK;
            break;
        case AcRx::kNullMsg:
        default:
            //ASSERT(0);
            break;
        }
        return( result );
    }
 
    virtual AcRx::AppRetCode On_kInitAppMsg( void *pkt )
    {
        m_hdllInstance = _hdllInstance;
 
        // Initialize classes
        AutoInitializer::instance()._DoInitialize();
 
        RegisterServerComponents();
        _FXARX_OBJECT_ENTRY** ppFXARXObjectFirst = &__pFXARXObjectFirst + 1;
        _FXARX_OBJECT_ENTRY** ppFXARXObjectLast = &__pFXARXObjectLast;
        int count = 0;
        for ( _FXARX_OBJECT_ENTRY** ppEntry = ppFXARXObjectFirst; ppEntry < ppFXARXObjectLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                _FXARX_OBJECT_ENTRY* pEntry = *ppEntry;
                pEntry->pRxInitFct();
                count++;
            }
        }
        if ( count > 0 )
            acrxBuildClassHierarchy();
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kUnloadAppMsg( void *pkt )
    {
        _FXARX_OBJECT_ENTRY** ppFXARXObjectFirst = &__pFXARXObjectFirst + 1;
        _FXARX_OBJECT_ENTRY** ppFXARXObjectLast = &__pFXARXObjectLast;
        for ( _FXARX_OBJECT_ENTRY** ppEntry = ppFXARXObjectFirst; ppEntry < ppFXARXObjectLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                _FXARX_OBJECT_ENTRY* pEntry = *ppEntry;
                pEntry->pRxUninitFct();
            }
        }
 
        // Deinitialize classes
        AutoInitializer::instance()._DoUninitialize();
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kSaveMsg( void *pkt )
    {
        return ( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kLoadDwgMsg( void *pkt )
    {
        return ( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kEndMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kQuitMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kDependencyMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kNoDependencyMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kOleUnloadAppMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kPreQuitMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual void RegisterServerComponents() = 0;
    HINSTANCE &GetModuleInstance()
    {
        return m_hdllInstance;
    }
 
protected:
    HINSTANCE m_hdllInstance;
};
 
class AcRxArxApp : public AcRxDbxApp
{
public:
    AcRx::AppRetCode entryPoint( AcRx::AppMsgCode event, void* data )
    {
        AcRx::AppRetCode result = AcRx::kRetError;
        switch ( event )
        {
        case AcRx::kInitAppMsg:
            result = On_kInitAppMsg( data );
            break;
        case AcRx::kUnloadAppMsg:
            result = On_kUnloadAppMsg( data );
            break;
        case AcRx::kSaveMsg:
            result = On_kSaveMsg( data );
            break;
        case AcRx::kLoadDwgMsg:
            result = On_kLoadDwgMsg( data );
            break;
        case AcRx::kUnloadDwgMsg:
            result = On_kUnloadDwgMsg( data );
            break;
        case AcRx::kInvkSubrMsg:
            result = On_kInvkSubrMsg( data );
            break;
        case AcRx::kEndMsg:
            result = On_kEndMsg( data );
            break;
        case AcRx::kQuitMsg:
            result = On_kQuitMsg( data );
            break;
        case AcRx::kDependencyMsg:
            result = On_kDependencyMsg( data );
            break;
        case AcRx::kNoDependencyMsg:
            result = On_kNoDependencyMsg( data );
            break;
        case AcRx::kOleUnloadAppMsg:
            result = On_kOleUnloadAppMsg( data );
            break;
        case AcRx::kPreQuitMsg:
            result = On_kPreQuitMsg( data );
            break;
        case AcRx::kInitDialogMsg:
            result = On_kInitDialogMsg( data );
            break;
        case AcRx::kCfgMsg:
            result = AcRx::kRetOK;
            break;
        case AcRx::kEndDialogMsg:
            result = On_kEndDialogMsg( data );
            break;
        case AcRx::kNullMsg:
        default:
            //ASSERT(0);
            break;
        }
        return( result );
    }
 
    virtual AcRx::AppRetCode On_kInitAppMsg( void *pkt )
    {
        AcRxDbxApp::On_kInitAppMsg( pkt );
 
#ifdef __ATLCOM_H__
        if( m_pDynPropManager == nullptr )
                    m_pDynPropManager =  new AcRxDynPropManager;
#endif
        _FXARX_COMMAND_ENTRY** ppFXARXCommandFirst = &__pFXARXCommandFirst + 1;
        _FXARX_COMMAND_ENTRY** ppFXARXCommandLast = &__pFXARXCommandLast;
        for ( _FXARX_COMMAND_ENTRY** ppEntry = ppFXARXCommandFirst; ppEntry < ppFXARXCommandLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                _FXARX_COMMAND_ENTRY* pEntry = *ppEntry;
                acedRegCmdsPtr()->addCommand( pEntry->pszGroup, pEntry->pszGlobCmd, pEntry->pszLocCmd, pEntry->cmdFlags, pEntry->pCmdFct, pEntry->pUIContext, 0, moduledllInstance(), NULL );
            }
        }
 
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kUnloadAppMsg( void *pkt )
    {
#ifdef __ATLCOM_H__
        if ( m_pDynPropManager != nullptr )
            delete m_pDynPropManager;
#endif
        _FXARX_COMMAND_ENTRY** ppFXARXCommandFirst = &__pFXARXCommandFirst + 1;
        _FXARX_COMMAND_ENTRY** ppFXARXCommandLast = &__pFXARXCommandLast;
        for ( _FXARX_COMMAND_ENTRY** ppEntry = ppFXARXCommandFirst; ppEntry < ppFXARXCommandLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                _FXARX_COMMAND_ENTRY* pEntry = *ppEntry;
                acedRegCmdsPtr()->removeCmd( pEntry->pszGroup, pEntry->pszGlobCmd );
            }
        }
 
        AcRxDbxApp::On_kUnloadAppMsg( pkt );
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kLoadDwgMsg( void *pkt )
    {
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryFirst = &__pFXARXADSSymbolsFirst + 1;
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryLast = &__pFXARXADSSymbolsLast;
        ACHAR buffer[ 133 ] = { 0 };
        int param = 0;
        for ( _FXARXADSSYMBOL_ENTRY **ppEntry = ppFXARXADSSymbolMapEntryFirst; ppEntry < ppFXARXADSSymbolMapEntryLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                if ( ( *ppEntry )->pszName == NULL )
                    ::LoadString( moduledllInstance(), ( *ppEntry )->nameID, buffer, 132 );
                acedDefun(
                    ( *ppEntry )->pszName == NULL ? buffer : ( *ppEntry )->pszName,
                    param
                );
                if ( ( *ppEntry )->bRegFunc == true )
                    acedRegFunc( ( *ppEntry )->fptr, param );
                param++;
            }
        }
        return ( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kUnloadDwgMsg( void *pkt )
    {
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryFirst = &__pFXARXADSSymbolsFirst + 1;
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryLast = &__pFXARXADSSymbolsLast;
        ACHAR buffer[ 133 ] = { 0 };
        int param = 0;
        for ( _FXARXADSSYMBOL_ENTRY **ppEntry = ppFXARXADSSymbolMapEntryFirst; ppEntry < ppFXARXADSSymbolMapEntryLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                if ( ( *ppEntry )->pszName == NULL )
                    ::LoadString( moduledllInstance(), ( *ppEntry )->nameID, buffer, 132 );
                acedUndef(
                    ( *ppEntry )->pszName == NULL ? buffer : ( *ppEntry )->pszName,
                    param++
                );
            }
        }
        return ( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kInvkSubrMsg( void *pkt )
    {
        int param = acedGetFunCode();
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryFirst = &__pFXARXADSSymbolsFirst + 1;
        _FXARXADSSYMBOL_ENTRY **ppFXARXADSSymbolMapEntryLast = &__pFXARXADSSymbolsLast;
        int paramIter = 0;
        for ( _FXARXADSSYMBOL_ENTRY **ppEntry = ppFXARXADSSymbolMapEntryFirst; ppEntry < ppFXARXADSSymbolMapEntryLast; ppEntry++ )
        {
            if ( *ppEntry != NULL )
            {
                if ( paramIter++ == param )
                {
                    ( *( ( *ppEntry )->fptr ) ) ( );
                    break;
                }
            }
        }
        return ( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kSaveMsg( void *pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kInitDialogMsg( void* pkt )
    {
        return( AcRx::kRetOK );
    }
 
    virtual AcRx::AppRetCode On_kEndDialogMsg( void* pkt )
    {
        return( AcRx::kRetOK );
    }
 
#ifdef __ATLCOM_H__
    AcRxDynPropManager* m_pDynPropManager = 0;
#endif
};
 
 
class ARX_API AcGsReactor : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcGsReactor );
 
    //public:
    //  AcGsReactor();
    //  virtual ~AcGsReactor()
    //  virtual void viewWasCreated( AcGsView * pView );
    //  virtual void viewToBeDestroyed( AcGsView * pView )
    //  virtual void gsToBeUnloaded( AcGsClassFactory * pClassFactory );
};
 
class ARX_API AcGsScreenShot
{
public:
    AcGsScreenShot();
    virtual ~AcGsScreenShot();
    virtual Adesk::Boolean getSize( int &, int &, int & ) const;
    virtual Adesk::Boolean getColorMap( int, Adesk::UInt8 &, Adesk::UInt8 &, Adesk::UInt8 & ) const;
    virtual void const * getScanline( int, int ) const;
};
 
class ARX_API AcEditorReactor2 : public AcEditorReactor
{
public:
    ACRX_DECLARE_MEMBERS( AcEditorReactor2 );
    AcEditorReactor2();
    ~AcEditorReactor2();
    virtual void beginDocClose( AcDbDatabase* );
    virtual void docCloseWillStart( AcDbDatabase* );
    virtual void layoutToBeSwitched( const ACHAR*, const ACHAR* );
    virtual void docCloseAborted( AcDbDatabase* );
 
};
 
class ARX_API AcEdInputContextReactor : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdInputContextReactor );
 
    virtual void beginGetPoint(
        const AcGePoint3d* /*pointIn*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetPoint(
        Acad::PromptStatus /*returnStatus*/,
        const AcGePoint3d& /*pointOut*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetAngle(
        const AcGePoint3d* /*pointIn*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetAngle(
        Acad::PromptStatus /*returnStatus*/,
        double& /*angle*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetDistance(
        const AcGePoint3d* /*pointIn*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetDistance(
        Acad::PromptStatus /*returnStatus*/,
        double& /*distance*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetOrientation(
        const AcGePoint3d* /*pointIn*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetOrientation(
        Acad::PromptStatus /*returnStatus*/,
        double& /*angle*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetCorner(
        const AcGePoint3d* /*firstCorner*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetCorner(
        Acad::PromptStatus /*returnStatus*/,
        AcGePoint3d& /*secondCorner*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetScaleFactor(
        const AcGePoint3d* /*pointIn*/,
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetScaleFactor(
        Acad::PromptStatus /*returnStatus*/,
        double& /*distance*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetString(
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/ )
    {
    }
 
    virtual void endGetString(
        Acad::PromptStatus /*returnStatus*/,
        wchar_t* /*pString*/ )
    {
    }
 
    virtual void beginGetKeyword(
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetKeyword(
        Acad::PromptStatus /*returnStatus*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetInteger(
        const int* /*dfault*/, // NULL implies no default
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetInteger( Acad::PromptStatus /*returnStatus*/,
                                int& /*retValue*/,
                                const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetColor( const int* /*dfault*/, // NULL implies no default
                                const wchar_t* /*promptString*/,
                                int   /*initGetFlags*/,
                                const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetColor(
        Acad::PromptStatus /*returnStatus*/,
        int& /*retValue*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginGetReal(
        const double* /*dfault*/, // NULL implies no default
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endGetReal(
        Acad::PromptStatus /*returnStatus*/,
        double& /*returnValue*/,
        const wchar_t*& /*pKeyword*/ )
    {
    }
 
    virtual void beginEntsel(
        const wchar_t* /*promptString*/,
        int   /*initGetFlags*/,
        const wchar_t* /*pKeywords*/ )
    {
    }
 
    virtual void endEntsel(
        Acad::PromptStatus /*returnStatus*/,
        AcDbObjectId& /*entPicked*/,
        AcGePoint3d& /*pickPoint*/,
        const wchar_t* /*pKeyword*/ )
    {
    }
 
    virtual void beginNentsel(
        const wchar_t*    /*promptString*/,
        Adesk::Boolean /*pickFlag*/,
        int            /*initGetFlags*/,
        const wchar_t*    /*pKeywords*/ )
    {
    }
 
    virtual void endNentsel(
        Acad::PromptStatus /*returnStatus*/,
        AcDbObjectId /*entPicked*/,
        const AcGePoint3d&  /*pickPoint*/,
        const AcGeMatrix3d& /*xform*/,
        const resbuf* /*referenceStack*/,
        const wchar_t*   /*pKeyword*/ )
    {
    }
 
    virtual void beginSSGet(
        const wchar_t*  /*pPrompt*/,
        int          /*initGetFlags*/,
        const wchar_t*  /*pKeywords*/,
        const wchar_t*  /*pSSControls*/, // str in ADS
        const AcArray<AcGePoint3d>& /*points*/,
        const resbuf*               /*entMask*/ )
    {
    }
 
    virtual void endSSGet(
        Acad::PromptStatus /*returnStatus*/,
        const AcDbObjectIdArray& /*ss*/ )
    {
    }
 
    virtual void beginDragSequence(
        const wchar_t*  /*promptString*/ )
    {
    }
    virtual void endDragSequence( Acad::PromptStatus /*returnStatus*/,
                                  AcGePoint3d&  /*pickPoint*/,
                                  AcGeVector3d& /*vec*/ )
    {
    }
 
    virtual void beginQuiescentState() {}
    virtual void endQuiescentState() {}
};
 
class ARX_API AcEdSelectionSetService
{
public:
    virtual ~AcEdSelectionSetService() {}
    virtual Acad::ErrorStatus ssNameX( bool, int, resbuf*& ) = 0;
    virtual Acad::ErrorStatus ssNameSubentityX( bool, int, int, resbuf*& ) = 0;
    virtual Acad::ErrorStatus ssNameSubentities( bool, int, AcDbFullSubentPathArray& ) = 0;
    virtual Acad::ErrorStatus add( resbuf*, const AcDbFullSubentPath* = 0, const AcDbObjectId* = 0 ) = 0;
    virtual Acad::ErrorStatus remove( int index ) = 0;
    virtual Acad::ErrorStatus removeSubentity( int, int ) = 0;
    virtual Acad::ErrorStatus highlight( int, const AcDbFullSubentPath& ) = 0;
    virtual int subSelectionMode() = 0;
    virtual Acad::ErrorStatus getSubSelectionPoints( AcGePoint3dArray& ) = 0;
    virtual Acad::ErrorStatus add( AcArray<resbuf*>& resbuffer, const AcArray<AcDbFullSubentPath*>*, bool ) = 0;
    virtual Acad::ErrorStatus addSubentities( resbuf*, const AcArray<AcDbFullSubentPath>&, bool ) = 0;
    virtual Acad::ErrorStatus remove( const AcArray<int>& set ) = 0;
    virtual Acad::ErrorStatus removeSubentities( int, const AcArray<int>& ) = 0;
};
 
namespace AcEdSSGet
{
    enum AcEdSSGetFlags
    {
        kNormal = 0,
        kPickPoints = 1,
        kDuplicates = 2,
        kNestedEntities = 4,
        kSubEntities = 8,
        kSinglePick = 16,
        kPickfirstSet = 32,
        kPreviousSet = 64,
        kSubSelection = 128,
        kUndo = 256,
        kFailedPickAuto = 512,
        kCommandPreview = 1024,
        kAllViewports = 2048,
        kForBoxPick = 4096,
        kPreSelectionHilite = 8192
    };
 
    enum AcEdSSGetModes
    {
        kUnknown = 0,
        kWin,
        kCross,
        kBox,
        kLast,
        kEntity,
        kAll,
        kFence,
        kCPoly,
        kWPoly,
        kPick,
        kEvery,
        kXten,
        kGroup,
        kPrevious,
        kMultiple,
    };
};
 
class AcEdSSGetFilterImpl;
class ARX_API AcEdSSGetFilter : public AcEdInputContextReactor
{
public:
    ACRX_DECLARE_MEMBERS( AcEdSSGetFilter );
    AcEdSSGetFilter();
    virtual ~AcEdSSGetFilter();
    virtual void ssgetAddFilter( int, AcEdSelectionSetService &, const AcDbObjectIdArray&, const AcDbObjectIdArray& ) {}
    virtual void ssgetRemoveFilter( int, AcEdSelectionSetService &, const AcDbObjectIdArray&, const AcDbObjectIdArray&, AcDbIntArray&, AcDbArrayIntArray & ) {}
    virtual void ssgetAddFailed( int, int, AcEdSelectionSetService &, const AcDbObjectIdArray &, resbuf* ) {}
    virtual void ssgetRemoveFailed( int, int, AcEdSelectionSetService &, const AcDbObjectIdArray&, resbuf *, AcDbIntArray&, AcDbArrayIntArray& ) {}
    virtual void endSSGet( Acad::PromptStatus, int, AcEdSelectionSetService&, const AcDbObjectIdArray& ) {}
    virtual void endEntsel( Acad::PromptStatus, const AcDbObjectId&, const AcGePoint3d&, AcEdSelectionSetService& ) {}
    virtual void endEntsel( Acad::PromptStatus, AcDbObjectId&, AcGePoint3d&, const wchar_t* ) override;
    AcEdSSGetFilterImpl* getImpl() const;
protected:
    AcEdSSGetFilter( AcEdSSGetFilterImpl *impl );
private:
    AcEdSSGetFilterImpl *m_acEdSSGetFilterImpl;
};
 
class AcEdSSGetFilter2Impl;
 
class ARX_API AcEdSSGetFilter2 : public AcEdSSGetFilter
{
public:
    AcEdSSGetFilter2();
    virtual ~AcEdSSGetFilter2() = default;
    virtual void ssgetRolloverFilter( const AcDbFullSubentPath&, AcDbFullSubentPath& ) {}
};
 
class ARX_API AcEdSSGetFilter3 : public AcEdSSGetFilter
{
public:
    AcEdSSGetFilter3();
    virtual ~AcEdSSGetFilter3() = default;
    virtual void ssgetRolloverFilter( const AcDbFullSubentPath& subEntityPath, AcDbFullSubentPathArray &highlightPaths ) {}
};
 
class ARX_API AcEdSSGetFilter4 : public AcEdSSGetFilter
{
public:
    AcEdSSGetFilter4();
    virtual ~AcEdSSGetFilter4() = default;
    virtual void entNEntsel( Acad::PromptStatus, const AcDbObjectId&, const AcGePoint3d&, ads_point, struct resbuf**, AcEdSelectionSetService& ) {}
    virtual void beginSSGetCustomKeywordCallback( const ACHAR* ) {}
    virtual void endSSGetCustomKeywordCallback( const ACHAR* ) {}
};
 
class AcEdInputPointMonitorResultImpl;
 
class ARX_API AcEdInputPointMonitorResult
{
    AcEdInputPointMonitorResult();
    AcEdInputPointMonitorResultImpl* m_impl;
public:
    ~AcEdInputPointMonitorResult();
    void setAdditionalTooltipString( wchar_t const * );
    bool appendToTooltipStr() const;
    const wchar_t* additionalTooltipString() const;
    friend class AcEdInputPointManager_Impl;
};
 
class ARX_API AcEdInputPointMonitor : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdInputPointMonitor );
    virtual Acad::ErrorStatus monitorInputPoint(
        bool&                             appendToTooltipStr,
        wchar_t*&                            additionalTooltipString,
 
        AcGiViewportDraw*                   drawContext,
 
        AcApDocument*                       document,
        bool                                pointComputed,
        int                                 history,
        const AcGePoint3d&                  lastPoint,
        const AcGePoint3d&                  rawPoint,
        const AcGePoint3d&                  grippedPoint,
        const AcGePoint3d&                  cartesianSnappedPoint,
        const AcGePoint3d&                  osnappedPoint,
        AcDb::OsnapMask                     osnapMask,
        const AcArray<AcDbCustomOsnapMode*>& customOsnapModes,
        AcDb::OsnapMask                     osnapOverrides,
        const AcArray<AcDbCustomOsnapMode*>& customOsnapOverrides,
        const AcDbObjectIdArray&        apertureEntities,
        const AcArray< AcDbObjectIdArray, AcArrayObjectCopyReallocator< AcDbObjectIdArray > >&
        nestedApertureEntities,
        const AcArray<Adesk::GsMarker>&                 gsSelectionMark,
        const AcDbObjectIdArray&        keyPointEntities,
        const AcArray< AcDbObjectIdArray, AcArrayObjectCopyReallocator< AcDbObjectIdArray > >&
        nestedKeyPointEntities,
        const AcArray<Adesk::GsMarker>&                 keyPointGsSelectionMark,
        const AcArray<AcGeCurve3d*>&        alignmentPaths,
        const AcGePoint3d&                  computedPoint,
        const wchar_t*                         tooltipString );
 
    virtual Acad::ErrorStatus monitorInputPoint( const AcEdInputPoint& /*input*/, AcEdInputPointMonitorResult& /*output*/ );
    virtual bool excludeFromOsnapCalculation( const AcDbObjectIdArray& /*nestedEntity*/, Adesk::GsMarker /*gsSelectionMark*/ );
};
 
class ARX_API AcEdInputPoint : public AcRxObject
{
    AcEdInputPointManager_Impl *manager;
    AcEdInputPoint( AcEdInputPointManager_Impl *manager );
public:
    ACRX_DECLARE_MEMBERS( AcEdInputPoint );
    AcGiViewportDraw* drawContext() const;
    AcGePoint3d const & computedPoint( void )const;
    bool pointComputed( void )const;
    AcArray<Adesk::GsMarker, AcArrayMemCopyReallocator<Adesk::GsMarker> > const & gsSelectionMark( void )const;
    AcDbObjectIdArray const & pickedEntities( void )const;
    int history( void )const;
    AcDb::OsnapMask const osnapMask( void )const;
    AcDb::OsnapMask const osnapOverrides( void )const;
    wchar_t const * tooltipString( void )const;
    AcGePoint3d const & rawPoint( void )const;
    AcDbObjectIdArray const & keyPointEntities( void )const;
    AcArray<AcDbCustomOsnapMode *, AcArrayMemCopyReallocator< AcDbCustomOsnapMode *> > const & customOsnapModes( void )const;
    AcGePoint3d const & lastPoint( void )const;
    AcGePoint3d const & osnappedPoint( void )const;
    AcArray< AcArray< AcDbObjectId, AcArrayMemCopyReallocator< AcDbObjectId> >, AcArrayObjectCopyReallocator< AcArray< AcDbObjectId, AcArrayMemCopyReallocator< AcDbObjectId> > > > const & nestedPickedEntities( void )const;
    AcGePoint3d const & grippedPoint( void )const;
    AcArray<Adesk::GsMarker, AcArrayMemCopyReallocator<Adesk::GsMarker> > const & keyPointGsSelectionMark( void )const;
    AcApDocument* document() const;
    const AcGePoint3d& cartesianSnappedPoint() const;
    const AcArray<AcDbCustomOsnapMode*>& customOsnapOverrides() const;
    const AcArray< AcDbObjectIdArray, AcArrayObjectCopyReallocator< AcDbObjectIdArray > >& nestedKeyPointEntities() const;
    const AcArray<AcGeCurve3d*>& alignmentPaths() const;
 
    friend class AcEdInputPointManager_Impl;
};
 
class AcEdInputPointFilterResultImpl;
class ARX_API AcEdInputPointFilterResult : public AcRxObject
{
    AcEdInputPointFilterResult();
    AcEdInputPointFilterResultImpl* m_impl;
public:
    ACRX_DECLARE_MEMBERS( AcEdInputPointFilterResult );
    ~AcEdInputPointFilterResult();
 
    void setRetry( bool );
    void setNewPoint( class AcGePoint3d const & );
    void setNewTooltipString( wchar_t const * );
    void setDisplayOsnapGlyph( bool );
    const AcGePoint3d& newPoint() const;
    bool displayOsnapGlyph() const;
    const wchar_t* newTooltipString() const;
    bool retry() const;
 
    friend class AcEdInputPointManager_Impl;
};
 
class ARX_API AcEdInputPointFilter : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdInputPointFilter );
    virtual Acad::ErrorStatus processInputPoint(
        const AcEdInputPoint&,
        AcEdInputPointFilterResult& );
    virtual Acad::ErrorStatus processInputPoint(
        bool&,
        AcGePoint3d&,
        bool&,
        bool&,
        wchar_t*&,
        bool&,
        AcGiViewportDraw*,
        AcApDocument*,
        bool,
        int,
        const AcGePoint3d&,
        const AcGePoint3d&,
        const AcGePoint3d&,
        const AcGePoint3d&,
        const AcGePoint3d&,
        AcDb::OsnapMask,
        const AcArray<AcDbCustomOsnapMode*>&,
        AcDb::OsnapMask,
        const AcArray<AcDbCustomOsnapMode*>&,
        const AcDbObjectIdArray&,
        const AcArray< AcDbObjectIdArray,
        AcArrayObjectCopyReallocator< AcDbObjectIdArray > >&,
        const AcArray<Adesk::GsMarker>&,
        const AcDbObjectIdArray&,
        const AcArray< AcDbObjectIdArray, AcArrayObjectCopyReallocator< AcDbObjectIdArray > >&,
        const AcArray<Adesk::GsMarker>&,
        const AcArray<AcGeCurve3d*>&,
        const AcGePoint3d&,
        const wchar_t* );
 
    virtual AcEdInputPointFilter* revokeInputFilter( AcEdInputPointFilter* /*revokedFilter*/ );
};
 
 
class AcEdSubSelectFilterImpl;
 
class ARX_API AcEdSubSelectFilter
{
public:
 
    enum SubSelectStatus
    {
        kSubSelectionNone = 0,
        kSubSelectionAugment,
        kSubSelectionExclusive,
        kSubSelectAll
    };
 
    virtual ~AcEdSubSelectFilter();
    virtual Acad::ErrorStatus subSelectClassList( AcArray<AcRxClass*>& );
    virtual bool selectEntity( const AcGePoint3d&, const AcGeVector3d&, const AcGeVector3d&, double, double, Adesk::Int32, const AcGiViewport*, AcDbEntity* ) const;
    virtual AcEdSubSelectFilter::SubSelectStatus subSelectEntity( const AcGePoint3d&, const AcGePoint3d&, const AcGeVector3d&,
                                                                  const AcGeVector3d&, double, double, AcDb::SelectType, bool, bool, bool, const AcGiViewport*, AcDbEntity*, AcDbFullSubentPathArray& );
    virtual AcEdSubSelectFilter::SubSelectStatus subSelectEntity( const resbuf*, bool, bool, bool, const AcGiViewport*, AcDbEntity*, AcDbFullSubentPathArray& );
    virtual bool reSubSelectEntity( AcDbEntity*, AcDbFullSubentPathArray& );
    virtual bool cancelSubSelect( AcDbEntity* );
    virtual bool cancelAllSubSelect();
    virtual bool onKey( Adesk::UInt32, unsigned int, unsigned int, unsigned int );
    virtual bool isSubSelected( AcDbEntity* ) const;
 
private:
    friend class AcEdInputPointManager_Impl;
    AcEdSubSelectFilterImpl* m_pImpl;
};
 
class ARX_API AcEdInputPointManager : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdInputPointManager );
    virtual ~AcEdInputPointManager();
 
    virtual Acad::ErrorStatus registerPointFilter( AcEdInputPointFilter* ) = 0;
    virtual Acad::ErrorStatus revokePointFilter() = 0;
    virtual AcEdInputPointFilter* currentPointFilter() const = 0;
    virtual Acad::ErrorStatus addPointMonitor( AcEdInputPointMonitor* ) = 0;
    virtual Acad::ErrorStatus removePointMonitor( AcEdInputPointMonitor* ) = 0;
    virtual Acad::ErrorStatus addInputContextReactor( AcEdInputContextReactor* ) = 0;
    virtual Acad::ErrorStatus removeInputContextReactor( AcEdInputContextReactor* ) = 0;
    virtual Acad::ErrorStatus disableSystemCursorGraphics() = 0;
    virtual Acad::ErrorStatus enableSystemCursorGraphics() = 0;
    virtual int systemCursorDisableCount() const = 0;
    virtual Acad::ErrorStatus turnOnForcedPick() = 0;
    virtual Acad::ErrorStatus turnOffForcedPick() = 0;
    virtual int forcedPickCount() const = 0;
    virtual int mouseHasMoved() const = 0;
    virtual Acad::ErrorStatus turnOnSubentityWindowSelection() = 0;
    virtual Acad::ErrorStatus turnOffSubentityWindowSelection() = 0;
    virtual void enableMultiSubentPathSelection( bool ) = 0;
    virtual Acad::ErrorStatus addSubSelectFilter( AcEdSubSelectFilter* ) = 0;
    virtual Acad::ErrorStatus removeSubSelectFilter( AcEdSubSelectFilter* ) = 0;
};
 
class ARX_API AcApDocumentIterator : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcApDocumentIterator );
    ~AcApDocumentIterator();
    bool  done( void )const;
    AcApDocument*  document( void );
    void  step( bool = true, bool = true );
};
 
class ARX_API AcLispAppInfo
{
public:
    bool  bUnloadable;
    ACHAR *  appFileName;
};
 
enum AcEdCommandStatusFlags
{
    kCmdStatusNone,
    kCmdStatusCancel,
    kCmdStatusFailed,
};
 
class AcEdCommandEventArgs
{
public:
    const ACHAR* groupName() const;
    AcEdCommandStatusFlags status() const;
    void setStatus( AcEdCommandStatusFlags );
 
protected:
    AcEdCommandEventArgs( const AcEdCommandEventArgs& );
    AcEdCommandEventArgs& operator=( const AcEdCommandEventArgs& );
};
 
class AcEdCommandReactor : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdCommandReactor );
 
    virtual void commandWillStart( AcEdCommand*, AcEdCommandEventArgs* );
    virtual void commandEnded( AcEdCommand*, AcEdCommandEventArgs* );
    virtual void goodbye( AcEdCommand*, AcEdCommandEventArgs* );
};
 
class ARX_API AcEdCommand : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdCommand );
 
    virtual ACHAR const * localName() const = 0;
    virtual ACHAR const * globalName() const = 0;
    virtual Adesk::Int32 commandFlags() const = 0;
    virtual void* commandApp() const = 0;
    virtual int functionCode() const = 0;
    virtual void functionCode( int ) = 0;
    virtual AcRxFunctionPtr functionAddr() const = 0;
    virtual void functionAddr( AcRxFunctionPtr ) = 0;
    virtual AcEdUIContext *UIContext() const = 0;
    virtual void commandUndef( bool ) = 0;
    virtual const AcRxResourceInstance& resourceInstance() const = 0;
 
    void addReactor( AcEdCommandReactor* );
    void removeReactor( AcEdCommandReactor* );
};
 
class ARX_API AcEdCommandIterator : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcEdCommandIterator );
    ~AcEdCommandIterator();
 
    bool  done( void )const;
    AcEdCommand*  document( void );
    void  step( bool = true, bool = true );
    void next();
    ACHAR const * commandGroup()  const;
    AcEdCommand const * command() const;
};
 
class ARX_API AcApLongTransactionManager : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcApLongTransactionManager );
 
    virtual void addReactor( AcApLongTransactionReactor* );
    virtual void removeReactor( AcApLongTransactionReactor* );
    virtual AcDbObjectId currentLongTransactionFor( const AcApDocument* ) const;
    virtual Acad::ErrorStatus abortLongTransaction( AcDbObjectId, bool = false );
 
    virtual Acad::ErrorStatus checkOut( AcDbObjectId&, AcDbObjectIdArray&, AcDbObjectId, AcDbIdMapping&, AcDbObjectId = AcDbObjectId::kNull );
    virtual Acad::ErrorStatus checkIn( AcDbObjectId, AcDbIdMapping&, bool = false );
 
    virtual Acad::ErrorStatus addClassFilter( AcRxClass* );
    virtual bool isFiltered( AcRxClass* ) const;
};
 
class ARX_API AcDbGroupIterator : public AcRxObject
{
public:
    ACRX_DECLARE_MEMBERS( AcDbGroupIterator );
 
    virtual Acad::ErrorStatus getObject( AcDbObject*&, AcDb::OpenMode = AcDb::kForRead );
    virtual AcDbObjectId objectId() const;
    virtual bool done() const;
    virtual bool next();
};
 
class ARX_API AcGsNode
{
    virtual AcGiDrawable *  drawable( void ) const = 0;
    virtual void            setDrawableNull( void ) = 0;
};
 
struct AcEdCommandStruc
{
    AcRxFunctionPtr fcnAddr;
    long            flags;
    void                *app;
    AcEdCommand         *cmd;
};