大过年的

why1025 · 发表于 2018-2-17 17:29:39

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

本帖最后由 why1025 于 2018-2-17 17:33 编辑

问个问题，拖动实体时如何处理尺寸，谢谢，拖动多个实体，其中一些是尺寸

marting · 发表于 2018-2-17 17:34:41

用 JIG 搜索论坛。

why1025 · 发表于 2018-2-17 21:48:01

本帖最后由 why1025 于 2018-2-17 21:49 编辑

virtual AcDbDimDataPtrArray*

dimData(

const double dimScale);
主要是这个函数，不知道怎么用

dimScale

Input DIMSCALE used to display the dynamic dimension

This function sets the DIMSCALE to be used when the dynamic dimension is displayed. It returns a pointer to an AcDbDimDataPtrArray object that the application maintains. This array contains a set of AcDbDimData object pointers: one for each dynamic dimension. The order of the potential (editable) dimensions in the AcDbDimDataPtrArray determines the order in which potential dimensions become active (focal) when the user presses the TAB key.
The application must override this method in the derived class to support dynamic dimensions. The default implementation in the AcEdJig base class simply returns a null pointer.
The dimScale value is calculated based on the zoom factor in the current viewport. Its purpose is to allow the application to determine the correct placement of the dimension line.
The application can add, delete or modify this setting during a prompting sequence. AutoCAD always displays the current dynamic dimensions.
It is the responsibility of the application to allocate and delete the AcDbDimData objects.
See the System Variables section of the AutoCAD Command Reference for information on DIMSCALE.

Comments?

why1025 · 发表于 2018-2-17 21:52:56

在例子中有个grip，阿恒例子中acrectjig，acrect里面写的代码非常多，理不出头绪，找不出哪段代码是控制尺寸拖动的

why1025 · 发表于 2018-2-17 21:55:08

//
// (C) Copyright 1998-2002 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. ** 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 "acrectjig.h"
#include "geassign.h"
#include "acmain.h"
#include "acrect.h"
#include <math.h>
// AcRectJig class member function implementation.
//
AcRectJig::AcRectJig(AcDbDatabase* pDb, AcRectangle* pRect)
{
mElevation = 0.0;
mNormal.set(0,0,1);
mpDb = pDb;
mpRect = pRect;
mLockWidth = false;
mLockHeight = false;
mKeyword = 0;
mpDimData = NULL;
}
AcRectJig::~AcRectJig()
{
// Delete AcDbDimData if any
//
if (mpDimData) {
for (int i = 0; i < mpDimData->length(); i++) {
AcDbDimData *pData = (*mpDimData);
AppData *pAppData = (AppData*)pData->appData();
if (pAppData)
delete pAppData;
delete pData;
}
delete mpDimData;
}
}
Acad::ErrorStatus
AcRectJig::setPlane()
{
// Acquire current UCS transformation matrix.
// We save the matrix for later use.
//
acdbUcsMatrix(mUcsToWcsMat);
mWcsToUcsMat = mUcsToWcsMat.inverse();
// Get data from user coordinate system.
//
AcGePoint3d orgPt;
AcGeVector3d xAxis, yAxis, zAxis;
mUcsToWcsMat.getCoordSystem(orgPt, xAxis, yAxis, zAxis);
// Get the current elevation w.r.t current UCS, w.r.t the current space.
//
struct resbuf rb;
ads_getvar(/*MSG0*/"CVPORT", &rb);
double elev;
if (rb.resval.rint == 1)
elev = mpDb->pelevation(); // Paper space
else
elev = mpDb->elevation(); // Model space
// Convert elevation from UCS to WCS.
//
orgPt += elev * zAxis;
mElevation = zAxis.dotProduct(orgPt.asVector());
mNormal = zAxis;
mHorizDir = xAxis;
mVertDir = mNormal.crossProduct(mHorizDir);
return Acad::eOk;
}
Acad::ErrorStatus
AcRectJig::acquireDefPoints()
{
setUserInputControls((UserInputControls)
(AcEdJig::kAccept3dCoordinates
| AcEdJig::kGovernedByOrthoMode
| AcEdJig::kNoNegativeResponseAccepted
| AcEdJig::kNullResponseAccepted
| AcEdJig::kNoZeroResponseAccepted));
setPlane();
const char* prompt = "\nSpecify first corner point: ";
setDispPrompt(prompt);
int stat = acquirePoint(mWcsPt1);
return (stat == AcEdJig::kNormal) ? Acad::eOk : Acad::eInvalidInput;
}
void AcRectJig::prepRect()
{
assert(mpRect);
mpRect->setDatabaseDefaults();
mpRect->setNormal(mNormal);
mpRect->setElevation(mElevation);
mpRect->setCenter(mWcsPt1);
mpRect->setHorizDir(mHorizDir);
}
void AcRectJig::dragIt()
{
AcEdJig::DragStatus stat;
const char* prompt = "\nSpecify other corner point: ";
do {
setDispPrompt(prompt);
stat = drag();
//keywordHandler(stat);
} while (stat != AcEdJig::kNormal && stat != AcEdJig::kCancel &&
stat != AcEdJig::kNull);
// Use AcDimJig's append
if (stat == AcEdJig::kNormal) {
append();
} else {
delete mpRect;
}
}
// This function is called by the drag function in order to
// aquire a sample input
//
AcEdJig::DragStatus AcRectJig::sampler()
{
DragStatus stat;
setUserInputControls((UserInputControls)
(AcEdJig::kAccept3dCoordinates
| AcEdJig::kGovernedByOrthoMode
| AcEdJig::kAcceptOtherInputString
| AcEdJig::kNoNegativeResponseAccepted
| AcEdJig::kNullResponseAccepted
| AcEdJig::kNoZeroResponseAccepted));
//const char* keyWord = "Horz Vert All None";
//setKeywordList(keyWord);
AcGePoint3d pnt;
stat = acquirePoint(pnt);
if (stat == kNormal) {
if (pnt == mWcsPt2) {
return AcEdJig::kNoChange;
} else {
mWcsPt2 = pnt;
}
}
return stat;
}
// This function is called to update the entity based on the
// input values
//
Adesk::Boolean AcRectJig::update()
{
AcGeVector3d diaVec = mWcsPt2 - mWcsPt1;
AcGePoint3d cenPt = mWcsPt1 + 0.5 * diaVec;
double width = fabs(diaVec.dotProduct(mHorizDir));
double height = fabs(diaVec.dotProduct(mVertDir));
if (!(mLockWidth || mLockHeight))
mpRect->setCenter(cenPt);
if (!mLockWidth)
mpRect->setWidth(width);
if (!mLockHeight)
mpRect->setHeight(height);
updateDimData();
return Adesk::kTrue;
}
// This function must be implemented to return a pointer to
// the entity being manipulated by the jig.
//
AcDbEntity* AcRectJig::entity() const
{
return mpRect;
}
AcDbDimDataPtrArray*
AcRectJig::dimData(const double dimScale)
{
addDimData(kHorizontalDim | kVerticalDim, dimScale);
switch (mKeyword) {
case AcEdJig::kKW1:
appendDimData(kHorizontalDim);
break;
case AcEdJig::kKW2:
appendDimData(kVerticalDim);
break;
case AcEdJig::kKW3:
appendDimData(kHorizontalDim | kVerticalDim);
break;
}
return mpDimData;
}
AcDbDimDataPtrArray*
AcRectJig::dimData() const
{
//addDimData(kHorizontalDim | kVerticalDim, 1.0);
return mpDimData;
}
bool
AcRectJig::addDimData(int which, double dimScale)
{
if (mpRect == NULL)
return false;
if (mpDimData == NULL) {
mpDimData = new AcDbDimDataPtrArray();
} else {
for (int i = 0; i < mpDimData->length(); i++) {
AcDbDimData *pData = (*mpDimData);
AppData *pAppData = (AppData*)pData->appData();
if (pAppData)
delete pAppData;
delete pData;
}
mpDimData->setLogicalLength(0);
}
double width = mpRect->width();
double height = mpRect->height();
AcGePoint3d cenPt = mpRect->center();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
AcGePoint3d pt1, pt2, pt3, pt4, dimPt1, dimPt2;
double horizRot = 0.0;
//double horizRot = userToLocalAngle(mNormal, mHorizDir);
pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir;
pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir;
if (which & kHorizontalDim) {
AcDbAlignedDimension *pAlnDim1 = new AcDbAlignedDimension();
dimPt1 = cenPt + (0.5 * height + 0.5 * dimScale) * vertDir;
pAlnDim1->setDatabaseDefaults();
pAlnDim1->setNormal(mNormal);
pAlnDim1->setElevation(mElevation);
pAlnDim1->setHorizontalRotation(-horizRot);
pAlnDim1->setXLine1Point(pt1);
pAlnDim1->setXLine2Point(pt2);
pAlnDim1->setDimLinePoint(dimPt1);
pAlnDim1->setDimtad(1);
AcDbDimData *dimData1 = new AcDbDimData(pAlnDim1);
AppData *appData1 = new AppData(1, dimScale);
dimData1->setAppData(appData1);
dimData1->setDimFocal(true);
//dimData1->setDimInvisible(true);
dimData1->setDimEditable(true);
mpDimData->append(dimData1);
}
if (which & kVerticalDim) {
AcDbAlignedDimension *pAlnDim2 = new AcDbAlignedDimension();
dimPt2 = cenPt + (0.5 * width + 0.5 * dimScale) * mHorizDir;
pAlnDim2->setDatabaseDefaults();
pAlnDim2->setNormal(mNormal);
pAlnDim2->setElevation(mElevation);
pAlnDim2->setHorizontalRotation(-horizRot);
pAlnDim2->setXLine1Point(pt1);
pAlnDim2->setXLine2Point(pt4);
pAlnDim2->setDimLinePoint(dimPt2);
pAlnDim2->setDimtad(1);
AcDbDimData *dimData2 = new AcDbDimData(pAlnDim2);
AppData *appData2 = new AppData(2, dimScale);
dimData2->setAppData(appData2);
//dimData2->setDimFocal(true);
dimData2->setDimEditable(false);
dimData2->setDimHideIfValueIsZero(true);
//dimData2->setDimInvisible(true);
mpDimData->append(dimData2);
}
return true;
}
bool
AcRectJig::updateDimData()
{
if (!mpRect || !mpDimData || (mpDimData->length() <= 0))
return false;
double width = mpRect->width();
double height = mpRect->height();
AcGePoint3d cenPt = mpRect->center();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
int dimIndex1 = 0, dimIndex2 = 0;
AcGePoint3d pt1, pt2, pt3, pt4, dimPt;
pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir;
pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir;
for (int i = 0; i < mpDimData->length(); i++) {
AcDbDimData *pData = (*mpDimData);
AppData *pDimAppData = (AppData*)pData->appData();
int dimIndex = pDimAppData ? pDimAppData->index() : 0;
double dimScale = pDimAppData->dimScale();
AcDbDimension *pDim = (AcDbDimension*)pData->dimension();
if (pDim->isKindOf(AcDbAlignedDimension::desc())) {
AcDbAlignedDimension *pAlnDim = AcDbAlignedDimension::cast(pDim);
switch (dimIndex) {
case 1:
dimPt = cenPt + (0.5 * height + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt2);
pAlnDim->setDimLinePoint(dimPt);
break;
case 2:
dimPt = cenPt + (0.5 * width + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
break;
}
}
}
return true;
}
Acad::ErrorStatus
AcRectJig::setDimValue(const AcDbDimData* dimData,
const double dimValue)
{
if (dimData == NULL)
return Acad::eInvalidInput;
AppData *pDimAppData = (AppData*)dimData->appData();
int dimIndex = pDimAppData ? pDimAppData->index() : 0;
switch (dimIndex) {
case 1:
mpRect->setWidth(dimValue);
mLockWidth = true;
break;
case 2:
mpRect->setHeight(dimValue);
mLockHeight = true;
break;
}
return Acad::eOk;
mpRect->setWidth(dimValue);
return Acad::eOk;
}
void
AcRectJig::keywordHandler(AcEdJig::DragStatus& kword)
{
switch (kword) {
case AcEdJig::kKW1:
mKeyword = kHorizontalDim;
break;
case AcEdJig::kKW2:
mKeyword = kVerticalDim;
break;
case AcEdJig::kKW3:
mKeyword = kHorizontalDim | kVerticalDim;
break;
case AcEdJig::kKW4:
mKeyword = kNone;
break;
}
}
bool
AcRectJig::appendDimData(int which, double dimScale)
{
if (mpRect == NULL)
return false;
if (mpDimData == NULL) {
mpDimData = new AcDbDimDataPtrArray();
}
double width = mpRect->width();
double height = mpRect->height();
AcGePoint3d cenPt = mpRect->center();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
AcGePoint3d pt1, pt2, pt3, pt4, dimPt1, dimPt2;
double horizRot = 0.0;
//double horizRot = userToLocalAngle(mNormal, mHorizDir);
pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir;
pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir;
if (which & kHorizontalDim) {
AcDbAlignedDimension *pAlnDim1 = new AcDbAlignedDimension();
dimPt1 = cenPt - (0.5 * height + 0.5 * dimScale) * vertDir;
pAlnDim1->setDatabaseDefaults();
pAlnDim1->setNormal(mNormal);
pAlnDim1->setElevation(mElevation);
pAlnDim1->setHorizontalRotation(-horizRot);
pAlnDim1->setXLine1Point(pt3);
pAlnDim1->setXLine2Point(pt4);
pAlnDim1->setDimLinePoint(dimPt1);
pAlnDim1->setDimtad(1);
AcDbDimData *dimData1 = new AcDbDimData(pAlnDim1);
AppData *appData1 = new AppData(3, dimScale);
dimData1->setAppData(appData1);
//dimData1->setDimFocal(true);
//dimData1->setDimInvisible(true);
dimData1->setDimEditable(true);
mpDimData->append(dimData1);
}
if (which & kVerticalDim) {
AcDbAlignedDimension *pAlnDim2 = new AcDbAlignedDimension();
dimPt2 = cenPt - (0.5 * width + 0.5 * dimScale) * mHorizDir;
pAlnDim2->setDatabaseDefaults();
pAlnDim2->setNormal(mNormal);
pAlnDim2->setElevation(mElevation);
pAlnDim2->setHorizontalRotation(-horizRot);
pAlnDim2->setXLine1Point(pt2);
pAlnDim2->setXLine2Point(pt3);
pAlnDim2->setDimLinePoint(dimPt2);
pAlnDim2->setDimtad(1);
AcDbDimData *dimData2 = new AcDbDimData(pAlnDim2);
AppData *appData2 = new AppData(4, dimScale);
dimData2->setAppData(appData2);
//dimData2->setDimFocal(true);
dimData2->setDimEditable(true);
//dimData2->setDimInvisible(true);
mpDimData->append(dimData2);
}
return true;
}

// 
// (C) Copyright 1998-2002 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. ** 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 "acrectjig.h" 
#include "geassign.h" 
#include "acmain.h" 
#include "acrect.h" 
#include <math.h> 
 
// AcRectJig class member function implementation. 
// 
 
AcRectJig::AcRectJig(AcDbDatabase* pDb, AcRectangle* pRect) 
{ 
    mElevation = 0.0; 
    mNormal.set(0,0,1); 
    mpDb = pDb; 
    mpRect = pRect; 
    mLockWidth = false; 
    mLockHeight = false; 
    mKeyword = 0; 
    mpDimData = NULL; 
} 
 
AcRectJig::~AcRectJig() 
{ 
    // Delete AcDbDimData if any 
    // 
    if (mpDimData) { 
        for (int i = 0; i < mpDimData->length(); i++) { 
            AcDbDimData *pData = (*mpDimData); 
            AppData *pAppData = (AppData*)pData->appData(); 
            if (pAppData) 
                delete pAppData; 
            delete pData; 
                } 
 
            delete mpDimData; 
    } 
} 
 
Acad::ErrorStatus 
AcRectJig::setPlane() 
{ 
    // Acquire current UCS transformation matrix. 
    // We save the matrix for later use. 
    // 
    acdbUcsMatrix(mUcsToWcsMat); 
    mWcsToUcsMat = mUcsToWcsMat.inverse(); 
 
    // Get data from user coordinate system. 
    // 
    AcGePoint3d orgPt; 
    AcGeVector3d xAxis, yAxis, zAxis; 
    mUcsToWcsMat.getCoordSystem(orgPt, xAxis, yAxis, zAxis); 
 
    // Get the current elevation w.r.t current UCS, w.r.t the current space. 
    // 
    struct resbuf rb; 
    ads_getvar(/*MSG0*/"CVPORT", &rb); 
    double elev; 
    if (rb.resval.rint == 1) 
        elev = mpDb->pelevation();  // Paper space 
    else 
        elev = mpDb->elevation();   // Model space 
 
    // Convert elevation from UCS to WCS. 
    // 
    orgPt += elev * zAxis; 
    mElevation = zAxis.dotProduct(orgPt.asVector()); 
    mNormal = zAxis; 
    mHorizDir = xAxis; 
    mVertDir = mNormal.crossProduct(mHorizDir); 
    return Acad::eOk; 
} 
 
Acad::ErrorStatus 
AcRectJig::acquireDefPoints() 
{ 
    setUserInputControls((UserInputControls) 
        (AcEdJig::kAccept3dCoordinates 
         | AcEdJig::kGovernedByOrthoMode 
         | AcEdJig::kNoNegativeResponseAccepted 
         | AcEdJig::kNullResponseAccepted 
         | AcEdJig::kNoZeroResponseAccepted)); 
 
    setPlane(); 
    const char* prompt = "\nSpecify first corner point: "; 
    setDispPrompt(prompt); 
 
    int stat = acquirePoint(mWcsPt1); 
    return (stat == AcEdJig::kNormal) ? Acad::eOk : Acad::eInvalidInput; 
} 
 
void AcRectJig::prepRect() 
{ 
    assert(mpRect); 
    mpRect->setDatabaseDefaults(); 
    mpRect->setNormal(mNormal); 
    mpRect->setElevation(mElevation); 
    mpRect->setCenter(mWcsPt1); 
    mpRect->setHorizDir(mHorizDir); 
} 
 
 
void AcRectJig::dragIt() 
{ 
    AcEdJig::DragStatus stat; 
    const char* prompt = "\nSpecify other corner point: "; 
 
    do { 
        setDispPrompt(prompt); 
        stat = drag(); 
        //keywordHandler(stat); 
 
    } while (stat != AcEdJig::kNormal && stat != AcEdJig::kCancel && 
             stat != AcEdJig::kNull); 
 
    // Use AcDimJig's append 
    if (stat == AcEdJig::kNormal) { 
        append(); 
 
    } else { 
        delete mpRect; 
    } 
} 
 
// This function is called by the drag function in order to 
// aquire a sample input 
// 
AcEdJig::DragStatus AcRectJig::sampler() 
{ 
    DragStatus stat; 
 
    setUserInputControls((UserInputControls) 
        (AcEdJig::kAccept3dCoordinates 
         | AcEdJig::kGovernedByOrthoMode 
         | AcEdJig::kAcceptOtherInputString   
         | AcEdJig::kNoNegativeResponseAccepted 
         | AcEdJig::kNullResponseAccepted 
         | AcEdJig::kNoZeroResponseAccepted)); 
 
    //const char* keyWord = "Horz Vert All None"; 
    //setKeywordList(keyWord); 
 
    AcGePoint3d pnt; 
    stat = acquirePoint(pnt); 
    if (stat == kNormal) { 
        if (pnt == mWcsPt2)   { 
            return AcEdJig::kNoChange; 
        } else { 
            mWcsPt2 = pnt; 
        } 
    } 
 
    return stat; 
} 
 
// This function is called to update the entity based on the 
// input values 
// 
Adesk::Boolean AcRectJig::update() 
{ 
    AcGeVector3d diaVec = mWcsPt2 - mWcsPt1; 
    AcGePoint3d cenPt = mWcsPt1 + 0.5 * diaVec; 
    double width = fabs(diaVec.dotProduct(mHorizDir)); 
    double height = fabs(diaVec.dotProduct(mVertDir)); 
 
    if (!(mLockWidth || mLockHeight)) 
        mpRect->setCenter(cenPt); 
 
    if (!mLockWidth) 
        mpRect->setWidth(width); 
 
    if (!mLockHeight) 
        mpRect->setHeight(height); 
 
    updateDimData(); 
 
    return Adesk::kTrue; 
} 
 
// This function must be implemented to return a pointer to 
// the entity being manipulated by the jig. 
// 
AcDbEntity* AcRectJig::entity() const 
{ 
    return mpRect; 
} 
 
AcDbDimDataPtrArray* 
AcRectJig::dimData(const double dimScale) 
{ 
    addDimData(kHorizontalDim | kVerticalDim, dimScale); 
 
    switch (mKeyword) { 
    case AcEdJig::kKW1: 
        appendDimData(kHorizontalDim); 
        break; 
 
    case AcEdJig::kKW2: 
        appendDimData(kVerticalDim); 
        break; 
 
    case AcEdJig::kKW3: 
        appendDimData(kHorizontalDim | kVerticalDim); 
        break; 
    } 
 
 
    return mpDimData; 
} 
 
AcDbDimDataPtrArray* 
AcRectJig::dimData() const 
{ 
    //addDimData(kHorizontalDim | kVerticalDim, 1.0); 
    return mpDimData; 
} 
 
bool 
AcRectJig::addDimData(int which, double dimScale) 
{ 
    if (mpRect == NULL) 
        return false; 
 
    if (mpDimData == NULL) { 
        mpDimData = new AcDbDimDataPtrArray(); 
    } else { 
        for (int i = 0; i < mpDimData->length(); i++) { 
            AcDbDimData *pData = (*mpDimData); 
            AppData *pAppData = (AppData*)pData->appData(); 
            if (pAppData) 
                delete pAppData; 
            delete pData; 
                } 
         
            mpDimData->setLogicalLength(0); 
    } 
 
    double width = mpRect->width(); 
    double height = mpRect->height(); 
    AcGePoint3d cenPt = mpRect->center(); 
 
    AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir); 
    AcGePoint3d pt1, pt2, pt3, pt4, dimPt1, dimPt2; 
    double horizRot = 0.0; 
    //double horizRot = userToLocalAngle(mNormal, mHorizDir); 
 
    pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
    pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
 
    if (which & kHorizontalDim) { 
        AcDbAlignedDimension *pAlnDim1 = new AcDbAlignedDimension(); 
        dimPt1 = cenPt + (0.5 * height + 0.5 * dimScale) * vertDir; 
        pAlnDim1->setDatabaseDefaults(); 
        pAlnDim1->setNormal(mNormal); 
        pAlnDim1->setElevation(mElevation); 
        pAlnDim1->setHorizontalRotation(-horizRot); 
        pAlnDim1->setXLine1Point(pt1); 
        pAlnDim1->setXLine2Point(pt2); 
        pAlnDim1->setDimLinePoint(dimPt1); 
        pAlnDim1->setDimtad(1); 
 
        AcDbDimData *dimData1 = new AcDbDimData(pAlnDim1); 
        AppData *appData1 = new AppData(1, dimScale); 
        dimData1->setAppData(appData1); 
        dimData1->setDimFocal(true); 
        //dimData1->setDimInvisible(true); 
        dimData1->setDimEditable(true); 
        mpDimData->append(dimData1); 
    } 
 
    if (which & kVerticalDim) { 
        AcDbAlignedDimension *pAlnDim2 = new AcDbAlignedDimension(); 
        dimPt2 = cenPt + (0.5 * width + 0.5 * dimScale) * mHorizDir; 
        pAlnDim2->setDatabaseDefaults(); 
        pAlnDim2->setNormal(mNormal); 
        pAlnDim2->setElevation(mElevation); 
        pAlnDim2->setHorizontalRotation(-horizRot); 
        pAlnDim2->setXLine1Point(pt1); 
        pAlnDim2->setXLine2Point(pt4); 
        pAlnDim2->setDimLinePoint(dimPt2); 
        pAlnDim2->setDimtad(1); 
        AcDbDimData *dimData2 = new AcDbDimData(pAlnDim2); 
        AppData *appData2 = new AppData(2, dimScale); 
        dimData2->setAppData(appData2); 
        //dimData2->setDimFocal(true); 
        dimData2->setDimEditable(false); 
                dimData2->setDimHideIfValueIsZero(true); 
        //dimData2->setDimInvisible(true); 
        mpDimData->append(dimData2); 
    } 
 
    return true; 
} 
 
bool 
AcRectJig::updateDimData() 
{ 
    if (!mpRect || !mpDimData || (mpDimData->length() <= 0)) 
        return false; 
 
    double width = mpRect->width(); 
    double height = mpRect->height(); 
    AcGePoint3d cenPt = mpRect->center(); 
    AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir); 
    int dimIndex1 = 0, dimIndex2 = 0; 
    AcGePoint3d pt1, pt2, pt3, pt4, dimPt; 
    pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
    pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
 
    for (int i = 0; i < mpDimData->length(); i++) { 
         AcDbDimData *pData = (*mpDimData); 
         AppData *pDimAppData = (AppData*)pData->appData();          
         int dimIndex = pDimAppData ? pDimAppData->index() : 0; 
         double dimScale = pDimAppData->dimScale(); 
         AcDbDimension *pDim = (AcDbDimension*)pData->dimension(); 
 
         if (pDim->isKindOf(AcDbAlignedDimension::desc())) { 
             AcDbAlignedDimension *pAlnDim = AcDbAlignedDimension::cast(pDim); 
             switch (dimIndex) { 
             case 1: 
                 dimPt = cenPt + (0.5 * height + 0.5 * dimScale) * vertDir; 
                 pAlnDim->setXLine1Point(pt1); 
                 pAlnDim->setXLine2Point(pt2); 
                 pAlnDim->setDimLinePoint(dimPt); 
                 break; 
 
             case 2: 
                 dimPt = cenPt + (0.5 * width + 0.5 * dimScale) * mHorizDir; 
                 pAlnDim->setXLine1Point(pt1); 
                 pAlnDim->setXLine2Point(pt4); 
                 pAlnDim->setDimLinePoint(dimPt); 
                 break; 
             } 
         } 
        } 
 
    return true; 
} 
 
Acad::ErrorStatus 
AcRectJig::setDimValue(const AcDbDimData* dimData, 
                       const double dimValue) 
{ 
    if (dimData == NULL) 
        return Acad::eInvalidInput; 
 
    AppData *pDimAppData = (AppData*)dimData->appData(); 
    int dimIndex = pDimAppData ? pDimAppData->index() : 0; 
 
    switch (dimIndex) { 
    case 1: 
        mpRect->setWidth(dimValue); 
        mLockWidth = true; 
        break; 
 
    case 2: 
        mpRect->setHeight(dimValue); 
        mLockHeight = true; 
        break; 
        } 
 
    return Acad::eOk; 
    mpRect->setWidth(dimValue); 
    return Acad::eOk; 
} 
 
void 
AcRectJig::keywordHandler(AcEdJig::DragStatus& kword) 
{ 
    switch (kword) { 
    case AcEdJig::kKW1: 
        mKeyword = kHorizontalDim; 
        break; 
 
    case AcEdJig::kKW2: 
        mKeyword = kVerticalDim; 
        break; 
 
    case AcEdJig::kKW3: 
        mKeyword = kHorizontalDim | kVerticalDim; 
        break; 
 
    case AcEdJig::kKW4: 
                mKeyword = kNone; 
        break; 
    } 
} 
 
bool 
AcRectJig::appendDimData(int which, double dimScale) 
{ 
    if (mpRect == NULL) 
        return false; 
 
    if (mpDimData == NULL) { 
        mpDimData = new AcDbDimDataPtrArray(); 
    } 
        
    double width = mpRect->width(); 
    double height = mpRect->height(); 
    AcGePoint3d cenPt = mpRect->center(); 
 
    AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir); 
    AcGePoint3d pt1, pt2, pt3, pt4, dimPt1, dimPt2; 
    double horizRot = 0.0; 
    //double horizRot = userToLocalAngle(mNormal, mHorizDir); 
 
    pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir; 
    pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
    pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir; 
 
    if (which & kHorizontalDim) { 
        AcDbAlignedDimension *pAlnDim1 = new AcDbAlignedDimension(); 
        dimPt1 = cenPt - (0.5 * height + 0.5 * dimScale) * vertDir; 
        pAlnDim1->setDatabaseDefaults(); 
        pAlnDim1->setNormal(mNormal); 
        pAlnDim1->setElevation(mElevation); 
        pAlnDim1->setHorizontalRotation(-horizRot); 
        pAlnDim1->setXLine1Point(pt3); 
        pAlnDim1->setXLine2Point(pt4); 
        pAlnDim1->setDimLinePoint(dimPt1); 
        pAlnDim1->setDimtad(1); 
 
        AcDbDimData *dimData1 = new AcDbDimData(pAlnDim1); 
        AppData *appData1 = new AppData(3, dimScale); 
        dimData1->setAppData(appData1); 
        //dimData1->setDimFocal(true); 
        //dimData1->setDimInvisible(true); 
        dimData1->setDimEditable(true); 
        mpDimData->append(dimData1); 
    } 
 
    if (which & kVerticalDim) { 
        AcDbAlignedDimension *pAlnDim2 = new AcDbAlignedDimension(); 
        dimPt2 = cenPt - (0.5 * width + 0.5 * dimScale) * mHorizDir; 
        pAlnDim2->setDatabaseDefaults(); 
        pAlnDim2->setNormal(mNormal); 
        pAlnDim2->setElevation(mElevation); 
        pAlnDim2->setHorizontalRotation(-horizRot); 
        pAlnDim2->setXLine1Point(pt2); 
        pAlnDim2->setXLine2Point(pt3); 
        pAlnDim2->setDimLinePoint(dimPt2); 
        pAlnDim2->setDimtad(1); 
        AcDbDimData *dimData2 = new AcDbDimData(pAlnDim2); 
        AppData *appData2 = new AppData(4, dimScale); 
        dimData2->setAppData(appData2); 
        //dimData2->setDimFocal(true); 
        dimData2->setDimEditable(true); 
        //dimData2->setDimInvisible(true); 
        mpDimData->append(dimData2); 
    } 
 
    return true; 
}

这是acrectjig

LoveArx · 发表于 2018-2-18 12:10:44

why1025 发表于 2018-2-17 21:55

你贴的这个例子，已经很完整的处理DIM的拖动了，编译运行，调试它，适当修改修改，看看变化，加深理解。你只有需要拖动过程中修改DIM的特有的属性才会用到，否则用拖动实体的，处理一般的情况。比如改位置，旋转移动什么的。

why1025 · 发表于 2018-2-18 19:23:15

还有个问题，这段代码在cad2004里面能看出尺寸拖动的效果，到2006里面就没尺寸了，不知道怎么回事

marting · 发表于 2018-2-18 21:09:26

why1025 发表于 2018-2-18 19:23

既然是ADESK的例子，那你就去看看2006 ARX目录下面的同名的文件是怎么写的，哪里有变化了。

why1025 · 发表于 2018-2-18 22:14:32

各位大师，有没有联系的qq或者邮箱，这个论坛太麻烦了，

marting · 发表于 2018-2-18 23:00:10

why1025 发表于 2018-2-18 22:14

多用搜索，多看以前的帖子，这是QQ比不了的。

why1025 · 发表于 2018-2-18 23:42:08

这是我写的一个类

//
// 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. ** 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 "StdAfx.h"
#include "ArcTestJig.h"
//-----------------------------------------------------------------------------
CArcTestJig::CArcTestJig () : AcEdJig ()
//,
//mCurrentInputLevel(0), mpEntity(NULL)
,m_Stage(center), m_pDimData(NULL), __PI(atan (1.)*4)
{
m_pArc = new AcDbArc(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis, 100., 0., __PI/2);
}
CArcTestJig::~CArcTestJig () {
if(m_pDimData == NULL)
return;
for(int ii = 0; ii < m_pDimData->length(); ii++)
delete m_pDimData->at(ii);
delete m_pDimData;
m_pDimData = NULL;
}
//-----------------------------------------------------------------------------
AcEdJig::DragStatus CArcTestJig::startJig ( /**pEntity*/) {
//- Store the new entity pointer
//mpEntity =pEntity ;
//- Setup each input prompt
////////////////////AcString inputPrompts [1] ={
//////////////////// "\nPick point"
////////////////////} ;
//////////////////////- Setup kwords for each input
////////////////////AcString kwords [1] ={
//////////////////// ""
////////////////////} ;
////////////////////bool appendOk =true ;
////////////////////AcEdJig::DragStatus status =AcEdJig::kNull ;
//////////////////////- Loop the number of inputs
////////////////////for ( mCurrentInputLevel =0 ; mCurrentInputLevel < 1 ; mCurrentInputLevel++ ) {
//////////////////// //- Add a new input point to the list of input points
//////////////////// mInputPoints.append (AcGePoint3d ()) ;
//////////////////// //- Set the input prompt
//////////////////// setDispPrompt (inputPrompts [mCurrentInputLevel]) ;
//////////////////// //- Setup the keywords required
//////////////////// setKeywordList (kwords [mCurrentInputLevel]) ;
//////////////////// bool quit =false ;
//////////////////// //- Lets now do the input
//////////////////// status =drag () ;
//////////////////// if ( status != kNormal ) {
//////////////////// //- If it's a keyword
//////////////////// switch ( status ) {
//////////////////// case kCancel:
//////////////////// case kNull:
//////////////////// quit =true ;
//////////////////// break ;
//////////////////// case kKW1:
//////////////////// case kKW2:
//////////////////// case kKW3:
//////////////////// case kKW4:
//////////////////// case kKW5:
//////////////////// case kKW6:
//////////////////// case kKW7:
//////////////////// case kKW8:
//////////////////// case kKW9:
//////////////////// //- Do something
//////////////////// break ;
//////////////////// }
//////////////////// } else {
//////////////////// appendOk =true ;
//////////////////// }
//////////////////// //- If to finish
//////////////////// if ( quit )
//////////////////// break ;
////////////////////}
//////////////////////- If the input went well
////////////////////if ( appendOk )
//////////////////// //- Append to the database
//////////////////// append () ;
////////////////////else
//////////////////// //- Clean up
//////////////////// delete m_pArc ;
////////////////////return (status) ;
CString sPrompt;
m_Stage = center;
sPrompt = _T("\n输入圆弧圆心Center of arc: ");
setDispPrompt(sPrompt);
AcEdJig::DragStatus sts = drag();
if(sts != kNormal)
return sts;
m_Stage = startpnt;
sPrompt = _T("\n输入圆弧起点Start point of arc: ");
setDispPrompt(sPrompt);
m_pArc->getStartPoint(m_PntPrev);
sts = drag();
if(sts != kNormal)
return sts;
m_Stage = endpnt;
sPrompt = _T("\n输入圆弧终点End point of arc: ");
setDispPrompt(sPrompt);
m_pArc->getEndPoint(m_PntPrev);
sts = drag();
if(sts == kNormal)
{
AcDbObjectId idArc = append();
}
return sts;
}
//-----------------------------------------------------------------------------
//- Input sampler
AcEdJig::DragStatus CArcTestJig::sampler () {
//- Setup the user input controls for each input
////////AcEdJig::UserInputControls userInputControls [1] ={
//////// /*AcEdJig::UserInputControls::*/(AcEdJig::UserInputControls)0
////////} ;
//////////- Setup the cursor type for each input
////////AcEdJig::CursorType cursorType [1] ={
//////// /*AcEdJig::CursorType::*/(AcEdJig::CursorType)0
////////} ;
//////////- Setup the user input controls for each sample
////////setUserInputControls (userInputControls [mCurrentInputLevel]) ;
////////setSpecialCursorType (cursorType [mCurrentInputLevel]) ;
////////AcEdJig::DragStatus status =AcEdJig::kCancel ;
//////////- Check the current input number to see which input to do
////////switch ( mCurrentInputLevel+1 ) {
//////// case 1:
//////// // TODO : get an input here
//////// //status =GetStartPoint () ;
//////// break ;
//////// default:
//////// break ;
////////}
////////return (status) ;
setUserInputControls((UserInputControls) ( AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));
DragStatus sts;
AcGePoint3d pntTemp;
if(m_Stage == startpnt)
sts = acquirePoint(pntTemp, m_pArc->center());
else
sts = acquirePoint(pntTemp);
if(sts == AcEdJig::kNormal)
{
if(pntTemp.isEqualTo(m_PntPrev))
sts = kNoChange;
m_PntPrev = pntTemp;
}
return sts;
}
//-----------------------------------------------------------------------------
//- Jigged entity update
Adesk::Boolean CArcTestJig::update () {
//- Check the current input number to see which update to do
////switch ( mCurrentInputLevel+1 ) {
//// case 1:
//// // TODO : update your entity for this input
//// //mpEntity->setCenter (mInputPoints [mCurrentInputLevel]) ;
//// break ;
//// default:
//// break ;
////}
////return (updateDimData ()) ;
if(m_pArc == NULL)
return false;
switch(m_Stage)
{
case center:
m_pArc->setCenter(m_PntPrev);
break;
case startpnt:
{
AcGeVector3d vStart = m_PntPrev - m_pArc->center();
double dRadius = vStart.length();
vStart.normalize();
double dStart = vStart.angleTo(AcGeVector3d::kXAxis, m_pArc->normal().negate());
if(dStart > __PI)
dStart -= __PI*2;
m_pArc->setRadius(dRadius);
m_pArc->setStartAngle(dStart);
m_pArc->setEndAngle(dStart + __PI/2);
}
break;
case endpnt:
setEndAngleTo(m_PntPrev);
break;
default:
return false;
}
updateDimData();
return true;
}
//-----------------------------------------------------------------------------
//- Jigged entity pointer return
AcDbEntity *CArcTestJig::entity () const {
return ((AcDbEntity *)m_pArc) ;
}
//-----------------------------------------------------------------------------
//- Dynamic dimension data setup
AcDbDimDataPtrArray *CArcTestJig::dimData (const double dimScale) {
/* SAMPLE CODE:
AcDbAlignedDimension *dim =new AcDbAlignedDimension () ;
dim->setDatabaseDefaults () ;
dim->setNormal (AcGeVector3d::kZAxis) ;
dim->setElevation (0.0) ;
dim->setHorizontalRotation (0.0) ;
dim->setXLine1Point (m_originPoint) ;
dim->setXLine2Point (m_lastPoint) ;
//- Get the dimPoint, first the midpoint
AcGePoint3d dimPoint =m_originPoint + ((m_lastPoint - m_originPoint) / 2.0) ;
//- Then the offset
dim->setDimLinePoint (dimPoint) ;
dim->setDimtad (1) ;
AcDbDimData *dimData = new AcDbDimData (dim) ;
//AppData *appData =new AppData (1, dimScale) ;
//dimData.setAppData (appData) ;
dimData->setDimFocal (true) ;
dimData->setDimHideIfValueIsZero (true) ;
//- Check to see if it is required
if ( getDynDimensionRequired (m_inputNumber) )
dimData->setDimInvisible (false) ;
else
dimData->setDimInvisible (true) ;
//- Make sure it is editable TODO:
dimData->setDimEditable (true) ;
mDimData.append (dimData) ;
return (&mDimData) ;
*/
if(m_Stage != endpnt)
return NULL;
if(m_pDimData == NULL)
return NULL;
for(int ii = 0; ii < m_pDimData->length(); ii++)
delete m_pDimData->at(ii);
delete m_pDimData;
m_pDimData = NULL;
////releaseDimData();
m_pDimData = new AcDbDimDataPtrArray();
AcDbDimData* pNewData(NULL);
// Arc Dimension
//AcDbArcDimension* pArcDim = new AcDbArcDimension();
//pArcDim->setDatabaseDefaults();
//pArcDim->setNormal(m_pArc->normal());
//pArcDim->setElevation(0.0);
//pArcDim->setHorizontalRotation(0.0);
//pArcDim->setDimscale(dimScale);
//pArcDim->setDimtad(1);
//// pArcDim->setDynamicDimension(true);
//////这个是我自己后加的，但没效果，
//AcGePoint3d pt;
//m_pArc->getStartPoint(pt);
//pArcDim->setTextPosition(pt);
//pArcDim->setDynamicDimension(true);
/////////////////////
//pNewData = new AcDbDimData(pArcDim);
//pNewData->setDimHideIfValueIsZero(false);
//pNewData->setDimEditable(true);
//pNewData->setDimFocal(true);
//m_pDimData->append(pNewData);
// Chord Dimension
AcDbAlignedDimension* pChordDim = new AcDbAlignedDimension();
pChordDim->setDatabaseDefaults();
pChordDim->setNormal(m_pArc->normal());
pChordDim->setElevation(0.0);
pChordDim->setHorizontalRotation(0.0);
pChordDim->setDimtad(1);
//pChordDim->setDynamicDimension(true);
pNewData = new AcDbDimData(pChordDim);
pNewData->setDimHideIfValueIsZero(false);
pNewData->setDimEditable(true);
pNewData->setDimFocal(false);
m_pDimData->append(pNewData);
// set dimension location
updateDimData();
return m_pDimData;
////return (NULL) ;
}
//-----------------------------------------------------------------------------
//- Dynamic dimension data update
Acad::ErrorStatus CArcTestJig::setDimValue (const AcDbDimData *pDimData, const double dimValue) {
////Acad::ErrorStatus es =Acad::eOk ;
/* SAMPLE CODE:
//- Convert the const pointer to non const
AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
int inputNumber =-1 ;
//- Find the dim data being passed so we can determine the input number
if ( mDimData.find (dimDataNC, inputNumber) ) {
//- Now get the dimension
AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
//- Check it's the type of dimension we want
AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
//- If ok
if ( pAlnDim ) {
//- Extract the dimensions as they are now
AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
//- Lets get the new point entered by the user
AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
//- Finally set the end dim point
pAlnDim->setXLine2Point (dimEndNew) ;
//- Now update the jig data to reflect the dynamic dimension input
mInputPoints [mCurrentInputLevel] =dimEndNew ;
}
}*/
////return (es) ;
AcDbDimension* pDim = (AcDbDimension *)pDimData->dimension();
//pDim=dimData->
//AcDbArcDimension* pArcDim = AcDbArcDimension::cast(pDim);
//if(pArcDim)
//{
// AcGePoint3d pntNewEnd;
// Acad::ErrorStatus es = m_pArc->getPointAtDist(dimValue, pntNewEnd);
// if(Acad::eOk != es)
// return es;
// ////////setEndAngleTo(pntNewEnd);
// return Acad::eOk;
//}
//else
//{
AcDbAlignedDimension* pChordDim = AcDbAlignedDimension::cast(pDim);
if(pChordDim)
{
double dRadius = m_pArc->radius();
if(dimValue > dRadius*2)
return Acad::eNotApplicable;
double dAngDlt = asin(dimValue/(dRadius*2));
double dNewEnd = m_pArc->startAngle() + dAngDlt*2;
m_pArc->setEndAngle(dNewEnd);
return Acad::eOk;
}
//}
return Acad::eInvalidInput;
}
//-----------------------------------------------------------------------------
//- Various helper functions
//- Dynamic dimdata update function
Adesk::Boolean CArcTestJig::updateDimData () {
//- Check the dim data store for validity
////if ( mDimData.length () <= 0 )
////return (true) ;
if(m_pDimData == NULL || m_pArc == NULL)
return false;
if(m_pDimData->length() < 2)
return false;
double dRadius = m_pArc->radius();
AcGePoint3d pntCenter = m_pArc->center();
AcGePoint3d pntStart;
m_pArc->getStartPoint(pntStart);
double dStart;
m_pArc->getStartParam(dStart);
AcGePoint3d pntEnd;
m_pArc->getEndPoint(pntEnd);
double dEnd;
m_pArc->getEndParam(dEnd);
//AcDbArcDimension* pArcDim = AcDbArcDimension::cast(m_pDimData->at(0)->dimension());
//if(pArcDim)
//{
// pArcDim->setArcSymbolType(2); // no symbol
// pArcDim->setCenterPoint(pntCenter);
// pArcDim->setXLine1Point(pntStart);
// pArcDim->setXLine2Point(pntEnd);
// pArcDim->setArcStartParam(dStart);
// pArcDim->setArcEndParam(dEnd);
// AcGeVector3d vStart = (pntStart - pntCenter).normalize();
// AcGeVector3d vEnd = (pntEnd - pntCenter).normalize();
// AcGeVector3d vMid = vStart + vEnd;
// vMid.normalize();
// if(vStart.angleTo(vEnd, m_pArc->normal()) > __PI)
// vMid.negate();
// pArcDim->setArcPoint(pntCenter + (dRadius + ARCDIM_OFFSET)*vMid );
// pArcDim->setHasLeader(false);
//}
AcDbAlignedDimension* pChordDim = AcDbAlignedDimension::cast(m_pDimData->at(0)->dimension());
if(pChordDim)
{
pChordDim->setXLine1Point(pntStart);
pChordDim->setXLine2Point(pntEnd);
AcGeVector3d vDir = (pntEnd - pntStart).normalize();
pChordDim->setDimLinePoint(pntStart + ARCDIM_OFFSET*vDir.perpVector());
}
/* SAMPLE CODE :
//- Extract the individual dimData
AcDbDimData *dimData =mDimData [m_inputNumber] ;
//- Now get the dimension
AcDbDimension *pDim =(AcDbDimension *)dimData->dimension () ;
//- Check it's the type of dimension we want
AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
//- If ok
if ( pAlnDim ) {
//- Check to see if it is required
if ( getDynDimensionRequired (m_inputNumber) )
dimData->setDimInvisible (false) ;
else
dimData->setDimInvisible (true) ;
pAlnDim->setXLine1Point (m_originPoint) ;
pAlnDim->setXLine2Point (m_lastPoint) ;
//- Get the dimPoint, first the midpoint
AcGePoint3d dimPoint =m_originPoint + ((m_lastPoint - m_originPoint) / 2.0) ;
//- Then the offset
pAlnDim->setDimLinePoint (dimPoint) ;
} */
return (true) ;
}
//-----------------------------------------------------------------------------
//- Std input to get a point with no rubber band
AcEdJig::DragStatus CArcTestJig::GetStartPoint () {
AcGePoint3d newPnt ;
//- Get the point
AcEdJig::DragStatus status =acquirePoint (newPnt) ;
//- If valid input
if ( status == AcEdJig::kNormal ) {
//- If there is no difference
if ( newPnt.isEqualTo (mInputPoints [mCurrentInputLevel]) )
return (AcEdJig::kNoChange) ;
//- Otherwise update the point
mInputPoints [mCurrentInputLevel] =newPnt ;
}
return (status) ;
}
//-----------------------------------------------------------------------------
//- Std input to get a point with rubber band from point
AcEdJig::DragStatus CArcTestJig::GetNextPoint () {
AcGePoint3d oldPnt =mInputPoints [mCurrentInputLevel] ;
AcGePoint3d newPnt ;
//- Get the point
AcEdJig::DragStatus status =acquirePoint (newPnt, oldPnt) ;
//- If valid input
if ( status == AcEdJig::kNormal ) {
//- If there is no difference
if ( newPnt.isEqualTo (mInputPoints [mCurrentInputLevel]) )
return (AcEdJig::kNoChange) ;
//- Otherwise update the point
mInputPoints [mCurrentInputLevel] =newPnt ;
}
return (status) ;
}
void CArcTestJig::setEndAngleTo(AcGePoint3d pntEnd)
{
AcGeVector3d vEnd = (pntEnd - m_pArc->center()).normalize();
double dNewEnd = vEnd.angleTo(AcGeVector3d::kXAxis, m_pArc->normal().negate());
// if(dNewEnd > __PI)
// dNewEnd -= __PI*2;
m_pArc->setEndAngle(dNewEnd);
}

// (C) Copyright 2005-2007 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. ** 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 "StdAfx.h" 
#include "ArcTestJig.h" 
 
//----------------------------------------------------------------------------- 
CArcTestJig::CArcTestJig () : AcEdJig () 
        //, 
        //mCurrentInputLevel(0), mpEntity(NULL) 
        ,m_Stage(center), m_pDimData(NULL), __PI(atan (1.)*4) 
{ 
        m_pArc = new AcDbArc(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis, 100., 0., __PI/2); 
} 
 
CArcTestJig::~CArcTestJig () { 
        if(m_pDimData == NULL) 
                return; 
        for(int ii = 0; ii < m_pDimData->length(); ii++) 
                delete m_pDimData->at(ii); 
 
        delete m_pDimData; 
        m_pDimData = NULL; 
} 
 
//----------------------------------------------------------------------------- 
AcEdJig::DragStatus CArcTestJig::startJig ( /**pEntity*/) { 
        //- Store the new entity pointer 
        //mpEntity =pEntity ; 
        //- Setup each input prompt 
        ////////////////////AcString inputPrompts [1] ={ 
        ////////////////////        "\nPick point" 
        ////////////////////} ; 
        //////////////////////- Setup kwords for each input 
        ////////////////////AcString kwords [1] ={ 
        ////////////////////        "" 
        ////////////////////} ; 
 
        ////////////////////bool appendOk =true ; 
        ////////////////////AcEdJig::DragStatus status =AcEdJig::kNull ; 
        //////////////////////- Loop the number of inputs 
        ////////////////////for ( mCurrentInputLevel =0 ; mCurrentInputLevel < 1 ; mCurrentInputLevel++ ) { 
        ////////////////////        //- Add a new input point to the list of input points 
        ////////////////////        mInputPoints.append (AcGePoint3d ()) ; 
        ////////////////////        //- Set the input prompt 
        ////////////////////        setDispPrompt (inputPrompts [mCurrentInputLevel]) ; 
        ////////////////////        //- Setup the keywords required 
        ////////////////////        setKeywordList (kwords [mCurrentInputLevel]) ; 
 
        ////////////////////        bool quit =false ; 
        ////////////////////        //- Lets now do the input 
        ////////////////////        status =drag () ; 
        ////////////////////        if ( status != kNormal ) { 
        ////////////////////                //- If it's a keyword 
        ////////////////////                switch ( status ) { 
        ////////////////////                        case kCancel: 
        ////////////////////                        case kNull: 
        ////////////////////                                quit =true ; 
        ////////////////////                                break ; 
 
        ////////////////////                        case kKW1: 
        ////////////////////                        case kKW2: 
        ////////////////////                        case kKW3: 
        ////////////////////                        case kKW4: 
        ////////////////////                        case kKW5: 
        ////////////////////                        case kKW6: 
        ////////////////////                        case kKW7: 
        ////////////////////                        case kKW8: 
        ////////////////////                        case kKW9: 
        ////////////////////                                //- Do something 
 
        ////////////////////                                break ; 
        ////////////////////          } 
        ////////////////////        } else { 
        ////////////////////                appendOk =true ; 
        ////////////////////        } 
 
        ////////////////////        //- If to finish 
        ////////////////////        if ( quit ) 
        ////////////////////                break ; 
        ////////////////////} 
 
        //////////////////////- If the input went well 
        ////////////////////if ( appendOk ) 
        ////////////////////        //- Append to the database 
        ////////////////////        append () ; 
        ////////////////////else 
        ////////////////////        //- Clean up 
        ////////////////////        delete m_pArc  ; 
 
        ////////////////////return (status) ; 
 
 
        CString sPrompt; 
 
        m_Stage = center; 
        sPrompt = _T("\n输入圆弧圆心Center of arc: "); 
        setDispPrompt(sPrompt); 
        AcEdJig::DragStatus sts = drag(); 
        if(sts != kNormal) 
                return sts; 
 
        m_Stage = startpnt; 
        sPrompt = _T("\n输入圆弧起点Start point of arc: "); 
        setDispPrompt(sPrompt); 
        m_pArc->getStartPoint(m_PntPrev); 
        sts = drag(); 
        if(sts != kNormal) 
                return sts; 
 
        m_Stage = endpnt; 
        sPrompt = _T("\n输入圆弧终点End point of arc: "); 
        setDispPrompt(sPrompt); 
        m_pArc->getEndPoint(m_PntPrev); 
        sts = drag(); 
        if(sts == kNormal) 
        { 
                AcDbObjectId idArc = append(); 
        } 
 
        return sts; 
} 
 
//----------------------------------------------------------------------------- 
//- Input sampler 
AcEdJig::DragStatus CArcTestJig::sampler () { 
        //- Setup the user input controls for each input 
        ////////AcEdJig::UserInputControls userInputControls [1] ={ 
        ////////        /*AcEdJig::UserInputControls::*/(AcEdJig::UserInputControls)0 
        ////////} ; 
        //////////- Setup the cursor type for each input 
        ////////AcEdJig::CursorType cursorType [1] ={ 
        ////////        /*AcEdJig::CursorType::*/(AcEdJig::CursorType)0 
        ////////} ; 
        //////////- Setup the user input controls for each sample 
        ////////setUserInputControls (userInputControls [mCurrentInputLevel]) ; 
        ////////setSpecialCursorType (cursorType [mCurrentInputLevel]) ; 
 
        ////////AcEdJig::DragStatus status =AcEdJig::kCancel ; 
        //////////- Check the current input number to see which input to do 
        ////////switch ( mCurrentInputLevel+1 ) { 
        ////////        case 1: 
        ////////                // TODO : get an input here 
        ////////                //status =GetStartPoint () ; 
        ////////                break ; 
 
        ////////        default: 
        ////////                break ; 
        ////////} 
        ////////return (status) ; 
 
 
        setUserInputControls((UserInputControls)        (        AcEdJig::kAccept3dCoordinates        | AcEdJig::kNullResponseAccepted)); 
 
        DragStatus sts; 
        AcGePoint3d pntTemp; 
        if(m_Stage == startpnt) 
                sts = acquirePoint(pntTemp, m_pArc->center()); 
        else 
                sts = acquirePoint(pntTemp); 
        if(sts == AcEdJig::kNormal) 
        { 
                if(pntTemp.isEqualTo(m_PntPrev)) 
                        sts = kNoChange; 
                m_PntPrev = pntTemp; 
        } 
        return sts; 
} 
 
//----------------------------------------------------------------------------- 
//- Jigged entity update 
Adesk::Boolean CArcTestJig::update () { 
        //- Check the current input number to see which update to do 
        
        ////switch ( mCurrentInputLevel+1 ) { 
        ////        case 1: 
        ////                // TODO : update your entity for this input 
        ////                //mpEntity->setCenter (mInputPoints [mCurrentInputLevel]) ; 
        ////                break ; 
 
        ////        default: 
        ////                break ; 
        ////} 
 
        ////return (updateDimData ()) ; 
 
        if(m_pArc == NULL) 
                return false; 
 
        switch(m_Stage) 
        { 
        case center: 
                m_pArc->setCenter(m_PntPrev); 
                break; 
 
        case startpnt: 
                { 
                        AcGeVector3d vStart = m_PntPrev - m_pArc->center(); 
                        double dRadius = vStart.length(); 
                        vStart.normalize(); 
                        double dStart = vStart.angleTo(AcGeVector3d::kXAxis, m_pArc->normal().negate()); 
                        if(dStart > __PI) 
                                dStart -= __PI*2; 
                        m_pArc->setRadius(dRadius); 
                        m_pArc->setStartAngle(dStart); 
                        m_pArc->setEndAngle(dStart + __PI/2); 
                } 
                break; 
 
        case endpnt: 
                setEndAngleTo(m_PntPrev); 
                break; 
 
        default: 
                return false; 
        } 
 
        updateDimData(); 
        return true; 
} 
 
//----------------------------------------------------------------------------- 
//- Jigged entity pointer return 
AcDbEntity *CArcTestJig::entity () const { 
        return ((AcDbEntity *)m_pArc) ; 
} 
 
//----------------------------------------------------------------------------- 
//- Dynamic dimension data setup 
AcDbDimDataPtrArray *CArcTestJig::dimData (const double dimScale) { 
 
        /* SAMPLE CODE: 
        AcDbAlignedDimension *dim =new AcDbAlignedDimension () ; 
        dim->setDatabaseDefaults () ; 
        dim->setNormal (AcGeVector3d::kZAxis) ; 
        dim->setElevation (0.0) ; 
        dim->setHorizontalRotation (0.0) ; 
        dim->setXLine1Point (m_originPoint) ; 
        dim->setXLine2Point (m_lastPoint) ; 
        //- Get the dimPoint, first the midpoint 
        AcGePoint3d dimPoint =m_originPoint + ((m_lastPoint - m_originPoint) / 2.0) ; 
        //- Then the offset 
        dim->setDimLinePoint (dimPoint) ; 
        dim->setDimtad (1) ; 
 
        AcDbDimData *dimData = new AcDbDimData (dim) ; 
        //AppData *appData =new AppData (1, dimScale) ; 
        //dimData.setAppData (appData) ; 
        dimData->setDimFocal (true) ; 
        dimData->setDimHideIfValueIsZero (true) ; 
 
        //- Check to see if it is required 
        if ( getDynDimensionRequired (m_inputNumber) ) 
                dimData->setDimInvisible (false) ; 
        else 
                dimData->setDimInvisible (true) ; 
 
        //- Make sure it is editable TODO: 
        dimData->setDimEditable (true) ; 
        mDimData.append (dimData) ; 
 
        return (&mDimData) ; 
        */ 
 
 
        if(m_Stage != endpnt) 
                return NULL; 
        
        if(m_pDimData == NULL) 
                return NULL; 
        for(int ii = 0; ii < m_pDimData->length(); ii++) 
                delete m_pDimData->at(ii); 
 
        delete m_pDimData; 
        m_pDimData = NULL; 
        ////releaseDimData(); 
 
        m_pDimData = new AcDbDimDataPtrArray(); 
 
        AcDbDimData* pNewData(NULL); 
 
        // Arc Dimension 
        //AcDbArcDimension* pArcDim = new AcDbArcDimension(); 
        //pArcDim->setDatabaseDefaults(); 
        //pArcDim->setNormal(m_pArc->normal()); 
        //pArcDim->setElevation(0.0); 
        //pArcDim->setHorizontalRotation(0.0); 
        //pArcDim->setDimscale(dimScale); 
        //pArcDim->setDimtad(1); 
        ////        pArcDim->setDynamicDimension(true); 
 
        //////这个是我自己后加的，但没效果， 
        //AcGePoint3d pt; 
        //m_pArc->getStartPoint(pt); 
        //pArcDim->setTextPosition(pt); 
        //pArcDim->setDynamicDimension(true); 
        ///////////////////// 
 
        //pNewData = new AcDbDimData(pArcDim); 
        //pNewData->setDimHideIfValueIsZero(false); 
        //pNewData->setDimEditable(true); 
        //pNewData->setDimFocal(true); 
 
        //m_pDimData->append(pNewData); 
 
        // Chord Dimension 
        AcDbAlignedDimension* pChordDim = new AcDbAlignedDimension(); 
        pChordDim->setDatabaseDefaults(); 
        pChordDim->setNormal(m_pArc->normal()); 
        pChordDim->setElevation(0.0); 
        pChordDim->setHorizontalRotation(0.0); 
        pChordDim->setDimtad(1); 
        //pChordDim->setDynamicDimension(true); 
 
        pNewData = new AcDbDimData(pChordDim); 
        pNewData->setDimHideIfValueIsZero(false); 
        pNewData->setDimEditable(true); 
        pNewData->setDimFocal(false); 
 
        m_pDimData->append(pNewData); 
 
        // set dimension location 
        updateDimData(); 
 
        return m_pDimData; 
        ////return (NULL) ; 
} 
 
//----------------------------------------------------------------------------- 
//- Dynamic dimension data update 
Acad::ErrorStatus CArcTestJig::setDimValue (const AcDbDimData *pDimData, const double dimValue) { 
        ////Acad::ErrorStatus es =Acad::eOk ; 
 
        /* SAMPLE CODE: 
        //- Convert the const pointer to non const 
        AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ; 
        int inputNumber =-1 ; 
        //- Find the dim data being passed so we can determine the input number 
        if ( mDimData.find (dimDataNC, inputNumber) ) { 
                //- Now get the dimension 
                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ; 
                //- Check it's the type of dimension we want 
                AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ; 
                //- If ok 
                if ( pAlnDim ) { 
                        //- Extract the dimensions as they are now 
                        AcGePoint3d dimStart =pAlnDim->xLine1Point () ; 
                        AcGePoint3d dimEnd =pAlnDim->xLine2Point () ; 
                        //- Lets get the new point entered by the user 
                        AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ; 
                        //- Finally set the end dim point 
                        pAlnDim->setXLine2Point (dimEndNew) ; 
                        //- Now update the jig data to reflect the dynamic dimension input 
                        mInputPoints [mCurrentInputLevel] =dimEndNew ; 
                } 
        }*/ 
        ////return (es) ; 
 
 
 
 
        AcDbDimension* pDim = (AcDbDimension *)pDimData->dimension(); 
        //pDim=dimData-> 
 
        //AcDbArcDimension* pArcDim = AcDbArcDimension::cast(pDim); 
        //if(pArcDim) 
        //{ 
        //        AcGePoint3d pntNewEnd; 
        //        Acad::ErrorStatus es = m_pArc->getPointAtDist(dimValue, pntNewEnd); 
        //        if(Acad::eOk != es) 
        //                return es; 
 
        //        ////////setEndAngleTo(pntNewEnd); 
 
        //        return Acad::eOk; 
        //} 
        //else 
        //{ 
                AcDbAlignedDimension* pChordDim =  AcDbAlignedDimension::cast(pDim); 
                if(pChordDim) 
                { 
                        double dRadius = m_pArc->radius(); 
                        if(dimValue > dRadius*2) 
                                return Acad::eNotApplicable; 
 
 
                        double dAngDlt = asin(dimValue/(dRadius*2)); 
                        double dNewEnd = m_pArc->startAngle() + dAngDlt*2; 
                        m_pArc->setEndAngle(dNewEnd); 
                        return Acad::eOk; 
                } 
        //} 
 
        return  Acad::eInvalidInput; 
} 
 
//----------------------------------------------------------------------------- 
//- Various helper functions 
//- Dynamic dimdata update function 
Adesk::Boolean CArcTestJig::updateDimData () { 
        //- Check the dim data store for validity 
        
        ////if ( mDimData.length () <= 0 ) 
                ////return (true) ; 
 
        if(m_pDimData == NULL || m_pArc == NULL) 
                return false; 
 
        if(m_pDimData->length() < 2) 
                return false; 
 
        double  dRadius = m_pArc->radius(); 
        AcGePoint3d  pntCenter = m_pArc->center(); 
 
        AcGePoint3d  pntStart; 
        m_pArc->getStartPoint(pntStart); 
        double dStart; 
        m_pArc->getStartParam(dStart); 
 
        AcGePoint3d  pntEnd; 
        m_pArc->getEndPoint(pntEnd); 
        double dEnd; 
        m_pArc->getEndParam(dEnd); 
 
        //AcDbArcDimension* pArcDim = AcDbArcDimension::cast(m_pDimData->at(0)->dimension()); 
        //if(pArcDim) 
        //{ 
        //        pArcDim->setArcSymbolType(2); // no symbol 
        //        pArcDim->setCenterPoint(pntCenter); 
        //        pArcDim->setXLine1Point(pntStart); 
        //        pArcDim->setXLine2Point(pntEnd); 
        //        pArcDim->setArcStartParam(dStart); 
        //        pArcDim->setArcEndParam(dEnd); 
 
        //        AcGeVector3d vStart = (pntStart - pntCenter).normalize(); 
        //        AcGeVector3d vEnd = (pntEnd - pntCenter).normalize(); 
        //        AcGeVector3d vMid = vStart + vEnd; 
        //        vMid.normalize(); 
 
        //        if(vStart.angleTo(vEnd, m_pArc->normal()) > __PI) 
        //                vMid.negate(); 
 
        //        pArcDim->setArcPoint(pntCenter + (dRadius + ARCDIM_OFFSET)*vMid ); 
 
        //        pArcDim->setHasLeader(false); 
        //} 
 
        AcDbAlignedDimension* pChordDim = AcDbAlignedDimension::cast(m_pDimData->at(0)->dimension()); 
        if(pChordDim) 
        { 
                pChordDim->setXLine1Point(pntStart); 
                pChordDim->setXLine2Point(pntEnd); 
                AcGeVector3d vDir = (pntEnd - pntStart).normalize(); 
 
                pChordDim->setDimLinePoint(pntStart + ARCDIM_OFFSET*vDir.perpVector()); 
        } 
        /* SAMPLE CODE : 
        //- Extract the individual dimData 
        AcDbDimData *dimData =mDimData [m_inputNumber] ; 
        //- Now get the dimension 
        AcDbDimension *pDim =(AcDbDimension *)dimData->dimension () ; 
        //- Check it's the type of dimension we want 
        AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ; 
        //- If ok 
        if ( pAlnDim ) { 
                //- Check to see if it is required 
                if ( getDynDimensionRequired (m_inputNumber) ) 
                        dimData->setDimInvisible (false) ; 
                else 
                        dimData->setDimInvisible (true) ; 
                pAlnDim->setXLine1Point (m_originPoint) ; 
                pAlnDim->setXLine2Point (m_lastPoint) ; 
                //- Get the dimPoint, first the midpoint 
                AcGePoint3d dimPoint =m_originPoint + ((m_lastPoint - m_originPoint) / 2.0) ; 
                //- Then the offset 
                pAlnDim->setDimLinePoint (dimPoint) ; 
        } */ 
        return (true) ; 
} 
 
//----------------------------------------------------------------------------- 
//- Std input to get a point with no rubber band 
AcEdJig::DragStatus CArcTestJig::GetStartPoint () { 
        AcGePoint3d newPnt ; 
        //- Get the point 
        AcEdJig::DragStatus status =acquirePoint (newPnt) ; 
        //- If valid input 
        if ( status == AcEdJig::kNormal ) { 
                //- If there is no difference 
                if ( newPnt.isEqualTo (mInputPoints [mCurrentInputLevel]) ) 
                        return (AcEdJig::kNoChange) ; 
                //- Otherwise update the point 
                mInputPoints [mCurrentInputLevel] =newPnt ; 
        } 
        return (status) ; 
} 
 
//----------------------------------------------------------------------------- 
//- Std input to get a point with rubber band from point 
AcEdJig::DragStatus CArcTestJig::GetNextPoint () { 
        AcGePoint3d oldPnt =mInputPoints [mCurrentInputLevel] ; 
        AcGePoint3d newPnt ; 
        //- Get the point 
        AcEdJig::DragStatus status =acquirePoint (newPnt, oldPnt) ; 
        //- If valid input 
        if ( status == AcEdJig::kNormal ) { 
                //- If there is no difference 
                if ( newPnt.isEqualTo (mInputPoints [mCurrentInputLevel]) ) 
                        return (AcEdJig::kNoChange) ; 
                //- Otherwise update the point 
                mInputPoints [mCurrentInputLevel] =newPnt ; 
        } 
        return (status) ; 
} 
 
 
void  CArcTestJig::setEndAngleTo(AcGePoint3d pntEnd) 
{ 
        AcGeVector3d vEnd = (pntEnd - m_pArc->center()).normalize(); 
        double dNewEnd = vEnd.angleTo(AcGeVector3d::kXAxis, m_pArc->normal().negate()); 
        //         if(dNewEnd > __PI) 
        //                 dNewEnd -= __PI*2; 
        m_pArc->setEndAngle(dNewEnd); 
}

why1025 · 发表于 2018-2-18 23:44:06

本帖最后由 why1025 于 2018-2-18 23:48 编辑

头文件

//
// 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. ** 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.
//-----------------------------------------------------------------------------
//- ArcTestJig.h
#pragma once
//-----------------------------------------------------------------------------
class CArcTestJig : public AcEdJig {
private:
//- Member variables
//- current input level, increment for each input
int mCurrentInputLevel ;
//- Dynamic dimension info
AcDbDimDataPtrArray mDimData ;
public:
//- Array of input points, each level corresponds to the mCurrentInputLevel
AcGePoint3dArray mInputPoints ;
//- Entity being jigged
//*mpEntity ;
#define ARCDIM_OFFSET 20.0
enum stage
{
center = 1,
startpnt,
endpnt
};
stage m_Stage;
AcGePoint3d m_PntPrev;
AcDbArc* m_pArc;
AcDbDimDataPtrArray* m_pDimData;
double __PI;
public:
CArcTestJig () ;
~CArcTestJig () ;
//- Command invoke the jig, call passing a new'd instance of the object to jig
AcEdJig::DragStatus startJig ( /**pEntityToJig*/) ;
protected:
//- AcEdJig overrides
//- input sampler
virtual DragStatus sampler () ;
//- jigged entity update
virtual Adesk::Boolean update () ;
//- jigged entity pointer return
virtual AcDbEntity *entity () const ;
//- dynamic dimension data setup
virtual AcDbDimDataPtrArray *dimData (const double dimScale) ;
//- dynamic dimension data update
virtual Acad::ErrorStatus setDimValue (const AcDbDimData *pDimData, const double dimValue) ;
//- Standard helper functions
//- dynamic dimdata update function
virtual Adesk::Boolean updateDimData () ;
//- Std input to get a point with no rubber band
AcEdJig::DragStatus GetStartPoint () ;
//- Std input to get a point with rubber band from point
AcEdJig::DragStatus GetNextPoint () ;
void setEndAngleTo(AcGePoint3d pntEnd);
} ;</div><div>测试代码</div><div>static void ArcTest2002_MyC2(void)
{
// Add your code for command ArcTest2002._MyC2 here
CArcTestJig arcJig;
arcJig.startJig();
}</div><div>编译完只能看到圆弧，看不到尺寸
</div>

<div><div>// (C) Copyright 2005-2007 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. ** 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. 
 
//----------------------------------------------------------------------------- 
//- ArcTestJig.h 
#pragma once 
 
//----------------------------------------------------------------------------- 
class CArcTestJig : public AcEdJig { 
 
private: 
        //- Member variables 
        //- current input level, increment for each input 
        int mCurrentInputLevel ; 
        //- Dynamic dimension info 
        AcDbDimDataPtrArray mDimData ; 
 
public: 
        //- Array of input points, each level corresponds to the mCurrentInputLevel 
        AcGePoint3dArray mInputPoints ; 
        //- Entity being jigged 
         //*mpEntity ; 
         #define ARCDIM_OFFSET  20.0 
         enum stage 
         { 
                 center = 1, 
                 startpnt, 
                 endpnt 
         }; 
 
         stage        m_Stage; 
         AcGePoint3d  m_PntPrev; 
         AcDbArc*     m_pArc; 
 
         AcDbDimDataPtrArray* m_pDimData; 
 
         double     __PI; 
public: 
        CArcTestJig () ; 
        ~CArcTestJig () ; 
 
        //- Command invoke the jig, call passing a new'd instance of the object to jig 
        AcEdJig::DragStatus startJig ( /**pEntityToJig*/) ; 
 
protected: 
        //- AcEdJig overrides 
        //- input sampler 
        virtual DragStatus sampler () ; 
        //- jigged entity update 
        virtual Adesk::Boolean update () ; 
        //- jigged entity pointer return 
        virtual AcDbEntity *entity () const ; 
        //- dynamic dimension data setup 
        virtual AcDbDimDataPtrArray *dimData (const double dimScale) ; 
        //- dynamic dimension data update 
        virtual Acad::ErrorStatus setDimValue (const AcDbDimData *pDimData, const double dimValue) ; 
 
        //- Standard helper functions 
        //- dynamic dimdata update function 
        virtual Adesk::Boolean updateDimData () ; 
 
        //- Std input to get a point with no rubber band 
        AcEdJig::DragStatus GetStartPoint () ; 
        //- Std input to get a point with rubber band from point 
        AcEdJig::DragStatus GetNextPoint () ; 
 
        void  setEndAngleTo(AcGePoint3d pntEnd); 
} ;</div><div>测试代码</div><div>static void ArcTest2002_MyC2(void) 
 { 
  // Add your code for command ArcTest2002._MyC2 here 
  CArcTestJig arcJig; 
  arcJig.startJig(); 
 }</div><div>编译完只能看到圆弧，看不到尺寸 
</div>

why1025 · 发表于 2018-2-18 23:52:06

编译完只能看到圆弧，看不到尺寸，帮忙查查原因

LoveArx · 发表于 2018-4-8 11:50:57

2006和2008以上，注意下重l载的worlddraw和subworlddraw的不同。

账号		自动登录	找回密码
密码			立即注册

[求助] 大过年的

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。