Merge pull request #4 from nventive/dev/jela/wasm-update

Add more native methods, fix the x64 UWP target.

src/CalcManager/CCalcManager.cpp

@@ -79,7 +79,7 @@ public:
 			auto pData = new char[str.size() + 1];
 
 #if !defined(__EMSCRIPTEN__)
-			strcpy_s(pData, str.size(), str.data());
+			strcpy_s(pData, str.size()+1, str.data());
 #else
             strcpy(pData, str.data());
 #endif
@@ -123,20 +123,141 @@ public:
 	}
 };
 
-void* CalculatorManager_Create(CalculatorManager_CreateParams* pParams) {
+CalculatorManager* AsManager(void* manager)
-
+{
-	printf("-> NativeCalcManager:CalculatorManager_Create(%p)\n", pParams);
+    return static_cast<CalculatorManager*>(manager);
+}
 
+void* CalculatorManager_Create(CalculatorManager_CreateParams* pParams)
+{
 	auto calcDisplay = new CalcDisplay(*pParams);
 	auto resProvider = new ResourceProvider(*pParams);
 
-	printf("NativeCalcManager:CalculatorManager_Create: Got providers\n");
-
 	auto cm = new CalculatorManager(calcDisplay, resProvider);
-    printf("<- NativeCalcManager:CalculatorManager_Create(%p)\n", pParams);
 	return cm;
 }
 
-void CalculatorManager_SendCommand(void* manager, int command) {
+void CalculatorManager_SendCommand(void* manager, int command)
-	(static_cast<CalculatorManager*>(manager))->SendCommand((Command)command);
+{
+    AsManager(manager)->SendCommand((Command)command);
+}
+
+void CalculatorManager_SetRadix(void* manager, RADIX_TYPE iRadixType)
+{
+    AsManager(manager)->SetRadix(iRadixType);
+}
+
+void CalculatorManager_Reset(void* manager, bool clearMemory)
+{
+    AsManager(manager)->Reset(clearMemory);
+}
+
+void CalculatorManager_SetStandardMode(void* manager)
+{
+    AsManager(manager)->SetStandardMode();
+}
+
+void CalculatorManager_SetScientificMode(void* manager)
+{
+    AsManager(manager)->SetScientificMode();
+}
+
+void CalculatorManager_SetProgrammerMode(void* manager)
+{
+    AsManager(manager)->SetProgrammerMode();
+}
+
+void CalculatorManager_MemorizeNumber(void* manager)
+{
+    AsManager(manager)->MemorizeNumber();
+}
+
+void CalculatorManager_MemorizedNumberLoad(void* manager, int value)
+{
+    AsManager(manager)->MemorizedNumberLoad(value);
+}
+
+void CalculatorManager_MemorizedNumberAdd(void* manager, int value)
+{
+    AsManager(manager)->MemorizedNumberAdd(value);
+}
+
+void CalculatorManager_MemorizedNumberSubtract(void* manager, int value)
+{
+    AsManager(manager)->MemorizedNumberSubtract(value);
+}
+
+void CalculatorManager_MemorizedNumberClear(void* manager, int value)
+{
+    AsManager(manager)->MemorizedNumberClear(value);
+}
+
+void CalculatorManager_MemorizedNumberClearAll(void* manager)
+{
+    AsManager(manager)->MemorizedNumberClearAll();
+}
+
+bool CalculatorManager_IsEngineRecording(void* manager)
+{
+    return AsManager(manager)->IsEngineRecording();
+}
+
+void CalculatorManager_SetMemorizedNumbersString(void* manager)
+{
+    AsManager(manager)->SetMemorizedNumbersString();
+}
+
+const char* CalculatorManager_GetResultForRadix(void* manager, int radix, int precision)
+{
+    auto res = AsManager(manager)->GetResultForRadix(radix, precision);
+
+	std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
+    auto str = convert.to_bytes(res);
+
+	return str.data();
+}
+
+void CalculatorManager_SetPrecision(void* manager, int precision)
+{
+    AsManager(manager)->SetPrecision(precision);
+}
+
+void CalculatorManager_UpdateMaxIntDigits(void* manager)
+{
+    AsManager(manager)->UpdateMaxIntDigits();
+}
+
+const char* CalculatorManager_DecimalSeparator(void* manager)
+{
+    auto res = AsManager(manager)->DecimalSeparator();
+
+    std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
+    auto str = convert.to_bytes(res);
+
+	return str.data();
+}
+
+bool CalculatorManager_RemoveHistoryItem(void* manager, int uIdx)
+{
+    return AsManager(manager)->RemoveHistoryItem(uIdx);
+}
+
+void CalculatorManager_ClearHistory(void* manager)
+{
+    AsManager(manager)->ClearHistory();
+}
+
+size_t CalculatorManager_MaxHistorySize(void* manager)
+{
+    return AsManager(manager)->MaxHistorySize();
+}
+
+int CalculatorManager_GetCurrentDegreeMode(void* manager)
+{
+    return (int)AsManager(manager)->GetCurrentDegreeMode();
+}
+
+void CalculatorManager_SetInHistoryItemLoadMode(void* manager, bool isHistoryItemLoadMode)
+{
+    AsManager(manager)->SetInHistoryItemLoadMode(isHistoryItemLoadMode);
 }

src/CalcManager/CCalcManager.h

@@ -60,5 +60,27 @@ struct CalculatorManager_CreateParams {
 extern "C" {
     DLL_EXPORT void* CalculatorManager_Create(CalculatorManager_CreateParams* params);
     DLL_EXPORT void CalculatorManager_SendCommand(void* manager, int command);
+    DLL_EXPORT void CalculatorManager_SetRadix(void* manager, RADIX_TYPE iRadixType);
+    DLL_EXPORT void CalculatorManager_Reset(void* manager, bool clearMemory);
+    DLL_EXPORT void CalculatorManager_SetStandardMode(void* manager);
+    DLL_EXPORT void CalculatorManager_SetScientificMode(void* manager);
+    DLL_EXPORT void CalculatorManager_SetProgrammerMode(void* manager);
+    DLL_EXPORT void CalculatorManager_MemorizeNumber(void* manager);
+    DLL_EXPORT void CalculatorManager_MemorizedNumberLoad(void* manager, int value);
+    DLL_EXPORT void CalculatorManager_MemorizedNumberAdd(void* manager, int value);
+    DLL_EXPORT void CalculatorManager_MemorizedNumberSubtract(void* manager, int value);
+    DLL_EXPORT void CalculatorManager_MemorizedNumberClear(void* manager, int value);
+    DLL_EXPORT void CalculatorManager_MemorizedNumberClearAll(void* manager);
+    DLL_EXPORT bool CalculatorManager_IsEngineRecording(void* manager);
+    DLL_EXPORT void CalculatorManager_SetMemorizedNumbersString(void* manager);
+    DLL_EXPORT const char* CalculatorManager_GetResultForRadix(void* manager, int radix, int precision);
+    DLL_EXPORT void CalculatorManager_SetPrecision(void* manager, int precision);
+    DLL_EXPORT void CalculatorManager_UpdateMaxIntDigits(void* manager);
+    DLL_EXPORT const char* CalculatorManager_DecimalSeparator(void* manager);
+    DLL_EXPORT bool CalculatorManager_RemoveHistoryItem(void* manager, int uIdx);
+    DLL_EXPORT void CalculatorManager_ClearHistory(void* manager);
+    DLL_EXPORT size_t CalculatorManager_MaxHistorySize(void* manager);
+    DLL_EXPORT int CalculatorManager_GetCurrentDegreeMode(void* manager);
+    DLL_EXPORT void CalculatorManager_SetInHistoryItemLoadMode(void* manager, bool isHistoryItemLoadMode);
 }
 

src/CalcManager/CalcManager.vcxproj

@@ -54,17 +54,17 @@
     <PreferredToolArchitecture>x64</PreferredToolArchitecture>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v142</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v142</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v142</PlatformToolset>
   </PropertyGroup>

src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs

@@ -13,23 +13,89 @@ namespace CalculationManager
 	public static class NativeDispatch
 	{
 		[DllImport("CalcManager")]
-		public static extern int CalculatorManager_Create(ref CalculatorManager_CreateParams parms);
+		public static extern IntPtr CalculatorManager_Create(ref CalculatorManager_CreateParams parms);
 
 		[DllImport("CalcManager")]
-		public static extern void CalculatorManager_SendCommand(int instance, Command command);
+		public static extern void CalculatorManager_SendCommand(IntPtr nativeManager, Command command);
 
-		public delegate int GetCEngineStringFunc(int state, string id);
+		[DllImport("CalcManager")]
-		public delegate void BinaryOperatorReceivedFunc(int state);
+		public static extern void CalculatorManager_SetRadix(IntPtr nativeManager, RADIX_TYPE iRadixType);
-		public delegate void SetPrimaryDisplayCallbackFunc(int state, string displayStringValue, bool isError);
-		public delegate void SetIsInErrorCallbackFunc(int state, bool isError);
-		public delegate void SetParenthesisNumberCallbackFunc(int state, int parenthesisCount);
 
-		public delegate void MaxDigitsReachedCallbackFunc(int state);
+		[DllImport("CalcManager")]
-		public delegate void MemoryItemChangedCallbackFunc(int state, int indexOfMemory);
+		public static extern void CalculatorManager_Reset(IntPtr nativeManager, bool clearMemory);
-		public delegate void OnHistoryItemAddedCallbackFunc(int state, int addedItemIndex);
+
-		public delegate void OnNoRightParenAddedCallbackFunc(int state);
+		[DllImport("CalcManager")]
-		public delegate void SetExpressionDisplayCallbackFunc(int state);
+		public static extern void CalculatorManager_SetStandardMode(IntPtr nativeManager);
-		public delegate void SetMemorizedNumbersCallbackFunc(int state, string[] newMemorizedNumbers);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SetScientificMode(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SetProgrammerMode(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizeNumber(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizedNumberLoad(IntPtr nativeManager, int value);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizedNumberAdd(IntPtr nativeManager, int value);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizedNumberSubtract(IntPtr nativeManager, int value);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizedNumberClear(IntPtr nativeManager, int value);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_MemorizedNumberClearAll(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern bool CalculatorManager_IsEngineRecording(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SetMemorizedNumbersString(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern string CalculatorManager_GetResultForRadix(IntPtr nativeManager, int radix, int precision);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SetPrecision(IntPtr nativeManager, int precision);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_UpdateMaxIntDigits(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern char CalculatorManager_DecimalSeparator(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern bool CalculatorManager_RemoveHistoryItem(IntPtr nativeManager, int uIdx);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_ClearHistory(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern int CalculatorManager_MaxHistorySize(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern Command CalculatorManager_GetCurrentDegreeMode(IntPtr nativeManager);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SetInHistoryItemLoadMode(IntPtr nativeManager, bool isHistoryItemLoadMode);
+
+		public delegate IntPtr GetCEngineStringFunc(IntPtr state, string id);
+		public delegate void BinaryOperatorReceivedFunc(IntPtr state);
+		public delegate void SetPrimaryDisplayCallbackFunc(IntPtr state, string displayStringValue, bool isError);
+		public delegate void SetIsInErrorCallbackFunc(IntPtr state, bool isError);
+		public delegate void SetParenthesisNumberCallbackFunc(IntPtr state, int parenthesisCount);
+
+		public delegate void MaxDigitsReachedCallbackFunc(IntPtr state);
+		public delegate void MemoryItemChangedCallbackFunc(IntPtr state, int indexOfMemory);
+		public delegate void OnHistoryItemAddedCallbackFunc(IntPtr state, int addedItemIndex);
+		public delegate void OnNoRightParenAddedCallbackFunc(IntPtr state);
+		public delegate void SetExpressionDisplayCallbackFunc(IntPtr state);
+		public delegate void SetMemorizedNumbersCallbackFunc(IntPtr state, int count, IntPtr newMemorizedNumbers);
 
 		public static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback;
 		public static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback;
@@ -44,7 +110,7 @@ namespace CalculationManager
 		public static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback = SetExpressionDisplayCallback;
 		public static SetMemorizedNumbersCallbackFunc _setMemorizedNumbersCallback = SetMemorizedNumbersCallback;
 
-		public static void MaxDigitsReachedCallback(int state)
+		public static void MaxDigitsReachedCallback(IntPtr state)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.MaxDigitsReached();
@@ -52,7 +118,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.MaxDigitsReachedCallback");
 		}
 
-		public static void MemoryItemChangedCallback(int state, int indexOfMemory)
+		public static void MemoryItemChangedCallback(IntPtr state, int indexOfMemory)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.MemoryItemChanged(indexOfMemory);
@@ -60,7 +126,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.MemoryItemChangedCallback({indexOfMemory})");
 		}
 
-		public static void OnHistoryItemAddedCallback(int state, int addedItemIndex)
+		public static void OnHistoryItemAddedCallback(IntPtr state, int addedItemIndex)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.OnHistoryItemAdded(addedItemIndex);
@@ -68,7 +134,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.OnHistoryItemAddedCallback({addedItemIndex})");
 		}
 
-		public static void OnNoRightParenAddedCallback(int state)
+		public static void OnNoRightParenAddedCallback(IntPtr state)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.OnNoRightParenAdded();
@@ -76,7 +142,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.OnNoRightParenAddedCallback");
 		}
 
-		public static void SetExpressionDisplayCallback(int state)
+		public static void SetExpressionDisplayCallback(IntPtr state)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			// manager.SetExpressionDisplay();
@@ -84,15 +150,24 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.SetExpressionDisplayCallback");
 		}
 
-		public static void SetMemorizedNumbersCallback(int state, string[] newMemorizedNumbers)
+		public static void SetMemorizedNumbersCallback(IntPtr state, int count, IntPtr newMemorizedNumbers)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
-			manager.SetMemorizedNumbers(newMemorizedNumbers.ToList());
 
-			Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", newMemorizedNumbers)})");
+			var numbers = new List<String>();
+			for (int i = 0; i < count; i++)
+			{
+				// TODO Use native encoding instead.
+				var value = Marshal.PtrToStringAnsi(Marshal.ReadIntPtr(newMemorizedNumbers, i));
+				numbers.Add(Encoding.UTF8.GetString(Encoding.ASCII.GetBytes(value)));
 			}
 
-		public static void SetParenthesisNumberCallback(int state, int parenthesisCount)
+			manager.SetMemorizedNumbers(numbers);
+
+			Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", numbers)})");
+		}
+
+		public static void SetParenthesisNumberCallback(IntPtr state, int parenthesisCount)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.SetParenthesisNumber(parenthesisCount);
@@ -100,7 +175,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.SetParenthesisNumberCallback({parenthesisCount})");
 		}
 
-		public static void BinaryOperatorReceivedCallback(int state)
+		public static void BinaryOperatorReceivedCallback(IntPtr state)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.BinaryOperatorReceived();
@@ -108,7 +183,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.BinaryOperatorReceivedCallback");
 		}
 
-		public static void SetPrimaryDisplayCallback(int state, string displayStringValue, bool isError)
+		public static void SetPrimaryDisplayCallback(IntPtr state, string displayStringValue, bool isError)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.SetPrimaryDisplay(displayStringValue, isError);
@@ -116,7 +191,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.SetPrimaryDisplayCallback({displayStringValue}, {isError})");
 		}
 
-		public static void SetIsInErrorCallback(int state, bool isError)
+		public static void SetIsInErrorCallback(IntPtr state, bool isError)
 		{
 			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
 			manager.SetIsInError(isError);
@@ -124,7 +199,7 @@ namespace CalculationManager
 			Debug.WriteLine($"CalculatorManager.SetIsInErrorCallback({isError})");
 		}
 
-		public static int GetCEngineStringCallback(int state, string resourceId)
+		public static IntPtr GetCEngineStringCallback(IntPtr state, string resourceId)
 		{
 			var provider = GCHandle.FromIntPtr((IntPtr)state).Target as EngineResourceProvider;
 			var ret = provider.GetCEngineString(resourceId) ?? "";
@@ -136,7 +211,7 @@ namespace CalculationManager
 
 			Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})");
 
-			return (int)retPtr;
+			return retPtr;
 		}
 	}
 
@@ -145,7 +220,7 @@ namespace CalculationManager
 
 		private GCHandle _displayCallbackHandle;
 		private GCHandle _resourceProviderHandle;
-		private readonly int _nativeManager;
+		private readonly IntPtr _nativeManager;
 
 	}
 }

src/Calculator.Shared/CalcManager/CalculatorManager.cs

@@ -100,7 +100,6 @@ namespace CalculationManager
 
         public CalculatorManager(ref CalculatorDisplay displayCallback, ref EngineResourceProvider resourceProvider)
         {
-			Debug.WriteLine($"new CalculatorManager");
             displayCallback = new CalculatorDisplay();
             resourceProvider = new EngineResourceProvider();
 
@@ -149,21 +148,24 @@ namespace CalculationManager
             };
 
 #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 Reset(bool clearMemory = true)
-        public void SetStandardMode() => throw new NotImplementedException();
+			=> NativeDispatch.CalculatorManager_Reset(_nativeManager, clearMemory);
-        public void SetScientificMode() => throw new NotImplementedException();
+
-        public void SetProgrammerMode() => throw new NotImplementedException();
+		public void SetStandardMode()
+			=> NativeDispatch.CalculatorManager_SetStandardMode(_nativeManager);
+
+		public void SetScientificMode()
+			=> NativeDispatch.CalculatorManager_SetScientificMode(_nativeManager);
+
+		public void SetProgrammerMode()
+			=> NativeDispatch.CalculatorManager_SetProgrammerMode(_nativeManager);
+
 		public void SendCommand(Command command)
-        {
+			=> NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command);
-            Debug.WriteLine($"CalculatorManager.SendCommand({command})");
-
-			NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command);
-        }
 
 		public List<char> SerializeCommands() => throw new NotImplementedException();
         public void DeSerializeCommands(List<char> serializedData) => throw new NotImplementedException();
@@ -175,45 +177,47 @@ namespace CalculationManager
         public void DeSerializePrimaryDisplay(List<long> serializedPrimaryDisplay) => throw new NotImplementedException();
         public Command SerializeSavedDegreeMode() => throw new NotImplementedException();
 
-        public void MemorizeNumber() => throw new NotImplementedException();
+        public void MemorizeNumber()
-        public void MemorizedNumberLoad(int value)
+			=> NativeDispatch.CalculatorManager_MemorizeNumber(_nativeManager);
-        {
+
-            Debug.WriteLine($"CalculatorManager.MemorizedNumberLoad({value})");
+		public void MemorizedNumberLoad(int value)
-        }
+			=> NativeDispatch.CalculatorManager_MemorizedNumberLoad(_nativeManager, value);
-        public void MemorizedNumberAdd(int value)
+
-        {
+		public void MemorizedNumberAdd(int value)
-            Debug.WriteLine($"CalculatorManager.MemorizedNumberAdd({value})");
+			=> NativeDispatch.CalculatorManager_MemorizedNumberAdd(_nativeManager, value);
-        }
+
-        public void MemorizedNumberSubtract(int value)
+		public void MemorizedNumberSubtract(int value)
-        {
+			=> NativeDispatch.CalculatorManager_MemorizedNumberSubtract(_nativeManager, value);
-            Debug.WriteLine($"CalculatorManager.MemorizedNumberSubtract({value})");
+
-        }
+		public void MemorizedNumberClear(int value)
-        public void MemorizedNumberClear(int value)
+			=> NativeDispatch.CalculatorManager_MemorizedNumberClear(_nativeManager, value);
-        {
+
-            Debug.WriteLine($"CalculatorManager.MemorizedNumberClear({value})");
+		public void MemorizedNumberClearAll()
-        }
+			=> NativeDispatch.CalculatorManager_MemorizedNumberClearAll(_nativeManager);
-        public void MemorizedNumberClearAll()
+
-        {
+		public bool IsEngineRecording()
-            Debug.WriteLine($"CalculatorManager.MemorizedNumberClearAll()");
+			=> NativeDispatch.CalculatorManager_IsEngineRecording(_nativeManager);
-        }
+
+		public List<char> GetSavedCommands()
+			=> throw new NotImplementedException();
 
-        public bool IsEngineRecording() => throw new NotImplementedException();
-        public List<char> GetSavedCommands() => throw new NotImplementedException();
         public void SetRadix(RADIX_TYPE iRadixType)
-        {
+			=> NativeDispatch.CalculatorManager_SetRadix(_nativeManager, iRadixType);
-            Debug.WriteLine($"CalculatorManager.SetRadix({iRadixType})");
+
-        }
+		public void SetMemorizedNumbersString()
-        public void SetMemorizedNumbersString() => throw new NotImplementedException();
+			=> NativeDispatch.CalculatorManager_SetMemorizedNumbersString(_nativeManager);
-        public string GetResultForRadix(int radix, int precision) => throw new NotImplementedException();
+
+		public string GetResultForRadix(int radix, int precision)
+			=> NativeDispatch.CalculatorManager_GetResultForRadix(_nativeManager, radix, precision);
+
 		public void SetPrecision(int precision)
-        {
+			=> NativeDispatch.CalculatorManager_SetPrecision(_nativeManager, precision);
-            Debug.WriteLine($"CalculatorManager.SetPrecision({precision})");
+
-        }
 		public void UpdateMaxIntDigits()
-        {
+			=> NativeDispatch.CalculatorManager_UpdateMaxIntDigits(_nativeManager);
-            Debug.WriteLine($"CalculatorManager.UpdateMaxIntDigits()");
+
-        }
+		public char DecimalSeparator()
-        public char DecimalSeparator() => throw new NotImplementedException();
+			=> NativeDispatch.CalculatorManager_DecimalSeparator(_nativeManager);
 
 		public List<HISTORYITEM> GetHistoryItems() => throw new NotImplementedException();
 
@@ -225,11 +229,21 @@ namespace CalculationManager
         }
 
         public HISTORYITEM GetHistoryItem(int uIdx) => throw new NotImplementedException();
-        public bool RemoveHistoryItem(int uIdx) => throw new NotImplementedException();
+        public bool RemoveHistoryItem(int uIdx)
-        public void ClearHistory() => throw new NotImplementedException();
+			=> NativeDispatch.CalculatorManager_RemoveHistoryItem(_nativeManager, uIdx);
-        public int MaxHistorySize() => throw new NotImplementedException();
+
-        public CalculationManager.Command GetCurrentDegreeMode() => throw new NotImplementedException();
+		public void ClearHistory()
+			=> NativeDispatch.CalculatorManager_ClearHistory(_nativeManager);
+
+		public int MaxHistorySize()
+			=> NativeDispatch.CalculatorManager_MaxHistorySize(_nativeManager);
+
+		public CalculationManager.Command GetCurrentDegreeMode()
+			=> NativeDispatch.CalculatorManager_GetCurrentDegreeMode(_nativeManager);
+
 		public void SetHistory(CALCULATOR_MODE eMode, List<HISTORYITEM> history) => throw new NotImplementedException();
-        public void SetInHistoryItemLoadMode(bool isHistoryItemLoadMode) => throw new NotImplementedException();
+
+        public void SetInHistoryItemLoadMode(bool isHistoryItemLoadMode)
+			=> NativeDispatch.CalculatorManager_SetInHistoryItemLoadMode(_nativeManager, isHistoryItemLoadMode);
 	}
 }