App/Application.h

Go to the documentation of this file.

/***************************************************************************
 *   (c) Jürgen Riegel (juergen.riegel@web.de) 2002                        *   
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License (LGPL)   *
 *   as published by the Free Software Foundation; either version 2 of     *
 *   the License, or (at your option) any later version.                   *
 *   for detail see the LICENCE text file.                                 *
 *                                                                         *
 *   FreeCAD is distributed in the hope that it will be useful,            *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        * 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with FreeCAD; if not, write to the Free Software        *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
 *   USA                                                                   *
 *                                                                         *
 *   Juergen Riegel 2002                                                   *
 ***************************************************************************/

#ifndef APP_APPLICATION_H
#define APP_APPLICATION_H

#include <boost/signal.hpp>

#include <vector>

#include <Base/PyObjectBase.h>
#include <Base/Parameter.h>
#include <Base/Observer.h>


namespace Base 
{
    class ConsoleObserverStd; 
    class ConsoleObserverFile;
}

namespace App
{

class Document;
class DocumentObject;
class ApplicationObserver;
class Property;



class AppExport Application
{

public:

    //---------------------------------------------------------------------
    // exported functions goes here +++++++++++++++++++++++++++++++++++++++
    //---------------------------------------------------------------------

    App::Document* newDocument(const char * Name=0l, const char * UserName=0l);
    bool closeDocument(const char* name);
    std::string getUniqueDocumentName(const char *Name) const;
    App::Document* openDocument(const char * FileName=0l);
    App::Document* getActiveDocument(void) const;
    App::Document* getDocument(const char *Name) const;
    const char * getDocumentName(const App::Document* ) const;
    std::vector<App::Document*> getDocuments() const;
    void setActiveDocument(App::Document* pDoc);
    void setActiveDocument(const char *Name);
    void closeAllDocuments(void);


    boost::signal<void (const Document&)> signalNewDocument;
    boost::signal<void (const Document&)> signalDeleteDocument;
    boost::signal<void ()> signalDeletedDocument;
    boost::signal<void (const Document&)> signalRelabelDocument;
    boost::signal<void (const Document&)> signalRenameDocument;
    boost::signal<void (const Document&)> signalActiveDocument;
    boost::signal<void (const Document&)> signalSaveDocument;
    boost::signal<void (const Document&)> signalRestoreDocument;



    boost::signal<void (const App::DocumentObject&)> signalNewObject;
    //boost::signal<void (const App::DocumentObject&)>     m_sig;
    boost::signal<void (const App::DocumentObject&)> signalDeletedObject;
    boost::signal<void (const App::DocumentObject&, const App::Property&)> signalChangedObject;
    boost::signal<void (const App::DocumentObject&)> signalRenamedObject;
    boost::signal<void (const App::DocumentObject&)> signalActivatedObject;



    ParameterManager &                                GetSystemParameter(void) ;
    ParameterManager &                                GetUserParameter(void) ;
    Base::Reference<ParameterGrp>                     GetParameterGroupByPath(const char* sName);

    ParameterManager *                                GetParameterSet(const char* sName) const;
    const std::map<std::string,ParameterManager *> &  GetParameterSetList(void) const;
    void AddParameterSet(const char* sName);
    void RemoveParameterSet(const char* sName);


    void addImportType(const char* Type, const char* ModuleName);
    std::vector<std::string> getImportModules(const char* Type) const;
    std::vector<std::string> getImportModules() const;
    std::vector<std::string> getImportTypes(const char* Module) const;
    std::vector<std::string> getImportTypes(void) const;
    std::map<std::string, std::string> getImportFilters(const char* Type) const;
    std::map<std::string, std::string> getImportFilters(void) const;


    void addExportType(const char* Type, const char* ModuleName);
    std::vector<std::string> getExportModules(const char* Type) const;
    std::vector<std::string> getExportModules() const;
    std::vector<std::string> getExportTypes(const char* Module) const;
    std::vector<std::string> getExportTypes(void) const;
    std::map<std::string, std::string> getExportFilters(const char* Type) const;
    std::map<std::string, std::string> getExportFilters(void) const;

    static void init(int argc, char ** argv);
    static void initTypes(void);
    static void destruct(void);
    static void destructObserver(void);
    static void processCmdLineFiles(void);
    static void runApplication(void);
    friend Application &GetApplication(void);
    static std::map<std::string,std::string> &Config(void){return mConfig;}
    static int GetARGC(void){return _argc;}
    static char** GetARGV(void){return _argv;}

    const char* GetHomePath(void) const;
    const char* getExecutableName(void) const;
    static std::string getUserAppDataDir();
    static std::string getResourceDir();
    static std::string getHelpDir();

    friend class App::Document;

protected:
    void renameDocument(const char *OldName, const char *NewName);

    void slotNewObject(const App::DocumentObject&);
    void slotDeletedObject(const App::DocumentObject&);
    void slotChangedObject(const App::DocumentObject&, const App::Property& Prop);
    void slotRenamedObject(const App::DocumentObject&);
    void slotActivatedObject(const App::DocumentObject&);

private:
    Application(ParameterManager *pcSysParamMngr, ParameterManager *pcUserParamMngr,std::map<std::string,std::string> &mConfig);
    virtual ~Application();

    static ParameterManager *_pcSysParamMngr;
    static ParameterManager *_pcUserParamMngr;


    //---------------------------------------------------------------------
    // python exports goes here +++++++++++++++++++++++++++++++++++++++++++
    //---------------------------------------------------------------------

    // static python wrapper of the exported functions
    static PyObject* sGetParam          (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetVersion        (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetConfig         (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sSetConfig         (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sDumpConfig        (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sTemplateAdd       (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sTemplateDelete    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sTemplateGet       (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sAddImportType     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetImportType     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sAddExportType     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetExportType     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetResourceDir    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetHomePath       (PyObject *self,PyObject *args,PyObject *kwd);

    static PyObject* sLoadFile          (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sOpenDocument      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sSaveDocument      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sSaveDocumentAs    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sNewDocument       (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sCloseDocument     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sActiveDocument    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sSetActiveDocument (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sGetDocument       (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sListDocuments     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sAddDocObserver    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sRemoveDocObserver (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject* sTranslateUnit     (PyObject *self,PyObject *args,PyObject *kwd);

    static PyMethodDef    Methods[]; 

    friend class ApplicationObserver;

    static void initConfig(int argc, char ** argv);
    static void initApplication(void);
    static void logStatus(void);
    // the one and only pointer to the application object
    static Application *_pcSingleton;
    static void ParseOptions(int argc, char ** argv);
    //static void CheckEnv(void);
    // search for the home path
    static std::string FindHomePath(const char* sCall);
    static void PrintInitHelp(void);
    static void ExtractUserPath();
    static void LoadParameters(void);
    static void SaveEnv(const char *);
    static std::map<std::string,std::string> mConfig;
    static int _argc;
    static char ** _argv;

    struct FileTypeItem {
        std::string filter;
        std::string module;
        std::vector<std::string> types;
    };

    std::vector<FileTypeItem> _mImportTypes;
    std::vector<FileTypeItem> _mExportTypes;
    std::map<std::string,Document*> DocMap;
    std::map<std::string,ParameterManager *> mpcPramManager;
    std::map<std::string,std::string> &_mConfig;
    App::Document* _pActiveDoc;

    static Base::ConsoleObserverStd  *_pConsoleObserverStd;
    static Base::ConsoleObserverFile *_pConsoleObserverFile;
};

inline App::Application &GetApplication(void){
    return *App::Application::_pcSingleton;
}

} // namespace App


#endif // APP_APPLICATION_H