geometrize::script::bindings Namespace Reference

Functions
std::shared_ptr< chaiscript::Module >	createDefaultBindings ()
	createDefaultBindings Creates the default Chaiscript to C++ bindings. More...
std::shared_ptr< chaiscript::Module >	createQWidgetBindings ()
	createQWidgetBindings Creates the Chaiscript to C++ bindings for the Qt QWidget class. More...
std::shared_ptr< chaiscript::Module >	createLaunchWindowBindings ()
	createLaunchWindowBindings Creates the Chaiscript to C++ bindings for the Geometrize launch window. More...
std::shared_ptr< chaiscript::Module >	createImageTaskWindowBindings ()
	createImageTaskWindowBindings Creates the Chaiscript to C++ binding for the Geometrize image task window. More...
std::shared_ptr< chaiscript::Module >	createImageBindings ()
	createImageBindings Creates the Chaiscript to C++ bindings for image manipulation. More...
std::shared_ptr< chaiscript::Module >	createSynchronousImageTaskBindings ()
	createSynchronousImageTaskBindings Creates the Chaiscript to C++ bindings for synchronous Geometrize image tasks (used by the Twitter bot). More...
std::shared_ptr< chaiscript::Module >	createImageTaskBindings ()
	createImageTaskBindings Creates the Chaiscript to C++ bindings for Geometrize image tasks. More...
std::shared_ptr< chaiscript::Module >	createImageExportBindings ()
	createImageExportBindings Creates the Chaiscript to C++ bindings for saving images. More...
std::shared_ptr< chaiscript::Module >	createAnimatedGifExportBindings ()
	createGifExportBindings Creates the ChaiScript to C++ bindings for saving animated GIFs. More...
std::shared_ptr< chaiscript::Module >	createGeometrizeLibraryBindings ()
	createGeometrizeLibraryBindings Creates the Chaiscript to C++ bindings for all of the functionality in the Geometrize library. More...
std::shared_ptr< chaiscript::Module >	createTabletEventBindings ()
	createTabletEventBindings Creates the Chaiscript to C++ bindings for tablet events (e.g. Wacom pen input data). More...
std::shared_ptr< chaiscript::Module >	createMathBindings ()
	createMathBindings Creates the Chaiscript to C++ bindings for common math functions. More...
std::shared_ptr< chaiscript::Module >	createUserInterfacePuppeteerBindings ()
	createUserInterfacePuppeteerBindings Creates ChaiScript to C++ bindings for driving the user interface (primarily for testing purposes). More...
std::shared_ptr< chaiscript::Module >	createFunctionalTestHelperBindings ()
	createFunctionalTestHelperBindings Creates ChaiScript to C++ bindings for helper functions needed for the functional/self-tests (e.g. reporting test results). More...
geometrize::dialog::ImageTaskWindow *	createImageTaskWindow ()
geometrize::dialog::LaunchWindow *	createLaunchWindow ()
geometrize::task::ImageTask *	createImageTask (geometrize::Bitmap &bitmap)
std::vector< geometrize::dialog::LaunchWindow * >	getLaunchWindows ()
std::vector< geometrize::dialog::ImageTaskWindow * >	getImageTaskWindows ()
std::string	getApplicationDirectoryPath ()
void	printToConsole (const std::string &str)
void	printToAllScriptConsoleWidgets (const std::string &str)
void	messageBox (const std::string &str)
void	debugBreak ()
void	processApplicationEvents ()
bool	fileExists (const std::string &filePath)
bool	directoryExists (const std::string &dirPath)
bool	directoriesExist (const std::vector< std::string > &dirPaths)
bool	directoryContainsFile (const std::string &dirPath, const std::string &fileName)
bool	createDirectory (const std::string &dirPath)
std::string	readFileAsString (const std::string &filePath)
std::vector< std::string >	getFilePathsForDirectory (const std::string &dirPath)
std::vector< std::string >	getScriptSearchPaths ()
std::vector< std::string >	getTemplateSearchPaths ()
std::string	getFirstFileWithExtension (const std::string &dirPath, const std::string &extension)
std::string	getFirstFileWithExtensions (const std::string &dirPath, const std::vector< std::string > &extensions)
std::vector< std::string >	getFilesWithExtensions (const std::string &, const std::vector< std::string > &)
std::vector< std::string >	getFilesWithExtension (const std::string &dirPath, const std::string &extension)
std::vector< std::string >	getSupportedImageFileExtensions ()
std::vector< std::string >	getScriptsForPath (const std::string &dirPath)
std::vector< std::string >	getScriptsForPaths (const std::vector< std::string > &dirPaths)
std::string	getDirectoryForFilePath (const std::string &filePath)
std::string	getFileNameForFilePath (const std::string &filePath)
void	openTask (const std::string &url, const bool addToRecents)
bool	openInDefaultApplication (const std::string &path)
bool	revealInDefaultApplication (const std::string &path)
void	clearGlobalClipboard ()
std::string	getGlobalClipboardText ()
void	setGlobalClipboardText (const std::string &text)
bool	stringBeginsWith (const std::string &str, const std::string &prefix)
bool	stringEndsWith (const std::string &str, const std::string &suffix)
std::string	getApplicationDirectoryLocation ()
std::string	getAppDataLocation ()
std::string	getHomeDirectoryLocation ()
std::string	getDesktopDirectoryLocation ()
bool	writeStringToFile (const std::string &str, const std::string &path)
std::string	percentEncode (const std::string &str)
int	randomIntInRange (const int lower, const int upper)
float	randomFloatInRange (const float lower, const float upper)
int	clampInt (const int value, const int lower, const int upper)
float	clampFloat (const float value, const float lower, const float upper)
std::vector< std::string >	split (const std::string &s, const char delimiter)
std::string	getOperatingSystemProductType ()
int	getCursorX ()
int	getCursorY ()
void	setCursorPos (const int x, const int y)
void	setTranslatorsForLocale (const std::string &locale)
std::vector< std::string >	getSupportedLocaleCodes ()
void	setLocaleAndUserInterfaceLanguage (const std::string &locale)
bool	exportGIF (const std::vector< geometrize::ShapeResult > &data, const std::uint32_t inputWidth, const std::uint32_t inputHeight, const std::uint32_t outputWidth, const std::uint32_t outputHeight, const std::size_t frameSkip, const std::string &filePath)
bool	saveWidgetScreenshot (const std::string &path, QWidget *widget)
std::string	customTabletEventDataToString (const geometrize::scene::TabletEventData &data)
std::vector< std::string >	getAllNamedWidgets ()
std::vector< std::string >	getAllNamedGeometrizeWidgets ()
QWidget *	getWidgetByName (const std::string &widgetName)
std::vector< std::string >	getAllNamedCommandHandlers ()
CommandHandler *	getCommandHandlerByName (const std::string &name)
void	sendCommandString (const std::string &target, const std::string &command)
void	sendCommandObject (const std::string &target, Command &command)
void	broadcastCommandString (const std::string &command)
void	broadcastCommandObject (Command &command)
std::string	getFormattedTimestamp (const std::string &formatString)
std::string	getFilenameTimestamp ()
std::string	getUuidString ()
void	setWidgetSize (QWidget *widget, int width, int height)
void	setWidgetPosition (QWidget *widget, int x, int y)
void	arrangeWidgetsInGrid (const std::vector< QWidget * > &widgets, int centerX, int centerY, int xDim, int yDim, int resizeX, int resizeY)
void	arrangeImageTaskWidgetsInGrid (int centerX, int centerY, int xDim, int yDim, int resizeX, int resizeY)
void	arrangeWidgetsInGridOnMonitor (const std::vector< QWidget * > &widgets, int monitorId, int resizeX, int resizeY)
void	arrangeImageTaskWidgetsInGridOnMonitor (int monitorId, int resizeX, int resizeY)
void	arrangeWidgetsInGridOnPrimaryMonitor (const std::vector< QWidget * > &widgets, int resizeX, int resizeY)
void	arrangeImageTaskWidgetsInGridOnPrimaryMonitor (int resizeX, int resizeY)
void	fitWidgetsInGridOnMonitor (const std::vector< QWidget * > &widgets, int screenIdx)
void	fitImageTaskWidgetsInGridOnMonitor (int screenIdx)
void	fitWidgetsInGridOnPrimaryMonitor (const std::vector< QWidget * > &widgets)
void	fitImageTaskWidgetsInGridOnPrimaryMonitor ()
template<typename T , typename U , typename V >
T	randomInRange (U lower, V upper)
template<typename T >
T	randomInVector (const std::vector< T > &v)
template<typename T , typename U , typename V >
T	clamp (T value, U lower, V upper)
template<typename T >
bool	vectorContains (const std::vector< T > &v, const T &t)

Function Documentation

arrangeImageTaskWidgetsInGrid()

void geometrize::script::bindings::arrangeImageTaskWidgetsInGrid	(	int	centerX,
		int	centerY,
		int	xDim,
		int	yDim,
		int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeImageTaskWidgetsInGrid(centerX, centerY, xDim, yDim, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeImageTaskWidgetsInGridOnMonitor()

void geometrize::script::bindings::arrangeImageTaskWidgetsInGridOnMonitor	(	int	monitorId,
		int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeImageTaskWidgetsInGridOnMonitor(monitorId, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeImageTaskWidgetsInGridOnPrimaryMonitor()

void geometrize::script::bindings::arrangeImageTaskWidgetsInGridOnPrimaryMonitor	(	int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeImageTaskWidgetsInGridOnPrimaryMonitor(resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGrid()

void geometrize::script::bindings::arrangeWidgetsInGrid	(	const std::vector< QWidget * > &	widgets,
		int	centerX,
		int	centerY,
		int	xDim,
		int	yDim,
		int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeWidgetsInGrid(widgets, centerX, centerY, xDim, yDim, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGridOnMonitor()

void geometrize::script::bindings::arrangeWidgetsInGridOnMonitor	(	const std::vector< QWidget * > &	widgets,
		int	monitorId,
		int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeWidgetsInGridOnMonitor(widgets, monitorId, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGridOnPrimaryMonitor()

void geometrize::script::bindings::arrangeWidgetsInGridOnPrimaryMonitor	(	const std::vector< QWidget * > &	widgets,
		int	resizeX,
		int	resizeY
	)

{
    geometrize::util::arrangeWidgetsInGridOnPrimaryMonitor(widgets, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

broadcastCommandObject()

void geometrize::script::bindings::broadcastCommandObject

(

Command &

command

)

{
    geometrize::util::broadcastCommand(command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

broadcastCommandString()

void geometrize::script::bindings::broadcastCommandString

(

const std::string &

command

)

{
    geometrize::util::broadcastCommand(command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

clamp()

template<typename T , typename U , typename V >

T geometrize::script::bindings::clamp	(	T	value,
		U	lower,
		V	upper
	)

{
    assert(lower <= upper);
    if (value < lower) {
        value = lower;
    }
    if (value > upper) {
        value = upper;
    }
    return value;
}

Here is the caller graph for this function:

clampFloat()

float geometrize::script::bindings::clampFloat	(	const float	value,
		const float	lower,
		const float	upper
	)

{
    return clamp<float, float, float>(value, lower, upper);
}

Here is the caller graph for this function:

clampInt()

int geometrize::script::bindings::clampInt	(	const int	value,
		const int	lower,
		const int	upper
	)

{
    return clamp<int, int, int>(value, lower, upper);
}

Here is the caller graph for this function:

clearGlobalClipboard()

void geometrize::script::bindings::clearGlobalClipboard

(

)

{
    geometrize::util::clearGlobalClipboard();
}

Here is the call graph for this function:

Here is the caller graph for this function:

createAnimatedGifExportBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createAnimatedGifExportBindings

(

)

createGifExportBindings Creates the ChaiScript to C++ bindings for saving animated GIFs.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::script::bindings;
 
    auto module = createModule();
 
    ADD_FREE_FUN(exportGIF);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createDefaultBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createDefaultBindings

(

)

createDefaultBindings Creates the default Chaiscript to C++ bindings.

Returns

A shared pointer to a module encapsulating the bindings.

{
    auto module = createModule();
 
    ADD_FREE_FUN(sleep);
 
    ADD_FREE_FUN(debugBreak);
    ADD_FREE_FUN(messageBox);
    ADD_FREE_FUN(printToAllScriptConsoleWidgets);
    ADD_FREE_FUN(printToConsole);
 
    ADD_FREE_FUN(processApplicationEvents);
    ADD_FREE_FUN(directoryContainsFile);
    ADD_FREE_FUN(createDirectory);
    ADD_FREE_FUN(fileExists);
    ADD_FREE_FUN(directoryExists);
    ADD_FREE_FUN(directoriesExist);
    ADD_FREE_FUN(readFileAsString);
    ADD_FREE_FUN(getFilePathsForDirectory);
 
    ADD_FREE_FUN(getScriptSearchPaths);
    ADD_FREE_FUN(getTemplateSearchPaths);
 
    ADD_FREE_FUN(getApplicationDirectoryPath);
 
    ADD_FREE_FUN(getFilesWithExtension);
    ADD_FREE_FUN(getFilesWithExtensions);
    ADD_FREE_FUN(getFirstFileWithExtension);
    ADD_FREE_FUN(getFirstFileWithExtensions);
    ADD_FREE_FUN(getScriptsForPath);
    ADD_FREE_FUN(getScriptsForPaths);
    ADD_FREE_FUN(getFileNameForFilePath);
    ADD_FREE_FUN(getDirectoryForFilePath);
 
    ADD_FREE_FUN(getSupportedImageFileExtensions);
 
    ADD_FREE_FUN(openTask);
 
    ADD_FREE_FUN(openInDefaultApplication);
    ADD_FREE_FUN(revealInDefaultApplication);
 
    ADD_FREE_FUN(clearGlobalClipboard);
    ADD_FREE_FUN(getGlobalClipboardText);
    ADD_FREE_FUN(setGlobalClipboardText);
 
    ADD_FREE_FUN(stringBeginsWith);
    ADD_FREE_FUN(stringEndsWith);
 
    ADD_FREE_FUN(getApplicationDirectoryLocation);
    ADD_FREE_FUN(getAppDataLocation);
    ADD_FREE_FUN(getHomeDirectoryLocation);
    ADD_FREE_FUN(getDesktopDirectoryLocation);
 
    ADD_FREE_FUN(writeStringToFile);
 
    ADD_FREE_FUN(percentEncode);
 
    ADD_FREE_FUN_TEMPLATE(randomInRange, float COMMA float COMMA float);
    ADD_FREE_FUN_TEMPLATE(clamp, float COMMA float COMMA float);
 
    // Some specialized helper templates if in doubt
    ADD_FREE_FUN(randomIntInRange);
    ADD_FREE_FUN(randomFloatInRange);
 
    ADD_FREE_FUN(clampInt);
    ADD_FREE_FUN(clampFloat);
 
    ADD_FREE_FUN_TEMPLATE(randomInVector, std::pair<int COMMA int>);
    ADD_FREE_FUN_TEMPLATE(randomInVector, std::pair<float COMMA float>);
 
    ADD_FREE_FUN_TEMPLATE(vectorContains, std::pair<int COMMA int>);
    ADD_FREE_FUN_TEMPLATE(vectorContains, std::pair<float COMMA float>);
 
    ADD_FREE_FUN(split);
 
    ADD_FREE_FUN(getOperatingSystemProductType);
 
    ADD_FREE_FUN(setTranslatorsForLocale);
    ADD_FREE_FUN(getSupportedLocaleCodes);
    ADD_FREE_FUN(setLocaleAndUserInterfaceLanguage);
 
    ADD_FREE_FUN(getAllNamedWidgets);
    ADD_FREE_FUN(getAllNamedGeometrizeWidgets);
    ADD_FREE_FUN(getWidgetByName);
 
    ADD_TYPE(Command);
    ADD_MEMBER(Command, getCommand);
    ADD_MEMBER(Command, setStringArg);
 
    ADD_TYPE(CommandHandler);
    ADD_MEMBER(CommandHandler, handleCommand);
    ADD_MEMBER(CommandHandler, getCommandHandlerName);
    ADD_MEMBER(CommandHandler, setCommandHandlerName);
 
    ADD_FREE_FUN(getAllNamedCommandHandlers);
    ADD_FREE_FUN(getCommandHandlerByName);
 
    ADD_FREE_FUN(sendCommandString);
    ADD_FREE_FUN(sendCommandObject);
 
    ADD_FREE_FUN(broadcastCommandString);
    ADD_FREE_FUN(broadcastCommandObject);
 
    ADD_FREE_FUN(getFormattedTimestamp);
    ADD_FREE_FUN(getFilenameTimestamp);
 
    ADD_FREE_FUN(getUuidString);
 
    return module;
}

Here is the caller graph for this function:

createDirectory()

bool geometrize::script::bindings::createDirectory

(

const std::string &

dirPath

)

{
    return geometrize::util::createDirectory(dirPath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

createFunctionalTestHelperBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createFunctionalTestHelperBindings

(

)

createFunctionalTestHelperBindings Creates ChaiScript to C++ bindings for helper functions needed for the functional/self-tests (e.g. reporting test results).

Returns

A shared pointer encapsulating the bindings.

{
    auto module = createModule();
 
    ADD_FREE_FUN(saveWidgetScreenshot);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createGeometrizeLibraryBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createGeometrizeLibraryBindings

(

)

createGeometrizeLibraryBindings Creates the Chaiscript to C++ bindings for all of the functionality in the Geometrize library.

Returns

A shared pointer to a module enscapsulating the bindings.

{
    auto module = createModule();
 
    ADD_TYPE(Bitmap);
    ADD_CONSTRUCTOR(Bitmap, Bitmap(std::uint32_t COMMA std::uint32_t COMMA geometrize::rgba));
    ADD_CONSTRUCTOR(Bitmap, Bitmap(std::uint32_t COMMA std::uint32_t COMMA const std::vector<std::uint8_t>& data));
    ADD_CONSTRUCTOR(Bitmap, Bitmap(const geometrize::Bitmap&));
    ADD_MEMBER(Bitmap, getWidth);
    ADD_MEMBER(Bitmap, getHeight);
    ADD_MEMBER(Bitmap, copyData);
    ADD_MEMBER(Bitmap, getDataRef);
    ADD_MEMBER(Bitmap, getPixel);
    ADD_MEMBER(Bitmap, setPixel);
    ADD_MEMBER(Bitmap, fill);
 
    ADD_TYPE(rgba);
    ADD_MEMBER(rgba, r);
    ADD_MEMBER(rgba, g);
    ADD_MEMBER(rgba, b);
    ADD_MEMBER(rgba, a);
 
    using namespace geometrize::exporter;
 
    ADD_FREE_FUN(exportBitmapData);
    ADD_FREE_FUN(exportBitmap);
    ADD_FREE_FUN(exportShapeArray);
    ADD_FREE_FUN(exportShapeJson);
    ADD_FREE_FUN(exportSVG);
 
    ADD_TYPE(ImageRunner);
    ADD_CONSTRUCTOR(ImageRunner, ImageRunner(const geometrize::Bitmap&));
    ADD_CONSTRUCTOR(ImageRunner, ImageRunner(const geometrize::Bitmap& COMMA const geometrize::Bitmap&));
    ADD_MEMBER(ImageRunner, step);
    //ADD_MEMBER(ImageRunner, getCurrent);
    //ADD_MEMBER(ImageRunner, getTarget);
    ADD_MEMBER(ImageRunner, getModel);
 
    ADD_TYPE(Shape);
    ADD_MEMBER(Shape, getType);
    ADD_MEMBER(Shape, clone);
 
    ADD_BASE_CLASS(Shape, Circle);
    ADD_TYPE(Circle);
    ADD_CONSTRUCTOR(Circle, Circle(float COMMA float COMMA float));
    ADD_MEMBER(Circle, m_x);
    ADD_MEMBER(Circle, m_y);
    ADD_MEMBER(Circle, m_r);
 
    ADD_BASE_CLASS(Shape, Ellipse);
    ADD_TYPE(Ellipse);
    ADD_CONSTRUCTOR(Ellipse, Ellipse(float COMMA float COMMA float COMMA float));
    ADD_MEMBER(Ellipse, m_x);
    ADD_MEMBER(Ellipse, m_y);
    ADD_MEMBER(Ellipse, m_rx);
    ADD_MEMBER(Ellipse, m_ry);
 
    ADD_BASE_CLASS(Shape, Line);
    ADD_TYPE(Line);
    ADD_CONSTRUCTOR(Line, Line(float COMMA float COMMA float COMMA float));
    ADD_MEMBER(Line, m_x1);
    ADD_MEMBER(Line, m_y1);
    ADD_MEMBER(Line, m_x2);
    ADD_MEMBER(Line, m_y2);
 
    ADD_BASE_CLASS(Shape, Polyline);
    ADD_TYPE(Polyline);
    ADD_CONSTRUCTOR(Polyline, Polyline(const std::vector<std::pair<float, float>>));
 
    // Make the polyline points vector accessible from scripts
    chaiscript::bootstrap::standard_library::pair_type<std::pair<float, float>>("FloatPair", *module);
    chaiscript::bootstrap::standard_library::vector_type<std::vector<std::pair<float, float>>>("IntPairVector", *module);
    module->add(chaiscript::vector_conversion<std::vector<std::pair<float, float>>>());
    ADD_MEMBER(Polyline, m_points);
 
    ADD_BASE_CLASS(Shape, QuadraticBezier);
    ADD_TYPE(QuadraticBezier);
    ADD_CONSTRUCTOR(QuadraticBezier, QuadraticBezier(float COMMA float COMMA float COMMA float COMMA float COMMA float));
    ADD_MEMBER(QuadraticBezier, m_cx);
    ADD_MEMBER(QuadraticBezier, m_cy);
    ADD_MEMBER(QuadraticBezier, m_x1);
    ADD_MEMBER(QuadraticBezier, m_y1);
    ADD_MEMBER(QuadraticBezier, m_x2);
    ADD_MEMBER(QuadraticBezier, m_y2);
 
    ADD_BASE_CLASS(Shape, Rectangle);
    ADD_TYPE(Rectangle);
    ADD_CONSTRUCTOR(Rectangle, Rectangle(float COMMA float COMMA float COMMA float));
    ADD_MEMBER(Rectangle, m_x1);
    ADD_MEMBER(Rectangle, m_y1);
    ADD_MEMBER(Rectangle, m_x2);
    ADD_MEMBER(Rectangle, m_y2);
 
    ADD_BASE_CLASS(Shape, RotatedEllipse);
    ADD_TYPE(RotatedEllipse);
    ADD_CONSTRUCTOR(RotatedEllipse, RotatedEllipse(float COMMA float COMMA float COMMA float COMMA float));
    ADD_MEMBER(RotatedEllipse, m_x);
    ADD_MEMBER(RotatedEllipse, m_y);
    ADD_MEMBER(RotatedEllipse, m_rx);
    ADD_MEMBER(RotatedEllipse, m_ry);
    ADD_MEMBER(RotatedEllipse, m_angle);
 
    ADD_BASE_CLASS(Shape, RotatedRectangle);
    ADD_TYPE(RotatedRectangle);
    ADD_CONSTRUCTOR(RotatedRectangle, RotatedRectangle(float COMMA float COMMA float COMMA float COMMA float));
    ADD_MEMBER(RotatedRectangle, m_x1);
    ADD_MEMBER(RotatedRectangle, m_y1);
    ADD_MEMBER(RotatedRectangle, m_x2);
    ADD_MEMBER(RotatedRectangle, m_y2);
    ADD_MEMBER(RotatedRectangle, m_angle);
 
    ADD_BASE_CLASS(Shape, Triangle);
    ADD_TYPE(Triangle);
    ADD_CONSTRUCTOR(Triangle, Triangle(float COMMA float COMMA float COMMA float COMMA float COMMA float));
    ADD_MEMBER(Triangle, m_x1);
    ADD_MEMBER(Triangle, m_y1);
    ADD_MEMBER(Triangle, m_x2);
    ADD_MEMBER(Triangle, m_y2);
    ADD_MEMBER(Triangle, m_x3);
    ADD_MEMBER(Triangle, m_y3);
 
    chaiscript::utility::add_class<geometrize::ShapeTypes>(*module,
      "ShapeTypes",
    {
      { RECTANGLE, "RECTANGLE" },
      { ROTATED_RECTANGLE, "ROTATED_RECTANGLE" },
      { TRIANGLE, "TRIANGLE" },
      { ELLIPSE, "ELLIPSE" },
      { ROTATED_ELLIPSE, "ROTATED_ELLIPSE" },
      { CIRCLE, "CIRCLE" },
      { LINE, "LINE" },
      { QUADRATIC_BEZIER, "QUADRATIC_BEZIER" },
      { POLYLINE, "POLYLINE" }
    });
 
    using namespace geometrize::core;
 
    ADD_FREE_FUN(defaultEnergyFunction);
 
    ADD_TYPE(Scanline);
    ADD_MEMBER(Scanline, y);
    ADD_MEMBER(Scanline, x1);
    ADD_MEMBER(Scanline, x2);
 
    chaiscript::bootstrap::standard_library::vector_type<std::vector<Scanline>>("ScanlineVector", *module);
 
    using namespace geometrize::commonutil;
 
    ADD_FREE_FUN(seedRandomGenerator);
    ADD_FREE_FUN(getAverageImageColor);
 
    ADD_FREE_FUN(shapesOverlap);
    ADD_FREE_FUN(shapeContains);
 
    ADD_FREE_FUN(shapeToPixels);
 
    ADD_FREE_FUN(scanlinesContainTransparentPixels);
 
    ADD_TYPE(Model);
    ADD_CONSTRUCTOR(Model, Model(const geometrize::Bitmap&));
    ADD_CONSTRUCTOR(Model, Model(const geometrize::Bitmap& COMMA const geometrize::Bitmap&));
 
    ADD_MEMBER(Model, reset);
    ADD_MEMBER(Model, getWidth);
    ADD_MEMBER(Model, getHeight);
    ADD_MEMBER(Model, step);
    //ADD_MEMBER(Model, drawShape);
    //ADD_MEMBER(Model, getCurrent);
    //ADD_MEMBER(Model, getTarget);
    ADD_MEMBER(Model, setSeed);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createImageBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createImageBindings

(

)

createImageBindings Creates the Chaiscript to C++ bindings for image manipulation.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::image;
 
    auto module = createModule();
 
    ADD_TYPE(QImage);
 
    ADD_MEMBER(QImage, sizeInBytes);
    ADD_MEMBER(QImage, colorCount);
    ADD_MEMBER(QImage, depth);
    ADD_MEMBER(QImage, isNull);
    ADD_MEMBER(QImage, width);
    ADD_MEMBER(QImage, height);
 
    chaiscript::utility::add_class<Qt::TransformationMode>(*module,
      "TransformationMode",
    {
      { Qt::FastTransformation, "QtFastTransformation" },
      { Qt::SmoothTransformation, "QtSmoothTransformation" }
    });
    ADD_MEMBER(QImage, scaledToWidth);
    ADD_MEMBER(QImage, scaledToHeight);
 
    ADD_FREE_FUN(loadImage);
    ADD_FREE_FUN(convertImageToRgba8888);
    ADD_FREE_FUN(createBitmap);
    ADD_FREE_FUN(convertImageToBitmapWithDownscaling);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createImageExportBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createImageExportBindings

(

)

createImageExportBindings Creates the Chaiscript to C++ bindings for saving images.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::exporter;
 
    auto module = createModule();
 
    ADD_FREE_FUN(exportBitmap);
    ADD_FREE_FUN(exportImage);
    ADD_FREE_FUN(exportRasterizedSvg);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createImageTask()

geometrize::task::ImageTask * geometrize::script::bindings::createImageTask

(

geometrize::Bitmap &

bitmap

)

{
    return new task::ImageTask(bitmap);
}

Here is the caller graph for this function:

createImageTaskBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createImageTaskBindings

(

)

createImageTaskBindings Creates the Chaiscript to C++ bindings for Geometrize image tasks.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::task;
    using namespace geometrize::preferences;
 
    auto module = createModule();
 
    ADD_TYPE(ImageTask);
 
    ADD_CONSTRUCTOR(ImageTask, ImageTask(Bitmap&));
 
    ADD_MEMBER(ImageTask, stepModel);
    ADD_MEMBER(ImageTask, drawBackgroundRectangle);
    ADD_MEMBER(ImageTask, getTarget);
    ADD_MEMBER(ImageTask, getCurrent);
    ADD_MEMBER(ImageTask, getTargetMutable);
    ADD_MEMBER(ImageTask, getCurrentMutable);
    ADD_MEMBER(ImageTask, getPreferences);
    ADD_MEMBER(ImageTask, setPreferences);
    ADD_MEMBER(ImageTask, getDisplayName);
    ADD_MEMBER(ImageTask, getWidth);
    ADD_MEMBER(ImageTask, getHeight);
    ADD_MEMBER(ImageTask, getTaskId);
    ADD_MEMBER(ImageTask, isStepping);
 
    ADD_FREE_FUN(createImageTask);
 
    ADD_TYPE(ImageTaskPreferences);
 
    ADD_CONSTRUCTOR(ImageTaskPreferences, ImageTaskPreferences());
    ADD_CONSTRUCTOR(ImageTaskPreferences, ImageTaskPreferences(const std::string&));
    ADD_CONSTRUCTOR(ImageTaskPreferences, ImageTaskPreferences(const ImageTaskPreferences&));
 
    ADD_MEMBER(ImageTaskPreferences, enableShapeTypes);
    ADD_MEMBER(ImageTaskPreferences, disableShapeTypes);
    ADD_MEMBER(ImageTaskPreferences, setShapeTypes);
    ADD_MEMBER(ImageTaskPreferences, setShapeAlpha);
    ADD_MEMBER(ImageTaskPreferences, setCandidateShapeCount);
    ADD_MEMBER(ImageTaskPreferences, setMaxShapeMutations);
    ADD_MEMBER(ImageTaskPreferences, setSeed);
    ADD_MEMBER(ImageTaskPreferences, setMaxThreads);
 
    module->add(chaiscript::fun(
                    static_cast<void(ImageTaskPreferences::*)(double, double, double, double)>
                    (&ImageTaskPreferences::setShapeBounds)), "setShapeBounds");
 
    ADD_MEMBER(ImageTaskPreferences, setShapeBoundsXMinPercent);
    ADD_MEMBER(ImageTaskPreferences, setShapeBoundsYMinPercent);
    ADD_MEMBER(ImageTaskPreferences, setShapeBoundsXMaxPercent);
    ADD_MEMBER(ImageTaskPreferences, setShapeBoundsYMaxPercent);
    ADD_MEMBER(ImageTaskPreferences, setShapeBoundsEnabled);
 
    ADD_MEMBER(ImageTaskPreferences, isScriptModeEnabled);
    ADD_MEMBER(ImageTaskPreferences, setScriptModeEnabled);
    ADD_MEMBER(ImageTaskPreferences, setScript);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createImageTaskWindow()

geometrize::dialog::ImageTaskWindow * geometrize::script::bindings::createImageTaskWindow

(

)

{
    return new dialog::ImageTaskWindow();
}

Here is the caller graph for this function:

createImageTaskWindowBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createImageTaskWindowBindings

(

)

createImageTaskWindowBindings Creates the Chaiscript to C++ binding for the Geometrize image task window.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::dialog;
    using namespace geometrize::common::ui;
 
    auto module = createModule();
 
    ADD_TYPE(ImageTaskWindow);
 
    ADD_BASE_CLASS(QMainWindow, ImageTaskWindow);
    ADD_BASE_CLASS(QWidget, ImageTaskWindow);
    ADD_BASE_CLASS(QObject, ImageTaskWindow);
    ADD_BASE_CLASS(CommandHandler, ImageTaskWindow);
 
    ADD_CONSTRUCTOR(ImageTaskWindow, ImageTaskWindow());
 
    ADD_FREE_FUN(createImageTaskWindow);
    ADD_FREE_FUN(arrangeImageTaskWidgetsInGrid);
    ADD_FREE_FUN(arrangeImageTaskWidgetsInGridOnMonitor);
    ADD_FREE_FUN(arrangeImageTaskWidgetsInGridOnPrimaryMonitor);
    ADD_FREE_FUN(fitImageTaskWidgetsInGridOnMonitor);
    ADD_FREE_FUN(fitImageTaskWidgetsInGridOnPrimaryMonitor);
 
    chaiscript::bootstrap::standard_library::vector_type<std::vector<ImageTaskWindow*>>("ImageTaskWindowVector", *module);
    ADD_FREE_FUN(getImageTaskWindows);
 
    ADD_MEMBER(ImageTaskWindow, show);
    ADD_MEMBER(ImageTaskWindow, hide);
    ADD_MEMBER(ImageTaskWindow, getImageTask);
    ADD_MEMBER(ImageTaskWindow, setImageTask);
 
    module->add(chaiscript::fun(static_cast<void(ImageTaskWindow::*)(int, int)>(&ImageTaskWindow::resize)), "resize");
    module->add(chaiscript::fun(static_cast<void(ImageTaskWindow::*)(int, int)>(&ImageTaskWindow::move)), "move");
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createLaunchWindow()

geometrize::dialog::LaunchWindow * geometrize::script::bindings::createLaunchWindow

(

)

{
    return new dialog::LaunchWindow();
}

Here is the caller graph for this function:

createLaunchWindowBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createLaunchWindowBindings

(

)

createLaunchWindowBindings Creates the Chaiscript to C++ bindings for the Geometrize launch window.

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::dialog;
    using namespace geometrize::common::ui;
 
    auto module = createModule();
 
    ADD_TYPE(LaunchWindow);
 
    ADD_BASE_CLASS(QMainWindow, LaunchWindow);
    ADD_BASE_CLASS(QWidget, LaunchWindow);
    ADD_BASE_CLASS(QObject, LaunchWindow);
    ADD_BASE_CLASS(CommandHandler, LaunchWindow);
 
    ADD_CONSTRUCTOR(LaunchWindow, LaunchWindow());
 
    ADD_FREE_FUN(createLaunchWindow);
 
    chaiscript::bootstrap::standard_library::vector_type<std::vector<LaunchWindow*>>("LaunchWindowVector", *module);
    ADD_FREE_FUN(getLaunchWindows);
 
    ADD_MEMBER(LaunchWindow, show);
    ADD_MEMBER(LaunchWindow, hide);
    ADD_MEMBER(LaunchWindow, updateGeometry);
 
    module->add(chaiscript::fun(static_cast<void(LaunchWindow::*)(int, int)>(&LaunchWindow::resize)), "resize");
    module->add(chaiscript::fun(static_cast<void(LaunchWindow::*)(int, int)>(&LaunchWindow::move)), "move");
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createMathBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createMathBindings

(

)

createMathBindings Creates the Chaiscript to C++ bindings for common math functions.

Returns

A shared pointer to a module encapsulating the bindings.

{
    return chaiscript::extras::math::bootstrap();
}

Here is the call graph for this function:

Here is the caller graph for this function:

createQWidgetBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createQWidgetBindings

(

)

createQWidgetBindings Creates the Chaiscript to C++ bindings for the Qt QWidget class.

Returns

A shared pointer to a module encapsulating the bindings.

{
    auto module = createModule();
 
    ADD_TYPE(QWidget);
 
    ADD_BASE_CLASS(QObject, QWidget);
 
    ADD_MEMBER(QWidget, show);
    ADD_MEMBER(QWidget, hide);
    ADD_MEMBER(QWidget, updateGeometry);
 
    ADD_FREE_FUN(setWidgetSize);
    ADD_FREE_FUN(setWidgetPosition);
 
    ADD_FREE_FUN(arrangeWidgetsInGrid);
    ADD_FREE_FUN(arrangeWidgetsInGridOnMonitor);
    ADD_FREE_FUN(arrangeWidgetsInGridOnPrimaryMonitor);
    ADD_FREE_FUN(fitWidgetsInGridOnMonitor);
    ADD_FREE_FUN(fitWidgetsInGridOnPrimaryMonitor);
 
    module->add(chaiscript::fun(static_cast<void(QWidget::*)(int, int)>(&QWidget::resize)), "resize");
    module->add(chaiscript::fun(static_cast<void(QWidget::*)(int, int)>(&QWidget::move)), "move");
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createSynchronousImageTaskBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createSynchronousImageTaskBindings

(

)

createSynchronousImageTaskBindings Creates the Chaiscript to C++ bindings for synchronous Geometrize image tasks (used by the Twitter bot).

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::task;
    using namespace geometrize::preferences;
 
    auto module = createModule();
 
    // Note we use synchronous-stepping image tasks for simplicity in some scripts e.g. the Twitter bot
    ADD_TYPE(SynchronousImageTask);
 
    ADD_CONSTRUCTOR(SynchronousImageTask, SynchronousImageTask(Bitmap&));
 
    ADD_MEMBER(SynchronousImageTask, stepModel);
    ADD_MEMBER(SynchronousImageTask, drawBackgroundRectangle);
    ADD_MEMBER(SynchronousImageTask, getTarget);
    ADD_MEMBER(SynchronousImageTask, getCurrent);
    ADD_MEMBER(SynchronousImageTask, getPreferences);
    ADD_MEMBER(SynchronousImageTask, setPreferences);
    ADD_MEMBER(SynchronousImageTask, getShapes);
 
    return module;
}

Here is the caller graph for this function:

createTabletEventBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createTabletEventBindings

(

)

createTabletEventBindings Creates the Chaiscript to C++ bindings for tablet events (e.g. Wacom pen input data).

Returns

A shared pointer to a module encapsulating the bindings.

{
    using namespace geometrize::scene;
 
    auto module = createModule();
 
    chaiscript::utility::add_class<TabletEventType>(*module,
      "TabletEventType",
    {
        { TabletEventType::Move, "Move" },
        { TabletEventType::Press, "Press" },
        { TabletEventType::Release, "Release" },
        { TabletEventType::EnterProximity, "EnterProximity" },
        { TabletEventType::LeaveProximity, "LeaveProximity" },
        { TabletEventType::Unknown, "Unknown" }
    });
 
    chaiscript::utility::add_class<TabletEventPointerType>(*module,
      "TabletEventPointerType",
    {
      { TabletEventPointerType::UnknownPointer, "UnknownPointer" },
      { TabletEventPointerType::Pen, "Pen" },
      { TabletEventPointerType::Cursor, "Cursor" },
      { TabletEventPointerType::Eraser, "Eraser" }
    });
 
    ADD_TYPE(TabletEventData);
    ADD_MEMBER(TabletEventData, eventType);
    ADD_MEMBER(TabletEventData, pointerType);
    ADD_MEMBER(TabletEventData, xViewPos);
    ADD_MEMBER(TabletEventData, yViewPos);
    ADD_MEMBER(TabletEventData, xScenePos);
    ADD_MEMBER(TabletEventData, yScenePos);
    ADD_MEMBER(TabletEventData, pressure);
    ADD_MEMBER(TabletEventData, tangentialPressure);
    ADD_MEMBER(TabletEventData, rotation);
    ADD_MEMBER(TabletEventData, xTilt);
    ADD_MEMBER(TabletEventData, yTilt);
 
    ADD_FREE_FUN(customTabletEventDataToString);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createUserInterfacePuppeteerBindings()

std::shared_ptr< chaiscript::Module > geometrize::script::bindings::createUserInterfacePuppeteerBindings

(

)

createUserInterfacePuppeteerBindings Creates ChaiScript to C++ bindings for driving the user interface (primarily for testing purposes).

Returns

A shared pointer encapsulating the bindings.

{
    auto module = createModule();
 
    ADD_FREE_FUN(getCursorX);
    ADD_FREE_FUN(getCursorY);
    ADD_FREE_FUN(setCursorPos);
 
    return module;
}

Here is the call graph for this function:

Here is the caller graph for this function:

customTabletEventDataToString()

std::string geometrize::script::bindings::customTabletEventDataToString

(

const geometrize::scene::TabletEventData &

data

)

{
    return geometrize::scene::tabletEventDataToString(data).toStdString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

debugBreak()

void geometrize::script::bindings::debugBreak

(

)

{
    geometrize::util::debugBreak();
}

Here is the call graph for this function:

Here is the caller graph for this function:

directoriesExist()

bool geometrize::script::bindings::directoriesExist

(

const std::vector< std::string > &

dirPaths

)

{
    return geometrize::util::directoriesExist(dirPaths);
}

Here is the call graph for this function:

Here is the caller graph for this function:

directoryContainsFile()

bool geometrize::script::bindings::directoryContainsFile	(	const std::string &	dirPath,
		const std::string &	fileName
	)

{
    return geometrize::util::directoryContainsFile(dirPath, fileName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

directoryExists()

bool geometrize::script::bindings::directoryExists

(

const std::string &

dirPath

)

{
    return geometrize::util::directoryExists(dirPath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exportGIF()

bool geometrize::script::bindings::exportGIF	(	const std::vector< geometrize::ShapeResult > &	data,
		const std::uint32_t	inputWidth,
		const std::uint32_t	inputHeight,
		const std::uint32_t	outputWidth,
		const std::uint32_t	outputHeight,
		const std::size_t	frameSkip,
		const std::string &	filePath
	)

{
    return geometrize::exporter::exportGIF(data, inputWidth, inputHeight, outputWidth, outputHeight, [frameSkip](std::size_t frameIndex) {
        return frameSkip == 0U ? false : (frameIndex % frameSkip == 0);
    }, filePath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fileExists()

bool geometrize::script::bindings::fileExists

(

const std::string &

filePath

)

{
    return geometrize::util::fileExists(filePath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitImageTaskWidgetsInGridOnMonitor()

void geometrize::script::bindings::fitImageTaskWidgetsInGridOnMonitor

(

int

screenIdx

)

{
    geometrize::util::fitImageTaskWidgetsInGridOnMonitor(screenIdx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitImageTaskWidgetsInGridOnPrimaryMonitor()

void geometrize::script::bindings::fitImageTaskWidgetsInGridOnPrimaryMonitor

(

)

{
    geometrize::util::fitImageTaskWidgetsInGridOnPrimaryMonitor();
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitWidgetsInGridOnMonitor()

void geometrize::script::bindings::fitWidgetsInGridOnMonitor	(	const std::vector< QWidget * > &	widgets,
		int	screenIdx
	)

{
    geometrize::util::fitWidgetsInGridOnMonitor(widgets, screenIdx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitWidgetsInGridOnPrimaryMonitor()

void geometrize::script::bindings::fitWidgetsInGridOnPrimaryMonitor

(

const std::vector< QWidget * > &

widgets

)

{
    geometrize::util::fitWidgetsInGridOnPrimaryMonitor(widgets);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAllNamedCommandHandlers()

std::vector< std::string > geometrize::script::bindings::getAllNamedCommandHandlers

(

)

{
    return geometrize::util::getAllNamedCommandHandlers();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAllNamedGeometrizeWidgets()

std::vector< std::string > geometrize::script::bindings::getAllNamedGeometrizeWidgets

(

)

{
    return geometrize::util::getAllNamedGeometrizeWidgets();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAllNamedWidgets()

std::vector< std::string > geometrize::script::bindings::getAllNamedWidgets

(

)

{
    return geometrize::util::getAllNamedWidgets();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAppDataLocation()

std::string geometrize::script::bindings::getAppDataLocation

(

)

{
    return geometrize::util::getAppDataLocation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getApplicationDirectoryLocation()

std::string geometrize::script::bindings::getApplicationDirectoryLocation

(

)

{
    return geometrize::util::getApplicationDirectoryLocation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getApplicationDirectoryPath()

std::string geometrize::script::bindings::getApplicationDirectoryPath

(

)

{
    return geometrize::searchpaths::getApplicationDirectoryPath();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCommandHandlerByName()

CommandHandler * geometrize::script::bindings::getCommandHandlerByName

(

const std::string &

name

)

{
    return geometrize::util::getCommandHandlerByName(name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCursorX()

int geometrize::script::bindings::getCursorX

(

)

{
    return geometrize::util::getCursorX();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCursorY()

int geometrize::script::bindings::getCursorY

(

)

{
    return geometrize::util::getCursorY();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getDesktopDirectoryLocation()

std::string geometrize::script::bindings::getDesktopDirectoryLocation

(

)

{
    return geometrize::util::getDesktopDirectoryLocation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getDirectoryForFilePath()

std::string geometrize::script::bindings::getDirectoryForFilePath

(

const std::string &

filePath

)

{
    return geometrize::util::getDirectoryForFilePath(filePath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFileNameForFilePath()

std::string geometrize::script::bindings::getFileNameForFilePath

(

const std::string &

filePath

)

{
    return geometrize::util::getFileNameForFilePath(filePath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFilenameTimestamp()

std::string geometrize::script::bindings::getFilenameTimestamp

(

)

{
    return geometrize::util::getFilenameTimestamp();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFilePathsForDirectory()

std::vector< std::string > geometrize::script::bindings::getFilePathsForDirectory

(

const std::string &

dirPath

)

{
    return geometrize::util::getFilePathsForDirectory(dirPath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFilesWithExtension()

std::vector< std::string > geometrize::script::bindings::getFilesWithExtension	(	const std::string &	dirPath,
		const std::string &	extension
	)

{
    return getFilesWithExtensions(dirPath, { extension });
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFilesWithExtensions()

std::vector< std::string > geometrize::script::bindings::getFilesWithExtensions	(	const std::string &	,
		const std::vector< std::string > &
	)

{
    std::vector<std::string> files;
 
    //for(const std::string& extension : extensions) {
        // TODO
    //}
 
    return files;
}

Here is the caller graph for this function:

getFirstFileWithExtension()

std::string geometrize::script::bindings::getFirstFileWithExtension	(	const std::string &	dirPath,
		const std::string &	extension
	)

{
    return geometrize::util::getFirstFileWithExtension(dirPath, extension);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFirstFileWithExtensions()

std::string geometrize::script::bindings::getFirstFileWithExtensions	(	const std::string &	dirPath,
		const std::vector< std::string > &	extensions
	)

{
    return geometrize::util::getFirstFileWithExtensions(dirPath, extensions);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFormattedTimestamp()

std::string geometrize::script::bindings::getFormattedTimestamp

(

const std::string &

formatString

)

{
    return geometrize::util::getFormattedTimestamp(formatString);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGlobalClipboardText()

std::string geometrize::script::bindings::getGlobalClipboardText

(

)

{
    return geometrize::util::getGlobalClipboardText();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getHomeDirectoryLocation()

std::string geometrize::script::bindings::getHomeDirectoryLocation

(

)

{
    return geometrize::util::getHomeDirectoryLocation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getImageTaskWindows()

std::vector< geometrize::dialog::ImageTaskWindow * > geometrize::script::bindings::getImageTaskWindows

(

)

{
    return geometrize::dialog::ImageTaskWindow::getExistingImageTaskWindows();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLaunchWindows()

std::vector< geometrize::dialog::LaunchWindow * > geometrize::script::bindings::getLaunchWindows

(

)

{
    return geometrize::dialog::LaunchWindow::getTopLevelLaunchWindows();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOperatingSystemProductType()

std::string geometrize::script::bindings::getOperatingSystemProductType

(

)

{
    return geometrize::util::getOperatingSystemProductType();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getScriptSearchPaths()

std::vector< std::string > geometrize::script::bindings::getScriptSearchPaths

(

)

{
    return geometrize::searchpaths::getScriptSearchPaths();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getScriptsForPath()

std::vector< std::string > geometrize::script::bindings::getScriptsForPath

(

const std::string &

dirPath

)

{
    return geometrize::util::getScriptsForPath(dirPath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getScriptsForPaths()

std::vector< std::string > geometrize::script::bindings::getScriptsForPaths

(

const std::vector< std::string > &

dirPaths

)

{
    return geometrize::util::getScriptsForPaths(dirPaths);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getSupportedImageFileExtensions()

std::vector< std::string > geometrize::script::bindings::getSupportedImageFileExtensions

(

)

{
    return geometrize::format::getReadableImageFileExtensions(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getSupportedLocaleCodes()

std::vector< std::string > geometrize::script::bindings::getSupportedLocaleCodes

(

)

{
    QStringList codes = geometrize::getSupportedLocaleCodes();
    std::vector<std::string> v;
    for(const QString& s : codes) {
        v.emplace_back(s.toStdString());
    }
    return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getTemplateSearchPaths()

std::vector< std::string > geometrize::script::bindings::getTemplateSearchPaths

(

)

{
    return geometrize::searchpaths::getTemplateSearchPaths();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getUuidString()

std::string geometrize::script::bindings::getUuidString

(

)

{
    return geometrize::util::getUuidString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getWidgetByName()

QWidget * geometrize::script::bindings::getWidgetByName

(

const std::string &

widgetName

)

{
    return geometrize::util::getWidgetByName(widgetName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

messageBox()

void geometrize::script::bindings::messageBox

(

const std::string &

str

)

{
    geometrize::util::messageBox(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

openInDefaultApplication()

bool geometrize::script::bindings::openInDefaultApplication

(

const std::string &

path

)

{
    return geometrize::util::openInDefaultApplication(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

openTask()

void geometrize::script::bindings::openTask	(	const std::string &	url,
		const bool	addToRecents
	)

{
    // Horrible workaround because QUrl doesn't handle Qt resource file prefixes well
    // See: https://forum.qt.io/topic/1494/universal-solution-for-resource-prefix
    // Note this breaks QUrl validation too (QUrl isValid chokes when given this modified url)
    QString qUrl{QString::fromStdString(url)};
    const QString strToReplace{":/"};
    if(qUrl.startsWith(strToReplace)) {
        qUrl.replace(0, strToReplace.size(), "qrc:///");
    }
 
    geometrize::util::openTasks(QStringList(QString::fromStdString(url)), addToRecents);
}

Here is the call graph for this function:

Here is the caller graph for this function:

percentEncode()

std::string geometrize::script::bindings::percentEncode

(

const std::string &

str

)

{
    return geometrize::util::percentEncode(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

printToAllScriptConsoleWidgets()

void geometrize::script::bindings::printToAllScriptConsoleWidgets

(

const std::string &

str

)

{
    geometrize::util::printToAllScriptConsoleWidgets(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

printToConsole()

void geometrize::script::bindings::printToConsole

(

const std::string &

str

)

{
    geometrize::util::printToConsole(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

processApplicationEvents()

void geometrize::script::bindings::processApplicationEvents

(

)

{
    geometrize::util::processApplicationEvents();
}

Here is the call graph for this function:

Here is the caller graph for this function:

randomFloatInRange()

float geometrize::script::bindings::randomFloatInRange	(	const float	lower,
		const float	upper
	)

{
    return randomInRange<float, float, float>(lower, upper);
}

Here is the caller graph for this function:

randomInRange()

template<typename T , typename U , typename V >

T geometrize::script::bindings::randomInRange	(	U	lower,
		V	upper
	)

{
    return static_cast<T>(geometrize::util::randomInRange(static_cast<int>(lower), static_cast<int>(upper)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

randomIntInRange()

int geometrize::script::bindings::randomIntInRange	(	const int	lower,
		const int	upper
	)

{
    return randomInRange<int, int, int>(lower, upper);
}

Here is the caller graph for this function:

randomInVector()

template<typename T >

T geometrize::script::bindings::randomInVector

(

const std::vector< T > &

v

)

{
    assert(!v.empty());
    return v[randomInRange<int, std::size_t, std::size_t>(0, v.size() - 1)];
}

Here is the caller graph for this function:

readFileAsString()

std::string geometrize::script::bindings::readFileAsString

(

const std::string &

filePath

)

{
    return geometrize::util::readFileAsString(filePath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

revealInDefaultApplication()

bool geometrize::script::bindings::revealInDefaultApplication

(

const std::string &

path

)

{
    return geometrize::util::revealInDefaultApplication(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveWidgetScreenshot()

bool geometrize::script::bindings::saveWidgetScreenshot	(	const std::string &	path,
		QWidget *	widget
	)

{
    return geometrize::util::saveWidgetScreenshot(path, widget);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendCommandObject()

void geometrize::script::bindings::sendCommandObject	(	const std::string &	target,
		Command &	command
	)

{
    geometrize::util::sendCommand(target, command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendCommandString()

void geometrize::script::bindings::sendCommandString	(	const std::string &	target,
		const std::string &	command
	)

{
    geometrize::util::sendCommand(target, command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setCursorPos()

void geometrize::script::bindings::setCursorPos	(	const int	x,
		const int	y
	)

{
    geometrize::util::setCursorPos(x, y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setGlobalClipboardText()

void geometrize::script::bindings::setGlobalClipboardText

(

const std::string &

text

)

{
    geometrize::util::setGlobalClipboardText(text);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setLocaleAndUserInterfaceLanguage()

void geometrize::script::bindings::setLocaleAndUserInterfaceLanguage

(

const std::string &

locale

)

{
    geometrize::setLocaleAndUserInterfaceLanguage(QString::fromStdString(locale));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setTranslatorsForLocale()

void geometrize::script::bindings::setTranslatorsForLocale

(

const std::string &

locale

)

{
    geometrize::setTranslatorsForLocale(QString::fromStdString(locale));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setWidgetPosition()

void geometrize::script::bindings::setWidgetPosition	(	QWidget *	widget,
		int	x,
		int	y
	)

{
    geometrize::util::setWidgetPosition(widget, x, y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setWidgetSize()

void geometrize::script::bindings::setWidgetSize	(	QWidget *	widget,
		int	width,
		int	height
	)

{
    geometrize::util::setWidgetSize(widget, width, height);
}

Here is the call graph for this function:

Here is the caller graph for this function:

split()

std::vector< std::string > geometrize::script::bindings::split	(	const std::string &	s,
		const char	delimiter
	)

{
    return geometrize::util::split(s, delimiter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stringBeginsWith()

bool geometrize::script::bindings::stringBeginsWith	(	const std::string &	str,
		const std::string &	prefix
	)

{
    return geometrize::util::stringBeginsWith(str, prefix);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stringEndsWith()

bool geometrize::script::bindings::stringEndsWith	(	const std::string &	str,
		const std::string &	suffix
	)

{
    return geometrize::util::stringEndsWith(str, suffix);
}

Here is the call graph for this function:

Here is the caller graph for this function:

vectorContains()

template<typename T >

bool geometrize::script::bindings::vectorContains	(	const std::vector< T > &	v,
		const T &	t
	)

{
    return (std::find(v.begin(), v.end(), t) != v.end());
}

Here is the caller graph for this function:

writeStringToFile()

bool geometrize::script::bindings::writeStringToFile	(	const std::string &	str,
		const std::string &	path
	)

{
    return geometrize::util::writeStringToFile(str, path);
}

Here is the call graph for this function:

Here is the caller graph for this function: