geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl Class Reference

Collaboration diagram for geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl:

Public Member Functions
	ImageTaskScriptingWidgetImpl (ImageTaskScriptingWidget *pQ)
	~ImageTaskScriptingWidgetImpl ()=default
ImageTaskScriptingWidgetImpl	operator= (const ImageTaskScriptingWidgetImpl &)=delete
	ImageTaskScriptingWidgetImpl (const ImageTaskScriptingWidgetImpl &)=delete
void	setImageTask (task::ImageTask *task)
void	syncUserInterface ()
std::map< std::string, std::string >	getShapeMutationScripts ()
std::map< std::string, std::string >	getScripts () const
bool	evaluateScriptsWithBooleanReturnValue (const std::string &scriptPrefix) const
void	evaluateScriptsWithNoReturnValue (const std::string &scriptGroupNamePrefix) const
bool	evaluateStopConditionScripts () const
void	evaluateOnStopConditionMetScripts () const
void	evaluateBeforeStepScripts () const
void	evaluateAfterStepScripts () const
bool	evaluateAddShapePreconditionScripts () const
void	evaluateBeforeAddShapeScripts () const
void	evaluateAfterAddShapeScripts () const
void	evaluateOnPenInputEventScripts () const
void	evaluateOnPenProximityEnterEventScripts () const
void	evaluateOnPenProximityExitEventScripts () const
void	evaluateOnKeyDownEventScripts () const
void	evaluateOnKeyUpEventScripts () const
void	evaluateOnMouseDownEventScripts () const
void	evaluateOnMouseUpEventScripts () const
void	evaluateOnMouseMoveEventScripts () const
void	evaluateOnMouseWheelEventScripts () const
void	evaluateOnTimedUpdateEventScripts () const
void	onLanguageChange ()

Private Member Functions
void	addScriptWidget (const std::string &scriptDisplayName, const std::string &functionName, const std::string &scriptCode)
void	addBeforeStepCallbackWidget (const std::string &scriptCode)
void	addAfterStepCallbackWidget (const std::string &scriptCode)
void	addCustomStopConditionWidget (const std::string &scriptCode)
void	addOnStopConditionMetWidget (const std::string &scriptCode)
void	addShapePreconditionWidget (const std::string &scriptCode)
void	addBeforeAddShapeCallbackWidget (const std::string &scriptCode)
void	addAfterAddShapeCallbackWidget (const std::string &scriptCode)
void	addOnPenInputWidget (const std::string &scriptCode)
void	addOnPenProximityEnterWidget (const std::string &scriptCode)
void	addOnPenProximityExitWidget (const std::string &scriptCode)
void	addOnKeyDownWidget (const std::string &scriptCode)
void	addOnKeyUpWidget (const std::string &scriptCode)
void	addOnMouseDownWidget (const std::string &scriptCode)
void	addOnMouseUpWidget (const std::string &scriptCode)
void	addOnMouseMoveWidget (const std::string &scriptCode)
void	addOnMouseWheelWidget (const std::string &scriptCode)
void	addOnTimedUpdateWidget (const std::string &scriptCode)
void	revealShapeScriptingPanel ()
void	setScripts (const std::map< std::string, std::string > &scripts)
dialog::ScriptEditorWidget *	findEditor (const std::string &editorId)
geometrize::dialog::ImageTaskShapeScriptingPanel *	getShapeScriptingPanel () const
void	populateUi ()
void	populateScriptSelectionComboBox (QComboBox *combo, const std::map< std::string, std::string > &scripts)
std::string	getScriptForSelectedComboBoxItem (QComboBox *combo)
void	buildScriptSelectionComboBoxes ()
std::string	makeUniqueFunctionName (const std::string &prefix)

Static Private Member Functions
static bool	startsWith (const std::string &s, const std::string &prefix)

Private Attributes
task::ImageTask *	m_task {nullptr}
ImageTaskScriptingWidget *	q
std::unique_ptr< Ui::ImageTaskScriptingWidget >	ui

Constructor & Destructor Documentation

ImageTaskScriptingWidgetImpl() [1/2]

geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::ImageTaskScriptingWidgetImpl ( ImageTaskScriptingWidget *  pQ )

inline

                                                               : q{pQ}, ui{std::make_unique<Ui::ImageTaskScriptingWidget>()}
    {
        ui->setupUi(q);
        populateUi();
 
        new geometrize::dialog::ImageTaskShapeScriptingPanel(q);
 
        // Populate the preset script comboboxes with the default/built-in scripts
        buildScriptSelectionComboBoxes();
 
        connect(ui->clearScriptsButton, &QPushButton::clicked, [this]() {
            QLayoutItem* item = nullptr;
            while((item = ui->customScriptsEditorLayout->takeAt(0)) != nullptr) {
                delete item->widget();
                delete item;
            }
        });
        connect(ui->rescanScriptsButton, &QPushButton::clicked, [this]() {
            buildScriptSelectionComboBoxes();
        });
 
        connect(ui->editShapeScriptsButton, &QPushButton::clicked, [this]() {
            revealShapeScriptingPanel();
        });
 
        connect(ui->addBeforeStepEvent, &QPushButton::clicked, [this]() {
            addBeforeStepCallbackWidget(getScriptForSelectedComboBoxItem(ui->addBeforeStepPresetScriptsComboBox));
        });
        connect(ui->addAfterStepEvent, &QPushButton::clicked, [this]() {
            addAfterStepCallbackWidget(getScriptForSelectedComboBoxItem(ui->addAfterStepPresetScriptsComboBox));
        });
        connect(ui->addStopConditionButton, &QPushButton::clicked, [this]() {
            addCustomStopConditionWidget(getScriptForSelectedComboBoxItem(ui->addStopConditionPresetScriptsComboBox));
        });
        connect(ui->addShapePreconditionButton, &QPushButton::clicked, [this]() {
            addShapePreconditionWidget(getScriptForSelectedComboBoxItem(ui->addShapePreconditionPresetScriptsComboBox));
        });
        connect(ui->onStopConditionMetEvent, &QPushButton::clicked, [this]() {
            addOnStopConditionMetWidget(getScriptForSelectedComboBoxItem(ui->onStopConditionMetEventComboBox));
        });
        connect(ui->addBeforeAddShapeEvent, &QPushButton::clicked, [this]() {
            addBeforeAddShapeCallbackWidget(getScriptForSelectedComboBoxItem(ui->addBeforeAddShapePresetScriptsComboBox));
        });
        connect(ui->addAfterAddShapeEvent, &QPushButton::clicked, [this]() {
            addAfterAddShapeCallbackWidget(getScriptForSelectedComboBoxItem(ui->addAfterAddShapePresetScriptsComboBox));
        });
        connect(ui->onScenePenInputEvent, &QPushButton::clicked, [this]() {
            addOnPenInputWidget(getScriptForSelectedComboBoxItem(ui->onScenePenInputEventPresetScriptsComboBox));
        });
        connect(ui->onPenProximityEnterEvent, &QPushButton::clicked, [this]() {
            addOnPenProximityEnterWidget(getScriptForSelectedComboBoxItem(ui->onPenProximityEnterEventPresetScriptsComboBox));
        });
        connect(ui->onPenProximityExitEvent, &QPushButton::clicked, [this]() {
            addOnPenProximityExitWidget(getScriptForSelectedComboBoxItem(ui->onPenProximityExitEventPresetScriptsComboBox));
        });
        connect(ui->onKeyDownEvent, &QPushButton::clicked, [this]() {
            addOnKeyDownWidget(getScriptForSelectedComboBoxItem(ui->onKeyDownEventPresetScriptsComboBox));
        });
        connect(ui->onKeyUpEvent, &QPushButton::clicked, [this]() {
            addOnKeyUpWidget(getScriptForSelectedComboBoxItem(ui->onKeyUpEventPresetScriptsComboBox));
        });
        connect(ui->onMouseDownEvent, &QPushButton::clicked, [this]() {
            addOnMouseDownWidget(getScriptForSelectedComboBoxItem(ui->onMouseDownEventPresetScriptsComboBox));
        });
        connect(ui->onMouseUpEvent, &QPushButton::clicked, [this]() {
            addOnMouseUpWidget(getScriptForSelectedComboBoxItem(ui->onMouseUpEventPresetScriptsComboBox));
        });
        connect(ui->onMouseMoveEvent, &QPushButton::clicked, [this]() {
            addOnMouseMoveWidget(getScriptForSelectedComboBoxItem(ui->onMouseMoveEventPresetScriptsComboBox));
        });
        connect(ui->onMouseWheelEvent, &QPushButton::clicked, [this]() {
            addOnMouseWheelWidget(getScriptForSelectedComboBoxItem(ui->onMouseWheelEventPresetScriptsComboBox));
        });
        connect(ui->onUpdateEvent, &QPushButton::clicked, [this]() {
            addOnTimedUpdateWidget(getScriptForSelectedComboBoxItem(ui->onUpdateEventPresetScriptsComboBox));
        });
 
        // Update the script code when the editor modifies them
        connect(q, &geometrize::dialog::ImageTaskScriptingWidget::signal_scriptChanged, [this](const std::string& functionName, const std::string& code) {
            if(m_task) {
                m_task->getPreferences().setScript(functionName, code);
            }
        });
 
        // Reveal shape scripting panel if global preferences are set this way
        const geometrize::preferences::GlobalPreferences& prefs{geometrize::preferences::getGlobalPreferences()};
        if(prefs.shouldShowImageTaskScriptEditorByDefault()) {
            revealShapeScriptingPanel();
        }
    }

~ImageTaskScriptingWidgetImpl()

geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::~ImageTaskScriptingWidgetImpl ( )

default

ImageTaskScriptingWidgetImpl() [2/2]

geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::ImageTaskScriptingWidgetImpl ( const ImageTaskScriptingWidgetImpl &  )

delete

Member Function Documentation

addAfterAddShapeCallbackWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addAfterAddShapeCallbackWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("After Add Shape Callback").toStdString(), makeUniqueFunctionName(::afterAddShapeCallbackPrefix), scriptCode);
    }

addAfterStepCallbackWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addAfterStepCallbackWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("After Step Callback").toStdString(), makeUniqueFunctionName(::afterStepCallbackPrefix), scriptCode);
    }

addBeforeAddShapeCallbackWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addBeforeAddShapeCallbackWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("Before Add Shape Callback").toStdString(), makeUniqueFunctionName(::beforeAddShapeCallbackPrefix), scriptCode);
    }

addBeforeStepCallbackWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addBeforeStepCallbackWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("Before Step Callback").toStdString(), makeUniqueFunctionName(::beforeStepCallbackPrefix), scriptCode);
    }

addCustomStopConditionWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addCustomStopConditionWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("Custom Stop Condition").toStdString(), makeUniqueFunctionName(::stopConditionIdPrefix), scriptCode);
    }

addOnKeyDownWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnKeyDownWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Key Down Callback").toStdString(), makeUniqueFunctionName(::onKeyDownCallbackPrefix), scriptCode);
    }

addOnKeyUpWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnKeyUpWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Key Up Callback").toStdString(), makeUniqueFunctionName(::onKeyUpCallbackPrefix), scriptCode);
    }

addOnMouseDownWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnMouseDownWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Mouse Down Callback").toStdString(), makeUniqueFunctionName(::onMouseDownCallbackPrefix), scriptCode);
    }

addOnMouseMoveWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnMouseMoveWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Mouse Move Callback").toStdString(), makeUniqueFunctionName(::onMouseMoveCallbackPrefix), scriptCode);
    }

addOnMouseUpWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnMouseUpWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Mouse Up Callback").toStdString(), makeUniqueFunctionName(::onMouseUpCallbackPrefix), scriptCode);
    }

addOnMouseWheelWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnMouseWheelWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Mouse Wheel Callback").toStdString(), makeUniqueFunctionName(::onMouseWheelCallbackPrefix), scriptCode);
    }

addOnPenInputWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnPenInputWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Pen Input Callback").toStdString(), makeUniqueFunctionName(::onPenInputCallbackPrefix), scriptCode);
    }

addOnPenProximityEnterWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnPenProximityEnterWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Pen Proximity Enter Callback").toStdString(), makeUniqueFunctionName(::onPenProximityEnterCallbackPrefix), scriptCode);
    }

addOnPenProximityExitWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnPenProximityExitWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Pen Proximity Exit Callback").toStdString(), makeUniqueFunctionName(::onPenProximityExitCallbackPrefix), scriptCode);
    }

addOnStopConditionMetWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnStopConditionMetWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Stop Condition Met Callback").toStdString(), makeUniqueFunctionName(::onStopConditionMetCallbackPrefix), scriptCode);
    }

addOnTimedUpdateWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addOnTimedUpdateWidget ( const std::string &  scriptCode )

inlineprivate

    {
        addScriptWidget(tr("On Timed Update Callback").toStdString(), makeUniqueFunctionName(::onTimedUpdateCallbackPrefix), scriptCode);
    }

addScriptWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addScriptWidget ( const std::string &  scriptDisplayName, const std::string &  functionName, const std::string &  scriptCode  )

inlineprivate

    {
        if(!startsWith(functionName, ::stopConditionIdPrefix) &&
           !startsWith(functionName, ::onStopConditionMetCallbackPrefix) &&
           !startsWith(functionName, ::addShapePreconditionCallbackPrefix) &&
           !startsWith(functionName, ::beforeAddShapeCallbackPrefix) &&
           !startsWith(functionName, ::afterAddShapeCallbackPrefix) &&
           !startsWith(functionName, ::beforeStepCallbackPrefix) &&
           !startsWith(functionName, ::afterStepCallbackPrefix) &&
           !startsWith(functionName, ::onPenInputCallbackPrefix) &&
           !startsWith(functionName, ::onPenProximityEnterCallbackPrefix) &&
           !startsWith(functionName, ::onPenProximityExitCallbackPrefix) &&
           !startsWith(functionName, ::onKeyDownCallbackPrefix) &&
           !startsWith(functionName, ::onKeyUpCallbackPrefix) &&
           !startsWith(functionName, ::onMouseDownCallbackPrefix) &&
           !startsWith(functionName, ::onMouseUpCallbackPrefix) &&
           !startsWith(functionName, ::onMouseMoveCallbackPrefix) &&
           !startsWith(functionName, ::onMouseWheelCallbackPrefix) &&
           !startsWith(functionName, ::onTimedUpdateCallbackPrefix))
        {
            return;
        }
 
        auto widget = new geometrize::dialog::ScriptEditorWidget(scriptDisplayName, functionName, scriptCode, ui->customScriptsGroupBox);
        connect(widget, &ScriptEditorWidget::signal_scriptChanged, [this](ScriptEditorWidget* /*self*/, const std::string& functionName, const std::string& code) {
            emit q->signal_scriptChanged(functionName, code);
        });
        ui->customScriptsEditorLayout->addWidget(widget);
    }

addShapePreconditionWidget()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::addShapePreconditionWidget ( const std::string &  scriptCode )

inlineprivate

    {
         addScriptWidget(tr("Add Shape Precondition").toStdString(), makeUniqueFunctionName(::addShapePreconditionCallbackPrefix), scriptCode);
    }

buildScriptSelectionComboBoxes()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::buildScriptSelectionComboBoxes ( )

inlineprivate

    {
        std::vector<std::pair<QComboBox*, std::map<std::string, std::string>>> presetScriptData;
        presetScriptData.push_back(std::make_pair(ui->addBeforeStepPresetScriptsComboBox, geometrize::script::getBeforeStepCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->addAfterStepPresetScriptsComboBox, geometrize::script::getAfterStepCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->addStopConditionPresetScriptsComboBox, geometrize::script::getStopConditionScripts()));
        presetScriptData.push_back(std::make_pair(ui->onStopConditionMetEventComboBox, geometrize::script::getOnStopConditionMetScripts()));
        presetScriptData.push_back(std::make_pair(ui->addShapePreconditionPresetScriptsComboBox, geometrize::script::getAddShapePreconditionScripts()));
        presetScriptData.push_back(std::make_pair(ui->addBeforeAddShapePresetScriptsComboBox, geometrize::script::getBeforeAddShapeCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->addAfterAddShapePresetScriptsComboBox, geometrize::script::getAfterAddShapeCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->onScenePenInputEventPresetScriptsComboBox, geometrize::script::getOnPenInputCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->onPenProximityEnterEventPresetScriptsComboBox, geometrize::script::getOnPenProximityEnterCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->onPenProximityExitEventPresetScriptsComboBox, geometrize::script::getOnPenProximityExitCallbackScripts()));
        presetScriptData.push_back(std::make_pair(ui->onKeyDownEventPresetScriptsComboBox, geometrize::script::getOnKeyDownEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onKeyUpEventPresetScriptsComboBox, geometrize::script::getOnKeyUpEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onMouseDownEventPresetScriptsComboBox, geometrize::script::getOnMouseDownEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onMouseUpEventPresetScriptsComboBox, geometrize::script::getOnMouseUpEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onMouseMoveEventPresetScriptsComboBox, geometrize::script::getOnMouseMoveEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onMouseWheelEventPresetScriptsComboBox, geometrize::script::getOnMouseWheelEventScripts()));
        presetScriptData.push_back(std::make_pair(ui->onUpdateEventPresetScriptsComboBox, geometrize::script::getOnTimedUpdateEventScripts()));
 
        for(const auto& item : presetScriptData) {
            populateScriptSelectionComboBox(item.first, item.second);
        }
    }

Here is the call graph for this function:

evaluateAddShapePreconditionScripts()

bool geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateAddShapePreconditionScripts ( ) const

inline

    {
        return evaluateScriptsWithBooleanReturnValue(::addShapePreconditionCallbackPrefix);
    }

evaluateAfterAddShapeScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateAfterAddShapeScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::afterAddShapeCallbackPrefix);
    }

evaluateAfterStepScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateAfterStepScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::afterStepCallbackPrefix);
    }

evaluateBeforeAddShapeScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateBeforeAddShapeScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::beforeAddShapeCallbackPrefix);
    }

evaluateBeforeStepScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateBeforeStepScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::beforeStepCallbackPrefix);
    }

evaluateOnKeyDownEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnKeyDownEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onKeyDownCallbackPrefix);
    }

evaluateOnKeyUpEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnKeyUpEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onKeyUpCallbackPrefix);
    }

evaluateOnMouseDownEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnMouseDownEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onMouseDownCallbackPrefix);
    }

evaluateOnMouseMoveEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnMouseMoveEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onMouseMoveCallbackPrefix);
    }

evaluateOnMouseUpEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnMouseUpEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onMouseUpCallbackPrefix);
    }

evaluateOnMouseWheelEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnMouseWheelEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onMouseWheelCallbackPrefix);
    }

evaluateOnPenInputEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnPenInputEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onPenInputCallbackPrefix);
    }

evaluateOnPenProximityEnterEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnPenProximityEnterEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onPenProximityEnterCallbackPrefix);
    }

evaluateOnPenProximityExitEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnPenProximityExitEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onPenProximityExitCallbackPrefix);
    }

evaluateOnStopConditionMetScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnStopConditionMetScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onStopConditionMetCallbackPrefix);
    }

evaluateOnTimedUpdateEventScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateOnTimedUpdateEventScripts ( ) const

inline

    {
        evaluateScriptsWithNoReturnValue(::onTimedUpdateCallbackPrefix);
    }

evaluateScriptsWithBooleanReturnValue()

bool geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateScriptsWithBooleanReturnValue ( const std::string &  scriptPrefix ) const

inline

    {
        const auto engine = m_task->getGeometrizer().getEngine();
        if(!engine) {
            return false;
        }
 
        const auto scriptWidgets = ui->customScriptsGroupBox->findChildren<geometrize::dialog::ScriptEditorWidget*>();
        bool returnValue = false;
        for(const auto& widget : scriptWidgets) {
            if(widget->getFunctionName().substr(0, scriptPrefix.length()) != scriptPrefix) {
                continue; // Skip anything other than stop conditions
            }
 
            try {
                auto retValue = engine->eval<bool>(widget->getCurrentCode());
                if(retValue) {
                    returnValue = true;
                }
                widget->onScriptEvaluationSucceeded();
            } catch(const chaiscript::exception::eval_error& e) {
                widget->onScriptEvaluationFailed(e.pretty_print());
            } catch(const std::exception& e) {
                widget->onScriptEvaluationFailed(e.what());
            } catch(...) {
                widget->onScriptEvaluationFailed("Unknown script evaluation error");
            }
        }
 
        return returnValue;
    }

Here is the call graph for this function:

evaluateScriptsWithNoReturnValue()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateScriptsWithNoReturnValue ( const std::string &  scriptGroupNamePrefix ) const

inline

    {
        const auto engine = m_task->getGeometrizer().getEngine();
        if(!engine) {
            return;
        }
 
        const auto scriptWidgets = ui->customScriptsGroupBox->findChildren<geometrize::dialog::ScriptEditorWidget*>();
        for(const auto& widget : scriptWidgets) {
            if(widget->getFunctionName().substr(0, scriptGroupNamePrefix.length()) != scriptGroupNamePrefix) {
                continue;
            }
 
            try {
                engine->eval(widget->getCurrentCode());
                widget->onScriptEvaluationSucceeded();
            } catch(const chaiscript::exception::eval_error& e) {
                widget->onScriptEvaluationFailed(e.pretty_print());
            } catch(const std::exception& e) {
                widget->onScriptEvaluationFailed(e.what());
            } catch(...) {
                widget->onScriptEvaluationFailed("Unknown script evaluation error");
            }
        }
    }

Here is the call graph for this function:

evaluateStopConditionScripts()

bool geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::evaluateStopConditionScripts ( ) const

inline

    {
        return evaluateScriptsWithBooleanReturnValue(::stopConditionIdPrefix);
    }

findEditor()

dialog::ScriptEditorWidget* geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::findEditor ( const std::string &  editorId )

inlineprivate

    {
        const auto& editors = ui->customScriptsGroupBox->findChildren<geometrize::dialog::ScriptEditorWidget*>();
        for(const auto& editor : editors) {
            if(editor->getFunctionName() == editorId) {
                return editor;
            }
        }
        return nullptr;
    }

getScriptForSelectedComboBoxItem()

std::string geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::getScriptForSelectedComboBoxItem ( QComboBox *  combo )

inlineprivate

    {
        return combo->itemData(combo->currentIndex()).toString().toStdString();
    }

getScripts()

std::map<std::string, std::string> geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::getScripts ( ) const

inline

    {
        // Gather the scripts from the editor boxes
        const auto& editors = ui->customScriptsGroupBox->findChildren<geometrize::dialog::ScriptEditorWidget*>();
        std::map<std::string, std::string> scripts;
        for(ScriptEditorWidget* editor : editors) {
            scripts[editor->getFunctionName()] = editor->getCurrentCode();
        }
 
        // Gather the scripts from the shape scripting panel
        const std::map<std::string, std::string> shapeScripts = getShapeScriptingPanel()->getScripts();
        scripts.insert(shapeScripts.begin(), shapeScripts.end());
 
        return scripts;
    }

Here is the call graph for this function:

getShapeMutationScripts()

std::map<std::string, std::string> geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::getShapeMutationScripts ( )

inline

    {
        return getShapeScriptingPanel()->getScripts();
    }

getShapeScriptingPanel()

geometrize::dialog::ImageTaskShapeScriptingPanel* geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::getShapeScriptingPanel ( ) const

inlineprivate

    {
        return q->findChild<geometrize::dialog::ImageTaskShapeScriptingPanel*>();
    }

makeUniqueFunctionName()

std::string geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::makeUniqueFunctionName ( const std::string &  prefix )

inlineprivate

    {
        return prefix + QUuid::createUuid().toString().toStdString();
    }

onLanguageChange()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::onLanguageChange ( )

inline

    {
        ui->retranslateUi(q);
        populateUi();
    }

operator=()

ImageTaskScriptingWidgetImpl geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::operator= ( const ImageTaskScriptingWidgetImpl &  )

delete

populateScriptSelectionComboBox()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::populateScriptSelectionComboBox ( QComboBox *  combo, const std::map< std::string, std::string > &  scripts  )

inlineprivate

    {
        combo->clear();
        for(const auto& item : scripts) {
            combo->addItem(QString::fromStdString(item.first), QString::fromStdString(item.second));
        }
        combo->setCurrentIndex(0);
    }

populateUi()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::populateUi ( )

inlineprivate

    {
    }

revealShapeScriptingPanel()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::revealShapeScriptingPanel ( )

inlineprivate

    {
        auto scriptingPanel = getShapeScriptingPanel();
        scriptingPanel->setWindowState(scriptingPanel->windowState() & ~Qt::WindowMinimized);
        QApplication::setActiveWindow(scriptingPanel);
        scriptingPanel->raise();
        scriptingPanel->show();
    }

setImageTask()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::setImageTask ( task::ImageTask *  task )

inline

    {
        m_task = task;
        getShapeScriptingPanel()->setImageTask(task);
    }

setScripts()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::setScripts ( const std::map< std::string, std::string > &  scripts )

inlineprivate

    {
        // Look for matching script editor widgets, and set their contents if found
        for(const auto& script : scripts) {
            if(dialog::ScriptEditorWidget* editor = findEditor(script.first)) {
                if(!script.second.empty()) {
                    editor->setCurrentCode(script.second);
                }
            } else {
                // If no such editor exists, create a new panel (but only for scripts with names we recognize)
                addScriptWidget(script.first, script.first, script.second);
            }
        }
    }

startsWith()

static bool geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::startsWith ( const std::string &  s, const std::string &  prefix  )

inlinestaticprivate

    {
        return s.rfind(prefix, 0) == 0;
    }

syncUserInterface()

void geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::syncUserInterface ( )

inline

    {
        if(m_task == nullptr) {
            return;
        }
 
        setScripts(m_task->getPreferences().getScripts());
        getShapeScriptingPanel()->syncUserInterface();
    }

Member Data Documentation

m_task

task::ImageTask* geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::m_task {nullptr}

private

q

ImageTaskScriptingWidget* geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::q

private

ui

std::unique_ptr<Ui::ImageTaskScriptingWidget> geometrize::dialog::ImageTaskScriptingWidget::ImageTaskScriptingWidgetImpl::ui

private

---

The documentation for this class was generated from the following file:

• /home/appveyor/projects/geometrize-docs/geometrize/geometrize/dialog/imagetaskscriptingwidget.cpp