QTModelManager.h

/*--------------------------------------------------------------------------------------------
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/ApplicationOption.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;
    class NDEVR_API GraphicsManagerBase : public QObject, public SoftwareService
    {
        Q_OBJECT
    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 updateActive(const DynamicPointer<GraphicsSession>& session, bool add_cameras = true) = 0;
        virtual void addRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual Buffer<DynamicPointer<GraphicsSession>> availableSessions() const = 0;
        virtual void executeRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual void removeRequest(const ConstPointer<CaptureRequest>& request) = 0;
        virtual void clearAll() = 0;
        virtual bool canServiceCaptureRequests() const = 0;
    signals:
        void captureManagerStateChangeSignal(); 
        void graphicsSessionChangeSignal(); 
    };

    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; 
    };

    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 add_all_objects = true) 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, bool generate_decorations = true) 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 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(const Buffer<UUID>& ids);
        virtual void removeSelected(UUID id);
        ProjectFileManager* projectFileManager() { return m_project_file_manager; }
        GraphicsManagerBase* graphicsManager();
        void setGraphicsManager(GraphicsManagerBase* 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 StringView& callback_name, const std::function<void(const UUID&)>& callback);
        const Dictionary<String, std::function<void(const UUID&)>>& requestDeploymentCallbacks();
        virtual bool useProjectFolders() const;
        virtual void postDesignCommand(const DynamicPointer<DesignCommand>& command) override;
        virtual void runDesignCommand(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);
        virtual void _qtUpdateObject(UUID object);
        void appendToAddQueue(UUID id);
 
    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 onAddScene(Buffer<UUID> id); 
        void onModelTopLevelChange(Buffer<UUID> id); 
        void onAddModel(Buffer<UUID> id); 
        void onAddCamera(UUID id); 
        void onAddMaterial(Buffer<UUID> id); 
        void onAddGeometry(Buffer<UUID> id); 
        void addLayerSignal(Buffer<UUID> id); 
        void onActiveProjectChanged(UUID id); 
        void onCommandExecutedSignal(UUID id); 
        void onAddCommand(UUID id); 
        void onAddViewportObject(UUID camera, UUID object); 
        void onShowPropertiesRequested(UUID object); 
        void captureManagerStateChangeSignal(); 
        void graphicsSessionChangeSignal(); 
        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 objectsUpdatedSignal(const Buffer<UUID>& ids); 
        void modelsUpdatedSignal(const Buffer<UUID>& ids); 
        void materialsUpdatedSignal(const Buffer<UUID>& ids); 
        void onProjectUpdatedSignal(); 
 
        void layersUpdatedSignal(const Buffer<UUID>& ids); 
        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 _performDeletion();
        void _refreshModelList();
    private:
        void finishCommand(const DynamicPointer<DesignCommand>& command) override;
    protected:
        Buffer<UUID> m_model_update_cache; 
        Buffer<UUID> m_layer_update_cache; 
        Buffer<UUID> m_geometry_update_cache; 
        Buffer<UUID> m_scene_update_cache; 
        Buffer<UUID> m_camera_update_cache; 
        Buffer<UUID> m_material_update_cache; 
#if NDEVR_VIEWPORT
        SelectionTreeManager m_selection_tree_manager; 
#endif
        Time m_last_qt_update_time; 
        Time m_last_audit_time; 
        Time m_last_tree_create_time = Time(0); 
        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_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; 
    };
    
}