geometrize::util Namespace Reference

Functions
void	debugBreak ()
	debugBreak Forces the debugger to break/halt the application when this is called. More...
void	printToConsole (const std::string &str)
	printToConsole A convenience function for printing a string to the command-line console. More...
void	printToAllScriptConsoleWidgets (const std::string &str)
	printToAllScriptConsoleWidgets A convenience function for printing a string to all the GUI console widgets in the application More...
void	messageBox (const std::string &str)
	messageBox A convenience function for displaying a message box containing a message. More...
void	processApplicationEvents ()
	processApplicationEvents Processes all pending application events for the calling thread. More...
bool	fileExists (const std::string &filePath)
	fileExists Checks if a file exists, returns true if it does. More...
bool	directoryExists (const std::string &dirPath)
	directoryExists Checks if a directory exists, returns true if it does. More...
bool	directoriesExist (const std::vector< std::string > &dirPaths)
	directoriesExist Checks if the given directories exist, returns true if all do. More...
bool	directoryContainsFile (const std::string &dirPath, const std::string &fileName)
	directoryContainsFile Checks if the directory contains the given file, returns true if it does. More...
bool	createDirectory (const std::string &dirPath)
	createDirectory Creates the directory at the given path, recursively creating subdirectories if needed More...
std::string	readFileAsString (const std::string &filePath)
	readFileAsString Reads a file, returning a string containing the contents. More...
std::vector< std::string >	getFilePathsForDirectory (const std::string &dirPath)
	getFilePathsForDirectory Gets the absolute file paths to the files in the given directory. More...
std::vector< std::string >	getSubdirectoriesForDirectory (const std::string &dirPath)
	getSubdirectoriesForDirectory Gets the absolute paths for direct subdirectories of the given directory. More...
bool	endsWith (const std::string &value, const std::string &ending)
std::vector< std::string >	getFilesWithExtension (const std::string &dirPath, const std::string &extension)
	getFilesWithExtension Gets the absolute file paths to the files with the given extension in the given directory. More...
std::string	getFirstFileWithExtension (const std::string &dirPath, const std::string &extension)
	getFirstFileWithExtension Gets the absolute file path to the first file with the given extension in the given directory. More...
std::string	getFirstFileWithExtensions (const std::string &dirPath, const std::vector< std::string > &extensions)
	getFirstFileWithExtensions Gets the absolute file path to the first file with one of the given extensions in the given directory. More...
std::vector< std::string >	getScriptsForPath (const std::string &path)
	getScriptsForPath Gets the absolute file paths to the script files (*.chai) for the given directory, using recursive search. More...
std::vector< std::string >	getScriptsForPaths (const std::vector< std::string > &dirPaths)
	getScriptsForPaths Gets the absolute file paths to the script files (*.chai) for the given directories, using recursive search. More...
std::string	getDirectoryForFilePath (const std::string &filePath)
	getDirectoryForFilePath Gets the directory path from the given local file path. More...
std::string	getFileNameForFilePath (const std::string &filePath)
	getFileNameForFilePath Gets the filename from the given local file path. More...
bool	openInDefaultApplication (const std::string &path)
	openInDefaultApplication Opens the given path in the default application. More...
bool	revealInDefaultApplication (const std::string &path)
	revealInDefaultApplication Reveals the given path in the parent folder (or path with the filename trimmed). More...
void	clearGlobalClipboard ()
	clearGlobalClipboard Clears the global system clipboard contents. More...
std::string	getGlobalClipboardText ()
	getGlobalClipboardText Gets the global system clipboard text. More...
void	setGlobalClipboardText (const std::string &text)
	setClipboardText Sets the global system clipboard text. More...
bool	stringBeginsWith (const std::string &str, const std::string &prefix)
	stringBeginsWith Checks if a string begins with the given prefix. More...
bool	stringEndsWith (const std::string &str, const std::string &suffix)
	stringEndsWith Checks if a string ends with the given suffix. More...
std::string	getApplicationDirectoryLocation ()
	getApplicationDirectory Get directory that the application is in. More...
std::string	getAppDataLocation ()
	getAppDataLocation Returns a directory location where persistent application data can be stored. More...
std::string	getHomeDirectoryLocation ()
	getHomeDirectoryLocation Returns a path to where the user's home directory is. More...
std::string	getDesktopDirectoryLocation ()
	getDesktopDirectoryLocation Returns a path to where the user's desktop is. More...
bool	writeStringToFile (const std::string &str, const std::string &path)
	writeStringToFile Writes the string to the file path, attempting to overwrite any existing file at the path. More...
std::string	percentEncode (const std::string &str)
	percentEncode Returns a percent-encoded copy of the input string. More...
int	randomInRange (int lower, int upper)
	randomInRange Returns a random integer in the range [lower, upper], inclusive. Note that this uses thread-local RNGs under the hood. This must not be called on the same thread as the Geometrize shape mutation code - otherwise the shape generation may not be deterministic. More...
std::vector< std::string >	split (const std::string &s, char delimiter)
	split Splits a given string into a vector of tokens using the given delimiter. More...
int	getCursorX ()
	getCursorX Gets the x-coordinate of the cursor in global screen coordinates. More...
int	getCursorY ()
	getCursorY Gets the y-coordinate of the cursor in global screen coordinates. More...
void	setCursorPos (int x, int y)
	setCursorPos Sets the cursor position in global screen coordinates. More...
std::string	getOperatingSystemProductType ()
	getOperatingSystemProductType Returns the product name of the operating system this application is running in. More...
bool	saveWidgetScreenshot (const std::string &path, QWidget *widget)
	saveWidgetScreenshot Takes a screenshot of the given widget and saves it as a .png image to the given path. More...
std::vector< std::string >	getAllNamedWidgets ()
	getAllWidgetNames Returns a vector containing the names of all the existing widgets in the application More...
std::vector< std::string >	getAllNamedGeometrizeWidgets ()
	getAllWidgetNames Returns a vector containing the names of all the widgets in the application with "geometrize" in their name More...
QWidget *	getWidgetByName (const std::string &widgetName)
	getWidgetByName Returns the first found instance of the existing widget with the given name More...
std::vector< std::string >	getAllNamedCommandHandlers ()
	getAllNamedCommandHandlers Gets all of the existing objects in the application that implement the CommandHandler interface and can be addressed by name More...
geometrize::script::CommandHandler *	getCommandHandlerByName (const std::string &name)
	getCommandHandlerByName Returns the first found instance of the existing command handler with the given name More...
void	sendCommand (const std::string &target, const std::string &command)
	sendCommand Sends a command to the given command handler More...
void	sendCommand (const std::string &target, geometrize::script::Command &command)
	sendCommand Sends a command to the given command handler More...
void	broadcastCommand (const std::string &command)
	broadcastCommand Sends a command to all command handlers More...
void	broadcastCommand (geometrize::script::Command &command)
	broadcastCommand Sends a command to all command handlers More...
std::string	getFormattedTimestamp (const std::string &formatString)
	getFormattedTimestamp Gets a formatted timestamp for the current local time More...
std::string	getFilenameTimestamp ()
	getFilenameTimestamp Gets a filename timestamp string for the current local time More...
std::string	getUuidString ()
	getUuidString Gets a Universally Unique Identifier (UUID) as a string More...
void	setWidgetSize (QWidget *widget, int width, int height)
	setWidgetSize Sets the size of the given widget in pixels. More...
void	setWidgetPosition (QWidget *widget, int x, int y)
	setWidgetPosition Sets the widget to the given position. More...
void	arrangeWidgetsInGrid (const std::vector< QWidget * > &widgets, int centerX, int centerY, int xDim, int yDim, int resizeX, int resizeY)
	arrangeWidgetsInGrid Arranges the given widgets into a grid shape More...
void	arrangeImageTaskWidgetsInGrid (int centerX, int centerY, int xDim, int yDim, int resizeX, int resizeY)
	arrangeImageTaskWidgetsInGrid Arranges all the open image task widgets into a grid shape More...
void	arrangeWidgetsInGridOnMonitor (const std::vector< QWidget * > &widgets, int screenIdx, int resizeX, int resizeY)
	arrangeWidgetsInGridOnMonitor Arranges the given widgets into a grid on the given monitor More...
void	arrangeImageTaskWidgetsInGridOnMonitor (int screenIdx, int resizeX, int resizeY)
	arrangeImageTaskWidgetsInGridOnMonitor Arranges all the open image task widgets into a grid on the given monitor More...
void	arrangeWidgetsInGridOnPrimaryMonitor (const std::vector< QWidget * > &widgets, int resizeX, int resizeY)
	arrangeWidgetsInGridOnPrimaryMonitor Arranges the given widgets into a grid on the primary monitor More...
void	arrangeImageTaskWidgetsInGridOnPrimaryMonitor (int resizeX, int resizeY)
	arrangeImageTaskWidgetsInGridOnPrimaryMonitor Arranges all the open image task widgets into a grid on the given monitor More...
void	fitWidgetsInGridOnMonitor (const std::vector< QWidget * > &widgets, int screenIdx)
	fitWidgetsInGridOnMonitor Fits the given widgets into a grid on the given monitor More...
void	fitImageTaskWidgetsInGridOnMonitor (int screenIdx)
	fitImageTaskWidgetsInGridOnMonitor Fits all of the open image task widgets into a grid on the given monitor More...
void	fitWidgetsInGridOnPrimaryMonitor (const std::vector< QWidget * > &widgets)
	fitWidgetsInGridOnPrimaryMonitor Fits the given widgets into a grid on the primary monitor More...
void	fitImageTaskWidgetsInGridOnPrimaryMonitor ()
	fitImageTaskWidgetsInGridOnPrimaryMonitor Fits all of the open image task widgets into a grid on the primary monitor More...
template<typename T >
T	clamp (T value, T lower, T upper)
	clamp Clamps a value within a range. More...
template<typename T >
void	split (const std::string &s, const char delimiter, T result)
std::vector< std::string >	readStringVector (const std::string &filePath)
	readStringVector Reads the JSON file containing the vector of strings at the given filepath. Will attempt to overwrite any existing file when it does this. More...
void	writeStringVector (const std::vector< std::string > &vec, const std::string &filePath)
	writeStringVector Writes the string vector to the given filepath as JSON. Will attempt to overwrite any existing file. More...
void	openTask (const QString &urlStr, bool addToRecents)
void	openTasks (const QStringList &urls, const bool addToRecents)
bool	openTemplate (chaiscript::ChaiScript &engine, const std::string &templateFolder)
TemplateManifest	getTemplateManifest (const std::string &templateFolder)

Function Documentation

arrangeImageTaskWidgetsInGrid()

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

arrangeImageTaskWidgetsInGrid Arranges all the open image task widgets into a grid shape

Parameters

centerX	The x coordinate of where to center the grid
centerY	The y coordinate of where to center the grid
xDim	The number of widgets to lay out horizontally
yDim	The number of widgets to lay out vertically
resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    arrangeWidgetsInGrid(getImageTaskWidgets(), 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::util::arrangeImageTaskWidgetsInGridOnMonitor	(	int	screenIdx,
		int	resizeX,
		int	resizeY
	)

arrangeImageTaskWidgetsInGridOnMonitor Arranges all the open image task widgets into a grid on the given monitor

Parameters

screenIdx	The index of the screen to center the grid on
resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    arrangeWidgetsInGridOnMonitor(getImageTaskWidgets(), screenIdx, resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeImageTaskWidgetsInGridOnPrimaryMonitor()

void geometrize::util::arrangeImageTaskWidgetsInGridOnPrimaryMonitor	(	int	resizeX,
		int	resizeY
	)

arrangeImageTaskWidgetsInGridOnPrimaryMonitor Arranges all the open image task widgets into a grid on the given monitor

Parameters

resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    arrangeWidgetsInGridOnPrimaryMonitor(getImageTaskWidgets(), resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGrid()

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

arrangeWidgetsInGrid Arranges the given widgets into a grid shape

Parameters

widgets	The widgets to arrange
centerX	The x coordinate of where to center the grid
centerY	The y coordinate of where to center the grid
xDim	The number of widgets to lay out horizontally
yDim	The number of widgets to lay out vertically
resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    int idx = 0;
    const int width = xDim * resizeX;
    const int height = yDim * resizeY;
    for(int y = 0; y < yDim; y++) {
        for(int x = 0; x < xDim; x++) {
            if(idx >= widgets.size()) {
                continue;
            }
            if(QWidget* widget = widgets[idx]) {
                setWidgetSize(widget, resizeX, resizeY);
                setWidgetPosition(widget, (centerX - width / 2) + x * resizeX, (centerY - height / 2) + y * resizeY);
            }
            idx++;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGridOnMonitor()

void geometrize::util::arrangeWidgetsInGridOnMonitor	(	const std::vector< QWidget * > &	widgets,
		int	screenIdx,
		int	resizeX,
		int	resizeY
	)

arrangeWidgetsInGridOnMonitor Arranges the given widgets into a grid on the given monitor

Parameters

widgets	The widgets to arrange
screenIdx	The index of the screen to center the grid on
resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    QList<QScreen*> screens = QGuiApplication::screens();
    if(screenIdx >= screens.size()) {
        return;
    }
    QRect screenGeometry = screens.at(screenIdx)->geometry();
    int height = screenGeometry.height();
    int width = screenGeometry.width();
    arrangeWidgetsInGrid(widgets, screenGeometry.x() + width / 2, screenGeometry.y() + height / 2, (width / resizeX), (height / resizeY), resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrangeWidgetsInGridOnPrimaryMonitor()

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

arrangeWidgetsInGridOnPrimaryMonitor Arranges the given widgets into a grid on the primary monitor

Parameters

widgets	The widgets to arrange
resizeX	The width to resize the widgets to
resizeY	The height to resize the widgets to

{
    arrangeWidgetsInGridOnMonitor(widgets, getPrimaryScreenIdx(), resizeX, resizeY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

broadcastCommand() [1/2]

void geometrize::util::broadcastCommand

(

const std::string &

command

)

broadcastCommand Sends a command to all command handlers

Parameters

command

A string representation of the command

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    for(const auto& h : handlers) {
        h->handleCommand(geometrize::script::Command(command));
    }
}

Here is the caller graph for this function:

broadcastCommand() [2/2]

void geometrize::util::broadcastCommand

(

geometrize::script::Command &

command

)

broadcastCommand Sends a command to all command handlers

Parameters

command

A command object representing the command

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    for(const auto& h : handlers) {
        h->handleCommand(command);
    }
}

clamp()

template<typename T >

T geometrize::util::clamp	(	T	value,
		T	lower,
		T	upper
	)

clamp Clamps a value within a range.

Parameters

value	The value to clamp.
lower	The lower bound of the range.
upper	The upper bound of the range.

Returns

The clamped value.

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

Here is the caller graph for this function:

clearGlobalClipboard()

void geometrize::util::clearGlobalClipboard

(

)

clearGlobalClipboard Clears the global system clipboard contents.

{
    QApplication::clipboard()->clear();
}

Here is the caller graph for this function:

createDirectory()

bool geometrize::util::createDirectory

(

const std::string &

dirPath

)

createDirectory Creates the directory at the given path, recursively creating subdirectories if needed

Returns

True if the directory was created (or already existed), else false

{
    return QDir().mkpath(QString::fromStdString(dirPath));
}

Here is the caller graph for this function:

debugBreak()

void geometrize::util::debugBreak

(

)

debugBreak Forces the debugger to break/halt the application when this is called.

{
#ifdef _MSC_VER
    __debugbreak();
#elif __MINGW32__
    // Not sure how to break here...
    assert(0 && "Mingw32 debug break");
#else
    raise(SIGTRAP);
#endif
}

Here is the caller graph for this function:

directoriesExist()

bool geometrize::util::directoriesExist

(

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

dirPaths

)

directoriesExist Checks if the given directories exist, returns true if all do.

Parameters

dirPaths

The directory paths.

Returns

True if all the directories exist, false if any do not.

{
    return std::all_of(dirPaths.begin(), dirPaths.end(), directoryExists);
}

Here is the call graph for this function:

Here is the caller graph for this function:

directoryContainsFile()

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

directoryContainsFile Checks if the directory contains the given file, returns true if it does.

Returns

True if the directory contains the given file, false otherwise.

{
    const QString qFileName{QString::fromStdString(fileName)};
    QDirIterator it(QString::fromStdString(dirPath));
    while(it.hasNext()) {
        it.next();
        if(QFileInfo(it.filePath()).isFile()) {
            if(it.fileName() == qFileName) {
                return true;
            }
        }
    }
    return false;
}

Here is the caller graph for this function:

directoryExists()

bool geometrize::util::directoryExists

(

const std::string &

dirPath

)

directoryExists Checks if a directory exists, returns true if it does.

Parameters

dirPath

The directory path.

Returns

True if the directory exists, false if it does not.

{
    return QDir(QString::fromStdString(dirPath)).exists();
}

Here is the caller graph for this function:

endsWith()

bool geometrize::util::endsWith ( const std::string &  value, const std::string &  ending  )

inline

{
    if (value.length() >= ending.length()) {
        return (0 == value.compare (value.length() - ending.length(), ending.length(), ending));
    } else {
        return false;
    }
}

fileExists()

bool geometrize::util::fileExists

(

const std::string &

filePath

)

fileExists Checks if a file exists, returns true if it does.

Parameters

filePath

The file path.

Returns

True if the file exists, false if it does not.

{
    return QFile(QString::fromStdString(filePath)).exists();
}

Here is the caller graph for this function:

fitImageTaskWidgetsInGridOnMonitor()

void geometrize::util::fitImageTaskWidgetsInGridOnMonitor

(

int

screenIdx

)

fitImageTaskWidgetsInGridOnMonitor Fits all of the open image task widgets into a grid on the given monitor

Parameters

screenIdx

The index of the screen to center the grid on

{
    fitWidgetsInGridOnMonitor(getImageTaskWidgets(), screenIdx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitImageTaskWidgetsInGridOnPrimaryMonitor()

void geometrize::util::fitImageTaskWidgetsInGridOnPrimaryMonitor

(

)

fitImageTaskWidgetsInGridOnPrimaryMonitor Fits all of the open image task widgets into a grid on the primary monitor

{
    fitWidgetsInGridOnPrimaryMonitor(getImageTaskWidgets());
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitWidgetsInGridOnMonitor()

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

fitWidgetsInGridOnMonitor Fits the given widgets into a grid on the given monitor

Parameters

widgets	The widgets to arrange
screenIdx	The index of the screen to center the grid on

{
    QList<QScreen*> screens = QGuiApplication::screens();
    if(screenIdx >= screens.size()) {
        return;
    }
    QRect screenGeometry = screens.at(screenIdx)->geometry();
    const int width = screenGeometry.width();
    const int height = screenGeometry.height();
    const double maxWidgetsAcross = 4.0;
    const int widgetWidth = std::max(1.0, (static_cast<double>(width) / maxWidgetsAcross) - 5);
    const int widgetHeight = std::max(1.0, std::min((static_cast<double>(height) / (static_cast<double>(widgets.size() / maxWidgetsAcross))) - 5, 800.0));
    arrangeWidgetsInGridOnMonitor(widgets, screenIdx, widgetWidth, widgetHeight);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fitWidgetsInGridOnPrimaryMonitor()

void geometrize::util::fitWidgetsInGridOnPrimaryMonitor

(

const std::vector< QWidget * > &

widgets

)

fitWidgetsInGridOnPrimaryMonitor Fits the given widgets into a grid on the primary monitor

Parameters

widgets

The widgets to arrange

{
    fitWidgetsInGridOnMonitor(widgets, getPrimaryScreenIdx());
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAllNamedCommandHandlers()

std::vector< std::string > geometrize::util::getAllNamedCommandHandlers

(

)

getAllNamedCommandHandlers Gets all of the existing objects in the application that implement the CommandHandler interface and can be addressed by name

Returns

A vector containing the names of all existing objects that implement the CommandHandler interface

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    std::vector<std::string> names;
    for(const auto& h : handlers) {
        names.emplace_back(h->getCommandHandlerName());
    }
    return names;
}

Here is the caller graph for this function:

getAllNamedGeometrizeWidgets()

std::vector< std::string > geometrize::util::getAllNamedGeometrizeWidgets

(

)

getAllWidgetNames Returns a vector containing the names of all the widgets in the application with "geometrize" in their name

Returns

A vector containing the names of all the existing widgets in the application with "geometrize" in their name

{
    std::vector<std::string> names;
    const QWidgetList allWidgets = QApplication::allWidgets();
    for (QWidget* widget : allWidgets) {
        if(widget && widget->objectName().contains("geometrize")) {
            names.emplace_back(widget->objectName().toStdString());
        }
    }
    return names;
}

Here is the caller graph for this function:

getAllNamedWidgets()

std::vector< std::string > geometrize::util::getAllNamedWidgets

(

)

getAllWidgetNames Returns a vector containing the names of all the existing widgets in the application

Returns

A vector containing the names of all the existing widgets in the application

{
    std::vector<std::string> names;
    const QWidgetList allWidgets = QApplication::allWidgets();
    for (QWidget* widget : allWidgets) {
        if(widget && !widget->objectName().isEmpty()) {
            names.emplace_back(widget->objectName().toStdString());
        }
    }
    return names;
}

Here is the caller graph for this function:

getAppDataLocation()

std::string geometrize::util::getAppDataLocation

(

)

getAppDataLocation Returns a directory location where persistent application data can be stored.

Returns

Directory location where persistent application data can be stored.

{
    return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation).toStdString();
}

Here is the caller graph for this function:

getApplicationDirectoryLocation()

std::string geometrize::util::getApplicationDirectoryLocation

(

)

getApplicationDirectory Get directory that the application is in.

Returns

Get application directory.

{
    return QCoreApplication::applicationDirPath().toStdString();
}

Here is the caller graph for this function:

getCommandHandlerByName()

geometrize::script::CommandHandler * geometrize::util::getCommandHandlerByName

(

const std::string &

name

)

getCommandHandlerByName Returns the first found instance of the existing command handler with the given name

Parameters

name	The name of the command handler to find

Returns

A pointer to the first command handler with the given name, nullptr if no match

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    for(const auto& h : handlers) {
        if(h->getCommandHandlerName() == name)
        {
            return h;
        }
    }
    return nullptr;
}

Here is the caller graph for this function:

getCursorX()

int geometrize::util::getCursorX

(

)

getCursorX Gets the x-coordinate of the cursor in global screen coordinates.

Returns

The x-coordinate of the cursor.

{
    return QCursor::pos().x();
}

Here is the caller graph for this function:

getCursorY()

int geometrize::util::getCursorY

(

)

getCursorY Gets the y-coordinate of the cursor in global screen coordinates.

Returns

The y-coordinate of the cursor.

{
    return QCursor::pos().y();
}

Here is the caller graph for this function:

getDesktopDirectoryLocation()

std::string geometrize::util::getDesktopDirectoryLocation

(

)

getDesktopDirectoryLocation Returns a path to where the user's desktop is.

Returns

Location of the user's desktop directory.

{
    return QStandardPaths::writableLocation(QStandardPaths::DesktopLocation).toStdString();
}

Here is the caller graph for this function:

getDirectoryForFilePath()

std::string geometrize::util::getDirectoryForFilePath

(

const std::string &

filePath

)

getDirectoryForFilePath Gets the directory path from the given local file path.

Parameters

filePath

The filepath to chop.

Returns

The directory path i.e. the file path with the file name and any trailing slashes removed.

{
    const QFileInfo fileInfo{QString::fromStdString(filePath)};
 
    if(!fileInfo.exists()) {
        assert(0 && "File does not exist");
    }
 
    return fileInfo.absoluteDir().absolutePath().toStdString();
}

Here is the caller graph for this function:

getFileNameForFilePath()

std::string geometrize::util::getFileNameForFilePath

(

const std::string &

filePath

)

getFileNameForFilePath Gets the filename from the given local file path.

Parameters

filePath

The filepath to chop.

Returns

The filename i.e. the file name from the end of the filepath

{
    return QFileInfo(QString::fromStdString(filePath)).fileName().toStdString();
}

Here is the caller graph for this function:

getFilenameTimestamp()

std::string geometrize::util::getFilenameTimestamp

(

)

getFilenameTimestamp Gets a filename timestamp string for the current local time

Returns

A timestamp string in the format "yyyy_MM_dd_hh_mm_ss_zzz"

{
    return getFormattedTimestamp("yyyy_MM_dd_hh_mm_ss_zzz");
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFilePathsForDirectory()

std::vector< std::string > geometrize::util::getFilePathsForDirectory

(

const std::string &

dirPath

)

getFilePathsForDirectory Gets the absolute file paths to the files in the given directory.

Parameters

dirPath

The directory to search.

Returns

A vector of files.

{
    std::vector<std::string> files;
 
    QDirIterator it(QString::fromStdString(dirPath));
    while(it.hasNext()) {
        it.next();
        if(QFileInfo(it.filePath()).isFile()) {
            files.push_back(it.filePath().toStdString());
        }
    }
    return files;
}

Here is the caller graph for this function:

getFilesWithExtension()

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

getFilesWithExtension Gets the absolute file paths to the files with the given extension in the given directory.

Parameters

dirPath	The directory to search.
extension	The file extension to match.

Returns

The file paths to the files encountered, empty vector if there are no matching files. The order of the file paths is implementation-dependent.

{
    std::vector<std::string> files{getFilePathsForDirectory(dirPath)};
 
    files.erase(std::remove_if(files.begin(), files.end(), [&extension](const std::string& s) {
        return !endsWith(s, extension);
    }), files.end());
 
    return files;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFirstFileWithExtension()

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

getFirstFileWithExtension Gets the absolute file path to the first file with the given extension in the given directory.

Parameters

dirPath	The directory to search.
extension	The file extension to match.

Returns

The file path to the first matching file encountered, empty string if there are no matching files. The 'first' file is implementation-dependent.

{
    const std::vector<std::string> files{getFilesWithExtension(dirPath, extension)};
 
    if(files.empty()) {
        return "";
    }
    return files.front();
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFirstFileWithExtensions()

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

getFirstFileWithExtensions Gets the absolute file path to the first file with one of the given extensions in the given directory.

Parameters

dirPath	The directory to search.
extensions	The file extension to match.

Returns

The file path to the first matching file encountered, empty string if there are no matching files. The 'first' file is implementation-dependent.

{
    for(const std::string& ext : extensions) {
        const std::string s{getFirstFileWithExtension(dirPath, ext)};
        if(!s.empty()) {
            return s;
        }
    }
 
    return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFormattedTimestamp()

std::string geometrize::util::getFormattedTimestamp

(

const std::string &

formatString

)

getFormattedTimestamp Gets a formatted timestamp for the current local time

Parameters

formatString

The format of the timestamp e.g. "ddMMyyyy-hhmmss"

Returns

A string representing a timestamp for the current local time

{
    return QDateTime::currentDateTime().toString(QString::fromStdString(formatString)).toStdString();
}

Here is the caller graph for this function:

getGlobalClipboardText()

std::string geometrize::util::getGlobalClipboardText

(

)

getGlobalClipboardText Gets the global system clipboard text.

Returns

The global system clipboard text, or an empty string if the clipboard does not contain any text.

{
    return QApplication::clipboard()->text().toStdString();
}

Here is the caller graph for this function:

getHomeDirectoryLocation()

std::string geometrize::util::getHomeDirectoryLocation

(

)

getHomeDirectoryLocation Returns a path to where the user's home directory is.

Returns

Location of the user's home directory.

{
    return QStandardPaths::writableLocation(QStandardPaths::HomeLocation).toStdString();
}

Here is the caller graph for this function:

getOperatingSystemProductType()

std::string geometrize::util::getOperatingSystemProductType

(

)

getOperatingSystemProductType Returns the product name of the operating system this application is running in.

Returns

The name of the operating system: "windows", "osx", "linux", "android", "ios", "tvos" etc

{
    return QSysInfo::productType().toStdString();
}

Here is the caller graph for this function:

getScriptsForPath()

std::vector< std::string > geometrize::util::getScriptsForPath

(

const std::string &

path

)

getScriptsForPath Gets the absolute file paths to the script files (*.chai) for the given directory, using recursive search.

Parameters

dirPath

The directory to search.

Returns

The absolute file paths to the script files for the given directory.

{
    std::vector<std::string> scripts;
    if(!util::directoryExists(dirPath)) {
        assert(0 && "Script directory does not exist");
        return scripts;
    }
 
    QDirIterator it(QString::fromStdString(dirPath), { "*.chai" }, QDir::Files, QDirIterator::Subdirectories);
    while (it.hasNext()) {
        scripts.push_back(it.next().toStdString());
    }
 
    return scripts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getScriptsForPaths()

std::vector< std::string > geometrize::util::getScriptsForPaths

(

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

dirPaths

)

getScriptsForPaths Gets the absolute file paths to the script files (*.chai) for the given directories, using recursive search.

Parameters

dirPaths

The directories to search.

Returns

The absolute file paths to the script files for the given directories.

{
    std::vector<std::string> scripts;
    for(const auto& dirPath : dirPaths) {
        const auto newScripts = getScriptsForPath(dirPath);
        scripts.insert(scripts.end(), newScripts.begin(), newScripts.end());
    }
    return scripts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getSubdirectoriesForDirectory()

std::vector< std::string > geometrize::util::getSubdirectoriesForDirectory

(

const std::string &

dirPath

)

getSubdirectoriesForDirectory Gets the absolute paths for direct subdirectories of the given directory.

Parameters

dirPath

The directory to search.

Returns

A vector of directory paths.

{
    std::vector<std::string> files;
 
    QDirIterator it(QString::fromStdString(dirPath));
    while(it.hasNext()) {
        it.next();
        if(QFileInfo(it.filePath()).isDir()) {
            files.push_back(it.filePath().toStdString());
        }
    }
    return files;
}

Here is the caller graph for this function:

getTemplateManifest()

TemplateManifest geometrize::util::getTemplateManifest

(

const std::string &

templateFolder

)

{
    return TemplateManifest(util::getFirstFileWithExtensions(templateFolder, format::getSupportedTemplateManifestFileExtensions()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

getUuidString()

std::string geometrize::util::getUuidString

(

)

getUuidString Gets a Universally Unique Identifier (UUID) as a string

Returns

The UUID string

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

Here is the caller graph for this function:

getWidgetByName()

QWidget * geometrize::util::getWidgetByName

(

const std::string &

widgetName

)

getWidgetByName Returns the first found instance of the existing widget with the given name

Parameters

widgetName

The name of the widget to find

Returns

A pointer to the first widget instance with the given name, nullptr if no match

{
    const QWidgetList allWidgets = QApplication::allWidgets();
    for (QWidget* widget : allWidgets) {
        if(widget && widget->objectName().toStdString() == widgetName) {
            return widget;
        }
    }
    return nullptr;
}

Here is the caller graph for this function:

messageBox()

void geometrize::util::messageBox

(

const std::string &

str

)

messageBox A convenience function for displaying a message box containing a message.

Parameters

str	The string to display in the message box.

{
    QMessageBox msgBox;
    msgBox.setText(QString::fromStdString(str));
    msgBox.exec();
}

Here is the caller graph for this function:

openInDefaultApplication()

bool geometrize::util::openInDefaultApplication

(

const std::string &

path

)

openInDefaultApplication Opens the given path in the default application.

Parameters

path	The path to the resource to open.

Returns

True if the directory, file, URL (or whatever) should open, else false.

{
    return QDesktopServices::openUrl(QUrl::fromUserInput(QString::fromStdString(path)));
}

Here is the caller graph for this function:

openTask()

void geometrize::util::openTask	(	const QString &	urlStr,
		bool	addToRecents
	)

{
    if(urlStr.length() == 0) {
        return;
    }
 
    if(addToRecents) {
        geometrize::getRecentItems().add(urlStr, urlStr);
    }
 
    const QUrl url{QUrl::fromUserInput(urlStr)};
    if(url.isLocalFile()) {
        geometrize::task::createImageTaskAndWindow(url.toLocalFile().toStdString(), url.toLocalFile().toStdString(), std::nullopt);
        return;
    }
 
    std::vector<std::string> imageExtensions{format::getReadableImageFileExtensions(true)};
    for(const std::string& ext : imageExtensions) {
        if(url.toString().endsWith(QString::fromStdString(ext), Qt::CaseInsensitive)) {
            network::downloadImage(url, network::completionhandlers::onImageDownloadComplete);
            return;
        }
    }
 
    network::downloadWebpage(url, network::completionhandlers::onWebpageDownloadComplete);
}

Here is the call graph for this function:

Here is the caller graph for this function:

openTasks()

void geometrize::util::openTasks	(	const QStringList &	urls,
		const bool	addToRecents
	)

{
    for(const QString& url : urls) {
        openTask(url, addToRecents);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

openTemplate()

bool geometrize::util::openTemplate	(	chaiscript::ChaiScript &	engine,
		const std::string &	templateFolder
	)

{
    const std::vector<std::string> scripts{util::getScriptsForPath(templateFolder)};
    if(scripts.empty()) {
        // Could not find script for template, so assume it's an image task
        const std::string imageFile{util::getFirstFileWithExtensions(templateFolder, format::getReadableImageFileExtensions(true))};
        if(imageFile.empty()) {
            return false;
        }
 
        // Apply settings file if a default one is available
        const auto prefs = [&templateFolder]() -> std::optional<preferences::ImageTaskPreferences> {
            const std::string settingsFile{geometrize::searchpaths::getDefaultTaskSettingsFilename()};
            if(util::directoryContainsFile(templateFolder, settingsFile)) {
                const std::string settingsPath{QDir(QString::fromStdString(templateFolder)).filePath(QString::fromStdString(settingsFile)).toStdString()};
                const preferences::ImageTaskPreferences prefs(settingsPath);
                return prefs;
            }
            return std::nullopt;
        }();
 
        task::createImageTaskAndWindow(imageFile, imageFile, prefs);
 
        return true;
    }
 
    const std::string script{util::readFileAsString(scripts.front())};
    engine.set_global(chaiscript::var(templateFolder), "templateDirectory");
    geometrize::script::runScript(script, engine);
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

percentEncode()

std::string geometrize::util::percentEncode

(

const std::string &

str

)

percentEncode Returns a percent-encoded copy of the input string.

Parameters

str	The input string, to be percent-encoded.

Returns

The percent-encoded input string.

{
    const QString s{QString::fromStdString(str)};
    const QString percentEncoded{QUrl::toPercentEncoding(s)};
    return percentEncoded.toStdString();
}

Here is the caller graph for this function:

printToAllScriptConsoleWidgets()

void geometrize::util::printToAllScriptConsoleWidgets

(

const std::string &

str

)

printToAllScriptConsoleWidgets A convenience function for printing a string to all the GUI console widgets in the application

Parameters

str	The string to print to the script console widgets.

{
    const auto& allWidgets = QApplication::topLevelWidgets();
    for (const auto& widget : allWidgets) {
        const auto& consoles = widget->findChildren<geometrize::dialog::ScriptConsole*>();
        for(auto& console : consoles) {
            console->appendString(str);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

printToConsole()

void geometrize::util::printToConsole

(

const std::string &

str

)

printToConsole A convenience function for printing a string to the command-line console.

Parameters

str	The string to print to the console.

{
    QTextStream(stdout) << QString::fromStdString(str);
}

Here is the caller graph for this function:

processApplicationEvents()

void geometrize::util::processApplicationEvents

(

)

processApplicationEvents Processes all pending application events for the calling thread.

{
    QCoreApplication* app = QCoreApplication::instance();
    if(app == nullptr) {
        assert(0 && "Application instance pointer is null");
        return;
    }
    app->processEvents();
}

Here is the caller graph for this function:

randomInRange()

int geometrize::util::randomInRange	(	int	lower,
		int	upper
	)

randomInRange Returns a random integer in the range [lower, upper], inclusive. Note that this uses thread-local RNGs under the hood. This must not be called on the same thread as the Geometrize shape mutation code - otherwise the shape generation may not be deterministic.

Parameters

lower	The minimum value.
upper	The maximum value.

Returns

An integer in the range [lower, upper] inclusive.

{
    assert(lower <= upper);
    return geometrize::commonutil::randomRange(lower, upper);
}

Here is the caller graph for this function:

readFileAsString()

std::string geometrize::util::readFileAsString

(

const std::string &

filePath

)

readFileAsString Reads a file, returning a string containing the contents.

Parameters

filePath

The path to the file.

Returns

The contents of the file, as a string.

{
    QFile file(QString::fromStdString(filePath));
 
    if(file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        return QString(file.readAll()).toStdString();
    }
 
    return "";
}

Here is the caller graph for this function:

readStringVector()

std::vector< std::string > geometrize::util::readStringVector

(

const std::string &

filePath

)

readStringVector Reads the JSON file containing the vector of strings at the given filepath. Will attempt to overwrite any existing file when it does this.

Parameters

filePath

The path to the file to read.

Returns

The vector of strings read from the file.

{
    if(!geometrize::util::stringEndsWith(filePath, ".json")) {
        assert(0 && "Failed to read string vector, check file extension");
    }
 
    std::vector<std::string> result;
    std::ifstream file(filePath);
    if(!file) {
        return result;
    }
 
    cereal::JSONInputArchive archive(file);
    archive(result);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

revealInDefaultApplication()

bool geometrize::util::revealInDefaultApplication

(

const std::string &

path

)

revealInDefaultApplication Reveals the given path in the parent folder (or path with the filename trimmed).

Parameters

path	The path to the resource to view.

Returns

True if the file, folder, URL (or whatever) should be revealed, else false.

{
    const QUrl directoryPath{QUrl::fromUserInput(QString::fromStdString(path)).adjusted(QUrl::RemoveFilename)};
    return QDesktopServices::openUrl(directoryPath);
}

Here is the caller graph for this function:

saveWidgetScreenshot()

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

saveWidgetScreenshot Takes a screenshot of the given widget and saves it as a .png image to the given path.

Parameters

path	The file path to save the screenshot to.
widget	The widget to take a screenshot of.

Returns

True if the screenshot was taken and save successfully, else false.

{
    return widget->grab().save(QString::fromStdString(path), "png");
}

Here is the caller graph for this function:

sendCommand() [1/2]

void geometrize::util::sendCommand	(	const std::string &	target,
		const std::string &	command
	)

sendCommand Sends a command to the given command handler

Parameters

target	The name of the target command handler
command	A string representation of the command

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    for(const auto& h : handlers) {
        if(h->getCommandHandlerName() == target)
        {
            h->handleCommand(geometrize::script::Command(command));
            return;
        }
    }
}

Here is the caller graph for this function:

sendCommand() [2/2]

void geometrize::util::sendCommand	(	const std::string &	target,
		geometrize::script::Command &	command
	)

sendCommand Sends a command to the given command handler

Parameters

target	The name of the target command handler
command	A command object representing the command

{
    const auto& handlers = geometrize::script::CommandHandler::allCommandHandlers;
    for(const auto& h : handlers) {
        if(h->getCommandHandlerName() == target)
        {
            h->handleCommand(geometrize::script::Command(command));
            return;
        }
    }
}

setCursorPos()

void geometrize::util::setCursorPos	(	int	x,
		int	y
	)

setCursorPos Sets the cursor position in global screen coordinates.

Parameters

x	The x-coordinate of the cursor.
y	The y-coordinate of the cursor.

{
    QCursor::setPos(x, y);
}

Here is the caller graph for this function:

setGlobalClipboardText()

void geometrize::util::setGlobalClipboardText

(

const std::string &

text

)

setClipboardText Sets the global system clipboard text.

Parameters

text	The text to set as the clipboard text.

{
    QApplication::clipboard()->setText(QString::fromStdString(text));
}

Here is the caller graph for this function:

setWidgetPosition()

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

setWidgetPosition Sets the widget to the given position.

Parameters

widget	The widget to move.
x	The x-coordinate to set on the widget.
y	The y-coordinate to set on the widget.

{
    widget->move(x, y);
}

Here is the caller graph for this function:

setWidgetSize()

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

setWidgetSize Sets the size of the given widget in pixels.

Parameters

widget	The widget to resize.
width	The width to set on the widget.
height	The height to set on the widget.

{
    widget->resize(width, height);
}

Here is the caller graph for this function:

split() [1/2]

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

split Splits a given string into a vector of tokens using the given delimiter.

Parameters

s	The string to split.
delimiter	The delimiter to split on.

Returns

A vector containing the split string.

{
    std::vector<std::string> elements;
    split(s, delimiter, std::back_inserter(elements));
    return elements;
}

Here is the caller graph for this function:

split() [2/2]

template<typename T >

void geometrize::util::split	(	const std::string &	s,
		const char	delimiter,
		T	result
	)

{
    std::stringstream ss;
    ss.str(s);
    std::string item;
    while (std::getline(ss, item, delimiter)) {
        *(result++) = item;
    }
}

stringBeginsWith()

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

stringBeginsWith Checks if a string begins with the given prefix.

Parameters

str	The string to check.
prefix	The prefix to check for.

Returns

True if the string begins with the given prefix, false otherwise.

{
    return str.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), str.begin());
}

Here is the caller graph for this function:

stringEndsWith()

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

stringEndsWith Checks if a string ends with the given suffix.

Parameters

str	The string to check.
suffix	The suffix ending to check for.

Returns

True if the string ends with the given suffix, false otherwise.

{
    return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}

Here is the caller graph for this function:

writeStringToFile()

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

writeStringToFile Writes the string to the file path, attempting to overwrite any existing file at the path.

Parameters

str	The string to write to file.
path	The file path to write to.

Returns

True if the string was successfully written to the file, else false.

{
    std::ofstream out(path, std::ios::trunc | std::ios::out);
    if(!out.is_open()) {
        return false;
    }
 
    if(out) {
        out << str;
    }
 
    out.close();
 
    if(!out) {
        return false;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

writeStringVector()

void geometrize::util::writeStringVector	(	const std::vector< std::string > &	vec,
		const std::string &	filePath
	)

writeStringVector Writes the string vector to the given filepath as JSON. Will attempt to overwrite any existing file.

Parameters

text	The vector of strings to write.
filePath	The path of the file to write to.

{
    if(!geometrize::util::stringEndsWith(filePath, ".json")) {
        assert(0 && "Failed to write string vector, check file extension");
    }
 
    // Create folders up to the path if necessary
    const QFileInfo fileInfo(QString::fromStdString(filePath));
    if(!fileInfo.exists()) {
        const bool createdDir{QDir().mkpath(fileInfo.absolutePath())};
        if(!createdDir) {
            assert(0 && "Failed to create directory for string vector");
            return;
        }
    }
 
    std::ofstream file(filePath);
    cereal::JSONOutputArchive archive(file);
    archive(cereal::make_nvp("stringVector", vec));
}

Here is the call graph for this function:

Here is the caller graph for this function: