ElementAgenda.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

typedef struct IDataObject    GuiDataObject;

#include <Bentley/bvector.h>
#include <Bentley/bset.h>
#include "ElementHandle.h"

DGNPLATFORM_TYPEDEFS (IModifyElement)
DGNPLATFORM_TYPEDEFS (IRedrawOperation)
DGNPLATFORM_TYPEDEFS (IRedrawAbort)

BEGIN_BENTLEY_DGNPLATFORM_NAMESPACE

enum class ModifyElementSource
{
    Selected         = 0,    
    SelectionSet     = 1,    
    Fence            = 2,    
    WorkingSet       = 3,    
    GraphicGroup     = 4,    
    NamedGroup       = 5,    
    DragSelection    = 6,    
    Unknown          = 10,   
};

struct  IElementAgendaEvents;

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
template <class T_ElemHandle> class ElemHandleArray : public bvector<T_ElemHandle>
{
public:
    bool                    IsEmpty ()          const   {return this->empty();}
    size_t                  GetCount ()         const   {return this->size();}
    T_ElemHandle const*     GetFirst ()         const   {return IsEmpty() ? NULL : &this->front();}
    T_ElemHandle const*     GetLast ()          const   {return IsEmpty() ? NULL : &this->back();}
    T_ElemHandle const*     GetEntry (size_t i) const   {return (i >= GetCount()) ? NULL : &this->front()+i;}
    T_ElemHandle*           GetFirstP ()                {return IsEmpty() ? NULL : &this->front();}
    T_ElemHandle*           GetLastP ()                 {return IsEmpty() ? NULL : &this->back();}
    T_ElemHandle*           GetEntryP (size_t i)        {return (i >= GetCount()) ? NULL : &this->front()+i;}
    void                    Empty (bool andFree=true)   {if (andFree) this->clear(); else this->resize (0);}
    DEFINE_T_SUPER(bvector<T_ElemHandle>);
    typedef typename T_Super::iterator iterator;

    void DropInvalidEntries ()
        {
        if (IsEmpty())
            return;

        iterator curr = this->begin();   // first entry
        iterator endIt = this->end();    // one past the last entry
        iterator nextValid = curr; // where next valid entry should go

        for (; curr != endIt; ++curr)
            {
            if (curr->IsValid ())
                {
                if (nextValid != curr)
                    *nextValid = *curr;
                ++nextValid;
                }
            }

        if (nextValid != endIt)
            this->erase (nextValid, endIt);
        }
};

struct RedrawGroupInfo
{
public:

enum class GroupEvent
    {
    OnGroupInit          = 0, 
    IsElementInGroup     = 1, 
    OnPostModifyElement  = 2, 
    OnPostModifyGroup    = 3, 
    OnGroupComplete      = 4, 
    };

private:
    virtual void MakeClassAbstract() = 0;
public:
public:

DGNPLATFORM_EXPORT GroupEvent GetEventType () const;
DGNPLATFORM_EXPORT ViewContextR GetViewContext () const;
DGNPLATFORM_EXPORT ElementRefP GetOriginalElement () const;
DGNPLATFORM_EXPORT ElementHandleCP GetModifiedElement () const;

}; // RedrawGroupInfo

struct     IElementAgendaEvents
{
    virtual bool _DoModifyAgendaEntries (ElementAgendaP agenda, AgendaOperation, AgendaModify) {return false;}

    virtual void _OnPreCopyAgenda (ElementAgendaCP agenda, AgendaOperation, AgendaModify, ElementCopyContextP) {};

    virtual void _OnPreModifyAgenda (ElementAgendaCP agenda, AgendaOperation, AgendaModify, bool isGroupOperation) {};

    virtual void _OnPostModifyAgenda (ElementAgendaCP agenda, AgendaOperation, AgendaModify, bool isGroupOperation) {};

    virtual void _DoAddDeferredClipboardFormats (ElementAgendaP, AgendaOperation, AgendaModify, GuiDataObject*) {}

    virtual bool _OnRedrawGroupEvent (ElementAgendaCP, AgendaOperation, AgendaModify, RedrawGroupInfo const*) {return false;}

    virtual bool Dummy1 (void*) {return false;}
};

struct ElemAgendaEntry : EditElementHandle
{
public:
    ElemAgendaEntry() {}
    ElemAgendaEntry (ElementRefP elRef, DgnModelRefP modelRef)  : EditElementHandle (elRef, modelRef) {}
    ElemAgendaEntry (ElementHandleCR from, bool duplicateDescr) : EditElementHandle (from, duplicateDescr) {}
    ElemAgendaEntry (ElemAgendaEntry const& from) {CopyFrom(from);}

    ElemAgendaEntry& operator= (ElemAgendaEntry const& from)
        {
        if (this == &from)
            return *this;

        ClearAll();
        return (ElemAgendaEntry&) CopyFrom (from);
        }

    static intptr_t  GetIndexFromHandleDifference (ElementHandleCP pToolElem, const ElemAgendaEntry* first)
        {
        //-------------------------------------------------------------------------------------
        // NEEDSWORK_VS2012 - Without the type-cast, we get this error with VS2012
        // error C2440: '-' : cannot convert from 
        //    'const Bentley::DgnPlatform::ElemAgendaEntry *' to 'Bentley::EditElementHandleCP'
        //-------------------------------------------------------------------------------------
        return pToolElem - static_cast<ElementHandleCP> (first);
        }

};

enum class AgendaHilitedState
{
    Unknown  = 0,    
    Yes      = 1,    
    No       = 2,    
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  ElemModelPair
{
private:
    ElementRefP      m_elem;
    DgnModelRefP    m_modelRef;
public:
    ElemModelPair () {m_elem = NULL, m_modelRef = NULL;}
    ElemModelPair (ElementRefP el, DgnModelRefP modelRef) {m_elem = el, m_modelRef = modelRef;}
    ElementRefP GetElementRef () const {return m_elem;}
    DgnModelRefP GetModelRef() const {return m_modelRef;}
    bool IsLess (ElemModelPair const& other) const {return (m_modelRef == other.m_modelRef) ? (m_elem<other.m_elem) : (m_modelRef<other.m_modelRef);}
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  ElemModelCompare {bool operator()(ElemModelPair const& a, ElemModelPair const& b) const {return a.IsLess(b);}};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct  ElemModelPairSet : bset<ElemModelPair, ElemModelCompare>
{
    void Add (ElementRefP el, DgnModelRefP modelRef) {insert (ElemModelPair(el, modelRef));}
};


typedef ElemHandleArray<ElemAgendaEntry>      T_AgendumVector;
//=======================================================================================
//  @bsiclass                                                     Bentley Systems
//=======================================================================================
struct ElementAgenda : RefCounted <T_AgendumVector>
{
private:
    ModifyElementSource m_source;
    AgendaHilitedState  m_hilitedState;

public:

DGNPLATFORM_EXPORT ElementAgenda();
DGNPLATFORM_EXPORT virtual ~ElementAgenda();

    DGNVIEW_EXPORT void Draw (ViewportP viewport, DgnDrawMode drawMode, DrawPurpose drawPurpose, IRedrawOperationP redrawOp, ClipVectorCP clip, IRedrawAbortP abort);

    DGNVIEW_EXPORT void DrawInAllViews (DgnDrawMode drawMode, DrawPurpose drawPurpose, IRedrawOperationP redrawOp, ClipVectorCP clip, IRedrawAbortP abort);

    DGNVIEW_EXPORT void Clear ();

    void SetCapacity (int nEntries) {reserve (nEntries);}

    ModifyElementSource GetSource () const {return m_source;}

    void SetSource (ModifyElementSource val) {m_source = val;}

    DGNPLATFORM_EXPORT EditElementHandleCP Find (ElementRefP elRef, DgnModelRefP modelRef, size_t startIndex=0, size_t endIndex=-1) const;

    DGNPLATFORM_EXPORT EditElementHandleP Insert (EditElementHandleR eeh, bool atHead = false);

    DGNPLATFORM_EXPORT EditElementHandleP Insert (ElementRefP elRef, DgnModelRefP modelRef, bool atHead=false);

    DGNVIEW_EXPORT EditElementHandleP InsertPath (DisplayPathCP path, bool doGroups, bool allowLocked);

    DGNPLATFORM_EXPORT EditElementHandleP InsertPath (DisplayPathCP path, bool doGroups, bool groupLockState, bool allowLocked);

    DGNPLATFORM_EXPORT void Insert (ElemModelPairSet& pairSet);

    DGNVIEW_EXPORT StatusInt ModifyAgenda (IModifyElementP modifyOp, bool redraw);

    DGNVIEW_EXPORT StatusInt BuildFromElementSet (IElementSetP elementSet, ModifyElementSource source);

    DGNVIEW_EXPORT StatusInt BuildFromFence (DgnModelRefP fenceModel, DgnModelRefListP modelRefs, bool overlap, bool modifyOrig, bool allowLocked, bool callAsynchs);

    DGNPLATFORM_EXPORT void BuildFromViewport (ViewportR viewPort);

    DGNVIEW_EXPORT void Hilite ();

    DGNVIEW_EXPORT void ClearHilite ();

    MSCORE_EXPORT static void AddListener (IElementAgendaEvents* agendaListener);

    MSCORE_EXPORT static void DropListener (IElementAgendaEvents* agendaListener);
};

/*=================================================================================**/
struct          IDrawElementAgenda
{
private:
    virtual void _DrawElementAgenda (ElementAgendaR agenda, DgnDrawMode drawMode, DrawPurpose purpose) = 0;
public:
    DGNPLATFORM_EXPORT void DrawElementAgenda (ElementAgendaR agenda, DgnDrawMode drawMode, DrawPurpose purpose);
}; // IDrawElementAgenda

END_BENTLEY_DGNPLATFORM_NAMESPACE