CoreApplication.h

Go to the documentation of this file.

#pragma once
 
#include <Base/Observer.h>
#include <Base/String.h>
#include <Core/CA_CommandObserver.h>
 
#include <functional>                 // for function, _Func_class
namespace Core { class Command; }
 
 
typedef std::vector<CA_CommandObserver*> ca_CommandObserver_Vector;
typedef std::vector<CA_TransactionObserver*> CA_TransactionObserver_Vector;
 
 
namespace Core
{
class CoreApplicationP;
class CoreDocument;
class DocObject;
class Property;
class CommandFactory;
 
 
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;
};
 
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; }
 
 
    Core::Command* createCommand(const std::string& commandName) { return _createCommand(commandName); };
    void setCreateCommandFunction(std::function < Core::Command * (const std::string&)> f) { _createCommand = f; }
 
    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);
 
    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;
    std::function<Core::Command*(const std::string&)> _createCommand;
 
    friend class AutoTransaction;
 
    std::string _activeTransactionName = "";
    int _activeTransactionID = 0;
    int _activeTransactionGuard = 0;
    bool _activeTransactionTmpName = false;
 
};
 
}  // namespace Core