WindowManager3D.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: QTWindowManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#if NDEVR_VIEWPORT
#include <NDEVR/WindowManager.h>
#include <NDEVR/WidgetInit.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/Buffer.h>
#include <QPointer>
namespace NDEVR
{
    class QCustomDockWidget;
    class SceneTreeWidget;
    class SelectionWidget;
    class DownloadDatasetWidget;
    class LibraryWidget;
    class ReportGeneratorDialog;
    class AsciiFileOutputStream;
    class ModelCommandsWidget;
    class QTResourceListener;
    class Toolbar;
    class GettingStartedDialog;
    class DrawCommandsWidget;
    class MeasurementCommandsWidget;
    class NDEVRRibbon;
    class StatusBar;
    class CameraPane;
    class CameraView;
    class MainWindow;
    class CustomDockButton;
    class NDEVR_API QTWindowManager : public WindowManager
    {
        Q_OBJECT
    public:
        QTWindowManager(QTModelManager* manager, const Buffer<String>& args = Buffer<String>());

        virtual void addCustomDockWidget(DockInit* widget) override;

        virtual void showModelProperties(const ShowPropertiesSettings& settings) override;

        virtual void updateModified() override;

        virtual void requestExitWithFunction(std::function<void()> exit_function, const PopupInfo& popup_origin = PopupInfo()) override;

        virtual void exit(bool relaunch = false, const StringView& relaunch_options = "--relaunch") override;

        virtual ContainerWidget* container() const override;

        virtual QWidget* mainWindow() const override;

        virtual void userZoomToModel(const UUID& id);

        template<class t_dock_type>
        DockWidget<t_dock_type>* customDock() const
        {
            for (uint04 i = 0; i < m_custom_dock_widgets.size(); i++)
            {
                if (m_custom_dock_widgets[i] != nullptr)
                {
                    if (DockWidget<t_dock_type>* dock = dynamic_cast<DockWidget<t_dock_type>*>(m_custom_dock_widgets[i]->getDock()))
                        return dock;
                }
            }
            return nullptr;
        }

        const Buffer<String>& args() const { return m_args; }
        virtual void setAutoCreateCameras(bool autocreate) { m_auto_create_camera_windows = autocreate; }
        virtual bool autoCreateWindows() { return m_auto_create_camera_windows; }
        virtual MainWindow* createWindow(uint04 monitor_number);
        virtual void addWindow(MainWindow* window);
        virtual uint04 windowCount() const { return m_main_windows.size(); };
        void finishInitialSetup();
        virtual bool isClosing() const { return m_is_exiting; }
        virtual MainWindow* window(uint04 index) const { return m_main_windows[index]; };
        virtual NDEVRRibbon* ribbon() const;
        virtual DockWidget<GettingStartedDialog>* home() const;
        virtual DockWidget<SceneTreeWidget>* sceneTree() const;
        virtual DockWidget<SelectionWidget>* selectionWidget();
        virtual DockWidget<DrawCommandsWidget>* drawEditor();
        virtual DockWidget<MeasurementCommandsWidget>* measureEditor();
        virtual DockWidget<LibraryWidget>* libraryEditor();
        virtual DockWidget<ModelCommandsWidget>* modelEditor();
        virtual DockWidget<DownloadDatasetWidget>* downloadWidget();
        virtual Toolbar* verticalModeToolbar();
        virtual void closeWindow(MainWindow* window, QCloseEvent* event);
        virtual String mainWindowPreferedName() const;
        virtual DockWidget<CameraPane>* cameraPane() const;
        DockWidget<CameraView>* cameraView(const UUID& camera) const;
        Buffer<QPointer<DockWidget<CameraView>>> cameraViews() const;
        virtual void onViewportSelection(UUID id);
    protected:
        virtual void closeWindow(uint04 index, QCloseEvent* event);
        virtual void setupViews();
        bool eventFilter(QObject* Object, QEvent* Event) override;
        virtual MainWindow* createMainWindow(uint04 monitor_number);
        virtual SceneTreeWidget* createSceneTree() const;
        virtual SelectionWidget* createSelectionWidget() const;
        virtual GettingStartedDialog* createGettingStartedDialog() const;
        virtual LibraryWidget* createLibraryWidget() const;
        virtual LogManagerDialog* createLogView() override;
        virtual DownloadDatasetWidget* createDownloadDatabaseWidget();
        void setupLogs();
        virtual QCustomDockWidget* largestCameraView(bool check_visible = true) const;
        virtual void recoverLastData() override;
        virtual void setupRibbons(bool setup_all);
        virtual void setupCameraPanels();
        virtual void readArgs(const Buffer<String>& args);
        virtual void readArg(const StringView& arg, const StringView& data);
        virtual DropArea defaultDropArea(const QCustomDockWidget* dock_widget) const override;
        virtual SectionWidget* defaultDropReference(const QCustomDockWidget* dock_widget = nullptr) const override;
        virtual RibbonArea defaultRibbonArea(const QCustomDockWidget* dock_widget) override;
        virtual void updateRemoteWidgets(const Buffer<QPointer<QWidget>>& widgets, bool are_remote);
        virtual void clearAll() override;
        void layoutAll() override;
        void swapCameras(DockWidget<CameraView>* camera_a, DockWidget<CameraView>* camera_b);
        void onCameraLayoutUpdated(Buffer<QPointer<DockWidget<CameraView>>>& removed_views);
        void hideCurrentSelectionEditorDialog();
    public slots:
        void setupRemoteWidgetsSlot();
        void setupSelectionWidget();
        void refreshCameraSwap();
        void cameraSwapSlot(UUID camera);
    protected slots:
        void addUserData(Buffer<UUID> object);
        void designObjectAdded(Buffer<UUID> object);
        void onDesignObjectDelete(Buffer<UUID> object);
        void onCameraDelete(UUID camera);
        void onCameraAdd(UUID camera);
        void updateProjectSlot();
        void onClearSlot();
    protected:
        Buffer<String> m_args; 
        Buffer<QPointer<QWidget>> m_active_screen_widgets; 
        Buffer<QPointer<QWidget>> m_inactive_screen_widgets; 
        StatusBar* m_status_bar = nullptr; 
        mutable DockWidget<SceneTreeWidget>* m_scene_tree_dock = nullptr; 
        mutable DockWidget<SelectionWidget>* m_selection_dock = nullptr; 
        DockWidget<ReportGeneratorDialog>* m_report_generator = nullptr; 
        DockWidget<DrawCommandsWidget>* m_draw_editor_dock = nullptr; 
        DockWidget<DownloadDatasetWidget>* m_download_widget = nullptr; 
        DockWidget<LibraryWidget>* m_library_dock = nullptr; 
        QPointer<DockWidget<ModelCommandsWidget>> m_model_edit_dock = nullptr; 
        QPointer<DockWidget<MeasurementCommandsWidget>> m_measure_editor_dock = nullptr; 
        Toolbar* m_vertical_mode_toolbar = nullptr; 
        CustomDockButton* m_add_camera_button = nullptr; 
        Buffer<MainWindow*> m_main_windows; 
        UUID m_selected_editor_id = Constant<UUID>::Invalid; 
        bool m_auto_create_camera_windows; 
        bool m_has_model_content; 
    };
}
#endif