//----------------------------------------------------------------------------
bool XmlConfig::setParameter( const std::string& key,
const std::string& val,
const std::string& type )
{
if( !_config )
return false;
std::cout << "setParameter(key = " << key
<< ", val = " << val
<< ", type = " << type
<< ")"
<< std::endl;
//resolve parts of identifier (Renderer:FeatureX) and find in config
std::string valname;
TiXmlNode* container = parseIdentifier(key, valname, true);
if( key.length() > valname.length() + 1 )
{
std::string component_name =
key.substr(0, key.length() - valname.length() - 1);
Configurable* comp = findComponent(component_name);
if( !comp )
LOG_ERROR("No such component: " << component_name);
else
comp->setParameter(valname, val, type);
}
//check if exists
TiXmlNode* node = container->FirstChild(valname);
TiXmlElement* arg = 0;
if( node )
{
arg = node->ToElement();
//check if it matches
int res = checkTypeMatch(key, arg, type);
if(res == 1)
arg->SetAttribute("type", type);
else if(res == 0)
return false;
}
else
{
//create new one
arg = new TiXmlElement( valname );
container->LinkEndChild(arg);
arg->SetAttribute("type", type);
}
arg->SetAttribute("val", val);
_dirty_write = true;
saveFile(); // TODO check if multiple variables changed within small
// time window
return true;
}
bool QtSignalForwarder::bind(QObject* sender, QEvent::Type event, const QtMetacallAdapter& callback, EventFilterFunc filter)
{
if (!checkTypeMatch(callback, QList<QByteArray>())) {
qWarning() << "Callback does not take 0 arguments";
return false;
}
setupDestroyNotify(sender);
sender->installEventFilter(this);
EventBinding binding(sender, event, callback, filter);
m_eventBindings.insertMulti(sender, binding);
return true;
}
bool QtSignalForwarder::bind(QObject* sender, const char* signal, QObject *context,
const QtMetacallAdapter& callback
)
{
int signalIndex = qtObjectSignalIndex(sender, signal);
if (signalIndex < 0) {
qWarning() << "No such signal" << signal << "for" << sender;
return false;
}
Binding binding(sender, signalIndex, context, callback);
binding.paramTypes = sender->metaObject()->method(signalIndex).parameterTypes();
if (!checkTypeMatch(callback, binding.paramTypes)) {
qWarning() << "Sender and receiver types do not match for" << signal+1;
return false;
}
if (!canAddSignalBindings()) {
qWarning() << "Limit of bindings per proxy has been reached";
return false;
}
if (m_freeSignalBindingIds.isEmpty()) {
m_freeSignalBindingIds << BINDING_METHOD_MIN_ID + m_signalBindings.count();
}
int bindingId = m_freeSignalBindingIds.takeFirst();
Q_ASSERT(!m_signalBindings.contains(bindingId));
// we use Qt::DirectConnection here, so the callback will always be invoked on the same
// thread that the signal was delivered. This ensures that we can rely on the object
// still existing in the qt_metacall() implementation. This also means that we don't
// retain any QObject* pointers in the internal maps once the destroyed(QObject*) signal
// has been emitted.
//
// If the binding's callback uses QtCallback, that will use a queued connection if the receiver
// actually lives in a different thread.
//
if (!QMetaObject::connect(sender, signalIndex, this, bindingId, Qt::DirectConnection, 0)) {
qWarning() << "Unable to connect signal" << signal << "for" << sender;
return false;
}
m_signalBindings.insert(bindingId, binding);
if (callback != s_senderDestroyedCallback) {
// listen for destroyed(QObject*) signal to remove
// all bindings. setupDestroyNotify() in turn calls bind()
// with s_senderDestroyedCallback as the callback
setupDestroyNotify(sender);
}
m_senderSignalBindingIds.insertMulti(sender, bindingId);
if (context) {
setupDestroyNotify(context);
m_contextBindingIds.insertMulti(context, bindingId);
}
return true;
}
