Tag * AdhocTag::generateResponse(const std::string &action) {
IQ _response(IQ::Result, m_from, m_id);
_response.setFrom(Transport::instance()->jid());
Tag *response = _response.tag();
if (action != "") {
response->addChild( new AdhocTag(findAttribute("sessionid"), findAttribute("node"), action) );
return response;
}
if (hasAttribute("action", "cancel"))
response->addChild( new AdhocTag(findAttribute("sessionid"), findAttribute("node"), "canceled") );
else
response->addChild( new AdhocTag(findAttribute("sessionid"), findAttribute("node"), "completed") );
return response;
}
void Item::setID(uint16_t newid)
{
const ItemType& prevIt = Item::items[id];
id = newid;
const ItemType& it = Item::items[newid];
uint32_t newDuration = it.decayTime * 1000;
if(newDuration == 0 && !it.stopTime && it.decayTo == -1){
removeAttribute(ATTR_ITEM_DECAYING);
removeAttribute(ATTR_ITEM_DURATION);
}
if(newDuration > 0 && (!prevIt.stopTime || !hasAttribute(ATTR_ITEM_DURATION)) ){
setDecaying(DECAYING_FALSE);
setDuration(newDuration);
}
}
PassRefPtr<FilterEffect> SVGFEColorMatrixElement::build(SVGFilterBuilder* filterBuilder)
{
FilterEffect* input1 = filterBuilder->getEffectById(in1());
if (!input1)
return 0;
Vector<float> filterValues;
SVGNumberList* numbers = values();
const ColorMatrixType filterType(static_cast<const ColorMatrixType>(type()));
// Use defaults if values is empty (SVG 1.1 15.10).
if (!hasAttribute(SVGNames::valuesAttr)) {
switch (filterType) {
case FECOLORMATRIX_TYPE_MATRIX:
for (size_t i = 0; i < 20; i++)
filterValues.append((i % 6) ? 0.0f : 1.0f);
break;
case FECOLORMATRIX_TYPE_HUEROTATE:
filterValues.append(0.0f);
break;
case FECOLORMATRIX_TYPE_SATURATE:
filterValues.append(1.0f);
break;
default:
break;
}
} else {
size_t size = numbers->numberOfItems();
for (size_t i = 0; i < size; i++) {
ExceptionCode ec = 0;
filterValues.append(numbers->getItem(i, ec));
}
size = filterValues.size();
if ((filterType == FECOLORMATRIX_TYPE_MATRIX && size != 20)
|| (filterType == FECOLORMATRIX_TYPE_HUEROTATE && size != 1)
|| (filterType == FECOLORMATRIX_TYPE_SATURATE && (size != 1
|| filterValues[0] < 0.0f || filterValues[0] > 1.0f)))
return 0;
}
return FEColorMatrix::create(input1, filterType, filterValues);
}
//---------------------------------------------------------------------
DocumentPtr SessionDeleteRequest::encode()
{
DocumentPtr ret = IMessageHelper::createDocumentWithRoot(*this);
ElementPtr root = ret->getFirstChildElement();
if (hasAttribute(AttributeType_Locations))
{
ElementPtr locationsEl = IMessageHelper::createElement("locations");
root->adoptAsLastChild(locationsEl);
for(StringList::const_iterator it = mLocations.begin(); it != mLocations.end(); ++it)
{
const String &loc = (*it);
locationsEl->adoptAsLastChild(IMessageHelper::createElementWithID("location", loc));
}
}
return ret;
}
SUMOTime
SUMOSAXAttributes::getOptSUMOTimeReporting(int attr, const char* objectid,
bool& ok, SUMOTime defaultValue, bool report) const {
if (!hasAttribute(attr)) {
return defaultValue;
}
try {
return (SUMOTime)(getFloat(attr) * 1000.);
} catch (NumberFormatException&) {
if (report) {
emitFormatError(getName(attr), "a real number", objectid);
}
} catch (EmptyData&) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return (SUMOTime) - 1;
}
int
SUMOSAXAttributes::getOptIntReporting(int attr, const char *objectid,
bool &ok, int defaultValue, bool report) const throw() {
if (!hasAttribute(attr)) {
return defaultValue;
}
try {
return getInt(attr);
} catch (NumberFormatException &) {
if (report) {
emitFormatError(getName(attr), "an int", objectid);
}
} catch (EmptyData &) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return -1;
}
SVGAnimationElement::AnimationMode SVGAnimationElement::animationMode() const
{
// http://www.w3.org/TR/2001/REC-smil-animation-20010904/#AnimFuncValues
if (hasTagName(SVGNames::setTag)) {
return ToAnimation;
}
if (!animationPath().isEmpty()) {
return PathAnimation;
}
if (hasAttribute(SVGNames::valuesAttr)) {
return ValuesAnimation;
}
if (!toValue().isEmpty()) {
return fromValue().isEmpty() ? ToAnimation : FromToAnimation;
}
if (!byValue().isEmpty()) {
return fromValue().isEmpty() ? ByAnimation : FromByAnimation;
}
return NoAnimation;
}
bool
SUMOSAXAttributes::getOptBoolReporting(int attr, const char *objectid,
bool &ok, bool defaultValue, bool report) const throw() {
if (!hasAttribute(attr)) {
return defaultValue;
}
try {
return getBool(attr);
} catch (BoolFormatException &) {
if (report) {
emitFormatError(getName(attr), "a boolean", objectid);
}
} catch (EmptyData &) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return false;
}
PassRefPtr<FilterEffect> SVGFEColorMatrixElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
{
FilterEffect* input1 = filterBuilder->getEffectById(in1());
if (!input1)
return 0;
Vector<float> filterValues;
const ColorMatrixType filterType(static_cast<ColorMatrixType>(type()));
// Use defaults if values is empty (SVG 1.1 15.10).
if (!hasAttribute(SVGNames::valuesAttr)) {
switch (filterType) {
case FECOLORMATRIX_TYPE_MATRIX:
for (size_t i = 0; i < 20; i++)
filterValues.append((i % 6) ? 0.0f : 1.0f);
break;
case FECOLORMATRIX_TYPE_HUEROTATE:
filterValues.append(0.0f);
break;
case FECOLORMATRIX_TYPE_SATURATE:
filterValues.append(1.0f);
break;
default:
break;
}
} else {
filterValues = values();
unsigned size = filterValues.size();
if ((filterType == FECOLORMATRIX_TYPE_MATRIX && size != 20)
|| (filterType == FECOLORMATRIX_TYPE_HUEROTATE && size != 1)
|| (filterType == FECOLORMATRIX_TYPE_SATURATE && (size != 1
|| filterValues[0] < 0.0f || filterValues[0] > 1.0f)))
return 0;
}
RefPtr<FilterEffect> effect = FEColorMatrix::create(filter, filterType, filterValues);
effect->inputEffects().append(input1);
return effect.release();
}
//
// Called to initialize a newly added node to the environment (not just read from the environment)
void EnvironmentNode::initialize()
{
//
// Add missing attributes
addMissingAttributesFromConfig();
//
// If we are a component and there is a buildSet attribute, set the value to the configItem's type
if (!(m_pSchemaItem->getProperty("itemType").empty()) && hasAttribute("buildSet"))
{
Status status;
setAttributeValue("buildSet", m_pSchemaItem->getProperty("itemType"), status);
}
//
// Initilize each attribute
for (auto attrIt = m_attributes.begin(); attrIt != m_attributes.end(); ++attrIt)
{
attrIt->second->initialize();
}
}
void Parser::sGesture() {
if (m_reader.isEndElement() && m_reader.name() == "gesture") {
state.removeLast();
return;
} else if (m_reader.isStartElement() && m_reader.name() == "action") {
state.append("ACTION");
auto attrs = m_reader.attributes();
if (!attrs.hasAttribute("type"))
throw(err("Attribute 'type' expected."));
Group *g = Memory::getGroup(appKey);
g->addGest(ges->num, Lists::gT(ges->type), Lists::gD(ges->direction));
Gesture *gest = g->getGest(ges->num, Lists::gT(ges->type), Lists::gD(ges->direction));
gest->setAction(Lists::aT(attrs.value("type").toString()));
//sAction(g->getGest(ges->num, Lists::gT(ges->type), Lists::gD(ges->direction))->getAction());->setAction(Lists::aT(attrs.value("type").toString()))
QStringList params = m_reader.readElementText().split(":");
foreach(const QString &p, params)
gest->getAction()->addParam(p.section("=",0,0),p.section("=",1));
state.removeLast();
} else
void XmlSettingsDialog::UpdateXml (bool whole)
{
const auto& nodes = Document_->elementsByTagName ("item");
if (whole)
for (int i = 0; i < nodes.size (); ++i)
{
auto elem = nodes.at (i).toElement ();
if (!elem.hasAttribute ("property"))
continue;
const auto& name = elem.attribute ("property");
const auto& value = WorkingObject_->property (name.toLatin1 ().constData ());
UpdateSingle (name, value, elem);
}
else
for (const auto& pair : Util::Stlize (HandlersManager_->GetNewValues ()))
{
QDomElement element;
const auto& name = pair.first;
for (int j = 0, size = nodes.size (); j < size; ++j)
{
const auto& e = nodes.at (j).toElement ();
if (e.isNull ())
continue;
if (e.attribute ("property") == name)
{
element = e;
break;
}
}
if (element.isNull ())
{
qWarning () << Q_FUNC_INFO << "element for property" << name << "not found";
return;
}
UpdateSingle (name, pair.second, element);
}
}
AffineTransform SVGSVGElement::localCoordinateSpaceTransform(SVGLocatable::CTMScope mode) const
{
AffineTransform viewBoxTransform;
if (hasAttribute(SVGNames::viewBoxAttr)) {
FloatSize size = currentViewportSize();
viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
}
AffineTransform transform;
if (!isOutermostSVGSVGElement()) {
SVGLengthContext lengthContext(this);
transform.translate(x().value(lengthContext), y().value(lengthContext));
} else if (mode == SVGLocatable::ScreenScope) {
if (RenderObject* renderer = this->renderer()) {
FloatPoint location;
// At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
// to map an element from SVG viewport coordinates to CSS box coordinates.
// RenderSVGRoot's localToAbsolute method expects CSS box coordinates.
if (renderer->isSVGRoot())
location = toRenderSVGRoot(renderer)->localToBorderBoxTransform().mapPoint(location);
// Translate in our CSS parent coordinate space
// FIXME: This doesn't work correctly with CSS transforms.
location = renderer->localToAbsolute(location, false, true);
// Be careful here! localToBorderBoxTransform() included the x/y offset coming from the viewBoxToViewTransform(),
// so we have to subtract it here (original cause of bug #27183)
transform.translate(location.x() - viewBoxTransform.e(), location.y() - viewBoxTransform.f());
// Respect scroll offset.
if (FrameView* view = document()->view()) {
LayoutSize scrollOffset = view->scrollOffset();
transform.translate(-scrollOffset.width(), -scrollOffset.height());
}
}
}
return transform.multiply(viewBoxTransform);
}
void Object::setAttributeIncDB(BString key,std::string value)
{
if(!hasAttribute(key))
{
addAttributeIncDB(key,value);
}
AttributeMap::iterator it = mAttributeMap.find(key.getCrc());
if(it == mAttributeMap.end())
{
DLOG(INFO) << "Object::setAttribute: could not find " << key.getAnsi();
return;
}
(*it).second = value;
uint32 attributeID = gWorldManager->getAttributeId(key.getCrc());
if(!attributeID)
{
DLOG(INFO) << "Object::addAttribute DB: no such attribute in the attribute table :" << key.getAnsi();
return;
}
int8 sql[512],*sqlPointer,restStr[128];
// int8 sql[1024]
sprintf(sql,"UPDATE item_attributes SET value='");
sqlPointer = sql + strlen(sql);
sqlPointer += gWorldManager->getDatabase()->escapeString(sqlPointer,value.c_str(),value.length());
sprintf(restStr,"'WHERE item_id=%"PRIu64" AND attribute_id=%u",this->getId(),attributeID);
strcat(sql,restStr);
//sprintf(sql,"UPDATE item_attributes SET value='%s' WHERE item_id=%"PRIu64" AND attribute_id=%u",value,this->getId(),attributeID);
gWorldManager->getDatabase()->executeSqlAsync(0,0,sql);
}
SUMOTime
SUMOSAXAttributes::getSUMOTimeReporting(int attr, const char* objectid,
bool& ok, bool report) const {
if (!hasAttribute(attr)) {
if (report) {
emitUngivenError(getName(attr), objectid);
}
ok = false;
return -1;
}
try {
return TIME2STEPS(getFloat(attr));
} catch (NumberFormatException&) {
if (report) {
emitFormatError(getName(attr), "a time value", objectid);
}
} catch (EmptyData&) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return (SUMOTime) - 1;
}
SUMOTime
SUMOSAXAttributes::getOptSUMOTimeReporting(int attr, const char *objectid,
bool &ok, SUMOTime defaultValue, bool report) const throw() {
#ifdef HAVE_SUBSECOND_TIMESTEPS
if (!hasAttribute(attr)) {
return defaultValue;
}
try {
return (SUMOTime)(getFloat(attr)*1000.);
} catch (NumberFormatException &) {
if (report) {
emitFormatError(getName(attr), "a real number", objectid);
}
} catch (EmptyData &) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return (SUMOTime) -1;
#else
return getOptIntReporting(attr, objectid, ok, defaultValue, report);
#endif
}
std::string
SUMOSAXAttributes::getStringReporting(int attr, const char *objectid,
bool &ok, bool report) const throw() {
if (!hasAttribute(attr)) {
if (report) {
emitUngivenError(getName(attr), objectid);
}
ok = false;
return "";
}
try {
std::string ret = getString(attr);
if (ret=="") {
throw EmptyData();
}
return ret;
} catch (EmptyData &) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return "";
}
SUMOReal
SUMOSAXAttributes::getSUMORealReporting(int attr, const char *objectid,
bool &ok, bool report) const throw() {
if (!hasAttribute(attr)) {
if (report) {
emitUngivenError(getName(attr), objectid);
}
ok = false;
return -1;
}
try {
return getFloat(attr);
} catch (NumberFormatException &) {
if (report) {
emitFormatError(getName(attr), "a real number", objectid);
}
} catch (EmptyData &) {
if (report) {
emitEmptyError(getName(attr), objectid);
}
}
ok = false;
return (SUMOReal) -1;
}
void ParametricAd::checkInputSandbox(std::vector<std::string>& extracted){
GLITE_STACK_TRY("ParametricAd::checkInputSandbox(std::vector<std::string>&)");
// This vector contains all ISB string extracted Values
unsigned int iter_i = extracted.size();
// This Vector will replace the old InputSanbox with the extracted values
vector<ExprTree*> isVect ;
ExprTree* isbTree = Lookup (JDL::INPUTSB);
if (!isbTree){ /* No inputFiles found: return */ return; }
// These variables are needed when extracting
const string wmpURI = (hasAttribute(JDL::WMPISB_BASE_URI))? (getString(JDL::WMPISB_BASE_URI)):"";
const string isbURI= (hasAttribute(JDL::ISB_BASE_URI)) ? (getString(JDL::ISB_BASE_URI) ):"";
Value val ;
string isb ;
EvaluateExpr(isbTree,val);
inputRemotes.clear();
switch ( val.GetType() ){
case Value::UNDEFINED_VALUE:
inputRemotes.push_back(isbTree->Copy());
isVect.push_back(isbTree->Copy());
break;
case Value::STRING_VALUE:
val.IsStringValue(isb);
toBretrieved=extractFiles (JDL::INPUTSB, isb, extracted,
lookInto_b,wmpURI,isbURI,extractedAd.get()) || toBretrieved;
// put the extracted files back into the InputSandbox attribute
for(;iter_i<extracted.size();iter_i++){ // Iterate ONLY over new value(s)
val.SetStringValue(extracted[iter_i]); // create classad Value
isVect.push_back(Literal::MakeLiteral(val)); // Update ISB value
}
break;
case Value::LIST_VALUE:{
const ExprList *el;
val.IsListValue( el );
vector<ExprTree*> vectList ;
el->GetComponents(vectList) ;
for ( unsigned int i = 0; i< vectList.size() ; i++){
if (vectList[i]->GetKind()!=ExprTree::LITERAL_NODE){
// not a literal node
inputRemotes.push_back( vectList[i]->Copy() );
isVect.push_back(vectList[i]->Copy());
}
else if (vectList[i]->Evaluate(val)){
switch (val.GetType()){
case Value::STRING_VALUE:
val.IsStringValue(isb);
toBretrieved=extractFiles (JDL::INPUTSB, isb, extracted,
lookInto_b,wmpURI,isbURI,extractedAd.get()) || toBretrieved;
// put the extracted files back into the InputSandbox attribute
for(;iter_i<extracted.size();iter_i++){ // Iterate ONLY over new value(s)
val.SetStringValue(extracted[iter_i]); // create classad Value
isVect.push_back(Literal::MakeLiteral(val)); // Update ISB value
}
break;
case Value::UNDEFINED_VALUE:
// It's an Expression evaluated
inputRemotes.push_back( vectList[i]->Copy() );
isVect.push_back(vectList[i]->Copy());
break;
default:
throw AdMismatchException (__FILE__,__LINE__,
METHOD,WMS_JDLMISMATCH , JDL::INPUTSB );
}
}else{
// It's an Expression not evaluated, leave it unchanged
inputRemotes.push_back( vectList[i]->Copy() );
isVect.push_back(vectList[i]->Copy());
}
val.Clear() ;
}
}
break;
default:
throw AdMismatchException (__FILE__ , __LINE__ ,METHOD, WMS_JDLMISMATCH , JDL::INPUTSB );
break;
}
classad:ExprTree* tmp_expr = ExprList::MakeExprList(isVect);
Insert (JDL::INPUTSB , tmp_expr) ;
GLITE_STACK_JDL_CATCH_ALL() ; //Exiting from method: remove line from stack trace
}
bool isDirty()
{
return (!m_drawn || transform()) && !hasAttribute(ATTRIB_DELETED);
}
bool ZoneProcessor::processNode(const TiXmlElement* zonesElem, const Ogre::String& resourceGroup, bool loadGameObjects)
{
if (zonesElem == NULL)
{
return false; // no zones
}
for (const TiXmlNode* cur = zonesElem->FirstChild(); cur != NULL; cur = cur->NextSibling())
{
if (cur->Type() == TiXmlNode::ELEMENT
&& hasNodeName(cur, "zone"))
{
const TiXmlElement* curZoneElem = cur->ToElement();
if (hasAttribute(curZoneElem, "name"))
{
Ogre::String name = getAttributeValueAsStdString(curZoneElem, "name");
Zone* zone = NULL;
if (name == "default")
{
zone = ZoneManager::getSingleton().getDefaultZone();
}
else
{
// get the zone with that name or create one
zone = ZoneManager::getSingleton().getZone(name);
if (!zone)
{
zone = ZoneManager::getSingleton().createZone(name, false);
}
// multiple areas
for (const TiXmlNode* curArea = cur->FirstChild(); curArea != NULL; curArea = curArea->NextSibling())
{
if (curArea->Type() == TiXmlNode::ELEMENT
&& hasNodeName(curArea, "area"))
{
const TiXmlElement *curAreaElem = curArea->ToElement();
if (hasAttribute(curAreaElem, "type"))
{
// type
Ogre::String type;
type = getAttributeValueAsStdString(curAreaElem, "type");
// add or subtract?
bool subtract = false;
if (hasAttribute(curAreaElem, "subtract"))
{
subtract = getAttributeValueAsBool(curAreaElem, "subtract");
}
// position
Vector3 position = Vector3::ZERO;
const TiXmlElement* positionElem = getChildNamed(curAreaElem, "position");
if (positionElem)
{
position = getValueAsVector3(positionElem);
}
//scale, rotation, offset
Vector3 scale = Vector3::UNIT_SCALE;
const TiXmlElement* scaleElem = getChildNamed(curAreaElem, "scale");
if (!scaleElem)
{
scaleElem = getChildNamed(curAreaElem, "size");
}
if (scaleElem)
{
scale = getValueAsVector3(scaleElem);
}
Vector3 offset = Vector3::ZERO;
const TiXmlElement* offsetElem = getChildNamed(curAreaElem, "offset");
if (offsetElem)
{
offset = getValueAsVector3(offsetElem);
}
Quaternion rotation = Quaternion::IDENTITY;
const TiXmlElement* rotationElem = getChildNamed(curAreaElem, "rotation");
if (rotationElem)
{
rotation = getValueAsQuaternion(rotationElem);
}
//transition distance
Real transitionDistance = 0;
const TiXmlElement* transitionElem = getChildNamed(curAreaElem, "transition_distance");
if (transitionElem)
{
transitionDistance = getValueAsReal(transitionElem);
}
if (type == "mesh")
{
Ogre::String meshName;
if (hasAttribute(curAreaElem, "meshfile"))
{
meshName = getAttributeValueAsStdString(curAreaElem, "meshfile");
if (subtract)
{
ZoneManager::getSingleton().subtractMeshAreaFromZone(name,
meshName, GT_CONVEXHULL, position, scale, offset, rotation, transitionDistance, QUERYFLAG_PLAYER);
}
else
{
ZoneManager::getSingleton().addMeshAreaToZone(name,
meshName, GT_CONVEXHULL, position, scale, offset, rotation, transitionDistance, QUERYFLAG_PLAYER);
}
}
else
{
LOG_ERROR(Logger::SCRIPT, "an <area> element with type=\"mesh\" must have attribute 'meshfile'");
}
}
else
{
GeometryType geom = GT_NONE;
if (type == "sphere")
{
geom = GT_SPHERE;
}
else if (type == "box")
{
geom = GT_BOX;
}
else if (type == "ellipsoid")
{
geom = GT_ELLIPSOID;
}
else if (type == "pyramid")
{
geom = GT_PYRAMID;
}
else if (type == "capsule")
{
geom = GT_CAPSULE;
}
else
{
LOG_ERROR(Logger::SCRIPT, "Unknown area type '" + type + "' !");
}
if ( geom != GT_NONE)
{
Ogre::AxisAlignedBox aabb;
aabb.setMinimum( - scale / 2.0f);
aabb.setMaximum( + scale / 2.0f);
if (subtract)
ZoneManager::getSingleton().subtractAreaFromZone(name,
aabb, geom, position, offset, rotation, transitionDistance, QUERYFLAG_PLAYER);
else
ZoneManager::getSingleton().addAreaToZone(name,
aabb, geom, position, offset, rotation, transitionDistance, QUERYFLAG_PLAYER);
}
}
}
else
{
LOG_ERROR(Logger::SCRIPT, "<area> elemt must have attribute 'type'");
}
}
}
}
if (zone)
{
for (const TiXmlNode* cur = curZoneElem->FirstChild(); cur != NULL; cur = cur->NextSibling())
{
if (cur->Type() == TiXmlNode::ELEMENT)
{
const TiXmlElement* curElem = cur->ToElement();
if (hasNodeName(curElem, "light"))
{
Ogre::String name = getAttributeValueAsStdString(curElem, "name");
zone->addLight(ActorManager::getSingleton().getActor(name));
}
else if (hasNodeName(curElem, "sound"))
{
Ogre::String name = getAttributeValueAsStdString(curElem, "name");
zone->addSound(name);
}
else if (hasNodeName(curElem, "trigger"))
{
Ogre::String classname =
getAttributeValueAsStdString(curElem, "classname");
Ogre::String name =
getAttributeValueAsStdString(curElem, "name");
Trigger* trigger = ScriptSubsystem::getSingleton().getTriggerFactory()
->createTrigger(classname, name);
// add trigger properties
for (const TiXmlNode* curProperty = cur->FirstChild(); curProperty != NULL; curProperty = curProperty->NextSibling())
{
if (hasNodeName(curProperty, "property"))
{
PropertyEntry propEntry = processProperty(curProperty->ToElement());
if (propEntry.first != "")
{
trigger->setProperty(propEntry.first, propEntry.second);
}
}
}
zone->addTrigger(trigger);
}
else if (hasNodeName(curElem, "eaxpreset"))
{
Ogre::String name = getAttributeValueAsStdString(curElem, "name");
zone->setEaxPreset(name);
}
}
}
}
else
{
LOG_ERROR(Logger::SCRIPT, "Zone named '"+name+"' could not be processes.");
}
}
else
{
LOG_ERROR(Logger::SCRIPT, "<zone> element must have attribute 'name'.");
}
}
}
ZoneManager::getSingleton().update();
return true;
}
char *wb_nrep::nameName(const char *n, int ntype, char *res)
{
static char result[512];
int colon_added = 0;
if ( !res)
res = result;
if ( ntype & cdh_mName_volume && ntype & cdh_mName_object)
ntype |= cdh_mName_path;
if ( ntype & cdh_mName_path && ntype & cdh_mName_attribute)
ntype |= cdh_mName_object;
if ( ntype & cdh_mName_volume && ntype & cdh_mName_attribute)
ntype = ntype | cdh_mName_path | cdh_mName_object;
strcpy( res, "");
if ( ntype & cdh_mName_idString) {
#if 0
if ( ntype & cdh_mName_volume) printf( "wname: volume\n");
if ( ntype & cdh_mName_object) printf( "wname: object\n");
if ( ntype & cdh_mName_attribute) printf( "wname: attribute\n");
#endif
if ( !(ntype & cdh_mName_attribute)) {
if ( ntype & cdh_mName_volume && !(ntype & cdh_mName_object))
strcat( res, "_V");
else if ( !(ntype & cdh_mName_volume))
strcat( res, "_X");
else
strcat( res, "_O");
}
else
strcat( res, "_A");
}
if ( ntype & cdh_mName_volume)
volumeName( n, res + strlen(res));
else if ( ntype & cdh_mName_ref)
volumeName( n, res + strlen(res));
if ( ntype & cdh_mName_path) {
if ( ntype & cdh_mName_volume && hasVolume()) {
strcat( res, ":");
colon_added = 1;
}
pathName( n, res + strlen(res));
}
if ( ntype & cdh_mName_object) {
if ( ntype & cdh_mName_path && hasPath())
strcat( res, "-");
else if ( ntype & cdh_mName_volume && !hasPath() && hasVolume() && !colon_added)
strcat( res, ":");
objectName( n, res + strlen(res));
}
if ( ntype & cdh_mName_attribute && hasAttribute()) {
if ( !m_hasSuper || m_shadowed || ntype & cdh_mName_trueAttr) {
strcat( res, ".");
strcat( res, n + attr[0].offs);
}
else {
for ( int i = 0; i < num_attr; i++) {
if ( !attr[i].isSuper) {
strcat( res, ".");
int l = strlen(res);
strncat( res, n + attr[i].offs, attr[i].len);
if ( attr[i].index != -1)
sprintf( &res[ l + attr[i].len], "[%d]", attr[i].index);
else
res[ l + attr[i].len] = 0;
}
}
}
}
return res;
}
bool MaintainingReader<TokenLookupClass, LookupKey>::hasAttribute(const QString &localName) const
{
return hasAttribute(QString(), localName);
}
PropertyEntry XmlPropertyReader::processProperty(XERCES_CPP_NAMESPACE::DOMElement* domElem) const
{
if (!hasAttribute(domElem, "type"))
{
return std::make_pair("", Property(0));
}
Ogre::String key = "";
if (hasAttribute(domElem, "name"))
{
key = getAttributeValueAsStdString(domElem, "name");
}
Ogre::String type = getAttributeValueAsStdString(domElem, "type");
CeGuiString value = "";
if (hasAttribute(domElem, "data"))
{
value = getAttributeValueAsString(domElem, "data");
}
Property prop;
if (type == "STRING")
{
prop = Property(value);
}
else if (type == "INT")
{
const int intVal = CEGUI::PropertyHelper::stringToInt(value);
prop = Property(intVal);
}
else if (type == "REAL" || type == "FLOAT")
{
const Ogre::Real realVal = CEGUI::PropertyHelper::stringToFloat(value);
prop = Property(realVal);
}
else if (type == "VECTOR3")
{
CeGuiString::size_type comma1 = value.find(",");
CeGuiString::size_type comma2 = value.find(",", comma1 + 1);
Ogre::Vector3 vec(Ogre::Vector3::ZERO);
if (comma1 != CeGuiString::npos && comma2 != CeGuiString::npos)
{
vec.x = CEGUI::PropertyHelper::stringToFloat(value.substr(0, comma1));
vec.y = CEGUI::PropertyHelper::stringToFloat(value.substr(comma1 + 1, comma2 - comma1 - 1));
vec.z = CEGUI::PropertyHelper::stringToFloat(value.substr(comma2 + 1));
}
prop = Property(vec);
}
else if (type == "QUATERNION")
{
CeGuiString::size_type comma1 = value.find(",");
CeGuiString::size_type comma2 = value.find(",", comma1 + 1);
CeGuiString::size_type comma3 = value.find(",", comma2 + 1);
Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
if (comma1 != CeGuiString::npos
&& comma2 != CeGuiString::npos
&& comma3 != CeGuiString::npos)
{
quat.w = CEGUI::PropertyHelper::stringToFloat(value.substr(0, comma1));
quat.x = CEGUI::PropertyHelper::stringToFloat(value.substr(comma1 + 1, comma2 - comma1 - 1));
quat.y = CEGUI::PropertyHelper::stringToFloat(value.substr(comma2 + 1, comma3 - comma2 - 1));
quat.z = CEGUI::PropertyHelper::stringToFloat(value.substr(comma3 + 1));
}
else if (comma1 != CeGuiString::npos
&& comma2 != CeGuiString::npos
&& comma3 == CeGuiString::npos)
{
Quaternion rotX, rotY, rotZ;
rotX.FromAngleAxis(
Ogre::Degree(CEGUI::PropertyHelper::stringToFloat(value.substr(0, comma1))),
Ogre::Vector3::UNIT_X);
rotY.FromAngleAxis(
Ogre::Degree(CEGUI::PropertyHelper::stringToFloat(value.substr(comma1 + 1, comma2 - comma1 - 1))),
Ogre::Vector3::UNIT_Y);
rotZ.FromAngleAxis(
Ogre::Degree(CEGUI::PropertyHelper::stringToFloat(value.substr(comma2 + 1))),
Ogre::Vector3::UNIT_Z);
quat = rotX * rotY * rotZ;
}
prop = Property(quat);
}
else if (type == "BOOL")
{
const bool boolVal = CEGUI::PropertyHelper::stringToBool(value);
prop = Property(boolVal);
}
else if (type == "ARRAY")
{
std::vector<Property> vecVal;
for (DOMNode* curChild = domElem->getFirstChild(); curChild != NULL;
curChild = curChild->getNextSibling())
{
if (curChild->getNodeType() == DOMNode::ELEMENT_NODE)
{
PropertyEntry entry = processProperty(static_cast<DOMElement*>(curChild));
vecVal.push_back(entry.second);
}
}
prop = Property(vecVal);
}
else if (type == "INTPAIR")
{
CeGuiString::size_type comma1 = value.find(",");
std::pair<int,int> intpairVal = std::make_pair(0, 0);
if (comma1 != CeGuiString::npos)
{
intpairVal = std::make_pair(
CEGUI::PropertyHelper::stringToInt(value.substr(0, comma1)),
CEGUI::PropertyHelper::stringToInt(value.substr(comma1 + 1)));
}
prop = Property(intpairVal);
}
else if (type == "INTTRIPLE")
{
CeGuiString::size_type comma1 = value.find(",");
CeGuiString::size_type comma2 = value.find(",", comma1 + 1);
Tripel<int> intTripel(0,0,0);
if (comma1 != CeGuiString::npos && comma2 != CeGuiString::npos)
{
intTripel.first = CEGUI::PropertyHelper::stringToFloat(value.substr(0, comma1));
intTripel.second = CEGUI::PropertyHelper::stringToFloat(value.substr(comma1 + 1, comma2 - comma1 - 1));
intTripel.third = CEGUI::PropertyHelper::stringToFloat(value.substr(comma2 + 1));
}
prop = Property(intTripel);
}
else if (type == "MAP")
{
PropertyMap mapVal;
for (DOMNode* curChild = domElem->getFirstChild(); curChild != NULL;
curChild = curChild->getNextSibling())
{
if (curChild->getNodeType() == DOMNode::ELEMENT_NODE)
{
DOMElement* curElem = static_cast<DOMElement*>(curChild);
CeGuiString key = getAttributeValueAsString(curElem, "name");
PropertyEntry entry = processProperty(curElem);
mapVal[key] = entry.second;
}
}
prop = Property(mapVal);
}
return std::make_pair(key, prop);
}
bool SVGScriptElement::hasSourceAttribute() const
{
return hasAttribute(XLinkNames::hrefAttr);
}
bool PANEElement::hasDesiredWidth() {
return hasAttribute( AttrNameWidth );
}
void XmlSettingsDialog::ParseEntity (const QDomElement& entity, QWidget *baseWidget)
{
QDomElement item = entity.firstChildElement ("item");
while (!item.isNull ())
{
ParseItem (item, baseWidget);
item = item.nextSiblingElement ("item");
}
auto gbox = entity.firstChildElement ("groupbox");
while (!gbox.isNull ())
{
const auto box = new QGroupBox (GetLabel (gbox));
box->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Preferred);
const auto groupLayout = new QGridLayout ();
groupLayout->setContentsMargins (2, 2, 2, 2);
box->setLayout (groupLayout);
ParseEntity (gbox, box);
const auto lay = qobject_cast<QGridLayout*> (baseWidget->layout ());
lay->addWidget (box, lay->rowCount (), 0, 1, 2);
gbox = gbox.nextSiblingElement ("groupbox");
}
auto scroll = entity.firstChildElement ("scrollarea");
while (!scroll.isNull ())
{
const auto area = new QScrollArea ();
if (scroll.hasAttribute ("horizontalScroll"))
{
const auto& attr = scroll.attribute ("horizontalScroll");
if (attr == "on")
area->setHorizontalScrollBarPolicy (Qt::ScrollBarAlwaysOn);
else if (attr == "off")
area->setHorizontalScrollBarPolicy (Qt::ScrollBarAlwaysOff);
}
if (scroll.hasAttribute ("verticalScroll"))
{
const auto& attr = scroll.attribute ("verticalScroll");
if (attr == "on")
area->setVerticalScrollBarPolicy (Qt::ScrollBarAlwaysOn);
else if (attr == "off")
area->setVerticalScrollBarPolicy (Qt::ScrollBarAlwaysOff);
}
area->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Expanding);
const auto areaWidget = new QFrame;
areaWidget->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Expanding);
const auto areaLayout = new QGridLayout;
areaWidget->setLayout (areaLayout);
ParseEntity (scroll, areaWidget);
area->setWidget (areaWidget);
area->setWidgetResizable (true);
areaWidget->show ();
const auto lay = qobject_cast<QGridLayout*> (baseWidget->layout ());
const auto thisRow = lay->rowCount ();
lay->addWidget (area, thisRow, 0, 1, 2);
lay->setRowStretch (thisRow, 1);
scroll = scroll.nextSiblingElement ("scrollarea");
}
auto tab = entity.firstChildElement ("tab");
if (!tab.isNull ())
{
const auto tabs = new QTabWidget;
const auto lay = qobject_cast<QGridLayout*> (baseWidget->layout ());
lay->addWidget (tabs, lay->rowCount (), 0, 1, 2);
while (!tab.isNull ())
{
const auto page = new QWidget;
const auto widgetLay = new QGridLayout;
widgetLay->setContentsMargins (0, 0, 0, 0);
page->setLayout (widgetLay);
tabs->addTab (page, GetLabel (tab));
ParseEntity (tab, page);
tab = tab.nextSiblingElement ("tab");
widgetLay->addItem (new QSpacerItem (0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding),
widgetLay->rowCount (), 0, 1, 1);
}
}
}
double HTMLProgressElement::position() const
{
if (!hasAttribute(valueAttr))
return -1;
return value() / max();
}
bool PANEElement::hasDesiredHeight() {
return hasAttribute( AttrNameHeight );
}
PassRefPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder* filterBuilder, Filter* filter)
{
FilterEffect* input1 = filterBuilder->getEffectById(in1());
if (!input1)
return 0;
int orderXValue = orderX();
int orderYValue = orderY();
if (!hasAttribute(SVGNames::orderAttr)) {
orderXValue = 3;
orderYValue = 3;
}
// Spec says order must be > 0. Bail if it is not.
if (orderXValue < 1 || orderYValue < 1)
return 0;
SVGNumberList& kernelMatrix = this->kernelMatrix();
int kernelMatrixSize = kernelMatrix.size();
// The spec says this is a requirement, and should bail out if fails
if (orderXValue * orderYValue != kernelMatrixSize)
return 0;
int targetXValue = targetX();
int targetYValue = targetY();
if (hasAttribute(SVGNames::targetXAttr) && (targetXValue < 0 || targetXValue >= orderXValue))
return 0;
// The spec says the default value is: targetX = floor ( orderX / 2 ))
if (!hasAttribute(SVGNames::targetXAttr))
targetXValue = static_cast<int>(floorf(orderXValue / 2));
if (hasAttribute(SVGNames::targetYAttr) && (targetYValue < 0 || targetYValue >= orderYValue))
return 0;
// The spec says the default value is: targetY = floor ( orderY / 2 ))
if (!hasAttribute(SVGNames::targetYAttr))
targetYValue = static_cast<int>(floorf(orderYValue / 2));
// Spec says default kernelUnitLength is 1.0, and a specified length cannot be 0.
int kernelUnitLengthXValue = kernelUnitLengthX();
int kernelUnitLengthYValue = kernelUnitLengthY();
if (!hasAttribute(SVGNames::kernelUnitLengthAttr)) {
kernelUnitLengthXValue = 1;
kernelUnitLengthYValue = 1;
}
if (kernelUnitLengthXValue <= 0 || kernelUnitLengthYValue <= 0)
return 0;
float divisorValue = divisor();
if (hasAttribute(SVGNames::divisorAttr) && !divisorValue)
return 0;
if (!hasAttribute(SVGNames::divisorAttr)) {
for (int i = 0; i < kernelMatrixSize; ++i)
divisorValue += kernelMatrix.at(i);
if (!divisorValue)
divisorValue = 1;
}
RefPtr<FilterEffect> effect = FEConvolveMatrix::create(filter,
IntSize(orderXValue, orderYValue), divisorValue,
bias(), IntPoint(targetXValue, targetYValue), edgeMode(),
FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix);
effect->inputEffects().append(input1);
return effect.release();
}
