QTModelManager.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: QTModelManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/PopupInfo.h>
#include <NDEVR/SelectionTreeManager.h>
#include <NDEVR/Model.h>
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/SnapLocation.h>
 
#include <NDEVR/UUID.h>
#include <NDEVR/Dictionary.h>
#include <QTimer>
class QMenu;
class QMimeData;
namespace NDEVR
{
    struct FileRequest;
    struct ExportRequest;
    struct ShowPropertiesSettings;
    class QTModelManagerView;
    class QTDesignObject;
    class WindowManager;
    class VulkanSession;
    class QCaptureManager;
    class CachedFactoryIOThread;
    class FileFormat;
    class LibraryManager;
    class ModelEditController;
    class BasicThread;
    class Thread;
    class Project;
    struct FactoryParameters;
    class QTModelManager;
    class ProjectFileManager;
    class ContextMenuManager;
    class DesignCommand;
    class GraphicsSession;
    class GraphicsDevice;
    struct CaptureRequest;
    /**--------------------------------------------------------------------------------------------------
    \brief Used for interfacing with a Gaphics engine, such as Vulkan or OpenGL.
    **/
    class GraphicsManagerBase : public QObject, public SoftwareService
    {
    public:
        virtual bool hasGraphicsSession(const DynamicPointer<GraphicsDevice>& device) = 0;
        virtual const DynamicPointer<GraphicsSession>& graphicsSession(const DynamicPointer<GraphicsDevice>& device) = 0;
        virtual void addGraphicsSession(DynamicPointer<GraphicsSession> session, bool add_cameras = true) = 0;
        virtual bool requestHandleManagerUpdating() const = 0;
        virtual void addRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual void executeRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual void removeRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual void clearAll() const = 0;
        virtual bool canServiceCaptureRequests() const = 0;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores a default rendering engine to be used with the application.
    **/
    class GraphicsManagerFactory : public SoftwareServiceManager
    {
    public:
        virtual GraphicsManagerBase* createManager(QTModelManager* manager) = 0;
    public:
        static NDEVR_API void SetDefaultFactory(GraphicsManagerFactory* factory);
        static NDEVR_API GraphicsManagerFactory* DefaultFactory();
    protected:
        static GraphicsManagerFactory* s_factory;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A wrapper around DesignObjectLookup that provides signal and slot functionality and adds
        rendering capabilities to the model heirarchy.
    **/
    class NDEVR_API QTModelManager : public QObject, public DesignObjectLookup
    {
        Q_OBJECT
    public:
        QTModelManager();
        QTModelManager(const QTModelManager& manager) = delete;
        virtual ~QTModelManager();
        virtual void addScene(Scene object, bool ignore_application_scene = false) override;
        virtual void addGeometry(Geometry object) override;
        virtual void addModel(Model object) override;
        virtual void addLayer(Model object) override;
        virtual void addMaterial(Material object) override;
        virtual LogManager* logManager() const override;
#if NDEVR_VIEWPORT
        virtual void addCamera(const DynamicPointer<Camera>& object) override;
#endif
        void deleteObject(UUID id) override;
        virtual void eraseModel(UUID id) override;
        virtual Model restoreModel(UUID id) override;
        virtual QTModelManagerView* modelManagerView();
 
        virtual void addCameraModel(const UUID& camera, const Model& object) override;
        
        virtual DynamicPointer<QTDesignObject> getQTObject(UUID id);
        virtual Buffer<DynamicPointer<QTDesignObject>> getQTObjectsByID(const Buffer<UUID>& ids);
 
        virtual void ShowProperties(const ShowPropertiesSettings& settings);
        
        
        WindowManager* windowManager() { return m_window_manager; }
        virtual void setWindowManager(WindowManager* manager) { m_window_manager = manager; }
        ContextMenuManager* contextMenuManager() { return m_context_menu_manager; }
 
        virtual Buffer<UUID> selected() const;
        
        
        virtual void updateModelTopLevel(const Model& object) override;
        virtual void update(const Time& time, const std::function<void()>& wait_callback) override;
        virtual void setActiveProject(UUID project_id) override;
        virtual DynamicPointer<LibraryManager> libraryManager();
        
        virtual bool canProcessMimeData(const QMimeData* data) const;
        virtual void processMimeData(const QMimeData* data, PopupInfo origin = PopupInfo());
        virtual void exportModels(ExportRequest request);
        virtual void saveModel(FactoryParameters& file, bool is_blocking = false);
        //virtual void loadModel(Buffer<FactoryParameters, uint04, ObjectAllocator<false>>& files, bool is_blocking = false);
        virtual void setActiveLayer(UUID layer_id) override;
        virtual void startQTUpdate(const TimeSpan& interval);
        virtual void stopQTUpdate();
        virtual void stopAll();
        virtual void clearSelected() override;
        virtual void setSelected(Buffer<UUID> ids) override;
        virtual void appendSelected(Buffer<UUID> ids) override;
        virtual void removeSelected(Buffer<UUID> ids);
        ProjectFileManager* projectFileManager() { return m_project_file_manager; }
        GraphicsManagerBase* graphicsManager();
        void setGraphicsManager(GraphicsManagerBase* graphics_manager) { m_graphics_manager = graphics_manager; };
        virtual DesignTaskManager* taskManager() const override;
        virtual bool hasBeenModified() const;
        virtual void requestQTUpdate();
        virtual void clearAll() override;
        virtual bool hasUserSavedProject() const;
        virtual void setProjectTimeZone();
        void popSelected(const UUID& id, bool signal = true);
        void addSelected(const UUID& id, bool signal = true);
        void setRequestDeploymentCallback(const String& callback_name, const std::function<void(const UUID&)>& callback);
        const Dictionary<String, std::function<void(const UUID&)>>& requestDeploymentCallbacks();
        virtual bool useProjectFolders() const;
        virtual void postCommand(const DynamicPointer<DesignCommand>& command) override;
        virtual void runCommand(const DynamicPointer<DesignCommand>& command) override;
    private:
        virtual void _qtUpdate(const Time& time);
        virtual void _qtUpdateDeleted(UUID model);
        virtual void _qtUpdateDeleted();
        virtual void _qtUpdateAdded();
        virtual void _qtUpdateModified();
        virtual void _qtUpdateModelModified(UUID model, Buffer<UUID>& ids);
    
    public slots:
        void popFocus();
        void setSelectedToFocus();
        void setFocus(UUID id);
    protected slots:
        void qtUpdate();
    signals:
        void canExitApplicationSignal(bool can_exit);
        void canOpenProjectSignal(bool can_open_project);
        void canImportFileSignal(bool can_import_file);
        void onClearAllSignal();
        void onRefreshObject(UUID id);
        void onAddScene(Buffer<UUID> id);
        void onModelTopLevelChange(Buffer<UUID> id);
        void onAddModel(Buffer<UUID> id);
        void onAddCamera(UUID id);
        void onAddMaterial(Buffer<UUID> id);
        void addLayerSignal(Buffer<UUID> id);
        void onActiveProjectChanged(UUID id);
        void onCommandExecutedSignal(UUID id);
        void onAddGeometry(Buffer<UUID> id);
        void onAddCommand(UUID id);
        void onAddCameraObject(UUID camera, UUID object);
        void onShowPropertiesRequested(UUID object);
        void onZoomToModel(SnapLocation location, UUID id, UUID camera);
        void onZoomToModel(SnapLocation location, UUID id);
 
        void onDeleteObjects(Buffer<UUID> ids);
        void onDeleteModel(UUID id);
        void onDeleteGeometry(UUID id);
        void onDeleteMaterial(UUID id);
        void onDeleteCamera(UUID id);
        void onDeleteObject(UUID id);
        void onDeleteCommand(UUID id);
        
        void onCleanupRequestSignal();
 
        void onObjectUpdatedSignal(const Buffer<UUID>& ids);
        void layerUpdatedSignal(UUID id);
        void activeLayerChangedSignal(UUID id);
        void onUpdateCommand(UUID id);
        void onSelectedSignal(Buffer<UUID> ids, bool selected);
        void onSwapSelectedSignal(Buffer<UUID> old_selected, Buffer<UUID> new_selected);
        void onUpdateFocus(UUID id, bool focussed);
    private slots:
        void _cleanupMemory();
        void _refreshModelList();
    private:
        void finishCommand(const DynamicPointer<DesignCommand>& command) override;
        void refreshScene(UUID object, bool ignore_application_scene) override;
    protected:
#if NDEVR_VIEWPORT
        SelectionTreeManager m_selection_tree_manager;
#endif
        Time m_last_qt_update_time;
        Time m_last_audit_time;
        UUID m_focused_object;
        QTimer m_launch_timer;
        QTimer m_auto_save_timer;
        Buffer<UUID> m_added_objects;
        Buffer<UUID> m_deleted_objects;
        Buffer<UUID> m_erased_objects;
        Buffer<UUID> m_selected_object;
        Buffer<UUID> m_objects_to_remove;
        Buffer<UUID> m_top_level_change;
        Dictionary<UUID, DynamicPointer<QTDesignObject>> m_qt_design_objects;
        WindowManager* m_window_manager = nullptr;
        ProjectFileManager* m_project_file_manager = nullptr;
        QTModelManagerView* m_manager_view = nullptr;
        ContextMenuManager* m_context_menu_manager = nullptr;
        GraphicsManagerBase* m_graphics_manager = nullptr;
        DynamicPointer<LibraryManager> m_library_manager;
#if NDEVR_SUPPORTS_THREADING
        CachedFactoryIOThread* m_write_thread = nullptr;
#endif
        bool m_needs_cleanup;
        bool m_is_updating;
        Dictionary<String, std::function<void(const UUID&)>> m_request_deployment_callbacks;
    };
    
}