void ConsoleObject::addProtectedField(const char* in_pFieldname,
const U32 in_fieldType,
const dsize_t in_fieldOffset,
AbstractClassRep::SetDataNotify in_setDataFn,
AbstractClassRep::GetDataNotify in_getDataFn,
const U32 in_elementCount,
const char* in_pFieldDocs,
U32 flags )
{
AbstractClassRep::Field f;
f.pFieldname = StringTable->insert(in_pFieldname);
if(in_pFieldDocs)
f.pFieldDocs = in_pFieldDocs;
f.type = in_fieldType;
f.offset = in_fieldOffset;
f.elementCount = in_elementCount;
f.validator = NULL;
f.flag = flags;
f.setDataFn = in_setDataFn;
f.getDataFn = in_getDataFn;
ConsoleBaseType* conType = ConsoleBaseType::getType( in_fieldType );
AssertFatal( conType, "ConsoleObject::addProtectedField - invalid console type" );
f.table = conType->getEnumTable();
sg_tempFieldList.push_back(f);
}
void GuiInspectorDynamicField::_executeSelectedCallback()
{
ConsoleBaseType* type = mDynField->type;
if ( type )
{ mInspector->onFieldSelected_callback( mDynField->slotName, type->getTypeName(), "" ); }
else
{ mInspector->onFieldSelected_callback( mDynField->slotName, "TypeDynamicField", "" ); }
}
static void dumpClassMember( Stream &stream,
const AbstractClassRep::Field& field )
{
stream.writeText( "/*!\r\n" );
if( field.pFieldDocs && field.pFieldDocs[ 0 ] )
{
stream.writeText( "@brief " );
String docs( field.pFieldDocs );
S32 newline = docs.find( '\n' );
if( newline == -1 )
stream.writeText( field.pFieldDocs );
else
{
String brief = docs.substr( 0, newline );
String body = docs.substr( newline + 1 );
stream.writeText( brief );
stream.writeText( "\r\n\r\n" );
stream.writeText( body );
}
stream.writeText( "\r\n" );
}
const bool isDeprecated = ( field.type == AbstractClassRep::DeprecatedFieldType );
if( isDeprecated )
stream.writeText( "@deprecated This member is deprecated and its value is always undefined.\r\n" );
stream.writeText( "*/\r\n" );
ConsoleBaseType* cbt = ConsoleBaseType::getType( field.type );
const char* type = ( cbt ? cbt->getTypeClassName() : "" );
if( field.elementCount > 1 )
stream.writeText( String::ToString( "%s %s[ %i ];\r\n", isDeprecated ? "deprecated" : type, field.pFieldname, field.elementCount ) );
else
stream.writeText( String::ToString( "%s %s;\r\n", isDeprecated ? "deprecated" : type, field.pFieldname ) );
}
const char *getFormattedData(S32 type, const char *data, const EnumTable *tbl, BitSet32 flag)
{
ConsoleBaseType *cbt = ConsoleBaseType::getType( type );
AssertFatal(cbt, "Con::getData - could not resolve type ID!");
// Datablock types are just a datablock
// name and don't ever need formatting.
if ( cbt->isDatablock() )
return data;
bool currWarn = gWarnUndefinedScriptVariables;
gWarnUndefinedScriptVariables = false;
const char* globalValue = Con::getVariable(data);
gWarnUndefinedScriptVariables = currWarn;
if (dStrlen(globalValue) > 0)
return globalValue;
void* variable = cbt->getNativeVariable();
if (variable)
{
Con::setData(type, variable, 0, 1, &data, tbl, flag);
const char* formattedVal = Con::getData(type, variable, 0, tbl, flag);
static const U32 bufSize = 2048;
char* returnBuffer = Con::getReturnBuffer(bufSize);
dSprintf(returnBuffer, bufSize, "%s\0", formattedVal );
cbt->deleteNativeVariable(variable);
return returnBuffer;
}
else
return data;
}
void XMLExport::exportBaseTypes()
{
mXML->pushNewElement("BaseTypes");
ConsoleBaseType *walk = ConsoleBaseType::getListHead();
while( walk != NULL )
{
mXML->pushNewElement("BaseType");
mXML->setAttribute("name", walk->getTypeName());
mXML->setAttribute("id", avar("%i",walk->getTypeID()));
mXML->setAttribute("size", avar("%i",walk->getTypeSize()));
mXML->setAttribute("doc", walk->getDocString() ? walk->getDocString() : "" );
mXML->popElement(); // Basetype
walk = walk->getListNext();
}
mXML->popElement(); // Basetypes
}
// -----------------------------------------------------------------------------
// Set attribute of top stack element to given value.
// -----------------------------------------------------------------------------
void SimXMLDocument::setObjectAttributes(const char* objectID)
{
if( !objectID || !objectID[0] )
return;
if(m_paNode.empty())
return;
SimObject *pObject = Sim::findObject( objectID );
if( pObject == NULL )
return;
const int iLastElement = m_paNode.size() - 1;
TiXmlElement* pElement = m_paNode[iLastElement];
if(!pElement)
return;
char textbuf[1024];
TiXmlElement field( "Field" );
TiXmlElement group( "FieldGroup" );
pElement->SetAttribute( "Name", pObject->getName() );
// Iterate over our filed list and add them to the XML document...
AbstractClassRep::FieldList fieldList = pObject->getFieldList();
AbstractClassRep::FieldList::iterator itr;
for(itr = fieldList.begin(); itr != fieldList.end(); itr++)
{
if( itr->type == AbstractClassRep::DepricatedFieldType ||
itr->type == AbstractClassRep::StartGroupFieldType ||
itr->type == AbstractClassRep::EndGroupFieldType) continue;
// Not an Array
if(itr->elementCount == 1)
{
// get the value of the field as a string.
ConsoleBaseType *cbt = ConsoleBaseType::getType(itr->type);
const char *val = Con::getData(itr->type, (void *) (((const char *)pObject) + itr->offset), 0, itr->table, itr->flag);
// Make a copy for the field check.
if (!val)
continue;
FrameTemp<char> valCopy( dStrlen( val ) + 1 );
dStrcpy( (char *)valCopy, val );
if (!pObject->writeField(itr->pFieldname, valCopy))
continue;
val = valCopy;
expandEscape(textbuf, val);
if( !pObject->writeField( itr->pFieldname, textbuf ) )
continue;
field.SetValue( "Property" );
field.SetAttribute( "name", itr->pFieldname );
if( cbt != NULL )
field.SetAttribute( "type", cbt->getTypeName() );
else
field.SetAttribute( "type", "TypeString" );
field.SetAttribute( "data", textbuf );
pElement->InsertEndChild( field );
continue;
}
}
//// IS An Array
//for(U32 j = 0; S32(j) < f->elementCount; j++)
//{
// // If the start of a group create an element for the group and
// // the our chache to it
// const char *val = Con::getData(itr->type, (void *) (((const char *)pObject) + itr->offset), j, itr->table, itr->flag);
// // Make a copy for the field check.
// if (!val)
// continue;
// FrameTemp<char> valCopy( dStrlen( val ) + 1 );
// dStrcpy( (char *)valCopy, val );
// if (!pObject->writeField(itr->pFieldname, valCopy))
// continue;
// val = valCopy;
// // get the value of the field as a string.
// ConsoleBaseType *cbt = ConsoleBaseType::getType(itr->type);
// const char * dstr = Con::getData(itr->type, (void *)(((const char *)pObject) + itr->offset), 0, itr->table, itr->flag);
// if(!dstr)
// dstr = "";
// expandEscape(textbuf, dstr);
// if( !pObject->writeField( itr->pFieldname, dstr ) )
// continue;
// field.SetValue( "Property" );
// field.SetAttribute( "name", itr->pFieldname );
// if( cbt != NULL )
// field.SetAttribute( "type", cbt->getTypeName() );
// else
// field.SetAttribute( "type", "TypeString" );
// field.SetAttribute( "data", textbuf );
// pElement->InsertEndChild( field );
//}
}
GuiInspectorField* GuiInspectorGroup::constructField( S32 fieldType )
{
// See if we can construct a field of this type
ConsoleBaseType *cbt = ConsoleBaseType::getType(fieldType);
if( !cbt )
return NULL;
// Alright, is it a datablock?
if(cbt->isDatablock())
{
// Default to GameBaseData
StringTableEntry typeClassName = cbt->getTypeClassName();
if( mParent->getNumInspectObjects() == 1 && !dStricmp(typeClassName, "GameBaseData") )
{
// Try and setup the classname based on the object type
char className[256];
dSprintf(className,256,"%sData", mParent->getInspectObject( 0 )->getClassName());
// Walk the ACR list and find a matching class if any.
AbstractClassRep *walk = AbstractClassRep::getClassList();
while(walk)
{
if(!dStricmp(walk->getClassName(), className))
break;
walk = walk->getNextClass();
}
// We found a valid class
if (walk)
typeClassName = walk->getClassName();
}
GuiInspectorDatablockField *dbFieldClass = new GuiInspectorDatablockField( typeClassName );
if( dbFieldClass != NULL )
{
// return our new datablock field with correct datablock type enumeration info
return dbFieldClass;
}
}
// Nope, not a datablock. So maybe it has a valid inspector field override we can use?
if(!cbt->getInspectorFieldType())
// Nothing, so bail.
return NULL;
// Otherwise try to make it!
ConsoleObject *co = create(cbt->getInspectorFieldType());
GuiInspectorField *gif = dynamic_cast<GuiInspectorField*>(co);
if(!gif)
{
// Wasn't appropriate type, bail.
delete co;
return NULL;
}
return gif;
}
static void dumpVariable( Stream& stream,
Dictionary::Entry* entry,
const char* inClass = NULL )
{
// Skip variables defined in script.
if( entry->type < 0 )
return;
// Skip internals... don't export them.
if ( entry->mUsage &&
( dStrstr( entry->mUsage, "@hide" ) || dStrstr( entry->mUsage, "@internal" ) ) )
return;
// Split up qualified name.
Vector< String > nameComponents;
String( entry->name ).split( "::", nameComponents );
if( !nameComponents.size() ) // Safety check.
return;
// Match filter.
if( inClass )
{
// Make sure first qualifier in name components is a
// namespace qualifier matching the given class name.
if( nameComponents.size() <= 1 || dStricmp( nameComponents.first().c_str() + 1, inClass ) != 0 ) // Skip '$'.
return;
}
else
{
// Make sure, this is *not* in a class namespace.
if( nameComponents.size() > 1 && Con::lookupNamespace( nameComponents.first().c_str() + 1 )->mClassRep )
return;
}
// Skip variables for which we can't decipher their type.
ConsoleBaseType* type = ConsoleBaseType::getType( entry->type );
if( !type )
{
Con::errorf( "Can't find type for variable '%s'", entry->name );
return;
}
// Write doc comment.
stream.writeText( "/*!\r\n" );
if( !inClass )
{
stream.writeText( "@var " );
stream.writeText( type->getTypeClassName() );
stream.writeText( " " );
stream.writeText( entry->name );
stream.writeText( ";\r\n" );
}
dumpDoc( stream, entry->mUsage );
stream.writeText( "*/\r\n" );
// Write definition.
const U32 numNameComponents = nameComponents.size();
if( !inClass && numNameComponents > 1 )
for( U32 i = 0; i < ( numNameComponents - 1 ); ++ i )
{
stream.writeText( "namespace " );
stream.writeText( nameComponents[ i ] );
stream.writeText( " { " );
}
if( inClass )
stream.writeText( "static " );
if( entry->mIsConstant )
stream.writeText( "const " );
stream.writeText( type->getTypeClassName() );
stream.writeText( " " );
stream.writeText( nameComponents.last() );
stream.writeText( ";" );
if( !inClass && numNameComponents > 1 )
for( U32 i = 0; i < ( numNameComponents - 1 ); ++ i )
stream.writeText( " } " );
stream.writeText( "\r\n" );
}
const char *getData(S32 type, void *dptr, S32 index, const EnumTable *tbl, BitSet32 flag)
{
ConsoleBaseType *cbt = ConsoleBaseType::getType(type);
AssertFatal(cbt, "Con::getData - could not resolve type ID!");
return cbt->getData((void *) (((const char *)dptr) + index * cbt->getTypeSize()), tbl, flag);
}
