VuoInputEditorMathExpressionList.cc

Go to the documentation of this file.

 
#include "VuoInputEditorMathExpressionList.hh"
#include "VuoInputEditorIcon.hh"
 
extern "C"
{
    #include "VuoHeap.h"
    #include "VuoMathExpressionList.h"
    #include "VuoMathExpressionParser.h"
}
 
VuoInputEditor * VuoInputEditorMathExpressionFactory::newInputEditor(void)
{
    return new VuoInputEditorMathExpressionList();
}
 
VuoInputEditorMathExpressionList::VuoInputEditorMathExpressionList(void)
    : VuoInputEditorWithLineEditList(false, 200)
{
    hasError = false;
    errorMessage = NULL;
    originalValue = NULL;
 
    QString validCharacters = QString(" _0-9a-zA-Z=&|<>!+*/^%?:()");
    validCharacters.append( getDecimalPointInUserLocale() );  // . or ,
    validCharacters.append( getListSeparatorInUserLocale() );  // , or ;
    QString validCharactersEscaped = QRegExp::escape(validCharacters);
    validCharactersEscaped.append("\\-");  // not escaped by QRegExp::escape()
    QRegExp regExp( QString("([%1])*").arg(validCharactersEscaped) );
    validator = new QRegExpValidator(regExp, this);
}
 
void VuoInputEditorMathExpressionList::setUpDialog(QDialog &dialog, json_object *originalValue, json_object *details)
{
    VuoInputEditorWithLineEditList::setUpDialog(dialog, originalValue, details);
 
    this->originalValue = originalValue;
 
    dialog.installEventFilter(this);
}
 
QLayout * VuoInputEditorMathExpressionList::setUpRow(QDialog &dialog, QLineEdit *lineEdit)
{
    QLayout *rowLayout = VuoInputEditorWithLineEditList::setUpRow(dialog, lineEdit);
 
    QPixmap *errorPixmap = VuoInputEditorIcon::renderErrorPixmap(isDark);
    QLabel *errorLabel = new QLabel(lineEdit);
    errorLabel->setPixmap(*errorPixmap);
    errorLabel->adjustSize();
    errorLabel->move(lineEdit->width() - errorLabel->width() - rowLayout->spacing(),
                     (lineEdit->height() - errorLabel->height()) / 2.);
    errorLabel->setVisible(false);
    errorSymbols.insert(rowLayout, errorLabel);
    delete errorPixmap;
 
    lineEdit->setValidator(validator);
    connect(lineEdit, &QLineEdit::editingFinished, this, &VuoInputEditorMathExpressionList::validate);
 
    return rowLayout;
}
 
void VuoInputEditorMathExpressionList::tearDownRow(QLayout *rowLayout)
{
    errorSymbols.remove(rowLayout);
}
 
json_object * VuoInputEditorMathExpressionList::getAcceptedValue(void)
{
    if (! isMathExpressionListValid())
        return originalValue;  // ... in case the user closed the input editor by clicking away from it.
 
    return VuoInputEditorWithLineEditList::getAcceptedValue();
}
 
QList<QString> VuoInputEditorMathExpressionList::convertToLineEditListFormat(json_object *value)
{
    QList<QString> lineEditTexts;
 
    VuoMathExpressionList expressionList = VuoMathExpressionList_makeFromJson(value);
    unsigned long expressionCount = VuoListGetCount_VuoText(expressionList.expressions);
    for (unsigned long i = 1; i <= expressionCount; ++i)
    {
        VuoText expression = VuoListGetValue_VuoText(expressionList.expressions, i);
        QString expressionString = convertToUserLocale(expression);
        lineEditTexts.append(expressionString);
    }
 
    return lineEditTexts;
}
 
json_object * VuoInputEditorMathExpressionList::convertFromLineEditListFormat(const QList<QString> &lineEditTexts)
{
    VuoList_VuoText expressions = getExpressionsFromLineEditTexts(lineEditTexts);
 
    VuoMathExpressionList expressionList = VuoMathExpressionList_make(expressions);
    json_object *value = VuoMathExpressionList_getJson(expressionList);
 
    VuoMathExpressionList_retain(expressionList);
    VuoMathExpressionList_release(expressionList);
 
    return value;
}
 
VuoList_VuoText VuoInputEditorMathExpressionList::getExpressionsFromLineEditTexts(const QList<QString> &lineEditTexts)
{
    VuoList_VuoText expressions = VuoListCreate_VuoText();
 
    foreach (QString lineEditText, lineEditTexts)
    {
        if (! lineEditText.isEmpty())
        {
            QString expressionString = convertFromUserLocale(lineEditText);
            VuoText expression = VuoText_make(expressionString.toUtf8().constData());
            VuoListAppendValue_VuoText(expressions, expression);
        }
    }
 
    return expressions;
}
 
QString VuoInputEditorMathExpressionList::convertToUserLocale(QString valueInStandardLocale)
{
    return valueInStandardLocale
            .replace(',', getListSeparatorInUserLocale())
            .replace('.', getDecimalPointInUserLocale());
}
 
QString VuoInputEditorMathExpressionList::convertFromUserLocale(QString valueInUserLocale)
{
    return valueInUserLocale
            .replace(getDecimalPointInUserLocale(), '.')
            .replace(getListSeparatorInUserLocale(), ',');
}
 
QChar VuoInputEditorMathExpressionList::getDecimalPointInUserLocale(void)
{
    return QLocale().decimalPoint();
}
 
QChar VuoInputEditorMathExpressionList::getListSeparatorInUserLocale(void)
{
    return getDecimalPointInUserLocale() == '.' ? ',' : ';';
}
 
void VuoInputEditorMathExpressionList::validate()
{
    validateMathExpressionList(false);
}
 
void VuoInputEditorMathExpressionList::validateMathExpressionList(bool shouldCheckForAtLeastOneExpression)
{
    QString errorMessageString;
    VuoList_VuoInteger errorExpressions = NULL;
 
    QList<QString> lineEditTexts = getLineEditTexts();
    VuoList_VuoText expressions = getExpressionsFromLineEditTexts(lineEditTexts);
    bool hasNoExpressions = (VuoListGetCount_VuoText(expressions) == 0);
 
    if (hasNoExpressions)
    {
        if (shouldCheckForAtLeastOneExpression)
            errorMessageString = "There must be at least one math expression.";
    }
    else
    {
        VuoMathExpressionError error = NULL;
        VuoMathExpressionParser_makeFromMultipleExpressions(expressions, &error);
        hasError = (error != NULL);
 
        if (error)
        {
            errorMessageString = VuoMathExpressionError_getMessage(error);
            errorExpressions = VuoMathExpressionError_getExpressionIndices(error);
            VuoMathExpressionError_free(error);
        }
    }
 
    VuoRetain(expressions);
    VuoRelease(expressions);
 
    if (errorMessage)
    {
        removeWidgetFromDialog(errorMessage);
        delete errorMessage;
        errorMessage = NULL;
    }
 
    foreach (QLabel *errorSymbol, errorSymbols.values())
        errorSymbol->setVisible(false);
 
    if (! errorMessageString.isEmpty())
    {
        errorMessage = new QLabel(errorMessageString);
        errorMessage->setWordWrap(true);
        addWidgetToDialog(errorMessage);
 
        if (errorExpressions)
        {
            unsigned long count = VuoListGetCount_VuoInteger(errorExpressions);
            for (unsigned long i = 1; i <= count; ++i)
            {
                int indexIgnoringEmptyStrings = VuoListGetValue_VuoInteger(errorExpressions, i) - 1;
 
                int index;
                int nonEmptyStringIndex = 0;
                for (index = 0; index < lineEditTexts.size(); ++index)
                    if (! lineEditTexts.at(index).isEmpty())
                        if (nonEmptyStringIndex++ == indexIgnoringEmptyStrings)
                            break;
 
                QLayout *rowLayout = getRowAtIndex(index);
                QLabel *errorSymbol = errorSymbols.value(rowLayout);
                errorSymbol->setVisible(true);
            }
 
            VuoRetain(errorExpressions);
            VuoRelease(errorExpressions);
        }
    }
}
 
bool VuoInputEditorMathExpressionList::isMathExpressionListValid(void)
{
    VuoList_VuoText expressions = getExpressionsFromLineEditTexts( getLineEditTexts() );
    bool hasNoExpressions = (VuoListGetCount_VuoText(expressions) == 0);
    VuoRetain(expressions);
    VuoRelease(expressions);
    return ! hasError && ! hasNoExpressions;
}
 
bool VuoInputEditorMathExpressionList::eventFilter(QObject *o, QEvent *event)
{
    if (event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return)
        {
            validateMathExpressionList(true);
            if (! isMathExpressionListValid())
                return true;
        }
    }
 
    return VuoInputEditorWithLineEditList::eventFilter(o, event);
}