自学教程：C++ ActivateOutput函数代码示例

	virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		switch (event)		{		case eFE_Initialize:			pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true );			break;		case eFE_Update:			{				ISystem *pSystem = GetISystem();				IRenderer *pRenderer = gEnv->pRenderer;				int sysMem = pSystem->GetUsedMemory();				size_t vidMemThisFrame( 0 );				size_t vidMemRecently( 0 );				pRenderer->GetVideoMemoryUsageStats( vidMemThisFrame, vidMemRecently );				int meshMem = 0;				pRenderer->EF_Query(EFQ_Alloc_APIMesh, meshMem);								ActivateOutput(pActInfo, OUT_SYSMEM, sysMem);				// potentially unsafe if we start using >2gb of video memory...?				ActivateOutput(pActInfo, OUT_VIDEOMEM_THISFRAME, int(vidMemThisFrame));				ActivateOutput(pActInfo, OUT_VIDEOMEM_RECENTLY, int(vidMemRecently));				ActivateOutput(pActInfo, OUT_MESHMEM, meshMem);			}			break;		}	}

	void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		switch (event)		{		case eFE_Activate:			if (IsPortActive(pActInfo,eIP_Get))			{				ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();				if (pTOD)				{					ActivateOutput(pActInfo, eOP_Latitude, pTOD->GetSunLatitude());					ActivateOutput(pActInfo, eOP_Longitude, pTOD->GetSunLongitude());				}			}			if (IsPortActive(pActInfo, eIP_Set))			{				ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();				if (pTOD)				{					float latitude = GetPortFloat(pActInfo, eIP_Latitude);					float longitude = GetPortFloat(pActInfo, eIP_Longitude);					pTOD->SetSunPos( longitude, latitude );					bool forceUpdate = GetPortBool( pActInfo, eIP_ForceUpdate );					pTOD->Update(true, forceUpdate);										ActivateOutput(pActInfo, eOP_Latitude, latitude);					ActivateOutput(pActInfo, eOP_Longitude, longitude);				}			}			break;		}	}

	void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		if(eFE_Activate == event)		{			const bool bAttach = IsPortActive(pActInfo, EIP_ATTACH);			const bool bDetach = IsPortActive(pActInfo, EIP_DETACH);			if (!bAttach && !bDetach)				return;			IActor* pActor = GetActor(pActInfo);			if (pActor == 0)				return;			const string& className = GetPortString(pActInfo, EIP_WEAPON);			CWeapon* pWeapon = static_cast<CWeapon*> ( className.empty() ? GetWeapon(pActor) : GetWeapon(pActor, className.c_str()) );			if (pWeapon != 0)			{				ItemString acc = ItemString(GetPortString(pActInfo, EIP_ACCESSORY));				if (bAttach && pWeapon->GetAccessory(acc) == 0)				{					pWeapon->SwitchAccessory(acc);					ActivateOutput(pActInfo, EOP_ATTACHED, true);				}				else if (bDetach && pWeapon->GetAccessory(acc) != 0)				{					pWeapon->SwitchAccessory(acc);					ActivateOutput(pActInfo, EOP_DETACHED, true);				}			}		}	}

	virtual void ProcessEvent( EFlowEvent event,SActivationInfo *pActInfo )	{		switch (event)		{		case eFE_Initialize:			{				m_bResult = 2;				break;			}		case eFE_Activate:			{				bool a = GetPortBool(pActInfo,INP_A);				bool b = GetPortBool(pActInfo,INP_B);				int result = Execute(a,b)? 1 : 0;				bool activateOutputs = GetPortBool( pActInfo, INP_Always ) || m_bResult!=result;				m_bResult = result;				if (activateOutputs)				{					ActivateOutput( pActInfo,0,result );					if(result)						ActivateOutput( pActInfo,1,true );					else						ActivateOutput( pActInfo,2,true );				}			}		};	};

void CFlashUIFromArrayNode::ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo ){	if (event == eFE_Activate && IsPortActive( pActInfo, eI_Array ))	{		SUIArguments args( GetPortString( pActInfo, eI_Array ).c_str());		ActivateOutput( pActInfo, eO_Count, args.GetArgCount());		SUIArguments leftOver;		int          port = eO_Val1;		for (int i = 0; i < args.GetArgCount(); ++i)		{			string arg;			args.GetArg( i, arg );			if (port + i < eO_LeftOver)			{				ActivateOutput( pActInfo, port + i, arg );			}			else			{				leftOver.AddArgument( arg );			}		}		if (leftOver.GetArgCount() > 0)		{			ActivateOutput( pActInfo, eO_LeftOver, string( leftOver.GetAsString()));		}	}}

	virtual void ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo)	{		switch(event)		{		case eFE_Activate:			CGameRules *pGR = g_pGame->GetGameRules();			if(!pGR)				return;			if(!pActInfo->pEntity)				return;			const bool bUseVapor = GetPortBool(pActInfo, EIP_Vapor);			if(IsPortActive(pActInfo, EIP_Freeze))			{				pGR->FreezeEntity(pActInfo->pEntity->GetId(), true, bUseVapor, true);				ActivateOutput(pActInfo, EOP_Frozen, true);			}			else if(IsPortActive(pActInfo, EIP_UnFreeze))			{				pGR->FreezeEntity(pActInfo->pEntity->GetId(), false, bUseVapor);				ActivateOutput(pActInfo, EOP_UnFrozen, true);			}			break;		}	}

	void OnHUDEvent(const SHUDEvent& event)	{		switch(event.eventType)		{		case eHUDEvent_OnScanningComplete:			{				if(m_enabled)				{					EntityId scannedEntityId = static_cast<EntityId>(event.GetData(0).m_int);					if (scannedEntityId != m_entityId) // Only selected entity						break;					IEntity* pScannedEntity = gEnv->pEntitySystem->GetEntity(scannedEntityId);					if(!pScannedEntity)					{						SetEnabled(false);						break;					}											if (m_delayResult)					{						SHUDEvent _event(eHUDEvent_OnControlCurrentTacticalScan);						_event.AddData(SHUDEventData(true)); // Delay result						CHUDEventDispatcher::CallEvent(_event);					}					ActivateOutput(&m_actInfo, EOP_OnEvent, true);					ActivateOutput(&m_actInfo, EOP_EntityID, m_entityId);				}				break;			}		}	}

	virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		switch (event)		{		case eFE_Initialize:			{			}			break;		case eFE_Activate:#if CRY_PLATFORM_DURANGO			if(IsPortActive(pActInfo, EIP_Poll))			{				std::shared_ptr<Live::State::User> cur_user = MatchmakingUtils::GetCurrentUser();				size_t memberCountSession = cur_user->GetSessionMembers().size();				CryLogAlways("SessionMembers: %d", memberCountSession);				static MatchmakingUtils::INetworkingUser_impl s_networkingUser;				bool isHost = s_networkingUser.IsHost();				if(isHost)				{					ActivateOutput(pActInfo, EOP_Host, 1);				}				else				{					ActivateOutput(pActInfo, EOP_Client, 1);				}				}#endif			break;		}	}

    // ~IInputEventListener    virtual bool OnInputEvent( const SInputEvent &event )    {        if (true == m_bActive)        {#if defined(ORBIS)	// FIXME: Using PS3 inputs for ORBIS            int nThisKey = event.keyId;            int nKey = -1;            int nInput = GetPortInt(&m_actInfo, EIP_Key);            int tableSize = sizeof(PS3KeyTable)/sizeof(PS3KeyTable[0]);            if ( nInput>=0 && nInput<tableSize )                nKey = PS3KeyTable[nInput];#else            // Translate key, check value            const int nThisKey = TranslateKey(event.keyId);            const int nKey = GetPortInt(&m_actInfo, EIP_Key);#endif            if (nKey == nThisKey)            {                // Return based on state                if (eIS_Pressed == event.state)                    ActivateOutput(&m_actInfo, EOP_Pressed, true);                else if (eIS_Released == event.state)                    ActivateOutput(&m_actInfo, EOP_Released, true);            }        }        // Let other listeners handle it        return false;    }

void CFlashUIScreenPosNode::ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ){    if ( event == eFE_Initialize )    {        UpdateUIElement( GetPortString( pActInfo, eI_UIElement ), pActInfo );    }    else if ( event == eFE_Activate )    {        if ( IsPortActive( pActInfo, eI_UIElement ) )        {            UpdateUIElement( GetPortString( pActInfo, eI_UIElement ), pActInfo );        }        if ( IsPortActive( pActInfo, eI_Get ) )        {            const int instanceId = GetPortInt(pActInfo, eI_InstanceID);            float px = GetPortFloat(pActInfo, eI_PX);            float py = GetPortFloat(pActInfo, eI_PY);            const bool scaleMode = GetPortBool(pActInfo, eI_ScaleMode);            SPerInstanceCall3< float&, float&, bool > caller;            if ( !caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIScreenPosNode::GetScreenPos), px, py, scaleMode, false) )            {                UIACTION_WARNING( "FG: UIElement /"%s/" called get screenpos for multiple instances! (passed instanceId %i), referenced at node /"%s/"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName( pActInfo->myID ) );            }            ActivateOutput( pActInfo, eO_OnGet, true );            ActivateOutput(pActInfo, eO_PX, px);            ActivateOutput(pActInfo, eO_PY, py);        }    }}

	virtual void Execute(SActivationInfo *pActInfo)	{		bool bResult = false;		// did the socket connect okay?		if (socketWorking) {			if (ReceiveLine() != -1) {				string r = recMessage;				//string value = r.c_str();				int indice = r.find("|",0);				string cvar = r.substr(0,indice);//r.Left(r.find("|",0));				string value = r.substr(indice+1,r.length()-(indice+1));				CryLogAlways(r);				ActivateOutput(pActInfo, EOP_CVAR, cvar);				ActivateOutput(pActInfo, EOP_Value, value);				bResult = true;			}		}			// return false if socket error, or no message				if (bResult) ActivateOutput(pActInfo, EOP_Received, true);		return;	}

	virtual void DialogCallback(uint32 dialogId, EDialogResponse response, const char* input)	{		assert(m_id == dialogId && m_bDisplayed);		ActivateOutput(&m_ActInfo, eO_Param, string(input));		ActivateOutput(&m_ActInfo, eO_Result, (int)response);		m_bDisplayed = false;	}

void CD6PlayerCreditRangeNode::ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo){    switch (event)    {    case eFE_Activate:    {        if (true == IsPortActive(pActInfo, EIP_Trigger))        {            // Get D6 Player            CD6Player *pPlayer = GetD6Player((NULL != pActInfo->pEntity ? pActInfo->pEntity->GetId() : 0));            if (NULL == pPlayer) break;            // Get range            unsigned int nMinRange = GetPortFloat(pActInfo, EIP_MinAmount);            unsigned int nMaxRange = GetPortFloat(pActInfo, EIP_MaxAmount);            // Get credits and test            unsigned int nCredits = pPlayer->GetCredits();            if (nCredits >= nMinRange && nCredits <= nMaxRange)                ActivateOutput(pActInfo, EOP_Pass, true);            else                ActivateOutput(pActInfo, EOP_Fail, true);        }    }    break;    }}

	virtual void ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo)	{		switch (event)		{		case eFE_Activate:			{				if(IsPortActive(pActInfo, EIP_RecenterPose))				{					bool triggered = false;					IHMDManager* pHmDManager = gEnv->pSystem->GetHMDManager();					IHMDDevice* pDev = pHmDManager ? pHmDManager->GetHMDDevice() : NULL;					if (pDev && pHmDManager->IsStereoSetupOk())					{						const HMDTrackingState& sensorState = pDev->GetTrackingState();						if (sensorState.CheckStatusFlags(HS_IsUsable))						{							pDev->RecenterPose();							triggered = true;						}					}					ActivateOutput(pActInfo, triggered ? EOP_Triggered : EOP_Failed, true);					ActivateOutput(pActInfo, EOP_Done, true);				}			}			break;		}	}

    virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)    {        if (event == eFE_Activate)        {            if (!IsPortActive(pActInfo, Get))                return;            EControlScheme curControlScheme = g_pGame->GetUI()->GetCurControlScheme();            switch (curControlScheme)            {            case eControlScheme_Keyboard:                ActivateOutput(pActInfo, Keyboard, GetPortAny(pActInfo, Get));                break;            case eControlScheme_KeyboardMouse:                ActivateOutput(pActInfo, KeyboardMouse, GetPortAny(pActInfo, Get));                break;            case eControlScheme_XBoxOneController:                ActivateOutput(pActInfo, XBoxOneController, GetPortAny(pActInfo, Get));                break;            case eControlScheme_PS4Controller:                ActivateOutput(pActInfo, PS4Controller, GetPortAny(pActInfo, Get));                break;            default:                GameWarning("CFlowNode_InputControlScheme::ProcessEvent: Failed to activate output port, unhandled control scheme type");            }        }    }

	virtual void ProcessEvent( EFlowEvent event, SActivationInfo* pActInfo )	{		switch (event)		{		case eFE_Activate:			if (IsPortActive(pActInfo,IN_SEND))			{				const string &       key     = GetPortString(pActInfo,IN_MSG);				const string &       value   = GetPortString(pActInfo,IN_VALUE);				const int            iTarget = GetPortInt(pActInfo,IN_TARGET);				SNetMsgData::ETarget target  = SNetMsgData::ConvertTargetIntToEnum(iTarget);				CRY_ASSERT_MESSAGE(target != SNetMsgData::eT_Invalid, "CFlowNode_MsgSender: IN_TARGET input got converted to an invalid Enum");				if (target != SNetMsgData::eT_Invalid)				{					if (CNetMessageDistpatcher* pNetMsgDispatcher = CCryAction::GetCryAction()->GetNetMessageDispatcher())					{						NET_MSG_DISPATCHER_LOG("CFlowNode_MsgSender: %s Send message [%s/%s]", CNetMessageDistpatcher::DbgTranslateLocationToString(), key.c_str(), value.c_str());						pNetMsgDispatcher->SendMessage(SNetMsgData(CNetMessageDistpatcher::GetLocation(), target, key, value));						ActivateOutput(pActInfo, OUT_DONE, true);						return;					}				}				ActivateOutput(pActInfo, OUT_ERROR, true);			}			break;		}	}

	void OnVehicleEvent(EVehicleEvent event, const SVehicleEventParams& params)	{		if ( (event == eVE_Destroyed) || 				 (event == eVE_PreVehicleDeletion) ||				 (event == eVE_Hide) ) // Safer to ensure the listener is removed at this point		{			SetActive(false);		}		else if (event == eVE_VehicleDeleted) // This shouldn't be called due to above but just in case		{			SetActive(false);		}		else if (event == eVE_Collision) // Currently disabled in C2 code		{			ActivateOutput(&m_actInfo, EOP_Collided, true);		}		else if (event == eVE_Hit) // Needed to detect collision in C2 code since above is disabled		{			IGameRules* pGameRules = gEnv->pGame->GetIGameFramework()->GetIGameRulesSystem()->GetCurrentGameRules();			if (pGameRules)			{				const int collisionHitType = pGameRules->GetHitTypeId("collision");				if (params.iParam == collisionHitType)				{					ActivateOutput(&m_actInfo, EOP_Collided, true);				}			}		}	}

	virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		switch (event)		{		case eFE_Initialize:			pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true );			break;		case eFE_Update:			{				if(!GetPortBool(pActInfo, 0))					return;				IEntity * pEntity = pActInfo->pEntity;				if (pEntity)				{					IPhysicalEntity * pPhysEntity = pEntity->GetPhysics();					if (pPhysEntity)					{						pe_status_dynamics dyn;						pPhysEntity->GetStatus( &dyn );						ActivateOutput(pActInfo, 0, dyn.v);						ActivateOutput(pActInfo, 1, dyn.a);						ActivateOutput(pActInfo, 2, dyn.w);						ActivateOutput(pActInfo, 3, dyn.wa);						ActivateOutput(pActInfo, 4, dyn.mass);					}				}			}		}	}

	virtual void OnHUDEvent(const SHUDEvent& event)	{		int eventID = GetPortInt(&m_pActInfo, 0);		if(event.eventType == eventID)		{			ActivateOutput(&m_pActInfo, eOP_EventFired, 1);			for(unsigned int i = 0; i < event.GetDataSize(); i++)			{				switch(event.GetData(i).m_type)				{				case SHUDEventData::eSEDT_voidptr:					break;				case SHUDEventData::eSEDT_bool:									break;				case SHUDEventData::eSEDT_int:					break;				case SHUDEventData::eSEDT_float:						{						if(eventID == eHUDEvent_LeavingBattleArea)						{							float fDeathTimer = event.GetData(i).GetFloat();							ActivateOutput(&m_pActInfo, eOP_DeathTimer, fDeathTimer);						}					}					break;				case SHUDEventData::eSEDT_undef:				default:					CryWarning(VALIDATOR_MODULE_FLOWGRAPH, VALIDATOR_WARNING, "[CFlowNode_BattleAreaListener] HudEvent data unknown.");					break;				}			}		}	}

	virtual void ProcessEvent(EFlowEvent event, SActivationInfo *pActInfo)	{		switch (event)		{		case eFE_Activate:			{				if(IsPortActive(pActInfo, EIP_FailCurrentScan))				{					SHUDEvent _event(eHUDEvent_OnControlCurrentTacticalScan);					_event.AddData(SHUDEventData(false)); // Delay result					_event.AddData(SHUDEventData(false));					CHUDEventDispatcher::CallEvent(_event);					ActivateOutput(pActInfo, EOP_Failed, true);				}				else if(IsPortActive(pActInfo, EIP_SucceedCurrentScan))				{					SHUDEvent _event(eHUDEvent_OnControlCurrentTacticalScan);					_event.AddData(SHUDEventData(false)); // Delay result					_event.AddData(SHUDEventData(true));					CHUDEventDispatcher::CallEvent(_event);					ActivateOutput(pActInfo, EOP_Succeeded, true);				}				break;			}		}	}

	void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )	{		if (event == eFE_Activate && IsPortActive(pActInfo,0))		{			IGameFramework * pGameFramework = gEnv->pGame->GetIGameFramework();			IActor* pActor = GetInputActor( pActInfo );			if (!pActor || pActor!=gEnv->pGame->GetIGameFramework()->GetClientActor())  // to avoid some extra RMIs and object creation. Tho, this causes the node to not work properly if it is used with non players entities. (which was never intended anyway)				return;									IInventory *pInventory = pActor->GetInventory();      if (!pInventory)        return;      const string& itemClass = GetPortString( pActInfo, 1 );			IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass( itemClass.c_str() );      EntityId id = pInventory->GetItemByClass( pClass );            if (id!=0)      {        pInventory->RMIReqToServer_RemoveItem( itemClass.c_str() );        // TODO: instant output activation, with delayed effective change in the inventory, it potentially could cause problems in rare situations        ActivateOutput(pActInfo,0,true);      }      else        ActivateOutput(pActInfo,0,true);		}	}

	void UpdateOutputs( int alertnessGlobal )	{		EFilterAI filterAI = (EFilterAI)(GetPortInt( &m_actInfo, IN_FILTERAI ));		int alertness = 0;		switch (filterAI)		{			case FAI_ALL:				alertness = alertnessGlobal;				break;			case FAI_ENEMIES:				alertness = g_pGame->GetGameAISystem()->GetAICounters().GetAlertnessCounter().GetAlertnessEnemies();				break;			case FAI_FRIENDS:				alertness = g_pGame->GetGameAISystem()->GetAICounters().GetAlertnessCounter().GetAlertnessFriends();				break;			case FAI_FACTION:			{				if (m_faction!=IFactionMap::InvalidFactionID)				{					alertness = g_pGame->GetGameAISystem()->GetAICounters().GetAlertnessCounter().GetAlertnessFaction( m_faction );				}				break;			}		}		ActivateOutput( &m_actInfo, OUT_ALERTNESS, alertness );		uint32 colorPort = clamp_tpl( alertness+OUT_GREEN, (int)OUT_GREEN, (int)OUT_RED );		ActivateOutput( &m_actInfo, colorPort, true );	}

	bool SendNext(SActivationInfo *pActInfo)	{		bool bResult = false;		if (m_Count > 0)		{			if (m_Iter < m_Count)			{				const int limit = GetPortInt(pActInfo, EIP_Limit);				if (limit == 0 || m_Iter <= limit)				{					OnIterNext(pActInfo);					EntityId id = *m_ListIter;					ActivateOutput(pActInfo, EOP_EntityId, id);					ActivateOutput(pActInfo, EOP_Count, m_Iter);					++m_Iter;					++m_ListIter;					bResult = true;				}			}		}		if (!bResult)		{			ActivateOutput(pActInfo, EOP_Done, m_Iter);		}		return bResult;	}

 virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) {     switch (event)     {     case eFE_Update:     {         bool bPaused = GetPortBool(pActInfo,IN_PAUSED);         if (!bPaused)         {             float fSeconds = gEnv->pTimer->GetFrameStartTime().GetSeconds();             ActivateOutput( pActInfo,OUT_SECONDS,fSeconds );             ActivateOutput( pActInfo,OUT_TICK,0 );         }     }     break;     case eFE_Initialize:     {         bool bPaused = GetPortBool(pActInfo,IN_PAUSED);         pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, !bPaused );         break;     }     case eFE_Activate:         if (IsPortActive(pActInfo,IN_PAUSED))         {             bool bPaused = GetPortBool(pActInfo,IN_PAUSED);             pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, !bPaused );         }         break;     } }

	virtual void Execute(SActivationInfo *pActInfo)	{		bool bResult = false;		if (udpListener->IsWorking()) {			if (udpListener->ReceiveLine() != -1) {				string chaine = udpListener->GetRecMessage();				string token0 = udpListener->GetToken(0);				Quat gyro = udpListener->TokenToQuat(token0);				string token1 = udpListener->GetToken(1);				Vec3 accel = udpListener->TokenToVec3(token1);				string token2 = udpListener->GetToken(2);				float compass = udpListener->TokenToFloat(token2);								//if(!gyro.IsValid()) CryLogAlways("NOT VALID");				ActivateOutput(pActInfo, EOP_Gyro_xyz, Vec3(gyro.v.x,gyro.v.y,gyro.v.z));				ActivateOutput(pActInfo, EOP_Gyro_w, gyro.w);								ActivateOutput(pActInfo, EOP_Accel, accel);				ActivateOutput(pActInfo, EOP_Compass, compass);								bResult = true;			}		}		return;	}

		virtual void GameOver(int localWinner)		{			switch(localWinner)			{				case 1:					if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0)					{						CryLog("--MP flowgraph: GameWon");					}					ActivateOutput(&m_actInfo, EOP_GameWon,true);					break;							case -1:					if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0)					{						CryLog("--MP flowgraph: GameLost");					}					ActivateOutput(&m_actInfo, EOP_GameLost,true);					break;				default:					if(g_pGame->GetCVars()->i_debug_mp_flowgraph != 0)					{						CryLog("--MP flowgraph: GameTied");					}					ActivateOutput(&m_actInfo, EOP_GameTied, true);					break;			}		}

void CFlashUIFunctionNode::ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo ){	if (event == eFE_Activate && IsPortActive(pActInfo, eI_Call))	{		int          port = GetDynStartPort();		SUIArguments args;		for (TUIParams::const_iterator iter = m_funcDesc.InputParams.Params.begin(); iter != m_funcDesc.InputParams.Params.end(); ++iter)		{			GetDynInput( args, *iter, pActInfo, port++ );		}		TUIData   res;		const int instanceId = GetPortInt( pActInfo, eI_InstanceID );		if (IsTemplate() && !UpdateTmplDesc( GetPortString(pActInfo, eI_TemplateInstanceName), pActInfo ))			return;		SPerInstanceCall2< const SUIArguments &, TUIData & > caller;		caller.Execute(m_pElement, instanceId, functor(*this, &CFlashUIFunctionNode::CallFunction), args, res);		string out;		res.GetValueWithConversion( out );		ActivateOutput( pActInfo, eO_RetVal, out  );		ActivateOutput( pActInfo, eO_OnCall, true );	}}