BVB Source Codes

CRYENGINE Show ScriptBind_UIAction.cpp Source code

Return Download CRYENGINE: download ScriptBind_UIAction.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:   ScriptBind_UIAction.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 "ScriptBind_UIAction.h"
  14. #include "FlashUI.h"
  15.  
  16. //------------------------------------------------------------------------
  17. CScriptBind_UIAction::CScriptBind_UIAction()
  18. {
  19.         CScriptableBase::Init(gEnv->pScriptSystem, gEnv->pSystem);
  20.         SetGlobalName("UIAction");
  21.  
  22.         RegisterMethods();
  23.  
  24.         if (gEnv->pFlashUI)
  25.         {
  26.                 gEnv->pFlashUI->RegisterModule(this, "CScriptBind_UIAction");
  27.         }
  28. }
  29.  
  30. //------------------------------------------------------------------------
  31. CScriptBind_UIAction::~CScriptBind_UIAction()
  32. {
  33.         if (gEnv->pFlashUI)
  34.         {
  35.                 gEnv->pFlashUI->UnregisterModule(this);
  36.         }
  37. }
  38.  
  39. //------------------------------------------------------------------------
  40. void CScriptBind_UIAction::RegisterMethods()
  41. {
  42. #undef SCRIPT_REG_CLASSNAME
  43. #define SCRIPT_REG_CLASSNAME &CScriptBind_UIAction::
  44.  
  45.         SCRIPT_REG_TEMPLFUNC(ReloadElement, "elementName, instanceID");
  46.         SCRIPT_REG_TEMPLFUNC(UnloadElement, "elementName, instanceID");
  47.         SCRIPT_REG_TEMPLFUNC(ShowElement, "elementName, instanceID");
  48.         SCRIPT_REG_TEMPLFUNC(HideElement, "elementName, instanceID");
  49.         SCRIPT_REG_TEMPLFUNC(RequestHide, "elementName, instanceID");
  50.  
  51.         SCRIPT_REG_TEMPLFUNC(CallFunction, "elementName, instanceID, functionName");
  52.         SCRIPT_REG_TEMPLFUNC(SetVariable, "elementName, instanceID, varName");
  53.         SCRIPT_REG_TEMPLFUNC(GetVariable, "elementName, instanceID, varName");
  54.         SCRIPT_REG_TEMPLFUNC(SetArray, "elementName, instanceID, arrayName");
  55.         SCRIPT_REG_TEMPLFUNC(GetArray, "elementName, instanceID, arrayName");
  56.  
  57.         SCRIPT_REG_TEMPLFUNC(GotoAndPlay, "elementName, instanceID, mcName, frameNum");
  58.         SCRIPT_REG_TEMPLFUNC(GotoAndStop, "elementName, instanceID, mcName, frameNum");
  59.         SCRIPT_REG_TEMPLFUNC(GotoAndPlayFrameName, "elementName, instanceID, mcName, frameName");
  60.         SCRIPT_REG_TEMPLFUNC(GotoAndStopFrameName, "elementName, instanceID, mcName, frameName");
  61.  
  62.         SCRIPT_REG_TEMPLFUNC(SetAlpha, "elementName, instanceID, mcName, fAlpha");
  63.         SCRIPT_REG_TEMPLFUNC(GetAlpha, "elementName, instanceID, mcName");
  64.         SCRIPT_REG_TEMPLFUNC(SetVisible, "elementName, instanceID, mcName, bVisible");
  65.         SCRIPT_REG_TEMPLFUNC(IsVisible, "elementName, instanceID, mcName");
  66.  
  67.         SCRIPT_REG_TEMPLFUNC(SetPos, "elementName, instanceID, mcName, vPos");
  68.         SCRIPT_REG_TEMPLFUNC(GetPos, "elementName, instanceID, mcName");
  69.         SCRIPT_REG_TEMPLFUNC(SetRotation, "elementName, instanceID, mcName, vRotation");
  70.         SCRIPT_REG_TEMPLFUNC(GetRotation, "elementName, instanceID, mcName");
  71.         SCRIPT_REG_TEMPLFUNC(SetScale, "elementName, instanceID, mcName, vScale");
  72.         SCRIPT_REG_TEMPLFUNC(GetScale, "elementName, instanceID, mcName");
  73.  
  74.         SCRIPT_REG_TEMPLFUNC(StartAction, "actionName");
  75.         SCRIPT_REG_TEMPLFUNC(EndAction, "actionName, disable");
  76.         SCRIPT_REG_TEMPLFUNC(EnableAction, "actionName");
  77.         SCRIPT_REG_TEMPLFUNC(DisableAction, "actionName");
  78.  
  79.         SCRIPT_REG_TEMPLFUNC(RegisterElementListener, "scripttable, elementName, instanceID, eventName, callback");
  80.         SCRIPT_REG_TEMPLFUNC(RegisterActionListener, "scripttable, actionName, eventName, callback");
  81.         SCRIPT_REG_TEMPLFUNC(RegisterEventSystemListener, "scripttable, eventSystem, eventName, callback");
  82.         SCRIPT_REG_TEMPLFUNC(UnregisterElementListener, "scripttable, callback");
  83.         SCRIPT_REG_TEMPLFUNC(UnregisterActionListener, "scripttable, callback");
  84.         SCRIPT_REG_TEMPLFUNC(UnregisterEventSystemListener, "scripttable, callback");
  85. }
  86.  
  87. //------------------------------------------------------------------------
  88. IUIElement* CScriptBind_UIAction::GetElement(const char* sName, int instanceID, bool bSupressWarning)
  89. {
  90.         if (gEnv->IsDedicated())
  91.                 return NULL;
  92.  
  93.         CRY_ASSERT_MESSAGE(gEnv->pFlashUI, "FlashUI extension does not exist!");
  94.         if (!gEnv->pFlashUI)
  95.         {
  96.                 UIACTION_WARNING("LUA: FlashUI extension does not exist!");
  97.                 return NULL;
  98.         }
  99.  
  100.         IUIElement* pElement = gEnv->pFlashUI->GetUIElement(sName);
  101.         if (pElement && instanceID > 0)
  102.                 pElement = pElement->GetInstance(instanceID);
  103.  
  104.         if (pElement && pElement->IsValid())
  105.                 return pElement;
  106.  
  107.         if (!bSupressWarning)
  108.         {
  109.                 UIACTION_WARNING("LUA: Try to access UIElement %s that is not valid!", sName);
  110.         }
  111.         return NULL;
  112. }
  113.  
  114. //------------------------------------------------------------------------
  115. IUIAction* CScriptBind_UIAction::GetAction(const char* sName)
  116. {
  117.         if (gEnv->IsDedicated())
  118.                 return NULL;
  119.  
  120.         CRY_ASSERT_MESSAGE(gEnv->pFlashUI, "FlashUI extension does not exist!");
  121.         if (!gEnv->pFlashUI)
  122.         {
  123.                 UIACTION_WARNING("LUA: FlashUI extension does not exist!");
  124.                 return NULL;
  125.         }
  126.  
  127.         IUIAction* pAction = gEnv->pFlashUI->GetUIAction(sName);
  128.         if (pAction && pAction->IsValid())
  129.                 return pAction;
  130.  
  131.         UIACTION_WARNING("LUA: Try to access UIAction %s that is not valid!", sName);
  132.         return NULL;
  133. }
  134.  
  135. //------------------------------------------------------------------------
  136. IUIEventSystem* CScriptBind_UIAction::GetEventSystem(const char* sName, IUIEventSystem::EEventSystemType type)
  137. {
  138.         if (gEnv->IsDedicated())
  139.                 return NULL;
  140.  
  141.         CRY_ASSERT_MESSAGE(gEnv->pFlashUI, "FlashUI extension does not exist!");
  142.         if (!gEnv->pFlashUI)
  143.         {
  144.                 UIACTION_WARNING("LUA: FlashUI extension does not exist!");
  145.                 return NULL;
  146.         }
  147.  
  148.         return gEnv->pFlashUI->GetEventSystem(sName, type);
  149. }
  150.  
  151. //------------------------------------------------------------------------
  152. int CScriptBind_UIAction::ReloadElement(IFunctionHandler* pH, const char* elementName, int instanceID)
  153. {
  154.         IUIElement* pElement = GetElement(elementName, instanceID);
  155.         if (pElement)
  156.         {
  157.                 if (instanceID < 0)
  158.                 {
  159.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  160.                         while (IUIElement* pInstance = elements->Next())
  161.                                 pInstance->Reload();
  162.                 }
  163.                 else
  164.                 {
  165.                         pElement->Reload();
  166.                 }
  167.                 return pH->EndFunction(true);
  168.         }
  169.         UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  170.         return pH->EndFunction(false);
  171. }
  172.  
  173. //------------------------------------------------------------------------
  174. int CScriptBind_UIAction::UnloadElement(IFunctionHandler* pH, const char* elementName, int instanceID)
  175. {
  176.         IUIElement* pElement = GetElement(elementName, instanceID);
  177.         if (pElement)
  178.         {
  179.                 if (instanceID < 0)
  180.                 {
  181.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  182.                         while (IUIElement* pInstance = elements->Next())
  183.                                 pInstance->Unload();
  184.                 }
  185.                 else
  186.                 {
  187.                         pElement->Unload();
  188.                 }
  189.                 return pH->EndFunction(true);
  190.         }
  191.         UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  192.         return pH->EndFunction(false);
  193. }
  194.  
  195. //------------------------------------------------------------------------
  196. int CScriptBind_UIAction::ShowElement(IFunctionHandler* pH, const char* elementName, int instanceID)
  197. {
  198.         IUIElement* pElement = GetElement(elementName, instanceID);
  199.         if (pElement)
  200.         {
  201.                 if (instanceID < 0)
  202.                 {
  203.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  204.                         while (IUIElement* pInstance = elements->Next())
  205.                                 pInstance->SetVisible(true);
  206.                 }
  207.                 else
  208.                 {
  209.                         pElement->SetVisible(true);
  210.                 }
  211.                 return pH->EndFunction(true);
  212.         }
  213.         UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  214.         return pH->EndFunction(false);
  215. }
  216.  
  217. //------------------------------------------------------------------------
  218. int CScriptBind_UIAction::HideElement(IFunctionHandler* pH, const char* elementName, int instanceID)
  219. {
  220.         IUIElement* pElement = GetElement(elementName, instanceID);
  221.         if (pElement)
  222.         {
  223.                 if (instanceID < 0)
  224.                 {
  225.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  226.                         while (IUIElement* pInstance = elements->Next())
  227.                                 pInstance->SetVisible(false);
  228.                 }
  229.                 else
  230.                 {
  231.                         pElement->SetVisible(false);
  232.                 }
  233.                 return pH->EndFunction(true);
  234.         }
  235.         UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  236.         return pH->EndFunction(false);
  237. }
  238.  
  239. //------------------------------------------------------------------------
  240. int CScriptBind_UIAction::RequestHide(IFunctionHandler* pH, const char* elementName, int instanceID)
  241. {
  242.         IUIElement* pElement = GetElement(elementName, instanceID);
  243.         if (pElement)
  244.         {
  245.                 if (instanceID < 0)
  246.                 {
  247.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  248.                         while (IUIElement* pInstance = elements->Next())
  249.                                 pInstance->RequestHide();
  250.                 }
  251.                 else
  252.                 {
  253.                         pElement->RequestHide();
  254.                 }
  255.                 return pH->EndFunction(true);
  256.         }
  257.         UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  258.         return pH->EndFunction(false);
  259. }
  260.  
  261. //------------------------------------------------------------------------
  262. int CScriptBind_UIAction::CallFunction(IFunctionHandler* pH, const char* elementName, int instanceID, const char* functionName)
  263. {
  264.         SUIArguments args;
  265.         if (!SUIToLuaConversationHelper::LuaArgsToUIArgs(pH, 4, args))
  266.         {
  267.                 UIACTION_WARNING("LUA: Failed to call function %s on element %s: Invalid arguments", functionName, elementName);
  268.                 return pH->EndFunction(false);
  269.         }
  270.  
  271.         IUIElement* pElement = GetElement(elementName, instanceID, true);
  272.         if (pElement)
  273.         {
  274.                 const SUIEventDesc* pFctDesc = pElement->GetFunctionDesc(functionName);
  275.                 if (pFctDesc)
  276.                 {
  277.                         TUIData res;
  278.                         bool bFctOk = true;
  279.                         if (instanceID < 0)
  280.                         {
  281.                                 IUIElementIteratorPtr elements = pElement->GetInstances();
  282.                                 while (IUIElement* pInstance = elements->Next())
  283.                                         bFctOk &= pInstance->CallFunction(pFctDesc, args, &res);
  284.                         }
  285.                         else
  286.                         {
  287.                                 bFctOk = pElement->CallFunction(pFctDesc, args, &res);
  288.                         }
  289.                         if (bFctOk)
  290.                         {
  291.                                 string sRes;
  292.                                 res.GetValueWithConversion(sRes);
  293.                                 return pH->EndFunction(sRes.c_str());
  294.                         }
  295.                 }
  296.                 UIACTION_WARNING("LUA: UIElement %s does not have function %s", elementName, functionName);
  297.         }
  298.         else if (IUIEventSystem* pEventSystem = GetEventSystem(elementName, IUIEventSystem::eEST_UI_TO_SYSTEM))
  299.         {
  300.                 uint eventid = pEventSystem->GetEventId(functionName);
  301.                 if (eventid != ~0)
  302.                 {
  303.                         SUIArguments res = pEventSystem->SendEvent(SUIEvent(eventid, args));
  304.                         SmartScriptTable table = gEnv->pScriptSystem->CreateTable();
  305.                         SUIToLuaConversationHelper::UIArgsToLuaTable(res, table);
  306.                         return pH->EndFunction(table);
  307.                 }
  308.                 UIACTION_WARNING("LUA: UIEventSystem %s does not have event %s", elementName, functionName);
  309.         }
  310.         else
  311.         {
  312.                 UIACTION_WARNING("LUA: UIElement or UIEventSystem %s does not exist", elementName);
  313.         }
  314.         return pH->EndFunction(false);
  315. }
  316.  
  317. //------------------------------------------------------------------------
  318. int CScriptBind_UIAction::SetVariable(IFunctionHandler* pH, const char* elementName, int instanceID, const char* varName)
  319. {
  320.         if (pH->GetParamCount() != 4)
  321.         {
  322.                 UIACTION_ERROR("LUA: UIAction.SetVariable - wrong number of arguments!");
  323.                 return pH->EndFunction(false);
  324.         }
  325.  
  326.         IUIElement* pElement = GetElement(elementName, instanceID);
  327.         if (pElement)
  328.         {
  329.                 const SUIParameterDesc* pVarDesc = pElement->GetVariableDesc(varName);
  330.                 if (pVarDesc)
  331.                 {
  332.                         bool bRet = true;
  333.                         TUIData value;
  334.                         if (SUIToLuaConversationHelper::LuaArgToUIArg(pH, 4, value))
  335.                         {
  336.                                 bool bVarOk = true;
  337.                                 if (instanceID < 0)
  338.                                 {
  339.                                         IUIElementIteratorPtr elements = pElement->GetInstances();
  340.                                         while (IUIElement* pInstance = elements->Next())
  341.                                                 bVarOk &= pInstance->SetVariable(pVarDesc, value);
  342.                                 }
  343.                                 else
  344.                                 {
  345.                                         bVarOk = pElement->SetVariable(pVarDesc, value);
  346.                                 }
  347.  
  348.                                 if (bVarOk)
  349.                                         return pH->EndFunction(true);
  350.                                 else
  351.                                 {
  352.                                         UIACTION_WARNING("LUA: Element %s has no variable %s", elementName, varName);
  353.                                 }
  354.                         }
  355.                         else
  356.                         {
  357.                                 UIACTION_WARNING("LUA: Element %s: wrong datatype for variable %s", elementName, varName);
  358.                         }
  359.                 }
  360.                 else
  361.                 {
  362.                         UIACTION_WARNING("LUA: Element %s has no variable %s", elementName, varName);
  363.                 }
  364.         }
  365.         else
  366.         {
  367.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  368.         }
  369.         return pH->EndFunction(false);
  370. }
  371.  
  372. //------------------------------------------------------------------------
  373. int CScriptBind_UIAction::GetVariable(IFunctionHandler* pH, const char* elementName, int instanceID, const char* varName)
  374. {
  375.         IUIElement* pElement = GetElement(elementName, instanceID);
  376.         if (pElement)
  377.         {
  378.                 const SUIParameterDesc* pVarDesc = pElement->GetVariableDesc(varName);
  379.                 if (pVarDesc)
  380.                 {
  381.                         TUIData value;
  382.                         if (pElement->GetVariable(pVarDesc, value))
  383.                         {
  384.                                 bool ok;
  385.                                 ScriptAnyValue res = SUIToLuaConversationHelper::UIValueToLuaValue(value, ok);
  386.                                 if (!ok)
  387.                                 {
  388.                                         UIACTION_WARNING("LUA: Error reading variable %s from UI Element %s", varName, elementName);
  389.                                 }
  390.                                 return pH->EndFunctionAny(res);
  391.                         }
  392.                 }
  393.                 UIACTION_WARNING("LUA: Element %s has no variable %s", elementName, varName);
  394.         }
  395.         else
  396.         {
  397.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  398.         }
  399.         return pH->EndFunction(false);
  400. }
  401.  
  402. //------------------------------------------------------------------------
  403. int CScriptBind_UIAction::SetArray(IFunctionHandler* pH, const char* elementName, int instanceID, const char* arrayName, SmartScriptTable values)
  404. {
  405.         IUIElement* pElement = GetElement(elementName, instanceID);
  406.         if (pElement)
  407.         {
  408.                 const SUIParameterDesc* pArrayDesc = pElement->GetArrayDesc(arrayName);
  409.                 if (pArrayDesc)
  410.                 {
  411.                         SUIArguments vals;
  412.                         if (SUIToLuaConversationHelper::LuaTableToUIArgs(values, vals))
  413.                         {
  414.                                 bool bVarOk = true;
  415.                                 if (instanceID < 0)
  416.                                 {
  417.                                         IUIElementIteratorPtr elements = pElement->GetInstances();
  418.                                         while (IUIElement* pInstance = elements->Next())
  419.                                                 bVarOk &= pInstance->SetArray(pArrayDesc, vals);
  420.                                 }
  421.                                 else
  422.                                 {
  423.                                         bVarOk = pElement->SetArray(pArrayDesc, vals);
  424.                                 }
  425.  
  426.                                 if (bVarOk)
  427.                                         return pH->EndFunction(true);
  428.                         }
  429.                         UIACTION_ERROR("LUA: Failed to set array %s on Element %s: Invalid arguments", arrayName, elementName);
  430.                 }
  431.                 UIACTION_WARNING("LUA: Element %s has no array %s", elementName, arrayName);
  432.         }
  433.         else
  434.         {
  435.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  436.         }
  437.         return pH->EndFunction(false);
  438. }
  439.  
  440. //------------------------------------------------------------------------
  441. int CScriptBind_UIAction::GetArray(IFunctionHandler* pH, const char* elementName, int instanceID, const char* arrayName)
  442. {
  443.         IUIElement* pElement = GetElement(elementName, instanceID);
  444.         if (pElement)
  445.         {
  446.                 const SUIParameterDesc* pArrayDesc = pElement->GetArrayDesc(arrayName);
  447.                 SUIArguments vals;
  448.                 if (pArrayDesc && pElement->GetArray(pArrayDesc, vals))
  449.                 {
  450.                         SmartScriptTable res(m_pSS);
  451.                         string val;
  452.                         for (int i = 0; i < vals.GetArgCount(); ++i)
  453.                         {
  454.                                 vals.GetArg(i).GetValueWithConversion(val);
  455.                                 res->SetAt(i + 1, val.c_str());
  456.                         }
  457.                         return pH->EndFunction(res);
  458.                 }
  459.                 UIACTION_WARNING("LUA: Element %s has no array %s", elementName, arrayName);
  460.         }
  461.         else
  462.         {
  463.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  464.         }
  465.         return pH->EndFunction(false);
  466. }
  467.  
  468. //------------------------------------------------------------------------
  469. int CScriptBind_UIAction::GotoAndPlay(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, int frameNum)
  470. {
  471.         IUIElement* pElement = GetElement(elementName, instanceID);
  472.         if (pElement)
  473.         {
  474.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  475.                 if (pMC)
  476.                 {
  477.                         pMC->GotoAndPlay(frameNum);
  478.                         return pH->EndFunction(true);
  479.                 }
  480.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  481.         }
  482.         else
  483.         {
  484.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  485.         }
  486.         return pH->EndFunction(false);
  487. }
  488.  
  489. //------------------------------------------------------------------------
  490. int CScriptBind_UIAction::GotoAndStop(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, int frameNum)
  491. {
  492.         IUIElement* pElement = GetElement(elementName, instanceID);
  493.         if (pElement)
  494.         {
  495.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  496.                 if (pMC)
  497.                 {
  498.                         pMC->GotoAndStop(frameNum);
  499.                         return pH->EndFunction(true);
  500.                 }
  501.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  502.         }
  503.         else
  504.         {
  505.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  506.         }
  507.         return pH->EndFunction(false);
  508.  
  509. }
  510.  
  511. //------------------------------------------------------------------------
  512. int CScriptBind_UIAction::GotoAndPlayFrameName(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, const char* frameName)
  513. {
  514.         IUIElement* pElement = GetElement(elementName, instanceID);
  515.         if (pElement)
  516.         {
  517.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  518.                 if (pMC)
  519.                 {
  520.                         pMC->GotoAndPlay(frameName);
  521.                         return pH->EndFunction(true);
  522.                 }
  523.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  524.         }
  525.         else
  526.         {
  527.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  528.         }
  529.         return pH->EndFunction(false);
  530.  
  531. }
  532.  
  533. //------------------------------------------------------------------------
  534. int CScriptBind_UIAction::GotoAndStopFrameName(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, const char* frameName)
  535. {
  536.         IUIElement* pElement = GetElement(elementName, instanceID);
  537.         if (pElement)
  538.         {
  539.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  540.                 if (pMC)
  541.                 {
  542.                         pMC->GotoAndStop(frameName);
  543.                         return pH->EndFunction(true);
  544.                 }
  545.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  546.         }
  547.         else
  548.         {
  549.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  550.         }
  551.         return pH->EndFunction(false);
  552.  
  553. }
  554.  
  555. //------------------------------------------------------------------------
  556. int CScriptBind_UIAction::SetAlpha(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, float fAlpha)
  557. {
  558.         IUIElement* pElement = GetElement(elementName, instanceID);
  559.         if (pElement)
  560.         {
  561.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  562.                 if (pMC)
  563.                 {
  564.                         SFlashDisplayInfo info;
  565.                         pMC->GetDisplayInfo(info);
  566.                         info.SetAlpha(fAlpha);
  567.                         pMC->SetDisplayInfo(info);
  568.                         return pH->EndFunction(true);
  569.                 }
  570.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  571.         }
  572.         else
  573.         {
  574.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  575.         }
  576.         return pH->EndFunction(false);
  577. }
  578.  
  579. //------------------------------------------------------------------------
  580. int CScriptBind_UIAction::GetAlpha(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName)
  581. {
  582.         IUIElement* pElement = GetElement(elementName, instanceID);
  583.         if (pElement)
  584.         {
  585.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  586.                 if (pMC)
  587.                 {
  588.                         SFlashDisplayInfo info;
  589.                         pMC->GetDisplayInfo(info);
  590.                         return pH->EndFunction(info.GetAlpha());
  591.                 }
  592.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  593.         }
  594.         else
  595.         {
  596.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  597.         }
  598.         return pH->EndFunction(false);
  599. }
  600.  
  601. //------------------------------------------------------------------------
  602. int CScriptBind_UIAction::SetVisible(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, bool bVisible)
  603. {
  604.         IUIElement* pElement = GetElement(elementName, instanceID);
  605.         if (pElement)
  606.         {
  607.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  608.                 if (pMC)
  609.                 {
  610.                         SFlashDisplayInfo info;
  611.                         pMC->GetDisplayInfo(info);
  612.                         info.SetVisible(bVisible);
  613.                         pMC->SetDisplayInfo(info);
  614.                         return pH->EndFunction(true);
  615.                 }
  616.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  617.         }
  618.         else
  619.         {
  620.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  621.         }
  622.         return pH->EndFunction(false);
  623. }
  624.  
  625. //------------------------------------------------------------------------
  626. int CScriptBind_UIAction::IsVisible(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName)
  627. {
  628.         IUIElement* pElement = GetElement(elementName, instanceID);
  629.         if (pElement)
  630.         {
  631.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  632.                 if (pMC)
  633.                 {
  634.                         SFlashDisplayInfo info;
  635.                         pMC->GetDisplayInfo(info);
  636.                         return pH->EndFunction(info.GetVisible());
  637.                 }
  638.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  639.         }
  640.         else
  641.         {
  642.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  643.         }
  644.         return pH->EndFunction(false);
  645. }
  646.  
  647. //------------------------------------------------------------------------
  648. int CScriptBind_UIAction::SetPos(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, Vec3 vPos)
  649. {
  650.         IUIElement* pElement = GetElement(elementName, instanceID);
  651.         if (pElement)
  652.         {
  653.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  654.                 if (pMC)
  655.                 {
  656.                         SFlashDisplayInfo info;
  657.                         pMC->GetDisplayInfo(info);
  658.                         info.SetX(vPos.x);
  659.                         info.SetY(vPos.y);
  660.                         info.SetZ(vPos.z);
  661.                         pMC->SetDisplayInfo(info);
  662.                         return pH->EndFunction(true);
  663.                 }
  664.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  665.         }
  666.         else
  667.         {
  668.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  669.         }
  670.         return pH->EndFunction(false);
  671. }
  672.  
  673. //------------------------------------------------------------------------
  674. int CScriptBind_UIAction::GetPos(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName)
  675. {
  676.         IUIElement* pElement = GetElement(elementName, instanceID);
  677.         if (pElement)
  678.         {
  679.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  680.                 if (pMC)
  681.                 {
  682.                         SFlashDisplayInfo info;
  683.                         pMC->GetDisplayInfo(info);
  684.                         return pH->EndFunction(Script::SetCachedVector(Vec3(info.GetX(), info.GetY(), info.GetZ()), pH, 1));
  685.                 }
  686.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  687.         }
  688.         else
  689.         {
  690.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  691.         }
  692.         return pH->EndFunction(false);
  693. }
  694.  
  695. //------------------------------------------------------------------------
  696. int CScriptBind_UIAction::SetRotation(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, Vec3 vRotation)
  697. {
  698.         IUIElement* pElement = GetElement(elementName, instanceID);
  699.         if (pElement)
  700.         {
  701.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  702.                 if (pMC)
  703.                 {
  704.                         SFlashDisplayInfo info;
  705.                         pMC->GetDisplayInfo(info);
  706.                         info.SetXRotation(vRotation.x);
  707.                         info.SetYRotation(vRotation.y);
  708.                         info.SetRotation(vRotation.z);
  709.                         pMC->SetDisplayInfo(info);
  710.                         return pH->EndFunction(true);
  711.                 }
  712.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  713.         }
  714.         else
  715.         {
  716.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  717.         }
  718.         return pH->EndFunction(false);
  719. }
  720.  
  721. //------------------------------------------------------------------------
  722. int CScriptBind_UIAction::GetRotation(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName)
  723. {
  724.         IUIElement* pElement = GetElement(elementName, instanceID);
  725.         if (pElement)
  726.         {
  727.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  728.                 if (pMC)
  729.                 {
  730.                         SFlashDisplayInfo info;
  731.                         pMC->GetDisplayInfo(info);
  732.                         return pH->EndFunction(Script::SetCachedVector(Vec3(info.GetXRotation(), info.GetYRotation(), info.GetRotation()), pH, 1));
  733.                 }
  734.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  735.         }
  736.         else
  737.         {
  738.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  739.         }
  740.         return pH->EndFunction(false);
  741. }
  742.  
  743. //------------------------------------------------------------------------
  744. int CScriptBind_UIAction::SetScale(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName, Vec3 vScale)
  745. {
  746.         IUIElement* pElement = GetElement(elementName, instanceID);
  747.         if (pElement)
  748.         {
  749.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  750.                 if (pMC)
  751.                 {
  752.                         SFlashDisplayInfo info;
  753.                         pMC->GetDisplayInfo(info);
  754.                         info.SetXScale(vScale.x);
  755.                         info.SetYScale(vScale.y);
  756.                         info.SetZScale(vScale.z);
  757.                         pMC->SetDisplayInfo(info);
  758.                         return pH->EndFunction(true);
  759.                 }
  760.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  761.         }
  762.         else
  763.         {
  764.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  765.         }
  766.         return pH->EndFunction(false);
  767. }
  768.  
  769. //------------------------------------------------------------------------
  770. int CScriptBind_UIAction::GetScale(IFunctionHandler* pH, const char* elementName, int instanceID, const char* mcName)
  771. {
  772.         IUIElement* pElement = GetElement(elementName, instanceID);
  773.         if (pElement)
  774.         {
  775.                 IFlashVariableObject* pMC = pElement->GetMovieClip(mcName);
  776.                 if (pMC)
  777.                 {
  778.                         SFlashDisplayInfo info;
  779.                         pMC->GetDisplayInfo(info);
  780.                         return pH->EndFunction(Script::SetCachedVector(Vec3(info.GetXScale(), info.GetYScale(), info.GetZScale()), pH, 1));
  781.                 }
  782.                 UIACTION_WARNING("LUA: Element %s has no movieclip %s", elementName, mcName);
  783.         }
  784.         else
  785.         {
  786.                 UIACTION_WARNING("LUA: UIElement %s does not exist", elementName);
  787.         }
  788.         return pH->EndFunction(false);
  789. }
  790.  
  791. //------------------------------------------------------------------------
  792. int CScriptBind_UIAction::StartAction(IFunctionHandler* pH, const char* actionName, SmartScriptTable arguments)
  793. {
  794.         IUIAction* pAction = GetAction(actionName);
  795.         if (pAction)
  796.         {
  797.                 SUIArguments args;
  798.                 if (SUIToLuaConversationHelper::LuaTableToUIArgs(arguments, args))
  799.                 {
  800.                         gEnv->pFlashUI->GetUIActionManager()->StartAction(pAction, args);
  801.                         return pH->EndFunction(true);
  802.                 }
  803.                 UIACTION_WARNING("LUA: Failed to call UIAction %s: Invalid arguments", actionName);
  804.         }
  805.         else
  806.         {
  807.                 UIACTION_WARNING("LUA: UIAction %s does not exist", actionName);
  808.         }
  809.         return pH->EndFunction(false);
  810. }
  811.  
  812. //------------------------------------------------------------------------
  813. int CScriptBind_UIAction::EndAction(IFunctionHandler* pH, SmartScriptTable pTable, bool disable, SmartScriptTable arguments)
  814. {
  815.         if (!pTable)
  816.         {
  817.                 UIACTION_WARNING("LUA: EndAction received non-valid script table!");
  818.                 return pH->EndFunction(false);
  819.         }
  820.  
  821.         const char* actionName;
  822.         if (pTable->GetValue("__ui_action_name", actionName))
  823.         {
  824.                 IUIAction* pAction = GetAction(actionName);
  825.                 if (pAction)
  826.                 {
  827.                         SUIArguments args;
  828.                         if (SUIToLuaConversationHelper::LuaTableToUIArgs(arguments, args))
  829.                         {
  830.                                 gEnv->pFlashUI->GetUIActionManager()->EndAction(pAction, args);
  831.                                 if (disable)
  832.                                         gEnv->pFlashUI->GetUIActionManager()->EnableAction(pAction, false);
  833.                                 return pH->EndFunction(true);
  834.                         }
  835.                         UIACTION_WARNING("LUA: Failed to end UIAction %s: Invalid arguments", actionName);
  836.                         return pH->EndFunction(false);
  837.                 }
  838.         }
  839.         UIACTION_WARNING("LUA: Failed to end UIAction: Called from different script than UIAction lua script!");
  840.         return pH->EndFunction(false);
  841. }
  842.  
  843. //------------------------------------------------------------------------
  844. int CScriptBind_UIAction::EnableAction(IFunctionHandler* pH, const char* actionName)
  845. {
  846.         IUIAction* pAction = GetAction(actionName);
  847.         if (pAction)
  848.         {
  849.                 pAction->SetEnabled(true);
  850.                 return pH->EndFunction(true);
  851.         }
  852.         UIACTION_WARNING("LUA: UIAction %s does not exist", actionName);
  853.         return pH->EndFunction(false);
  854. }
  855.  
  856. //------------------------------------------------------------------------
  857. int CScriptBind_UIAction::DisableAction(IFunctionHandler* pH, const char* actionName)
  858. {
  859.         IUIAction* pAction = GetAction(actionName);
  860.         if (pAction)
  861.         {
  862.                 pAction->SetEnabled(false);
  863.                 return pH->EndFunction(true);
  864.         }
  865.         UIACTION_WARNING("LUA: UIAction %s does not exist", actionName);
  866.         return pH->EndFunction(false);
  867. }
  868.  
  869. //------------------------------------------------------------------------
  870. int CScriptBind_UIAction::RegisterElementListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* elementName, int instanceID, const char* eventName, const char* callback)
  871. {
  872.         if (!pTable)
  873.         {
  874.                 UIACTION_WARNING("LUA: RegisterElementListener received non-valid script table!");
  875.                 return pH->EndFunction(false);
  876.         }
  877.  
  878.         IUIElement* pElement = strlen(elementName) > 0 ? GetElement(elementName, 0) : NULL;
  879.         m_ElementCallbacks.Init(pElement);
  880.         m_ElementCallbacks.AddCallback(pTable, callback, SUILuaCallbackInfo<IUIElement>::CreateInfo(pElement, eventName ? eventName : "", instanceID));
  881.         return pH->EndFunction(true);
  882.  
  883. }
  884.  
  885. //------------------------------------------------------------------------
  886. int CScriptBind_UIAction::RegisterActionListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* actionName, const char* eventName, const char* callback)
  887. {
  888.         if (!pTable)
  889.         {
  890.                 UIACTION_WARNING("LUA: RegisterActionListener received non-valid script table!");
  891.                 return pH->EndFunction(false);
  892.         }
  893.  
  894.         IUIAction* pAction = strlen(actionName) > 0 ? GetAction(actionName) : NULL;
  895.         m_ActionCallbacks.AddCallback(pTable, callback, SUILuaCallbackInfo<IUIAction>::CreateInfo(pAction, eventName ? eventName : ""));
  896.         return pH->EndFunction(true);
  897. }
  898.  
  899. //------------------------------------------------------------------------
  900. int CScriptBind_UIAction::RegisterEventSystemListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* eventSystem, const char* eventName, const char* callback)
  901. {
  902.         if (!pTable)
  903.         {
  904.                 UIACTION_WARNING("LUA: RegisterEventSystemListener received non-valid script table!");
  905.                 return pH->EndFunction(false);
  906.         }
  907.  
  908.         IUIEventSystem* pEventSystem = GetEventSystem(eventSystem, IUIEventSystem::eEST_SYSTEM_TO_UI);
  909.         m_EventSystemCallbacks.Init(pEventSystem);
  910.         m_EventSystemCallbacks.AddCallback(pTable, callback, SUILuaCallbackInfo<IUIEventSystem>::CreateInfo(pEventSystem, eventName ? eventName : ""));
  911.         return pH->EndFunction(true);
  912. }
  913.  
  914. //------------------------------------------------------------------------
  915. int CScriptBind_UIAction::UnregisterElementListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* callback)
  916. {
  917.         if (!pTable)
  918.         {
  919.                 UIACTION_WARNING("LUA: UnregisterElementListener received non-valid script table!");
  920.                 return pH->EndFunction(false);
  921.         }
  922.         m_ElementCallbacks.RemoveCallbacks(pTable, callback);
  923.         return pH->EndFunction(true);
  924. }
  925.  
  926. //------------------------------------------------------------------------
  927. int CScriptBind_UIAction::UnregisterActionListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* callback)
  928. {
  929.         if (!pTable)
  930.         {
  931.                 UIACTION_WARNING("LUA: UnregisterActionListener received non-valid script table!");
  932.                 return pH->EndFunction(false);
  933.         }
  934.         m_ActionCallbacks.RemoveCallbacks(pTable, callback);
  935.         return pH->EndFunction(true);
  936. }
  937.  
  938. //------------------------------------------------------------------------
  939. int CScriptBind_UIAction::UnregisterEventSystemListener(IFunctionHandler* pH, SmartScriptTable pTable, const char* callback)
  940. {
  941.         if (!pTable)
  942.         {
  943.                 UIACTION_WARNING("LUA: UnregisterEventSystemListener received non-valid script table!");
  944.                 return pH->EndFunction(false);
  945.         }
  946.         m_EventSystemCallbacks.RemoveCallbacks(pTable, callback);
  947.         return pH->EndFunction(true);
  948. }
  949.  
  950. //------------------------------------------------------------------------
  951. //------------------------------------------------------------------------
  952. //------------------------------------------------------------------------
  953. void CScriptBind_UIAction::Reload()
  954. {
  955.         Reset();
  956. }
  957.  
  958. //------------------------------------------------------------------------
  959. void CScriptBind_UIAction::Reset()
  960. {
  961.         m_ElementCallbacks.Clear();
  962.         m_ActionCallbacks.Clear();
  963.         m_EventSystemCallbacks.Clear();
  964. }
  965.  
  966. //------------------------------------------------------------------------
  967. //------------------------------------------------------------------------
  968. //------------------------------------------------------------------------
  969. SUIElementLuaCallback::~SUIElementLuaCallback()
  970. {
  971.         Clear();
  972. }
  973.  
  974. //------------------------------------------------------------------------
  975. void SUIElementLuaCallback::Clear()
  976. {
  977.         if (gEnv->pFlashUI)
  978.         {
  979.                 const int count = gEnv->pFlashUI->GetUIElementCount();
  980.                 for (int i = 0; i < count; ++i)
  981.                 {
  982.                         IUIElementIteratorPtr elements = gEnv->pFlashUI->GetUIElement(i)->GetInstances();
  983.                         while (IUIElement* pInst = elements->Next())
  984.                                 pInst->RemoveEventListener(this);
  985.                 }
  986.         }
  987.         ClearCallbacks();
  988. }
  989.  
  990. //------------------------------------------------------------------------
  991. void SUIElementLuaCallback::Init(IUIElement* pElement)
  992. {
  993.         if (gEnv->pFlashUI)
  994.         {
  995.                 if (!pElement)
  996.                 {
  997.                         const int count = gEnv->pFlashUI->GetUIElementCount();
  998.                         for (int i = 0; i < count; ++i)
  999.                         {
  1000.                                 pElement = gEnv->pFlashUI->GetUIElement(i);
  1001.                                 IUIElementIteratorPtr elements = pElement->GetInstances();
  1002.                                 while (IUIElement* pInst = elements->Next())
  1003.                                 {
  1004.                                         pInst->RemoveEventListener(this); // to avoid double registration
  1005.                                         pInst->AddEventListener(this, "SUIElementLuaCallback");
  1006.                                 }
  1007.                         }
  1008.                 }
  1009.                 else
  1010.                 {
  1011.                         IUIElementIteratorPtr elements = pElement->GetInstances();
  1012.                         while (IUIElement* pInst = elements->Next())
  1013.                         {
  1014.                                 pInst->RemoveEventListener(this); // to avoid double registration
  1015.                                 pInst->AddEventListener(this, "SUIElementLuaCallback");
  1016.                         }
  1017.                 }
  1018.         }
  1019. }
  1020.  
  1021. //------------------------------------------------------------------------
  1022. void SUIElementLuaCallback::OnUIEvent(IUIElement* pSender, const SUIEventDesc& event, const SUIArguments& args)
  1023. {
  1024.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, event.sDisplayName), args);
  1025. }
  1026.  
  1027. //------------------------------------------------------------------------
  1028. void SUIElementLuaCallback::OnUIEventEx(IUIElement* pSender, const char* fscommand, const SUIArguments& args, void* pUserData)
  1029. {
  1030.         SUIArguments luaArgs;
  1031.         luaArgs.AddArgument(fscommand);
  1032.         luaArgs.AddArguments(args);
  1033.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, "OnUIEventEx"), luaArgs);
  1034. }
  1035.  
  1036. //------------------------------------------------------------------------
  1037. void SUIElementLuaCallback::OnInit(IUIElement* pSender, IFlashPlayer* pFlashPlayer)
  1038. {
  1039.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, "OnInit"));
  1040. }
  1041.  
  1042. //------------------------------------------------------------------------
  1043. void SUIElementLuaCallback::OnUnload(IUIElement* pSender)
  1044. {
  1045.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, "OnUnload"));
  1046. }
  1047.  
  1048. //------------------------------------------------------------------------
  1049. void SUIElementLuaCallback::OnSetVisible(IUIElement* pSender, bool bVisible)
  1050. {
  1051.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, bVisible ? "OnShow" : "OnHide"));
  1052. }
  1053.  
  1054. //------------------------------------------------------------------------
  1055. void SUIElementLuaCallback::OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance)
  1056. {
  1057.         pNewInstance->RemoveEventListener(this); // to avoid double registration
  1058.         pNewInstance->AddEventListener(this, "SUIElementLuaCallback");
  1059. }
  1060.  
  1061. //------------------------------------------------------------------------
  1062. void SUIElementLuaCallback::OnInstanceDestroyed(IUIElement* pSender, IUIElement* pDeletedInstance)
  1063. {
  1064.         NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, "OnInstanceDestroyed"));
  1065. }
  1066.  
  1067. //------------------------------------------------------------------------
  1068. //------------------------------------------------------------------------
  1069. //------------------------------------------------------------------------
  1070. SUIActionLuaCallback::SUIActionLuaCallback()
  1071. {
  1072.         if (gEnv->pFlashUI)
  1073.                 gEnv->pFlashUI->GetUIActionManager()->AddListener(this, "SUIActionLuaCallback");
  1074. }
  1075.  
  1076. //------------------------------------------------------------------------
  1077. SUIActionLuaCallback::~SUIActionLuaCallback()
  1078. {
  1079.         if (gEnv->pFlashUI)
  1080.                 gEnv->pFlashUI->GetUIActionManager()->RemoveListener(this);
  1081. }
  1082.  
  1083. //------------------------------------------------------------------------
  1084. void SUIActionLuaCallback::Clear()
  1085. {
  1086.         ClearCallbacks();
  1087. }
  1088.  
  1089. //------------------------------------------------------------------------
  1090. void SUIActionLuaCallback::OnStart(IUIAction* pAction, const SUIArguments& args)
  1091. {
  1092.         NotifyEvent(SUILuaCallbackInfo<IUIAction>::CreateInfo(pAction, "OnStart"), args);
  1093. }
  1094.  
  1095. //------------------------------------------------------------------------
  1096. void SUIActionLuaCallback::OnEnd(IUIAction* pAction, const SUIArguments& args)
  1097. {
  1098.         NotifyEvent(SUILuaCallbackInfo<IUIAction>::CreateInfo(pAction, "OnEnd"), args);
  1099. }
  1100.  
  1101. //------------------------------------------------------------------------
  1102. //------------------------------------------------------------------------
  1103. //------------------------------------------------------------------------
  1104. SUIEventSystemLuaCallback::~SUIEventSystemLuaCallback()
  1105. {
  1106.         Clear();
  1107. }
  1108.  
  1109. //------------------------------------------------------------------------
  1110. void SUIEventSystemLuaCallback::Init(IUIEventSystem* pEventSystem)
  1111. {
  1112.         if (gEnv->pFlashUI)
  1113.         {
  1114.                 if (!pEventSystem)
  1115.                 {
  1116.                         IUIEventSystemIteratorPtr eventSystems = gEnv->pFlashUI->CreateEventSystemIterator(IUIEventSystem::eEST_SYSTEM_TO_UI);
  1117.                         string name;
  1118.                         while (pEventSystem = eventSystems->Next(name))
  1119.                                 AddNewListener(pEventSystem);
  1120.                 }
  1121.                 else
  1122.                         AddNewListener(pEventSystem);
  1123.         }
  1124. }
  1125.  
  1126. //------------------------------------------------------------------------
  1127. void SUIEventSystemLuaCallback::Clear()
  1128. {
  1129.         m_Listener.clear();
  1130.         ClearCallbacks();
  1131. }
  1132.  
  1133. //------------------------------------------------------------------------
  1134. void SUIEventSystemLuaCallback::OnEvent(IUIEventSystem* pEventSystem, const SUIEvent& event)
  1135. {
  1136.         NotifyEvent(SUILuaCallbackInfo<IUIEventSystem>::CreateInfo(pEventSystem, pEventSystem->GetEventDesc((int)event.event)->sDisplayName), event.args);
  1137. }
  1138.  
  1139. //------------------------------------------------------------------------
  1140. void SUIEventSystemLuaCallback::AddNewListener(IUIEventSystem* pEventSystem)
  1141. {
  1142.         for (int i = 0, count = m_Listener.size(); i < count; ++i)
  1143.                 if (m_Listener[i].GetEventSystem() == pEventSystem)
  1144.                         return;
  1145.  
  1146.         m_Listener.push_back(SEventSystemListener(pEventSystem, this));
  1147. }
  1148.  
  1149. //------------------------------------------------------------------------
  1150. SUIEventSystemLuaCallback::SEventSystemListener::~SEventSystemListener()
  1151. {
  1152.         Clear();
  1153. }
  1154.  
  1155. //------------------------------------------------------------------------
  1156. void SUIEventSystemLuaCallback::SEventSystemListener::Init(IUIEventSystem* pEventSystem, SUIEventSystemLuaCallback* pOwner)
  1157. {
  1158.         m_pEventSystem = pEventSystem;
  1159.         m_pOwner = pOwner;
  1160.         if (m_pEventSystem)
  1161.                 m_pEventSystem->RegisterListener(this, "SUIEventSystemLuaCallback");
  1162. }
  1163.  
  1164. //------------------------------------------------------------------------
  1165. void SUIEventSystemLuaCallback::SEventSystemListener::Clear()
  1166. {
  1167.         if (m_pEventSystem)
  1168.         {
  1169.                 m_pEventSystem->UnregisterListener(this); // to avoid double registration
  1170.         }
  1171. }
  1172.  
  1173. //------------------------------------------------------------------------
  1174. SUIArgumentsRet SUIEventSystemLuaCallback::SEventSystemListener::OnEvent(const SUIEvent& event)
  1175. {
  1176.         assert(m_pOwner && m_pEventSystem);
  1177.         m_pOwner->OnEvent(m_pEventSystem, event);
  1178.         return SUIArguments();
  1179. }
  1180.  
  1181. //------------------------------------------------------------------------
  1182. void SUIEventSystemLuaCallback::SEventSystemListener::OnEventSystemDestroyed(IUIEventSystem* pEventSystem)
  1183. {
  1184.         m_pEventSystem = NULL;
  1185. }
  1186.  
  1187. //------------------------------------------------------------------------
  1188. //------------------------------------------------------------------------
  1189. //------------------------------------------------------------------------
  1190. namespace SUIConvHelperTmpl
  1191. {
  1192. template<class T>
  1193. ScriptVarType            GetVarType(T& t, int idx)                 { assert(false); return svtNull; }
  1194. template<> ScriptVarType GetVarType(SmartScriptTable& t, int idx)  { return t->GetAtType(idx); }
  1195. template<> ScriptVarType GetVarType(IFunctionHandler*& t, int idx) { return t->GetParamType(idx); }
  1196.  
  1197. template<class T, class V>
  1198. bool                   GetVarValue(T& t, int idx, V& val)                 { assert(false); return false; }
  1199. template<class V> bool GetVarValue(SmartScriptTable& t, int idx, V& val)  { return t->GetAt(idx, val); }
  1200. template<class V> bool GetVarValue(IFunctionHandler*& t, int idx, V& val) { return t->GetParam(idx, val); }
  1201.  
  1202. template<class T>
  1203. bool LuaArgToUIArgImpl(T& t, int idx, TUIData& value)
  1204. {
  1205.         bool bOk = false;
  1206.         switch (GetVarType(t, idx))
  1207.         {
  1208.         case svtBool:
  1209.                 {
  1210.                         bool val;
  1211.                         bOk = GetVarValue(t, idx, val);
  1212.                         value = TUIData(val);
  1213.                 }
  1214.                 break;
  1215.         case svtNumber:
  1216.                 {
  1217.                         float val;
  1218.                         bOk = GetVarValue(t, idx, val);
  1219.                         value = TUIData(val);
  1220.                 }
  1221.                 break;
  1222.         case svtString:
  1223.                 {
  1224.                         const char* val;
  1225.                         bOk = GetVarValue(t, idx, val);
  1226.                         value = TUIData(string(val));
  1227.                 }
  1228.                 break;
  1229.         case svtObject:
  1230.                 {
  1231.                         Vec3 val(ZERO);
  1232.                         bOk = GetVarValue(t, idx, val);
  1233.                         value = TUIData(val);
  1234.                 }
  1235.                 break;
  1236.         case svtPointer:
  1237.                 {
  1238.                         ScriptHandle sh;
  1239.                         bOk = GetVarValue(t, idx, sh);
  1240.                         value = TUIData((EntityId)sh.n);
  1241.                 }
  1242.                 break;
  1243.         case svtNull:
  1244.                 CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");
  1245.                 break;
  1246.         case svtUserData:
  1247.                 CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");
  1248.                 break;
  1249.         case svtFunction:
  1250.                 CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");
  1251.                 break;
  1252.         }
  1253.         return bOk;
  1254. }
  1255.  
  1256. template<class T>
  1257. ScriptAnyValue GetValueRaw(const TUIData& value)
  1258. {
  1259.         const T* val = value.GetPtr<T>();
  1260.         assert(val);
  1261.         return ScriptAnyValue(*val);
  1262. }
  1263.  
  1264. template<class T1>
  1265. void SetTableVal(const T1& val, SmartScriptTable table, int idx) { table->SetAt(idx, val); }
  1266.  
  1267. template<>
  1268. void SetTableVal(const string& val, SmartScriptTable table, int idx) { table->SetAt(idx, val.c_str()); }
  1269.  
  1270. template<class T>
  1271. void ArgToLuaTable(const SUIArguments& args, SmartScriptTable table, int idx)
  1272. {
  1273.         T val;
  1274.         args.GetArgNoConversation(idx, val);
  1275.         SetTableVal<T>(val, table, idx);
  1276. }
  1277.  
  1278. template<class T>
  1279. bool TryArgToLuaTable(const SUIArguments& args, SmartScriptTable table, int idx)
  1280. {
  1281.         T val;
  1282.         if (args.GetArg(idx, val))
  1283.         {
  1284.                 SetTableVal<T>(val, table, idx);
  1285.                 return true;
  1286.         }
  1287.         return false;
  1288. }
  1289. }
  1290.  
  1291. //------------------------------------------------------------------------
  1292. //------------------------------------------------------------------------
  1293. //------------------------------------------------------------------------
  1294. ScriptAnyValue SUIToLuaConversationHelper::UIValueToLuaValue(const TUIData& value, bool& ok)
  1295. {
  1296.         ok = true;
  1297.         switch (value.GetType())
  1298.         {
  1299.         case eUIDT_Bool:
  1300.                 return SUIConvHelperTmpl::GetValueRaw<bool>(value);
  1301.         case eUIDT_Int:
  1302.                 return SUIConvHelperTmpl::GetValueRaw<int>(value);
  1303.         case eUIDT_EntityId:
  1304.                 return SUIConvHelperTmpl::GetValueRaw<EntityId>(value);
  1305.         case eUIDT_Float:
  1306.                 return SUIConvHelperTmpl::GetValueRaw<float>(value);
  1307.         case eUIDT_Vec3:
  1308.                 return SUIConvHelperTmpl::GetValueRaw<Vec3>(value);
  1309.         case eUIDT_String:
  1310.         case eUIDT_WString:
  1311.                 {
  1312.                         string val;
  1313.                         if (value.GetValueWithConversion(val))
  1314.                                 return ScriptAnyValue(val.c_str());
  1315.                 }
  1316.         }
  1317.         ok = false;
  1318.         return ScriptAnyValue(false);
  1319. }
  1320.  
  1321. //------------------------------------------------------------------------
  1322. bool SUIToLuaConversationHelper::LuaTableToUIArgs(SmartScriptTable table, SUIArguments& args)
  1323. {
  1324.         for (int i = 0; i <= table->Count(); ++i)
  1325.         {
  1326.                 if (i == 0 && table->GetAtType(0) == svtNull)
  1327.                         continue; // if passing {arg1, arg2, arg3} to scriptbind first entry will be nil
  1328.  
  1329.                 TUIData val;
  1330.                 if (!SUIConvHelperTmpl::LuaArgToUIArgImpl(table, i, val))
  1331.                         return false;
  1332.                 args.AddArgument(val);
  1333.         }
  1334.         return true;
  1335. }
  1336.  
  1337. //------------------------------------------------------------------------
  1338. bool SUIToLuaConversationHelper::LuaArgsToUIArgs(IFunctionHandler* pH, int startIdx, SUIArguments& args)
  1339. {
  1340.         for (int i = startIdx; i <= pH->GetParamCount(); ++i)
  1341.         {
  1342.                 TUIData val;
  1343.                 if (!LuaArgToUIArg(pH, i, val))
  1344.                 {
  1345.                         return false;
  1346.                 }
  1347.                 args.AddArgument(val);
  1348.         }
  1349.         return true;
  1350. }
  1351.  
  1352. //------------------------------------------------------------------------
  1353. bool SUIToLuaConversationHelper::LuaArgToUIArg(IFunctionHandler* pH, int idx, TUIData& value)
  1354. {
  1355.         if (idx >= 0 && idx <= pH->GetParamCount())
  1356.                 return SUIConvHelperTmpl::LuaArgToUIArgImpl(pH, idx, value);
  1357.         return false;
  1358. }
  1359.  
  1360. //------------------------------------------------------------------------
  1361. bool SUIToLuaConversationHelper::UIArgsToLuaTable(const SUIArguments& args, SmartScriptTable table)
  1362. {
  1363.         bool res = true;
  1364.         for (int i = 0; i < args.GetArgCount(); ++i)
  1365.         {
  1366.                 switch (args.GetArgType(i))
  1367.                 {
  1368.                 case eUIDT_Bool:
  1369.                         SUIConvHelperTmpl::ArgToLuaTable<bool>(args, table, i);
  1370.                         break;
  1371.                 case eUIDT_Int:
  1372.                         SUIConvHelperTmpl::ArgToLuaTable<int>(args, table, i);
  1373.                         break;
  1374.                 case eUIDT_Float:
  1375.                         SUIConvHelperTmpl::ArgToLuaTable<float>(args, table, i);
  1376.                         break;
  1377.                 case eUIDT_EntityId:
  1378.                         SUIConvHelperTmpl::ArgToLuaTable<EntityId>(args, table, i);
  1379.                         break;
  1380.                 case eUIDT_Vec3:
  1381.                         SUIConvHelperTmpl::ArgToLuaTable<Vec3>(args, table, i);
  1382.                         break;
  1383.                 case eUIDT_String:
  1384.                 case eUIDT_WString:
  1385.                         SUIConvHelperTmpl::ArgToLuaTable<string>(args, table, i);
  1386.                         break;
  1387.                 case eUIDT_Any:
  1388.                         {
  1389.                                 bool ok = SUIConvHelperTmpl::TryArgToLuaTable<int>(args, table, i)
  1390.                                           || SUIConvHelperTmpl::TryArgToLuaTable<float>(args, table, i)
  1391.                                           || SUIConvHelperTmpl::TryArgToLuaTable<string>(args, table, i);
  1392.                                 res &= ok;
  1393.                         }
  1394.                 default:
  1395.                         res = false;
  1396.                 }
  1397.         }
  1398.         return res;
  1399. }
  1400.  
  1401. //------------------------------------------------------------------------
  1402.  
downloadScriptBind_UIAction.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