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	evaluateStopConditionScripts () const

void	evaluateScriptsWithNoReturnValue (const std::string &scriptGroupNamePrefix) const

void	evaluateBeforeStepScripts () const

void	evaluateAfterStepScripts () 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 &scriptIdPrefix, const std::string &scriptCode)

void	addBeforeStepCallbackWidget (const std::string &scriptCode)

void	addAfterStepCallbackWidget (const std::string &scriptCode)

void	addCustomStopConditionWidget (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 ()

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

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

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

default

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

delete

Member Function Documentation

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

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

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

inlineprivate

     {
         if(!startsWith(scriptIdPrefix, ::stopConditionIdPrefix) &&
            !startsWith(scriptIdPrefix, ::beforeAddShapeCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::afterAddShapeCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::beforeStepCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::afterStepCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onPenInputCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onPenProximityEnterCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onPenProximityExitCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onKeyDownCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onKeyUpCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onMouseDownCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onMouseUpCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onMouseMoveCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onMouseWheelCallbackPrefix) &&
            !startsWith(scriptIdPrefix, ::onTimedUpdateCallbackPrefix))
         {
             return;
         }
 
         const std::string functionName = scriptIdPrefix + QUuid::createUuid().toString().toStdString();
         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);
     }

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->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:

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

inline

     {
         evaluateScriptsWithNoReturnValue(::afterAddShapeCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::afterStepCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::beforeAddShapeCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::beforeStepCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onKeyDownCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onKeyUpCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onMouseDownCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onMouseMoveCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onMouseUpCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onMouseWheelCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onPenInputCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onPenProximityEnterCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onPenProximityExitCallbackPrefix);
     }

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

inline

     {
         evaluateScriptsWithNoReturnValue(::onTimedUpdateCallbackPrefix);
     }

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:

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

inline

     {
         const auto engine = m_task->getGeometrizer().getEngine();
         if(!engine) {
             return false;
         }
 
         const auto scriptWidgets = ui->customScriptsGroupBox->findChildren<geometrize::dialog::ScriptEditorWidget*>();
         bool scriptStopConditionMet = false;
         for(const auto& widget : scriptWidgets) {
             if(widget->getFunctionName().substr(0, stopConditionIdPrefix.length()) != stopConditionIdPrefix) {
                 continue; // Skip anything other than stop conditions
             }
 
             try {
                 auto stopCondition = engine->eval<bool>(widget->getCurrentCode());
                 if(stopCondition) {
                     scriptStopConditionMet = 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 scriptStopConditionMet;
     }

Here is the call graph for this function:

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

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

inlineprivate

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

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:

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

inline

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

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

inlineprivate

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

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

inline

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

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

delete

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

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

inlineprivate

485 {

486 }

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

inlineprivate

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

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

inline

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

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

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

inlinestaticprivate

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

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

inline

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

Member Data Documentation

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

private

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

private

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

private

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

/home/travis/build/Tw1ddle/geometrize-docs/geometrize/geometrize/dialog/imagetaskscriptingwidget.cpp

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation