Selection.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) Juergen 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_SELECTION_H
#define GUI_SELECTION_H

// Std. configurations

#include <string>
#include <vector>
#include <list>
#include <map>
#include <CXX/Objects.hxx>

#include <Base/Observer.h>
#include <Base/Type.h>
#include <App/Document.h>
#include <App/DocumentObject.h>

#include <Gui/SelectionObject.h>

namespace App
{
  class DocumentObject;
  class Document;
}

namespace Gui
{

    class SelectionFilter;

class GuiExport SelectionChanges
{
public:
    enum MsgType {
        AddSelection,
        RmvSelection,
        SetSelection,
        ClrSelection,
        SetPreselect,
        RmvPreselect
    };

    MsgType Type;

    const char* pDocName;
    const char* pObjectName;
    const char* pSubName;
    float x;
    float y;
    float z;
};

} //namespace Gui



// Export an instance of the base class (to avoid warning C4275, see also 
// C++ Language Reference/General Rules and Limitations on MSDN for more details.)
//
// For compiler gcc4.1 we need to define the template class outside namespace 'Gui'
// otherwise we get the compiler error: 
// 'explicit instantiation of 'class Base::Subject<const Gui::SelectionChanges&>'
// in namespace 'Gui' (which does not enclose namespace 'Base')
// 
// It seems that this costruct is not longer needed for gcc4.4 and even leads to
// errors under Mac OS X. Thus, we check for version between 4.1 and 4.4.
// It seems that for Mac OS X this can be completely ignored

#if defined(__GNUC__) && defined(__GNUC_MINOR__) && !defined(FC_OS_MACOSX)
#define GNUC_VERSION (((__GNUC__)<<16)+((__GNUC_MINOR__)<<8))
#if GNUC_VERSION >= 0x040100 && GNUC_VERSION < 0x040400
template class GuiExport Base::Subject<const Gui::SelectionChanges&>;
#endif
#undef GNUC_VERSION
#endif

namespace Gui
{

class GuiExport SelectionObserver
{

public:
    SelectionObserver();
    virtual ~SelectionObserver();
    bool blockConnection(bool block);
    bool isConnectionBlocked() const;

    void attachSelection();
    void detachSelection();

private:
    virtual void onSelectionChanged(const SelectionChanges& msg) = 0;

private:
    typedef boost::signals::connection Connection;
    Connection connectSelection;
};

class GuiExport SelectionObserverPython : public SelectionObserver
{

public:
    SelectionObserverPython(const Py::Object& obj);
    virtual ~SelectionObserverPython();

    static void addObserver(const Py::Object& obj);
    static void removeObserver(const Py::Object& obj);

private:
    void onSelectionChanged(const SelectionChanges& msg);
    void addSelection(const SelectionChanges&);
    void removeSelection(const SelectionChanges&);
    void setSelection(const SelectionChanges&);
    void clearSelection(const SelectionChanges&);
    void setPreselection(const SelectionChanges&);
    void removePreselection(const SelectionChanges&);

private:
    Py::Object inst;
    static std::vector<SelectionObserverPython*> _instances;
};

class SelectionGate 
{
public:
    virtual bool allow(App::Document*,App::DocumentObject*, const char*)=0;
};


class GuiExport SelectionSingleton : public Base::Subject<const SelectionChanges&>
{
public:
    bool addSelection(const char* pDocName, const char* pObjectName=0, const char* pSubName=0, float x=0, float y=0, float z=0);
    void rmvSelection(const char* pDocName, const char* pObjectName=0, const char* pSubName=0);
    void setSelection(const char* pDocName, const std::vector<App::DocumentObject*>&);
    void clearSelection(const char* pDocName=0);
    void clearCompleteSelection();
    bool isSelected(const char* pDocName, const char* pObjectName=0, const char* pSubName=0) const;
    bool isSelected(App::DocumentObject*, const char* pSubName=0) const;

    bool setPreselect(const char* pDocName, const char* pObjectName, const char* pSubName, float x=0, float y=0, float z=0);
    void rmvPreselect();
    void setPreselectCoord(float x, float y, float z);
    const SelectionChanges& getPreselection(void) const;
    void addSelectionGate(Gui::SelectionGate *gate);
    void rmvSelectionGate(void);


    unsigned int countObjectsOfType(const Base::Type& typeId, const char* pDocName=0) const;

    unsigned int countObjectsOfType(const char* typeName, const char* pDocName=0) const;

    std::vector<App::DocumentObject*> getObjectsOfType(const Base::Type& typeId, const char* pDocName=0) const;

    std::vector<App::DocumentObject*> getObjectsOfType(const char* typeName, const char* pDocName=0) const;
    template<typename T> inline std::vector<T*> getObjectsOfType(const char* pDocName=0) const;

    struct SelObj {
        const char* DocName;
        const char* FeatName;
        const char* SubName;
        const char* TypeName;
        App::Document* pDoc;
        App::DocumentObject*  pObject;
        float x,y,z;
    };

    boost::signal<void (const SelectionChanges& msg)> signalSelectionChanged;

    std::vector<SelObj> getSelection(const char* pDocName=0) const;
    std::vector<Gui::SelectionObject> getSelectionEx(const char* pDocName=0,Base::Type typeId=App::DocumentObject::getClassTypeId()) const;

    std::vector<SelObj> getCompleteSelection() const;
    bool hasSelection() const;
    bool hasSelection(const char* doc) const;

    unsigned int size(void) const {
        return static_cast<unsigned int>(_SelList.size());
    }

    static SelectionSingleton& instance(void);
    static void destruct (void);
    friend class SelectionFilter;

    // Python interface
    static PyMethodDef    Methods[];

protected:
    static PyObject *sAddSelection        (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sRemoveSelection     (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sClearSelection      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sIsSelected          (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sGetSelection        (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sGetSelectionEx      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sAddSelObserver      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sRemSelObserver      (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *saddSelectionGate    (PyObject *self,PyObject *args,PyObject *kwd);
    static PyObject *sremoveSelectionGate (PyObject *self,PyObject *args,PyObject *kwd);

protected:
    SelectionSingleton();
    virtual ~SelectionSingleton();

    void slotRenamedObject(const App::DocumentObject&);
    void slotDeletedObject(const App::DocumentObject&);

    App::Document* getDocument(const char* pDocName=0) const;

    SelectionChanges CurrentPreselection;

    struct _SelObj {
        std::string DocName;
        std::string FeatName;
        std::string SubName;
        std::string TypeName;
        App::Document* pDoc;
        App::DocumentObject* pObject;
        float x,y,z;
    };
    std::list<_SelObj> _SelList;

    static SelectionSingleton* _pcSingleton;

    std::string DocName;
    std::string FeatName;
    std::string SubName;
    float hx,hy,hz;

    Gui::SelectionGate *ActiveGate;
};

template<typename T>
inline std::vector<T*> SelectionSingleton::getObjectsOfType(const char* pDocName) const
{
    std::vector<T*> type;
    std::vector<App::DocumentObject*> obj = this->getObjectsOfType(T::getClassTypeId(), pDocName);
    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;
}

inline SelectionSingleton& Selection(void)
{
    return SelectionSingleton::instance();
}

} //namespace Gui

#endif // GUI_SELECTION_H