shared_ptr<Component> ScheduledActionsFactory::createObject(std::map<std::string, std::string> parameters,
ComponentRegistry *reg) {
REQUIRE_ATTRIBUTES(parameters, "delay", "repeats", "duration");
shared_ptr<Variable> delay = reg->getVariable(parameters["delay"]);
shared_ptr<Variable> duration = reg->getVariable(parameters["duration"]);
shared_ptr<Variable> repeats = reg->getVariable(parameters["repeats"]);
shared_ptr<Variable> cancel = reg->getVariable(parameters["cancel"], "0");
checkAttribute(duration, parameters["reference_id"], "duration", parameters["duration"]);
checkAttribute(delay, parameters["reference_id"], "delay", parameters["delay"]);
checkAttribute(repeats, parameters["reference_id"], "repeats", parameters["repeats"]);
checkAttribute(repeats, parameters["reference_id"], "cancel", parameters["cancel"]);
// TODO .. needs more work, the actual actions aren't included here
auto newScheduledActions = boost::make_shared<ScheduledActions>(repeats, delay, duration, cancel);
if (cancel) {
auto notification = boost::make_shared<ScheduledActions::CancelNotification>(newScheduledActions);
cancel->addNotification(notification);
}
return newScheduledActions;
}
shared_ptr<mw::Component> mFakeMonkeyEyeMovementChannelFactory::createObject(std::map<std::string, std::string> parameters,
ComponentRegistry *reg) {
const char *EYE_H_VARIABLE = "eye_h";
const char *EYE_V_VARIABLE = "eye_v";
const char *UPDATE_PERIOD = "update_interval";
const char *DATA_SAMPLING_PERIOD = "data_interval";
REQUIRE_ATTRIBUTES(parameters, EYE_H_VARIABLE, EYE_V_VARIABLE, UPDATE_PERIOD, DATA_SAMPLING_PERIOD);
shared_ptr<Variable> eye_h_variable = reg->getVariable(parameters.find(EYE_H_VARIABLE)->second);
checkAttribute(eye_h_variable, parameters.find("reference_id")->second, EYE_H_VARIABLE, parameters.find(EYE_H_VARIABLE)->second);
shared_ptr<Variable> eye_v_variable = reg->getVariable(parameters.find(EYE_V_VARIABLE)->second);
checkAttribute(eye_v_variable, parameters.find("reference_id")->second, EYE_V_VARIABLE, parameters.find(EYE_V_VARIABLE)->second);
MWorksTime update_period = reg->getNumber(parameters.find(UPDATE_PERIOD)->second);
MWorksTime data_sampling_period = reg->getNumber(parameters.find(DATA_SAMPLING_PERIOD)->second);
int samples_per_update = update_period/data_sampling_period;
shared_ptr <mw::Component> new_fake_monkey_eye_channel = shared_ptr<mw::Component>(new mFakeMonkeyEyeMovementChannel(eye_h_variable,
eye_v_variable,
update_period,
samples_per_update));
return new_fake_monkey_eye_channel;
}
GnomeKeyringResult
findLogins(const nsAString & aHostname,
const nsAString & aActionURL,
const nsAString & aHttpRealm,
void (*foundLogin)(GnomeKeyringFound* found, T data),
T data)
{
GnomeKeyringAttributeList *attributes = gnome_keyring_attribute_list_new();
gnome_keyring_attribute_list_append_string(attributes,
kLoginInfoMagicAttrName, kLoginInfoMagicAttrValue);
/* Convert to UTF-8 (but keep a reference to the NS_ConvertUTF16ToUTF8
* instance around, so the string .get() returns won't be free'd */
gnome_keyring_attribute_list_append_string(attributes, kHostnameAttr,
NS_ConvertUTF16toUTF8(aHostname).get());
GList* unfiltered;
GnomeKeyringResult result = gnome_keyring_find_items_sync(
GNOME_KEYRING_ITEM_GENERIC_SECRET,
attributes,
&unfiltered );
gnome_keyring_attribute_list_free(attributes);
/* Convert to UTF-8 (but keep a reference to the NS_ConvertUTF16ToUTF8
* instance around, so the string .get() returns won't be free'd */
const NS_ConvertUTF16toUTF8 utf8ActionURL(aActionURL);
const char* tempActionUrl = utf8ActionURL.IsVoid() ? NULL : utf8ActionURL.get();
const NS_ConvertUTF16toUTF8 utf8HttpRealm(aHttpRealm);
const char* tempHttpRealm = utf8HttpRealm.IsVoid() ? NULL : utf8HttpRealm.get();
for (GList* l = unfiltered; l != NULL; l = l->next) {
bool isMatch = TRUE;
GnomeKeyringFound* found = static_cast<GnomeKeyringFound*>(l->data);
GnomeKeyringAttribute *attrArray = (GnomeKeyringAttribute *)found->attributes->data;
for (PRUint32 i = 0; i < found->attributes->len; i++) {
if (attrArray[i].type != GNOME_KEYRING_ATTRIBUTE_TYPE_STRING)
continue;
const char *attrName = attrArray[i].name;
const char *attrValue = attrArray[i].value.string;
if (!strcmp(attrName, kFormSubmitURLAttr)) {
checkAttribute(tempActionUrl, attrValue, &isMatch);
} else if (!strcmp(attrName, kHttpRealmAttr)) {
checkAttribute(tempHttpRealm, attrValue, &isMatch);
}
}
if (isMatch) {
foundLogin(found, data);
}
}
gnome_keyring_found_list_free(unfiltered);
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// Add Attributes to an given element.
/// It copies the \c attr array and all values,
/// replaces all attribute names by constant literal strings,
/// converts the null-terminated array into an array of known size n.
///
///\param el The element.
///\param attr Attributes.
///\returns 0 if there is no error occurred. Otherwise, return 1 to indicate an error.
///////////////////////////////////////////////////////////////////////////////
int addAttributes(Element* el, const char** attr) {
int n, a;
const char** att = NULL;
for (n=0; attr[n]; n+=2);
printDebug("\n");
printfIntDebug("addAttributes(): n = %d\n", n);
if (n>0) {
att = calloc(n, sizeof(char*));
if (checkPointer(att)) return 1;
}
printDebug("addAttributes(): allocated att");
for (n=0; attr[n]; n+=2) {
char* value = strdup(attr[n+1]); //duplicate string attr[n+1]
printfDebug("addAttributes(): value = %s\n", value);
if (checkPointer(value)) return 1;
a = checkAttribute(attr[n]);
printfIntDebug("addAttributes(): index a = %d\n", a);
if (a == -1) {
printf("Illegal attribute in");
return 1; // illegal attribute error
}
att[n ] = attNames[a]; // no heap memory
printfDebug("addAttributes(): attNames = %s\n", attNames[a]);
att[n+1] = value; // heap memory
printfDebug("addAttributes(): att[n+1] = %s\n", att[n+1] );
}
el->attributes = att; // NULL if n=0
el->n = n;
return 0; // success
}
int Swig_need_name_warning(Node *n) {
int need = 1;
/*
we don't use name warnings for:
- class forwards, no symbol is generated at the target language.
- template declarations, only for real instances using %template(name).
- typedefs, they have no effect at the target language.
*/
if (checkAttribute(n, "nodeType", "classforward")) {
need = 0;
} else if (checkAttribute(n, "storage", "typedef")) {
need = 0;
} else if (Getattr(n, "hidden")) {
need = 0;
} else if (Getattr(n, "ignore")) {
need = 0;
} else if (Getattr(n, "templatetype")) {
need = 0;
}
return need;
}
SpellbookInfo Spellbooks::parseSpellbook(pugi::xml_node& node) {
SpellbookInfo curInfo;
checkAttribute(node, "offset");
checkAttribute(node, "name");
checkAttribute(node, "gump");
curInfo.packetOffset_ = node.attribute("offset").as_uint();
curInfo.name_ = node.attribute("name").value();
curInfo.gumpName_ = node.attribute("gump").value();
pugi::xml_node sectionIter = node.first_child();
while (sectionIter) {
SpellbookSectionInfo curSection = parseSection(sectionIter);
for (unsigned int i = 0; i < 8; ++i) {
curSection.spells_[i].spellId_ += curInfo.packetOffset_;
}
curInfo.sections_[curSection.byteIndex_] = curSection;
sectionIter = sectionIter.next_sibling();
}
return curInfo;
}
SpellbookSectionInfo Spellbooks::parseSection(pugi::xml_node& node) {
SpellbookSectionInfo curInfo;
checkAttribute(node, "byte");
checkAttribute(node, "name");
curInfo.byteIndex_ = node.attribute("byte").as_uint();
curInfo.name_ = node.attribute("name").value();
if (curInfo.byteIndex_ > 7) {
LOG_ERROR << "Byte index of spellbook section must not be > 7" << std::endl;
throw XmlLoadException("Byte index of spellbook section must not be > 7");
}
pugi::xml_node spellIter = node.first_child();
while (spellIter) {
SpellInfo curSpell = parseSpell(spellIter);
curSpell.sectionHeader_ = curInfo.name_;
curSpell.spellId_ += curInfo.byteIndex_ * 8;
curInfo.spells_[curSpell.bitIndex_] = curSpell;
spellIter = spellIter.next_sibling();
}
return curInfo;
}
shared_ptr<mw::Component> LinearEyeCalibratorFactory::createObject(std::map<std::string, std::string> parameters,
ComponentRegistry *reg) {
REQUIRE_ATTRIBUTES(parameters, "tag", "eyeh_raw", "eyeh_calibrated", "eyev_raw", "eyev_calibrated");
std::string tagname(parameters.find("tag")->second);
shared_ptr<Variable> eyeh_raw = reg->getVariable(parameters.find("eyeh_raw")->second);
shared_ptr<Variable> eyev_raw = reg->getVariable(parameters.find("eyev_raw")->second);
shared_ptr<Variable> eyeh_calibrated = reg->getVariable(parameters.find("eyeh_calibrated")->second);
shared_ptr<Variable> eyev_calibrated = reg->getVariable(parameters.find("eyev_calibrated")->second);
checkAttribute(eyeh_raw, parameters["reference_id"], "eyeh_raw", parameters.find("eyeh_raw")->second);
checkAttribute(eyev_raw, parameters["reference_id"], "eyev_raw", parameters.find("eyev_raw")->second);
checkAttribute(eyeh_calibrated, parameters["reference_id"], "eyeh_calibrated", parameters.find("eyeh_calibrated")->second);
checkAttribute(eyev_calibrated, parameters["reference_id"], "eyev_calibrated", parameters.find("eyev_calibrated")->second);
shared_ptr <mw::Component> newEyeCalibrator = shared_ptr<mw::Component>(new EyeCalibrator(tagname,
eyeh_raw,
eyev_raw,
eyeh_calibrated,
eyev_calibrated,
1));
return newEyeCalibrator;
}
int Swig_need_protected(Node *n) {
String *nodetype = nodeType(n);
if (checkAttribute(n, "access", "protected")) {
if ((Equal(nodetype, "cdecl"))) {
if (Swig_director_mode() && Swig_director_protected_mode() && Swig_all_protected_mode()) {
return 1;
}
if (SwigType_isfunction(Getattr(n, "decl"))) {
String *storage = Getattr(n, "storage");
/* The function is declared virtual, or it has no storage. This eliminates typedef, static etc. */
return !storage || Equal(storage, "virtual");
}
} else if (Equal(nodetype, "constructor") || Equal(nodetype, "destructor")) {
return 1;
} else if (Equal(nodetype, "using") && !Getattr(n, "namespace")) {
return 1;
}
}
return 0;
}
// Returns 0 to indicate error
// Copies the attr array and all values.
// Replaces all attribute names by constant literal strings.
// Converts the null-terminated array into an array of known size n.
int addAttributes(Element* el, const char** attr) {
int n, a;
const char** att = NULL;
for (n=0; attr[n]; n+=2);
if (n>0) {
att = calloc(n, sizeof(char*));
if (!checkPointer(att)) return 0;
}
for (n=0; attr[n]; n+=2) {
char* value = strdup(attr[n+1]);
if (!checkPointer(value)) return 0;
a = checkAttribute(attr[n]);
if (a == -1) return 0; // illegal attribute error
att[n ] = attNames[a]; // no heap memory
att[n+1] = value; // heap memory
}
el->attributes = att; // NULL if n=0
el->n = n;
return 1; // success
}
void OutputCrosstab::checkTraces() {
if (traceRecords().size() < 2) {
QString msg("Crosstab output must have at least two traces");
throw Exception(msg, this);
}
Trace *y = traceRecords()[1].trace;
checkAttribute(y, "rows");
checkAttribute(y, "columns");
rowClass = y->attribute("rows").toString();
columnClass = y->attribute("columns").toString();
for (int i = 2; i < traceRecords().size(); ++i) {
Trace *y = traceRecords()[i].trace;
checkAttribute(y, "rows");
checkAttribute(y, "columns");
checkAttribute(y, "rows", rowClass);
checkAttribute(y, "columns", columnClass);
}
}
SpellInfo Spellbooks::parseSpell(pugi::xml_node& node) {
SpellInfo curInfo;
checkAttribute(node, "bit");
checkAttribute(node, "name");
checkAttribute(node, "wops");
checkAttribute(node, "description-header");
checkAttribute(node, "description");
checkAttribute(node, "gumpid");
curInfo.bitIndex_ = node.attribute("bit").as_uint();
curInfo.name_ = node.attribute("name").value();
curInfo.wops_ = node.attribute("wops").value();
curInfo.descriptionHeader_ = node.attribute("description-header").value();
curInfo.description_ = node.attribute("description").value();
curInfo.gumpId_ = node.attribute("gumpid").as_uint();
curInfo.spellId_ = curInfo.bitIndex_; // section and book offset are added in parseSection and parseSpellbook
if (curInfo.bitIndex_ > 7) {
LOG_ERROR << "Bit index of spell must not be > 7" << std::endl;
throw XmlLoadException("Bit index of spell must not be > 7");
}
return curInfo;
}
static int cparse_template_expand(Node *n, String *tname, String *rname, String *templateargs, List *patchlist, List *typelist, List *cpatchlist) {
static int expanded = 0;
int ret;
String *nodeType;
if (!n)
return 0;
nodeType = nodeType(n);
if (Getattr(n, "error"))
return 0;
if (Equal(nodeType, "template")) {
/* Change the node type back to normal */
if (!expanded) {
expanded = 1;
set_nodeType(n, Getattr(n, "templatetype"));
ret = cparse_template_expand(n, tname, rname, templateargs, patchlist, typelist, cpatchlist);
expanded = 0;
return ret;
} else {
/* Called when template appears inside another template */
/* Member templates */
set_nodeType(n, Getattr(n, "templatetype"));
ret = cparse_template_expand(n, tname, rname, templateargs, patchlist, typelist, cpatchlist);
set_nodeType(n, "template");
return ret;
}
} else if (Equal(nodeType, "cdecl")) {
/* A simple C declaration */
SwigType *t, *v, *d;
String *code;
t = Getattr(n, "type");
v = Getattr(n, "value");
d = Getattr(n, "decl");
code = Getattr(n, "code");
Append(typelist, t);
Append(typelist, d);
Append(patchlist, v);
Append(cpatchlist, code);
if (Getattr(n, "conversion_operator")) {
Append(cpatchlist, Getattr(n, "name"));
if (Getattr(n, "sym:name")) {
Append(cpatchlist, Getattr(n, "sym:name"));
}
}
if (checkAttribute(n, "storage", "friend")) {
String *symname = Getattr(n, "sym:name");
if (symname) {
String *stripped_name = SwigType_templateprefix(symname);
Setattr(n, "sym:name", stripped_name);
Delete(stripped_name);
}
Append(typelist, Getattr(n, "name"));
}
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
} else if (Equal(nodeType, "class")) {
/* Patch base classes */
{
int b = 0;
for (b = 0; b < 3; ++b) {
List *bases = Getattr(n, baselists[b]);
if (bases) {
int i;
int ilen = Len(bases);
for (i = 0; i < ilen; i++) {
String *name = Copy(Getitem(bases, i));
Setitem(bases, i, name);
Append(typelist, name);
}
}
}
}
/* Patch children */
{
Node *cn = firstChild(n);
while (cn) {
cparse_template_expand(cn, tname, rname, templateargs, patchlist, typelist, cpatchlist);
cn = nextSibling(cn);
}
}
} else if (Equal(nodeType, "constructor")) {
String *name = Getattr(n, "name");
if (!(Getattr(n, "templatetype"))) {
String *symname;
String *stripped_name = SwigType_templateprefix(name);
if (Strstr(tname, stripped_name)) {
Replaceid(name, stripped_name, tname);
}
Delete(stripped_name);
symname = Getattr(n, "sym:name");
if (symname) {
stripped_name = SwigType_templateprefix(symname);
if (Strstr(tname, stripped_name)) {
Replaceid(symname, stripped_name, tname);
}
Delete(stripped_name);
}
if (strchr(Char(name), '<')) {
Append(patchlist, Getattr(n, "name"));
} else {
Append(name, templateargs);
}
name = Getattr(n, "sym:name");
if (name) {
if (strchr(Char(name), '<')) {
Clear(name);
Append(name, rname);
} else {
String *tmp = Copy(name);
Replace(tmp, tname, rname, DOH_REPLACE_ANY);
Clear(name);
Append(name, tmp);
Delete(tmp);
}
}
/* Setattr(n,"sym:name",name); */
}
Append(cpatchlist, Getattr(n, "code"));
Append(typelist, Getattr(n, "decl"));
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
} else if (Equal(nodeType, "destructor")) {
String *name = Getattr(n, "name");
if (name) {
if (strchr(Char(name), '<'))
Append(patchlist, Getattr(n, "name"));
else
Append(name, templateargs);
}
name = Getattr(n, "sym:name");
if (name) {
if (strchr(Char(name), '<')) {
String *sn = Copy(tname);
Setattr(n, "sym:name", sn);
Delete(sn);
} else {
Replace(name, tname, rname, DOH_REPLACE_ANY);
}
}
/* Setattr(n,"sym:name",name); */
Append(cpatchlist, Getattr(n, "code"));
} else if (Equal(nodeType, "using")) {
String *uname = Getattr(n, "uname");
if (uname && strchr(Char(uname), '<')) {
Append(patchlist, uname);
}
if (Getattr(n, "namespace")) {
/* Namespace link. This is nasty. Is other namespace defined? */
}
} else {
/* Look for obvious parameters */
Node *cn;
Append(cpatchlist, Getattr(n, "code"));
Append(typelist, Getattr(n, "type"));
Append(typelist, Getattr(n, "decl"));
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "kwargs"), cpatchlist, typelist);
add_parms(Getattr(n, "pattern"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
cn = firstChild(n);
while (cn) {
cparse_template_expand(cn, tname, rname, templateargs, patchlist, typelist, cpatchlist);
cn = nextSibling(cn);
}
}
return 0;
}
int isComplexData(int _iDatasetId)
{
return checkAttribute(_iDatasetId, (char *)g_SCILAB_CLASS_COMPLEX, "true");
}
bool BBEntity::isAir()
{
return checkAttribute(BB_UNIT_ATTRIBUTE_AIR);
};
bool BBEntity::isWater()
{
return checkAttribute(BB_UNIT_ATTRIBUTE_WATER);
};
bool BBEntity::isGround()
{
return checkAttribute(BB_UNIT_ATTRIBUTE_GROUND);
};
bool BBEntity::isStructure()
{
return checkAttribute(BB_UNIT_ATTRIBUTE_STRUCTURE);
};
MStatus boingRbCmd::redoIt()
{
if (argParser->isFlagSet("help") || argParser->isFlagSet("h"))
{
MString helpMsg = "boingRB - command : Boing - bullet plugin by Risto Puukko\n";
helpMsg += "---------------------------------------------------------\n";
helpMsg += "boingRB [flag] [args] \n";
helpMsg += "\n";
helpMsg += "flags :\n";
helpMsg += " -getAttr [name.attr]\n";
helpMsg += " example : boingRb -getAttr (\"boingRb1.velocity\");\n" ;
helpMsg += "\n";
helpMsg += " -getAttr [*.attr]\n";
helpMsg += " example : boingRb -getAttr (\"*.name\");\n" ;
helpMsg += "\n";
helpMsg += " -setAttr [name.attr] -value [float float float ]\n";
helpMsg += " example : boingRb -setAttr (\"boingRb1.velocity\") -value 0 4 3 ;\n" ;
helpMsg += "\n";
helpMsg += " -addAttr [name.attr] -type [int/double/string/vector]\n";
helpMsg += " example : boingRb -addAttr \"sampleRb.IntAttribute\" -type \"int\";\n" ;
helpMsg += " example : boingRb -addAttr \"sampleRb.VectorAttribute\" -type \"vector\";\n" ;
helpMsg += "\n";
helpMsg += " -create [ ( \"name=string;geo=string;velocity/vel=float,float,float;position/pos=float,float,float\" )]\n";
helpMsg += " example : boingRb -create (\"name=sampleRb;geo=pCubeShape1;pos=0,4,0\");\n";
helpMsg += "\n";
helpMsg += " -exists [name]\n";
helpMsg += " example : boingRb -exists \"sampleRb\";\n" ;
helpMsg += "\n";
helpMsg += " -delete [name]\n";
helpMsg += " example : boingRb -delete \"sampleRb\";\n";
helpMsg += "\n";
helpMsg += "---------------------------------------------------------\n";
MGlobal::displayInfo(helpMsg);
return MS::kSuccess;
}
isSetAttr = argParser->isFlagSet("-setAttr");
isGetAttr = argParser->isFlagSet("-getAttr");
isAddAttr = argParser->isFlagSet("-addAttr");
isType = argParser->isFlagSet("-type");
isExists = argParser->isFlagSet("-exists");
isAttributeExist = argParser->isFlagSet("-attributeExist");
isCreate = argParser->isFlagSet("-create");
isDelete = argParser->isFlagSet("-delete");
isValue = argParser->isFlagSet("-value");
//std::cout<<"argsList : "<<*argsList<<std::endl;
//unsigned i;
//MStatus stat;
//MVector res;
// Parse the arguments.
/*
for (i = 0; i <argsList->length (); i++) {
//MString arg = argsList->asString(i, &stat);
//if (MS::kSuccess == stat) std::cout<<"arg["<<i<<"] : "<<arg<<std::endl;
if (
MString ("-setAttr") == argsList->asString(i, &stat) &&
MString ("-value") == argsList->asString(i+2, &stat) &&
MS::kSuccess == stat
) {
for (unsigned j=3; j!=6; ++j)
res[j-3 ] = argsList->asDouble (j, &stat);
}
}
std::cout<<"res : "<<res<<std::endl;
*/
if (isSetAttr && isValue) {
MString sAttr;
argParser->getFlagArgument("setAttr", 0, sAttr);
//std::cout<<sAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(sAttr, ".");
MString rbName = jobArgsArray[0];
MString attr = checkAttribute(jobArgsArray[1]);
//std::cout<<"attr : "<<attr<<std::endl;
if ( attr == "custom" ) {
MString customAttr = jobArgsArray[1];
//char * custAttr = (char*)customAttr.asChar();
//std::cout<<"customAttr : "<<customAttr<<std::endl;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(rbName);
//std::cout<<"data : "<<data<<std::endl;
if (!data) return MS::kFailure;
//std::cout<<"data->m_int_data : "<<data->m_int_data<<std::endl;
MString type = b_solv->getAttrType(data, customAttr);
//std::cout<<"attrype : "<<type<<std::endl;
if (type == "string") {
//std::cout<<"saving custom string : "<<customAttr<<std::endl;
MString value;
value = argsList->asString(3);
data->m_string_data.append(value);
b_solv->set_custom_data_string(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//char * chars = (char *)value.asChar();
//void * char_ptr = (void *)chars;
//b_solv->set_custom_data(customAttr, char_ptr);
} else if (type == "double") {
//std::cout<<"saving custom double : "<<customAttr<<std::endl;
double value;
value = argsList->asDouble(3);
data->m_double_data.append(value);
b_solv->set_custom_data_double(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//void *val = &value;
//b_solv->set_custom_data(customAttr, val);
} else if (type == "int") {
//std::cout<<"saving custom int : "<<customAttr<<std::endl;
int value;
value = argsList->asInt(3);
//std::cout<<"argsList->get(3, value) -> value : "<<value<<std::endl;
data->m_int_data.append(value);
b_solv->set_custom_data_int(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//std::cout<<"data->m_int_data : "<<data->m_int_data<<std::endl;
//void *val = &value;
//b_solv->set_custom_data(customAttr, val);
//std::cout<<"b_solv->set_custom_data,static_cast<void*>(&value)) DONE!!!"<<std::endl;
} else if (type == "vector") {
//std::cout<<"saving custom vector : "<<customAttr<<std::endl;
MVector value = MVector();
value.x = argsList->asDouble(3);
value.y = argsList->asDouble(4);
value.z = argsList->asDouble(5);
data->m_vector_data.append(value);
b_solv->set_custom_data_vector(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//MVector *MVecPtr = &value;
//void * vec_ptr = static_cast<void*const>(MVecPtr);
//b_solv->set_custom_data(customAttr, vec_ptr);
}
} else {
if (attr == "velocity" ||
attr == "position" ||
attr == "angularVelocity")
{
MVector value;
value.x = argsList->asDouble(3);
value.y = argsList->asDouble(4);
value.z = argsList->asDouble(5);
//std::cout<<"vector argument : "<<value<<std::endl;
setBulletVectorAttribute(rbName, attr, value);
}
}
//cout<<value<<endl;
setResult(MS::kSuccess);
} else if ( isAttributeExist ) {
MString exAttr;
bool result = false;
argParser->getFlagArgument("attributeExist", 0, exAttr);
//std::cout<<"exAttr : "<<exAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(exAttr, ".");
MString rbname = jobArgsArray[0];
//std::cout<<"rbname : "<<rbname<<std::endl;
MString attrToQuery = jobArgsArray[1];
//std::cout<<"attrToQuery : "<<attrToQuery<<std::endl;
MString attr = checkAttribute(attrToQuery);
//std::cout<<"attr : "<<attr<<std::endl;
if ( attr == "custom" ){ // here we check if user attribute by the name attrToQuery exists
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
//char * queryAttr = (char*)attrToQuery.asChar();
MString attrResult = b_solv->getAttrType(b_solv->getdata(rbname), attrToQuery);
if (attrResult != "")
//if (b_solv->attribute_exists(attrToQuery))
result = true;
//std::cout<<result<<std::endl;;
setResult(result);
}
} else if ( isAddAttr && isType ) {
MString aAttr;
argParser->getFlagArgument("addAttr", 0, aAttr);
//std::cout<<"aAttr : "<<aAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(aAttr, ".");
//std::cout<<"jobArgsArray : "<<jobArgsArray<<std::endl;
MString rbname = jobArgsArray[0];
MString attrAdded = jobArgsArray[1];
//char *added = (char *)attrAdded.asChar();
MString attrType;
argParser->getFlagArgument("-type", 0, attrType);
//char *type = (char *)attrType.asChar();
//std::cout<<"attrType : "<<attrType<<std::endl;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
data->m_attr_name.append(attrAdded);
data->m_attr_type.append(attrType);
b_solv->saveAttrType(data, attrAdded, attrType);
//std::cout<<"attr "<<aAttr<<" added"<<std::endl;
//std::cout<<"data->m_attr_type : "<<data->m_attr_type<<std::endl;
//std::cout<<"data->m_attr_name : "<<data->m_attr_name<<std::endl;
} else if ( isGetAttr) {
MString gAttr;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
argParser->getFlagArgument("getAttr", 0, gAttr);
//std::cout<<gAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(gAttr, ".");
MString rbname = jobArgsArray[0];
//std::cout<<"name : "<<rbname<<std::endl;
if ( rbname == "" ) {
MString errorMsg = "ERROR ! boing -getAttr must provide a rigid body name!";
displayWarning(errorMsg, true);
return MS::kFailure;
}
MString attr = checkAttribute(jobArgsArray[1]);
//std::cout<<"attr = "<<attr<<std::endl;
if ( attr=="velocity" || attr=="position" || attr=="angularVelocity" ) {
//MVector result =
MDoubleArray dResult = getBulletVectorAttribute(rbname, attr);
setResult(dResult);
} else if (attr == "contactPositions") {
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
MDoubleArray d_points = MDoubleArray();
if ( data->m_contact_count > 0 ) {
MPointArray points = data->m_contact_positions;
for (int i=0; i<points.length();i++) {
d_points.append(points[i].x);
d_points.append(points[i].y);
d_points.append(points[i].z);
}
}
setResult(d_points);
} else if (attr == "contactGeos") {
MStringArray contact_objects = MStringArray();
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
if ( data->m_contact_count > 0 ) {
MStringArray contact_objects = data->m_contact_objects;
}
setResult(contact_objects);
} else if (attr == "contactCount") {
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
int contact_count = data->m_contact_count;
setResult(contact_count);
} else if (attr == "name") {
MStringArray result;
MStringArray names = b_solv->get_all_keys();
//std::cout<<"names : "<<names<<std::endl;
//std::cout<<"b_solv->getdatalength() : "<<b_solv->getdatalength()<<std::endl;
for(int i=0; i < names.length(); i++) {
bSolverNode::m_custom_data *data = b_solv->getdata(names[i]);
if ( NULL != data) {
//std::cout<<"data->name : "<<data->name<<std::endl;
//std::cout<<"data->m_initial_position: "<<data->m_initial_position<<std::endl;
result.append(data->name);
}
}
setResult(result);
} else if ( attr == "" ) {
MString errorMsg = "ERROR ! boing -getAttr must provide an attribute name to query!";
displayWarning(errorMsg, true);
return MS::kFailure;
} else if ( attr == "custom" ){ // here we handle user attributes
MString customAttr = jobArgsArray[1];
//char * custAttr = (char*)customAttr.asChar();
//std::cout<<"customAttr : "<<customAttr<<std::endl;
MString type = b_solv->getAttrType(b_solv->getdata(rbname), customAttr);
//bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
std::cout<<" type : "<<type<<std::endl;
if (type == "string") {
//char * result = static_cast<char*>(b_solv->get_custom_data(customAttr));
MString result = b_solv->get_custom_data_string(b_solv->getdata(rbname), customAttr);
if (result != NULL) {
//std::cout<<"result : "<<result<<std::endl;
MString value(result);
setResult(value);
} else {
displayError(MString("Error getting b_solv->get_custom_data_string(\"" + customAttr + "\")"));
}
} else if (type == "double") {
//double *value = static_cast<double*>(b_solv->get_custom_data(customAttr));
double value = b_solv->get_custom_data_double(b_solv->getdata(rbname), customAttr);
setResult(value);
} else if (type == "int") {
//int *value = static_cast<int*>(b_solv->get_custom_data(customAttr));
int value = b_solv->get_custom_data_int(b_solv->getdata(rbname), customAttr);
setResult(value);
} else if (type == "vector") {
//void * result = b_solv->get_custom_data(customAttr);
//MVector *vec_res = (MVector*)result;
MVector result = b_solv->get_custom_data_vector(b_solv->getdata(rbname), customAttr);
MDoubleArray value;
value.append(result.x);
value.append(result.y);
value.append(result.z);
setResult(value);
}
}
} else if ( isCreate ) {
MString aArgument;
argParser->getFlagArgument("-create", 0, aArgument);
MStringArray createArgs = parseArguments(aArgument,";");
int size = createArgs.length();
MString inputShape;
MString rbname = "dummyRb";
MVector av;
MVector vel;
MVector pos;
MVector rot;
for (int i=0; i!=size; ++i) {
MStringArray singleArg = parseArguments(createArgs[i],"=");
//std::cout<<"singleArg : "<<singleArg<<std::endl;
if (singleArg[0] == "name") {
rbname = singleArg[1];
} else if (singleArg[0] == "geo") {
//geo
inputShape = singleArg[1];
//std::cout<<"geo = "<<inputShape<<std::endl;
} else if (singleArg[0] == "vel") {
//initialvelocity
MStringArray velArray = parseArguments(singleArg[1], ",");
vel = MVector(velArray[0].asDouble(),
velArray[1].asDouble(),
velArray[2].asDouble()
);
//std::cout<<"velocity = "<<vel<<std::endl;
} else if (singleArg[0] == "pos") {
//initialposition
MStringArray posArray = parseArguments(singleArg[1], ",");
pos = MVector(posArray[0].asDouble(),
posArray[1].asDouble(),
posArray[2].asDouble()
);
//std::cout<<"position = "<<pos<<std::endl;
} else if (singleArg[0] == "rot") {
//initialrotation
MStringArray rotArray = parseArguments(singleArg[1], ",");
rot = MVector(rotArray[0].asDouble(),
rotArray[1].asDouble(),
rotArray[2].asDouble()
);
//std::cout<<"rotation = "<<rot<<std::endl;
} else if (singleArg[0] == "av") {
//initialAngularVelocity
MStringArray avArray = parseArguments(singleArg[1], ",");
av = MVector(avArray[0].asDouble(),
avArray[1].asDouble(),
avArray[2].asDouble()
);
//std::cout<<"initialAngularVelocity = "<<av<<std::endl;
} else {
std::cout<<"Unrecognized parameter : "<<singleArg[0]<<std::endl;
}
}
// create boing node
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
MObject node = nameToNode(inputShape);
float mass = 1.0f;
MString tname = "boing";
MStatus stat = b_solv->createNode(node, rbname, tname, pos, vel, rot, av, mass);
if (MS::kSuccess == stat) {
setResult(rbname);
} else {
MGlobal::displayError(MString("Something went wrong when trying to create rigidbody : " + rbname + " ."));
}
} else if ( isDelete ) {
MString aArgument;
argParser->getFlagArgument("-delete", 0, aArgument);
//std::cout<<"delete aArgument "<<aArgument<<std::endl;
if (aArgument != "") {
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
b_solv->deletedata(aArgument);
MStatus stat = b_solv->delete_key(aArgument, -1);
if (stat != MS::kSuccess) {
std::cerr<<"error occurred deleting "<<aArgument<<" ."<<std::endl;
setResult(1);
}
}
} else if ( isExists ) {
MString exArg;
argParser->getFlagArgument("-exists", 0, exArg);
//std::cout<<"exArg : "<<exArg<<std::endl;
if (exArg != "") {
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(exArg);
int result = false;
if ( NULL != data ) {
//setResult ( data->name );
result = true;
}
setResult(result);
}
}
return MS::kSuccess;
}
int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self = 0;
String *gname;
int varcref = flags & CWRAP_NATURAL_VAR;
if (flags & CWRAP_SMART_POINTER) {
if (checkAttribute(n, "storage", "static")) {
Node *sn = Getattr(n, "cplus:staticbase");
String *base = Getattr(sn, "name");
self = NewStringf("%s::", base);
} else {
self = NewString("(*this)->");
}
}
if (flags & CWRAP_ALL_PROTECTED_ACCESS) {
self = NewStringf("darg->");
}
name = Getattr(n, "name");
type = Getattr(n, "type");
gname = Swig_name_get(name);
membername = Swig_name_member(classname, gname);
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t, "self");
Setattr(parms, "self", "1");
Setattr(parms, "hidden","1");
Delete(t);
ty = Swig_wrapped_member_var_type(type, varcref);
if (flags & CWRAP_EXTEND) {
String *call;
String *cres;
String *code = Getattr(n, "code");
if (code) {
/* I don't think this ever gets run - WSF */
Swig_add_extension_code(n, mangled, parms, ty, code, cparse_cplusplus, "self");
}
call = Swig_cfunction_call(mangled, parms);
cres = Swig_cresult(ty, "result", call);
Setattr(n, "wrap:action", cres);
Delete(cres);
Delete(call);
} else {
String *call = Swig_cmemberget_call(name, type, self, varcref);
String *cres = Swig_cresult(ty, "result", call);
Setattr(n, "wrap:action", cres);
Delete(call);
Delete(cres);
}
Setattr(n, "type", ty);
Setattr(n, "parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(gname);
Delete(mangled);
return SWIG_OK;
}
MStatus boingRbCmd::redoIt()
{
//MGlobal::getActiveSelectionList(m_undoSelectionList)
/*
if (argData->isFlagSet("help"))
{
MGlobal::displayInfo(MString("Tässä olisi helppi-teksti"));
return MS::kSuccess;
}*/
isSetAttr = argParser->isFlagSet("-setAttr");
isGetAttr = argParser->isFlagSet("-getAttr");
isCreate = argParser->isFlagSet("-create");
isDelete = argParser->isFlagSet("-delete");
isValue = argParser->isFlagSet("-value");
if (isSetAttr && isValue) {
MString sAttr;
//MArgList argList;
argParser->getFlagArgument("setAttr", 0, sAttr);
//cout<<sAttr<<endl;
MStringArray jobArgsArray = parseArguments(sAttr, ".");
/*
MString stringBuffer;
for (unsigned int charIdx = 0; charIdx < sAttr.numChars(); charIdx++) {
MString ch = sAttr.substringW(charIdx, charIdx);
//cout<<"ch = "<<ch<<endl;
if (ch == ".") {
if (stringBuffer.length() > 0) {
jobArgsArray.append(stringBuffer);
//cout<<"jobArgsArray = "<<jobArgsArray<<endl;
stringBuffer.clear();
}
} else {
stringBuffer += ch;
//cout<<"stringBuffer = "<<stringBuffer<<endl;
}
}
jobArgsArray.append(stringBuffer);
*/
MVector value;
argParser->getFlagArgument("-value", 0, value.x);
argParser->getFlagArgument("-value", 1, value.y);
argParser->getFlagArgument("-value", 2, value.z);
//cout<<"jobArgsArray[1] : "<<jobArgsArray[1]<<endl;
MString attr = checkAttribute(jobArgsArray[1]);
setBulletVectorAttribute(nameToNode(jobArgsArray[0]), attr, value);
//cout<<value<<endl;
setResult(MS::kSuccess);
} else if ( isGetAttr) {
MString gAttr;
argParser->getFlagArgument("getAttr", 0, gAttr);
//cout<<gAttr<<endl;
MStringArray jobArgsArray = parseArguments(gAttr, ".");
MString attr = checkAttribute(jobArgsArray[1]);
//cout<<"attr = "<<attr<<endl;
if (attr!="name") {
MVector result = getBulletVectorAttribute(nameToNode(jobArgsArray[0]), attr);
MDoubleArray dResult;
dResult.append(result.x);
dResult.append(result.y);
dResult.append(result.z);
setResult(dResult);
} else {
MStringArray result;
std::set<boingRBNode*> nodes;
//bSolverNode::getRigidBodies(result, nodes);
//solver_t *solver_t;
//shared_ptr<solver_impl_t> m_impl_t = solver_t->get_solver();
//bt_solver_t *solv = bt_solver_t;
//shared_ptr<solver_impl_t> solver = solver_t->get_solver();
//cout<<"size(m_rigid_bodies)"<<m_rigid_bodies->length()<<endl;
//btDefaultSerializer* serializer = new MySerializer(solver_t->get_solver());
//btHashMap<btHashPtr,const char*> m_nameMap;
//for(size_t i = 0; i < m_rigid_bodies.size(); ++i) {
//solver_t::remove_rigid_body(m_rigid_bodies[i]);
//cout<<"m_rigid_bodies["<<i<<"] : "<<m_rigid_bodies[i]<<endl;
//}
//cout << "rigid bodies" << endl;
//std::set<rigid_body_t::pointer>m_rigid_bodies = solver_t->get_rigid_bodies();
//btDefaultSerializer* serializer = new MySerializer(solv);
//btHashMap<btHashPtr,const char*> m_nameMap = bt_solver_t::get_m_nameMap();
//std::set<rigid_body_t::pointer>::iterator it;
//unsigned int i=0;
//for (it = m_rigid_bodies.begin(); it != m_rigid_bodies.end(); ++it) {
//rigid_body_t::pointer body = static_cast<rigid_body_t::pointer>bt_rigid_body_t::body();
//rigid_body_t::pointer body = it->get();
//bt_rigid_body_t::body();
//collision_shape_t::pointer collshape_pointer = (collision_shape_t::pointer)body->collision_shape();
//const char *namePtr = solv->m_nameMap.find(it);
// rigid_body_t::pointer m_rigid_body = it->get();
// const rigid_body_impl_t* rb = m_rigid_body->impl();
//const char*const * namePtr = solv->m_nameMap.find(rb);
// const char* namePtr = serializer->findNameForPointer(rb);
// cout<<++i<<endl;
//if (namePtr && *namePtr) {
//cout<<namePtr<<endl;
// result.append((MString) namePtr);
//} else {
// continue;
//}
//cout<<collshape_pointer<<endl;
//cout<<"pointer : " << (*)it << endl;
//const char* rbname = MySerializer::findNameForPointer(it);
//cout<<"rbname = "<<rbname<<endl;
//}
cout<<"result : "<<result<<endl;
setResult(result);
}
} else if ( isCreate ) {
MString aArgument;
argParser->getFlagArgument("-create", 0, aArgument);
MStringArray createArgs = parseArguments(aArgument,";");
int size = createArgs.length();
MString inputShape;
MString rbname = "dummyRb";
MVector vel;
MVector pos;
MVector rot;
for (int i=0; i<size; ++i) {
//cout<<"createArgs[i] = "<<createArgs[i]<<endl;
MStringArray singleArg = parseArguments(createArgs[i],"=");
cout<<"singleArg[0] : "<<singleArg[0]<<endl;
cout<<"singleArg[1] : "<<singleArg[1]<<endl;
if (singleArg[0] == "name") {
//name
rbname = singleArg[1];
cout<<"name"<<endl;
cout<<"singleArg[0] : "<<singleArg[0]<<endl;
cout<<"singleArg[1] : "<<singleArg[1]<<endl;
} else if (singleArg[0] == "geo") {
//geo
inputShape = singleArg[1];
} else if (singleArg[0] == "vel") {
//initialvelocity
MStringArray velArray = parseArguments(singleArg[1], ",");
vel = MVector(velArray[0].asDouble(),
velArray[1].asDouble(),
velArray[2].asDouble()
);
//cout<<"velocity = "<<vel<<endl;
} else if (singleArg[0] == "pos") {
//initialposition
MStringArray posArray = parseArguments(singleArg[1], ",");
pos = MVector(posArray[0].asDouble(),
posArray[1].asDouble(),
posArray[2].asDouble()
);
//cout<<"position = "<<pos<<endl;
} else if (singleArg[0] == "rot") {
//initialrotation
MStringArray rotArray = parseArguments(singleArg[1], ",");
rot = MVector(rotArray[0].asDouble(),
rotArray[1].asDouble(),
rotArray[2].asDouble()
);
//cout<<"rotation = "<<rot<<endl;
} else {
cout<<"Unrecognized parameter : "<<singleArg[0]<<endl;
}
}
// create the collisionShape-node
MObject node = nameToNode(inputShape);
collision_shape_t::pointer collShape = createCollisionShape(node);
createRigidBody(collShape, node, rbname, vel, pos, rot);
} else if ( isDelete ) {
}
return MS::kSuccess;
}
int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self = 0;
String *gname;
int varcref = flags & CWRAP_NATURAL_VAR;
if (flags & CWRAP_SMART_POINTER) {
if (checkAttribute(n, k_storage, k_static)) {
Node *sn = Getattr(n, k_cplusstaticbase);
String *base = Getattr(sn, k_name);
self = NewStringf("%s::", base);
} else {
self = NewString("(*this)->");
}
}
name = Getattr(n, k_name);
type = Getattr(n, k_type);
gname = Swig_name_get(name);
membername = Swig_name_member(classname, gname);
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t, k_self);
Setattr(parms, k_self, "1");
Setattr(parms, k_hidden, "1");
Delete(t);
ty = Swig_wrapped_member_var_type(type, varcref);
if (flags & CWRAP_EXTEND) {
String *call;
String *cres;
String *code = Getattr(n, k_code);
if (code) {
Swig_add_extension_code(n, mangled, parms, ty, code, cparse_cplusplus, k_self);
}
call = Swig_cfunction_call(mangled, parms);
cres = Swig_cresult(ty, k_result, call);
Setattr(n, k_wrapaction, cres);
Delete(cres);
Delete(call);
} else {
String *call = Swig_cmemberget_call(name, type, self, varcref);
String *cres = Swig_cresult(ty, k_result, call);
Setattr(n, k_wrapaction, cres);
Delete(call);
Delete(cres);
}
Setattr(n, k_type, ty);
Setattr(n, k_parms, parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(gname);
Delete(mangled);
return SWIG_OK;
}
static int isEmptyDataset(int _iDatasetId)
{
return checkAttribute(_iDatasetId, (char *)g_SCILAB_CLASS_EMPTY, "true");
}
