diff --git a/src/CalcManager/CCalcManager.cpp b/src/CalcManager/CCalcManager.cpp index 6db0f533..7ffb32af 100644 --- a/src/CalcManager/CCalcManager.cpp +++ b/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) { - - printf("-> NativeCalcManager:CalculatorManager_Create(%p)\n", pParams); +CalculatorManager* AsManager(void* manager) +{ + return static_cast(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) { - (static_cast(manager))->SendCommand((Command)command); +void CalculatorManager_SendCommand(void* manager, int 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> 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> 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); } diff --git a/src/CalcManager/CCalcManager.h b/src/CalcManager/CCalcManager.h index 37e10406..5ce62c9d 100644 --- a/src/CalcManager/CCalcManager.h +++ b/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); } diff --git a/src/CalcManager/CalcManager.vcxproj b/src/CalcManager/CalcManager.vcxproj index d5bf99b1..7bc39631 100644 --- a/src/CalcManager/CalcManager.vcxproj +++ b/src/CalcManager/CalcManager.vcxproj @@ -54,17 +54,17 @@ x64 - StaticLibrary + DynamicLibrary true v142 - StaticLibrary + DynamicLibrary true v142 - StaticLibrary + DynamicLibrary true v142 diff --git a/src/CalcManager/CalcManager.wasm b/src/CalcManager/CalcManager.wasm index ec28806f..924d9d07 100644 Binary files a/src/CalcManager/CalcManager.wasm and b/src/CalcManager/CalcManager.wasm differ diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs index 88ebd595..e07c30c1 100644 --- a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs +++ b/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); - public delegate void BinaryOperatorReceivedFunc(int state); - 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); + [DllImport("CalcManager")] + public static extern void CalculatorManager_SetRadix(IntPtr nativeManager, RADIX_TYPE iRadixType); - public delegate void MaxDigitsReachedCallbackFunc(int state); - public delegate void MemoryItemChangedCallbackFunc(int state, int indexOfMemory); - public delegate void OnHistoryItemAddedCallbackFunc(int state, int addedItemIndex); - public delegate void OnNoRightParenAddedCallbackFunc(int state); - public delegate void SetExpressionDisplayCallbackFunc(int state); - public delegate void SetMemorizedNumbersCallbackFunc(int state, string[] newMemorizedNumbers); + [DllImport("CalcManager")] + public static extern void CalculatorManager_Reset(IntPtr nativeManager, bool clearMemory); + + [DllImport("CalcManager")] + public static extern void CalculatorManager_SetStandardMode(IntPtr nativeManager); + + [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,22 @@ 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(); + for (int i = 0; i < count; i++) + { + numbers.Add(Marshal.PtrToStringUTF8(Marshal.ReadIntPtr(newMemorizedNumbers, i))); + } + + manager.SetMemorizedNumbers(numbers); + + Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", numbers)})"); } - public static void SetParenthesisNumberCallback(int state, int parenthesisCount) + public static void SetParenthesisNumberCallback(IntPtr state, int parenthesisCount) { var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay; manager.SetParenthesisNumber(parenthesisCount); @@ -100,7 +173,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 +181,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 +189,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 +197,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 +209,7 @@ namespace CalculationManager Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})"); - return (int)retPtr; + return retPtr; } } @@ -145,7 +218,7 @@ namespace CalculationManager private GCHandle _displayCallbackHandle; private GCHandle _resourceProviderHandle; - private readonly int _nativeManager; + private readonly IntPtr _nativeManager; } } diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.cs index 00049a96..c440731f 100644 --- a/src/Calculator.Shared/CalcManager/CalculatorManager.cs +++ b/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,23 +148,26 @@ 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 SetStandardMode() => throw new NotImplementedException(); - public void SetScientificMode() => throw new NotImplementedException(); - public void SetProgrammerMode() => throw new NotImplementedException(); - public void SendCommand(Command command) - { - Debug.WriteLine($"CalculatorManager.SendCommand({command})"); + public void Reset(bool clearMemory = true) + => NativeDispatch.CalculatorManager_Reset(_nativeManager, clearMemory); - NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command); - } + public void SetStandardMode() + => NativeDispatch.CalculatorManager_SetStandardMode(_nativeManager); - public List SerializeCommands() => throw new NotImplementedException(); + public void SetScientificMode() + => NativeDispatch.CalculatorManager_SetScientificMode(_nativeManager); + + public void SetProgrammerMode() + => NativeDispatch.CalculatorManager_SetProgrammerMode(_nativeManager); + + public void SendCommand(Command command) + => NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command); + + public List SerializeCommands() => throw new NotImplementedException(); public void DeSerializeCommands(List serializedData) => throw new NotImplementedException(); public void SerializeMemory() => throw new NotImplementedException(); public List GetSerializedMemory() => throw new NotImplementedException(); @@ -175,47 +177,49 @@ namespace CalculationManager public void DeSerializePrimaryDisplay(List serializedPrimaryDisplay) => throw new NotImplementedException(); public Command SerializeSavedDegreeMode() => throw new NotImplementedException(); - public void MemorizeNumber() => throw new NotImplementedException(); - public void MemorizedNumberLoad(int value) - { - Debug.WriteLine($"CalculatorManager.MemorizedNumberLoad({value})"); - } - public void MemorizedNumberAdd(int value) - { - Debug.WriteLine($"CalculatorManager.MemorizedNumberAdd({value})"); - } - public void MemorizedNumberSubtract(int value) - { - Debug.WriteLine($"CalculatorManager.MemorizedNumberSubtract({value})"); - } - public void MemorizedNumberClear(int value) - { - Debug.WriteLine($"CalculatorManager.MemorizedNumberClear({value})"); - } - public void MemorizedNumberClearAll() - { - Debug.WriteLine($"CalculatorManager.MemorizedNumberClearAll()"); - } + public void MemorizeNumber() + => NativeDispatch.CalculatorManager_MemorizeNumber(_nativeManager); + + public void MemorizedNumberLoad(int value) + => NativeDispatch.CalculatorManager_MemorizedNumberLoad(_nativeManager, value); + + public void MemorizedNumberAdd(int value) + => NativeDispatch.CalculatorManager_MemorizedNumberAdd(_nativeManager, value); + + public void MemorizedNumberSubtract(int value) + => NativeDispatch.CalculatorManager_MemorizedNumberSubtract(_nativeManager, value); + + public void MemorizedNumberClear(int value) + => NativeDispatch.CalculatorManager_MemorizedNumberClear(_nativeManager, value); + + public void MemorizedNumberClearAll() + => NativeDispatch.CalculatorManager_MemorizedNumberClearAll(_nativeManager); + + public bool IsEngineRecording() + => NativeDispatch.CalculatorManager_IsEngineRecording(_nativeManager); + + public List GetSavedCommands() + => throw new NotImplementedException(); - public bool IsEngineRecording() => throw new NotImplementedException(); - public List GetSavedCommands() => throw new NotImplementedException(); public void SetRadix(RADIX_TYPE iRadixType) - { - Debug.WriteLine($"CalculatorManager.SetRadix({iRadixType})"); - } - public void SetMemorizedNumbersString() => throw new NotImplementedException(); - public string GetResultForRadix(int radix, int precision) => throw new NotImplementedException(); - public void SetPrecision(int precision) - { - Debug.WriteLine($"CalculatorManager.SetPrecision({precision})"); - } - public void UpdateMaxIntDigits() - { - Debug.WriteLine($"CalculatorManager.UpdateMaxIntDigits()"); - } - public char DecimalSeparator() => throw new NotImplementedException(); + => NativeDispatch.CalculatorManager_SetRadix(_nativeManager, iRadixType); - public List GetHistoryItems() => throw new NotImplementedException(); + public void SetMemorizedNumbersString() + => NativeDispatch.CalculatorManager_SetMemorizedNumbersString(_nativeManager); + + public string GetResultForRadix(int radix, int precision) + => NativeDispatch.CalculatorManager_GetResultForRadix(_nativeManager, radix, precision); + + public void SetPrecision(int precision) + => NativeDispatch.CalculatorManager_SetPrecision(_nativeManager, precision); + + public void UpdateMaxIntDigits() + => NativeDispatch.CalculatorManager_UpdateMaxIntDigits(_nativeManager); + + public char DecimalSeparator() + => NativeDispatch.CalculatorManager_DecimalSeparator(_nativeManager); + + public List GetHistoryItems() => throw new NotImplementedException(); public List GetHistoryItems(CalculationManager.CALCULATOR_MODE mode) { @@ -225,11 +229,21 @@ namespace CalculationManager } public HISTORYITEM GetHistoryItem(int uIdx) => throw new NotImplementedException(); - public bool RemoveHistoryItem(int uIdx) => throw new NotImplementedException(); - public void ClearHistory() => throw new NotImplementedException(); - public int MaxHistorySize() => throw new NotImplementedException(); - public CalculationManager.Command GetCurrentDegreeMode() => throw new NotImplementedException(); - public void SetHistory(CALCULATOR_MODE eMode, List history) => throw new NotImplementedException(); - public void SetInHistoryItemLoadMode(bool isHistoryItemLoadMode) => throw new NotImplementedException(); - } + public bool RemoveHistoryItem(int uIdx) + => NativeDispatch.CalculatorManager_RemoveHistoryItem(_nativeManager, uIdx); + + 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 history) => throw new NotImplementedException(); + + public void SetInHistoryItemLoadMode(bool isHistoryItemLoadMode) + => NativeDispatch.CalculatorManager_SetInHistoryItemLoadMode(_nativeManager, isHistoryItemLoadMode); + } }