SimObject* findObject(const char* name)
{
PROFILE_SCOPE(SimFindObject);
// Play nice with bad code - JDD
if( !name )
return NULL;
SimObject *obj;
char c = *name;
if (c == '%')
{
if (gEvalState.getStackDepth())
{
Dictionary::Entry* ent = gEvalState.getCurrentFrame().lookup(StringTable->insert(name));
if (ent)
return Sim::findObject(ent->getIntValue());
}
}
if(c == '/')
return gRootGroup->findObject(name + 1 );
if(c >= '0' && c <= '9')
{
// it's an id group
const char* temp = name + 1;
for(;;)
{
c = *temp++;
if(!c)
return findObject(dAtoi(name));
else if(c == '/')
{
obj = findObject(dAtoi(name));
if(!obj)
return NULL;
return obj->findObject(temp);
}
}
}
S32 len;
for(len = 0; name[len] != 0 && name[len] != '/'; len++)
;
StringTableEntry stName = StringTable->lookupn(name, len);
if(!stName)
return NULL;
obj = gNameDictionary->find(stName);
if(!name[len])
return obj;
if(!obj)
return NULL;
return obj->findObject(name + len + 1);
}
ASMShaderParameter* ASMShader::getNamedParameter(StringTableEntry name)
{
for(U32 i = 0; i < mParameters.size(); i++)
{
if(dStricmp(mParameters[i]->mName, name) == 0)
{
return mParameters[i];
}
}
//No parameter...
const char* paramString;
ASMShaderParameter* param = NULL;
paramString = dStrstr(mVertexSourceString, name);
if(paramString)
{
param = new ASMShaderParameter;
const char* openBracket = dStrstr(paramString, "[");
const char* closeBracket = dStrstr(paramString, "]");
char* num = (char *)dMalloc((closeBracket - openBracket + 1) * sizeof(U8));
num = dStrncpy(num, openBracket + 1, (closeBracket - (openBracket + 1)));
num[(closeBracket - (openBracket + 1))] = NULL;
param->mName = StringTable->insert(name);
param->mVertexId = dAtoi(num);
const char* env = dStrstr(paramString, "program.env");
param->mVertexIsEnv = (env != NULL && env < openBracket);
param->mFragmentId = -1;
param->mFragmentIsEnv = false;
mParameters.push_back(param);
dFree(num);
}
paramString = dStrstr(mPixelSourceString, name);
if(paramString)
{
if(!param)
{
param = new ASMShaderParameter;
mParameters.push_back(param);
param->mVertexId = -1;
param->mVertexIsEnv = false;
param->mName = StringTable->insert(name);
}
const char* openBracket = dStrstr(paramString, "[");
const char* closeBracket = dStrstr(paramString, "]");
char* num = (char *)dMalloc((closeBracket - openBracket + 1) * sizeof(U8));
num = dStrncpy(num, openBracket + 1, (closeBracket - (openBracket + 1)));
num[(closeBracket - (openBracket + 1))] = NULL;
param->mFragmentId = dAtoi(num);
const char* env = dStrstr(paramString, "program.env");
param->mFragmentIsEnv = (env != NULL && env < openBracket);
dFree(num);
}
return param;
}
bool hasVersion( const char *name, const char* prefix, int major, int minor )
{
// Extension group names are compared against the version number. The prefix
// string should be "GL_VERSION" or "GLX_VERSION".. group names are
// "GL_VERSION_1_1", "GL_VERSION_1_2", "GLX_VERSION_1_2", etc.
while (*name && *prefix && *name == *prefix)
name++, prefix++;
if (*name == '_' && *prefix == '\0') {
int maj = dAtoi(++name);
while (dIsdigit(*name))
*name++;
int min = dAtoi(++name);
return versionCombine(maj,min) <= versionCombine(major,minor);
}
return false;
}
const char* RemoteCommandEvent::getTaggedString(const char* tag)
{
const char *indexPtr = tag;
if (*indexPtr == StringTagPrefixByte)
indexPtr++;
return gNetStringTable->lookupString(dAtoi(indexPtr));
}
bool Platform::stringToFileTime(const char * string, FileTime * time)
{
if(!time || !string)
return(false);
*time = dAtoi(string);
return(true);
}
bool ProjectileData::setFadeDelay( void *obj, const char *index, const char *data )
{
S32 value = dAtoi(data);
value = scaleValue(value);
ProjectileData *object = static_cast<ProjectileData*>(obj);
object->fadeDelay = value;
return false;
}
bool WaterPlane::protectedSetGridSize( void *obj, const char *index, const char *data )
{
WaterPlane *object = static_cast<WaterPlane*>(obj);
S32 size = dAtoi( data );
object->setGridSize( size );
// We already set the field.
return false;
}
bool ProjectileData::setLifetime( void *obj, const char *data )
{
S32 value = dAtoi(data);
value = scaleValue(value);
ProjectileData *object = static_cast<ProjectileData*>(obj);
object->lifetime = value;
return false;
}
S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void* b )
{
ArrayObject::Element* ea = ( ArrayObject::Element* )( a );
ArrayObject::Element* eb = ( ArrayObject::Element* )( b );
ConsoleValueRef argv[] = { smCompareFunction, ea->value, eb->value };
S32 result = dAtoi( Con::execute( 3, argv ) );
S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
return ( smDecreasing ? -res : res );
}
bool TCPObject::processArguments(S32 argc, ConsoleValueRef *argv)
{
if(argc == 0)
return true;
else if(argc == 1)
{
addToTable(U32(dAtoi(argv[0])));
return true;
}
return false;
}
bool Platform::stringToFileTime(const char * string, FileTime * time)
{
if(!time || !string)
return(false);
char buf[80];
dSprintf(buf, sizeof(buf), (char *)string);
char * sep = (char *)dStrstr((const char *)buf, (const char *)":");
if(!sep)
return(false);
*sep = 0;
sep++;
time->v2 = dAtoi(buf);
time->v1 = dAtoi(sep);
return(true);
}
const char *ProjectileData::getScaledValue( void *obj, const char *data)
{
S32 value = dAtoi(data);
value = scaleValue(value, false);
String stringData = String::ToString(value);
char *strBuffer = Con::getReturnBuffer(stringData.size());
dMemcpy( strBuffer, stringData, stringData.size() );
return strBuffer;
}
S32 QSORT_CALLBACK SimObjectList::_callbackSort( const void *a, const void *b )
{
const SimObject *objA = *reinterpret_cast<const SimObject* const*>( a );
const SimObject *objB = *reinterpret_cast<const SimObject* const*>( b );
static char idA[64];
dSprintf( idA, sizeof( idA ), "%d", objA->getId() );
static char idB[64];
dSprintf( idB, sizeof( idB ), "%d", objB->getId() );
return dAtoi( Con::executef( smSortScriptCallbackFn, idA, idB ) );
}
S32 script_simobject_getfield_int(U32 objectId, const char* fieldName)
{
SimObject *object = Sim::findObject( objectId );
if( object )
{
const char *v = object->getDataField(fieldName, "");
return dAtoi(v);
}
return false;
}
S32 QSORT_CALLBACK ArrayObject::_valueFunctionCompare( const void* a, const void* b )
{
ArrayObject::Element* ea = ( ArrayObject::Element* )( a );
ArrayObject::Element* eb = ( ArrayObject::Element* )( b );
const char* argv[ 3 ];
argv[ 0 ] = smCompareFunction;
argv[ 1 ] = ea->value;
argv[ 2 ] = eb->value;
S32 result = dAtoi( Con::execute( 3, argv ) );
S32 res = result < 0 ? -1 : ( result > 0 ? 1 : 0 );
return ( smIncreasing ? res : -res );
}
void RemoteCommandEvent::process(NetConnection *conn)
{
static char idBuf[10];
// de-tag the command name
for(S32 i = mArgc - 1; i >= 0; i--)
{
char *arg = mArgv[i+1];
if(*arg == StringTagPrefixByte)
{
// it's a tag:
U32 localTag = dAtoi(arg + 1);
NetStringHandle tag = conn->translateRemoteStringId(localTag);
NetStringTable::expandString( tag,
mBuf,
sizeof(mBuf),
(mArgc - 1) - i,
(const char**)(mArgv + i + 2) );
dFree(mArgv[i+1]);
mArgv[i+1] = dStrdup(mBuf);
}
}
const char *rmtCommandName = dStrchr(mArgv[1], ' ') + 1;
if(conn->isConnectionToServer())
{
dStrcpy(mBuf, "clientCmd");
dStrcat(mBuf, rmtCommandName);
char *temp = mArgv[1];
mArgv[1] = mBuf;
Con::execute(mArgc, (const char **) mArgv+1);
mArgv[1] = temp;
}
else
{
dStrcpy(mBuf, "serverCmd");
dStrcat(mBuf, rmtCommandName);
char *temp = mArgv[1];
dSprintf(idBuf, sizeof(idBuf), "%d", conn->getId());
mArgv[0] = mBuf;
mArgv[1] = idBuf;
Con::execute(mArgc+1, (const char **) mArgv);
mArgv[1] = temp;
}
}
void DecalRoad::onStaticModified( const char* slotName, const char*newValue )
{
Parent::onStaticModified( slotName, newValue );
/*
if ( isProperlyAdded() &&
dStricmp( slotName, "material" ) == 0 )
{
setMaskBits( DecalRoadMask );
}
*/
if ( dStricmp( slotName, "renderPriority" ) == 0 )
{
mRenderPriority = getMax( dAtoi(newValue), (S32)1 );
}
}
void script_call_namespace_entry_void(Namespace::Entry* entry, S32 argc, const char** argv)
{
// maxArgs improper on a number of console function/methods
if (argc < entry->mMinArgs)// || argc > entry->mMaxArgs)
return;
SimObject* o = NULL;
if (entry->mNamespace && entry->mNamespace->isClass())
{
Sim::findObject(dAtoi(argv[1]));
if (!o)
return;
}
StringStackConsoleWrapper args(argc, argv);
entry->cb.mVoidCallbackFunc(o, args.count(), args);
}
void TSStatic::setSkinName( const char *name )
{
if ( !isGhost() )
{
if ( name[0] != '\0' )
{
// Use tags for better network performance
// Should be a tag, but we'll convert to one if it isn't.
if ( name[0] == StringTagPrefixByte )
mSkinNameHandle = NetStringHandle( U32(dAtoi(name + 1)) );
else
mSkinNameHandle = NetStringHandle( name );
}
else
mSkinNameHandle = NetStringHandle();
setMaskBits( SkinMask );
}
}
RemoteCommandEvent::RemoteCommandEvent(S32 argc, const char **argv, NetConnection *conn)
{
mArgc = argc;
for(S32 i = 0; i < argc; i++)
{
if(argv[i][0] == StringTagPrefixByte)
{
char buffer[256];
mTagv[i+1] = NetStringHandle(dAtoi(argv[i]+1));
if(conn)
{
dSprintf(buffer + 1, sizeof(buffer) - 1, "%d", conn->getNetSendId(mTagv[i+1]));
buffer[0] = StringTagPrefixByte;
mArgv[i+1] = dStrdup(buffer);
}
}
else
mArgv[i+1] = dStrdup(argv[i]);
}
}
void Win32WindowManager::_processCmdLineArgs( const S32 argc, const char **argv )
{
if (argc > 1)
{
for (S32 i = 1; i < argc; i++)
{
if ( dStrnicmp( argv[i], "-window", 7 ) == 0 )
{
i++;
if ( i >= argc )
{
Con::errorf( "Command line error: -window requires an argument" );
break;
}
S32 hwnd = dAtoi( argv[i] );
if ( hwnd == 0 || hwnd == S32_MAX )
{
Con::errorf( "Command line error: -window requires a number, found [%s]", argv[i] );
break;
}
mParentWindow = (HWND)hwnd;
Con::printf( "HWND from command line: %d", hwnd );
}
if ( dStrnicmp( argv[i], "-offscreen", 10 ) == 0 )
{
mOffscreenRender = true;
}
}
}
}
{
addField("columns", TypeS32Vector, Offset(mColumnOffsets, GuiFrameSetCtrl));
addField("rows", TypeS32Vector, Offset(mRowOffsets, GuiFrameSetCtrl));
addField("borderWidth", TypeS32, Offset(mFramesetDetails.mBorderWidth, GuiFrameSetCtrl));
addField("borderColor", TypeColorI, Offset(mFramesetDetails.mBorderColor, GuiFrameSetCtrl));
addField("borderEnable", TypeEnum, Offset(mFramesetDetails.mBorderEnable, GuiFrameSetCtrl), 1, &gBorderStateTable);
addField("borderMovable", TypeEnum, Offset(mFramesetDetails.mBorderMovable, GuiFrameSetCtrl), 1, &gBorderStateTable);
addField("autoBalance", TypeBool, Offset(mAutoBalance, GuiFrameSetCtrl));
addField("fudgeFactor", TypeS32, Offset(mFudgeFactor, GuiFrameSetCtrl));
Parent::initPersistFields();
}
//-----------------------------------------------------------------------------
ConsoleMethod( GuiFrameSetCtrl, frameBorder, void, 3, 4, "(int index, bool enable=true)")
{
S32 index = dAtoi(argv[2]);
if (argc == 3)
object->frameBorderEnable(index);
else
object->frameBorderEnable(index, argv[3]);
}
ConsoleMethod( GuiFrameSetCtrl, frameMovable, void, 3, 4, "(int index, bool enable=true)" )
{
S32 index = dAtoi(argv[2]);
if (argc == 3)
object->frameBorderMovable(index);
else
object->frameBorderMovable(index, argv[3]);
}
bool Net::stringToAddress(const char *addressString, NetAddress *address)
{
if(!dStrnicmp(addressString, "ipx:", 4))
// ipx support deprecated
return false;
if(!dStrnicmp(addressString, "ip:", 3))
addressString += 3; // eat off the ip:
sockaddr_in ipAddr;
char remoteAddr[256];
if(strlen(addressString) > 255)
return false;
dStrcpy(remoteAddr, addressString);
char *portString = dStrchr(remoteAddr, ':');
if(portString)
*portString++ = '\0';
if(!dStricmp(remoteAddr, "broadcast"))
ipAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
else
{
ipAddr.sin_addr.s_addr = inet_addr(remoteAddr);
if (ipAddr.sin_addr.s_addr == INADDR_NONE) // error
{
// On the Xbox, 'gethostbyname' does not exist so...
#ifndef TORQUE_OS_XENON
struct hostent *hp;
if((hp = gethostbyname(remoteAddr)) == 0)
return false;
else
memcpy(&ipAddr.sin_addr.s_addr, hp->h_addr, sizeof(in_addr));
#else
// On the Xbox do XNetDnsLookup
XNDNS *pxndns = NULL;
HANDLE hEvent = CreateEvent(NULL, false, false, NULL);
XNetDnsLookup(remoteAddr, hEvent, &pxndns);
// Wait for event (passing NULL as a handle to XNetDnsLookup will NOT
// cause it to behave synchronously, so do not remove the handle/wait
while(pxndns->iStatus == WSAEINPROGRESS)
WaitForSingleObject(hEvent, INFINITE);
bool foundAddr = pxndns->iStatus == 0 && pxndns->cina > 0;
if(foundAddr)
{
// Lets just grab the first address returned, for now
memcpy(&ipAddr.sin_addr, pxndns->aina, sizeof(IN_ADDR));
}
XNetDnsRelease(pxndns);
CloseHandle(hEvent);
// If we didn't successfully resolve the DNS lookup, bail after the
// handles are released
if(!foundAddr)
return false;
#endif
}
}
if(portString)
ipAddr.sin_port = htons(dAtoi(portString));
else
ipAddr.sin_port = htons(defaultPort);
ipAddr.sin_family = AF_INET;
IPSocketToNetAddress(&ipAddr, address);
return true;
}
NetSocket Net::openConnectTo(const char *addressString)
{
if(!dStrnicmp(addressString, "ipx:", 4))
// ipx support deprecated
return InvalidSocket;
if(!dStrnicmp(addressString, "ip:", 3))
addressString += 3; // eat off the ip:
char remoteAddr[256];
dStrcpy(remoteAddr, addressString);
char *portString = dStrchr(remoteAddr, ':');
U16 port;
if(portString)
{
*portString++ = 0;
port = htons(dAtoi(portString));
}
else
port = htons(defaultPort);
if(!dStricmp(remoteAddr, "broadcast"))
return InvalidSocket;
if(Journal::IsPlaying())
{
U32 ret;
Journal::Read(&ret);
return NetSocket(ret);
}
NetSocket sock = openSocket();
setBlocking(sock, false);
sockaddr_in ipAddr;
dMemset(&ipAddr, 0, sizeof(ipAddr));
ipAddr.sin_addr.s_addr = inet_addr(remoteAddr);
if(ipAddr.sin_addr.s_addr != INADDR_NONE)
{
ipAddr.sin_port = port;
ipAddr.sin_family = AF_INET;
if(::connect(sock, (struct sockaddr *)&ipAddr, sizeof(ipAddr)) == -1)
{
S32 err = getLastError();
if(err != Net::WouldBlock)
{
Con::errorf("Error connecting %s: %s",
addressString, strerror(err));
::closesocket(sock);
sock = InvalidSocket;
}
}
if(sock != InvalidSocket)
{
// add this socket to our list of polled sockets
addPolledSocket(sock, ConnectionPending);
}
}
else
{
// need to do an asynchronous name lookup. first, add the socket
// to the polled list
addPolledSocket(sock, NameLookupRequired, remoteAddr, port);
// queue the lookup
gNetAsync.queueLookup(remoteAddr, sock);
}
if(Journal::IsRecording())
Journal::Write(U32(sock));
return sock;
}
#include "T3D/shapeBase.h"
#include "T3D/gameProcess.h"
#include "renderInstance/renderPassManager.h"
IMPLEMENT_CONOBJECT(Explosion);
#define MaxLightRadius 20
MRandomLCG sgRandom(0xdeadbeef);
ConsoleFunction( calcExplosionCoverage, F32, 4, 4, "(Point3F source, SceneObject originator, bitset coverageMask)")
{
Point3F pos, center;
dSscanf(argv[1], "%f %f %f", &pos.x, &pos.y, &pos.z);
S32 id = dAtoi(argv[2]);
U32 covMask = (U32)dAtoi(argv[3]);
SceneObject* sceneObject = NULL;
if (Sim::findObject(id, sceneObject) == false) {
Con::warnf(ConsoleLogEntry::General, "calcExplosionCoverage: couldn't find object: %s", argv[2]);
return 1.0f;
}
if (sceneObject->isClientObject() || sceneObject->getContainer() == NULL) {
Con::warnf(ConsoleLogEntry::General, "calcExplosionCoverage: object is on the client, or not in the container system");
return 1.0f;
}
sceneObject->getObjBox().getCenter(¢er);
center.convolve(sceneObject->getScale());
sceneObject->getTransform().mulP(center);
"file is too small. Did you maybe export as 8bit RAW intead of 16bit raw?"
" Or maybe size of RAW is not pow2+1? (ie, 257 instead of 256, 4097 instead of 4096)");
*cur = F32(h) / 16.0;
cur++;
}
return true;
}
};
ConsoleFunction(atlasGenerateGeometryFromHeightfield, void, 6, 6,
"(atlasOutFile, inHeightfield, hfSize, gridSpacing, patchSize) - generate terrain geometry "
"to atlasOutFile based on the heightfield.")
{
const U32 hfSize = dAtoi(argv[3]);
const F32 gridSpacing = dAtof(argv[4]);
const U32 tileSize = dAtoi(argv[5]);
// Caculate treeDepth...
const S32 treeDepth = getBinLog2(hfSize/tileSize)+1;
Con::errorf("***************************************************************");
Con::errorf("");
Con::errorf("BE AWARE - THIS FUNCTION IS STILL IN DEVELOPMENT AND WILL NOT GIVE USEFUL RESULTS.");
Con::errorf("PLEASE USE THE atlasOldGenerateChunkFileFromRaw16 method AND importOldAtlasCHU");
Con::errorf("TO GENERATE GEOMETRY FOR NOW.");
Con::errorf("");
Con::errorf("Now generating geometry...");
Con::errorf("");
Con::errorf("***************************************************************");
SimObject *SimObjectMemento::restore() const
{
// Make sure we have data to restore.
if ( !mState )
return NULL;
// TODO: We could potentially make this faster by
// caching the CodeBlock generated from the string
SimObject* object;
if( !mIsDatablock )
{
// Set the redefine behavior to automatically giving
// the new objects unique names. This will restore the
// old names if they are still available or give reasonable
// approximations if not.
const char* oldRedefineBehavior = Con::getVariable( "$Con::redefineBehavior" );
Con::setVariable( "$Con::redefineBehavior", "renameNew" );
// Read the object.
const UTF8* result = Con::evaluate( mState );
// Restore the redefine behavior.
Con::setVariable( "$Con::redefineBehavior", oldRedefineBehavior );
if ( !result || !result[ 0 ] )
return NULL;
// Look up the object.
U32 objectId = dAtoi( result );
object = Sim::findObject( objectId );
}
else
{
String objectName = mObjectName;
// For datablocks, it's getting a little complicated. Datablock definitions cannot be used
// as expressions and thus we can't get to the datablock object we create by using the
// Con::evaluate() return value. Instead, we need to rely on the object name. However, if
// the name is already taken and needs to be changed, we need to manually do that. To complicate
// this further, we cannot rely on automatic renaming since then we don't know by what name
// the newly created object actually goes. So what we do is we alter the source text snapshot
// and substitute a name in case the old object name is actually taken now.
char* tempBuffer;
if( !Sim::findObject( objectName ) )
tempBuffer = mState;
else
{
String uniqueName = Sim::getUniqueName( objectName );
U32 uniqueNameLen = uniqueName.length();
char* pLeftParen = dStrchr( mState, '(' );
if( pLeftParen == NULL )
return NULL;
U32 numCharsToLeftParen = pLeftParen - mState;
tempBuffer = ( char* ) dMalloc( dStrlen( mState ) + uniqueNameLen + 1 );
dMemcpy( tempBuffer, mState, numCharsToLeftParen );
dMemcpy( &tempBuffer[ numCharsToLeftParen ], uniqueName, uniqueNameLen );
dStrcpy( &tempBuffer[ numCharsToLeftParen + uniqueNameLen ], &mState[ numCharsToLeftParen ] );
}
Con::evaluate( tempBuffer );
if( tempBuffer != mState )
dFree( tempBuffer );
if( objectName == String::EmptyString )
return NULL;
object = Sim::findObject( objectName );
}
return object;
}
// The first one is the top of the stack.
//
// COUT console-output - echo of console output from engine
//
// BRKMOV file line newline - sent when a breakpoint is moved to a breakable line.
//
// BRKCLR file line - sent when a breakpoint cannot be moved to a breakable line on the client.
//
ConsoleFunction( dbgSetParameters, void, 3, 4, "(int port, string password, bool waitForClient)"
"Open a debug server port on the specified port, requiring the specified password, "
"and optionally waiting for the debug client to connect.")
{
if (TelDebugger)
TelDebugger->setDebugParameters(dAtoi(argv[1]), argv[2], argc > 3 ? dAtob(argv[3]) : false );
}
ConsoleFunction( dbgIsConnected, bool, 1, 1, "()"
"Returns true if a script debugging client is connected else return false.")
{
return TelDebugger && TelDebugger->isConnected();
}
ConsoleFunction( dbgDisconnect, void, 1, 1, "()"
"Forcibly disconnects any attached script debugging client.")
{
if (TelDebugger)
TelDebugger->disconnect();
}
}
//------------------------------------------------------------------------------
static GameBase * getControlObj()
{
GameConnection * connection = GameConnection::getLocalClientConnection();
ShapeBase* control = 0;
if(connection)
control = dynamic_cast<ShapeBase*>(connection->getControlObject());
return(control);
}
ConsoleMethod( EditManager, setBookmark, void, 3, 3, "(int slot)")
{
S32 val = dAtoi(argv[2]);
if(val < 0 || val > 9)
return;
GameBase * control = getControlObj();
if(control)
object->mBookmarks[val] = control->getTransform();
}
ConsoleMethod( EditManager, gotoBookmark, void, 3, 3, "(int slot)")
{
S32 val = dAtoi(argv[2]);
if(val < 0 || val > 9)
return;
GameBase * control = getControlObj();
addField("CallbackOnY", TypeString, Offset(mCallbackOnY, GuiGameListMenuCtrl));
Parent::initPersistFields();
}
ConsoleMethod(GuiGameListMenuCtrl, addRow, void, 4, 8,
"(string label, string callback, int icon, int yPad, bool enabled)\n"
"Add a row to the list control.\n\n"
"\\param label The text to display on the row as a label.\n"
"\\param callback Name of a script function to use as a callback when this row is activated.\n"
"\\param icon [optional] Index of the icon to use as a marker.\n"
"\\param yPad [optional] An extra amount of height padding before the row. Does nothing on the first row.\n"
"\\param useHighlightIcon [optional] Does this row use the highlight icon?.\n"
"\\param enabled [optional] If this row is initially enabled.")
{
object->addRow(argv[2], argv[3], argc > 4 ? dAtoi(argv[4]) : -1, argc > 5 ? dAtoi(argv[5]) : 0, argc > 6 ? dAtob(argv[6]) : true, argc > 7 ? dAtob(argv[7]) : true);
}
ConsoleMethod(GuiGameListMenuCtrl, isRowEnabled, bool, 3, 3,
"(int row)\n"
"Determines if the specified row is enabled or disabled.\n\n"
"\\param row The row to set the enabled status of.\n"
"\\return (bool) True if the specified row is enabled. False if the row is not enabled or the given index was not valid.")
{
return object->isRowEnabled(dAtoi(argv[2]));
}
ConsoleMethod(GuiGameListMenuCtrl, setRowEnabled, void, 4, 4,
"(int row, bool enabled)\n"
"Sets a row's enabled status according to the given parameters.\n\n"
"\\param row The index to check for validity.\n"
