From 8ae0af3e25d0d8a85c6cba1b3930b8771352b370 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Laban?= Date: Wed, 15 May 2019 11:26:44 -0400 Subject: [PATCH] Add support for Wasm, fonts, loading. --- src/Calculator.Shared/Assets/CalcMDL2.woff | Bin 0 -> 9008 bytes .../CalcManager/CalculatorManager.Interop.cs | 263 +++++++++--------- .../CalcManager/CalculatorManager.cs | 36 ++- .../Calculator.Shared.projitems | 1 + src/Calculator.Shared/Styles.xaml | 8 +- .../ViewModels/ApplicationViewModel.cs | 14 +- .../ViewModels/StandardCalculatorViewModel.cs | 8 +- src/Calculator.Shared/Views/MainPage.xaml.cs | 80 ++++-- src/Calculator.Wasm/Calculator.Wasm.csproj | 17 +- src/Calculator.Wasm/Program.cs | 6 +- src/Calculator.Wasm/WasmCSS/Fonts.css | 11 +- .../WasmScripts/CalcManager.js | 44 +++ 12 files changed, 307 insertions(+), 181 deletions(-) create mode 100644 src/Calculator.Shared/Assets/CalcMDL2.woff create mode 100644 src/Calculator.Wasm/WasmScripts/CalcManager.js diff --git a/src/Calculator.Shared/Assets/CalcMDL2.woff b/src/Calculator.Shared/Assets/CalcMDL2.woff new file mode 100644 index 0000000000000000000000000000000000000000..e32f7a0932da80d976bbe725c2837977dce95a5c GIT binary patch literal 9008 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 UE;ibKy7#j`;6J^ZwUY3^0I$vm4gdfE literal 0 HcmV?d00001 diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs index cfd5b643..d5b675da 100644 --- a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs +++ b/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs @@ -10,137 +10,142 @@ using System.Text; namespace CalculationManager { + public static class NativeDispatch + { + [DllImport("CalcManager")] + public static extern int CalculatorManager_Create(ref CalculatorManager_CreateParams parms); + + [DllImport("CalcManager")] + public static extern void CalculatorManager_SendCommand(int instance, Command command); + + private delegate int GetCEngineStringFunc(int state, string id); + private delegate void BinaryOperatorReceivedFunc(int state); + private delegate void SetPrimaryDisplayCallbackFunc(int state, string displayStringValue, bool isError); + private delegate void SetIsInErrorCallbackFunc(int state, bool isError); + private delegate void SetParenthesisNumberCallbackFunc(int state, int parenthesisCount); + + private delegate void MaxDigitsReachedCallbackFunc(int state); + private delegate void MemoryItemChangedCallbackFunc(int state, int indexOfMemory); + private delegate void OnHistoryItemAddedCallbackFunc(int state, int addedItemIndex); + private delegate void OnNoRightParenAddedCallbackFunc(int state); + private delegate void SetExpressionDisplayCallbackFunc(int state); + private delegate void SetMemorizedNumbersCallbackFunc(int state, string[] newMemorizedNumbers); + + private static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback; + private static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback; + private static SetPrimaryDisplayCallbackFunc _setPrimaryDisplayCallback = SetPrimaryDisplayCallback; + private static SetIsInErrorCallbackFunc _setIsInErrorCallback = SetIsInErrorCallback; + private static SetParenthesisNumberCallbackFunc _setParenthesisNumberCallback = SetParenthesisNumberCallback; + + private static MaxDigitsReachedCallbackFunc _maxDigitsReachedCallback = MaxDigitsReachedCallback; + private static MemoryItemChangedCallbackFunc _memoryItemChangedCallback = MemoryItemChangedCallback; + private static OnHistoryItemAddedCallbackFunc _onHistoryItemAddedCallback = OnHistoryItemAddedCallback; + private static OnNoRightParenAddedCallbackFunc _onNoRightParenAddedCallback = OnNoRightParenAddedCallback; + private static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback = SetExpressionDisplayCallback; + private static SetMemorizedNumbersCallbackFunc _setMemorizedNumbersCallback = SetMemorizedNumbersCallback; + + public static void MaxDigitsReachedCallback(int state) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.MaxDigitsReached(); + + Debug.WriteLine($"CalculatorManager.MaxDigitsReachedCallback"); + } + + public static void MemoryItemChangedCallback(int state, int indexOfMemory) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.MemoryItemChanged(indexOfMemory); + + Debug.WriteLine($"CalculatorManager.MemoryItemChangedCallback({indexOfMemory})"); + } + + public static void OnHistoryItemAddedCallback(int state, int addedItemIndex) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.OnHistoryItemAdded(addedItemIndex); + + Debug.WriteLine($"CalculatorManager.OnHistoryItemAddedCallback({addedItemIndex})"); + } + + public static void OnNoRightParenAddedCallback(int state) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.OnNoRightParenAdded(); + + Debug.WriteLine($"CalculatorManager.OnNoRightParenAddedCallback"); + } + + public static void SetExpressionDisplayCallback(int state) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + // manager.SetExpressionDisplay(); + + Debug.WriteLine($"CalculatorManager.SetExpressionDisplayCallback"); + } + + public static void SetMemorizedNumbersCallback(int state, string[] newMemorizedNumbers) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.SetMemorizedNumbers(newMemorizedNumbers.ToList()); + + Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", newMemorizedNumbers)})"); + } + + public static void SetParenthesisNumberCallback(int state, int parenthesisCount) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.SetParenthesisNumber(parenthesisCount); + + Debug.WriteLine($"CalculatorManager.SetParenthesisNumberCallback({parenthesisCount})"); + } + + public static void BinaryOperatorReceivedCallback(int state) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.BinaryOperatorReceived(); + + Debug.WriteLine($"CalculatorManager.BinaryOperatorReceivedCallback"); + } + + public static void SetPrimaryDisplayCallback(int state, string displayStringValue, bool isError) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.SetPrimaryDisplay(displayStringValue, isError); + + Debug.WriteLine($"CalculatorManager.SetPrimaryDisplayCallback({displayStringValue}, {isError})"); + } + + public static void SetIsInErrorCallback(int state, bool isError) + { + var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; + manager.SetIsInError(isError); + + Debug.WriteLine($"CalculatorManager.SetIsInErrorCallback({isError})"); + } + + public static int GetCEngineStringCallback(int state, string resourceId) + { + var provider = GCHandle.FromIntPtr((IntPtr)state).Target as EngineResourceProvider; + var ret = provider.GetCEngineString(resourceId) ?? ""; + + var retBytes = Encoding.UTF8.GetBytes(ret); + var retPtr = Marshal.AllocHGlobal(retBytes.Length + 1); + Marshal.WriteByte(retPtr + retBytes.Length, 0); + Marshal.Copy(retBytes, 0, retPtr, retBytes.Length); + + Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})"); + + return (int)retPtr; + } + } + public partial class CalculatorManager : ICalcDisplay { - [DllImport("CalcManager")] - public static extern IntPtr CalculatorManager_Create(ref CalculatorManager_CreateParams parms); - [DllImport("CalcManager")] - public static extern void CalculatorManager_SendCommand(IntPtr instance, Command command); + private GCHandle _displayCallbackHandle; + private GCHandle _resourceProviderHandle; + private readonly int _nativeManager; - private delegate IntPtr GetCEngineStringFunc(IntPtr state, string id); - private delegate void BinaryOperatorReceivedFunc(IntPtr state); - private delegate void SetPrimaryDisplayCallbackFunc(IntPtr state, string displayStringValue, bool isError); - private delegate void SetIsInErrorCallbackFunc(IntPtr state, bool isError); - private delegate void SetParenthesisNumberCallbackFunc(IntPtr state, int parenthesisCount); - - private delegate void MaxDigitsReachedCallbackFunc(IntPtr state); - private delegate void MemoryItemChangedCallbackFunc(IntPtr state, int indexOfMemory); - private delegate void OnHistoryItemAddedCallbackFunc(IntPtr state, int addedItemIndex); - private delegate void OnNoRightParenAddedCallbackFunc(IntPtr state); - private delegate void SetExpressionDisplayCallbackFunc(IntPtr state); - private delegate void SetMemorizedNumbersCallbackFunc(IntPtr state, string[] newMemorizedNumbers); - - private static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback; - private static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback; - private static SetPrimaryDisplayCallbackFunc _setPrimaryDisplayCallback = SetPrimaryDisplayCallback; - private static SetIsInErrorCallbackFunc _setIsInErrorCallback = SetIsInErrorCallback; - private static SetParenthesisNumberCallbackFunc _setParenthesisNumberCallback = SetParenthesisNumberCallback; - - private static MaxDigitsReachedCallbackFunc _maxDigitsReachedCallback = MaxDigitsReachedCallback; - private static MemoryItemChangedCallbackFunc _memoryItemChangedCallback = MemoryItemChangedCallback; - private static OnHistoryItemAddedCallbackFunc _onHistoryItemAddedCallback = OnHistoryItemAddedCallback; - private static OnNoRightParenAddedCallbackFunc _onNoRightParenAddedCallback = OnNoRightParenAddedCallback; - private static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback = SetExpressionDisplayCallback; - private static SetMemorizedNumbersCallbackFunc _setMemorizedNumbersCallback = SetMemorizedNumbersCallback; - - private GCHandle _displayCallbackHandle; - private GCHandle _resourceProviderHandle; - private readonly IntPtr _nativeManager; - - private static void MaxDigitsReachedCallback(IntPtr state) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.MaxDigitsReached(); - - Debug.WriteLine($"CalculatorManager.MaxDigitsReachedCallback"); - } - - private static void MemoryItemChangedCallback(IntPtr state, int indexOfMemory) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.MemoryItemChanged(indexOfMemory); - - Debug.WriteLine($"CalculatorManager.MemoryItemChangedCallback({indexOfMemory})"); - } - - private static void OnHistoryItemAddedCallback(IntPtr state, int addedItemIndex) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.OnHistoryItemAdded(addedItemIndex); - - Debug.WriteLine($"CalculatorManager.OnHistoryItemAddedCallback({addedItemIndex})"); - } - - private static void OnNoRightParenAddedCallback(IntPtr state) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.OnNoRightParenAdded(); - - Debug.WriteLine($"CalculatorManager.OnNoRightParenAddedCallback"); - } - - private static void SetExpressionDisplayCallback(IntPtr state) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - // manager.SetExpressionDisplay(); - - Debug.WriteLine($"CalculatorManager.SetExpressionDisplayCallback"); - } - - private static void SetMemorizedNumbersCallback(IntPtr state, string[] newMemorizedNumbers) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.SetMemorizedNumbers(newMemorizedNumbers.ToList()); - - Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", newMemorizedNumbers)})"); - } - - private static void SetParenthesisNumberCallback(IntPtr state, int parenthesisCount) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.SetParenthesisNumber(parenthesisCount); - - Debug.WriteLine($"CalculatorManager.SetParenthesisNumberCallback({parenthesisCount})"); - } - - private static void BinaryOperatorReceivedCallback(IntPtr state) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.BinaryOperatorReceived(); - - Debug.WriteLine($"CalculatorManager.BinaryOperatorReceivedCallback"); - } - - private static void SetPrimaryDisplayCallback(IntPtr state, string displayStringValue, bool isError) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.SetPrimaryDisplay(displayStringValue, isError); - - Debug.WriteLine($"CalculatorManager.SetPrimaryDisplayCallback({displayStringValue}, {isError})"); - } - - private static void SetIsInErrorCallback(IntPtr state, bool isError) - { - var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay; - manager.SetIsInError(isError); - - Debug.WriteLine($"CalculatorManager.SetIsInErrorCallback({isError})"); - } - - private static IntPtr GetCEngineStringCallback(IntPtr state, string resourceId) - { - var provider = GCHandle.FromIntPtr(state).Target as EngineResourceProvider; - var ret = provider.GetCEngineString(resourceId) ?? ""; - - var retBytes = Encoding.UTF8.GetBytes(ret); - var retPtr = Marshal.AllocHGlobal(retBytes.Length+1); - Marshal.WriteByte(retPtr + retBytes.Length, 0); - Marshal.Copy(retBytes, 0, retPtr, retBytes.Length); - - Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})"); - - return retPtr; - } - } + } } diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.cs index 46a8241e..3002f44e 100644 --- a/src/Calculator.Shared/CalcManager/CalculatorManager.cs +++ b/src/Calculator.Shared/CalcManager/CalculatorManager.cs @@ -6,6 +6,8 @@ using System.Collections.Generic; using System.Diagnostics; using System.Runtime.InteropServices; using System.Text; +using Uno; +using Uno.Foundation; namespace CalculationManager { @@ -100,13 +102,36 @@ namespace CalculationManager public CalculatorManager(ref CalculatorDisplay displayCallback, ref EngineResourceProvider resourceProvider) { - Debug.WriteLine($"new CalculatorManager"); + Debug.WriteLine($"new CalculatorManager"); displayCallback = new CalculatorDisplay(); resourceProvider = new EngineResourceProvider(); _displayCallbackHandle = GCHandle.Alloc(displayCallback); _resourceProviderHandle = GCHandle.Alloc(resourceProvider); +#if __WASM__ + var rawPtrs = WebAssemblyRuntime.InvokeJS("CalcManager.registerCallbacks()"); + var ptrs = rawPtrs.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); + + var p = new CalculatorManager_CreateParams + { + CalculatorState = GCHandle.ToIntPtr(_displayCallbackHandle), + ResourceState = GCHandle.ToIntPtr(_resourceProviderHandle), + + GetCEngineString = (IntPtr)int.Parse(ptrs[0]), + BinaryOperatorReceived = (IntPtr)int.Parse(ptrs[1]), + SetPrimaryDisplay = (IntPtr)int.Parse(ptrs[2]), + SetIsInError = (IntPtr)int.Parse(ptrs[3]), + SetParenthesisNumber = (IntPtr)int.Parse(ptrs[4]), + MaxDigitsReached = (IntPtr)int.Parse(ptrs[5]), + MemoryItemChanged = (IntPtr)int.Parse(ptrs[6]), + OnHistoryItemAdded = (IntPtr)int.Parse(ptrs[7]), + OnNoRightParenAdded = (IntPtr)int.Parse(ptrs[8]), + SetExpressionDisplay = (IntPtr)int.Parse(ptrs[9]), + SetMemorizedNumbers = (IntPtr)int.Parse(ptrs[10]), + }; + +#else var p = new CalculatorManager_CreateParams { CalculatorState = GCHandle.ToIntPtr(_displayCallbackHandle), @@ -125,8 +150,11 @@ namespace CalculationManager SetMemorizedNumbers = Marshal.GetFunctionPointerForDelegate(_setMemorizedNumbersCallback), }; - _nativeManager = CalculatorManager_Create(ref p); - } +#endif + Debug.WriteLine($"-> CalculatorManager_Create"); + _nativeManager = NativeDispatch.CalculatorManager_Create(ref p); + Debug.WriteLine($"<- CalculatorManager_Create"); + } public void Reset(bool clearMemory = true) => throw new NotImplementedException(); public void SetStandardMode() => throw new NotImplementedException(); @@ -136,7 +164,7 @@ namespace CalculationManager { Debug.WriteLine($"CalculatorManager.SendCommand({command})"); - CalculatorManager_SendCommand(_nativeManager, command); + NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command); } public List SerializeCommands() => throw new NotImplementedException(); diff --git a/src/Calculator.Shared/Calculator.Shared.projitems b/src/Calculator.Shared/Calculator.Shared.projitems index 6dd46e12..24599449 100644 --- a/src/Calculator.Shared/Calculator.Shared.projitems +++ b/src/Calculator.Shared/Calculator.Shared.projitems @@ -225,6 +225,7 @@ + diff --git a/src/Calculator.Shared/Styles.xaml b/src/Calculator.Shared/Styles.xaml index 98abae65..5d3fd51a 100644 --- a/src/Calculator.Shared/Styles.xaml +++ b/src/Calculator.Shared/Styles.xaml @@ -1,10 +1,13 @@  + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:local="using:CalculatorApp" + mc:Ignorable="xamarin"> - + true + release-dynamic + C:\Users\jerome.laban\Downloads\mono-wasm-4d023b6bf84.zip + - + @@ -27,9 +30,10 @@ You can safely remove this ItemGroup completely. --> + - + @@ -37,5 +41,8 @@ + + + diff --git a/src/Calculator.Wasm/Program.cs b/src/Calculator.Wasm/Program.cs index 46ada3e5..40b01b4c 100644 --- a/src/Calculator.Wasm/Program.cs +++ b/src/Calculator.Wasm/Program.cs @@ -11,8 +11,10 @@ namespace WindowsCalculator.Wasm private static App _app; static void Main(string[] args) - { - ConfigureFilters(LogExtensionPoint.AmbientLoggerFactory); + { + Console.WriteLine("Program.Main"); + + ConfigureFilters(LogExtensionPoint.AmbientLoggerFactory); Windows.UI.Xaml.Application.Start(_ => _app = new App()); } diff --git a/src/Calculator.Wasm/WasmCSS/Fonts.css b/src/Calculator.Wasm/WasmCSS/Fonts.css index 27e5a545..a49767b6 100644 --- a/src/Calculator.Wasm/WasmCSS/Fonts.css +++ b/src/Calculator.Wasm/WasmCSS/Fonts.css @@ -1,7 +1,12 @@ @font-face { - font-family: "Symbols"; - /* winjs-symbols.woff2: https://github.com/Microsoft/fonts/tree/master/Symbols */ - src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); + font-family: "Calculator MDL2 Assets"; + src: url("Assets/CalcMDL2.woff") format('woff'); +} + +@font-face { + font-family: "Symbols"; + /* winjs-symbols.woff2: https://github.com/Microsoft/fonts/tree/master/Symbols */ + src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); } @font-face { diff --git a/src/Calculator.Wasm/WasmScripts/CalcManager.js b/src/Calculator.Wasm/WasmScripts/CalcManager.js new file mode 100644 index 00000000..fffd2bfa --- /dev/null +++ b/src/Calculator.Wasm/WasmScripts/CalcManager.js @@ -0,0 +1,44 @@ +class CalcManager { + static registerCallbacks() { + + var _getCEngineStringCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:GetCEngineStringCallback"); + var _binaryOperatorReceivedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:BinaryOperatorReceivedCallback"); + var _setPrimaryDisplayCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetPrimaryDisplayCallback"); + var _setIsInErrorCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetIsInErrorCallback"); + var _setParenthesisNumberCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetParenthesisNumberCallback"); + var _maxDigitsReachedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:MaxDigitsReachedCallback"); + var _memoryItemChangedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:MemoryItemChangedCallback"); + var _onHistoryItemAddedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:OnHistoryItemAddedCallback"); + var _onNoRightParenAddedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:OnNoRightParenAddedCallback"); + var _setExpressionDisplayCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetExpressionDisplayCallback"); + var _setMemorizedNumbersCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetMemorizedNumbersCallback"); + + var fGetCEngineStringCallback = Module.addFunction((state, id) => _getCEngineStringCallback(state, Module.UTF8ToString(id)), 'iii'); + + var fBinaryOperatorReceivedCallback = Module.addFunction((state) => _binaryOperatorReceivedCallback(state), 'vi'); + var fSetPrimaryDisplayCallback = Module.addFunction((state, displayStringValue, isError) => _setPrimaryDisplayCallback(state, Module.UTF8ToString(displayStringValue), isError), 'viii'); + var fSetIsInErrorCallback = Module.addFunction((state, isError) => _setIsInErrorCallback(state, isError), 'vii'); + var fSetParenthesisNumberCallback = Module.addFunction((state, parenthesisCount) => _setParenthesisNumberCallback(state, parenthesisCount), 'vii'); + var fMaxDigitsReachedCallback = Module.addFunction((state) => _maxDigitsReachedCallback(state), 'vii'); + var fMemoryItemChangedCallback = Module.addFunction((state, indexOfMemory) => _memoryItemChangedCallback(state, indexOfMemory), 'vii'); + var fOnHistoryItemAddedCallback = Module.addFunction((state, addedItemIndex) => _onHistoryItemAddedCallback(state, addedItemIndex), 'vii'); + var fOnNoRightParenAddedCallback = Module.addFunction((state) => _onNoRightParenAddedCallback (state), 'vi'); + var fSetExpressionDisplayCallback = Module.addFunction((state) => _setExpressionDisplayCallback (state), 'vi'); + var fSetMemorizedNumbersCallback = Module.addFunction((state, numbers) => _setMemorizedNumbersCallback(state, numbers), 'vii'); + + var ret = `${fGetCEngineStringCallback};` + + `${fBinaryOperatorReceivedCallback};` + + `${fSetPrimaryDisplayCallback};` + + `${fSetIsInErrorCallback};` + + `${fSetParenthesisNumberCallback};` + + `${fMaxDigitsReachedCallback};` + + `${fMemoryItemChangedCallback};` + + `${fOnHistoryItemAddedCallback};` + + `${fOnNoRightParenAddedCallback};` + + `${fSetExpressionDisplayCallback};` + + `${fSetMemorizedNumbersCallback};` + ; + + return ret; + } +}