BuildActionProgramLogic.h

#pragma once
#include "BuildActions.h"
#include "BuildActionWidget.h"
#include "BuildActionItemsWidget.h"
#include "BuildActionUISetupWidget.h"
#include <NDEVR/CustomModelLogic.h>
#include <NDEVR/QTWindowManager.h>
#include <NDEVR/SceneTreeWidget.h>
#include <NDEVR/Ribbon.h>
#include <NDEVR/RibbonSubGroup.h>
#include <NDEVR/RibbonGroup.h>
#include <NDEVR/NDEVRRibbon.h>
#include <NDEVR/SceneTree.h>
#include <NDEVR/DesignObjectDialog.h>
#include <NDEVR/QTIconManager.h>
#include <NDEVR/Button.h>
#include <NDEVR/QTTools.h>
#include <QPointer>
namespace NDEVR
{
    class BuildActionProgramLogic : public CustomModelLogic
    {
    public:
        BuildActionProgramLogic(QTWindowManager* window_manager, QTModelManager* manager)
            : CustomModelLogic(manager, {BuildActionDefinition::TypeName()})
            , m_window_manager(window_manager)
        {
            setSorter([](const Model& a, const Model& b)
            {
                Model parent_a = a.getParent();
                Model parent_b = b.getParent();
                if (parent_a == parent_b && parent_a.isValid())
                    return a.getChildIndex() > b.getChildIndex();
                else
                    return a.get<NDPO::creation_time>()
                        > b.get<NDPO::creation_time>();
            });
        }

        Button* createButton(const BuildActionDefinition& definition)
        {
            Button* b = new Button(definition.displayName()
                , definition.getIcon()
                , [definition, this](Button* b)
                {
                    ShowPropertiesSettings settings(definition.get<NDPO::guid>(), b);
                    m_window_manager->showModelProperties(settings);
                });
            m_buttons[definition.get<NDPO::guid>()].add(b);
            return b;
        }

        bool canBeHandledBySelectionWidget() const override
        {
            return false;
        }

        void setupUI(const BuildActionDefinition& definition)
        {
            if (m_buttons.hasKey(definition.get<NDPO::guid>()))
            {
                for (auto iter : m_buttons[definition.get<NDPO::guid>()])
                {
                    if (!iter.isNull())
                        delete iter;
                }
                m_buttons.clear();
                m_window_manager->ribbon()->ribbon()->cleanupEmpty();
            }
            BuildActionUIDefinition ui = definition.uiDefinition();
            if (ui.show_at_bottom_of_tree)
                m_window_manager->sceneTree()->widget().addButton(createButton(definition));
            if (ui.show_on_ribbon)
            {
                String group = ui.ribbon_group;
                RibbonGroup* ribbon_group = nullptr;
                if (group.size() == 0)
                    ribbon_group = m_window_manager->ribbon()->homeRibbonGroup();
                else
                    ribbon_group = &m_window_manager->ribbon()->ribbon()->group(TranslatedString(group));
                String sub_group = ui.ribbon_sub_group;
                if (sub_group.size() == 0)
                    sub_group = "General";
                RibbonSubGroup& ribbon_sub_group = (*ribbon_group)[TranslatedString(sub_group)];
                ribbon_sub_group.addButton(createButton(definition), Constant<uint04>::Invalid, true);
            }
        }
        //Override the below to add custom program behavior
    protected:
        //Adds menu items to context menus when model of type is selected
        QAction* m_run_menu_action = nullptr;               
        QAction* m_create_new_action_before = nullptr;      
        QAction* m_create_new_action_after = nullptr;       
        QAction* m_create_child_action = nullptr;           
        virtual void addMenuItems(Model& model, QTModelManager*, QMenu& menu, const Buffer<UUID>&, const SelectionInfo&) override
        {
            m_run_menu_action = menu.addAction(QTIconManager::GetIconResourceBlocking("play"), _tqa("Run"));
            BuildActionDefinition definition(model);
            switch (definition.action())
            {
            case BuildAction::e_workflow:
            case BuildAction::e_process_files:
            case BuildAction::e_variable_loop:
            case BuildAction::e_file_loop:
            case BuildAction::e_index_loop:
                m_create_child_action = menu.addAction(QTIconManager::GetIconResourceBlocking("plus"), _tqa("Create Child Action"));
                break;
            default:
                m_create_child_action = nullptr;
                break;
            }
            Model parent = model.getParent();
            if (parent.isValid())
            {
                m_create_new_action_before = menu.addAction(QTIconManager::GetIconResourceBlocking("plus"), _tqa("Create Action Before"));
                m_create_new_action_after = menu.addAction(QTIconManager::GetIconResourceBlocking("plus"), _tqa("Create Action After"));
            }
            else
            {
                m_create_new_action_before = nullptr;
                m_create_new_action_after = nullptr;
            }
        }
        //executes menu items to context menus when model of type is selected
        void executeMenuItems(Model& model, QTModelManager* manager, QAction* action,  const Buffer<UUID>&, const SelectionInfo&, PopupInfo info) override
        {
            if (action == m_run_menu_action)
            {
                BuildActionDefinition definition(m_last_model);
                LogPtr info_pipe = manager->logManager()->getLog(definition.defaultLogName());
                definition.executeThreaded(manager->lockPtr(), info_pipe);
            }
            if (action == m_create_child_action)
            {
                createAndShowChildDefinition(model, info);
            }
            if (action == m_create_new_action_before || action == m_create_new_action_after)
            {
                WLock lock = manager->writeLock();
                Model parent = model.getParent();
                if (!parent.isValid())
                    return;
                uint04 idx = model.getChildIndex();
                if (action == m_create_new_action_after)
                    idx++;
                BuildActionDefinition definition(parent.createChild(idx));
                parent.updateModifiedTime();
                manager->addModel(definition);
                ShowPropertiesSettings settings(definition.get<NDPO::guid>(), DesignDialogStyle::e_object_creation, info);
                manager->ShowProperties(settings);
            }
        }
        //modifies property dialogs when objects are created
        virtual void setupPropertiesDialog(DesignObjectDialog* dialog, const DynamicPointer<QTDesignObject>& object) override
        {
            dialog->addTabDialog(new BuildActionWidget(object));
            dialog->addTabDialog(new BuildActionItemsWidget(object));
            dialog->addTabDialog(new BuildActionUISetupWidget(object, this));
        }
        //performs any needed setup for the model when it is read in via ndv file
        virtual void setupModel(Model& model) override
        {
            if (!model.is<NDPN::type>(BuildActionDefinition::TypeName()))
                return;
            BuildActionDefinition def(model);
            def.set<NDPO::application_locked>(false);
            def.set<NDPN::model_color>(Constant<RGBColor>::Invalid);
            setupUI(BuildActionDefinition(model));
        }
        //custom buttons that appear when selected or selected with the tree
        virtual void setTreeWidgetsForSelection(const Model& model, Buffer<QWidget*>& widgets, SceneTree* tree) override
        {
            widgets.setSize(1);
            if (m_play_button == nullptr)
            {
                m_play_button = new Button(_t("Run"), "play", [this, tree](Button*)
                {
                    BuildActionDefinition definition(m_last_model);
                    LogPtr info = tree->manager()->logManager()->getLog(definition.defaultLogName());
                    definition.executeThreaded(tree->manager()->lockPtr(), info);
                });
                m_play_button->setButtonState(Button::e_small);
                m_play_button->setFlat(true);
            }
            BuildActionDefinition definition(model);
            switch (definition.action())
            {
            case BuildAction::e_workflow:
            case BuildAction::e_process_files:
            case BuildAction::e_variable_loop:
            case BuildAction::e_file_loop:
            case BuildAction::e_index_loop:
            {
                m_create_child_button = new Button(_t("Create Child"), "new", [this, tree](Button* b)
                {
                    createAndShowChildDefinition(m_last_model, b);
                });
                m_create_child_button->setButtonState(Button::e_small);
                m_create_child_button->setFlat(true);
                widgets.add(m_create_child_button);
            }
            default:
                break;
            }
            m_last_model = model;
            widgets.add(m_play_button);
        };

        void createAndShowChildDefinition(Model& model, PopupInfo info)
        {
            WLock lock = m_manager->writeLock();
            auto definition = BuildActionDefinition(model).createChildBuildDefinition();
            m_manager->addModel(definition);
            ShowPropertiesSettings settings(definition.get<NDPO::guid>(), DesignDialogStyle::e_object_creation, info);
            m_manager->ShowProperties(settings);
        }
        Model m_last_model;                                             
        Button* m_play_button = nullptr;                                
        Button* m_create_child_button = nullptr;                        
        QTWindowManager* m_window_manager;                              
        Dictionary<UUID, Buffer<QPointer<Button>>> m_buttons;           
    };
 
}