f784daf7f1
With the new setup object signals it may happen that a document object claims children but has no property changed after the viewprodivers creation. This scenario is not supportet up to now as the scene graph children are only set when the object changes.
263 lines
11 KiB
C++
263 lines
11 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2004 Jürgen Riegel <juergen.riegel@web.de> *
|
|
* *
|
|
* 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 GUI_DOCUMENT_H
|
|
#define GUI_DOCUMENT_H
|
|
|
|
#include "MDIView.h"
|
|
|
|
#include <list>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
#include <Base/Persistence.h>
|
|
#include <App/Document.h>
|
|
|
|
#include "Tree.h"
|
|
|
|
class SoPath;
|
|
|
|
namespace Base {
|
|
class Matrix4D;
|
|
}
|
|
|
|
namespace App {
|
|
class DocumentObjectGroup;
|
|
}
|
|
|
|
namespace Gui {
|
|
|
|
class ViewProvider;
|
|
class ViewProviderDocumentObject;
|
|
class Application;
|
|
class DocumentPy;
|
|
enum HighlightMode;
|
|
|
|
/** The Gui Document
|
|
* This is the document on GUI level. Its main responsibility is keeping
|
|
* track off open windows for a document and warning on unsaved closes.
|
|
* All handled views on the document must inherit from MDIView
|
|
* @see App::Document
|
|
* @see MDIView
|
|
* @author Jürgen Riegel
|
|
*/
|
|
class GuiExport Document : public Base::Persistence
|
|
{
|
|
public:
|
|
Document(App::Document* pcDocument, Application * app);
|
|
~Document();
|
|
|
|
protected:
|
|
/** @name I/O of the document */
|
|
//@{
|
|
/// This slot is connected to the App::Document::signalNewObject(...)
|
|
void slotNewObject(const App::DocumentObject&);
|
|
void slotDeletedObject(const App::DocumentObject&);
|
|
void slotChangedObject(const App::DocumentObject&, const App::Property&);
|
|
void slotRelabelObject(const App::DocumentObject&);
|
|
void slotActivatedObject(const App::DocumentObject&);
|
|
void slotStartRestoreDocument(const App::Document&);
|
|
void slotFinishRestoreDocument(const App::Document&);
|
|
void slotUndoDocument(const App::Document&);
|
|
void slotRedoDocument(const App::Document&);
|
|
//@}
|
|
|
|
public:
|
|
/** @name Signals of the document */
|
|
//@{
|
|
/// signal on new Object
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalNewObject;
|
|
/// signal on deleted Object
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalDeletedObject;
|
|
/** signal on changed Object, the 2nd argument is the changed property
|
|
of the referenced document object, not of the view provider */
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&,
|
|
const App::Property&)> signalChangedObject;
|
|
/// signal on renamed Object
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalRelabelObject;
|
|
/// signal on activated Object
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalActivatedObject;
|
|
/// signal on entering in edit mode
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalInEdit;
|
|
/// signal on leaving edit mode
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&)> signalResetEdit;
|
|
/// signal on changed Object, the 2nd argument is the highlite mode to use
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&,
|
|
const Gui::HighlightMode&,
|
|
bool)> signalHighlightObject;
|
|
/// signal on changed Object, the 2nd argument is the highlite mode to use
|
|
mutable boost::signal<void (const Gui::ViewProviderDocumentObject&,
|
|
const Gui::TreeItemMode&)> signalExpandObject;
|
|
/// signal on undo Document
|
|
mutable boost::signal<void (const Gui::Document& doc)> signalUndoDocument;
|
|
/// signal on redo Document
|
|
mutable boost::signal<void (const Gui::Document& doc)> signalRedoDocument;
|
|
//@}
|
|
|
|
/** @name I/O of the document */
|
|
//@{
|
|
unsigned int getMemSize (void) const;
|
|
/// Save the document
|
|
bool save(void);
|
|
/// Save the document under a new file name
|
|
bool saveAs(void);
|
|
/// Save a copy of the document under a new file name
|
|
bool saveCopy(void);
|
|
/// This method is used to save properties or very small amounts of data to an XML document.
|
|
virtual void Save (Base::Writer &writer) const;
|
|
/// This method is used to restore properties from an XML document.
|
|
virtual void Restore(Base::XMLReader &reader);
|
|
/// This method is used to save large amounts of data to a binary file.
|
|
virtual void SaveDocFile (Base::Writer &writer) const;
|
|
/// This method is used to restore large amounts of data from a binary file.
|
|
virtual void RestoreDocFile(Base::Reader &reader);
|
|
void exportObjects(const std::vector<App::DocumentObject*>&, Base::Writer&);
|
|
void importObjects(const std::vector<App::DocumentObject*>&, Base::Reader&,
|
|
const std::map<std::string, std::string>& nameMapping);
|
|
/// Add all root objects of the given array to a group
|
|
void addRootObjectsToGroup(const std::vector<App::DocumentObject*>&, App::DocumentObjectGroup*);
|
|
//@}
|
|
|
|
/// Observer message from the App doc
|
|
void setModified(bool);
|
|
bool isModified() const;
|
|
|
|
/// Getter for the App Document
|
|
App::Document* getDocument(void) const;
|
|
|
|
/** @name methods for View handling */
|
|
//@{
|
|
/// Getter for the active view
|
|
Gui::MDIView* getActiveView(void) const;
|
|
Gui::MDIView* getEditingViewOfViewProvider(Gui::ViewProvider*) const;
|
|
Gui::MDIView* getViewOfViewProvider(Gui::ViewProvider*) const;
|
|
/// Create a new view
|
|
void createView(const Base::Type& typeId);
|
|
/** send messages to the active view
|
|
* Send a specific massage to the active view and is able to recive a
|
|
* return massage
|
|
*/
|
|
/// send Messages to all views
|
|
bool sendMsgToViews(const char* pMsg);
|
|
/** Sends the message \a pMsg to the views of type \a typeid and stops with
|
|
* the first view that supports the message and returns \a ppReturn. The very
|
|
* first checked view is the current active view.
|
|
* If a view supports the message true is returned and false otherwise.
|
|
*/
|
|
bool sendMsgToFirstView(const Base::Type& typeId, const char* pMsg, const char** ppReturn);
|
|
/// Attach a view (get called by the MDIView constructor)
|
|
void attachView(Gui::BaseView* pcView, bool bPassiv=false);
|
|
/// Detach a view (get called by the MDIView destructor)
|
|
void detachView(Gui::BaseView* pcView, bool bPassiv=false);
|
|
/// helper for selection
|
|
ViewProvider* getViewProviderByPathFromTail(SoPath * path) const;
|
|
/// call update on all attached views
|
|
void onUpdate(void);
|
|
/// call relabel to all attached views
|
|
void onRelabel(void);
|
|
/// returns a list of all attached MDI views
|
|
std::list<MDIView*> getMDIViews() const;
|
|
/// returns a list of all MDI views of a certain type
|
|
std::list<MDIView*> getMDIViewsOfType(const Base::Type& typeId) const;
|
|
//@}
|
|
|
|
/** @name View provider handling */
|
|
//@{
|
|
/// Get the view provider for that object
|
|
ViewProvider* getViewProvider(const App::DocumentObject *) const;
|
|
/// set an annotation view provider
|
|
void setAnnotationViewProvider(const char* name, ViewProvider *pcProvider);
|
|
/// get an annotation view provider
|
|
ViewProvider * getAnnotationViewProvider(const char* name) const;
|
|
/// remove an annotation view provider
|
|
void removeAnnotationViewProvider(const char* name);
|
|
/// test if the feature is in show
|
|
bool isShow(const char* name);
|
|
/// put the feature in show
|
|
void setShow(const char* name);
|
|
/// set the feature in Noshow
|
|
void setHide(const char* name);
|
|
/// set the feature transformation (only viewing)
|
|
void setPos(const char* name, const Base::Matrix4D& rclMtrx);
|
|
std::vector<ViewProvider*> getViewProvidersOfType(const Base::Type& typeId) const;
|
|
ViewProvider *getViewProviderByName(const char* name) const;
|
|
/// set the ViewProvider in special edit mode
|
|
bool setEdit(Gui::ViewProvider* p, int ModNum=0);
|
|
/// reset from edit mode
|
|
void resetEdit(void);
|
|
/// get the in edit ViewProvider or NULL
|
|
ViewProvider *getInEdit(void) const;
|
|
//@}
|
|
|
|
/** @name methods for the UNDO REDO handling */
|
|
//@{
|
|
/// Open a new Undo transaction on the document
|
|
void openCommand(const char* sName=0);
|
|
/// Commit the Undo transaction on the document
|
|
void commitCommand(void);
|
|
/// Abort the Undo transaction on the document
|
|
void abortCommand(void);
|
|
/// Check if an Undo transaction is open
|
|
bool hasPendingCommand(void) const;
|
|
/// Get an Undo string vector with the Undo names
|
|
std::vector<std::string> getUndoVector(void) const;
|
|
/// Get an Redo string vector with the Redo names
|
|
std::vector<std::string> getRedoVector(void) const;
|
|
/// Will UNDO one or more steps
|
|
void undo(int iSteps);
|
|
/// Will REDO one or more steps
|
|
void redo(int iSteps) ;
|
|
//@}
|
|
|
|
/// handels the application close event
|
|
bool canClose();
|
|
bool isLastView(void);
|
|
|
|
virtual PyObject *getPyObject(void);
|
|
|
|
protected:
|
|
// pointer to the python class
|
|
Gui::DocumentPy *_pcDocPy;
|
|
|
|
private:
|
|
//handles the scene graph nodes to correctly group child and parents
|
|
void handleChildren3D(ViewProvider* viewProvider);
|
|
|
|
struct DocumentP* d;
|
|
static int _iDocCount;
|
|
|
|
/** @name attributes for the UNDO REDO facility
|
|
*/
|
|
//@{
|
|
/// undo names list
|
|
std::list<std::string> listUndoNames;
|
|
/// redo names list
|
|
std::list<std::string> listRedoNames;
|
|
//@}
|
|
};
|
|
|
|
} // namespace Gui
|
|
|
|
|
|
#endif // GUI_DOCUMENT_H
|