void Properties::setProperty( QString propertyName, const QDateTime& propertyDateTime, QVariant propertyValue )
{
//qDebug( ) << "setProperty(" << propertyName << " " << propertyDateTime.toString( ) << " " << propertyValue.toString( );
if ( !hasProperty( propertyName ) )
addProperty( propertyName, propertyValue );
if ( hasProperty( propertyName ) ) // Test is property exists or new property creation was successfull
{
TimeValueMap* timeValueMap = nullptr;
if ( !_propertiesTimeValueMap.contains( propertyName ) )
{
timeValueMap = new QMap< QDateTime, QVariant >( );
_propertiesTimeValueMap.insert( propertyName, timeValueMap );
}
else timeValueMap = _propertiesTimeValueMap.value( propertyName, nullptr );
Q_ASSERT( timeValueMap != nullptr );
timeValueMap->insert( propertyDateTime, propertyValue );
// First and last initialization
if ( !_last.isValid( ) )
_last = propertyDateTime;
if ( !_first.isValid( ) )
_first = propertyDateTime;
if ( propertyDateTime > _last ) // Update object date time interval
_last = propertyDateTime;
else if ( propertyDateTime < _first )
_first = propertyDateTime;
}
}
void Demultiplexer::dataChanged()
{
if ( hasProperty("numInput") && dataInt("numInput") != -1 )
{
int addressSize = int( std::ceil( std::log( (double)dataInt("numInput") ) / std::log(2.0) ) );
property("numInput")->setValue(-1);
if ( addressSize < 1 )
addressSize = 1;
else if ( addressSize > 8 )
addressSize = 8;
// This function will get called again when we set the value of numInput
property("addressSize")->setValue(addressSize);
return;
}
if ( hasProperty("numInput") )
{
m_variantData["numInput"]->deleteLater();
m_variantData.remove("numInput");
}
initPins( unsigned(dataInt("addressSize")) );
}
void TCPUnixAccountHandler::loadProperties()
{
UT_DEBUGMSG(("TCPUnixAccountHandler::loadProperties()\n"));
bool serve = getProperty("server") == "";
if (server_button && GTK_IS_TOGGLE_BUTTON(server_button))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(server_button), serve);
if (client_button && GTK_IS_TOGGLE_BUTTON(client_button))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(client_button), !serve);
if (server_entry && GTK_IS_ENTRY(server_entry))
gtk_entry_set_text(GTK_ENTRY(server_entry), getProperty("server").c_str());
int port = DEFAULT_TCP_PORT;
try {
if (hasProperty("port"))
port = boost::lexical_cast<int>(getProperty("port"));
} catch (boost::bad_lexical_cast &) {
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
if (port_button && GTK_IS_ENTRY(port_button))
gtk_spin_button_set_value(GTK_SPIN_BUTTON(port_button), port);
if (allow_all_button && GTK_IS_TOGGLE_BUTTON(allow_all_button))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(allow_all_button), hasProperty("allow-all") ? getProperty("allow-all") == "true" : false);
bool autoconnect = hasProperty("autoconnect") ? getProperty("autoconnect") == "true" : true;
if (autoconnect_button && GTK_IS_TOGGLE_BUTTON(autoconnect_button))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autoconnect_button), autoconnect);
}
/** Return the run start time as given by the 'start_time' or 'run_start'
* property.
* 'start_time' is tried first, falling back to 'run_start' if the former isn't
* found.
* @returns The start time of the run
* @throws std::runtime_error if neither property is defined
*/
const Kernel::DateAndTime LogManager::startTime() const {
const std::string start_prop("start_time");
if (hasProperty(start_prop)) {
try {
DateAndTime start_time(getProperty(start_prop)->value());
if (start_time != DateAndTimeHelpers::GPS_EPOCH) {
return start_time;
}
} catch (std::invalid_argument &) { /*Swallow and move on*/
}
}
const std::string run_start_prop("run_start");
if (hasProperty(run_start_prop)) {
try {
DateAndTime start_time(getProperty(run_start_prop)->value());
if (start_time != DateAndTimeHelpers::GPS_EPOCH) {
return start_time;
}
} catch (std::invalid_argument &) { /*Swallow and move on*/
}
}
throw std::runtime_error("No valid start time has been set for this run.");
}
bool Properties::duplicateTo( qps::Properties* destination ) const
{
if ( destination == nullptr )
return false;
if ( getTarget() == nullptr )
return false;
// Duplicate static properties
int staticPropertyCount = getTarget()->metaObject( )->propertyCount( );
for ( int s = 0; s < staticPropertyCount; s++ ) {
QMetaProperty metaProperty = getTarget()->metaObject( )->property( s );
const char* propertyName = metaProperty.name( );
if ( propertyName == nullptr )
continue;
if ( std::strcmp( propertyName, "target" ) == 0 ) // Do not modify destination target
continue;
QVariant srcValue = getTarget()->property( propertyName );
if ( hasProperty( propertyName ) && metaProperty.isWritable( ) )
destination->setProperty( propertyName, srcValue );
else
destination->addDynamicProperty( propertyName, srcValue );
}
// Duplicate dynamic properties
QList< QByteArray > dynamicProperties = getTarget()->dynamicPropertyNames( );
for ( int d = 0; d < dynamicProperties.size( ); d++ ) {
QString propertyName = dynamicProperties.at( d );
QVariant srcValue = getTarget()->property( propertyName.toLatin1( ) );
if ( hasProperty( propertyName ) )
destination->setProperty( propertyName, srcValue );
else
destination->addDynamicProperty( propertyName, srcValue );
}
return true;
}
// also handle an xlfd with %d for size?
static char*
makeFontOfSize(char *font, int size, char *fallback)
{
FcPattern *pattern;
char *result;
if (font[0]=='-') {
char *fname;
fname = fixXLFD(font, size);
pattern = XftXlfdParse(fname, False, False);
wfree(fname);
} else {
pattern = FcNameParse(font);
}
//FcPatternPrint(pattern);
if (size > 0) {
FcPatternDel(pattern, "pixelsize");
FcPatternAddDouble(pattern, "pixelsize", (double)size);
} else if (size==0 && !hasProperty(pattern, "size") &&
!hasProperty(pattern, "pixelsize")) {
FcPatternAddDouble(pattern, "pixelsize", (double)DEFAULT_SIZE);
}
if (fallback && !hasPropertyWithStringValue(pattern, "family", fallback)) {
FcPatternAddString(pattern, "family", fallback);
}
result = FcNameUnparse(pattern);
FcPatternDestroy(pattern);
return result;
}
void MaterialInstance::create (Platform* platform)
{
mMaterial = platform->createMaterial(mName);
if (hasProperty ("shadow_caster_material"))
mMaterial->setShadowCasterMaterial (retrieveValue<StringValue>(getProperty("shadow_caster_material"), NULL).get());
if (hasProperty ("lod_values"))
mMaterial->setLodLevels (retrieveValue<StringValue>(getProperty("lod_values"), NULL).get());
}
/*!
\internal
Return true if the format has number format.
*/
bool Format::hasNumFmtData() const
{
if (!d)
return false;
if (hasProperty(FormatPrivate::P_NumFmt_Id)
|| hasProperty(FormatPrivate::P_NumFmt_FormatCode)) {
return true;
}
return false;
}
//
// Convert javascript's json object to libsvm's svm_node
//
struct svm_node* SVMPredict::FromJsonObj(v8::Local<v8::Object> obj){
//v8::Isolate* isolate = v8::Isolate::GetCurrent();
//v8::EscapableHandleScope scope(isolate);
#if defined(PROCESS_DEBUG)
log("is called.");
#endif
struct svm_node *prob_node = nullptr;
v8::Local<v8::Value> id;
v8::Local<v8::Object> values;
bool ok;
if (hasProperty(obj,std::string("id")) &&
hasProperty(obj,std::string("values"))){
id = obj->Get(ToV8<std::string>(std::string("id")));
values = v8::Local<v8::Object>::Cast(
obj->Get(ToV8<std::string>(std::string("values"))));
if ( !values->IsObject() ){
ThrowError("Values field seem not to be json object.");
//return scope.Close(v8::Null());
return nullptr;
}
v8::Local<v8::Array> v = values->GetOwnPropertyNames();
int length = v->Length();
//#if PROCESS_DEBUG
// std::cout<< "feature length: " << length << std::endl;
//#endif
prob_node =
reinterpret_cast<svm_node*>(malloc((length+1) * sizeof(struct svm_node)));
//(struct svm_node *) malloc ((length+1) * sizeof(struct svm_node));
if (prob_node == NULL){
std::cout<<"Failed to allocate memory for svm_node"<<std::endl;
return nullptr;
}
for(int i=0; i<length; i++){
prob_node[i].index = FromV8<int32_t>(v->Get(i),&ok);
prob_node[i].value = FromV8<double>(values->Get(v->Get(i)),&ok);
//std::cout<< "index " << i <<" :" << prob_node[i].index<< ", value: " << prob_node[i].value << std::endl;
}
prob_node[length].index = -1;
struct svm_node *p = prob_node;
printf("In FromJsonObj:");
while(p->index != -1) {
printf("%d:%.8g ",p->index,p->value);
p++;
}
printf("\n");
return prob_node;
}
return nullptr;
}
bool PlyReader::requestProperty(const std::string& elementName,
const std::string& propertyName,
int dataType, int dataOffset,
int countType, int countOffset)
{
SURGSIM_ASSERT(isValid()) << "'" << m_filename << "' is an invalid .ply file";
SURGSIM_ASSERT(hasElement(elementName)) <<
"The element <" << elementName << "> has not been requested yet, you cannot access properties for it";
SURGSIM_ASSERT(hasProperty(elementName, propertyName)) <<
"The requested property <" << propertyName << "> cannot be found in element <" << elementName << ">.";
bool result = false;
bool scalar = isScalar(elementName, propertyName);
bool wantScalar = (countType == 0);
if (wantScalar && !scalar)
{
SURGSIM_FAILURE() << "Trying to access a list property as a scalar." <<
"for element <" << elementName << "> and property <" << propertyName << ">.";
}
else if (!wantScalar && scalar)
{
SURGSIM_FAILURE() << "Trying to access a scalar property as a list." <<
"for element <" << elementName << "> and property <" << propertyName << ">.";
}
if (hasProperty(elementName, propertyName) && (scalar == wantScalar))
{
auto itBegin = std::begin(m_requestedElements[elementName].requestedProperties);
auto itEnd = std::end(m_requestedElements[elementName].requestedProperties);
bool doAdd = std::find_if(itBegin, itEnd,
[propertyName](PropertyInfo p){return p.propertyName == propertyName;}) == itEnd;
if (doAdd)
{
PropertyInfo info;
info.propertyName = propertyName;
info.dataType = m_data->types[dataType];
info.dataOffset = dataOffset;
info.countType = m_data->types[countType];
info.countOffset = countOffset;
m_requestedElements[elementName].requestedProperties.push_back(info);
result = true;
}
}
return result;
}
/*!
* Turn on/off shrink to fit base on \a shink.
*/
void Format::setShrinkToFit(bool shink)
{
if (shink && hasProperty(FormatPrivate::P_Alignment_Wrap))
clearProperty(FormatPrivate::P_Alignment_Wrap);
if (shink && hasProperty(FormatPrivate::P_Alignment_AlignH)) {
HorizontalAlignment hl = horizontalAlignment();
if (hl == AlignHFill || hl == AlignHJustify || hl == AlignHDistributed)
setHorizontalAlignment(AlignLeft);
}
setProperty(FormatPrivate::P_Alignment_ShinkToFit, shink, false);
}
/**
* _getOptionArgs
*
* Returns the address of an OPTIONS struct with all supported options decoded.
* Two types of optional parameters are supported, that is, 'queryOptions' and
* 'options'.
*
* query-options :== 'queryOptions' '=' '{' (object (',' object)*))? '}'
* options :== 'options' '=' '[' (string (',' string)*)? ']'
* object :== '{' (property (',' property)*)? '}'
* property :== string ':' value
* array :== '[' (value (',' value)*)? ']'
* value :== string | number | object | array | 'true' | 'false'
* string :== '"' char* '"'
*
* Example:
*
* queryOptions={"deep":true, "ignoreCase":false}
* options=["dirsOnly", "showHiddenFiles"]
*
* @note: Strict JSON encoding rules are enforced when decoding parameters.
*
* @param pGET Address of a variable data type. (php style $_GET variable)
* @param piResult Address integer receiving the final result code:
* HTTP_V_OK, HTTP_V_BAD_REQUEST or HTTP_V_SERVER_ERROR
*
* @return On success the address of an OPTIONS struct otherwise NULL
**/
static OPTIONS * _getOptionArgs( DATA *pGET, int *piResult )
{
OPTIONS *pOptions;
DATA *ptQueryOptions,
*ptOptions;
if( (pOptions = (OPTIONS *)calloc(1, sizeof(OPTIONS))) )
{
if( hasProperty( "options", pGET ) )
{
if( (ptOptions = jsonDecode( varGetProperty("options", pGET))) )
{
pOptions->bShowHiddenFiles = varInArray("showHiddenFiles", ptOptions);
pOptions->bDebug = varInArray("debug", ptOptions);
destroy( ptOptions );
}
else // Ill formatted JSON array
{
cbtDebug( "options parameter is not a valid JSON object." );
*piResult = HTTP_V_BAD_REQUEST;
destroy( pOptions );
return NULL;
}
}
if( hasProperty( "queryOptions", pGET ) )
{
if( (ptQueryOptions = jsonDecode( varGetProperty("queryOptions", pGET))) )
{
pOptions->bIgnoreCase = (bool)varGet( varGetProperty("ignoreCase", ptQueryOptions) );
pOptions->bDeep = (bool)varGet( varGetProperty("deep", ptQueryOptions) );
destroy( ptQueryOptions );
}
else // Ill formatted JSON object
{
cbtDebug( "queryOptions parameter is not a valid JSON object." );
*piResult = HTTP_V_BAD_REQUEST;
destroy( pOptions );
return NULL;
}
}
*piResult = HTTP_V_OK; // Success
}
else // Out of memory...
{
*piResult = HTTP_V_SERVER_ERROR;
}
return pOptions;
}
/*!
* Set the horizontal alignment with the given \a align.
*/
void Format::setHorizontalAlignment(HorizontalAlignment align)
{
if (hasProperty(FormatPrivate::P_Alignment_Indent)
&&(align != AlignHGeneral && align != AlignLeft && align != AlignRight && align != AlignHDistributed)) {
clearProperty(FormatPrivate::P_Alignment_Indent);
}
if (hasProperty(FormatPrivate::P_Alignment_ShinkToFit)
&& (align == AlignHFill || align == AlignHJustify || align == AlignHDistributed)) {
clearProperty(FormatPrivate::P_Alignment_ShinkToFit);
}
setProperty(FormatPrivate::P_Alignment_AlignH, align, AlignHGeneral);
}
void Item::restoreFromItemData( const ItemData &itemData )
{
move( itemData.x, itemData.y );
if ( canResize() )
setSize( itemData.size );
Item *parentItem = p_itemDocument->itemWithID( itemData.parentId );
if (parentItem)
setParentItem(parentItem);
else
m_baseZ = itemData.z;
//BEGIN Restore data
const QStringMap::const_iterator stringEnd = itemData.dataString.end();
for ( QStringMap::const_iterator it = itemData.dataString.begin(); it != stringEnd; ++it )
{
if ( hasProperty(it.key()) )
property( it.key() )->setValue( it.value() );
}
const DoubleMap::const_iterator numberEnd = itemData.dataNumber.end();
for ( DoubleMap::const_iterator it = itemData.dataNumber.begin(); it != numberEnd; ++it )
{
if ( hasProperty(it.key()) )
property( it.key() )->setValue( it.value() );
}
const QColorMap::const_iterator colorEnd = itemData.dataColor.end();
for ( QColorMap::const_iterator it = itemData.dataColor.begin(); it != colorEnd; ++it )
{
if ( hasProperty(it.key()) )
property( it.key() )->setValue( it.value() );
}
const BoolMap::const_iterator boolEnd = itemData.dataBool.end();
for ( BoolMap::const_iterator it = itemData.dataBool.begin(); it != boolEnd; ++it )
{
if ( hasProperty(it.key()) )
property( it.key() )->setValue( QVariant( it.value() /*, 0*/ ) );
}
const QBitArrayMap::const_iterator rawEnd = itemData.dataRaw.end();
for ( QBitArrayMap::const_iterator it = itemData.dataRaw.begin(); it != rawEnd; ++it )
{
if ( hasProperty(it.key()) )
property( it.key() )->setValue( it.value() );
}
//END Restore Data
}
bool KisBrushBasedPaintOpSettings::paintIncremental()
{
if (hasProperty("PaintOpAction")) {
return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
}
return true;
}
void MaterialInstance::destroyAll ()
{
if (hasProperty("create_configuration"))
return;
mMaterial->removeAll();
mTexUnits.clear();
}
/*!
* Enable the text wrap if \a wrap is true.
*/
void Format::setTextWarp(bool wrap)
{
if (wrap && hasProperty(FormatPrivate::P_Alignment_ShinkToFit))
clearProperty(FormatPrivate::P_Alignment_ShinkToFit);
setProperty(FormatPrivate::P_Alignment_Wrap, wrap, false);
}
const std::string &Map::getName() const
{
if (hasProperty("name"))
return getProperty("name");
return getProperty("mapname");
}
void Properties::setPoint(const std::string &name, const Point &value, bool warnDuplicates) {
if (hasProperty(name) && warnDuplicates)
SLog(EWarn, "Property \"%s\" has already been specified!", name.c_str());
m_elements[name].type = EPoint;
m_elements[name].v_point = value;
m_elements[name].queried = false;
}
void Map::initializeOverlays()
{
ResourceManager *resman = ResourceManager::getInstance();
for (int i = 0;
hasProperty("overlay" + toString(i) + "image");
i++)
{
const std::string name = "overlay" + toString(i);
Image *img = resman->getImage(getProperty(name + "image"));
const float speedX = getFloatProperty(name + "scrollX");
const float speedY = getFloatProperty(name + "scrollY");
const float parallax = getFloatProperty(name + "parallax");
const bool keepRatio = getBoolProperty(name + "keepratio");
if (img)
{
mOverlays.push_back(
new AmbientOverlay(img, parallax, speedX, speedY, keepRatio));
// The AmbientOverlay takes control over the image.
img->decRef();
}
}
}
void InterfacePointerValue::put(const std::string& name, Value* value, int attributes)
{
InterfacePrototypeValue* proto = static_cast<InterfacePrototypeValue*>(prototype);
AttributeSetterValue* setter;
if (!canPut(name))
{
return;
}
if (hasProperty(name))
{
ObjectValue::put(name, value, attributes);
}
else if ((setter = static_cast<AttributeSetterValue*>(proto->getOpObject(InterfacePrototypeValue::IndexSetter)))
&& isIndexAccessor(name))
{
setter->put(this, name, value);
}
else if ((setter = static_cast<AttributeSetterValue*>(proto->getOpObject(InterfacePrototypeValue::NameSetter))))
{
setter->put(this, name, value);
}
else
{
ObjectValue::put(name, value, attributes);
}
}
void Properties::setInteger(const std::string &name, int value, bool warnDuplicates) {
if (hasProperty(name) && warnDuplicates)
SLog(EWarn, "Property \"%s\" has already been specified!", name.c_str());
m_elements[name].type = EInteger;
m_elements[name].v_long = value;
m_elements[name].queried = false;
}
/**
* \brief set a property
*/
void Properties::setProperty(const std::string& name,
const std::string& value) {
debug(LOG_DEBUG, DEBUG_LOG, 0, "adding %s -> %s",
name.c_str(), value.c_str());
properties.insert(std::make_pair(name, value));
debug(LOG_DEBUG, DEBUG_LOG, 0, "has value: %s",
hasProperty(name) ? "YES" : "NO");
}
void Event::setProperty(const string inName, const string inValue) {
if ( hasProperty(inName) ) {
mProperties.find(inName)->second = inValue;
return;
}
mProperties.insert( make_pair<string, string>(inName, inValue) );
nrProperties++;
}
TITANIUM_FUNCTION(Properties, hasProperty)
{
ENSURE_STRING_AT_INDEX(property, 0);
const auto js_context = this_object.get_context();
const auto object_ptr = GetStaticObject(js_context).GetPrivate<Properties>();
return js_context.CreateBoolean(object_ptr->hasProperty(property));
}
Spectrum Properties::getSpectrum(const std::string &name, const Spectrum &defVal) const {
if (!hasProperty(name))
return defVal;
std::map<std::string, Element>::const_iterator it = m_elements.find(name);
if ((*it).second.type != ESpectrum)
SLog(EError, "Property \"%s\" has wrong type", name.c_str());
(*it).second.queried = true;
return (*it).second.v_spectrum;
}
int Properties::getInteger(const std::string &name, int defVal) const {
if (!hasProperty(name))
return defVal;
std::map<std::string, Element>::const_iterator it = m_elements.find(name);
if ((*it).second.type != EInteger)
SLog(EError, "Property \"%s\" has wrong type", name.c_str());
(*it).second.queried = true;
return (int) (*it).second.v_long;
}
bool Properties::getBoolean(const std::string &name, bool defVal) const {
if (!hasProperty(name))
return defVal;
std::map<std::string, Element>::const_iterator it = m_elements.find(name);
if ((*it).second.type != EBoolean)
SLog(EError, "Property \"%s\" has wrong type", name.c_str());
(*it).second.queried = true;
return (*it).second.v_boolean;
}
Point Properties::getPoint(const std::string &name) const {
if (!hasProperty(name))
SLog(EError, "Property \"%s\" missing", name.c_str());
std::map<std::string, Element>::const_iterator it = m_elements.find(name);
if ((*it).second.type != EPoint)
SLog(EError, "Property \"%s\" has wrong type", name.c_str());
(*it).second.queried = true;
return (*it).second.v_point;
}
/*!
* \internal
*/
QColor Format::colorProperty(int propertyId, const QColor &defaultValue) const
{
if (!hasProperty(propertyId))
return defaultValue;
const QVariant prop = d->property[propertyId];
if (prop.userType() != qMetaTypeId<XlsxColor>())
return defaultValue;
return qvariant_cast<XlsxColor>(prop).rgbColor();
}
