Gui/ViewProvider.h

Go to the documentation of this file.

/***************************************************************************
 *   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_VIEWPROVIDER_H
#define GUI_VIEWPROVIDER_H

#include <map>
#include <vector>
#include <string>
#include <QIcon>
#include <boost/signals.hpp>

class SbVec3f;
class SoNode;
class SoPath;
class SoSeparator;
class SoEvent;
class SoSwitch;
class SoTransform;
class SbMatrix;
class SoEventCallback;
class SoPickedPoint;
class QString;
class QMenu;
class QObject;


namespace Base {
  class Matrix4D;
}
namespace App {
  class Color;
}

#include <App/PropertyContainer.h>
#include <Base/Vector3D.h>

namespace Gui {
    namespace TaskView {
        class TaskContent;
    }
class View3DInventorViewer;
class ViewProviderPy;
class ObjectItem;


class GuiExport ViewProvider : public App::PropertyContainer
{
    PROPERTY_HEADER(Gui::ViewProvider);

public:
    ViewProvider();

    virtual ~ViewProvider();

    // returns the root node of the Provider (3D)
    virtual SoSeparator* getRoot(void){return pcRoot;}
    // returns the root for the Annotations. 
    SoSeparator* getAnnotation(void);
    // returns the root node of the Provider (3D)
    virtual SoSeparator* getFrontRoot(void) const {return 0;}
    // returns the root node of the Provider (3D)
    virtual SoSeparator* getBackRoot(void) const {return 0;}


    virtual bool useNewSelectionModel(void) const {return false;}
    virtual bool isSelectable(void) const {return true;}
    virtual std::string getElement(const SoPickedPoint *) const { return std::string(); }
    virtual std::vector<Base::Vector3d> getSelectionShape(const char* Element) const
    { return std::vector<Base::Vector3d>(); };
    virtual bool onDelete(const std::vector<std::string> &)
    { return true;}



    virtual QIcon getIcon(void) const;
    virtual std::vector<App::DocumentObject*> claimChildren(void) const
    { return std::vector<App::DocumentObject*>(); }


    boost::signal<void ()> signalChangeIcon;
    boost::signal<void (const QString&)> signalChangeToolTip;
    boost::signal<void (const QString&)> signalChangeStatusTip;

    void update(const App::Property*);
    virtual void updateData(const App::Property*)=0;
    bool isUpdatesEnabled () const;
    void setUpdatesEnabled (bool enable);

    std::string toString() const;
    PyObject* getPyObject();

    std::string getActiveDisplayMode(void) const;
    virtual void setDisplayMode(const char* ModeName);
    virtual const char* getDefaultDisplayMode() const=0;
    virtual std::vector<std::string> getDisplayModes(void) const=0;
    virtual void hide(void);
    virtual void show(void);
    virtual bool isShow(void) const;
    void setVisible(bool);
    bool isVisible() const;

    enum EditMode {Default = 0,
                   Transform,
                   Cutting,
                   Color,
    };
protected:
    virtual bool setEdit(int ModNum);
    virtual void unsetEdit(int ModNum);
    int getEditingMode() const;

public:
    bool startEditing(int ModNum = 0);
    bool isEditing() const;
    void finishEditing();
    virtual void setEditViewer(View3DInventorViewer*, int ModNum);
    virtual void unsetEditViewer(View3DInventorViewer*);


    virtual void getTaskViewContent(std::vector<Gui::TaskView::TaskContent*>&) const {}

    virtual bool keyPressed(bool pressed, int key) { return false; }
    virtual bool doubleClicked(void) { return false; }
    virtual bool mouseMove(const SbVec3f &pos, const SbVec3f &norm, const SoPickedPoint* pp)
    { return false; }
    virtual bool mouseButtonPressed(int Button, bool pressed, const SbVec3f &pos,
                                    const SbVec3f &norm, const SoPickedPoint* pp)
    { return false; }
    virtual void setupContextMenu(QMenu*, QObject*, const char*) {}


    virtual void setTransformation(const Base::Matrix4D &rcMatrix);
    virtual void setTransformation(const SbMatrix &rcMatrix);
    SbMatrix convert(const Base::Matrix4D &rcMatrix) const;

public:
    // this method is called by the viewer when the ViewProvider is in edit
    static void eventCallback(void * ud, SoEventCallback * node);

protected:

    void addDisplayMaskMode( SoNode *node, const char* type );
    void setDisplayMaskMode( const char* type );
    std::vector<std::string> getDisplayMaskModes() const;
    void setDefaultMode(int);

    SoPickedPoint* getPointOnRay(const SbVec3f& pos,const SbVec3f& dir,
        const View3DInventorViewer& viewer) const;
    void onChanged(const App::Property* prop);

protected:
    SoSeparator *pcRoot;
    SoTransform *pcTransform;
    const char* sPixmap;
    SoSwitch    *pcModeSwitch;
    SoSeparator *pcAnnotation;
    ViewProviderPy* pyViewObject;

private:
    int _iActualMode;
    int _iEditMode;
    std::string _sCurrentMode;
    std::map<std::string, int> _sDisplayMaskModes;
    bool _updateData;

    // friends
    friend class ViewProviderPythonFeaturePy;
};

} // namespace Gui

#endif // GUI_VIEWPROVIDER_H