ChEXPORT EshOpt::Value& EshOpt::getProperty(PID in_pid, PType in_type) const
{
ChLOG_DEBUG_START_FN;
ChASSERT(isPropertySet(in_pid));
ChASSERT(getPropertyType(in_pid) == in_type);
return (const_cast<EshOpt*>(this))->m_data[in_pid];
}
void FlyCamera::setProperty(CameraManager::CameraProperty* p)
{
if(p->getType() == CameraManager::AUTOTRIGGER)
{
TriggerMode triggerMode;
cam->GetTriggerMode(&triggerMode);
triggerMode.onOff = !p->getAuto();
triggerMode.mode = 0;
triggerMode.parameter = 0;
triggerMode.source = 0;
cam->SetTriggerMode(&triggerMode);
}else
{
Error error;
Property prop;
prop.type = getPropertyType(p);
qDebug() << "setProp" << p->getName().c_str() << p->getAuto();
error = cam->GetProperty(&prop);
if (error == PGRERROR_OK)
{
prop.autoManualMode = p->getAuto();
prop.absValue = p->getValue();
prop.valueA = (int) p->getValue();
prop.valueB = (int) p->getValue();
cam->SetProperty(&prop);
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Properties::load(istream& in)
{
setDefaults();
// Loop reading properties
string key, value;
for(;;)
{
// Get the key associated with this property
key = readQuotedString(in);
// Make sure the stream is still okay
if(!in)
return;
// A null key signifies the end of the property list
if(key == "")
break;
// Get the value associated with this property
value = readQuotedString(in);
// Make sure the stream is still okay
if(!in)
return;
// Set the property
PropertyType type = getPropertyType(key);
set(type, value);
}
}
/** Utility function for creating and inserting layer properties
@param layer Spacescape layer
@param insertAfter Property to insert after
@param minimize Minimize this layer
@return The created / inserted property
*/
QtProperty* QtSpacescapeMainWindow::insertLayerProperties(Ogre::SpacescapeLayer* layer, QtProperty *insertAfter, bool minimize)
{
// turn refreshing flag on so we don't process valueChanged events
mRefreshing = true;
// get layer params
Ogre::NameValuePairList params = layer->getParams();
// create the layer properties object
QtProperty *layerProperties = mPropertyManager->addProperty(
QtVariantPropertyManager::groupTypeId(),
QLatin1String(layer->getName().c_str())
);
// insert it into the property tree early so we can minize items inside
ui->layerProperties->insertProperty(layerProperties, insertAfter);
// minimize the layer - speeds things up!
if(minimize) {
ui->layerProperties->setExpanded(ui->layerProperties->topLevelItem(layerProperties), false);
}
// add the common layer params to the subproperties first
layerProperties->addSubProperty(createProperty( "name", layer->getName()));
layerProperties->addSubProperty(createProperty( "type", layer->getLayerTypeName()));
layerProperties->addSubProperty(createProperty( "visible", "true"));
layerProperties->addSubProperty(createProperty( "seed", params["seed"]));
// now add all the remaining layer params to the subproperties
Ogre::NameValuePairList::iterator pl;
for(pl = params.begin(); pl != params.end(); pl++) {
// skip common params that come first
if(pl->first == "name" || pl->first == "type" ||
pl->first == "visible" || pl->first == "seed") {
continue;
}
// create the sub property
QtVariantProperty* subProperty = createProperty(pl->first, pl->second);
if(!subProperty) {
continue;
}
// add this sub property parameter
layerProperties->addSubProperty(subProperty);
// special auto hide for color types
if(getPropertyType(pl->first) == QVariant::Color) {
QList<QtBrowserItem *> bi = ui->layerProperties->items(subProperty);
ui->layerProperties->setExpanded(bi.first(),false);
}
}
// done adding properties
mRefreshing = false;
return layerProperties;
}
void cMenu::handleButton( pClient ps, cClientPacket* pkg )
{
cPacketMenuSelection* p = (cPacketMenuSelection*)pkg;
pChar pc = ps->currChar();
if ( ! pc ) return;
uint32_t button = p->buttonId.get();
this->switchs = &p->switchs;
this->textResp = &p->text_entries;
uint32_t buttonReturnCode;
if( button!=MENU_CLOSE ) {
buttonReturnCode = getButton( button );
map< uint32_t, FUNCIDX >::iterator iter( buttonCallbacks.find( button ) );
if( iter!=buttonCallbacks.end() ) {
AmxFunction func( iter->second );
func.Call( serial, pc->getSerial(), buttonReturnCode );
return;
}
}
else {
buttonReturnCode = 0;
}
//set property if there are
if( ( buttonReturnCode!=MENU_CLOSE ) && ( buttonReturnCode==buffer[3] ) ) {
map< uint32_t, int32_t >::iterator propIter( editProps.begin() ), lastProp( editProps.end() );
for( ; propIter!=lastProp; ++propIter ) {
int32_t props = propIter->first;
int prop, prop2, prop3;
getPropsFromInt( props, prop, prop2, prop3 );
if( getPropertyType( prop )!=T_BOOL ) {
unistring* data = getText( propIter->second, true );
if( data!=NULL )
setPropertyField( buffer[0], buffer[1], prop, prop2, prop3, *data );
}
else {
setPropertyField( buffer[0], buffer[1], prop, prop2, prop3, getCheckBox( propIter->second, true ) );
}
}
}
if( callback!=NULL )
callback->Call( serial, pc->getSerial(), buttonReturnCode );
else
hard( this, ps, buttonReturnCode );
}
bool GenericDataCollection::exportToCSV(CSVWriter& writer) const
{
writer.clearHeader();
for (int i=0; i<getPropertNames().size(); ++i)
{
writer.addHeader(getPropertyName(i), getPropertyTypeMeta(i));
}
writer.writeHeader();
// Export the data ordered by ID
QList<int> objKeys = m_objects.keys();
qSort(objKeys);
for (int idx=0; idx < objKeys.size(); ++idx)
{
CSVLine newLine;
GenericDataObject* obj = m_objects.value(objKeys[idx]);
for (int i=0; i<getPropertNames().size(); ++i)
{
if (obj->containsValue(getPropertyName(i)))
{
QMetaType::Type columnType = getPropertyTypeMeta(i);
bool qualified = (columnType == QMetaType::QString);
newLine.append(CSVColumn(obj->getString(getPropertyName(i)), qualified, columnType));
}
else
{
newLine.append(CSVColumn("", false, QMetaType::QString));
}
}
writer.write(newLine);
}
#if 0
QHashIterator<int, GenericDataObject*> iterator(m_objects);
while (iterator.hasNext())
{
iterator.next();
CSVLine newLine;
for (int i=0; i<getPropertNames().size(); ++i)
{
if (iterator.value()->hasValue(getPropertyName(i)))
{
QMetaType::Type columnType = CSVColumn::variantTypeToMetaType(getPropertyType(i));
bool qualified = (columnType == QMetaType::QString);
newLine.append(CSVColumn(iterator.value()->getString(getPropertyName(i)), qualified, columnType));
}
else
{
newLine.append(CSVColumn("", false, QMetaType::QString));
}
}
writer.write(newLine);
}
#endif
return true;
}
unistring cMenu::getPropertyField( uint32_t type, SERIAL obj, SERIAL prop, SERIAL subProp, SERIAL subProp2 )
{
VAR_TYPE t = getPropertyType( prop );
switch( type ) {
case PROpCharACTER: {
pChar pc = cSerializable::findCharBySerial( obj );
if ( ! pc ) return unistring();
switch( t ) {
case T_CHAR :
return toWstr( getCharCharProperty( pc, prop, subProp ) );
case T_INT:
return toWstr( getCharIntProperty( pc, prop, subProp ) );
case T_SHORT:
return toWstr( getCharShortProperty( pc, prop, subProp ) );
case T_STRING:
return toWstr( getCharStrProperty( pc, prop, subProp ) );
case T_UNICODE:
return getCharUniProperty( pc, prop, subProp );
}
}
break;
case PROpItem : {
pItem pi = cSerializable::findItemBySerial( obj );
if ( ! pi ) return unistring();
switch( t ) {
case T_CHAR :
return toWstr( getItemCharProperty( pi, prop, subProp ) );
case T_INT:
return toWstr( getItemIntProperty( pi, prop, subProp ) );
case T_SHORT:
return toWstr( getItemShortProperty( pi, prop, subProp ) );
case T_STRING:
return toWstr( getItemStrProperty( pi, prop, subProp ) );
case T_UNICODE:
return getItemUniProperty( pi, prop, subProp );
}
}
break;
case PROP_CALENDAR:
case PROP_GUILD:
default:
return unistring(L"Not implemented yet");
}
return unistring( L"Error" );
}
std::uint32_t ItemPropertiesBox::findPropertyIndex(const PropertyType type, const std::uint32_t itemId) const
{
const ItemPropertyAssociation::AssociationEntries propertyIndexVector = mAssociations.getAssociationEntries(itemId);
for (const auto& entry : propertyIndexVector)
{
const Box* property = mContainer.getProperty(entry.index - 1);
const std::string boxType = property->getType();
if (getPropertyType(property) == type)
{
return entry.index;
}
}
return 0;
}
void cMenu::addPropertyField( uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t property, uint32_t subProperty, uint32_t hue, uint32_t subProperty2 )
{
VAR_TYPE t = getPropertyType( property );
int32_t props = getIntFromProps( property, subProperty, subProperty2 );
if( t==T_BOOL )
{
addCheckbox( x, y, 0x00D2, 0x00D3, getPropertyFieldBool( buffer[0], buffer[1], property, subProperty, subProperty2 ), props );
}
else
{
addInputField( x, y, width, height, props, getPropertyField( buffer[0], buffer[1], property, subProperty, subProperty2 ), hue );
}
editProps.insert( make_pair( props, rc_serialCurrent-1 ) );
}
ItemPropertiesBox::PropertyInfos ItemPropertiesBox::getItemProperties(const std::uint32_t itemId) const
{
PropertyInfos propertyInfoVector;
const ItemPropertyAssociation::AssociationEntries associations = mAssociations.getAssociationEntries(itemId);
for (const auto& entry : associations)
{
PropertyInfo propertyInfo;
const Box* property = mContainer.getProperty(entry.index - 1);
propertyInfo.type = getPropertyType(property);
propertyInfo.index = entry.index - 1;
propertyInfo.essential = entry.essential;
propertyInfoVector.push_back(propertyInfo);
}
return propertyInfoVector;
}
void FlyCamera::updateProperty(CameraManager::CameraProperty* p)
{
if(p->getType() == CameraManager::AUTOTRIGGER)
{
TriggerMode triggerMode;
cam->GetTriggerMode(&triggerMode);
p->setAuto(triggerMode.onOff ? false:true);
}else
{
Error error;
Property prop;
prop.type = getPropertyType(p);
error = cam->GetProperty(&prop);
if (error == PGRERROR_OK)
{
p->setAuto(prop.autoManualMode);
p->setValue(p->getDecimals() > 0 ? prop.absValue : prop.valueA);
}
}
}
void EshOpt::deleteComplexPropertyValue(PID in_pid)
{
ChLOG_DEBUG_START_FN;
PType type = getPropertyType(in_pid);
if (type == PTYPE_STRING)
{
CsString* pString = m_data[in_pid].getString();
ChDELETE(pString);
m_data[in_pid].setString(NULL);
}
else if (type == PTYPE_COMPLEX)
{
EshPropVal* pComplex = m_data[in_pid].getComplex();
ChDELETE(pComplex);
m_data[in_pid].setComplex(NULL);
}
else if (type == PTYPE_NONE)
{
GenericValue* pGenericValue = m_data[in_pid].getGeneric();
ChDELETE(pGenericValue);
m_data[in_pid].setGeneric(NULL);
}
}
ChEXPORT void EshOpt::setProperty(PID in_pid, PType in_type, Value& in_value)
{
ChLOG_DEBUG_START_FN;
ChASSERT(getPropertyType(in_pid) == in_type);
m_data[in_pid] = in_value;
}
/** Utility function for creating a property from a key/value pair
@param key The key
@param value The value
@return the created QtProperty
*/
QtVariantProperty* QtSpacescapeMainWindow::createProperty(const Ogre::String& key, const Ogre::String& value)
{
QStringList noiseTypes, layerTypes, blendTypes, textureSizes;
noiseTypes << "fbm" << "ridged";
layerTypes << "points" << "billboards" << "noise";
blendTypes << "one" << "zero" << "dest_colour" << "src_colour"
<< "one_minus_dest_colour" << "one_minus_src_colour"
<< "dest_alpha" << "src_alpha" << "one_minus_dest_alpha"
<< "one_minus_src_alpha";
textureSizes << "64" << "128" << "256" << "512" << "1024" << "2048" << "4096" << "8192";
int propertyType = getPropertyType(key);
QtVariantProperty* property;
property = mPropertyManager->addProperty(propertyType, getPropertyTitle(key));
property->setStatusTip(getPropertyStatusTip(key));
property->setToolTip(getPropertyStatusTip(key));
if(propertyType == QVariant::Int) {
property->setValue(Ogre::StringConverter::parseInt(value));
property->setAttribute(QLatin1String("minimum"), 0);
property->setAttribute(QLatin1String("singleStep"), 1);
}
else if(propertyType == QVariant::Bool) {
property->setValue(Ogre::StringConverter::parseBool(value));
}
else if(propertyType == QtVariantPropertyManager::enumTypeId()) {
QStringList *enumList = NULL;
if(key == "destBlendFactor" || key == "sourceBlendFactor") {
enumList = &blendTypes;
}
else if(key == "type") {
enumList = &layerTypes;
}
else if(key == "noiseType" || key == "maskNoiseType") {
enumList = &noiseTypes;
}
else if(key == "previewTextureSize") {
enumList = &textureSizes;
}
property->setAttribute(QLatin1String("enumNames"), *enumList);
int valueIndex = 0;
// find the selected value
for(int i = 0; i < enumList->size(); i++) {
if((*enumList)[i] == QString(value.c_str())) {
valueIndex = i;
break;
}
}
property->setValue(valueIndex);
}
else if(propertyType == QVariant::Double) {
property->setValue(Ogre::StringConverter::parseReal(value));
property->setAttribute(QLatin1String("singleStep"), 0.01);
property->setAttribute(QLatin1String("decimals"), 3);
}
else if(propertyType == QVariant::Color) {
property->setValue(getColor(value));
}
else {
// assume string
property->setValue(value.c_str());
}
return property;
}
void cMenu::setPropertyField( uint32_t type, SERIAL obj, SERIAL prop, SERIAL subProp, SERIAL subProp2, unistring data )
{
VAR_TYPE t = getPropertyType( prop );
switch( type ) {
case PROpCharACTER: {
pChar pc = cSerializable::findCharBySerial( obj );
if ( ! pc ) return;
switch( t ) {
case T_CHAR : {
char value = str2num( data );
if( value!=getCharCharProperty( pc, prop, subProp ) )
setCharCharProperty( pc, prop, subProp, subProp2, value );
}
break;
case T_INT: {
int value = str2num( data );
if( value!=getCharIntProperty( pc, prop, subProp ) )
setCharIntProperty( pc, prop, subProp, subProp2, value );
}
break;
case T_SHORT: {
short value = str2num( data );
if( value!=getCharShortProperty( pc, prop, subProp ) )
setCharShortProperty( pc, prop, subProp, subProp2, value );
}
break;
case T_STRING: {
string value;
unistring2string( data, value );
if( value!=string( getCharStrProperty( pc, prop, subProp ) ) )
setCharStrProperty( pc, prop, subProp, subProp2, const_cast<char*>(value.c_str()) );
}
break;
case T_UNICODE: {
if( data!=getCharUniProperty( pc, prop, subProp ) )
setCharUniProperty( pc, prop, subProp, subProp2, data );
}
break;
}
}
break;
case PROpItem : {
pItem pi = cSerializable::findItemBySerial( obj );
if ( ! pi ) return;
switch( t ) {
case T_CHAR : {
char value = str2num( data );
if( value!=getItemCharProperty( pi, prop, subProp ) )
setItemCharProperty( pi, prop, subProp, value );
}
break;
case T_INT: {
int value = str2num( data );
if( value!=getItemIntProperty( pi, prop, subProp ) )
setItemIntProperty( pi, prop, subProp, value );
}
break;
case T_SHORT: {
short value = str2num( data );
if( value!=getItemShortProperty( pi, prop, subProp ) )
setItemShortProperty( pi, prop, subProp, value );
}
break;
case T_STRING: {
string value;
unistring2string( data, value );
if( value!=string( getItemStrProperty( pi, prop, subProp ) ) )
setItemStrProperty( pi, prop, subProp, const_cast<char*>(value.c_str()) );
}
break;
case T_UNICODE:
if( data!=getItemUniProperty( pi, prop, subProp ) )
setItemUniProperty( pi, prop, subProp, data );
break;
}
}
break;
case PROP_CALENDAR:
case PROP_GUILD:
default:
return;
}
}
