BVB Source Codes

CRYENGINE Show FlashUIActionNodes.cpp Source code

Return Download CRYENGINE: download FlashUIActionNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlashUIActionNodes.cpp
  5. //  Version:     v1.00
  6. //  Created:     10/9/2010 by Paul Reindell.
  7. //  Description:
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12. #include "StdAfx.h"
  13. #include "FlashUIActionNodes.h"
  14. #include "FlashUIBaseNode.h"
  15. #include "FlashUI.h"
  16.  
  17. //--------------------------------------------------------------------------------------------
  18. CFlashUIActionBaseNode::CFlashUIActionBaseNode(const char* name)
  19.         : m_pAction(NULL)
  20. {
  21.         if (gEnv->pFlashUI)
  22.                 gEnv->pFlashUI->GetUIActionManager()->AddListener(this, name);
  23. }
  24.  
  25. CFlashUIActionBaseNode::~CFlashUIActionBaseNode()
  26. {
  27.         if (gEnv->pFlashUI)
  28.                 gEnv->pFlashUI->GetUIActionManager()->RemoveListener(this);
  29. }
  30.  
  31. void CFlashUIActionBaseNode::UpdateAction(const char* sName, bool bStrict)
  32. {
  33.         if (gEnv->pFlashUI)
  34.                 m_pAction = gEnv->pFlashUI->GetUIAction(sName);
  35.  
  36.         if (!m_pAction && bStrict)
  37.         {
  38.                 UIACTION_ERROR("FG: UIAction \"%s\" does not exist", sName);
  39.         }
  40. }
  41.  
  42. void CFlashUIActionBaseNode::UpdateAction(IFlowGraph* pGraph)
  43. {
  44.         if (gEnv->pFlashUI)
  45.         {
  46.                 int i = 0;
  47.                 while (IUIAction* pAction = gEnv->pFlashUI->GetUIAction(i++))
  48.                 {
  49.                         if (pAction->GetType() == IUIAction::eUIAT_FlowGraph && pAction->GetFlowGraph() == pGraph)
  50.                         {
  51.                                 m_pAction = pAction;
  52.                                 break;
  53.                         }
  54.                 }
  55.         }
  56.         if (!m_pAction)
  57.         {
  58.                 UIACTION_WARNING("FG: UI:Action:Start/End nodes only allowed within UIAction graph!");
  59.         }
  60. }
  61.  
  62. //--------------------------------------------------------------------------------------------
  63. CFlashUIStartActionNode::~CFlashUIStartActionNode()
  64. {
  65.         m_stack.clear();
  66. }
  67.  
  68. void CFlashUIStartActionNode::GetConfiguration(SFlowNodeConfig& config)
  69. {
  70.         static const SInputPortConfig in_config[] = {
  71.                 InputPortConfig<bool>("UseAsState", false, "If this is set to true, the Flowgraph is disabled per default. It will be enabled once it gets started.", "DisableAction"),
  72.                 { 0 }
  73.         };
  74.         static const SOutputPortConfig out_config[] = {
  75.                 OutputPortConfig_Void("StartAction", "Triggered if someone starts the action"),
  76.                 OutputPortConfig<string>("Args",     "Comma separated argument string"),
  77.                 { 0 }
  78.         };
  79.  
  80.         config.pInputPorts = in_config;
  81.         config.pOutputPorts = out_config;
  82.         config.sDescription = "Start node for UI Action";
  83.         config.SetCategory(EFLN_APPROVED);
  84. }
  85.  
  86. void CFlashUIStartActionNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  87. {
  88.         switch (event)
  89.         {
  90.         case eFE_Initialize:
  91.                 UpdateAction(pActInfo->pGraph);
  92.                 m_stack.clear();
  93.                 m_stack.init(pActInfo->pGraph);
  94.                 if (m_pAction)
  95.                 {
  96.                         CRY_ASSERT_MESSAGE(gEnv->pFlashUI, "No FlashUI extension available!");
  97.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  98.                         if (GetPortBool(pActInfo, eI_UseAsState))
  99.                                 gEnv->pFlashUI->GetUIActionManager()->EnableAction(m_pAction, false);
  100.                 }
  101.                 break;
  102.         case eFE_Update:
  103.                 FlushNextAction(pActInfo);
  104.                 break;
  105.         }
  106. }
  107.  
  108. void CFlashUIStartActionNode::OnStart(IUIAction* pAction, const SUIArguments& args)
  109. {
  110.         if (m_pAction != NULL && pAction == m_pAction)
  111.         {
  112.                 UI_STACK_PUSH(m_stack, std::make_pair(pAction, args), "Start UIAction %s (%s)", pAction->GetName(), args.GetAsString());
  113.         }
  114. }
  115.  
  116. void CFlashUIStartActionNode::FlushNextAction(SActivationInfo* pActInfo)
  117. {
  118.         if (m_stack.size() > 0)
  119.         {
  120.                 const SUIArguments& args = m_stack.get().second;
  121.                 ActivateOutput(pActInfo, eO_OnActionStart, true);
  122.                 ActivateOutput(pActInfo, eO_Args, string(args.GetAsString()));
  123.                 m_stack.pop();
  124.         }
  125. }
  126.  
  127. //--------------------------------------------------------------------------------------------
  128. void CFlashUIEndActionNode::GetConfiguration(SFlowNodeConfig& config)
  129. {
  130.         static const SInputPortConfig in_config[] = {
  131.                 InputPortConfig_Void("EndAction",   "Trigger to announce that action is finished"),
  132.                 InputPortConfig<bool>("UseAsState", false,                                         "If this is set to true, the end node will disable this UIAction flowgraph","DisableAction"),
  133.                 InputPortConfig<string>("Args",     "Comma separated argument string"),
  134.                 { 0 }
  135.         };
  136.  
  137.         config.pInputPorts = in_config;
  138.         config.pOutputPorts = 0;
  139.         config.sDescription = "End node for UI Action";
  140.         config.SetCategory(EFLN_APPROVED);
  141. }
  142.  
  143. void CFlashUIEndActionNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  144. {
  145.         switch (event)
  146.         {
  147.         case eFE_Initialize:
  148.                 UpdateAction(pActInfo->pGraph);
  149.                 break;
  150.         case eFE_Activate:
  151.                 if (gEnv->pFlashUI && m_pAction && IsPortActive(pActInfo, eI_OnActionEnd))
  152.                 {
  153.                         SUIArguments args(GetPortString(pActInfo, eI_Args).c_str(), true);
  154.                         gEnv->pFlashUI->GetUIActionManager()->EndAction(m_pAction, args);
  155.  
  156.                         if (GetPortBool(pActInfo, eI_UseAsState))
  157.                         {
  158.                                 gEnv->pFlashUI->GetUIActionManager()->EnableAction(m_pAction, false);
  159.                         }
  160.                 }
  161.                 break;
  162.         }
  163. }
  164.  
  165. //--------------------------------------------------------------------------------------------
  166. CFlashUIActionNode::~CFlashUIActionNode()
  167. {
  168.         m_startStack.clear();
  169.         m_endStack.clear();
  170.         m_selfEndStack.clear();
  171. }
  172.  
  173. void CFlashUIActionNode::GetConfiguration(SFlowNodeConfig& config)
  174. {
  175.         static const SInputPortConfig in_config[] = {
  176.                 InputPortConfig<string>("uiActions_UIAction", "Name of UI action",                _HELP("UIAction")),
  177.                 InputPortConfig<bool>("Strict",               false,                              "If true this node will log an error if the UIAction does not exist, otherwise it can be used in a more loose way."),
  178.                 InputPortConfig_Void("Start",                 "Start UI action"),
  179.                 InputPortConfig<string>("Args",               "Comma separated argument string"),
  180.                 { 0 }
  181.         };
  182.  
  183.         static const SOutputPortConfig out_config[] = {
  184.                 OutputPortConfig_Void("OnStart",    "Triggered if this node starts the action"),
  185.                 OutputPortConfig_Void("OnEnd",      "Triggered if action is stopped and was started by this node"),
  186.                 OutputPortConfig_Void("OnStartAll", "Always triggered if the action started"),
  187.                 OutputPortConfig_Void("OnEndAll",   "Always triggered if action is stopped"),
  188.                 OutputPortConfig<string>("Args",    "Comma separated argument string"),
  189.                 { 0 }
  190.         };
  191.  
  192.         config.pInputPorts = in_config;
  193.         config.pOutputPorts = out_config;
  194.         config.sDescription = "Controls an UI Action";
  195.         config.SetCategory(EFLN_APPROVED);
  196. }
  197.  
  198. void CFlashUIActionNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  199. {
  200.         switch (event)
  201.         {
  202.         case eFE_Initialize:
  203.                 m_bWasStarted = false;
  204.                 m_startStack.clear();
  205.                 m_endStack.clear();
  206.                 m_selfEndStack.clear();
  207.                 m_startStack.init(pActInfo->pGraph);
  208.                 m_endStack.init(pActInfo->pGraph);
  209.                 m_selfEndStack.init(pActInfo->pGraph);
  210.                 UpdateAction(GetPortString(pActInfo, eI_UIAction).c_str(), GetPortBool(pActInfo, eI_Strict));
  211.                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  212.                 break;
  213.         case eFE_Activate:
  214.                 UpdateAction(GetPortString(pActInfo, eI_UIAction).c_str(), GetPortBool(pActInfo, eI_Strict));
  215.  
  216.                 if (gEnv->pFlashUI && m_pAction)
  217.                 {
  218.                         if (IsPortActive(pActInfo, eI_StartAction))
  219.                         {
  220.                                 SUIArguments args(GetPortString(pActInfo, eI_Args).c_str(), true);
  221.                                 gEnv->pFlashUI->GetUIActionManager()->StartAction(m_pAction, args);
  222.                                 ActivateOutput(pActInfo, eO_UIOnStart, true);
  223.                                 m_bWasStarted = true;
  224.                         }
  225.                 }
  226.                 break;
  227.         case eFE_Update:
  228.                 FlushNextAction(pActInfo);
  229.                 break;
  230.         }
  231. }
  232.  
  233. void CFlashUIActionNode::OnStart(IUIAction* pAction, const SUIArguments& args)
  234. {
  235.         if (m_pAction != NULL && pAction == m_pAction)
  236.         {
  237.                 UI_STACK_PUSH(m_startStack, std::make_pair(pAction, args), "OnStart UIAction %s (%s)", pAction->GetName(), args.GetAsString());
  238.         }
  239. }
  240.  
  241. void CFlashUIActionNode::OnEnd(IUIAction* pAction, const SUIArguments& args)
  242. {
  243.         if (m_pAction != NULL && pAction == m_pAction)
  244.         {
  245.                 UI_STACK_PUSH(m_endStack, std::make_pair(pAction, args), "OnEnd UIAction %s (%s)", pAction->GetName(), args.GetAsString());
  246.                 if (m_bWasStarted)
  247.                 {
  248.                         m_bWasStarted = false;
  249.                         UI_STACK_PUSH(m_selfEndStack, std::make_pair(pAction, args), "OnEnd (self) UIAction %s (%s)", pAction->GetName(), args.GetAsString());
  250.                 }
  251.         }
  252. }
  253.  
  254. void CFlashUIActionNode::FlushNextAction(SActivationInfo* pActInfo)
  255. {
  256.         if (m_startStack.size() > 0)
  257.         {
  258.                 const SUIArguments& args = m_startStack.get().second;
  259.                 ActivateOutput(pActInfo, eO_UIOnStartAll, true);
  260.                 ActivateOutput(pActInfo, eO_Args, string(args.GetAsString()));
  261.                 m_startStack.pop();
  262.         }
  263.         else if (m_endStack.size() > 0)
  264.         {
  265.                 const SUIArguments& args = m_endStack.get().second;
  266.                 ActivateOutput(pActInfo, eO_UIOnEndAll, true);
  267.                 ActivateOutput(pActInfo, eO_Args, string(args.GetAsString()));
  268.                 m_endStack.pop();
  269.         }
  270.         else if (m_selfEndStack.size() > 0)
  271.         {
  272.                 const SUIArguments& args = m_selfEndStack.get().second;
  273.                 ActivateOutput(pActInfo, eO_UIOnEnd, true);
  274.                 ActivateOutput(pActInfo, eO_Args, string(args.GetAsString()));
  275.                 m_selfEndStack.pop();
  276.         }
  277. }
  278.  
  279. //--------------------------------------------------------------------------------------------
  280. REGISTER_FLOW_NODE("UI:Action:Start", CFlashUIStartActionNode);
  281. REGISTER_FLOW_NODE("UI:Action:End", CFlashUIEndActionNode);
  282. REGISTER_FLOW_NODE("UI:Action:Control", CFlashUIActionNode);
  283.  
downloadFlashUIActionNodes.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top