C++ IProperty类代码示例

const char* IPropertySet::GetSTRING(const void* pData, int nIndex)
{
	assert(nIndex>=0 && nIndex<PropertyCount());
	if(nIndex<0 || nIndex>=PropertyCount()) return NULL;
	IProperty* pInfo = GetProperty(nIndex);
	assert(pInfo->GetType()==PROPERTY_TYPE_STRING);
	if(pInfo->GetType()!=PROPERTY_TYPE_STRING) return NULL;
	return (const char*)pData + pInfo->GetOffset();
}

	void IObject::SetPropertyValue(Core::IString Name,Core::IString Value)
	{
		IProperty *prop = m_aProperties.GetProperty(Name);

		if (prop)
		{
			prop->SetValueFromString(Value);
			OnPropertyChange(Name);
		}
	}

void IProperty::setDirty(bool b)
{
	if (isFake()) {
		IProperty *p = parent();
		while (p != 0 && p->isFake())
			p = p->parent();
		if (p != 0)
			p->setDirty(true);
	} else {
		m_dirty = b;
	}
}

int CGamesysManager::CreateNewArchetype(int donorArch, const char* name)
{
	int newArch = g_pObjSys->BeginCreate(donorArch, 2);

	g_pObjSys->NameObject(newArch, name);
	IProperty* donorProp = g_pPropMan->GetPropertyNamed("DonorType");

	if (donorProp->IsSimplyRelevant(donorArch))
	{
		donorProp->Copy(newArch, donorArch);
	}

	g_pObjSys->EndCreate(newArch);

	if (!newArch)
		Log.Print("acache: Failed to create %s.", name);

	return newArch;
}

//! fills the property with children - must be called after the array has been inserted to the property list
void wxArrayProperty::Fill(ArrayProperty* pProperty)
{
	s32 numProperties = pProperty->GetProperties().size();
	for(s32 i=0; i<numProperties; ++i)
	{
		IProperty* pSubProperty = pProperty->GetProperties()[i];

		std::stringstream ss;
		ss << "[" << i << "]";
		pSubProperty->SetName(ss.str());

		wxPGProperty* pWxProperty = PropertyList::GetWxProperty(pSubProperty, m_pParent);
		InsertChild(-1, pWxProperty);
		bool bParentDisabled = !GetGrid()->IsPropertyEnabled(this);
		if(bParentDisabled)
		{
			GetGrid()->DisableProperty(pWxProperty);
		}
	}

	UpdateValue();
}

bool PropertyBag::GetNext(
   gubi::IProperty** ppProperty )
{
   bool bReturn = false;

   if (ppProperty != NULL && m_mapIterator != m_mapProperty.end())
   {
      IProperty* pProperty = m_mapIterator->second;

      if (pProperty != NULL)
      {
         pProperty->AddReference();
      }

      *ppProperty = pProperty;
      bReturn     = true;

      m_mapIterator++;
   }

   return bReturn;
}

bool PropertyBag::Find(
   const gubi::Identifier& ePropertyId,
   gubi::IProperty** ppProperty )
{
   bool bReturn              = false;
   property_map::iterator it = m_mapProperty.find(ePropertyId);

   if (ppProperty != NULL && it != m_mapProperty.end())
   {
      IProperty* pProperty = it->second;

      if (pProperty != NULL)
      {
         pProperty->AddReference();
      }

      *ppProperty = pProperty;
      bReturn     = true;
   }

   return bReturn;
}

RESULT
Animation::BindTo( IProperty& property )
{
    RESULT rval = S_OK;
   
    if (property.IsNull())
    {
        SAFE_DELETE(m_pTargetProperty);
        m_isBoundToProperty = false;
        Stop();
        
        goto Exit;
    }

    
    if (property.GetType() != m_propertyType)
    {
        RETAILMSG(ZONE_ERROR, "ERROR: Animation::BindTo( \"%s\", 0x%x ): target Property type 0x%x incorrect for this Animation",
                  m_name.c_str(), (UINT32)&property, property.GetType());
        rval = E_INVALID_OPERATION;
        goto Exit;
    }
    

    SAFE_DELETE(m_pTargetProperty);
    m_pTargetProperty   = property.Clone();
    m_isBoundToProperty = true;    
    
    if (m_relativeToCurrentState)
    {
        // Save the target Property into our m_startingValue.
        // Keyframes will be interpolated, then added to m_startingValue to produce the final result.
        switch (m_keyFrameType)
        {
            case KEYFRAME_TYPE_UINT32:
                m_startingValue.SetIntValue( m_pTargetProperty->GetInteger() );
                break;
            case KEYFRAME_TYPE_FLOAT:
                m_startingValue.SetFloatValue( m_pTargetProperty->GetFloat() );
                break;
            case KEYFRAME_TYPE_VEC2:
                m_startingValue.SetVec2Value( m_pTargetProperty->GetVec2() );
                break;
            case KEYFRAME_TYPE_VEC3:
                m_startingValue.SetVec3Value( m_pTargetProperty->GetVec3() );
                break;
            case KEYFRAME_TYPE_VEC4:
                m_startingValue.SetVec4Value( m_pTargetProperty->GetVec4() );
                break;
            case KEYFRAME_TYPE_COLOR:
                m_startingValue.SetColorValue( m_pTargetProperty->GetColor() );
                break;
            default:
                DEBUGCHK(0);
                break;
        }
    }


Exit:
    return rval;
}

//.........这里部分代码省略.........

      if ( type == "Converter" || type == "DataObject" ) {
        /// no Properties, so don't bother create Configurables...
        continue;
      }

      //if ( type == "ApplicationMgr" ) {
      ///  @FIXME: no Configurable for this component. yet...
      ///  continue;
      //}

      if ( !known ) {
        cout << "WARNING: Unknown (return) type [" << rtype << "] !!\n"
             << "WARNING: component [" << ident << "] is skipped !"
             << endl;
        allGood = false;
        continue;
      }

      string cname = "DefaultName";
      vector<void*>  args;
      args.reserve( 3 );
      if ( type == "AlgTool" ) {
        args.resize( 3 );
        args[0] = &cname;
        args[1] = &type;
        args[2] = dummySvc;
      }
      else {
        args.resize( 2 );
        args[0] = &cname;
        args[1] = svcLoc;
      }
      IProperty* prop = 0;
      try {
        if ( type == "Algorithm" ) {
          prop = makeInstance<IAlgorithm>(*it,args);
        }
        else if ( type == "Service") {
          prop = makeInstance<IService>(*it,args);
        }
        else if ( type == "AlgTool") {
          prop = makeInstance<IAlgTool>(*it,args);
        }
        else if ( type == "Auditor") {
          prop = makeInstance<IAuditor>(*it,args);
        }
        else if ( type == "ApplicationMgr") {
          //svcLoc->queryInterface(IProperty::interfaceID(), pp_cast<void>(&prop));
          svcLoc->queryInterface(IProperty::interfaceID(), (void**)(&prop));
        }
        else {
          prop = makeInstance<IInterface>(*it,args);
        }
      }
      catch ( exception& e ) {
        cout << "ERROR: Error instantiating " << name
             << " from " << *iLib << endl;
        cout << "ERROR: Got exception: " << e.what() << endl;
        allGood = false;
        continue;
      }
      catch ( ... ) {
        cout << "ERROR: Error instantiating " << name
             << " from " << *iLib << endl;
        allGood = false;

bool wxArrayPropertyEditor::OnEvent( wxPropertyGrid* propGrid,
                                     wxPGProperty* property,
                                     wxWindow* ctrl,
                                     wxEvent& event ) const
{
    if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
    {
        wxPGMultiButton* buttons = (wxPGMultiButton*) propGrid->GetEditorControlSecondary();
		wxArrayProperty* pArrayProperty = static_cast<wxArrayProperty*>(property);

		if(event.GetId() == buttons->GetButtonId(0)) // + - add element
		{
			if(pArrayProperty->GetMaxElems() < 0
			|| pArrayProperty->GetChildCount() < u32(pArrayProperty->GetMaxElems()))
			{
				// determine new property name
				IProperty* pNewProperty = pArrayProperty->GetSubPropertyTemplate();
				std::stringstream ss;
				ss << "[" << property->GetChildCount() << "]";
				pNewProperty->SetName(ss.str());

				// create a new wxPGProperty out of it and insert it
				wxPGProperty* pWxProperty = PropertyList::GetWxProperty(pNewProperty, pArrayProperty->GetParent());
				property->InsertChild(-1, pWxProperty);

				if(pNewProperty->GetType() == PT_Reference)
				{
					pArrayProperty->GetParent()->FillArrayProperties(pNewProperty, pWxProperty);	
				}

				pArrayProperty->UpdateValue();
				propGrid->RefreshProperty(property);			

				// update the corresponding property in the property stream
				wxPropertyGridEvent PGEvent;
				PGEvent.SetProperty(property);
				pArrayProperty->SetEventType(wxArrayProperty::E_PropertyAdded);
				pArrayProperty->GetParent()->OnPropertyGridChange(PGEvent);
			}			
		}	
		else if(event.GetId() == buttons->GetButtonId(1)) // - remove element
		{
			int childCount = property->GetChildCount();
			if(childCount > 0)
			{
				// remove the wx property
				wxPGProperty* pChild = property->Item(childCount-1);
				propGrid->DeleteProperty(pChild);	
				pArrayProperty->UpdateValue();
				propGrid->RefreshProperty(property);

				// update the corresponding property in the property stream
				wxPropertyGridEvent PGEvent;
				PGEvent.SetProperty(property);
				pArrayProperty->SetEventType(wxArrayProperty::E_PropertyRemoved);
				pArrayProperty->GetParent()->OnPropertyGridChange(PGEvent);
			}
		}

		return true;
    }
	else
	{
		return wxPGTextCtrlEditor::OnEvent(propGrid, property, ctrl, event);
	}    
}

LRESULT 
CAppOptAdvancedPage::OnTreeNotify(LPNMHDR pnmh)
{
	BOOL fSuccess = FALSE;
	// pnmh->hwndFrom;
	
	if (IDC_OPTION_TREE != pnmh->idFrom) {
		// ignore other notification
		SetMsgHandled(FALSE);
		return TRUE;
	}

	if (PIN_ITEMCHANGING != pnmh->code) {
		// ignore notifications other than PIN_CLICK
		SetMsgHandled(FALSE);
		return TRUE;
	}

	LPNMPROPERTYITEM pnmProp = reinterpret_cast<LPNMPROPERTYITEM>(pnmh);
	if (NULL == pnmProp->prop) {
		SetMsgHandled(FALSE);
		return TRUE;
	}

	IProperty* prop = pnmProp->prop;

	if (NDASSVC_SUSPEND_ALLOW == prop->GetItemData())
	{
		VARIANT varValue;
		::VariantInit(&varValue);
		fSuccess = prop->GetValue(&varValue);
		ATLASSERT(fSuccess);
		ATLASSERT(varValue.vt = VT_BOOL);
		if (!fSuccess || VT_BOOL != varValue.vt) {
			::VariantClear(&varValue);
			SetMsgHandled(FALSE);
			return TRUE;
		}

		//
		// Ignore the status of already checked.
		//
		if (varValue.boolVal) {
			::VariantClear(&varValue);
			SetMsgHandled(FALSE);
			return TRUE;
		}
		::VariantClear(&varValue);

		int response = AtlMessageBox(
			m_hWnd,
			IDS_SUSPEND_WARNING,
			IDS_MAIN_TITLE,
			MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2);

		if (IDYES != response) 
		{
			SetMsgHandled(TRUE);
			return TRUE;
		}
	}

	SetMsgHandled(FALSE);
	return TRUE;
}