QTDesignObject.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: NDEVR
File: QTDesignObject
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/QTModelManager.h>
#include <NDEVR/Model.h>
#include <NDEVR/UUID.h>
namespace NDEVR
{
    class DesignCommand;
    /**--------------------------------------------------------------------------------------------------
    \brief Used with QTDesignObject to check the type of an object.
    **/
    template<class t_type>
    struct ObjectChecker { static bool is(const DynamicPointer<DesignObject>& object); };
    template<> struct ObjectChecker<DesignObject> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->hasObjectID(id);
        }
    };
    template<> struct ObjectChecker<Model> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->modelOrLayer(id).isValid();
        }
    };
    template<> struct ObjectChecker<Geometry> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->hasGeometryID(id);
        }
    };
    template<> struct ObjectChecker<Material> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->hasMaterialID(id);
        }
    };
#if NDEVR_VIEWPORT
    template<> struct ObjectChecker<Camera> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->hasCamera(id);
        }
    };
#endif
    template<> struct ObjectChecker<DesignSelection> {
        static bool is(const UUID& id, QTModelManager* manager)
        {
            return manager->hasSelectionInfo(id);
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A pointer to a DesignObject within a QTModelManager that recieves and emits update signals
        based on the state of the object.
    **/
    class NDEVR_API QTDesignObject : public QObject
    {
        Q_OBJECT
        friend class QTModelManager;
    protected:
        QTDesignObject(const UUID& object, QTModelManager* manager)
            : m_id(object)
            , m_manager(manager)
        {}
        QTDesignObject(const QTDesignObject& object)
            : QObject()
            , m_id(object.m_id)
            , m_manager(object.m_manager)
        {}
    public:
        ~QTDesignObject()
        {
            lib_assert(!IsInvalid(m_id), "Tried to access Invalid id in QTModel");
        }
    
        template<class t_type>
        bool is() const
        {
            lib_assert(!IsInvalid(m_id), "Tried to access Invalid id in QTModel");
            return ObjectChecker<t_type>::is(m_id, m_manager);
        }
        UUID uuid() const
        {
            return m_id;
        }
        template<class t_type>
        t_type getAs() const
        {
            lib_assert(m_manager->hasObjectID(m_id), "Tried to access Invalid id in QTModel");
            if(DesignObject obj = m_manager->object(m_id))
                return t_type(obj);
            return t_type();
        }
        template<class t_type>
        t_type getProperty(DesignObject::DesignProperty property) const
        {
            return m_manager->object(m_id).getProperty<t_type>(property);
        }
        template<class t_type>
        t_type getModelProperty(Model::ModelProperty property) const
        {
            return getAs<Model>().getModelProperty<t_type>(property);
        }
        template<class t_type>
        t_type getMaterialProperty(Material::MaterialProperties property) const
        {
            return getAs<Material>().getMaterialProperty<t_type>(property);
        }
        template<class t_type>
        t_type getGeometryProperty(Geometry::GeometryProperty property) const
        {
            return getAs<Geometry>().getGeometryProperty<t_type>(property);
        }
 
        TranslatedString displayName() const
        {
            if (is<Model>())
                return getAs<Model>().displayName();
            if (is<Material>())
                return getAs<Material>().displayName();
            return getProperty<TranslatedString>(DesignObject::e_name);
        }
        DesignSelection getAsSelection() const;
        void postCommand(const DynamicPointer<DesignCommand>& command);
        void runCommand(const DynamicPointer<DesignCommand>& command);
        UUID id() const
        {
            return m_id;
        }
        QTModelManager* manager() const
        {
            return m_manager;
        }
        void showProperties(const PopupInfo& location = PopupInfo());
        void exportToFile();
        QTDesignObject& operator=(const QTDesignObject& other)
        {
            lib_assert(m_manager == other.m_manager, "Cannot set equal to Design Object from another Manager");
            m_id = other.m_id;
            return *this;
        }
        DesignObject get() const
        {
            return getAs<DesignObject>();
        }
 
        void updateSelected(UUID id, bool is_selected)
        {
            if (uuid() == id)
            {
                if(is_selected)
                    emit selectedSignal(id);
            }
        }
        void deleteModel(UUID id)
        {
            if (uuid() == id)
                emit deletedSignal(id);
        }
        void updateObject()
        {
            emit updatedSignal(uuid());
        }
        void updateDescendent()
        {
            emit descendentUpdatedSignal(uuid());
        }
    public slots:
        void deleteObject()
        {
            m_manager->deleteObject(uuid());
        }
        void update()
        {
            m_manager->object(uuid()).updateDesignModifiedTime();
        }
        void setFocus(bool focus)
        {
            if(focus)
                m_manager->setFocus(uuid());
        }
        void setSelected(bool is_selected)
        {
            if(is_selected)
                m_manager->setSelected({ m_id });
        }
#if NDEVR_VIEWPORT
        void zoomToModel() const
        {
            m_manager->setViewportFocus(uuid());
        }
#endif
    protected slots:
        
    signals:
        void deletedSignal(UUID id);
        void updatedSignal(UUID id);
        void descendentUpdatedSignal(UUID id);
        void selectedSignal(UUID id);
    protected:
        UUID m_id;
        QTModelManager* m_manager;
    };
}