CoreApplication.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/Observer.h>
#include <Base/String.h>

#include <map>
#include <set>
#include <vector>
#include "CA_CommandObserver.h"

class CA_CommandObserver;
class CA_TransactionObserver;

typedef std::vector<CA_CommandObserver*> ca_CommandObserver_Vector;
typedef std::vector<CA_TransactionObserver*> CA_TransactionObserver_Vector;

namespace Base
{
class MessageBase;
class SequencerBase;
}  // namespace Base

namespace Core
{
class CoreApplicationP;
class CoreDocument;
class DocObject;
class Property;
class Pythonize;
class CommandFactory;
class AutoTransaction;


class LX_CORE_EXPORT AppChanges
{
public:
    enum why
    {
        NewDocument,
        CloseDocument,
        SetActiveDocument
    } Why;

    bool operator==(const AppChanges& m) const
    {
        return ((this->Why == m.Why) && (this->Doc == m.Doc) && (this->CreateGui == m.CreateGui) &&
                (this->SetAsActiveDocument == m.SetAsActiveDocument));
    }

    Core::CoreDocument* Doc = nullptr;
    bool CreateGui;                   // If true a corresponding GuiDocument gets created
    bool SetAsActiveDocument = true;  // If true when NewDocument is notified, the document will become active
};


class LX_CORE_EXPORT LoadedDll
{
public:
    LoadedDll(void){};
    virtual ~LoadedDll(void){};
    virtual Base::String getInfo() = 0;
    virtual void init() = 0;
    virtual void release() = 0;
};

class LX_CORE_EXPORT PartAcis : public Core::LoadedDll
{
public:
    PartAcis(void){};
    virtual ~PartAcis(void){};
    virtual Base::String getInfo() = 0;
    virtual void init() = 0;
    virtual void release() = 0;
    virtual Core::DocObject* create_PartGeometry(Core::CoreDocument* doc, const std::string& type) = 0;
};




#ifndef SWIG
// LX_CORE_EXTERN template class LX_CORE_EXPORT std::set<Base::Observer<const Core::AppChanges>*>;
LX_CORE_EXTERN template class LX_CORE_EXPORT std::set<CA_TransactionObserver*>;
LX_CORE_EXTERN template class LX_CORE_EXPORT std::set<CA_CommandObserver*>;
LX_CORE_EXTERN template class LX_CORE_EXPORT std::set<CoreDocument*>;
LX_CORE_EXTERN template class LX_CORE_EXPORT std::map<Base::String, Core::CoreDocument*>;
#endif
// LX_CORE_EXTERN template class LX_CORE_EXPORT std::list<const Core::AppChanges>;


class LX_CORE_EXPORT CoreApplication : public Base::Subject<Core::AppChanges>
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    CoreApplication(int argc, char** argv);
    ~CoreApplication();

    static CoreApplication* instance(void);
    static void destroy();
    static void reset();

    Base::String getApplicationName() const;
    void setApplicationName(const Base::String& name);

    Core::CoreDocument* newCoreDocument(const std::string& typeName, const Base::String& name = Base::String());
    Core::CoreDocument* newDocument(const std::string& typeName,
                                    const Base::String& name = Base::String(),
                                    bool createGui = true,
                                    bool setAsActiveDocument = true,
                                    bool createDefaultObjects = true);
    Core::CoreDocument* openCoreDocument(const std::string& typeName, const Base::String& path);
    Core::CoreDocument* openDocument(const std::string& typeName,
                                     const Base::String& path = Base::String(),
                                     bool createGui = true,
                                     bool savepath = true,
                                     bool setAsActiveDocument = true);
    bool closeDocument(Core::CoreDocument* doc);
    Core::CoreDocument* getActiveDocument() const;
    bool setActiveDocument(Core::CoreDocument* doc);
    Core::CoreDocument* getDocumentByName(const Base::String& name);
    std::vector<Core::CoreDocument*> getDocuments() const;
    void closeApplication();
    Base::String getApplicationPath() const;
    Base::String getTmpDirectory(Core::CoreDocument* doc);

    void setModulePreferenceValue(const std::string& moduleName, const std::string& key, const std::string& value);
    std::string getModulePreferenceValue(const std::string& moduleName, const std::string& key);

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

#ifndef LXAPI  // INTERFACES BELOW ARE -NOT- PART OF THE LEXOCAD API

    bool registerCommandObserver(CA_CommandObserver* observer);
    bool unregisterCommandObserver(CA_CommandObserver* observer);
    ca_CommandObserver_Vector getCommandObserver();

    bool add_TransactionObserver(CA_TransactionObserver* observer);
    bool remove_TransactionObserver(CA_TransactionObserver* observer);
    CA_TransactionObserver_Vector getTransactionObservers();

    // Notifications
    void notifyObject(Core::CoreDocument* doc, Core::DocObject* obj, Core::Property* pro, CA_Transaction::why transaction);
    void notifyDocumentCreated(Core::CoreDocument* doc);
    void notifyDocumentDeleted(Core::CoreDocument* doc);
    void notifyDocumentRenamed(Core::CoreDocument* doc);
    void notifyDocumentOpened(Core::CoreDocument* doc);
    void notifyDocumentClosed(Core::CoreDocument* doc);
    void notifyDocumentSaved(Core::CoreDocument* doc);
    void notifyDocumentFinishedRead(Core::CoreDocument* doc);
    void notifyDocumentChanged(Core::CoreDocument* doc, Core::Property* pro);
    void notifyDocumentSetActive(Core::CoreDocument* doc);

    void notifyObjectCreated(Core::CoreDocument* doc, Core::DocObject* obj);
    void notifyObjectDeleted(Core::CoreDocument* doc, Core::DocObject* obj);
    void notifyObjectAdded(Core::CoreDocument* doc, Core::DocObject* obj);
    void notifyObjectChanged(Core::CoreDocument* doc, Core::DocObject* obj, Core::Property* pro);
    void notifyObjectHasError(Core::CoreDocument* doc, Core::DocObject* obj);

    void notifyPropertyCreate(Core::CoreDocument* doc, Core::DocObject* obj, Core::Property* pro);
    void notifyPropertyChanged(Core::CoreDocument* doc, Core::DocObject* obj, Core::Property* pro);
    void notifyPropertyDeleted(Core::CoreDocument* doc, Core::DocObject* obj, Core::Property* pro);

    void notifyRecomputeSuccess(Core::CoreDocument* doc);
    void notifyRecomputeFailed(Core::CoreDocument* doc);

    void notifyApp(Core::CoreDocument* doc, AppChanges::why why, bool createGui, bool setAsActiveDocument = true);
    void notifyCmdObservers(Core::CoreDocument* doc, bool createGui);

    bool closeDocument(Core::CoreDocument* doc, bool forceClose /*=false*/, bool dontNotify = false);

    // Look through the opened documents map for the tested document;
    // this could happen when the document was closed and we just have still the pointer to removed document
    // which is invalid
    bool isDocumentValid(Core::CoreDocument* testedDocument) const;

    bool onClose(bool forceClose, bool dontNotify, bool& hardClose);
    bool closeApplication(bool forceClose, bool dontNotify, bool& hardClose);
    Base::String getUniqueDocumentName(const Base::String& s) const;
    int getOpenDocuments(std::vector<Core::CoreDocument*>& vec);

    void initPython() const;
    void finalizePython() const;

    bool runPythonString(const Base::String& str) const;
    bool runPythonString(const Base::String& str, Base::String& err) const;
    bool runPythonScript(const Base::String& scr, Base::String& err) const;
    bool runPythonScript(const Base::String& scr) const;

    bool isClosing() const;
    bool hasGui() const;
    void sethasGui(bool on);

    static unsigned int getVersionYear();
    static std::string getBuildDateTime();
    static std::string getDocumentVersion();
    static int getDocumentVersionAsInteger();
    static long getRefCount();
    void ref(void);
    void unref(void);

    LoadedDll* loadDllByName(const Base::String& name);

    void setCommandFactory(Core::CommandFactory* commandFactory) { _commandFactory = commandFactory; }
    Core::CommandFactory* getCommandFactory() const { return _commandFactory; }

    virtual const char* subject_name(void) { return "CoreApplication"; };


    int setActiveTransaction(const char* name, bool persist = false);
    const char* getActiveTransaction(int* tid = nullptr) const;
    void closeActiveTransaction(bool abort = false, int id = 0);

#endif

protected:
    Core::CoreDocument* _newDocument(const std::string& typeName, const Base::String& name, bool createGui);

    void deleteDocument(Core::CoreDocument* doc);

    std::map<Base::String, Core::CoreDocument*> _documentMap;

private:
    static void cleanOldTempDirectories();
    //CoreApplication() {}
    bool maybeSave(Core::CoreDocument* doc);
    bool closeDocumentP(Core::CoreDocument* doc, bool forceClose, bool dontNotify);

    std::unique_ptr<CoreApplicationP> _pimpl = nullptr;
    static CoreApplication* _instance;
    Base::String _applicationName;
    std::set<CA_CommandObserver*> _commandObserverRegistry;
    std::set<CA_TransactionObserver*> _transactionObserverRegistry;
    static long _refcnt;
    Core::PartAcis* _partTool = nullptr;
    Core::CommandFactory* _commandFactory = nullptr;

    friend class AutoTransaction;

    std::string _activeTransactionName = "";
    int _activeTransactionID = 0;
    int _activeTransactionGuard = 0;
    bool _activeTransactionTmpName = false;

};

}  // namespace Core