asdksmiley.cpp

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

        switch( idx ) {

        // Stretch smiley center
        //
        case 0:
            setCenter( center() + offset );
            continue;

        // Stretch smiley radius
        //
        case 1:
            oldquad = center() + AcGeVector3d( radius(), 0, 0 );
            break;
        case 2:
            oldquad = center() + AcGeVector3d( 0, radius(), 0 );
            break;
        case 3:
            oldquad = center() - AcGeVector3d( radius(), 0, 0 );
            break;
        case 4:
            oldquad = center() - AcGeVector3d( 0, radius(), 0 );
            break;

        // Stretch smiley mouth
        //
        case 5:
            // Left hand edge of mouth
            //
            setMouthLeft( mouthLeft() + offset );
            ensureRadius();

            continue;

        case 6:
            // Right hand edge of mouth
            //
            setMouthRight( mouthRight() + offset );
            ensureRadius();

            continue;

        case 7:
            // Middle mouth chord
            //
            setMouth( mouthLeft() + offset, mouthBottom() + offset, mouthRight() + offset );
            ensureRadius();

            continue;

        case 8:
            // Bottom of mouth arc
            //
            setMouthBottom( mouthBottom() + offset );
            ensureRadius();

            continue;

        // Stretch smiley eyes
        //
        default:
            if(( eyearray.length() * 5 ) + 9 > idx ){
                
                // Get eye number, extracting it from the array
                //
                int eyepos = (int)(( idx - 9 ) / 5 );
                AcGePoint3d eyecen = eyearray.at( eyepos );
                
                // Handle the grip for the eye
                //
                int subidx = idx - 9;
                while ( subidx >= 5 ){ subidx -= 5; }
                switch( subidx ){

                // Stretch eye center
                //
                case 0:
                    // Keep the minimum eye height at zero
                    //
                    if( meyesheight+offset[Y] < 0 )
                        setEyesHeight( 0 );
                    else
                        setEyesHeight( meyesheight + offset[Y] );

                    // Keep the eyes from overlapping
                    //
                    if( eyecen[X] < center()[X] ){    // left eye
                        if( meyesapart - ( offset[X] * 2 ) < meyesize * 2 )
                            setEyesApart( meyesize * 2 );
                        else
                            setEyesApart( meyesapart - ( offset[X] * 2 ));
                    }
                    else {                          // right eye
                        if( meyesapart + ( offset[X] * 2 ) < meyesize * 2 )
                            setEyesApart( meyesize * 2 );
                        else
                            setEyesApart( meyesapart + ( offset[X] * 2));
                    }
                    ensureRadius();
                    continue;

                // Stretch eye radius
                //
                case 1:
                    oldquad = eyecen + AcGeVector3d( meyesize, 0, 0 );
                    break;
                case 2:
                    oldquad = eyecen + AcGeVector3d( 0, meyesize, 0 );
                    break;
                case 3:
                    oldquad = eyecen - AcGeVector3d( meyesize, 0, 0 );
                    break;
                case 4:
                    oldquad = eyecen - AcGeVector3d( 0, meyesize, 0 );
                    break;
                }
                newquad = oldquad + offset;
                
                // Keep eyes from touching
                //
                if( newquad.distanceTo( eyecen ) > meyesapart / 2 )
                    setEyeSize( meyesapart / 2 );
                else
                    setEyeSize( newquad.distanceTo( eyecen ));
                ensureRadius();
            }
            continue;
        }
        newquad = oldquad + offset;
        scaleRadius( newquad.distanceTo( center() ));
    }

    return Acad::eOk;
}

Acad::ErrorStatus
AsdkSmiley::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
    assertReadEnabled();

    //  getStretchPoints == getGripPoints
    //
    AcDbIntArray osnapModes;
    AcDbIntArray geomIds;
    return getGripPoints( stretchPoints, osnapModes, geomIds );
}

Acad::ErrorStatus
AsdkSmiley::moveStretchPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    assertWriteEnabled();

    //  moveStretchPointsAt == moveGripPointsAt
    //
    return moveGripPointsAt( indices, offset );
}

Acad::ErrorStatus
AsdkSmiley::transformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();

    // Transform the center point and get the translation vector
    AcGePoint3d oldCenter( center() ),
                newCenter( center() );
    newCenter.transformBy( xform );
    AcGeVector3d transVec = newCenter - center();

    // Get the equivalent transformation
    AcGeMatrix3d newXform;
    newXform.setToTranslation( transVec );

    // Only translate the face and mouth - do not transform!
    mfacecircle.transformBy( newXform );
    mmoutharc.transformBy( newXform );

    // Get the point at a quadrant, transform it..
    AcGePoint3d oldXquad = center() + AcGeVector3d( radius(), 0, 0 ),
                newXquad( oldXquad );
    newXquad.transformBy( xform );

    // ... then scale the Smiley accordingly
    if ( Adesk::kFalse == xform.isEqualTo( AcGeMatrix3d::kIdentity ))
        scaleRadius( radius() * newCenter.distanceTo( newXquad ) / oldCenter.distanceTo( oldXquad ));

    return Acad::eOk;
}

void
AsdkSmiley::saveAs(AcGiWorldDraw *wd, AcDb::SaveType saveType)
{

    // saveType == AcDb::kR12Save for saveasr12
    // saveType == AcDb::kR13Save for proxy graphics save
    //
    AcGiRegenType rtype = wd->regenType();

    if( AcDb::kR12Save == saveType )
        wd->subEntityTraits().setFillType( kAcGiFillNever );
    else if( AcDb::kR13Save == saveType )
        wd->subEntityTraits().setFillType( kAcGiFillAlways );

    // Draw face
    //
    wd->geometry().circle( center(), radius(), mnormal );

    if( AcDb::kR13Save == saveType )
        wd->subEntityTraits().setColor( 250 );

    // Draw eyes
    //
    AcGePoint3dArray eyearray;
    eyes( eyearray );
    AcGeVector3d eyevec( -1, 0, 0 );
    double eyeang = kPi;
    for( int i = 0; i < eyearray.length(); i++ ){
        wd->geometry().circularArc( eyearray.at( i ), meyesize, mnormal, eyevec, eyeang );
    }

    // Draw frown
    //
    AcGePoint3d smilecen = center();
    smilecen[Y] -= radius() * 1.1;
    double smilerad = radius() * 0.8;
    AcGeVector3d smilevec( 1, 1, 0 );
    double smileang = kPi / 2;
    wd->geometry().circularArc( smilecen, smilerad, mnormal, smilevec, smileang, kAcGiArcChord );
}

Acad::ErrorStatus
AsdkSmiley::osnapNear(
    const AcGePoint3d& pickPoint,
    AcGePoint3dArray& snapPoints) const
{
    // For osnap near, define the same points as the grip points.
    // This definitely not the proper implementation,  but it is
    // adequate for this simple sample.
    //

    AcGeVector3d xoff( radius(), 0, 0 );
    AcGeVector3d yoff( 0, radius(), 0 );
    AcGePoint3d center( center() );
    snapPoints.append( center + xoff );
    snapPoints.append( center + yoff );
    snapPoints.append( center - xoff );
    snapPoints.append( center - yoff );

    return Acad::eOk;
}

Acad::ErrorStatus
AsdkSmiley::osnapCen(
    const AcGePoint3d& pickPoint,
    AcGePoint3dArray& snapPoints) const
{
    // Osnap center to the face's center
    //
    snapPoints.append( center() );

    // Osnap center to the eyes' center
    //
    AcGePoint3dArray eyearray;
    eyes( eyearray );
    for( int i = 0; i < eyearray.length(); i++ ){
        snapPoints.append( eyearray.at( i ));
    }

    return Acad::eOk;
}

Acad::ErrorStatus
AsdkSmiley::osnapQuad(
    const AcGePoint3d& pickPoint,
    AcGePoint3dArray& snapPoints) const
{
    AcGeVector3d xoff(0,0,0);
    AcGeVector3d yoff(0,0,0);

    // Osnap quad to the face's quad points
    //
    xoff.x = yoff.y = radius();
    AcGePoint3d center( center() );
    snapPoints.append( center + xoff );
    snapPoints.append( center + yoff );
    snapPoints.append( center - xoff );
    snapPoints.append( center - yoff );
    
    // Osnap quad to the eyes' quad points
    //
    AcGePoint3dArray eyearray;
    AcGePoint3d eyecen;
    eyes( eyearray );
    for( int i = 0; i < eyearray.length(); i++ ){
        eyecen = eyearray.at( i );
        xoff.x = meyesize;
        yoff.y = meyesize;
        snapPoints.append( eyecen + xoff );
        snapPoints.append( eyecen + yoff );
        snapPoints.append( eyecen - xoff );
        snapPoints.append( eyecen - yoff );
    }

    return Acad::eOk;
}

AcGePoint3d
AsdkSmiley::center() const
{
    assertReadEnabled();
    return mfacecircle.center();
}

void
AsdkSmiley::setCenter(const AcGePoint3d c) 
{
    assertWriteEnabled();
    mmoutharc.translateBy( c - center() );
    mfacecircle.setCenter( c );
    recordGraphicsModified();
} // smiley center

double
AsdkSmiley::radius() const
{
    assertReadEnabled();
    return mfacecircle.radius();
}

void
AsdkSmiley::setRadius(const double r)       
{
    assertWriteEnabled();
    mfacecircle.setRadius( r );
} // smiley radius

void
AsdkSmiley::scaleRadius(const double r)       
{
    assertWriteEnabled();
    AcGePoint3d center( center() );
    double rad = radius(),
           factor = r / rad;
    setEyesApart( factor * meyesapart );
    setEyesHeight( factor * meyesheight );
    setEyeSize( factor * meyesize );
    AcGePoint3d left( mouthLeft() ),
                bottom( mouthBottom() ),
                right( mouthRight() );
    setMouth( left.scaleBy( factor, center ), bottom.scaleBy( factor, center ), right.scaleBy( factor, center ) );
    setRadius( r );
    recordGraphicsModified();
} // smiley radius

AcGeVector3d
AsdkSmiley::normal() const
{
    assertReadEnabled();
    return mnormal;
}

void
AsdkSmiley::setNormal(const AcGeVector3d v)
{
    assertWriteEnabled();
    mnormal = v;
    recordGraphicsModified();
} // smiley normal

double
AsdkSmiley::eyesApart() const
{
    assertReadEnabled();
    return meyesapart;
}

void
AsdkSmiley::setEyesApart(const double d)       
{
    assertWriteEnabled();
    meyesapart = d;
    recordGraphicsModified();
} // smiley eyes apart

double
AsdkSmiley::eyesHeight() const
{
    assertReadEnabled();
    return meyesheight;
}

void
AsdkSmiley::setEyesHeight(const double h)       
{
    assertWriteEnabled();
    meyesheight = h;
    recordGraphicsModified();
} // smiley eyes height

double
AsdkSmiley::eyeSize() const
{
    assertReadEnabled();
    return meyesize;
}

void
AsdkSmiley::setEyeSize(const double s)       
{
    assertWriteEnabled();
    meyesize = s;
    recordGraphicsModified();
} // smiley eyes size

void
AsdkSmiley::eyes(AcGePoint3dArray& array) const
{
    assertReadEnabled();
    // left eye
    AcGePoint3d eye = center();
    eye[X] -= meyesapart / 2;
    eye[Y] += meyesheight;
    array.append(eye);
    // right eye
    eye[X] += meyesapart;
    array.append(eye);
} // smiley eyes

AcGePoint3d
AsdkSmiley::mouthCenter() const
{
    assertReadEnabled();
    return mmoutharc.center();
}

double
AsdkSmiley::mouthRadius() const
{
    assertReadEnabled();
    return mmoutharc.radius();
}

AcGePoint3d
AsdkSmiley::mouthLeft() const
{
    assertReadEnabled();
    return mmoutharc.startPoint();
}

void
AsdkSmiley::setMouthLeft(const AcGePoint3d& p)       
{
    assertWriteEnabled();
    mmoutharc.set( p, mouthBottom(), mouthRight() );
    recordGraphicsModified();
} // left point of mouth arc (smile)

AcGePoint3d
AsdkSmiley::mouthRight() const
{
    assertReadEnabled();
    return mmoutharc.endPoint();
}

void
AsdkSmiley::setMouthRight(const AcGePoint3d& p)       
{
    assertWriteEnabled();
    mmoutharc.set( mouthLeft(), mouthBottom(), p );
    recordGraphicsModified();
} // right point of mouth arc (smile)

AcGePoint3d
AsdkSmiley::mouthBottom() const
{
    assertReadEnabled();
    AcGeVector3d yoff( 0, radius(), 0 );
    AcGePoint3d center( center() );
    AcGePoint3d faceBottom( center - yoff );
    AcGePointOnCurve3d pntCurve;
    
    mmoutharc.getClosestPointTo( faceBottom, pntCurve );
    return pntCurve.point();
}

void
AsdkSmiley::setMouthBottom(const AcGePoint3d& p)       
{
    assertWriteEnabled();
    mmoutharc.set( mouthLeft(), p, mouthRight() );
    recordGraphicsModified();
} // bottom point of mouth arc (smile)

void
AsdkSmiley::setMouth( const AcGePoint3d& left, const AcGePoint3d& bottom, const AcGePoint3d& right )
{
    assertWriteEnabled();
    AcGePoint3d realLeft( left ), realBottom( bottom ), realRight( right );

    double topY = center()[Y] + eyesHeight() - eyeSize();
    double diff = 0.0;

    if (( left[Y] - topY ) > diff ){
        diff = left[Y] - topY;
    }
    if (( bottom[Y] - topY ) > diff ){
        diff = bottom[Y] - topY;
    }
    if (( right[Y] - topY ) > diff ){
        diff = right[Y] - topY;
    }
    
    AcGeVector3d vec( 0, diff, 0 );
    mmoutharc.set( realLeft - vec, realBottom - vec, realRight - vec );
    recordGraphicsModified();
}