AssociativeElementAPI.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once
SMARTFEATURE_TYPEDEFS(AssociativeElement)
SMARTFEATURE_TYPEDEFS(AssociativeCurveVector)
SMARTFEATURE_TYPEDEFS(AssociativeOffsetFace)
SMARTFEATURE_TYPEDEFS(AssociativeFace)
SMARTFEATURE_TYPEDEFS(AssociativeEdge)
SMARTFEATURE_TYPEDEFS(AssociativeIntersection)

#ifdef __SMARTFEATURE_BUILD__
    #define SMARTFEATURE_EXPORT __declspec(dllexport)
#else
    #define SMARTFEATURE_EXPORT __declspec(dllimport)
#endif

#define ASSOCIATIVE_ELEMENT_VERSION 1
#define ELEMENTHANDLERID_AssociativeElementHandler 23006
BEGIN_SMARTFEATURE_NAMESPACE
typedef RefCountedPtr <struct AssociativeElement>           AssociativeElementPtr;
typedef RefCountedPtr <struct AssociativeCurveVector>       AssociativeCurveVectorPtr;
typedef RefCountedPtr <struct AssociativeOffsetFace>        AssociativeOffsetFacePtr;
typedef RefCountedPtr <struct AssociativeFace>              AssociativeFacePtr;
typedef RefCountedPtr <struct AssociativeEdge>              AssociativeEdgePtr;
typedef RefCountedPtr <struct AssociativeIntersection>      AssociativeIntersectionPtr;
//=======================================================================================
// AssociativeElement is a class used to create elements that will react to the changes
// of the parent element they are associated with. For example, extracting a face
// of a solid, and changing the solid, will cause the face to re-generate
//
// This is the base class for AssociativeElements and this should only be used to create
// new types of associative elements
//
// Both solid primitives and smart feature solids can be extracted with these elements
//
// How to use:
// 1. Create a desired associative element (e.g. AssociativeFace::Create(...))
// 2. Use AssociativeElement::CreateAssociativeElement (myNewEeh, &hostEh, destinationModel)
//    this will intitialize your EditElementHandle to carry the XAttribute for the associative
//    elements
// 3. Save the data of the new associative element in your EditElementHandle by calling
//    AssociativeElement::SaveData(myNewEeh, associativeElementPtr)
// 4. Add myNewEeh to the model (e.g. myNewEeh.AddToModel())
//
// @bsistruct                                                   Diego.Pinate    04/17
//=======================================================================================
struct AssociativeElement : RefCountedBase
{
private:
    static bmap<UInt32, IAssociativeElementFactory*> s_factories;

protected:
    virtual bool                    IsCurveVectorType() const { return false; }
    virtual bool                    IsSurfaceType() const { return false; }

    SMARTFEATURE_EXPORT ElementHandle           GetParentElement(ElementHandleCR hostEh, int index = 0) const 
        {
        if (!m_peps[index].EvaluateElementFromHost(hostEh).IsValid())
            {
            //BeAssert(false && "\n --- Invalid parent element of Associative Element");
            //BeConsole::Printf("\n Associative Element id = %d", hostEh.GetElementId());
            }
        return m_peps[index].EvaluateElementFromHost(hostEh);              
        }

    SMARTFEATURE_EXPORT static BentleyStatus    ExtractData(AssociativeElementPtr& associativeElement, ElementHandleCR eh);

    SMARTFEATURE_EXPORT static BentleyStatus    SaveData(EditElementHandleR eeh, AssociativeElementCR associativeElement);

    SMARTFEATURE_EXPORT static bool             IsAssociativeElement(ElementHandleCR eh);

    SMARTFEATURE_EXPORT static void             CreateAssociativeElement(EditElementHandleR newEeh, ElementHandleCP pTemplateEh, DgnModelRefP destinationModelRef);
}; // AssociativeElement

//=======================================================================================
// Used to extract the face from a smart feature or solid primitive
// This type of element generates planar curve vectors only
// @bsistruct                                                   Diego.Pinate    04/17
//=======================================================================================
struct AssociativeFace : AssociativeCurveVector
{
public:
    SMARTFEATURE_EXPORT static AssociativeElementPtr    Create(ElementHandleCR hostEh, FaceId& faceId, UInt32 nodeId = 0) { return new AssociativeFace(hostEh, faceId, nodeId); };
}; // AssociativeFace

//=======================================================================================
// Used to extract edges from a smart feature or solid primitive
// This type of element generates curve vectors only
// @bsistruct                                                   Diego.Pinate    04/17
//=======================================================================================
struct AssociativeEdge : AssociativeCurveVector
{
public:
    SMARTFEATURE_EXPORT static AssociativeElementPtr    Create(ElementHandleCR hostEh, bvector<EdgeId>& edgeIds, UInt32 nodeId = 0) { return new AssociativeEdge(hostEh, edgeIds, nodeId); };
}; // AssociativeEdge

//=======================================================================================
// Used to generate an associative slice of a solid
// This base class will handle slicing and providing a curve vector
// Child classes should handle how to generate the slicing plane so that we can support
// Different types of inputs
// @bsistruct                                                   Diego.Pinate    06/17
//=======================================================================================
struct AssociativeSlice : AssociativeCurveVector
{
    friend struct AssociativeElement;

    AssociativeSlice(UInt32 type) : AssociativeCurveVector(type) { }
    AssociativeSlice(ElementHandleCR hostEh, UInt32 type, UInt32 nodeId) : AssociativeCurveVector(hostEh, type, nodeId) { }
    AssociativeSlice(bvector<ElementHandle> const& dependents, bvector<UInt32> const& nodeIds, UInt32 type) : AssociativeCurveVector(dependents, nodeIds, type) { }
protected:
    virtual BentleyStatus   _ObtainSolidBody (ElementHandleCR hostEh, ISolidKernelEntityPtr& body);
    virtual BentleyStatus   _ObtainPlane(ElementHandleCR hostEh, DPlane3dR plane) const { return ERROR; }
    virtual BentleyStatus   _GetPlaneSheet(ElementHandleCR hostEh,  ISolidKernelEntityPtr& sheetBody);

    virtual BentleyStatus   _GenerateCurveVector(ElementHandleCR hostEh, CurveVectorPtr& curveVector) override;
};

//=======================================================================================
// Used to slice a solid using the direction of a curve and the point as the plane
// @bsistruct                                                   Diego.Pinate    06/17
//=======================================================================================
struct AssociativeSliceOnCurve : AssociativeSlice
{
    friend struct AssociativeElement;

    enum Flags
        {
        USE_DISTANCE = 1 << 0,
        };

protected:
    double                  m_fraction;
    UInt32                  m_flags;

    virtual BentleyStatus   _ExtractData(SmartFeatureDataSource& source) override;
    virtual BentleyStatus   _SaveData(SmartFeatureDataSink& sink) const override;
    virtual BentleyStatus   _ObtainPlane(ElementHandleCR hostEh, DPlane3dR plane) const override;

    bool                    IsDefinedByDistance() const { return ((m_flags & USE_DISTANCE) != 0); }

    virtual bool    IsCurveVectorType() const override { return true; }
    virtual bool    IsSurfaceType() const override { return true; }

    AssociativeSliceOnCurve() : AssociativeSlice((UInt32)AssociativeElementType::SliceOnCurve) { }
    AssociativeSliceOnCurve(bvector<ElementHandle> const& dependents, bvector<UInt32> const& nodeIds, double distance, UInt32 flags);

public:
    SMARTFEATURE_EXPORT static AssociativeElementPtr    Create(ElementHandleCR solidEh, ElementHandleCR pathEh, double fractionOrDistance, UInt32 nodeId, UInt32 flags);
};

//=======================================================================================
// Used to extract faces from solid primitives or smart features, they can be non-planar
// This type of element may generate curve vectors, bspline surfaces or solid primitive
// faces
// @bsistruct                                                   Diego.Pinate    04/17
//=======================================================================================
struct  AssociativeOffsetFace : AssociativeElement
{
public:
    double  GetOffset ()                { return m_offset; }
    void    SetOffset(double offset)    { m_offset = offset; }

   
    SMARTFEATURE_EXPORT static AssociativeElementPtr    Create(ElementHandleCR hostEh, FaceId id, UInt32 nodeId, UInt32 geomType, double offset = 0.0) { return new AssociativeOffsetFace(hostEh, id, nodeId,offset, geomType); }

    
}; // AssociativeOffsetFace

public:
        double  GetOffset() { return m_offset; }
        void    SetOffset(double offset) { m_offset = offset; }

        SMARTFEATURE_EXPORT static AssociativeElementPtr    Create(ElementHandleCR hostEh, FaceId id, UInt32 nodeId, double offset = 0.0) { return new AssociativeOffsetCurveVector(hostEh, id, nodeId, offset); }
}; 

END_SMARTFEATURE_NAMESPACE