App/Document.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) Jürgen Riegel          (juergen.riegel@web.de) 2002     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef APP_DOCUMENT_H
#define APP_DOCUMENT_H

#include <CXX/Objects.hxx>
#include <Base/Observer.h>
#include <Base/Persistence.h>
#include <Base/Type.h>

#include "PropertyContainer.h"
#include "PropertyStandard.h"

#include <map>
#include <vector>
#include <stack>

#include <boost/signals.hpp>
#include <boost/graph/adjacency_list.hpp>


namespace Base {
    class Writer;
}

namespace App
{
    class DocumentObject;
    class DocumentObjectExecReturn;
    class Document;
    class DocumentPy; // the python document class
    class Application;
    class Transaction;
}

namespace App
{

class AppExport Document : public App::PropertyContainer
{
    PROPERTY_HEADER(App::Document);

public:

    PropertyString Label;
    PropertyString FileName;
    PropertyString CreatedBy;
    PropertyString CreationDate;
    PropertyString LastModifiedBy;
    PropertyString LastModifiedDate;
    PropertyString Company;
    PropertyString Comment;
    PropertyString Id;
    PropertyString TransientDir;


    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;
    boost::signal<void (Base::Writer   &)> signalSaveDocument;
    boost::signal<void (Base::XMLReader&)> signalRestoreDocument;
    boost::signal<void (const std::vector<App::DocumentObject*>&,
                        Base::Writer   &)> signalExportObjects;
    boost::signal<void (const std::vector<App::DocumentObject*>&,
                        Base::XMLReader&)> signalImportObjects;


    //void saveAs (const char* Name);
    bool save (void);
    void restore (void);
    void exportObjects(const std::vector<App::DocumentObject*>&, std::ostream&);
    std::vector<App::DocumentObject*> importObjects(std::istream&);
    //void open (void);
    bool isSaved() const;
    const char* getName() const;

    virtual void Save (Base::Writer &writer) const;
    virtual void Restore(Base::XMLReader &reader);

    unsigned int getMemSize (void) const;


    DocumentObject *addObject(const char* sType, const char* pObjectName=0);
    void remObject(const char* sName);
    DocumentObject* copyObject(DocumentObject* obj, bool recursive=false);
    DocumentObject* moveObject(DocumentObject* obj, bool recursive=false);
    DocumentObject *getActiveObject(void) const;
    DocumentObject *getObject(const char *Name) const;
    const char *getObjectName(DocumentObject *pFeat) const;
    std::string getUniqueObjectName(const char *Name) const;
    std::string getStandardObjectName(const char *Name, int d) const;
    std::vector<DocumentObject*> getObjects() const;
    std::vector<DocumentObject*> getObjectsOfType(const Base::Type& typeId) const;
    template<typename T> inline std::vector<T*> getObjectsOfType() const;
    int countObjectsOfType(const Base::Type& typeId) const;
    int countObjects(void) const;


    void purgeTouched();
    bool isTouched(void) const;
    std::vector<App::DocumentObject *> getTouched(void) const;
    void setClosable(bool);
    bool isClosable() const;
    void recompute();
    void recomputeFeature(DocumentObject* Feat);
    const std::vector<App::DocumentObjectExecReturn*> &getRecomputeLog(void)const{return _RecomputeLog;}
    const char* getErrorDescription(const App::DocumentObject*) const;



    void setUndoMode(int iMode);  
    int getUndoMode(void) const;  
    void setTransactionMode(int iMode);
    void openTransaction(const char* name=0);
    // Commit the Command transaction. Do nothing If there is no Command transaction open.
    void commitTransaction();
    void abortTransaction();
    void setUndoLimit(unsigned int UndoMemSize=0);
    unsigned int getUndoMemSize (void) const;
    void setMaxUndoStackSize(unsigned int UndoMaxStackSize=20);
    unsigned int getMaxUndoStackSize(void)const;
    void clearUndos();
    int getAvailableUndos() const;
    std::vector<std::string> getAvailableUndoNames() const;
    bool undo();
    int getAvailableRedos() const;
    std::vector<std::string> getAvailableRedoNames() const;
    bool redo() ;


    void writeDependencyGraphViz(std::ostream &out);
    bool checkOnCycle(void);
    std::vector<App::DocumentObject*> getInList(const DocumentObject* me) const;
    // set Changed
    //void setChanged(DocumentObject* change);

    virtual PyObject *getPyObject(void);

    friend class Application;
    friend class DocumentObject;
    friend class Transaction;
    friend class TransactionObject;

    virtual ~Document();

protected:
    Document(void);

    void _remObject(DocumentObject* pcObject);
    void _addObject(DocumentObject* pcObject, const char* pObjectName);
    DocumentObject* _copyObject(DocumentObject* obj, std::map<DocumentObject*, 
        DocumentObject*>&, bool recursive=false);
    void breakDependency(DocumentObject* pcObject, bool clear);

    void onChanged(const Property* prop);
    void onBeforeChangeProperty(const DocumentObject *Who, const Property *What);
    void onChangedProperty(const DocumentObject *Who, const Property *What);
    bool _recomputeFeature(DocumentObject* Feat);
    void _clearRedos();


private:
    // # Data Member of the document +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    std::list<Transaction*> mUndoTransactions;
    std::list<Transaction*> mRedoTransactions;
    // recompute log
    std::vector<App::DocumentObjectExecReturn*> _RecomputeLog;

    // pointer to the python class
    Py::Object DocumentPythonObject;
    struct DocumentP* d;
};

template<typename T>
inline std::vector<T*> Document::getObjectsOfType() const
{
    std::vector<T*> type;
    std::vector<App::DocumentObject*> obj = this->getObjectsOfType(T::getClassTypeId());
    type.reserve(obj.size());
    for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it)
        type.push_back(static_cast<T*>(*it));
    return type;
}


} //namespace App

#endif // APP_DOCUMENT_H