BVB Source Codes

CRYENGINE Show FlashUIElementNodes.h Source code

Return Download CRYENGINE: download FlashUIElementNodes.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlashUIElementNodes.h
  5. //  Version:     v1.00
  6. //  Created:     10/9/2010 by Paul Reindell.
  7. //  Description:
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12. #ifndef __FlashUIElementNodes_H__
  13. #define __FlashUIElementNodes_H__
  14.  
  15. #include "FlashUIBaseNode.h"
  16.  
  17. ////////////////////////////////////////////////////////////////////////////
  18. #define IMPL_BASE_NODE(name, base, istmpl)                                                \
  19.   class name : public base                                                                \
  20.   {                                                                                       \
  21.   public:                                                                                 \
  22.     name(SActivationInfo * pActInfo) : base(pActInfo, istmpl) {}                          \
  23.     virtual IFlowNodePtr Clone(SActivationInfo * pActInfo) { return new name(pActInfo); } \
  24.   };
  25. #define IMPL_DEFAULT_NODE(name, base)  IMPL_BASE_NODE(name, base, false)
  26. #define IMPL_TEMPLATE_NODE(name, base) IMPL_BASE_NODE(name, base, true)
  27.  
  28. ////////////////////////////////////////////////////////////////////////////
  29. class CFlashUIVariableBaseNode : public CFlashUIBaseDescNode<eUOT_Variable>
  30. {
  31. public:
  32.         CFlashUIVariableBaseNode(SActivationInfo* pActInfo, bool isTemplate) : m_isTemplate(isTemplate) {}
  33.         virtual ~CFlashUIVariableBaseNode() {}
  34.  
  35.         virtual void GetConfiguration(SFlowNodeConfig& config);
  36.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  37.  
  38. private:
  39.         void SetVariable(IUIElement* pInstance, const TUIData& value) { pInstance->SetVariable(GetObjectDesc(), value, GetTmplDesc()); }
  40.         void GetVariable(IUIElement* pInstance, TUIData& value)       { pInstance->GetVariable(GetObjectDesc(), value, GetTmplDesc()); }
  41.  
  42.         void ConvertToUIData(const TFlowInputData& in, TUIData& out, SActivationInfo* pActInfo);
  43.  
  44. private:
  45.         enum EInputs
  46.         {
  47.                 eI_UIVariable = 0,
  48.                 eI_InstanceID,
  49.                 eI_TemplateInstanceName,
  50.                 eI_Set,
  51.                 eI_Get,
  52.                 eI_Value,
  53.         };
  54.  
  55.         enum EOutputs
  56.         {
  57.                 eO_OnSet = 0,
  58.                 eO_Value,
  59.         };
  60.  
  61.         inline bool IsTemplate() const { return m_isTemplate; }
  62.         inline int  GetInputPort(EInputs input)
  63.         {
  64.                 if (input <= eI_TemplateInstanceName)
  65.                         return (int) input;
  66.                 return m_isTemplate ? (int) input : (int) input - 1;
  67.         }
  68.         bool m_isTemplate;
  69. };
  70. ////////////////////////////////////////////////////////////////////////////
  71. IMPL_DEFAULT_NODE(CFlashUIVariableNode, CFlashUIVariableBaseNode);
  72. IMPL_TEMPLATE_NODE(CFlashUITmplVariableNode, CFlashUIVariableBaseNode);
  73.  
  74. ////////////////////////////////////////////////////////////////////////////
  75. class CFlashUIArrayBaseNode : public CFlashUIBaseDescNode<eUOT_Array>
  76. {
  77. public:
  78.         CFlashUIArrayBaseNode(SActivationInfo* pActInfo, bool isTemplate) : m_isTemplate(isTemplate) {}
  79.         virtual ~CFlashUIArrayBaseNode() {}
  80.  
  81.         virtual void GetConfiguration(SFlowNodeConfig& config);
  82.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  83.  
  84. private:
  85.         void SetArray(IUIElement* pInstance, const SUIArguments& array) { pInstance->SetArray(GetObjectDesc(), array, GetTmplDesc()); }
  86.         void GetArray(IUIElement* pInstance, SUIArguments& array)       { pInstance->GetArray(GetObjectDesc(), array, GetTmplDesc()); }
  87.  
  88. private:
  89.         enum EInputs
  90.         {
  91.                 eI_UIArray = 0,
  92.                 eI_InstanceID,
  93.                 eI_TemplateInstanceName,
  94.                 eI_Set,
  95.                 eI_Get,
  96.                 eI_Value,
  97.         };
  98.  
  99.         enum EOutputs
  100.         {
  101.                 eO_OnSet = 0,
  102.                 eO_Value,
  103.         };
  104.  
  105.         inline bool IsTemplate() const { return m_isTemplate; }
  106.         inline int  GetInputPort(EInputs input)
  107.         {
  108.                 if (input <= eI_TemplateInstanceName)
  109.                         return (int) input;
  110.                 return m_isTemplate ? (int) input : (int) input - 1;
  111.         }
  112.         bool m_isTemplate;
  113. };
  114.  
  115. ////////////////////////////////////////////////////////////////////////////
  116. IMPL_DEFAULT_NODE(CFlashUIArrayNode, CFlashUIArrayBaseNode);
  117. IMPL_TEMPLATE_NODE(CFlashUITmplArrayNode, CFlashUIArrayBaseNode);
  118.  
  119. ////////////////////////////////////////////////////////////////////////////
  120. ////////////////////////////////////////////////////////////////////////////
  121. ////////////////////////////////////////////////////////////////////////////
  122. class CFlashUIGotoAndPlayBaseNode : public CFlashUIBaseDescNode<eUOT_MovieClip>
  123. {
  124. public:
  125.         CFlashUIGotoAndPlayBaseNode(SActivationInfo* pActInfo, bool isTemplate) : m_isTemplate(isTemplate) {}
  126.         virtual ~CFlashUIGotoAndPlayBaseNode() {}
  127.  
  128.         virtual void GetConfiguration(SFlowNodeConfig& config);
  129.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  130.  
  131. private:
  132.         void GotoAndPlay(IUIElement* pElement, int frameId, const char* frameName);
  133.         void GotoAndStop(IUIElement* pElement, int frameId, const char* frameName);
  134.  
  135. private:
  136.         enum EInputs
  137.         {
  138.                 eI_UIMovieClip = 0,
  139.                 eI_InstanceID,
  140.                 eI_TemplateInstanceName,
  141.                 eI_GotoAndPlay,
  142.                 eI_GotoAndStop,
  143.                 eI_FrameNum,
  144.                 eI_FrameName,
  145.         };
  146.  
  147.         enum EOutputs
  148.         {
  149.                 eO_OnGotoAndPlay = 0,
  150.                 eO_OnGotoAndStop,
  151.         };
  152.  
  153.         inline bool IsTemplate() const { return m_isTemplate; }
  154.         inline int  GetInputPort(EInputs input)
  155.         {
  156.                 if (input <= eI_TemplateInstanceName)
  157.                         return (int) input;
  158.                 return m_isTemplate ? (int) input : (int) input - 1;
  159.         }
  160.         bool m_isTemplate;
  161. };
  162. ////////////////////////////////////////////////////////////////////////////
  163. IMPL_DEFAULT_NODE(CFlashUIGotoAndPlayNode, CFlashUIGotoAndPlayBaseNode);
  164. IMPL_TEMPLATE_NODE(CFlashUIGotoAndPlayTmplNode, CFlashUIGotoAndPlayBaseNode);
  165.  
  166. ////////////////////////////////////////////////////////////////////////////
  167. class CFlashUIMCVisibleBaseNode : public CFlashUIBaseDescNode<eUOT_MovieClip>
  168. {
  169. public:
  170.         CFlashUIMCVisibleBaseNode(SActivationInfo* pActInfo, bool isTemplate) : m_isTemplate(isTemplate) {}
  171.         virtual ~CFlashUIMCVisibleBaseNode() {}
  172.  
  173.         virtual void GetConfiguration(SFlowNodeConfig& config);
  174.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  175.  
  176. private:
  177.         void SetValues(IUIElement* pElement, bool bVisible, float alpha);
  178.         void GetValues(IUIElement* pElement, bool& bVisible, float& alpha);
  179.  
  180. private:
  181.         enum EInputs
  182.         {
  183.                 eI_UIMovieClip = 0,
  184.                 eI_InstanceID,
  185.                 eI_TemplateInstanceName,
  186.                 eI_Set,
  187.                 eI_Get,
  188.                 eI_Visible,
  189.                 eI_Alpha,
  190.         };
  191.  
  192.         enum EOutputs
  193.         {
  194.                 eO_OnSet = 0,
  195.                 eO_Visible,
  196.                 eO_Alpha,
  197.         };
  198.  
  199.         inline bool IsTemplate() const { return m_isTemplate; }
  200.         inline int  GetInputPort(EInputs input)
  201.         {
  202.                 if (input <= eI_TemplateInstanceName)
  203.                         return (int) input;
  204.                 return m_isTemplate ? (int) input : (int) input - 1;
  205.         }
  206.         bool m_isTemplate;
  207. };
  208. ////////////////////////////////////////////////////////////////////////////
  209. IMPL_DEFAULT_NODE(CFlashUIMCVisibleNode, CFlashUIMCVisibleBaseNode);
  210. IMPL_TEMPLATE_NODE(CFlashUIMCVisibleTmplNode, CFlashUIMCVisibleBaseNode);
  211.  
  212. ////////////////////////////////////////////////////////////////////////////
  213. class CFlashUIMCPosRotScaleBaseNode : public CFlashUIBaseDescNode<eUOT_MovieClip>
  214. {
  215. public:
  216.         CFlashUIMCPosRotScaleBaseNode(SActivationInfo* pActInfo, bool isTemplate) : m_isTemplate(isTemplate) {}
  217.         virtual ~CFlashUIMCPosRotScaleBaseNode() {}
  218.  
  219.         virtual void GetConfiguration(SFlowNodeConfig& config);
  220.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  221.  
  222. private:
  223.         void SetValues(IUIElement* pElement, const Vec3& vPos, const Vec3& vRot, const Vec3& vScale);
  224.         void GetValues(IUIElement* pElement, Vec3& vPos, Vec3& vRot, Vec3& vScale);
  225.  
  226. private:
  227.         enum EInputs
  228.         {
  229.                 eI_UIMovieClip = 0,
  230.                 eI_InstanceID,
  231.                 eI_TemplateInstanceName,
  232.                 eI_Set,
  233.                 eI_Get,
  234.                 eI_Pos,
  235.                 eI_Rot,
  236.                 eI_Scale,
  237.         };
  238.  
  239.         enum EOutputs
  240.         {
  241.                 eO_OnSet = 0,
  242.                 eO_Pos,
  243.                 eO_Rot,
  244.                 eO_Scale,
  245.         };
  246.  
  247.         inline bool IsTemplate() const { return m_isTemplate; }
  248.         inline int  GetInputPort(EInputs input)
  249.         {
  250.                 if (input <= eI_TemplateInstanceName)
  251.                         return (int) input;
  252.                 return m_isTemplate ? (int) input : (int) input - 1;
  253.         }
  254.         bool m_isTemplate;
  255. };
  256. ////////////////////////////////////////////////////////////////////////////
  257. IMPL_DEFAULT_NODE(CFlashUIMCPosRotScaleNode, CFlashUIMCPosRotScaleBaseNode);
  258. IMPL_TEMPLATE_NODE(CFlashUIMCPosRotScaleTmplNode, CFlashUIMCPosRotScaleBaseNode);
  259.  
  260. ////////////////////////////////////////////////////////////////////////////
  261. ////////////////////////////////////////////////////////////////////////////
  262. ////////////////////////////////////////////////////////////////////////////
  263. class CFlashUIMCTemplateCreateNode : public CFlowBaseNode<eNCT_Instanced>
  264. {
  265. public:
  266.         CFlashUIMCTemplateCreateNode(SActivationInfo* pActInfo) {}
  267.         virtual ~CFlashUIMCTemplateCreateNode() {}
  268.  
  269.         virtual void         GetMemoryUsage(ICrySizer* s) const { s->Add(*this); }
  270.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  271.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  272.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlashUIMCTemplateCreateNode(pActInfo); }
  273.  
  274. private:
  275.         void CreateMoviclip(IUIElement* pElement, const SUIMovieClipDesc* pTemplate, const SUIMovieClipDesc* pParent, string& newname);
  276.  
  277. private:
  278.         enum EInputs
  279.         {
  280.                 eI_UIMovieClipTmpl = 0,
  281.                 eI_UIParentMovieClip,
  282.                 eI_InstanceID,
  283.                 eI_NewInstanceName,
  284.                 eI_Create,
  285.         };
  286.  
  287.         enum EOutputs
  288.         {
  289.                 eO_OnCreate = 0,
  290.                 eO_InstanceName,
  291.         };
  292.  
  293.         CFlashUIBaseDescNode<eUOT_MovieClipTmpl> m_TmplDescHelper;
  294.         CFlashUIBaseDescNode<eUOT_MovieClip>     m_ParentDescHelper;
  295.  
  296.         inline IUIElement*             GetElement() const      { return m_TmplDescHelper.GetElement(); }
  297.         inline const SUIMovieClipDesc* GetTemplateDesc() const { return m_TmplDescHelper.GetObjectDesc(); }
  298.         inline const SUIMovieClipDesc* GetParentDesc() const   { return m_ParentDescHelper.GetObjectDesc(); }
  299. };
  300.  
  301. ////////////////////////////////////////////////////////////////////////////
  302. class CFlashUIMCTemplateRemoveNode : public CFlashUIBaseDescNode<eUOT_MovieClipTmpl>
  303. {
  304. public:
  305.         CFlashUIMCTemplateRemoveNode(SActivationInfo* pActInfo) {}
  306.         virtual ~CFlashUIMCTemplateRemoveNode() {}
  307.  
  308.         virtual void GetConfiguration(SFlowNodeConfig& config);
  309.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  310.  
  311. private:
  312.         void RemoveMoviclip(IUIElement* pElement, const SUIMovieClipDesc* pMc) { pElement->RemoveMovieClip(pMc); }
  313.  
  314. private:
  315.         enum EInputs
  316.         {
  317.                 eI_UIElement = 0,
  318.                 eI_InstanceID,
  319.                 eI_TemplateInstanceName,
  320.                 eI_Remove,
  321.         };
  322.  
  323.         enum EOutputs
  324.         {
  325.                 eO_OnRemove = 0,
  326.         };
  327. };
  328.  
  329. ////////////////////////////////////////////////////////////////////////////
  330. ////////////////////////////////////////////////////////////////////////////
  331. ////////////////////////////////////////////////////////////////////////////
  332. class CFlashUIEventNode
  333.         : public CFlashUIBaseElementNode
  334.           , public IUIElementEventListener
  335. {
  336. public:
  337.         CFlashUIEventNode(IUIElement* pUIElement, string sCategory, const SUIEventDesc* pEventDesc);
  338.         virtual ~CFlashUIEventNode();
  339.  
  340.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo);
  341.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  342.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  343.  
  344.         virtual void         OnUIEvent(IUIElement* pSender, const SUIEventDesc& event, const SUIArguments& args);
  345.         virtual void         OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance);
  346.  
  347. private:
  348.         void RegisterAsListener(IUIElement* pInstance) { pInstance->AddEventListener(this, "CFlashUIEventNode"); }
  349.         void ClearListener();
  350.         void FlushNextEvent(SActivationInfo* pActInfo);
  351.  
  352. private:
  353.         enum EInputs
  354.         {
  355.                 eI_InstanceID = 0,
  356.                 eI_CheckPort,
  357.                 eI_CheckValue,
  358.         };
  359.  
  360.         enum EOutputs
  361.         {
  362.                 eO_OnEvent = 0,
  363.                 eO_OnInstanceId,
  364.                 eO_DynamicPorts,
  365.         };
  366.  
  367.         std::vector<SOutputPortConfig> m_outPorts;
  368.         std::vector<SInputPortConfig>  m_inPorts;
  369.         SUIEventDesc                   m_eventDesc;
  370.  
  371.         int                            m_iCurrInstanceId;
  372.  
  373.         typedef CUIStack<std::pair<SUIArguments, int>> TEventStack;
  374.         TEventStack m_events;
  375. };
  376.  
  377. ////////////////////////////////////////////////////////////////////////////
  378. ////////////////////////////////////////////////////////////////////////////
  379. ////////////////////////////////////////////////////////////////////////////
  380. class CFlashUIFunctionNode
  381.         : public CFlashUIBaseElementNode
  382. {
  383. public:
  384.         CFlashUIFunctionNode(IUIElement* pUIElement, string sCategory, const SUIEventDesc* pFuncDesc, bool isTemplate);
  385.         virtual ~CFlashUIFunctionNode();
  386.  
  387.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo);
  388.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  389.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  390.  
  391. private:
  392.         void CallFunction(IUIElement* pInstance, const SUIArguments& args, TUIData& res) { pInstance->CallFunction(&m_funcDesc, args, &res, m_pTmplDesc); }
  393.  
  394.         bool UpdateTmplDesc(const string& sInputStr, SActivationInfo* pActInfo)
  395.         {
  396.                 m_pTmplDesc = NULL;
  397.                 if (m_pElement)
  398.                 {
  399.                         m_pTmplDesc = m_pElement->GetMovieClipDesc(sInputStr.c_str());
  400.                         if (!m_pTmplDesc)
  401.                         {
  402.                                 UIACTION_WARNING("FG: UIElement \"%s\" does not have template \"%s\", referenced at node \"%s\"", m_pElement->GetName(), sInputStr.c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  403.                         }
  404.                         return true;
  405.                 }
  406.                 UIACTION_WARNING("FG: Invalid UIElement, referenced at node \"%s\"", pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  407.                 return false;
  408.         }
  409.  
  410. private:
  411.         enum EInputs
  412.         {
  413.                 eI_Call = 0,
  414.                 eI_InstanceID,
  415.                 eI_TemplateInstanceName,
  416.                 eI_DynamicPorts,
  417.         };
  418.  
  419.         enum EOutputs
  420.         {
  421.                 eO_OnCall = 0,
  422.                 eO_RetVal,
  423.         };
  424.  
  425.         inline bool IsTemplate() const { return m_isTemplate; }
  426.         inline int  GetDynStartPort()  { return m_isTemplate ? (int) eI_DynamicPorts : (int) eI_DynamicPorts - 1; }
  427.  
  428.         bool                          m_isTemplate;
  429.         SUIEventDesc                  m_funcDesc;
  430.         std::vector<SInputPortConfig> m_inPorts;
  431.         const SUIMovieClipDesc*       m_pTmplDesc;
  432. };
  433.  
  434. ////////////////////////////////////////////////////////////////////////////
  435. ////////////////////////////////////////////////////////////////////////////
  436. ////////////////////////////////////////////////////////////////////////////
  437. class CFlashUIElementListenerNode
  438.         : public CFlashUIBaseNode
  439.           , public IUIElementEventListener
  440. {
  441. public:
  442.         CFlashUIElementListenerNode(SActivationInfo* pActInfo);
  443.         virtual ~CFlashUIElementListenerNode();
  444.  
  445.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  446.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  447.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlashUIElementListenerNode(pActInfo); }
  448.  
  449.         virtual void         OnInit(IUIElement* pSender, IFlashPlayer* pFlashPlayer);
  450.         virtual void         OnUnload(IUIElement* pSender);
  451.         virtual void         OnSetVisible(IUIElement* pSender, bool bVisible);
  452.         virtual void         OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance);
  453.  
  454. private:
  455.         void RegisterAsListener(IUIElement* pInstance) { pInstance->AddEventListener(this, "CFlashUIElementListenerNode"); }
  456.         void ClearListener();
  457.         void FlushNextEvent(SActivationInfo* pActInfo);
  458.  
  459. private:
  460.         enum EInputs
  461.         {
  462.                 eI_UIElement = 0,
  463.                 eI_InstanceID,
  464.         };
  465.         enum EOutputs
  466.         {
  467.                 eO_InstanceId = 0,
  468.                 eO_OnInit,
  469.                 eO_OnUnload,
  470.                 eO_OnShow,
  471.                 eO_OnHide,
  472.         };
  473.  
  474.         typedef CUIStack<std::pair<EOutputs, int>> TEventStack;
  475.         TEventStack m_events;
  476.  
  477.         int         m_iCurrInstanceId;
  478. };
  479.  
  480. ////////////////////////////////////////////////////////////////////////////
  481. class CFlashUIElementInstanceNode
  482.         : public CFlashUIBaseNode
  483.           , public IUIElementEventListener
  484. {
  485. public:
  486.         CFlashUIElementInstanceNode(SActivationInfo* pActInfo) {}
  487.         virtual ~CFlashUIElementInstanceNode();
  488.  
  489.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  490.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  491.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlashUIElementInstanceNode(pActInfo); }
  492.  
  493.         virtual void         OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance);
  494.         virtual void         OnInstanceDestroyed(IUIElement* pSender, IUIElement* pDeletedInstance);
  495.  
  496. private:
  497.         void DestroyInstance(IUIElement* pInstance) { pInstance->DestroyThis(); }
  498.         void FlushNextEvent(SActivationInfo* pActInfo);
  499.  
  500. private:
  501.         enum EInputs
  502.         {
  503.                 eI_UIElement = 0,
  504.                 eI_InstanceID,
  505.                 eI_DestroyInstance,
  506.         };
  507.         enum EOutputs
  508.         {
  509.                 eO_InstanceId = 0,
  510.                 eO_OnNewInstance,
  511.                 eO_OnInstanceDestroyed,
  512.         };
  513.  
  514.         typedef CUIStack<std::pair<EOutputs, int>> TEventStack;
  515.         TEventStack m_events;
  516. };
  517. ////////////////////////////////////////////////////////////////////////////
  518.  
  519. #endif //#ifndef __FlashUIElementNodes_H__
  520.  
downloadFlashUIElementNodes.h 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