void AllowedLookupsResolver::requestValueResolution( const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int> &roles )
{
Q_ASSERT( topLeft.row() == bottomRight.row() );
// We need to attempt to resolve the ownership information only if the property value was changed.
bool filterChanged = roles.size() == 0;
foreach( int role, roles )
{
if( role == PropertyValueListModel::FilterRole )
filterChanged = true;
}
if( ! filterChanged )
return; // Other than changes to the property value do not affect ownership information.
// Fetch the current value and abort resolution if the property isn't lookup.
MFiles::PropertyValue currentValue( m_model->data( topLeft, PropertyValueListModel::PropertyValueRole ).toJsonValue() );
if( currentValue.typedValue().dataType() != MFiles::Constants::MultiSelectLookup &&
currentValue.typedValue().dataType() != MFiles::Constants::SingleSelectLookup )
return;
// Fetch the allowed values using the new filter.
AsyncFetch* fetchAllowed = this->fetchAllowedItems( topLeft, currentValue.value() );
// Resolve the validity.
QObject::connect( fetchAllowed, &AsyncFetch::finished, [=]() mutable {
fetchAllowed->deleteLater();
QJsonArray values = fetchAllowed->values();
this->resolveValidity( values, topLeft, currentValue.value() );
} );
}
bool
Reader::decodeDouble( Token &token )
{
double value = 0;
const int bufferSize = 32;
int count;
int length = int(token.end_ - token.start_);
if ( length <= bufferSize )
{
Char buffer[bufferSize];
memcpy( buffer, token.start_, length );
buffer[length] = 0;
count = sscanf( buffer, "%lf", &value );
}
else
{
std::string buffer( token.start_, token.end_ );
count = sscanf( buffer.c_str(), "%lf", &value );
}
if ( count != 1 )
return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
currentValue() = value;
return true;
}
bool
Reader::readObject ()
{
Token tokenName;
std::string name;
currentValue () = Value (objectValue);
while (readToken (tokenName))
{
if (tokenName.type_ == tokenObjectEnd && name.empty ()) // empty object
return true;
if (tokenName.type_ != tokenString)
break;
name = "";
if (!decodeString (tokenName, name))
return recoverFromError (tokenObjectEnd);
Token colon;
if (!readToken (colon) || colon.type_ != tokenMemberSeparator)
{
return addErrorAndRecover ("Missing ':' after object member name",
colon,
tokenObjectEnd);
}
Value &value = currentValue ()[ name ];
nodes_.push (&value);
bool ok = readValue ();
nodes_.pop ();
if (!ok) // error already set
return recoverFromError (tokenObjectEnd);
Token comma;
if (!readToken (comma)
|| (comma.type_ != tokenObjectEnd &&
comma.type_ != tokenArraySeparator))
{
return addErrorAndRecover ("Missing ',' or '}' in object declaration",
comma,
tokenObjectEnd);
}
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover ("Missing '}' or object member name",
tokenName,
tokenObjectEnd);
}
void VariablesEditor::lvValues_selectionModel_selectionChanged()
{
const QModelIndex variableIndex = currentVariable();
const QModelIndex valueIndex = currentValue();
const int count = mModel->rowCount( variableIndex );
ui->tbValuesEdit->setEnabled( valueIndex.isValid() );
ui->tbValuesClear->setEnabled( variableIndex.isValid() && count > 0 );
}
void Worker::slotNextValue()
{
emit currentValue(--m_nValue);
if (!m_nValue)
{
//emit finished();
}
}
bool
Reader::decodeString( Token &token )
{
std::string decoded;
if ( !decodeString( token, decoded ) )
return false;
currentValue() = decoded;
return true;
}
char
CaseValue::lireValeur(void) const {
// Lire la premièrelettre de l'entrée
wxString currentValue(GetLineText(0));
std::string s(currentValue.ToStdString());
// Si la taille est nulle, retourner un point
if( s.size()==0 ) return '.';
// Sinon retourner la valeur en tant que caractère
return s.at(0);
}
void SVGAnimatedAngle::synchronizeAttribute()
{
AtomicString value;
if (m_orientType->currentValue()->enumValue() == SVGMarkerOrientAuto)
value = "auto";
else
value = AtomicString(currentValue()->valueAsString());
contextElement()->setSynchronizedLazyAttribute(attributeName(), value);
}
void SVGAnimatedAngle::synchronizeAttribute()
{
DEFINE_STATIC_LOCAL(const AtomicString, autoValue, ("auto", AtomicString::ConstructFromLiteral));
AtomicString value;
if (m_orientType->currentValue()->enumValue() == SVGMarkerOrientAuto)
value = autoValue;
else
value = AtomicString(currentValue()->valueAsString());
contextElement()->setSynchronizedLazyAttribute(attributeName(), value);
}
static JSValue getNthValueOnKeyPath(ExecState* exec, JSValue rootValue, const Vector<String>& keyPathElements, size_t index)
{
JSValue currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; i++) {
JSValue parentValue(currentValue);
if (!get(exec, parentValue, keyPathElements[i], currentValue))
return jsUndefined();
}
return currentValue;
}
bool
Reader::readArray( Token &/*tokenStart*/ )
{
currentValue() = Value( arrayValue );
skipSpaces();
if ( *current_ == ']' ) // empty array
{
Token endArray;
readToken( endArray );
return true;
}
int index = 0;
for (;;)
{
Value &value = currentValue()[ index++ ];
nodes_.push( &value );
bool ok = readValue();
nodes_.pop();
if ( !ok ) // error already set
return recoverFromError( tokenArrayEnd );
Token token;
// Accept Comment after last item in the array.
ok = readToken( token );
while ( token.type_ == tokenComment && ok )
{
ok = readToken( token );
}
bool badTokenType = ( token.type_ != tokenArraySeparator &&
token.type_ != tokenArrayEnd );
if ( !ok || badTokenType )
{
return addErrorAndRecover( "Missing ',' or ']' in array declaration",
token,
tokenArrayEnd );
}
if ( token.type_ == tokenArrayEnd )
break;
}
return true;
}
long unsigned int findOptimalAmount(short int factor2,short int factor3)
{ unsigned int n = currentValue(factor2,factor3);
if(n < 12)
{ costArray[factor2][factor3] = n;
return (long unsigned int)n;
}
else
{ if(costArray[factor2][factor3] == 0)
costArray[factor2][factor3] = (findOptimalAmount(factor2+1,factor3) + findOptimalAmount(factor2,factor3+1) + findOptimalAmount(factor2+2,factor3));
return costArray[factor2][factor3];
}
}
bool QNumberStyleAnimation::isUpdateNeeded() const
{
if (QStyleAnimation::isUpdateNeeded()) {
qreal current = currentValue();
if (!qFuzzyCompare(_prev, current))
{
_prev = current;
return true;
}
}
return false;
}
static v8::Handle<v8::Value> getNthValueOnKeyPath(v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index, v8::Isolate* isolate)
{
v8::Handle<v8::Value> currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; ++i) {
v8::Handle<v8::Value> parentValue(currentValue);
if (!get(parentValue, keyPathElements[i], currentValue, isolate))
return v8Undefined();
}
return currentValue;
}
bool
Reader::readValue ()
{
Token token;
do
readToken (token);
while (token.type_ == tokenComment);
bool successful = true;
switch (token.type_)
{
case tokenObjectBegin:
successful = readObject ();
break;
case tokenArrayBegin:
successful = readArray ();
break;
case tokenNumber:
successful = decodeNumber (token);
break;
case tokenString:
successful = decodeString (token);
break;
case tokenTrue:
currentValue () = true;
break;
case tokenFalse:
currentValue () = false;
break;
case tokenNull:
currentValue () = Value ();
break;
default:
return addError ("Syntax error: value, object or array expected.", token);
}
return successful;
}
void MyThread::slotNextValue()
{
QString str;
m_nValue--;
if (!m_nValue)
{
emit finished();
}
str = "TEST message: this is a test message without any parameters.";
emit currentValue(str);
emit currentNumValue(m_nValue);
emit pushTheButton();
}
bool
Reader::decodeNumber( Token &token )
{
bool isDouble = false;
for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
{
isDouble = isDouble
|| in( *inspect, '.', 'e', 'E', '+' )
|| ( *inspect == '-' && inspect != token.start_ );
}
if ( isDouble )
return decodeDouble( token );
Location current = token.start_;
bool isNegative = *current == '-';
if ( isNegative )
++current;
Value::UInt threshold = (isNegative ? Value::UInt(-Value::minInt)
: Value::maxUInt) / 10;
Value::UInt value = 0;
while ( current < token.end_ )
{
Char c = *current++;
if ( c < '0' || c > '9' )
return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
if ( value >= threshold )
return decodeDouble( token );
value = value * 10 + Value::UInt(c - '0');
}
if ( isNegative )
currentValue() = -Value::Int( value );
else if ( value <= Value::UInt(Value::maxInt) )
currentValue() = Value::Int( value );
else
currentValue() = value;
return true;
}
bool OnOffLightService::processRequest(uint16_t requestType, XBeeAddress from, uint8_t* payload, uint8_t payload_length) {
switch (requestType) {
case 0x0001: { //is on?
#ifdef DEBUG_ASRVS
Serial.println("Request for current status");
#endif
uint8_t value = currentValue() ? 0x01 : 0x00;
uint8_t data[] = { 0, 0, 0, 0, value };
fillResponseHeader(data, requestType);
_sender->send(from, data, 5);
return true;
}
default: return false;
}
}
bool ScriptNode::makeDatum(std::string n, PyTypeObject* type,
std::string value, bool output)
{
for (auto a : script.active)
if (a->name == n)
return false;
// If there's an existing datum and it's of the wrong type, delete it.
auto d = getDatum(n);
if (d != NULL && (d->type != type))
{
datums.remove_if([&](const std::unique_ptr<Datum>& d_)
{ return d_.get() == d; });
d = NULL;
}
if (d == NULL)
{
d = new Datum(n, value, type, this);
assert(d->isValid());
}
else
{
// Move the existing datum to the end of the list
// (so that ordering matches ordering in the script)
for (auto itr = datums.begin(); itr != datums.end(); ++itr)
if (itr->get() == d)
{
datums.splice(datums.end(), datums, itr);
break;
}
// If the datum is an output, update its expression
if (output)
d->setText(value);
// Otherwise, erase the output sigil by setting the text
else if (d->isOutput())
d->setText(value);
}
script.active.insert(d);
// Inject this variable into the script's namespace
script.inject(n.c_str(), d->currentValue());
saveLookup(n, &script);
return true;
}
static bool canInjectNthValueOnKeyPath(ExecState* exec, JSValue rootValue, const Vector<String>& keyPathElements, size_t index)
{
if (!rootValue.isObject())
return false;
JSValue currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; ++i) {
JSValue parentValue(currentValue);
const String& keyPathElement = keyPathElements[i];
if (!get(exec, parentValue, keyPathElement, currentValue))
return canSet(parentValue, keyPathElement);
}
return true;
}
static bool canInjectNthValueOnKeyPath(v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index, v8::Isolate* isolate)
{
if (!rootValue->IsObject())
return false;
v8::Handle<v8::Value> currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; ++i) {
v8::Handle<v8::Value> parentValue(currentValue);
const String& keyPathElement = keyPathElements[i];
if (!get(parentValue, keyPathElement, currentValue, isolate))
return canSet(parentValue, keyPathElement);
}
return true;
}
bool Beats::detected()
{
bool beatDetected = false;
if ( currentValue() > midPoint()
&& lastValue() < midPoint()
&& currentDerivative() > derivativeMidPoint()
&& currentDerivative() > derivativeLimit
&& beatCanTrigger())
{
beatDetected = true;
iterationCounter = 1;
}
return beatDetected;
}
static JSValue ensureNthValueOnKeyPath(ExecState* exec, JSValue rootValue, const Vector<String>& keyPathElements, size_t index)
{
JSValue currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; i++) {
JSValue parentValue(currentValue);
const String& keyPathElement = keyPathElements[i];
if (!get(exec, parentValue, keyPathElement, currentValue)) {
JSObject* object = constructEmptyObject(exec);
if (!set(exec, parentValue, keyPathElement, JSValue(object)))
return jsUndefined();
currentValue = JSValue(object);
}
}
return currentValue;
}
static v8::Handle<v8::Value> ensureNthValueOnKeyPath(v8::Handle<v8::Value>& rootValue, const Vector<String>& keyPathElements, size_t index, v8::Isolate* isolate)
{
v8::Handle<v8::Value> currentValue(rootValue);
ASSERT(index <= keyPathElements.size());
for (size_t i = 0; i < index; ++i) {
v8::Handle<v8::Value> parentValue(currentValue);
const String& keyPathElement = keyPathElements[i];
if (!get(parentValue, keyPathElement, currentValue, isolate)) {
v8::Handle<v8::Object> object = v8::Object::New();
if (!set(parentValue, keyPathElement, object, isolate))
return v8Undefined();
currentValue = object;
}
}
return currentValue;
}
void AlDatabase::read()
{
for (;;) {
const char *key = currentKey();
if (strcmp(key, "begin")==0) {
const char *value = currentValue();
if (strcmp(value, "MemoryMap")==0) {
gMemoryMap.readBlock(*this);
} else {
printErrValue();
}
} else {
printErrKey();
}
if (!readNext())
return;
}
}
void VariablesEditor::on_tbValuesEdit_triggered( QAction* action )
{
const QModelIndex variableIndex = currentVariable();
const QModelIndex valueIndex = currentValue();
if ( !variableIndex.isValid() || !valueIndex.isValid() ) {
return;
}
const QString title = tr( "Edit a value..." );
bool ok = true;
QString value = valueIndex.data( Qt::DisplayRole ).toString();
if ( action == aValuesEditValue ) {
value = QInputDialog::getText( QApplication::activeWindow(), title, tr( "Edit the value :" ), QLineEdit::Normal, value, &ok );
if ( !ok ) {
value.clear();
}
}
else {
value = mProject->filePath( value );
if ( action == aValuesEditFile ) {
value = QFileDialog::getOpenFileName( QApplication::activeWindow(), tr( "Choose a file" ), value );
}
else if ( action == aValuesEditPath ) {
value = QFileDialog::getExistingDirectory( QApplication::activeWindow(), tr( "Choose a path" ), value );
}
if ( !value.isEmpty() ) {
value = mProject->relativeFilePath( value );
}
}
if ( value.isEmpty() || !ok ) {
return;
}
if ( !mModel->setData( valueIndex, value, Qt::DisplayRole ) ) {
QMessageBox::information( QApplication::activeWindow(), tr( "Information..." ), tr( "This value already exists." ) );
}
}
int ProgressStatus::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = app(); break;
case 1: *reinterpret_cast< int*>(_v) = currentValue(); break;
case 2: *reinterpret_cast< int*>(_v) = endValue(); break;
case 3: *reinterpret_cast< QString*>(_v) = error(); break;
case 4: *reinterpret_cast< QString*>(_v) = item(); break;
case 5: *reinterpret_cast< QString*>(_v) = operation(); break;
case 6: *reinterpret_cast< QString*>(_v) = units(); break;
}
_id -= 7;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 7;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 7;
}
#endif // QT_NO_PROPERTIES
return _id;
}
char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type,
DataArrayList **dataArrayList ) {
if ( ddl_nullptr == dataArrayList ) {
return in;
}
*dataArrayList = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
return in;
}
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
++in;
Value *currentValue( ddl_nullptr );
Reference *refs( ddl_nullptr );
DataArrayList *prev( ddl_nullptr ), *currentDataList( ddl_nullptr );
do {
size_t numRefs( 0 ), numValues( 0 );
currentValue = ddl_nullptr;
in = parseDataList( in, end, type, ¤tValue, numValues, &refs, numRefs );
if( ddl_nullptr != currentValue || 0 != numRefs ) {
if( ddl_nullptr == prev ) {
*dataArrayList = createDataArrayList( currentValue, numValues, refs, numRefs );
prev = *dataArrayList;
} else {
currentDataList = createDataArrayList( currentValue, numValues, refs, numRefs );
if( ddl_nullptr != prev ) {
prev->m_next = currentDataList;
prev = currentDataList;
}
}
}
} while( Grammar::CommaSeparator[ 0 ] == *in && in != end );
in = lookForNextToken( in, end );
++in;
}
return in;
}
bool
Reader::decodeDouble( Token &token )
{
double value = 0;
const int bufferSize = 32;
int count;
int length = int(token.end_ - token.start_);
// Sanity check to avoid buffer overflow exploits.
if (length < 0) {
return addError( "Unable to parse token length", token );
}
// Avoid using a string constant for the format control string given to
// sscanf, as this can cause hard to debug crashes on OS X. See here for more
// info:
//
// http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
char format[] = "%lf";
if ( length <= bufferSize )
{
Char buffer[bufferSize+1];
memcpy( buffer, token.start_, length );
buffer[length] = 0;
count = sscanf( buffer, format, &value );
}
else
{
std::string buffer( token.start_, token.end_ );
count = sscanf( buffer.c_str(), format, &value );
}
if ( count != 1 )
return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
currentValue() = value;
return true;
}
Buddy SelectBuddyComboBox::currentBuddy()
{
return currentValue();
}
