CoreApplication.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/Observer.h>
#include <Base/String.h>
#include <Core/core_defines2.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 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 CORE_EXPORT LoadedDll
{
public:
    LoadedDll(void){};
    virtual ~LoadedDll(void){};
    virtual Base::String getInfo() = 0;
    virtual void init() = 0;
    virtual void release() = 0;
};

class 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
// CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::set<Base::Observer<const Core::AppChanges>*>;
CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::set<CA_TransactionObserver*>;
CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::set<CA_CommandObserver*>;
CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::set<CoreDocument*>;
CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::map<Base::String, Core::CoreDocument*>;
#endif
// CORE_EXPIMP_TEMPLATE template class CORE_EXPORT std::list<const Core::AppChanges>;


class 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);
    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);
    static std::string getVersion();
    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();

    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 void getVersion(int& one, int& two, int& three, int& revision);
    static unsigned int getVersionYear();
    static std::string getVersionStr();
    static std::string getBuildDateTime();
    static std::string getDocumentVersion();
    static int getDocumentVersionAsInteger();
    static long getRefCount();
    void ref(void);
    void unref(void);

    LoadedDll* loadDllByName(Base::String n);
    LoadedDll* getPartAcis();
 

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

    virtual const char* subject_name(void) { return "CoreApplication"; };
#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:
    //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;

};

}  // namespace Core