BVB Source Codes

CRYENGINE Show FlowXmlNavNodes.cpp Source code

Return Download CRYENGINE: download FlowXmlNavNodes.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:   FlowXmlNavNodes.cpp
  5. //  Description: Flowgraph nodes to read/write Xml files
  6. // -------------------------------------------------------------------------
  7. //  History:
  8. //    - 8/16/08 : File created - Kevin Kirst
  9. //    - 09/06/2011: Added to SDK - Sascha Hoba
  10. ////////////////////////////////////////////////////////////////////////////
  11.  
  12. #include "StdAfx.h"
  13. #include "FlowBaseXmlNode.h"
  14.  
  15. ////////////////////////////////////////////////////
  16. class CFlowXmlNode_NewChild : public CFlowXmlNode_Base
  17. {
  18.         enum EInputs
  19.         {
  20.                 EIP_Name = EIP_CustomStart,
  21.                 EIP_Active,
  22.         };
  23.  
  24. public:
  25.         ////////////////////////////////////////////////////
  26.         CFlowXmlNode_NewChild(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  27.         {
  28.  
  29.         }
  30.  
  31.         ////////////////////////////////////////////////////
  32.         virtual ~CFlowXmlNode_NewChild(void)
  33.         {
  34.  
  35.         }
  36.  
  37.         ////////////////////////////////////////////////////
  38.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  39.         {
  40.  
  41.         }
  42.  
  43.         ////////////////////////////////////////////////////
  44.         virtual void GetConfiguration(SFlowNodeConfig& config)
  45.         {
  46.                 // Define input ports here, in same order as EInputPorts
  47.                 static const SInputPortConfig inputs[] =
  48.                 {
  49.                         ADD_BASE_INPUTS(),
  50.                         InputPortConfig<string>("Name","",    _HELP("Name of child node"),                      0, 0),
  51.                         InputPortConfig<bool>("Active",true,  _HELP("Make new child node the active element")),
  52.                         { 0 }
  53.                 };
  54.  
  55.                 // Define output ports here, in same oreder as EOutputPorts
  56.                 static const SOutputPortConfig outputs[] =
  57.                 {
  58.                         ADD_BASE_OUTPUTS(),
  59.                         { 0 }
  60.                 };
  61.  
  62.                 // Fill in configuration
  63.                 config.pInputPorts = inputs;
  64.                 config.pOutputPorts = outputs;
  65.                 config.sDescription = _HELP("Creates a new child node at end of parent's sibling list.");
  66.                 config.SetCategory(EFLN_APPROVED);
  67.         }
  68.  
  69.         ////////////////////////////////////////////////////
  70.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  71.         {
  72.                 return new CFlowXmlNode_NewChild(pActInfo);
  73.         }
  74.  
  75.         ////////////////////////////////////////////////////
  76.         virtual void GetMemoryUsage(ICrySizer* s) const
  77.         {
  78.                 s->Add(*this);
  79.         }
  80.  
  81.         ////////////////////////////////////////////////////
  82.         virtual bool Execute(SActivationInfo* pActInfo)
  83.         {
  84.                 bool bResult = false;
  85.  
  86.                 SXmlDocument* doc;
  87.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  88.                 {
  89.                         XmlNodeRef ref = doc->active->newChild(GetPortString(pActInfo, EIP_Name));
  90.                         if (ref)
  91.                         {
  92.                                 if (GetPortBool(pActInfo, EIP_Active))
  93.                                 {
  94.                                         doc->active = ref;
  95.                                 }
  96.                                 bResult = true;
  97.                         }
  98.                 }
  99.  
  100.                 return bResult;
  101.         }
  102. };
  103.  
  104. ////////////////////////////////////////////////////
  105. class CFlowXmlNode_GetChild : public CFlowXmlNode_Base
  106. {
  107.         enum EInputs
  108.         {
  109.                 EIP_Name = EIP_CustomStart,
  110.                 EIP_Create,
  111.         };
  112.  
  113. public:
  114.         ////////////////////////////////////////////////////
  115.         CFlowXmlNode_GetChild(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  116.         {
  117.  
  118.         }
  119.  
  120.         ////////////////////////////////////////////////////
  121.         virtual ~CFlowXmlNode_GetChild(void)
  122.         {
  123.  
  124.         }
  125.  
  126.         ////////////////////////////////////////////////////
  127.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  128.         {
  129.  
  130.         }
  131.  
  132.         ////////////////////////////////////////////////////
  133.         virtual void GetConfiguration(SFlowNodeConfig& config)
  134.         {
  135.                 // Define input ports here, in same order as EInputPorts
  136.                 static const SInputPortConfig inputs[] =
  137.                 {
  138.                         ADD_BASE_INPUTS(),
  139.                         InputPortConfig<string>("Name","",     _HELP("Name of child node"),             0, 0),
  140.                         InputPortConfig<bool>("Create",false,  _HELP("Create child node if not found"), 0, 0),
  141.                         { 0 }
  142.                 };
  143.  
  144.                 // Define output ports here, in same oreder as EOutputPorts
  145.                 static const SOutputPortConfig outputs[] =
  146.                 {
  147.                         ADD_BASE_OUTPUTS(),
  148.                         { 0 }
  149.                 };
  150.  
  151.                 // Fill in configuration
  152.                 config.pInputPorts = inputs;
  153.                 config.pOutputPorts = outputs;
  154.                 config.sDescription = _HELP("Navigates into the first child node with the given name.");
  155.                 config.SetCategory(EFLN_APPROVED);
  156.         }
  157.  
  158.         ////////////////////////////////////////////////////
  159.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  160.         {
  161.                 return new CFlowXmlNode_GetChild(pActInfo);
  162.         }
  163.  
  164.         ////////////////////////////////////////////////////
  165.         virtual void GetMemoryUsage(ICrySizer* s) const
  166.         {
  167.                 s->Add(*this);
  168.         }
  169.  
  170.         ////////////////////////////////////////////////////
  171.         virtual bool Execute(SActivationInfo* pActInfo)
  172.         {
  173.                 bool bResult = false;
  174.  
  175.                 SXmlDocument* doc;
  176.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  177.                 {
  178.                         char const* name = GetPortString(pActInfo, EIP_Name);
  179.                         XmlNodeRef ref = doc->active->findChild(name);
  180.                         if (ref)
  181.                         {
  182.                                 doc->active = ref;
  183.                                 bResult = true;
  184.                         }
  185.                         else if (GetPortBool(pActInfo, EIP_Create))
  186.                         {
  187.                                 ref = doc->active->newChild(name);
  188.                                 if (ref)
  189.                                 {
  190.                                         doc->active = ref;
  191.                                         bResult = true;
  192.                                 }
  193.                         }
  194.                 }
  195.  
  196.                 return bResult;
  197.         }
  198. };
  199.  
  200. ////////////////////////////////////////////////////
  201. class CFlowXmlNode_GetChildAt : public CFlowXmlNode_Base
  202. {
  203.         enum EInputs
  204.         {
  205.                 EIP_Name = EIP_CustomStart,
  206.                 EIP_Index,
  207.         };
  208.  
  209. public:
  210.         ////////////////////////////////////////////////////
  211.         CFlowXmlNode_GetChildAt(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  212.         {
  213.  
  214.         }
  215.  
  216.         ////////////////////////////////////////////////////
  217.         virtual ~CFlowXmlNode_GetChildAt(void)
  218.         {
  219.  
  220.         }
  221.  
  222.         ////////////////////////////////////////////////////
  223.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  224.         {
  225.  
  226.         }
  227.  
  228.         ////////////////////////////////////////////////////
  229.         virtual void GetConfiguration(SFlowNodeConfig& config)
  230.         {
  231.                 // Define input ports here, in same order as EInputPorts
  232.                 static const SInputPortConfig inputs[] =
  233.                 {
  234.                         ADD_BASE_INPUTS(),
  235.                         InputPortConfig<string>("Name","",  _HELP("Name of child node"),                  0, 0),
  236.                         InputPortConfig<int>("Index",  1,   _HELP("Location of child in list (1-based)"), 0, 0),
  237.                         { 0 }
  238.                 };
  239.  
  240.                 // Define output ports here, in same oreder as EOutputPorts
  241.                 static const SOutputPortConfig outputs[] =
  242.                 {
  243.                         ADD_BASE_OUTPUTS(),
  244.                         { 0 }
  245.                 };
  246.  
  247.                 // Fill in configuration
  248.                 config.pInputPorts = inputs;
  249.                 config.pOutputPorts = outputs;
  250.                 config.sDescription = _HELP("Navigates into the Nth child node with the given name.");
  251.                 config.SetCategory(EFLN_APPROVED);
  252.         }
  253.  
  254.         ////////////////////////////////////////////////////
  255.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  256.         {
  257.                 return new CFlowXmlNode_GetChildAt(pActInfo);
  258.         }
  259.  
  260.         ////////////////////////////////////////////////////
  261.         virtual void GetMemoryUsage(ICrySizer* s) const
  262.         {
  263.                 s->Add(*this);
  264.         }
  265.  
  266.         ////////////////////////////////////////////////////
  267.         virtual bool Execute(SActivationInfo* pActInfo)
  268.         {
  269.                 bool bResult = false;
  270.  
  271.                 SXmlDocument* doc;
  272.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  273.                 {
  274.                         const string childName = GetPortString(pActInfo, EIP_Name);
  275.                         const int childIndex = GetPortInt(pActInfo, EIP_Index);
  276.                         const int childCount = doc->active->getChildCount();
  277.                         XmlNodeRef ref = NULL;
  278.                         for (int i = 0, realCount = 0; i < childCount; ++i)
  279.                         {
  280.                                 ref = doc->active->getChild(i);
  281.                                 if (ref && strcmp(ref->getTag(), childName) == 0)
  282.                                 {
  283.                                         if (++realCount >= childIndex)
  284.                                         {
  285.                                                 doc->active = ref;
  286.                                                 bResult = true;
  287.                                                 break;
  288.                                         }
  289.                                 }
  290.                         }
  291.                 }
  292.  
  293.                 return bResult;
  294.         }
  295. };
  296.  
  297. ////////////////////////////////////////////////////
  298. class CFlowXmlNode_GetChildCount : public CFlowXmlNode_Base
  299. {
  300.         enum EOutputs
  301.         {
  302.                 EOP_Count = EOP_CustomStart,
  303.         };
  304.  
  305. public:
  306.         ////////////////////////////////////////////////////
  307.         CFlowXmlNode_GetChildCount(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  308.         {
  309.  
  310.         }
  311.  
  312.         ////////////////////////////////////////////////////
  313.         virtual ~CFlowXmlNode_GetChildCount(void)
  314.         {
  315.  
  316.         }
  317.  
  318.         ////////////////////////////////////////////////////
  319.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  320.         {
  321.  
  322.         }
  323.  
  324.         ////////////////////////////////////////////////////
  325.         virtual void GetConfiguration(SFlowNodeConfig& config)
  326.         {
  327.                 // Define input ports here, in same order as EInputPorts
  328.                 static const SInputPortConfig inputs[] =
  329.                 {
  330.                         ADD_BASE_INPUTS(),
  331.                         { 0 }
  332.                 };
  333.  
  334.                 // Define output ports here, in same oreder as EOutputPorts
  335.                 static const SOutputPortConfig outputs[] =
  336.                 {
  337.                         ADD_BASE_OUTPUTS(),
  338.                         OutputPortConfig<int>("Count",_HELP("Number of children")),
  339.                         { 0 }
  340.                 };
  341.  
  342.                 // Fill in configuration
  343.                 config.pInputPorts = inputs;
  344.                 config.pOutputPorts = outputs;
  345.                 config.sDescription = _HELP("Returns number of children of the active element.");
  346.                 config.SetCategory(EFLN_APPROVED);
  347.         }
  348.  
  349.         ////////////////////////////////////////////////////
  350.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  351.         {
  352.                 return new CFlowXmlNode_GetChildCount(pActInfo);
  353.         }
  354.  
  355.         ////////////////////////////////////////////////////
  356.         virtual void GetMemoryUsage(ICrySizer* s) const
  357.         {
  358.                 s->Add(*this);
  359.         }
  360.  
  361.         ////////////////////////////////////////////////////
  362.         virtual bool Execute(SActivationInfo* pActInfo)
  363.         {
  364.                 bool bResult = false;
  365.  
  366.                 SXmlDocument* doc;
  367.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  368.                 {
  369.                         const int count = doc->active->getChildCount();
  370.                         ActivateOutput(pActInfo, EOP_Count, count);
  371.                         bResult = true;
  372.                 }
  373.  
  374.                 return bResult;
  375.         }
  376. };
  377.  
  378. ////////////////////////////////////////////////////
  379. class CFlowXmlNode_DeleteChild : public CFlowXmlNode_Base
  380. {
  381.         enum EInputs
  382.         {
  383.                 EIP_Name = EIP_CustomStart,
  384.         };
  385.  
  386. public:
  387.         ////////////////////////////////////////////////////
  388.         CFlowXmlNode_DeleteChild(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  389.         {
  390.  
  391.         }
  392.  
  393.         ////////////////////////////////////////////////////
  394.         virtual ~CFlowXmlNode_DeleteChild(void)
  395.         {
  396.  
  397.         }
  398.  
  399.         ////////////////////////////////////////////////////
  400.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  401.         {
  402.  
  403.         }
  404.  
  405.         ////////////////////////////////////////////////////
  406.         virtual void GetConfiguration(SFlowNodeConfig& config)
  407.         {
  408.                 // Define input ports here, in same order as EInputPorts
  409.                 static const SInputPortConfig inputs[] =
  410.                 {
  411.                         ADD_BASE_INPUTS(),
  412.                         InputPortConfig<string>("Name","",  _HELP("Name of child node"), 0, 0),
  413.                         { 0 }
  414.                 };
  415.  
  416.                 // Define output ports here, in same oreder as EOutputPorts
  417.                 static const SOutputPortConfig outputs[] =
  418.                 {
  419.                         ADD_BASE_OUTPUTS(),
  420.                         { 0 }
  421.                 };
  422.  
  423.                 // Fill in configuration
  424.                 config.pInputPorts = inputs;
  425.                 config.pOutputPorts = outputs;
  426.                 config.sDescription = _HELP("Deletes the first child node with the given name.");
  427.                 config.SetCategory(EFLN_APPROVED);
  428.         }
  429.  
  430.         ////////////////////////////////////////////////////
  431.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  432.         {
  433.                 return new CFlowXmlNode_DeleteChild(pActInfo);
  434.         }
  435.  
  436.         ////////////////////////////////////////////////////
  437.         virtual void GetMemoryUsage(ICrySizer* s) const
  438.         {
  439.                 s->Add(*this);
  440.         }
  441.  
  442.         ////////////////////////////////////////////////////
  443.         virtual bool Execute(SActivationInfo* pActInfo)
  444.         {
  445.                 bool bResult = false;
  446.  
  447.                 SXmlDocument* doc;
  448.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  449.                 {
  450.                         const string childName = GetPortString(pActInfo, EIP_Name);
  451.                         const int childCount = doc->active->getChildCount();
  452.                         XmlNodeRef ref = NULL;
  453.                         for (int i = 0; i < childCount; ++i)
  454.                         {
  455.                                 ref = doc->active->getChild(i);
  456.                                 if (ref && strcmp(ref->getTag(), childName) == 0)
  457.                                 {
  458.                                         doc->active->deleteChildAt(i);
  459.                                         bResult = true;
  460.                                         break;
  461.                                 }
  462.                         }
  463.                 }
  464.  
  465.                 return bResult;
  466.         }
  467. };
  468.  
  469. ////////////////////////////////////////////////////
  470. class CFlowXmlNode_DeleteChildAt : public CFlowXmlNode_Base
  471. {
  472.         enum EInputs
  473.         {
  474.                 EIP_Name = EIP_CustomStart,
  475.                 EIP_Index,
  476.         };
  477.  
  478. public:
  479.         ////////////////////////////////////////////////////
  480.         CFlowXmlNode_DeleteChildAt(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  481.         {
  482.  
  483.         }
  484.  
  485.         ////////////////////////////////////////////////////
  486.         virtual ~CFlowXmlNode_DeleteChildAt(void)
  487.         {
  488.  
  489.         }
  490.  
  491.         ////////////////////////////////////////////////////
  492.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  493.         {
  494.  
  495.         }
  496.  
  497.         ////////////////////////////////////////////////////
  498.         virtual void GetConfiguration(SFlowNodeConfig& config)
  499.         {
  500.                 // Define input ports here, in same order as EInputPorts
  501.                 static const SInputPortConfig inputs[] =
  502.                 {
  503.                         ADD_BASE_INPUTS(),
  504.                         InputPortConfig<string>("Name","",  _HELP("Name of child node"),                  0, 0),
  505.                         InputPortConfig<int>("Index",  1,   _HELP("Location of child in list (1-based)"), 0, 0),
  506.                         { 0 }
  507.                 };
  508.  
  509.                 // Define output ports here, in same oreder as EOutputPorts
  510.                 static const SOutputPortConfig outputs[] =
  511.                 {
  512.                         ADD_BASE_OUTPUTS(),
  513.                         { 0 }
  514.                 };
  515.  
  516.                 // Fill in configuration
  517.                 config.pInputPorts = inputs;
  518.                 config.pOutputPorts = outputs;
  519.                 config.sDescription = _HELP("Deletes the Nth child node with the given name.");
  520.                 config.SetCategory(EFLN_APPROVED);
  521.         }
  522.  
  523.         ////////////////////////////////////////////////////
  524.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  525.         {
  526.                 return new CFlowXmlNode_DeleteChildAt(pActInfo);
  527.         }
  528.  
  529.         ////////////////////////////////////////////////////
  530.         virtual void GetMemoryUsage(ICrySizer* s) const
  531.         {
  532.                 s->Add(*this);
  533.         }
  534.  
  535.         ////////////////////////////////////////////////////
  536.         virtual bool Execute(SActivationInfo* pActInfo)
  537.         {
  538.                 bool bResult = false;
  539.  
  540.                 SXmlDocument* doc;
  541.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  542.                 {
  543.                         const string childName = GetPortString(pActInfo, EIP_Name);
  544.                         const int childIndex = GetPortInt(pActInfo, EIP_Index);
  545.                         const int childCount = doc->active->getChildCount();
  546.                         XmlNodeRef ref = NULL;
  547.                         for (int i = 0, realCount = 0; i < childCount; ++i)
  548.                         {
  549.                                 ref = doc->active->getChild(i);
  550.                                 if (ref && strcmp(ref->getTag(), childName) == 0)
  551.                                 {
  552.                                         if (++realCount >= childIndex)
  553.                                         {
  554.                                                 doc->active->deleteChildAt(i);
  555.                                                 bResult = true;
  556.                                                 break;
  557.                                         }
  558.                                 }
  559.                         }
  560.                 }
  561.  
  562.                 return bResult;
  563.         }
  564. };
  565.  
  566. ////////////////////////////////////////////////////
  567. class CFlowXmlNode_DeleteAllChildren : public CFlowXmlNode_Base
  568. {
  569.         enum EInputs
  570.         {
  571.                 EIP_Name = EIP_CustomStart,
  572.         };
  573.  
  574. public:
  575.         ////////////////////////////////////////////////////
  576.         CFlowXmlNode_DeleteAllChildren(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  577.         {
  578.  
  579.         }
  580.  
  581.         ////////////////////////////////////////////////////
  582.         virtual ~CFlowXmlNode_DeleteAllChildren(void)
  583.         {
  584.  
  585.         }
  586.  
  587.         ////////////////////////////////////////////////////
  588.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  589.         {
  590.  
  591.         }
  592.  
  593.         ////////////////////////////////////////////////////
  594.         virtual void GetConfiguration(SFlowNodeConfig& config)
  595.         {
  596.                 // Define input ports here, in same order as EInputPorts
  597.                 static const SInputPortConfig inputs[] =
  598.                 {
  599.                         ADD_BASE_INPUTS(),
  600.                         InputPortConfig<string>("Name","",  _HELP("Optional child name - Specify to delete all children with matching name only"), 0, 0),
  601.                         { 0 }
  602.                 };
  603.  
  604.                 // Define output ports here, in same oreder as EOutputPorts
  605.                 static const SOutputPortConfig outputs[] =
  606.                 {
  607.                         ADD_BASE_OUTPUTS(),
  608.                         { 0 }
  609.                 };
  610.  
  611.                 // Fill in configuration
  612.                 config.pInputPorts = inputs;
  613.                 config.pOutputPorts = outputs;
  614.                 config.sDescription = _HELP("Deletes all children of the active element.");
  615.                 config.SetCategory(EFLN_APPROVED);
  616.         }
  617.  
  618.         ////////////////////////////////////////////////////
  619.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  620.         {
  621.                 return new CFlowXmlNode_DeleteAllChildren(pActInfo);
  622.         }
  623.  
  624.         ////////////////////////////////////////////////////
  625.         virtual void GetMemoryUsage(ICrySizer* s) const
  626.         {
  627.                 s->Add(*this);
  628.         }
  629.  
  630.         ////////////////////////////////////////////////////
  631.         virtual bool Execute(SActivationInfo* pActInfo)
  632.         {
  633.                 bool bResult = false;
  634.  
  635.                 SXmlDocument* doc;
  636.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  637.                 {
  638.                         char const* name = GetPortString(pActInfo, EIP_Name);
  639.                         if (!name || !name[0])
  640.                         {
  641.                                 doc->active->removeAllChilds();
  642.                         }
  643.                         else
  644.                         {
  645.                                 const int childCount = doc->active->getChildCount();
  646.                                 XmlNodeRef ref = NULL;
  647.                                 for (int i = 0; i < childCount; ++i)
  648.                                 {
  649.                                         ref = doc->active->getChild(i);
  650.                                         if (ref && strcmp(ref->getTag(), name) == 0)
  651.                                         {
  652.                                                 doc->active->deleteChildAt(i);
  653.                                         }
  654.                                 }
  655.                         }
  656.                         bResult = true;
  657.                 }
  658.  
  659.                 return bResult;
  660.         }
  661. };
  662.  
  663. ////////////////////////////////////////////////////
  664. class CFlowXmlNode_GetParent : public CFlowXmlNode_Base
  665. {
  666. public:
  667.         ////////////////////////////////////////////////////
  668.         CFlowXmlNode_GetParent(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  669.         {
  670.  
  671.         }
  672.  
  673.         ////////////////////////////////////////////////////
  674.         virtual ~CFlowXmlNode_GetParent(void)
  675.         {
  676.  
  677.         }
  678.  
  679.         ////////////////////////////////////////////////////
  680.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  681.         {
  682.  
  683.         }
  684.  
  685.         ////////////////////////////////////////////////////
  686.         virtual void GetConfiguration(SFlowNodeConfig& config)
  687.         {
  688.                 // Define input ports here, in same order as EInputPorts
  689.                 static const SInputPortConfig inputs[] =
  690.                 {
  691.                         ADD_BASE_INPUTS(),
  692.                         { 0 }
  693.                 };
  694.  
  695.                 // Define output ports here, in same oreder as EOutputPorts
  696.                 static const SOutputPortConfig outputs[] =
  697.                 {
  698.                         ADD_BASE_OUTPUTS(),
  699.                         { 0 }
  700.                 };
  701.  
  702.                 // Fill in configuration
  703.                 config.pInputPorts = inputs;
  704.                 config.pOutputPorts = outputs;
  705.                 config.sDescription = _HELP("Sets the active element to the current active element's parent (move one up).");
  706.                 config.SetCategory(EFLN_APPROVED);
  707.         }
  708.  
  709.         ////////////////////////////////////////////////////
  710.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  711.         {
  712.                 return new CFlowXmlNode_GetParent(pActInfo);
  713.         }
  714.  
  715.         ////////////////////////////////////////////////////
  716.         virtual void GetMemoryUsage(ICrySizer* s) const
  717.         {
  718.                 s->Add(*this);
  719.         }
  720.  
  721.         ////////////////////////////////////////////////////
  722.         virtual bool Execute(SActivationInfo* pActInfo)
  723.         {
  724.                 bool bResult = false;
  725.  
  726.                 SXmlDocument* doc;
  727.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->active)
  728.                 {
  729.                         XmlNodeRef ref = doc->active->getParent();
  730.                         if (ref)
  731.                         {
  732.                                 doc->active = ref;
  733.                                 bResult = true;
  734.                         }
  735.                 }
  736.  
  737.                 return bResult;
  738.         }
  739. };
  740.  
  741. ////////////////////////////////////////////////////
  742. class CFlowXmlNode_GetRoot : public CFlowXmlNode_Base
  743. {
  744. public:
  745.         ////////////////////////////////////////////////////
  746.         CFlowXmlNode_GetRoot(SActivationInfo* pActInfo) : CFlowXmlNode_Base(pActInfo)
  747.         {
  748.  
  749.         }
  750.  
  751.         ////////////////////////////////////////////////////
  752.         virtual ~CFlowXmlNode_GetRoot(void)
  753.         {
  754.  
  755.         }
  756.  
  757.         ////////////////////////////////////////////////////
  758.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  759.         {
  760.  
  761.         }
  762.  
  763.         ////////////////////////////////////////////////////
  764.         virtual void GetConfiguration(SFlowNodeConfig& config)
  765.         {
  766.                 // Define input ports here, in same order as EInputPorts
  767.                 static const SInputPortConfig inputs[] =
  768.                 {
  769.                         ADD_BASE_INPUTS(),
  770.                         { 0 }
  771.                 };
  772.  
  773.                 // Define output ports here, in same oreder as EOutputPorts
  774.                 static const SOutputPortConfig outputs[] =
  775.                 {
  776.                         ADD_BASE_OUTPUTS(),
  777.                         { 0 }
  778.                 };
  779.  
  780.                 // Fill in configuration
  781.                 config.pInputPorts = inputs;
  782.                 config.pOutputPorts = outputs;
  783.                 config.sDescription = _HELP("Sets the active element to the root node (move to top).");
  784.                 config.SetCategory(EFLN_APPROVED);
  785.         }
  786.  
  787.         ////////////////////////////////////////////////////
  788.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  789.         {
  790.                 return new CFlowXmlNode_GetRoot(pActInfo);
  791.         }
  792.  
  793.         ////////////////////////////////////////////////////
  794.         virtual void GetMemoryUsage(ICrySizer* s) const
  795.         {
  796.                 s->Add(*this);
  797.         }
  798.  
  799.         ////////////////////////////////////////////////////
  800.         virtual bool Execute(SActivationInfo* pActInfo)
  801.         {
  802.                 bool bResult = false;
  803.  
  804.                 SXmlDocument* doc;
  805.                 if (GDM->GetXmlDocument(pActInfo->pGraph, &doc) && doc->root)
  806.                 {
  807.                         doc->active = doc->root;
  808.                         bResult = true;
  809.                 }
  810.  
  811.                 return bResult;
  812.         }
  813. };
  814.  
  815. ////////////////////////////////////////////////////
  816. ////////////////////////////////////////////////////
  817.  
  818. REGISTER_FLOW_NODE("Xml:NewChild", CFlowXmlNode_NewChild);
  819. REGISTER_FLOW_NODE("Xml:GetChild", CFlowXmlNode_GetChild);
  820. REGISTER_FLOW_NODE("Xml:GetChildAt", CFlowXmlNode_GetChildAt);
  821. REGISTER_FLOW_NODE("Xml:GetChildCount", CFlowXmlNode_GetChildCount);
  822. REGISTER_FLOW_NODE("Xml:DeleteChild", CFlowXmlNode_DeleteChild);
  823. REGISTER_FLOW_NODE("Xml:DeleteChildAt", CFlowXmlNode_DeleteChildAt);
  824. REGISTER_FLOW_NODE("Xml:DeleteAllChildren", CFlowXmlNode_DeleteAllChildren);
  825. REGISTER_FLOW_NODE("Xml:GetParent", CFlowXmlNode_GetParent);
  826. REGISTER_FLOW_NODE("Xml:GetRoot", CFlowXmlNode_GetRoot);
  827.  
downloadFlowXmlNavNodes.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