GME: Builder.h Source File

00001 #define BUILDER_CAST(CLASS,PTR) (DYNAMIC_DOWNCAST(CLASS,PTR))
00002 
00003 #ifndef GME_BUILDER_H
00004 #define GME_BUILDER_H
00005 
00006 #include "GMECOM.h"
00007 #include "ComHelp.h"
00008 #include "Mga.h"
00009 
00010 class CBuilder;
00011 class CBuilderFolder;
00012 class CBuilderObject;
00013 class CBuilderModel;
00014 class CBuilderAtom;
00015 class CBuilderReference;
00016 class CBuilderModelReference;
00017 class CBuilderAtomReference;
00018 class CBuilderReferencePort;
00019 class CBuilderConnection;
00020 class CBuilderSet;
00021 
00022 typedef CTypedPtrList<CPtrList, CBuilderFolder*>                                                                CBuilderFolderList;
00023 typedef CTypedPtrList<CPtrList, CBuilderObject*>                                                                CBuilderObjectList;
00024 typedef CTypedPtrList<CPtrList, CBuilderModel*>                                                                 CBuilderModelList;
00025 typedef CTypedPtrList<CPtrList, CBuilderAtom*>                                                                  CBuilderAtomList;
00026 typedef CTypedPtrList<CPtrList, CBuilderReference*>                                                             CBuilderReferenceList;
00027 typedef CTypedPtrList<CPtrList, CBuilderAtomReference*>                                                 CBuilderAtomReferenceList;
00028 typedef CTypedPtrList<CPtrList, CBuilderModelReference*>                                                CBuilderModelReferenceList;
00029 typedef CTypedPtrList<CPtrList, CBuilderReferencePort*>                                                 CBuilderReferencePortList;
00030 typedef CTypedPtrList<CPtrList, CBuilderConnection*>                                                    CBuilderConnectionList;
00031 typedef CTypedPtrList<CPtrList, CBuilderSet*>                                                                   CBuilderSetList;
00032 
00033 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderModelList *>                             CBuilderModelListTable;
00034 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderAtomList *>                              CBuilderAtomListTable;
00035 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderReferenceList *>                 CBuilderReferenceListTable;
00036 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderAtomReferenceList *>             CBuilderAtomReferenceListTable;
00037 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderModelReferenceList *>    CBuilderModelReferenceListTable;
00038 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderConnectionList *>                CBuilderConnectionListTable;
00039 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderSetList *>               CBuilderSetListTable;
00040 
00041 typedef CBuilderModel* (*CBuilderModelCreateFunction)(IMgaModel *iModel, CBuilderModel *parent);
00042 typedef CBuilderReference* (*CBuilderRefCreateFunction)(IMgaReference *iRef, CBuilderModel *parent);
00043 typedef CBuilderModelReference* (*CBuilderModelRefCreateFunction)(IMgaReference *iModelRef, CBuilderModel *parent);
00044 typedef CBuilderAtom* (*CBuilderAtomCreateFunction)(IMgaAtom *iAtom, CBuilderModel *parent);
00045 typedef CBuilderAtomReference* (*CBuilderAtomRefCreateFunction)(IMgaReference *iAtomRef, CBuilderModel *parent);
00046 typedef CBuilderConnection* (*CBuilderConnectionCreateFunction)(IMgaSimpleConnection *iConnection, CBuilderModel *parent);
00047 typedef CBuilderSet* (*CBuilderSetCreateFunction)(IMgaSet *iSet, CBuilderModel *parent);
00048 
00049 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderModelCreateFunction> CBuilderModelCreateFunctionTable;
00050 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderAtomCreateFunction> CBuilderAtomCreateFunctionTable;
00051 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderRefCreateFunction> CBuilderRefCreateFunctionTable;
00052 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderModelRefCreateFunction> CBuilderModelRefCreateFunctionTable;
00053 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderAtomRefCreateFunction> CBuilderAtomRefCreateFunctionTable;
00054 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderConnectionCreateFunction> CBuilderConnectionCreateFunctionTable;
00055 typedef CTypedPtrMap<CMapStringToPtr, CString, CBuilderSetCreateFunction> CBuilderSetCreateFunctionTable;
00056 
00057 typedef CMap<IUnknown*, IUnknown*, CBuilderObject*, CBuilderObject*> CBuilderObjectLookupTable;
00058 typedef CMap<IUnknown*, IUnknown*, CBuilderConnection*, CBuilderConnection*> CBuilderConnectionLookupTable;
00059 typedef CMap<IUnknown*, IUnknown*, CBuilderReferencePort*, CBuilderReferencePort*> CBuilderReferencePortLookupTable;
00060 
00061 typedef CMap<CString, LPCTSTR, CString, LPCTSTR> CStringMap;
00062 
00063 typedef CBuilderObject CBuilderAtomicObject;
00064 typedef CBuilderObjectList CBuilderAtomicObjectList;
00065 
00066 enum editormodes { DEFAULT } ;
00067 typedef enum editormodes EditorModes;
00068 
00069 class CBuilder : public CObject {
00070         DECLARE_DYNAMIC(CBuilder)
00071         friend class CBuilderFolder;
00072 public:
00073         CBuilder(IMgaProject* iGme, CStringMap *pmp = NULL);
00074         virtual ~CBuilder();
00075 protected:
00076         CComPtr<IMgaFolder> ciRootFolder;
00077         CComPtr<IMgaProject> ciGme;
00078         CComPtr<IMgaTerritory> ciTerr;
00079         CBuilderFolderList folders;
00080         CBuilderFolder *rootfolder;
00081 
00082         CBuilderObjectLookupTable objectmap;
00083         CBuilderConnectionLookupTable connectionmap;
00084 
00085         CStringMap *parametermap;
00086 
00087 public:
00088         static CBuilder* theInstance;
00089 
00090         IMgaProject* GetProject() const { return ciGme; }
00091 
00092         void SetObjectRef(IMgaFCO* i, CBuilderObject* o);
00093         void SetConnectionRef(IMgaSimpleConnection* i, CBuilderConnection* o);
00094 
00095         CBuilderObject* FindObject(IMgaFCO* i);
00096         CBuilderConnection* FindConnection(IMgaSimpleConnection* i);
00097 
00098         void ForgetObjectRef(IMgaFCO* i);
00099         void ForgetConnectionRef(IMgaSimpleConnection* i);
00100 
00101         CString GetParameter(CString name);
00102         bool PutParameter(CString name, CString value);
00103 
00104         EditorModes GetEditorMode() const;
00105         void SetEditorMode(EditorModes mode);
00106 
00107         bool BeginTransaction(transactiontype_enum mode = TRANSACTION_GENERAL);
00108         bool CommitTransaction();
00109         void AbortTransaction();
00110 
00111 public:
00112         const CBuilderFolderList *GetFolders() const                    { return &folders; }
00113         CBuilderFolder *GetFolder(CString name) const;
00114         CBuilderFolder *GetRootFolder() const                                   { return rootfolder; }
00115         CString GetProjectName() const;
00116 };
00117 
00118 class CBuilderFolder : public CObject {
00119         DECLARE_DYNAMIC(CBuilderFolder)
00120         friend class CBuilder;
00121         friend class CBuilderModel;
00122 public:
00123         CBuilderFolder(IMgaFolder *iFolder, CBuilderFolder *parent);
00124         virtual ~CBuilderFolder();
00125 protected:
00126         CComPtr<IMgaFolder> ciFolder;
00127         CBuilderModelList rootModels;
00128         CBuilderObjectList rootObjects;
00129         CBuilderFolderList subfolders;
00130         CBuilderFolder  *parentfolder;
00131         CString name;
00132         CString kindName;
00133         CString kindTitle;
00134 
00135 
00136         void Resolve();
00137         void RemoveRootModel(CBuilderModel *model);
00138 
00139 public:
00140         IMgaFolder* GetIFolder() const                                          { return ciFolder; }
00141         CComPtr<IMgaMetaFolder> GetMeta() const;
00142 public:
00143         const CString& GetName() const { return name; }
00144         const CString& GetKindName() const                                                      { return kindName; }    // returns folder kind name
00145         const CString& GetKindTitle() const                                                     { return kindTitle; }   // returns folder kind title (displayed name)
00146         const CBuilderModelList *GetRootModels() const                          { return &rootModels; }
00147         const CBuilderObjectList *GetRootObjects() const                                { return &rootObjects; }
00148         const CBuilderFolderList *GetSubFolders() const                         { return &subfolders; }
00149         CBuilderModel *GetRootModel(CString name) const;
00150         CBuilderModel *CreateNewModel(CString kindName, CBuilderModel* baseType = NULL, bool instance = true);
00151         CBuilderFolder *CreateNewFolder(CString kindName);
00152         CBuilderAtom  *CreateNewAtom(CString kindName, CBuilderAtom* baseType = NULL, bool instance = true);
00153         CBuilderModelReference *CreateNewModelReference(CString kindName, CBuilderObject* refTo);
00154         CBuilderAtomReference *CreateNewAtomReference(CString kindName, CBuilderObject* refTo);
00155         CBuilderReference *CreateNewReference(CString kindName, CBuilderObject* refTo, CBuilderReference* baseType = NULL, bool instance = true);
00156         CBuilderConnection *CreateNewConnection(CString kindName, CBuilderObject *src, CBuilderObject *dst);
00157         CBuilderSet *CreateNewSet(CString kindName, CBuilderSet* baseType = NULL, bool instance = true);
00158         bool GetRegistryValue(CString &path,CString &val) const;
00159         bool SetRegistryValue(CString &path,CString &val) const;
00160 };
00161 
00162 class CBuilderObject : public CObject {
00163         DECLARE_DYNAMIC(CBuilderObject)
00164         friend class CBuilderModel;
00165         friend class CBuilderAtom;
00166         friend class CBuilderReference;
00167         friend class CBuilderAtomReference;
00168         friend class CBuilderReferencePort;
00169         friend class CBuilderModelReference;
00170         friend class CBuilderConnection;
00171         friend class CBuilderSet;
00172 public:
00173         typedef enum { OBJNULL = OBJTYPE_NULL,
00174                    MODEL =       OBJTYPE_MODEL,
00175                    ATOM =        OBJTYPE_ATOM,
00176                    REFERENCE    = OBJTYPE_REFERENCE,
00177                    CONNECTION   = OBJTYPE_CONNECTION,
00178                    SET                  = OBJTYPE_SET} objtype;
00179 
00180 public:
00181         virtual ~CBuilderObject();
00182         virtual void Destroy();
00183 protected:
00184         virtual void Initialize() { }
00185         CBuilderObject(IMgaFCO *iObject, CBuilderModel *parent, bool globalregister = true);
00186 
00187         CComPtr<IMgaFCO> ciObject;
00188         CBuilderModel *parent;
00189         CBuilderConnectionListTable inConnections;
00190         CBuilderConnectionListTable outConnections;
00191         CBuilderConnectionListTable inConnections2;
00192         CBuilderConnectionListTable outConnections2;
00193         CString name;
00194         CString kindName;
00195         CString kindTitle;
00196         CString partName;
00197 
00198         void DisplayMessage(CString &msg,bool error) const;
00199         void CreateOutConnections();
00200         void AddInConnection(CString &name,CBuilderConnection *conn);
00201         void AddOutConnection(CString &name,CBuilderConnection *conn);
00202         void AddPortInConnection(CString &name,CBuilderConnection *conn);
00203         void AddPortOutConnection(CString &name,CBuilderConnection *conn);
00204         CBuilderConnectionList *FindInConnections(const CString &name) const;
00205         CBuilderConnectionList *FindOutConnections(const CString &name) const;
00206         void RemoveInConnection(CBuilderConnection *conn);
00207         void RemoveOutConnection(CBuilderConnection *conn);
00208 
00209         bool GetDirectConnections(const CString &name, CBuilderObjectList &list, bool in);
00210 
00211         virtual void Resolve() = 0; //                                                                          { ASSERT(false); }
00212 public:
00213         IMgaFCO* GetIObject() const                                                             { return ciObject; }
00214         long GetObjId() const;
00215         objtype GetObjType() const;
00216 
00217         const CString& GetName() const                                                          { return name; }
00218         const CString& GetKindName() const                                                      { return kindName; }    // returns model kind name, e.g. "Compound"
00219         const CString& GetKindTitle() const                                                     { return kindTitle; }   // returns model kind title, e.g. "Compound"
00220         const CString& GetPartName() const                                                      { return partName; }    // returns model part name, e.g. "CompoundParts"
00221         void GetNamePath(CString &namePath) const;                                      // makes "__" separated list of names of all ascendants
00222         void GetExtendedName(CString &extName,CString separator,bool startWithRoot) const; // makes "separator" separated list of names of all ascendants in specified order
00223         const CBuilderModel *GetParent() const                                          { return parent; }
00224         bool GetLocation(CString &aspectName,CRect &loc);
00225         bool SetLocation(CString aspectName,CPoint loc);
00226         short GetNamePosition();
00227         void SetNamePosition(short pos);
00228         CBuilderFolder* GetFolder() const;
00229         void DisplayError(CString &msg)  const                                          { DisplayMessage(msg,true); }
00230         void DisplayError(char *msg) const                                                      { DisplayMessage(CString(msg),true); }
00231         void DisplayWarning(CString &msg) const                                         { DisplayMessage(msg,false); }
00232         void DisplayWarning(char *msg) const                                            { DisplayMessage(CString(msg),false); }
00233 
00234         virtual void TraverseChildren(void *pointer = 0)                        { }
00235 
00236         bool GetRegistryValue(CString &path,CString &val) const;
00237         bool SetRegistryValue(CString &path,CString &val) const;
00238 
00239         bool GetAttribute(CString &name,CString &val) const;
00240         bool GetAttribute(char *name,CString &val) const                        { return GetAttribute(CString(name),val); }
00241         bool GetAttribute(CString &name,int &val) const;
00242         bool GetAttribute(char *name,int &val) const                            { return GetAttribute(CString(name),val); }
00243         bool GetAttribute(CString &name,bool &val) const;
00244         bool GetAttribute(char *name,bool &val) const                           { return GetAttribute(CString(name),val); }
00245         bool GetAttribute(CString &name,double &val) const;
00246         bool GetAttribute(char *name,double &val) const                         { return GetAttribute(CString(name),val); }
00247         bool GetAttribute(CString &name,CBuilderObject *&val) const;
00248         bool GetAttribute(char *name,CBuilderObject *&val) const        { return GetAttribute(CString(name),val); }
00249         int  GetAttributeStatus(CString attrName);                                      // See Mga.idl for ATTSTATUS enum values
00250 
00251         bool SetAttribute(CString &name, CString &val);
00252         bool SetAttribute(CString &name, int val);
00253         bool SetAttribute(CString &name, bool val);
00254         bool SetAttribute(CString &name, double val);
00255         bool SetAttribute(CString &name, CBuilderObject *val);
00256 
00257         void GetAttributeNames(CStringList &list, attval_enum type, attval_enum sectype = ATTVAL_NULL) const;
00258         void GetStrAttributeNames(CStringList &list) const;
00259         void GetIntAttributeNames(CStringList &list) const;
00260         void GetBoolAttributeNames(CStringList &list) const;
00261         void GetFloatAttributeNames(CStringList &list) const;
00262         void GetRefAttributeNames(CStringList &list) const;
00263 
00264 
00265         bool SetName(CString newname);
00266 
00267         bool IsMarked();
00268         void Mark(bool marked);
00269 
00270         const CBuilderConnectionList *GetInConnections(const CString &name, bool bPorts = true ) const;
00271         const CBuilderConnectionList *GetInConnections(char *name, bool bPorts = true ) const           { return GetInConnections(CString(name), bPorts ); }
00272         const CBuilderConnectionList *GetOutConnections(const CString &name, bool bPorts = true ) const;
00273         const CBuilderConnectionList *GetOutConnections(char *name, bool bPorts = true ) const          { return GetOutConnections(CString(name), bPorts ); }
00274         void GetReferencedBy(CBuilderObjectList &list) const;                   // references which point to this object
00275         void GetMemberOfSets(CBuilderObjectList &list) const;                   // sets which contain this object
00276 
00277         bool GetInConnectedObjects(const CString &name, CBuilderObjectList &list, bool bPorts = true );
00278         bool GetInConnectedObjects(const char *name, CBuilderObjectList &list, bool bPorts = true ) { return GetInConnectedObjects(CString(name), list, bPorts ); }
00279         bool GetOutConnectedObjects(const CString &name, CBuilderObjectList &list, bool bPorts = true );
00280         bool GetOutConnectedObjects(const char *name, CBuilderObjectList &list, bool bPorts = true ) { return GetOutConnectedObjects(CString(name), list, bPorts ); }
00281 
00282         bool GetDirectInConnections(const CString &name, CBuilderObjectList &list) { return GetDirectConnections(name, list, true); }
00283         bool GetDirectInConnections(const char *name, CBuilderObjectList &list) { return GetDirectConnections(CString(name), list, true); }
00284         bool GetDirectOutConnections(const CString &name, CBuilderObjectList &list) { return GetDirectConnections(name, list, false); }
00285         bool GetDirectOutConnections(const char *name, CBuilderObjectList &list) { return  GetDirectConnections(CString(name), list, false); }
00286 
00287         const CBuilderConnectionListTable &GetInConnections() const                             { return inConnections; }
00288         const CBuilderConnectionListTable &GetOutConnections() const                    { return outConnections; }
00289 
00290         CComPtr<IMgaMetaFCO> GetMeta() const;
00291 
00292 //      Additions:
00293         bool IsInstance();
00294         CBuilderObject *GetType();     //  or NULL, if it is an instance
00295         CBuilderObject *GetDerivedFrom();     //  or NULL, if it does not have immediate parent
00296 
00297         void GetDerivedObjects(CBuilderObjectList &, int mode = 0);     //  mode is 0 for both, 1 for subtypes only, 2 for instances
00298 };
00299 
00300 class CBuilderModel : public CBuilderObject {
00301         DECLARE_DYNAMIC(CBuilderModel)
00302         friend class CBuilder;
00303         friend class CBuilderFolder;
00304         friend class CBuilderObject;
00305         friend class CBuilderReference;
00306         friend class CBuilderModelReference;
00307         friend class CBuilderFactory;
00308         friend class CBuilderAtom;
00309         friend class CBuilderAtomReference;
00310         friend class CBuilderConnection;
00311         friend class CBuilderSet;
00312 public:
00313         virtual ~CBuilderModel();
00314         virtual void Destroy();
00315 protected:
00316         CBuilderModel(IMgaModel *iModel, CBuilderModel *parent);
00317 
00318         CBuilderObjectList children;
00319         CBuilderConnectionList connchildren;
00320         CBuilderModelList models;
00321         CBuilderModelListTable modelLists;
00322         CBuilderAtomListTable atomLists;
00323         CBuilderReferenceListTable referenceLists;
00324         CBuilderModelReferenceListTable modelReferenceLists;
00325         CBuilderAtomReferenceListTable atomReferenceLists;
00326         CBuilderConnectionListTable connectionLists;
00327         CBuilderSetList sets;
00328         CBuilderSetListTable setLists;
00329 
00330         void CreateModels();
00331         void CreateAtoms();
00332         void CreateReferences();
00333         void CreateConnections();
00334         void CreateSets();
00335         void MapPortsToAtoms();
00336         void Resolve();
00337         CBuilderConnection *AddConnection(IMgaSimpleConnection *iConnection);
00338         CBuilderSet *AddSet(IMgaSet *iSet);
00339         CBuilderConnectionList *FindConnections(CString name) const;
00340         CBuilderSetList *FindSets(CString name) const;
00341         void RemoveModel(CBuilderModel *model);
00342         void RemoveAtom(CBuilderAtom *atom);
00343 
00344         void RemoveReference(CBuilderReference *atomref);
00345         void RemoveModelReference(CBuilderModelReference *modelref);
00346         void RemoveAtomReference(CBuilderAtomReference *atomref);
00347 
00348         void RemoveConnection(CBuilderConnection *conn);
00349         void RemoveSet(CBuilderSet *cond);
00350 
00351         void RemoveMemberFromSets(CBuilderObject *part);
00352 
00353 public:
00354         IMgaModel* GetIModel() const { return CComQIPtr<IMgaModel>(ciObject); }
00355 
00356         const CBuilderObjectList *GetChildren() const                           { return &children; }   // return list of all models and parts
00357         const CBuilderModelList *GetModels() const                              { return &models; }             // return list of (non-atomic) models only
00358         const CBuilderModelList *GetModels(CString partName) const;                                                     // you supply partname, returns list of one kind of models, e.g. "CompoundParts"
00359         const CBuilderAtomList *GetAtoms(CString partName) const;                                                       // you supply partname, returns list of one kind of models, e.g "InputSignals"
00360         const CBuilderModelReferenceList *GetModelReferences(CString refPartName) const;        // you supply partname, returns list of one kind of references, e.g. "CompoundRefs"
00361         const CBuilderAtomReferenceList *GetAtomReferences(CString refPartName) const;          // you supply partname, returns list of one kind of references, e.g. "InputSignalReferences"
00362         const CBuilderReferenceList *GetReferences(CString refPartName) const;              // you supply partname, returns list matching refs no matter what the target is (including null)
00363         const CBuilderConnectionList *GetConnections(CString name) const        { return FindConnections(name); } // returns list of one kind of connections, e.g. "Dataflow"
00364         const CBuilderSetList *GetSets(CString name) const      { return FindSets(name); } // returns list of one kind of sets, e.g. "StateDep"
00365         const CBuilderSetList *GetSets() const                          { return &sets; } // returns list of all sets
00366 
00367         virtual void TraverseModels(void *pointer = 0);                          // traverse user defined models
00368         virtual void TraverseChildren(void *pointer = 0);                        // traverse all models (atoms, references etc.)
00369 
00370         void Open();
00371         bool IsOpened();
00372         bool Close(bool withchildren = false);
00373 
00374         void GetSelection(CBuilderObjectList &list);
00375         void SelectionRemoveAll() const;
00376         void SelectionRemove(CBuilderObjectList& list) const;
00377         void SelectionRemove(CBuilderObject* object) const;
00378         void SelectionAdd(CBuilderObjectList& list) const;
00379         void SelectionAdd(CBuilderObject* object) const;
00380         void SelectionSet(CBuilderObjectList& list) const { SelectionRemoveAll(); SelectionAdd(list); }
00381         void SelectionSet(CBuilderObject* object) const { SelectionRemoveAll(); SelectionAdd(object); }
00382 
00383         void SetCurrentAspect(CString& aspect);
00384         CString GetCurrentAspect();
00385         void GetAspectNames(CStringList &list);
00386 
00387         CBuilderObject *CloneHere( CBuilderObject* orig);
00388 
00389         CBuilderModel *CreateNewModel(CString partName, CBuilderModel* baseType = NULL, bool instance = true);
00390         CBuilderAtom  *CreateNewAtom(CString patrName, CBuilderAtom* baseType = NULL, bool instance = true);
00391         CBuilderModelReference *CreateNewModelReference(CString refPartName, CBuilderObject* refTo);
00392         CBuilderAtomReference *CreateNewAtomReference(CString refPartName, CBuilderObject* refTo);
00393         CBuilderReference *CreateNewReference(CString refPartName, CBuilderObject* refTo, CBuilderReference* baseType = NULL, bool instance = true);
00394         CBuilderConnection *CreateNewConnection(CString connName, CBuilderObject *src, CBuilderObject *dst);
00395         CBuilderSet *CreateNewSet(CString condName, CBuilderSet* baseType = NULL, bool instance = true);
00396 };
00397 
00398 class CBuilderAtom : public CBuilderObject {
00399         DECLARE_DYNAMIC(CBuilderAtom)
00400         friend class CBuilderObject;
00401         friend class CBuilderModel;
00402         friend class CBuilderFactory;
00403 public:
00404         virtual ~CBuilderAtom();
00405 protected:
00406         CBuilderAtom(IMgaAtom *iAtom, CBuilderModel *parent);
00407 
00408         void Resolve();
00409 
00410 public:
00411         IMgaAtom* GetIAtom() const { return CComQIPtr<IMgaAtom>(ciObject); }
00412 };
00413 
00414 
00415 class CBuilderReferencePort : public CBuilderObject {
00416         DECLARE_DYNAMIC(CBuilderReferencePort)
00417         friend class CBuilderModelReference;
00418 public:
00419         virtual ~CBuilderReferencePort() {}
00420 protected:
00421         CBuilderReferencePort(IMgaFCO *iPort, CBuilderModelReference *o);
00422 
00423         CBuilderObject *portobj;
00424         CBuilderModelReference *owner;
00425         void Resolve();
00426 
00427 public:
00428         const CBuilderModelReference * GetOwner() const { return owner; }
00429         const CBuilderAtom * GetAtom() const                            {  return BUILDER_CAST(CBuilderAtom, portobj); }
00430         const CBuilderObject * GetPortObject() const                            { return portobj; }
00431 };
00432 
00433 class CBuilderReference : public CBuilderObject {
00434         DECLARE_DYNAMIC(CBuilderReference)
00435         friend class CBuilderObject;
00436         friend class CBuilderModel;
00437         friend class CBuilderConnection;
00438         friend class CBuilderFactory;
00439         friend class CBuilderReferencePort;
00440 public:
00441         CBuilderReference(IMgaReference *iRef, CBuilderModel *parent);
00442         ~CBuilderReference();
00443 protected:
00444         CBuilderObject *ref;
00445 
00446         void Resolve();
00447 
00448 public:
00449         IMgaReference* GetIRef() const { return CComQIPtr<IMgaReference>(ciObject); }
00450         const CBuilderObject *GetReferred() const       { return ref; }
00451         bool PutReferred(CBuilderObject *nref);
00452         const CBuilderObject::objtype GetReferredType() const;
00453 };
00454 
00455 
00456 class CBuilderModelReference : public CBuilderReference {
00457         DECLARE_DYNAMIC(CBuilderModelReference)
00458         friend class CBuilderObject;
00459         friend class CBuilderModel;
00460         friend class CBuilderConnection;
00461         friend class CBuilderFactory;
00462         friend class CBuilderReferencePort;
00463 public:
00464         virtual ~CBuilderModelReference();
00465         virtual void Destroy();
00466 protected:
00467         CBuilderModelReference(IMgaReference *iModelRef, CBuilderModel *parent);
00468 public:
00469 
00470 protected:
00471         CBuilderReferencePortLookupTable objectmap;
00472         CBuilderReferencePortList refPorts;
00473 
00474         void CreateReferencePorts();
00475         void Resolve();
00476         void CreateConnections();
00477         IMgaObject *GetPort(CString aspectName,CBuilderReferencePort *port) const;
00478         CBuilderReferencePort *FindPortRef(IMgaFCO *search) const;
00479         void SetPortRef(IMgaFCO *search, CBuilderReferencePort *tgt);
00480         void ForgetPortRef(IMgaFCO* i);
00481 
00482 public:
00483         IMgaReference* GetIModelRef() const { return GetIRef(); }
00484 
00485         const CBuilderReferencePortList &GetRefereePorts() const        { return refPorts; }
00486 };
00487 
00488 class CBuilderAtomReference : public CBuilderReference {
00489         DECLARE_DYNAMIC(CBuilderAtomReference)
00490         friend class CBuilderObject;
00491         friend class CBuilderModel;
00492         friend class CBuilderFactory;
00493 public:
00494         virtual ~CBuilderAtomReference();
00495 protected:
00496         CBuilderAtomReference(IMgaReference *iAtomRef, CBuilderModel *parent);
00497 
00498         void Resolve();
00499 public:
00500         IMgaReference* GetIAtomRef() const { return GetIRef(); }
00501 
00502 };
00503 
00504 
00505 
00506 class CBuilderConnection : public CBuilderObject {
00507         DECLARE_DYNAMIC(CBuilderConnection)
00508         friend class CBuilderObject;
00509 public:
00510         CBuilderConnection(IMgaSimpleConnection *iConn,CBuilderModel *o);
00511         virtual ~CBuilderConnection();
00512         virtual void Destroy();
00513 
00514 protected:
00515 //      CString kindName;
00516         CBuilderModel *&owner;
00517         CBuilderObject *src;
00518         CBuilderObject *dst;
00519 #define ciConnection ciObject
00520 //      CComPtr<IMgaSimpleConnection> ciConnection;
00521 
00522 public:
00523         CBuilderModel *GetOwner()       const                   { return owner; }       // the model where the connection is visible
00524         CBuilderObject *GetSource()     const                   { return src; }         // where it starts
00525         CBuilderObject *GetDestination() const          { return dst; }         // where it ends
00526         const CString &GetKindName() const                      { return kindName; }
00527         IMgaSimpleConnection *GetIConnection() const            {
00528                 return CComQIPtr<IMgaSimpleConnection>(ciConnection);
00529         }
00530 
00531         void Resolve();
00532 };
00533 
00534 
00535 class CBuilderSet : public CBuilderObject {
00536         DECLARE_DYNAMIC(CBuilderSet)
00537         friend class CBuilderModel;
00538 public:
00539         CBuilderSet(IMgaSet *iCond,CBuilderModel *own);
00540         virtual ~CBuilderSet();
00541 //      virtual void Destroy();
00542 
00543 protected:
00544 #define iSet ciObject
00545         CBuilderObjectList members;
00546 
00547         void InsertMember(CBuilderObject *member)                               { members.AddTail(member); }
00548 
00549 public:
00550 //      long GetObjId() const;
00551         IMgaSet* GetISet() const { return CComQIPtr<IMgaSet>(ciObject); }
00552         void Resolve();
00553         const CBuilderModel *GetOwner() const                           { return GetParent(); }
00554         const CBuilderObjectList *GetMembers() const                    { return &members; }
00555 
00556         bool AddMember(CBuilderObject *part);
00557         bool RemoveMember(CBuilderObject *part);
00558 };
00559 
00560 // -------------------------- BuilderFactory
00561 
00562 class CBuilderFactory
00563 {
00564 public:
00565         CBuilderFactory(CString modelkinds, CBuilderModelCreateFunction createFn);
00566         CBuilderFactory(CString atomkinds, CBuilderAtomCreateFunction createFn);
00567 
00568         CBuilderFactory(CString refkinds, CBuilderRefCreateFunction createFn);
00569         CBuilderFactory(CString modelrefkinds, CBuilderModelRefCreateFunction createFn);
00570         CBuilderFactory(CString atomrefkinds, CBuilderAtomRefCreateFunction createFn);
00571 
00572         CBuilderFactory(CString connectionkinds, CBuilderConnectionCreateFunction createFn);
00573         CBuilderFactory(CString setkinds, CBuilderSetCreateFunction createFn);
00574         ~CBuilderFactory();
00575 
00576         static void CheckKindNames(IMgaFolder* iparadigm);
00577         static void CollectFolderKindNames(IMgaMetaFolder*);
00578         static void CollectFCOKindNames(IMgaMetaFCOs*);
00579 
00580         static CStringList modelkindnames;
00581         static CStringList atomkindnames;
00582         static CStringList refkindnames;
00583         static CStringList connectionkindnames;
00584         static CStringList setkindnames;
00585 
00586         static CBuilderModelCreateFunctionTable *modelBuildFunctions;
00587         static CBuilderAtomCreateFunctionTable *atomBuildFunctions;
00588         static CBuilderRefCreateFunctionTable *refBuildFunctions;
00589         static CBuilderModelRefCreateFunctionTable *modelRefBuildFunctions;
00590         static CBuilderAtomRefCreateFunctionTable *atomRefBuildFunctions;
00591         static CBuilderConnectionCreateFunctionTable *connectionBuildFunctions;
00592         static CBuilderSetCreateFunctionTable *setBuildFunctions;
00593 
00594         static CBuilderModel* Create(IMgaModel* iModel, CBuilderModel* parent);
00595         static CBuilderAtom* Create(IMgaAtom* iAtom, CBuilderModel* parent);
00596         static CBuilderReference* Create(IMgaReference* iModelRef, CBuilderModel* parent);
00597         static CBuilderConnection* Create(IMgaSimpleConnection* iConnection, CBuilderModel* parent);
00598         static CBuilderSet* Create(IMgaSet* iSet, CBuilderModel* parent);
00599 };
00600 
00601 // -------------------------- Macros
00602 
00603 #define DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBUILDERMODEL, IMGAMODEL) \
00604         DECLARE_DYNAMIC(CLASS) \
00605 protected: \
00606         CLASS(IMGAMODEL* iModel, CBuilderModel* parent); \
00607 public: \
00608         static CBUILDERMODEL* Create(IMGAMODEL* iModel, CBuilderModel* parent); \
00609         static CBuilderFactory registercreatefunc;
00610 
00611 #define IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBUILDERMODEL, IMGAMODEL) \
00612 IMPLEMENT_DYNAMIC(CLASS, BASECLASS) \
00613 CLASS::CLASS(IMGAMODEL* iInterface, CBuilderModel* parent) \
00614         : BASECLASS(iInterface, parent) { } \
00615 CBUILDERMODEL* CLASS::Create(IMGAMODEL* iModel, CBuilderModel* parent) \
00616 { \
00617         CLASS* ptr = new CLASS(iModel, parent); \
00618         ptr->Initialize(); \
00619         return ptr; \
00620 } \
00621 CBuilderFactory CLASS::registercreatefunc(NAMES, CLASS::Create);
00622 
00623 #define DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBUILDERMODEL, IMGAMODEL) \
00624         DECLARE_DYNAMIC(CLASS) \
00625 protected: \
00626         CLASS(IMGAMODEL* iInterface, CBuilderModel* parent) : BASECLASS(iInterface, parent) { } \
00627 public:
00628 
00629 #define IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBUILDERMODEL, IMGAMODEL) \
00630 IMPLEMENT_DYNAMIC(CLASS, BASECLASS) \
00631 
00632 
00633 // --- Custom
00634 
00635 #define DECLARE_CUSTOMMODEL(CLASS, BASECLASS) \
00636         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderModel, IMgaModel)
00637 #define IMPLEMENT_CUSTOMMODEL(CLASS, BASECLASS, NAMES) \
00638         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderModel, IMgaModel)
00639 
00640 #define DECLARE_CUSTOMATOM(CLASS, BASECLASS) \
00641         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderAtom, IMgaAtom)
00642 #define IMPLEMENT_CUSTOMATOM(CLASS, BASECLASS, NAMES) \
00643         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderAtom, IMgaAtom)
00644 
00645 #define DECLARE_CUSTOMREF(CLASS, BASECLASS) \
00646         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderReference, IMgaReference)
00647 #define IMPLEMENT_CUSTOMREF(CLASS, BASECLASS, NAMES) \
00648         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderReference, IMgaReference)
00649 
00650 #define DECLARE_CUSTOMMODELREF(CLASS, BASECLASS) \
00651         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderModelReference, IMgaReference)
00652 #define IMPLEMENT_CUSTOMMODELREF(CLASS, BASECLASS, NAMES) \
00653         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderModelReference, IMgaReference)
00654 
00655 #define DECLARE_CUSTOMATOMREF(CLASS, BASECLASS) \
00656         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderAtomReference, IMgaReference)
00657 #define IMPLEMENT_CUSTOMATOMREF(CLASS, BASECLASS, NAMES) \
00658         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderAtomReference, IMgaReference)
00659 
00660 #define DECLARE_CUSTOMCONNECTION(CLASS, BASECLASS) \
00661         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderConnection, IMgaSimpleConnection)
00662 #define IMPLEMENT_CUSTOMCONNECTION(CLASS, BASECLASS, NAMES) \
00663         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderConnection, IMgaSimpleConnection)
00664 
00665 #define DECLARE_CUSTOMSET(CLASS, BASECLASS) \
00666         DECLARE_CUSTOMXXX(CLASS, BASECLASS, CBuilderSet, IMgaSet)
00667 #define IMPLEMENT_CUSTOMSET(CLASS, BASECLASS, NAMES) \
00668         IMPLEMENT_CUSTOMXXX(CLASS, BASECLASS, NAMES, CBuilderSet, IMgaSet)
00669 
00670 
00671 
00672 // --- Base
00673 
00674 #define DECLARE_CUSTOMMODELBASE(CLASS, BASECLASS) \
00675         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderModel, IMgaModel)
00676 #define IMPLEMENT_CUSTOMMODELBASE(CLASS, BASECLASS) \
00677         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderModel, IMgaModel)
00678 
00679 #define DECLARE_CUSTOMATOMBASE(CLASS, BASECLASS) \
00680         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderAtom, IMgaAtom)
00681 #define IMPLEMENT_CUSTOMATOMBASE(CLASS, BASECLASS) \
00682         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderAtom, IMgaAtom)
00683 
00684 #define DECLARE_CUSTOMREFBASE(CLASS, BASECLASS) \
00685         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderReference, IMgaReference)
00686 #define IMPLEMENT_CUSTOMREFBASE(CLASS, BASECLASS) \
00687         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderReference, IMgaReference)
00688 
00689 #define DECLARE_CUSTOMMODELREFBASE(CLASS, BASECLASS) \
00690         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderModelReference, IMgaReference)
00691 #define IMPLEMENT_CUSTOMMODELREFBASE(CLASS, BASECLASS) \
00692         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderModelReference, IMgaReference)
00693 
00694 #define DECLARE_CUSTOMATOMREFBASE(CLASS, BASECLASS) \
00695         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderAtomReference, IMgaReference)
00696 #define IMPLEMENT_CUSTOMATOMREFBASE(CLASS, BASECLASS) \
00697         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderAtomReference, IMgaReference)
00698 
00699 #define DECLARE_CUSTOMCONNECTIONBASE(CLASS, BASECLASS) \
00700         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderConnection, IMgaSimpleConnection)
00701 #define IMPLEMENT_CUSTOMCONNECTIONBASE(CLASS, BASECLASS) \
00702         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderConnection, IMgaSimpleConnection)
00703 
00704 #define DECLARE_CUSTOMSETBASE(CLASS, BASECLASS) \
00705         DECLARE_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderSet, IMgaSet)
00706 #define IMPLEMENT_CUSTOMSETBASE(CLASS, BASECLASS) \
00707         IMPLEMENT_CUSTOMXXXBASE(CLASS, BASECLASS, CBuilderSet, IMgaSet)
00708 
00709 
00710 // --- Cast
00711 
00712 #endif // whole file