smileyentity.cpp

autocad 编程 对autocad 开发软件的朋友提供

//
// (C) Copyright 2000 by Autodesk, Inc. 
//
// 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.
//
//

// SmileyEntity.cpp : Implementation of CSmileyEntity

#include "stdafx.h"
#include "SmileyDbCom.h"
#include "SmileyEntity.h"
#include "SmileyCats.h"
#include "axpnt3d.h"
#include "dbproxy.h"
#include "dbxutil.h"
#include "geassign.h"

#define AXEntityDocLock(objId)                              \
    AcAxDocLock docLock(objId, AcAxDocLock::kNormal);       \
    if(docLock.lockStatus() != Acad::eOk)                   \
        throw docLock.lockStatus();
/////////////////////////////////////////////////////////////////////////////
// CSmileyEntity
#define CHECKOUTPARAM(x) if (x==NULL) return E_POINTER;

ACRX_DEFINE_MEMBERS( AsdkSmiley );

STDMETHODIMP CSmileyEntity::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&IID_ISmileyEntity,
        &IID_IAcadObject,
        &IID_IAcadEntity,
        &IID_IOPMPropertyExpander,
        &IID_ICategorizeProperties,
        //&IID_IPerPropertyBrowsing,
        &IID_IOPMPropertyExtension
	};
	for (int i=0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

HRESULT CSmileyEntity::CreateNewObject(AcDbObjectId& objId, AcDbObjectId& ownerId, TCHAR* keyName)
{
    try 
    {
        AXEntityDocLock(ownerId);
        Acad::ErrorStatus es;
        AsdkSmiley *pSmiley = (AsdkSmiley*)AsdkSmiley::desc()->create();
        if ( NULL == pSmiley )
            throw Acad::eOutOfMemory;
        AcDbDatabase* pDb = ownerId.database();
        pSmiley->setDatabaseDefaults(pDb);
        AcDbBlockTableRecordPointer pBlockTableRecord(ownerId, AcDb::kForWrite);
        if((es = pBlockTableRecord.openStatus()) != Acad::eOk)
		{
			delete pSmiley;
            throw es;
		}
        if((es = pBlockTableRecord->appendAcDbEntity(objId, pSmiley)) != Acad::eOk)
		{
			delete pSmiley;
            throw es;
		}
		pSmiley->close();
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to create Smiley through entity interface.",IID_ISmileyEntity,E_FAIL);
    }
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////////////////
//
// CSmileyEntity methods
//
STDMETHODIMP CSmileyEntity::get_Radius(double FAR* d)
{
    CHECKOUTPARAM(d);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        *d = pSmiley->radius();
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_Radius(double d)
{
    try
    {
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setRadius(d);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_Center(VARIANT* pv)
{
	CHECKOUTPARAM(pv);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        AcAxPoint3d pt = pSmiley->center();
        pt.setVariant(pv);
    }
	    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_Center(VARIANT var)
{
    try
    {
        AcAxPoint3d pt = var;
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setCenter(pt);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_Normal(VARIANT* pv)
{
	CHECKOUTPARAM(pv);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        AcAxPoint3d pt = pSmiley->normal();
        pt.setVariant(pv);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_Normal(VARIANT var)
{
    try
    {
        AcAxPoint3d pt = var;
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setNormal( pt.asVector() );
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_EyesSize(double FAR* d)
{
    CHECKOUTPARAM(d);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        *d = pSmiley->eyeSize();
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_EyesSize(double d)
{
    try
    {
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setEyeSize(d);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_EyesHeight(double FAR* d)
{
    CHECKOUTPARAM(d);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        *d = pSmiley->eyesHeight();
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_EyesHeight(double d)
{
    try
    {
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setEyesHeight(d);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_EyesApart(double FAR* d)
{
    CHECKOUTPARAM(d);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        *d = pSmiley->eyesApart();
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::put_EyesApart(double d)
{
    try
    {
        AXEntityDocLock(m_objId);

        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForWrite,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        
        pSmiley->setEyesApart(d);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_MouthCenter(VARIANT* d)
{
	CHECKOUTPARAM(d);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        AcAxPoint3d pt = pSmiley->mouthCenter();
        pt.setVariant(d);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}

STDMETHODIMP CSmileyEntity::get_MouthLeft(VARIANT* pv)
{
	CHECKOUTPARAM(pv);
    try
    {
        Acad::ErrorStatus es;
        AcDbObjectPointer<AsdkSmiley> pSmiley(m_objId,AcDb::kForRead,Adesk::kTrue);
	    if((es=pSmiley.openStatus()) != Acad::eOk)
            throw es;
        AcAxPoint3d pt = pSmiley->mouthLeft();
        pt.setVariant(pv);
    }
    catch(const Acad::ErrorStatus)
    {
        return Error(L"Failed to open object.",IID_ISmileyEntity,E_FAIL);
    }
    catch(const HRESULT hr)
    {
        return Error(L"Invalid argument.",IID_ISmileyEntity,hr);
    }
	return S_OK;
}