QList<QpMetaProperty> QpMetaObject::relationProperties() const
{
if (data->metaProperties.isEmpty()) {
initProperties();
}
return data->relationProperties;
}
void CObjectPropertyPanel::setObject(int t_index)
{
CObject* a_objectPtr = 0;
if(CDataStorage::getInstance().m_objects.size() > 0)
{
m_selectedObjectIndex = t_index;
a_objectPtr = CDataStorage::getInstance().m_objects[t_index];
//////////////////////////////////////////////////////////////////////////
// append object properties
initProperties();
fillPropertyGrid();
//////////////////////////////////////////////////////////////////////////
// append texture keys
m_listTextureKeys->Clear();
std::vector<std::string>::iterator a_it;
for(a_it = a_objectPtr->m_textureKeys.begin(); a_it != a_objectPtr->m_textureKeys.end(); a_it++)
{
m_listTextureKeys->Append((*a_it));
}
}
}
bool EQModSimulator::updateProperties(bool enable)
{
if (enable)
{
initProperties();
telescope->defineSwitch(SimModeSP);
telescope->defineNumber(SimWormNP);
telescope->defineNumber(SimRatioNP);
telescope->defineNumber(SimMotorNP);
telescope->defineSwitch(SimHighSpeedSP);
telescope->defineText(SimMCVersionTP);
/*
AlignDataFileTP=telescope->getText("ALIGNDATAFILE");
AlignDataBP=telescope->getBLOB("ALIGNDATA");
*/
} else {
telescope->deleteProperty(SimModeSP->name);
telescope->deleteProperty(SimWormNP->name);
telescope->deleteProperty(SimRatioNP->name);
telescope->deleteProperty(SimMotorNP->name);
telescope->deleteProperty(SimHighSpeedSP->name);
telescope->deleteProperty(SimMCVersionTP->name);
}
return true;
}
QList<QpMetaProperty> QpMetaObject::simpleProperties() const
{
if (data->metaProperties.isEmpty()) {
initProperties();
}
return data->simpleProperties;
}
QList<QpMetaProperty> QpMetaObject::calculatedProperties() const
{
if (data->metaProperties.isEmpty()) {
initProperties();
}
return data->calculatedProperties;
}
/// \param effectDef XML tag containing the effect definition
ParticleEffect::ParticleEffect(TiXmlElement *effectDef)
{
// assign defaults
m_nTotalParticleCount = 0;
m_bCycleParticles = true;
m_bIsDead = false;
m_IsDying = false;
m_nLiveParticleCount = 0;
m_fEmitPartial = 1.0f; // start with at least one particle
m_vecGravity = Vector3::kZeroVector;
m_vecPosition = Vector3::kZeroVector;
m_txtParticleTexture = NULL;
m_UpdateFunc.clear();
m_InitFunc.clear();
m_fPILife = 1.0f;
m_fPISpeed = 100.0f;
m_fPIDragValue = 0.0f;
m_PIFadeIn = 0.0f;
m_PIFadeOut = 1.0f;
m_PIFadeMax = 1.0f;
m_PIRotationSpeed = 0.0f;
m_PIRotationStopTime = 0.0f;
m_distFunc = NULL;
// default emit rate is all at once (or at least all in the first .01 secs)
m_nEmitRate = m_nTotalParticleCount * 100;
m_sort = false;
m_vertBuffer = NULL;
m_indexBuffer = NULL;
// get system data
effectDef->Attribute("particleCount", &m_nTotalParticleCount);
const char *filename = effectDef->Attribute("textureName");
// initialize effect properties from the xml tag
initProperties(effectDef);
// allocate memory needed
m_Particles = new Particle[m_nTotalParticleCount];
m_drawOrder = new int[m_nTotalParticleCount];
initParticles();
// create vertex and index buffers, and initialize index buffer. We can
// create the index buffer as static since it doesn't change values; this
// will increase performance a little.
m_vertBuffer = new VertexLBuffer(m_nTotalParticleCount * 4, true);
m_indexBuffer = new IndexBuffer(m_nTotalParticleCount * 2);
initIndexBuffer();
// this should be replaced with the renderer version of loading a texture
gDirectoryManager.setDirectory(eDirectoryTextures);
D3DXIMAGE_INFO structImageInfo; //image information
HRESULT hres=D3DXCreateTextureFromFileEx(pD3DDevice, filename,
0,0,1,0,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,D3DX_FILTER_NONE,
D3DX_DEFAULT,0,&structImageInfo,NULL, &m_txtParticleTexture);
}
void
Init_rpmte(void)
{
rpmteClass = rb_define_class("Te", rb_cObject);
if (_debug)
fprintf(stderr, "==> %s() rpmteClass 0x%lx\n", __FUNCTION__, rpmteClass);
rb_define_alloc_func(rpmteClass, rpmte_alloc);
initProperties(rpmteClass);
initMethods(rpmteClass);
}
Caches::Caches(): Singleton<Caches>(), mInitialized(false) {
init();
initFont();
initExtensions();
initConstraints();
initProperties();
mDebugLevel = readDebugLevel();
ALOGD("Enabling debug mode %d", mDebugLevel);
}
void AFPSGWeapon::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
Super::PostEditChangeProperty(PropertyChangedEvent);
initProperties();
if (GEngine != NULL)
{
//GEngine->AddOnScreenDebugMessage(-1, 6.f, FColor::Blue, TEXT("AFPSGWeapon::PostEditChangeProperty(): ") + getWeaponName() + TEXT(": ") + FString::FromInt(getCurrentAmmunition()));
}
}
void AFPSGCharacter::PostInitProperties()
{
Super::PostInitProperties();
if (GEngine != NULL)
{
//GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Black, TEXT("AFPSGCharacter::PostInitProperties"));
}
initProperties();
}
int main( int argc, char *argv[] ) {
if ( argc != 4 ) throwError("Please enter the correct arguments...\nFormat: ./progName templateFile variableFile outputFile");
Properties documentProperties;
initProperties (&documentProperties, argv);
setToHash (&documentProperties);
interpretTemp (&documentProperties);
printDocumentProperties (documentProperties);
}
cSimpleFusion::cSimpleFusion(const tChar* __info) : adtf::cFilter(__info)
{
m_nLastMSTime = 0;
ir_short_iterations = 1;
ir_long_iterations = 1;
sigma_iterations = 0;
median = 0;
initProperties();
}
void
Init_rpmmi(void)
{
rpmmiClass = rb_define_class("Mi", rb_cObject);
if (_debug)
fprintf(stderr, "==> %s() rpmmiClass 0x%lx\n", __FUNCTION__, rpmmiClass);
rb_include_module(rpmmiClass, rb_mEnumerable);
rb_define_singleton_method(rpmmiClass, "new", rpmmi_new, -1);
initProperties(rpmmiClass);
initMethods(rpmmiClass);
}
/* --- Class initialization */
void
Init_rpmhdr(void)
{
rpmhdrClass = rb_define_class("Hdr", rb_cObject);
if (_debug)
fprintf(stderr, "==> %s() rpmhdrClass 0x%lx\n", __FUNCTION__, rpmhdrClass);
#ifdef NOTYET
rb_include_module(rpmhdrClass, rb_mEnumerable);
#endif
rb_define_singleton_method(rpmhdrClass, "new", rpmhdr_new, -1);
initProperties(rpmhdrClass);
initMethods(rpmhdrClass);
}
void KrView::init()
{
// sanity checks:
if (!_widget)
qFatal("_widget must be set during construction of KrView inheritors");
// ok, continue
initProperties();
_operator = createOperator();
setup();
restoreDefaultSettings();
KConfigGroup grp(_config, _instance.name());
enableUpdateDefaultSettings(true);
_instance.m_objects.append(this);
}
ctkPluginFrameworkContext::ctkPluginFrameworkContext(
const ctkProperties& initProps)
: plugins(0), services(0), systemPlugin(new ctkPluginFramework()),
storage(0), firstInit(true), props(initProps), initialized(false)
{
{
QMutexLocker lock(&globalFwLock);
id = globalId++;
systemPlugin->ctkPlugin::init(new ctkPluginFrameworkPrivate(systemPlugin, this));
}
initProperties();
log() << "created";
}
QpMetaProperty QpMetaObject::metaProperty(const QString &name) const
{
if (data->metaProperties.isEmpty()) {
initProperties();
}
auto it = data->metaPropertiesByName.find(name);
Q_ASSERT_X(it != data->metaPropertiesByName.end(),
Q_FUNC_INFO,
qPrintable(QString("The '%1' class has no property '%2'.")
.arg(data->metaObject.className())
.arg(name)));
return it.value();
}
void FileHandler::init(const sp<String>& pattern, bool append, int32_t limit, int32_t count, int32_t bufferSize, int32_t dataVolumeLimit) {
initProperties(pattern, append, limit, count, bufferSize, dataVolumeLimit);
initOutputFiles();
initPreferences();
}
CurveDetector::CurveDetector(const char *__info) : cFilter(__info)
{
this->isFirstFrame = true;
initProperties();
}
/*
*******************************************************************
* Function:
*
* Description:
*
* Parameters:
*
* Returns:
*
*******************************************************************
*/
void xDistributedSession::unpackUpdate(TNL::GhostConnection *connection, TNL::BitStream *stream)
{
xNetInterface *netInterface = (xNetInterface*) connection->getInterface();
if (netInterface)
{
//////////////////////////////////////////////////////////////////////////
//initial update ?
if(stream->readFlag())
{
if(stream->readFlag())
{
char oName[256];stream->readString(oName); // retrieve objects name :
char cName[256];stream->readString(cName); // retrieve objects dist class name :
int type = stream->readInt(32); //read the dist class base type :
int userID = stream->readInt(32);
int serverID2 = stream->readInt(32);
float creationTime = 0.0f;
stream->read(&creationTime);
int sessionID = stream->readInt(32);
int MaxUsers = stream->readInt(32);
char pass[256];stream->readString(pass);
//////////////////////////////////////////////////////////////////////////
//now we store all in the dist object :
//find and store the dist class :
xDistributedClassesArrayType *_classes = netInterface->getDistributedClassInterface()->getDistrutedClassesPtr();
xDistributedClass *classTemplate = netInterface->getDistributedClassInterface()->get(cName,type);
if (!classTemplate)
{
xLogger::xLog(ELOGERROR,E_LI_SESSION,"Warning initial unpack of session %s failed : no related class found : %s",oName,cName);
//xLogger::xLog(ELOGINFO,XL_START,"Warning Initial Unpack Update, no related class found : %s",cName);
//xLogger::xLog(ELOGERROR,XL_SESSION,"Warning Initial Unpack Update, no related class found : %s",cName);
classTemplate = netInterface->getDistributedClassInterface()->createClass(cName,type);
}
setDistributedClass(classTemplate);
SetName(oName);
setServerID(connection->getGhostIndex(this));
setObjectFlags(E_DO_CREATION_CREATED);
setUserID(userID);
setNetInterface(netInterface);
setCreationTime(creationTime);
setSessionID(sessionID);
getOwnershipState().set( 1<<E_DO_OS_OWNER, getUserID() == ((vtConnection*)connection)->getUserID() );
setInterfaceFlags(E_DO_CREATED);
getSessionFlags().set( 1 << E_SF_INCOMPLETE );
xLogger::xLog(ELOGTRACE,E_LI_SESSION,"Retrieved initial state of session %s",oName);
initProperties();
setMaxUsers(MaxUsers);
setPassword(xNString(pass));
vtConnection *con = (vtConnection*)connection;
setOwnerConnection(con);
}
}
int updateBits = stream->readSignedInt(32);
TNL::BitSet32 updateBitsMask(updateBits);
setGhostUpdateBits(updateBits);
xDistributedPropertyArrayType &props = *getDistributedPorperties();
int propCounter = 0;
for (unsigned int i = 0 ; i < props.size() ; i++ )
{
xDistributedProperty *prop = props[i];
xDistributedPropertyInfo*propInfo = prop->getPropertyInfo();
int blockIndex = prop->getBlockIndex();
if (updateBitsMask.testStrict(1<<blockIndex))
{
prop->updateFromServer(stream);
xLogger::xLog(ELOGTRACE,E_LI_SESSION,"Client : retrieving session property : %s |pred :%d",prop->getPropertyInfo()->mName.getString(),prop->getPropertyInfo()->mPredictionType);
//xLogger::xLog(ELOGINFO,XL_START,"client : retrieving session property : %s",prop->getPropertyInfo()->mName.getString());
getSessionFlags().set( 1 << E_SF_COMPLETE );
propCounter++;
}
}
if (propCounter == props.size())
{
getSessionFlags().set( 1 << E_SF_COMPLETE );
}
}
}
RuleMatcher::RuleMatcher() {
initProperties();
}
void FileHandler::init(const sp<String>& pattern, bool append, int32_t limit,
int32_t count)
{
initProperties(pattern, append, limit, count);
initOutputFiles();
}
DriverFilter::DriverFilter(const char *__info) : cFilter(__info)
{
this->isFirstTimeRun = true;
this->stopCounter = 0;
initProperties();
}
