github/msft-calculator
1
0
Fork 0
mirror of https://github.com/Microsoft/calculator.git synced 2025-08-22 22:23:29 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
Wasm updates
This commit is contained in:
Jérôme Laban 2019-05-15 15:50:47 -04:00 • committed by GitHub
commit afa02f9da3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
32 changed files with 745 additions and 2212 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/CalcManager/CCalcManager.cpp
View file

@ -1,8 +1,14 @@
#define __STDC_WANT_LIB_EXT1__ 1
#include "pch.h"
#include "CCalcManager.h"
#include "CalculatorManager.h"
#include "CalculatorResource.h"
#include <codecvt>
#include <locale>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace CalculationManager;
@ -71,7 +77,12 @@ public:
{
auto str = convert.to_bytes(memorizedNumbers[i]);
auto pData = new char[str.size() + 1];
strncpy_s(pData, str.size(), str.data(), str.size());
#if !defined(__EMSCRIPTEN__)
strcpy_s(pData, str.size(), str.data());
#else
strcpy(pData, str.data());
#endif
numbers[i] = pData;
}
@ -114,10 +125,15 @@ public:
void* CalculatorManager_Create(CalculatorManager_CreateParams* pParams) {
printf("-> NativeCalcManager:CalculatorManager_Create(%p)\n", 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;
}

10
src/CalcManager/CCalcManager.h
View file

@ -51,8 +51,14 @@ struct CalculatorManager_CreateParams {
GetCEngineStringFunc GetCEngineString;
};
#if defined(__EMSCRIPTEN__)
#define DLL_EXPORT
#else
#define DLL_EXPORT __declspec(dllexport)
#endif
extern "C" {
__declspec(dllexport) void* CalculatorManager_Create(CalculatorManager_CreateParams* params);
__declspec(dllexport) void CalculatorManager_SendCommand(void* manager, int command);
DLL_EXPORT void* CalculatorManager_Create(CalculatorManager_CreateParams* params);
DLL_EXPORT void CalculatorManager_SendCommand(void* manager, int command);
}

2
src/CalcManager/CalcManager.vcxproj
View file

@ -314,7 +314,6 @@
<ClInclude Include="Ratpack\CalcErr.h" />
<ClInclude Include="Ratpack\ratconst.h" />
<ClInclude Include="Ratpack\ratpak.h" />
<ClInclude Include="UnitConverter.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="CalculatorHistory.cpp" />
@ -355,7 +354,6 @@
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="UnitConverter.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets" />

2
src/CalcManager/CalcManager.vcxproj.filters
View file

@ -76,7 +76,6 @@
</ClCompile>
<ClCompile Include="CalculatorHistory.cpp" />
<ClCompile Include="CalculatorManager.cpp" />
<ClCompile Include="UnitConverter.cpp" />
<ClCompile Include="CEngine\CalcInput.cpp">
<Filter>CEngine</Filter>
</ClCompile>
@ -106,7 +105,6 @@
<Filter>RatPack</Filter>
</ClInclude>
<ClInclude Include="CalculatorVector.h" />
<ClInclude Include="UnitConverter.h" />
<ClInclude Include="CalculatorHistory.h" />
<ClInclude Include="CalculatorManager.h" />
<ClInclude Include="CalculatorResource.h" />

BIN
src/CalcManager/CalcManager.wasm Normal file
View file

Binary file not shown.

4
src/CalcManager/CalculatorManager.cpp
View file

@ -14,7 +14,11 @@ static constexpr size_t SERIALIZED_NUMBER_MINSIZE = 3;
// Converts Memory Command enum value to unsigned char,
// while ignoring Warning C4309: 'conversion' : truncation of constant value
#if defined(__EMSCRIPTEN__)
#define MEMORY_COMMAND_TO_UNSIGNED_CHAR(c) static_cast<unsigned char>(c)
#else
#define MEMORY_COMMAND_TO_UNSIGNED_CHAR(c) __pragma(warning(push)) __pragma(warning(disable : 4309)) static_cast<unsigned char>(c) __pragma(warning(pop))
#endif
namespace CalculationManager
{

2
src/CalcManager/CalculatorVector.h
View file

@ -10,7 +10,7 @@
#include "Ratpack/CalcErr.h"
#include <stdexcept> // for std::out_of_range
#if !defined(__WEBASSEMBLY__)
#if !defined(__EMSCRIPTEN__)
#include <winerror.h>
#include <sal.h> // for SAL
#endif

4
src/CalcManager/Ratpack/basex.cpp
View file

@ -34,7 +34,7 @@ void _mulnumx(PNUMBER* pa, PNUMBER b);
//
//----------------------------------------------------------------------------
void __inline mulnumx(PNUMBER* pa, PNUMBER b)
void /*__inline*/ mulnumx(PNUMBER* pa, PNUMBER b)
{
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)
@ -215,7 +215,7 @@ void _divnumx(PNUMBER* pa, PNUMBER b, int32_t precision);
//
//----------------------------------------------------------------------------
void __inline divnumx(PNUMBER* pa, PNUMBER b, int32_t precision)
void /*__inline*/ divnumx(PNUMBER* pa, PNUMBER b, int32_t precision)
{
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)

14
src/CalcManager/Ratpack/conv.cpp
View file

@ -131,7 +131,8 @@ void* zmalloc(size_t a)
void _dupnum(_In_ PNUMBER dest, _In_ const NUMBER* const src)
{
memcpy(dest, src, (int)(sizeof(NUMBER) + ((src)->cdigit) * (sizeof(MANTTYPE))));
memcpy(dest, src, (int)(sizeof(NUMBER) - sizeof(MANTTYPE*)));
memcpy(dest->mant, src->mant, (int)(src->cdigit) * sizeof(MANTTYPE));
}
//-----------------------------------------------------------------------------
@ -151,6 +152,7 @@ void _destroynum(_In_ PNUMBER pnum)
{
if (pnum != nullptr)
{
free(pnum->mant);
free(pnum);
}
}
@ -198,14 +200,18 @@ PNUMBER _createnum(_In_ uint32_t size)
uint32_t cbAlloc;
// sizeof( MANTTYPE ) is the size of a 'digit'
if (SUCCEEDED(Calc_ULongAdd(size, 1, &cbAlloc)) && SUCCEEDED(Calc_ULongMult(cbAlloc, sizeof(MANTTYPE), &cbAlloc))
&& SUCCEEDED(Calc_ULongAdd(cbAlloc, sizeof(NUMBER), &cbAlloc)))
if (SUCCEEDED(Calc_ULongMult(size, sizeof(MANTTYPE), &cbAlloc)))
{
pnumret = (PNUMBER)zmalloc(cbAlloc);
pnumret = (PNUMBER)zmalloc(sizeof(NUMBER));
if (pnumret == nullptr)
{
throw(CALC_E_OUTOFMEMORY);
}
pnumret->mant = (MANTTYPE*)zmalloc(cbAlloc);
if (pnumret->mant == nullptr)
{
throw(CALC_E_OUTOFMEMORY);
}
}
else
{

6
src/CalcManager/Ratpack/num.cpp
View file

@ -43,7 +43,7 @@ using namespace std;
void _addnum(PNUMBER* pa, PNUMBER b, uint32_t radix);
void __inline addnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void /*__inline*/ addnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
{
if (b->cdigit > 1 || b->mant[0] != 0)
@ -186,7 +186,7 @@ void _addnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void _mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix);
void __inline mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void /*__inline*/ mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
{
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)
@ -365,7 +365,7 @@ void remnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void _divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision);
void __inline divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision)
void /*__inline*/ divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision)
{
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)

850
src/CalcManager/Ratpack/ratconst.h
View file

@ -4,591 +4,345 @@
#pragma once
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_num_one = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_num_one[] = {
1,
};
inline const NUMBER init_num_one = { 1, 1, 0, p_init_num_one };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_num_two = { 1,
1,
0,
{
2,
} };
MANTTYPE p_init_num_two[] = {
2,
};
inline const NUMBER init_num_two = { 1, 1, 0, p_init_num_two };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_num_five = { 1,
1,
0,
{
5,
} };
MANTTYPE p_init_num_five[] = {
5,
};
inline const NUMBER init_num_five = { 1, 1, 0, p_init_num_five };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_num_six = { 1,
1,
0,
{
6,
} };
MANTTYPE p_init_num_six[] = {
6,
};
inline const NUMBER init_num_six = { 1, 1, 0, p_init_num_six };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_num_ten = { 1,
1,
0,
{
10,
} };
MANTTYPE p_init_num_ten[] = {
10,
};
inline const NUMBER init_num_ten = { 1, 1, 0, p_init_num_ten };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_smallest = { 1,
1,
0,
{
1,
} };
inline const NUMBER init_q_rat_smallest = { 1,
4,
0,
{
0,
190439170,
901055854,
10097,
} };
MANTTYPE p_init_p_rat_smallest[] = {
1,
};
inline const NUMBER init_p_rat_smallest = { 1, 1, 0, p_init_p_rat_smallest };
MANTTYPE p_init_q_rat_smallest[] = {
0,
190439170,
901055854,
10097,
};
inline const NUMBER init_q_rat_smallest = { 1, 4, 0, p_init_q_rat_smallest };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_negsmallest = { -1,
1,
0,
{
1,
} };
inline const NUMBER init_q_rat_negsmallest = { 1,
4,
0,
{
0,
190439170,
901055854,
10097,
} };
MANTTYPE p_init_p_rat_negsmallest[] = {
1,
};
inline const NUMBER init_p_rat_negsmallest = { -1, 1, 0, p_init_p_rat_negsmallest };
MANTTYPE p_init_q_rat_negsmallest[] = {
0,
190439170,
901055854,
10097,
};
inline const NUMBER init_q_rat_negsmallest = { 1, 4, 0, p_init_q_rat_negsmallest };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_pt_eight_five = { 1,
1,
0,
{
85,
} };
inline const NUMBER init_q_pt_eight_five = { 1,
1,
0,
{
100,
} };
MANTTYPE p_init_p_pt_eight_five[] = {
85,
};
inline const NUMBER init_p_pt_eight_five = { 1, 1, 0, p_init_p_pt_eight_five };
MANTTYPE p_init_q_pt_eight_five[] = {
100,
};
inline const NUMBER init_q_pt_eight_five = { 1, 1, 0, p_init_q_pt_eight_five };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_six = { 1,
1,
0,
{
6,
} };
inline const NUMBER init_q_rat_six = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_six[] = {
6,
};
inline const NUMBER init_p_rat_six = { 1, 1, 0, p_init_p_rat_six };
MANTTYPE p_init_q_rat_six[] = {
1,
};
inline const NUMBER init_q_rat_six = { 1, 1, 0, p_init_q_rat_six };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_two = { 1,
1,
0,
{
2,
} };
inline const NUMBER init_q_rat_two = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_two[] = {
2,
};
inline const NUMBER init_p_rat_two = { 1, 1, 0, p_init_p_rat_two };
MANTTYPE p_init_q_rat_two[] = {
1,
};
inline const NUMBER init_q_rat_two = { 1, 1, 0, p_init_q_rat_two };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_zero = { 1,
1,
0,
{
0,
} };
inline const NUMBER init_q_rat_zero = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_zero[] = {
0,
};
inline const NUMBER init_p_rat_zero = { 1, 1, 0, p_init_p_rat_zero };
MANTTYPE p_init_q_rat_zero[] = {
1,
};
inline const NUMBER init_q_rat_zero = { 1, 1, 0, p_init_q_rat_zero };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_one = { 1,
1,
0,
{
1,
} };
inline const NUMBER init_q_rat_one = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_one[] = {
1,
};
inline const NUMBER init_p_rat_one = { 1, 1, 0, p_init_p_rat_one };
MANTTYPE p_init_q_rat_one[] = {
1,
};
inline const NUMBER init_q_rat_one = { 1, 1, 0, p_init_q_rat_one };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_neg_one = { -1,
1,
0,
{
1,
} };
inline const NUMBER init_q_rat_neg_one = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_neg_one[] = {
1,
};
inline const NUMBER init_p_rat_neg_one = { -1, 1, 0, p_init_p_rat_neg_one };
MANTTYPE p_init_q_rat_neg_one[] = {
1,
};
inline const NUMBER init_q_rat_neg_one = { 1, 1, 0, p_init_q_rat_neg_one };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_half = { 1,
1,
0,
{
1,
} };
inline const NUMBER init_q_rat_half = { 1,
1,
0,
{
2,
} };
MANTTYPE p_init_p_rat_half[] = {
1,
};
inline const NUMBER init_p_rat_half = { 1, 1, 0, p_init_p_rat_half };
MANTTYPE p_init_q_rat_half[] = {
2,
};
inline const NUMBER init_q_rat_half = { 1, 1, 0, p_init_q_rat_half };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_ten = { 1,
1,
0,
{
10,
} };
inline const NUMBER init_q_rat_ten = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_ten[] = {
10,
};
inline const NUMBER init_p_rat_ten = { 1, 1, 0, p_init_p_rat_ten };
MANTTYPE p_init_q_rat_ten[] = {
1,
};
inline const NUMBER init_q_rat_ten = { 1, 1, 0, p_init_q_rat_ten };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_pi = { 1,
6,
0,
{
125527896,
283898350,
1960493936,
1672850762,
1288168272,
8,
} };
inline const NUMBER init_q_pi = { 1,
6,
0,
{
1288380402,
1120116153,
1860424692,
1944118326,
1583591604,
2,
} };
MANTTYPE p_init_p_pi[] = {
125527896, 283898350, 1960493936, 1672850762, 1288168272, 8,
};
inline const NUMBER init_p_pi = { 1, 6, 0, p_init_p_pi };
MANTTYPE p_init_q_pi[] = {
1288380402, 1120116153, 1860424692, 1944118326, 1583591604, 2,
};
inline const NUMBER init_q_pi = { 1, 6, 0, p_init_q_pi };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_two_pi = { 1,
6,
0,
{
251055792,
567796700,
1773504224,
1198217877,
428852897,
17,
} };
inline const NUMBER init_q_two_pi = { 1,
6,
0,
{
1288380402,
1120116153,
1860424692,
1944118326,
1583591604,
2,
} };
MANTTYPE p_init_p_two_pi[] = {
251055792, 567796700, 1773504224, 1198217877, 428852897, 17,
};
inline const NUMBER init_p_two_pi = { 1, 6, 0, p_init_p_two_pi };
MANTTYPE p_init_q_two_pi[] = {
1288380402, 1120116153, 1860424692, 1944118326, 1583591604, 2,
};
inline const NUMBER init_q_two_pi = { 1, 6, 0, p_init_q_two_pi };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_pi_over_two = { 1,
6,
0,
{
125527896,
283898350,
1960493936,
1672850762,
1288168272,
8,
} };
inline const NUMBER init_q_pi_over_two = { 1,
6,
0,
{
429277156,
92748659,
1573365737,
1740753005,
1019699561,
5,
} };
MANTTYPE p_init_p_pi_over_two[] = {
125527896, 283898350, 1960493936, 1672850762, 1288168272, 8,
};
inline const NUMBER init_p_pi_over_two = { 1, 6, 0, p_init_p_pi_over_two };
MANTTYPE p_init_q_pi_over_two[] = {
429277156, 92748659, 1573365737, 1740753005, 1019699561, 5,
};
inline const NUMBER init_q_pi_over_two = { 1, 6, 0, p_init_q_pi_over_two };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_one_pt_five_pi = { 1,
6,
0,
{
1241201312,
270061909,
1051574664,
1924965045,
1340320627,
70,
} };
inline const NUMBER init_q_one_pt_five_pi = { 1,
6,
0,
{
1579671539,
1837970263,
1067644340,
523549916,
2119366659,
14,
} };
MANTTYPE p_init_p_one_pt_five_pi[] = {
1241201312, 270061909, 1051574664, 1924965045, 1340320627, 70,
};
inline const NUMBER init_p_one_pt_five_pi = { 1, 6, 0, p_init_p_one_pt_five_pi };
MANTTYPE p_init_q_one_pt_five_pi[] = {
1579671539, 1837970263, 1067644340, 523549916, 2119366659, 14,
};
inline const NUMBER init_q_one_pt_five_pi = { 1, 6, 0, p_init_q_one_pt_five_pi };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_e_to_one_half = { 1,
6,
0,
{
256945612,
216219427,
223516738,
477442596,
581063757,
23,
} };
inline const NUMBER init_q_e_to_one_half = { 1,
6,
0,
{
1536828363,
698484484,
1127331835,
224219346,
245499408,
14,
} };
MANTTYPE p_init_p_e_to_one_half[] = {
256945612, 216219427, 223516738, 477442596, 581063757, 23,
};
inline const NUMBER init_p_e_to_one_half = { 1, 6, 0, p_init_p_e_to_one_half };
MANTTYPE p_init_q_e_to_one_half[] = {
1536828363, 698484484, 1127331835, 224219346, 245499408, 14,
};
inline const NUMBER init_q_e_to_one_half = { 1, 6, 0, p_init_q_e_to_one_half };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_exp = { 1,
6,
0,
{
943665199,
1606559160,
1094967530,
1759391384,
1671799163,
1123581,
} };
inline const NUMBER init_q_rat_exp = { 1,
6,
0,
{
879242208,
2022880100,
617392930,
1374929092,
1367479163,
413342,
} };
MANTTYPE p_init_p_rat_exp[] = {
943665199, 1606559160, 1094967530, 1759391384, 1671799163, 1123581,
};
inline const NUMBER init_p_rat_exp = { 1, 6, 0, p_init_p_rat_exp };
MANTTYPE p_init_q_rat_exp[] = {
879242208, 2022880100, 617392930, 1374929092, 1367479163, 413342,
};
inline const NUMBER init_q_rat_exp = { 1, 6, 0, p_init_q_rat_exp };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_ln_ten = { 1,
6,
0,
{
2086268922,
165794492,
1416063951,
1851428830,
1893239400,
65366841,
} };
inline const NUMBER init_q_ln_ten = { 1,
6,
0,
{
26790652,
564532679,
783998273,
216030448,
1564709968,
28388458,
} };
MANTTYPE p_init_p_ln_ten[] = {
2086268922, 165794492, 1416063951, 1851428830, 1893239400, 65366841,
};
inline const NUMBER init_p_ln_ten = { 1, 6, 0, p_init_p_ln_ten };
MANTTYPE p_init_q_ln_ten[] = {
26790652, 564532679, 783998273, 216030448, 1564709968, 28388458,
};
inline const NUMBER init_q_ln_ten = { 1, 6, 0, p_init_q_ln_ten };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_ln_two = { 1,
6,
0,
{
1789230241,
1057927868,
715399197,
908801241,
1411265331,
3,
} };
inline const NUMBER init_q_ln_two = { 1,
6,
0,
{
1559869847,
1930657510,
1228561531,
219003871,
593099283,
5,
} };
MANTTYPE p_init_p_ln_two[] = {
1789230241, 1057927868, 715399197, 908801241, 1411265331, 3,
};
inline const NUMBER init_p_ln_two = { 1, 6, 0, p_init_p_ln_two };
MANTTYPE p_init_q_ln_two[] = {
1559869847, 1930657510, 1228561531, 219003871, 593099283, 5,
};
inline const NUMBER init_q_ln_two = { 1, 6, 0, p_init_q_ln_two };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rad_to_deg = { 1,
6,
0,
{
2127722024,
1904928383,
2016479213,
2048947859,
1578647346,
492,
} };
inline const NUMBER init_q_rad_to_deg = { 1,
6,
0,
{
125527896,
283898350,
1960493936,
1672850762,
1288168272,
8,
} };
MANTTYPE p_init_p_rad_to_deg[] = {
2127722024, 1904928383, 2016479213, 2048947859, 1578647346, 492,
};
inline const NUMBER init_p_rad_to_deg = { 1, 6, 0, p_init_p_rad_to_deg };
MANTTYPE p_init_q_rad_to_deg[] = {
125527896, 283898350, 1960493936, 1672850762, 1288168272, 8,
};
inline const NUMBER init_q_rad_to_deg = { 1, 6, 0, p_init_q_rad_to_deg };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rad_to_grad = { 1,
6,
0,
{
2125526288,
684931327,
570267400,
129125085,
1038224725,
547,
} };
inline const NUMBER init_q_rad_to_grad = { 1,
6,
0,
{
125527896,
283898350,
1960493936,
1672850762,
1288168272,
8,
} };
MANTTYPE p_init_p_rad_to_grad[] = {
2125526288, 684931327, 570267400, 129125085, 1038224725, 547,
};
inline const NUMBER init_p_rad_to_grad = { 1, 6, 0, p_init_p_rad_to_grad };
MANTTYPE p_init_q_rad_to_grad[] = {
125527896, 283898350, 1960493936, 1672850762, 1288168272, 8,
};
inline const NUMBER init_q_rad_to_grad = { 1, 6, 0, p_init_q_rad_to_grad };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_qword = { 1,
3,
0,
{
2147483647,
2147483647,
3,
} };
inline const NUMBER init_q_rat_qword = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_qword[] = {
2147483647,
2147483647,
3,
};
inline const NUMBER init_p_rat_qword = { 1, 3, 0, p_init_p_rat_qword };
MANTTYPE p_init_q_rat_qword[] = {
1,
};
inline const NUMBER init_q_rat_qword = { 1, 1, 0, p_init_q_rat_qword };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_dword = { 1,
2,
0,
{
2147483647,
1,
} };
inline const NUMBER init_q_rat_dword = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_dword[] = {
2147483647,
1,
};
inline const NUMBER init_p_rat_dword = { 1, 2, 0, p_init_p_rat_dword };
MANTTYPE p_init_q_rat_dword[] = {
1,
};
inline const NUMBER init_q_rat_dword = { 1, 1, 0, p_init_q_rat_dword };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_max_i32 = { 1,
1,
0,
{
2147483647,
} };
inline const NUMBER init_q_rat_max_i32 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_max_i32[] = {
2147483647,
};
inline const NUMBER init_p_rat_max_i32 = { 1, 1, 0, p_init_p_rat_max_i32 };
MANTTYPE p_init_q_rat_max_i32[] = {
1,
};
inline const NUMBER init_q_rat_max_i32 = { 1, 1, 0, p_init_q_rat_max_i32 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_min_i32 = { -1,
2,
0,
{
0,
1,
} };
inline const NUMBER init_q_rat_min_i32 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_min_i32[] = {
0,
1,
};
inline const NUMBER init_p_rat_min_i32 = { -1, 2, 0, p_init_p_rat_min_i32 };
MANTTYPE p_init_q_rat_min_i32[] = {
1,
};
inline const NUMBER init_q_rat_min_i32 = { 1, 1, 0, p_init_q_rat_min_i32 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_word = { 1,
1,
0,
{
65535,
} };
inline const NUMBER init_q_rat_word = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_word[] = {
65535,
};
inline const NUMBER init_p_rat_word = { 1, 1, 0, p_init_p_rat_word };
MANTTYPE p_init_q_rat_word[] = {
1,
};
inline const NUMBER init_q_rat_word = { 1, 1, 0, p_init_q_rat_word };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_byte = { 1,
1,
0,
{
255,
} };
inline const NUMBER init_q_rat_byte = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_byte[] = {
255,
};
inline const NUMBER init_p_rat_byte = { 1, 1, 0, p_init_p_rat_byte };
MANTTYPE p_init_q_rat_byte[] = {
1,
};
inline const NUMBER init_q_rat_byte = { 1, 1, 0, p_init_q_rat_byte };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_400 = { 1,
1,
0,
{
400,
} };
inline const NUMBER init_q_rat_400 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_400[] = {
400,
};
inline const NUMBER init_p_rat_400 = { 1, 1, 0, p_init_p_rat_400 };
MANTTYPE p_init_q_rat_400[] = {
1,
};
inline const NUMBER init_q_rat_400 = { 1, 1, 0, p_init_q_rat_400 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_360 = { 1,
1,
0,
{
360,
} };
inline const NUMBER init_q_rat_360 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_360[] = {
360,
};
inline const NUMBER init_p_rat_360 = { 1, 1, 0, p_init_p_rat_360 };
MANTTYPE p_init_q_rat_360[] = {
1,
};
inline const NUMBER init_q_rat_360 = { 1, 1, 0, p_init_q_rat_360 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_200 = { 1,
1,
0,
{
200,
} };
inline const NUMBER init_q_rat_200 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_200[] = {
200,
};
inline const NUMBER init_p_rat_200 = { 1, 1, 0, p_init_p_rat_200 };
MANTTYPE p_init_q_rat_200[] = {
1,
};
inline const NUMBER init_q_rat_200 = { 1, 1, 0, p_init_q_rat_200 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_180 = { 1,
1,
0,
{
180,
} };
inline const NUMBER init_q_rat_180 = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_180[] = {
180,
};
inline const NUMBER init_p_rat_180 = { 1, 1, 0, p_init_p_rat_180 };
MANTTYPE p_init_q_rat_180[] = {
1,
};
inline const NUMBER init_q_rat_180 = { 1, 1, 0, p_init_q_rat_180 };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_max_exp = { 1,
1,
0,
{
100000,
} };
inline const NUMBER init_q_rat_max_exp = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_max_exp[] = {
100000,
};
inline const NUMBER init_p_rat_max_exp = { 1, 1, 0, p_init_p_rat_max_exp };
MANTTYPE p_init_q_rat_max_exp[] = {
1,
};
inline const NUMBER init_q_rat_max_exp = { 1, 1, 0, p_init_q_rat_max_exp };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_min_exp = { -1,
1,
0,
{
100000,
} };
inline const NUMBER init_q_rat_min_exp = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_min_exp[] = {
100000,
};
inline const NUMBER init_p_rat_min_exp = { -1, 1, 0, p_init_p_rat_min_exp };
MANTTYPE p_init_q_rat_min_exp[] = {
1,
};
inline const NUMBER init_q_rat_min_exp = { 1, 1, 0, p_init_q_rat_min_exp };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_max_fact = { 1,
1,
0,
{
3249,
} };
inline const NUMBER init_q_rat_max_fact = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_max_fact[] = {
3249,
};
inline const NUMBER init_p_rat_max_fact = { 1, 1, 0, p_init_p_rat_max_fact };
MANTTYPE p_init_q_rat_max_fact[] = {
1,
};
inline const NUMBER init_q_rat_max_fact = { 1, 1, 0, p_init_q_rat_max_fact };
// Autogenerated by _dumprawrat in support.cpp
inline const NUMBER init_p_rat_min_fact = { -1,
1,
0,
{
1000,
} };
inline const NUMBER init_q_rat_min_fact = { 1,
1,
0,
{
1,
} };
MANTTYPE p_init_p_rat_min_fact[] = {
1000,
};
inline const NUMBER init_p_rat_min_fact = { -1, 1, 0, p_init_p_rat_min_fact };
MANTTYPE p_init_q_rat_min_fact[] = {
1,
};
inline const NUMBER init_q_rat_min_fact = { 1, 1, 0, p_init_q_rat_min_fact };

2
src/CalcManager/Ratpack/ratpak.h
View file

@ -66,7 +66,7 @@ typedef struct _number
// radix being used.
int32_t exp; // The offset of digits from the radix point
// (decimal point in radix 10)
MANTTYPE mant[];
MANTTYPE* mant;
// This is actually allocated as a continuation of the
// NUMBER structure.
} NUMBER, *PNUMBER, **PPNUMBER;

7
src/CalcManager/Ratpack/trans.cpp
View file

@ -120,6 +120,8 @@ void sinanglerat(_Inout_ PRAT* pa, ANGLE_TYPE angletype, uint32_t radix, int32_t
divrat(pa, rat_200, precision);
mulrat(pa, pi, precision);
break;
case ANGLE_RAD:
break;
}
_sinrat(pa, precision);
}
@ -223,6 +225,8 @@ void cosanglerat(_Inout_ PRAT* pa, ANGLE_TYPE angletype, uint32_t radix, int32_t
divrat(pa, rat_200, precision);
mulrat(pa, pi, precision);
break;
case ANGLE_RAD:
break;
}
_cosrat(pa, radix, precision);
}
@ -285,6 +289,9 @@ void tananglerat(_Inout_ PRAT* pa, ANGLE_TYPE angletype, uint32_t radix, int32_t
divrat(pa, rat_200, precision);
mulrat(pa, pi, precision);
break;
case ANGLE_RAD:
break;
}
_tanrat(pa, radix, precision);
}

1105
src/CalcManager/UnitConverter.cpp
View file

File diff suppressed because it is too large Load diff

318
src/CalcManager/UnitConverter.h
View file

@ -1,318 +0,0 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#include <vector>
#include <unordered_map>
#include <ppltasks.h>
#include <sal.h> // for SAL
#include <memory> // for std::shared_ptr
namespace UnitConversionManager
{
enum class Command;
struct Unit
{
Unit()
{
}
Unit(int id, std::wstring name, std::wstring abbreviation, bool isConversionSource, bool isConversionTarget, bool isWhimsical)
: id(id)
, name(name)
, accessibleName(name)
, abbreviation(abbreviation)
, isConversionSource(isConversionSource)
, isConversionTarget(isConversionTarget)
, isWhimsical(isWhimsical)
{
}
Unit(
int id,
std::wstring currencyName,
std::wstring countryName,
std::wstring abbreviation,
bool isRtlLanguage,
bool isConversionSource,
bool isConversionTarget)
: id(id)
, abbreviation(abbreviation)
, isConversionSource(isConversionSource)
, isConversionTarget(isConversionTarget)
, isWhimsical(false)
{
std::wstring nameValue1 = isRtlLanguage ? currencyName : countryName;
std::wstring nameValue2 = isRtlLanguage ? countryName : currencyName;
name = nameValue1 + L" - " + nameValue2;
accessibleName = nameValue1 + L" " + nameValue2;
}
virtual ~Unit()
{
}
int id;
std::wstring name;
std::wstring accessibleName;
std::wstring abbreviation;
bool isConversionSource;
bool isConversionTarget;
bool isWhimsical;
bool operator!=(const Unit& that) const
{
return that.id != id;
}
bool operator==(const Unit& that) const
{
return that.id == id;
}
};
// The EMPTY_UNIT acts as a 'null-struct' so that
// Unit pointers can safely be dereferenced without
// null checks.
//
// unitId, name, abbreviation, isConversionSource, isConversionTarget, isWhimsical
inline const Unit EMPTY_UNIT = Unit{ -1, L"", L"", true, true, false };
struct Category
{
Category()
{
}
Category(int id, std::wstring name, bool supportsNegative)
: id(id)
, name(name)
, supportsNegative(supportsNegative)
{
}
int id;
std::wstring name;
bool supportsNegative;
bool operator!=(const Category& that) const
{
return that.id != id;
}
bool operator==(const Category& that) const
{
return that.id == id;
}
};
class UnitHash
{
public:
size_t operator()(const Unit& x) const
{
return x.id;
}
};
class CategoryHash
{
public:
size_t operator()(const Category& x) const
{
return x.id;
}
};
struct SuggestedValueIntermediate
{
double magnitude;
double value;
Unit type;
};
struct ConversionData
{
ConversionData()
{
}
ConversionData(double ratio, double offset, bool offsetFirst)
: ratio(ratio)
, offset(offset)
, offsetFirst(offsetFirst)
{
}
virtual ~ConversionData()
{
}
double ratio;
double offset;
bool offsetFirst;
};
struct CurrencyStaticData
{
std::wstring countryCode;
std::wstring countryName;
std::wstring currencyCode;
std::wstring currencyName;
std::wstring currencySymbol;
};
struct CurrencyRatio
{
double ratio;
std::wstring sourceCurrencyCode;
std::wstring targetCurrencyCode;
};
typedef std::tuple<std::vector<UnitConversionManager::Unit>, UnitConversionManager::Unit, UnitConversionManager::Unit> CategorySelectionInitializer;
typedef std::unordered_map<
UnitConversionManager::Unit,
std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>,
UnitConversionManager::UnitHash>
UnitToUnitToConversionDataMap;
typedef std::unordered_map<UnitConversionManager::Category, std::vector<UnitConversionManager::Unit>, UnitConversionManager::CategoryHash>
CategoryToUnitVectorMap;
class IViewModelCurrencyCallback
{
public:
virtual ~IViewModelCurrencyCallback(){};
virtual void CurrencyDataLoadFinished(bool didLoad) = 0;
virtual void CurrencySymbolsCallback(_In_ const std::wstring& fromSymbol, _In_ const std::wstring& toSymbol) = 0;
virtual void CurrencyRatiosCallback(_In_ const std::wstring& ratioEquality, _In_ const std::wstring& accRatioEquality) = 0;
virtual void CurrencyTimestampCallback(_In_ const std::wstring& timestamp, bool isWeekOldData) = 0;
virtual void NetworkBehaviorChanged(_In_ int newBehavior) = 0;
};
class IConverterDataLoader
{
public:
virtual ~IConverterDataLoader(){};
virtual void LoadData() = 0; // prepare data if necessary before calling other functions
virtual std::vector<Category> LoadOrderedCategories() = 0;
virtual std::vector<Unit> LoadOrderedUnits(const Category& c) = 0;
virtual std::unordered_map<Unit, ConversionData, UnitHash> LoadOrderedRatios(const Unit& u) = 0;
virtual bool SupportsCategory(const Category& target) = 0;
};
class ICurrencyConverterDataLoader
{
public:
virtual void SetViewModelCallback(const std::shared_ptr<UnitConversionManager::IViewModelCurrencyCallback>& callback) = 0;
virtual std::pair<std::wstring, std::wstring>
GetCurrencySymbols(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) = 0;
virtual std::pair<std::wstring, std::wstring>
GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) = 0;
virtual std::wstring GetCurrencyTimestamp() = 0;
virtual concurrency::task<bool> TryLoadDataFromCacheAsync() = 0;
virtual concurrency::task<bool> TryLoadDataFromWebAsync() = 0;
virtual concurrency::task<bool> TryLoadDataFromWebOverrideAsync() = 0;
};
class IUnitConverterVMCallback
{
public:
virtual ~IUnitConverterVMCallback(){};
virtual void DisplayCallback(const std::wstring& from, const std::wstring& to) = 0;
virtual void SuggestedValueCallback(const std::vector<std::tuple<std::wstring, Unit>>& suggestedValues) = 0;
virtual void MaxDigitsReached() = 0;
};
class IUnitConverter
{
public:
virtual ~IUnitConverter()
{
}
virtual void Initialize() = 0; // Use to initialize first time, use deserialize instead to rehydrate
virtual std::vector<Category> GetCategories() = 0;
virtual CategorySelectionInitializer SetCurrentCategory(const Category& input) = 0;
virtual Category GetCurrentCategory() = 0;
virtual void SetCurrentUnitTypes(const Unit& fromType, const Unit& toType) = 0;
virtual void SwitchActive(const std::wstring& newValue) = 0;
virtual std::wstring Serialize() = 0;
virtual void DeSerialize(const std::wstring& serializedData) = 0;
virtual std::wstring SaveUserPreferences() = 0;
virtual void RestoreUserPreferences(_In_ const std::wstring& userPreferences) = 0;
virtual void SendCommand(Command command) = 0;
virtual void SetViewModelCallback(_In_ const std::shared_ptr<IUnitConverterVMCallback>& newCallback) = 0;
virtual void SetViewModelCurrencyCallback(_In_ const std::shared_ptr<IViewModelCurrencyCallback>& newCallback) = 0;
virtual concurrency::task<std::pair<bool, std::wstring>> RefreshCurrencyRatios() = 0;
virtual void Calculate() = 0;
virtual void ResetCategoriesAndRatios() = 0;
};
class UnitConverter : public IUnitConverter, public std::enable_shared_from_this<UnitConverter>
{
public:
UnitConverter(_In_ const std::shared_ptr<IConverterDataLoader>& dataLoader);
UnitConverter(_In_ const std::shared_ptr<IConverterDataLoader>& dataLoader, _In_ const std::shared_ptr<IConverterDataLoader>& currencyDataLoader);
// IUnitConverter
void Initialize() override;
std::vector<Category> GetCategories() override;
CategorySelectionInitializer SetCurrentCategory(const Category& input) override;
Category GetCurrentCategory() override;
void SetCurrentUnitTypes(const Unit& fromType, const Unit& toType) override;
void SwitchActive(const std::wstring& newValue) override;
std::wstring Serialize() override;
void DeSerialize(const std::wstring& serializedData) override;
std::wstring SaveUserPreferences() override;
void RestoreUserPreferences(const std::wstring& userPreference) override;
void SendCommand(Command command) override;
void SetViewModelCallback(_In_ const std::shared_ptr<IUnitConverterVMCallback>& newCallback) override;
void SetViewModelCurrencyCallback(_In_ const std::shared_ptr<IViewModelCurrencyCallback>& newCallback) override;
concurrency::task<std::pair<bool, std::wstring>> RefreshCurrencyRatios() override;
void Calculate() override;
void ResetCategoriesAndRatios() override;
// IUnitConverter
static std::vector<std::wstring> StringToVector(const std::wstring& w, const wchar_t* delimiter, bool addRemainder = false);
static std::wstring Quote(const std::wstring& s);
static std::wstring Unquote(const std::wstring& s);
private:
bool CheckLoad();
double Convert(double value, ConversionData conversionData);
std::vector<std::tuple<std::wstring, Unit>> CalculateSuggested();
void ClearValues();
void TrimString(std::wstring& input);
void InitializeSelectedUnits();
std::wstring RoundSignificant(double num, int numSignificant);
Category StringToCategory(const std::wstring& w);
std::wstring CategoryToString(const Category& c, const wchar_t* delimiter);
std::wstring UnitToString(const Unit& u, const wchar_t* delimiter);
Unit StringToUnit(const std::wstring& w);
ConversionData StringToConversionData(const std::wstring& w);
std::wstring ConversionDataToString(ConversionData d, const wchar_t* delimiter);
void UpdateCurrencySymbols();
void UpdateViewModel();
bool AnyUnitIsEmpty();
std::shared_ptr<IConverterDataLoader> GetDataLoaderForCategory(const Category& category);
std::shared_ptr<ICurrencyConverterDataLoader> GetCurrencyConverterDataLoader();
private:
std::shared_ptr<IConverterDataLoader> m_dataLoader;
std::shared_ptr<IConverterDataLoader> m_currencyDataLoader;
std::shared_ptr<IUnitConverterVMCallback> m_vmCallback;
std::shared_ptr<IViewModelCurrencyCallback> m_vmCurrencyCallback;
std::vector<Category> m_categories;
CategoryToUnitVectorMap m_categoryToUnits;
UnitToUnitToConversionDataMap m_ratioMap;
Category m_currentCategory;
Unit m_fromType;
Unit m_toType;
std::wstring m_currentDisplay;
std::wstring m_returnDisplay;
bool m_currentHasDecimal;
bool m_returnHasDecimal;
bool m_switchedActive;
};
}

11
src/CalcManager/build.sh Normal file
View file

@ -0,0 +1,11 @@
emcc \
-std=c++17 \
-s WASM=1 \
-s LEGALIZE_JS_FFI=0 \
-s RESERVED_FUNCTION_POINTERS=64 \
-s ALLOW_MEMORY_GROWTH=1 \
-s BINARYEN=1 \
-s SIDE_MODULE=1 \
-o CalcManager.wasm \
-s EXPORT_ALL=1 \
CEngine/*.cpp RatPack/*.cpp *.cpp -I.

2
src/CalcManager/compat.h
View file

@ -1,6 +1,6 @@
#pragma once
#if defined(__WEBASSEMBLY__)
#if defined(__EMSCRIPTEN__)
#define HRESULT long
#define _In_opt_

0
src/CalcManager/output.txt Normal file
View file

7
src/CalcManager/pch.h
View file

@ -11,12 +11,15 @@
#include <algorithm>
#include <array>
#include <cassert>
#include <intsafe.h>
#include <list>
#include <ppltasks.h>
#include <regex>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
#if !defined(__EMSCRIPTEN__)
#include <ppltasks.h>
#include <winerror.h>
#include <intsafe.h>
#endif

BIN
src/Calculator.Shared/Assets/CalcMDL2.woff Normal file
View file

Binary file not shown.

263
src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs
View file

@ -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);
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);
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);
public static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback;
public static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback;
public static SetPrimaryDisplayCallbackFunc _setPrimaryDisplayCallback = SetPrimaryDisplayCallback;
public static SetIsInErrorCallbackFunc _setIsInErrorCallback = SetIsInErrorCallback;
public static SetParenthesisNumberCallbackFunc _setParenthesisNumberCallback = SetParenthesisNumberCallback;
public static MaxDigitsReachedCallbackFunc _maxDigitsReachedCallback = MaxDigitsReachedCallback;
public static MemoryItemChangedCallbackFunc _memoryItemChangedCallback = MemoryItemChangedCallback;
public static OnHistoryItemAddedCallbackFunc _onHistoryItemAddedCallback = OnHistoryItemAddedCallback;
public static OnNoRightParenAddedCallbackFunc _onNoRightParenAddedCallback = OnNoRightParenAddedCallback;
public static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback = SetExpressionDisplayCallback;
public 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;
}
}
}
}

56
src/Calculator.Shared/CalcManager/CalculatorManager.cs
View file

@ -100,33 +100,59 @@ 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 = Uno.Foundation.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),
GetCEngineString = Marshal.GetFunctionPointerForDelegate(_getCEngineStringCallback),
GetCEngineString = Marshal.GetFunctionPointerForDelegate(NativeDispatch._getCEngineStringCallback),
ResourceState = GCHandle.ToIntPtr(_resourceProviderHandle),
BinaryOperatorReceived = Marshal.GetFunctionPointerForDelegate(_binaryOperatorReceivedCallback),
SetPrimaryDisplay = Marshal.GetFunctionPointerForDelegate(_setPrimaryDisplayCallback),
SetIsInError = Marshal.GetFunctionPointerForDelegate(_setIsInErrorCallback),
SetParenthesisNumber = Marshal.GetFunctionPointerForDelegate(_setParenthesisNumberCallback),
MaxDigitsReached = Marshal.GetFunctionPointerForDelegate(_maxDigitsReachedCallback),
MemoryItemChanged = Marshal.GetFunctionPointerForDelegate(_memoryItemChangedCallback),
OnHistoryItemAdded = Marshal.GetFunctionPointerForDelegate(_onHistoryItemAddedCallback),
OnNoRightParenAdded = Marshal.GetFunctionPointerForDelegate(_onNoRightParenAddedCallback),
SetExpressionDisplay = Marshal.GetFunctionPointerForDelegate(_setExpressionDisplayCallback),
SetMemorizedNumbers = Marshal.GetFunctionPointerForDelegate(_setMemorizedNumbersCallback),
BinaryOperatorReceived = Marshal.GetFunctionPointerForDelegate(NativeDispatch._binaryOperatorReceivedCallback),
SetPrimaryDisplay = Marshal.GetFunctionPointerForDelegate(NativeDispatch._setPrimaryDisplayCallback),
SetIsInError = Marshal.GetFunctionPointerForDelegate(NativeDispatch._setIsInErrorCallback),
SetParenthesisNumber = Marshal.GetFunctionPointerForDelegate(NativeDispatch._setParenthesisNumberCallback),
MaxDigitsReached = Marshal.GetFunctionPointerForDelegate(NativeDispatch._maxDigitsReachedCallback),
MemoryItemChanged = Marshal.GetFunctionPointerForDelegate(NativeDispatch._memoryItemChangedCallback),
OnHistoryItemAdded = Marshal.GetFunctionPointerForDelegate(NativeDispatch._onHistoryItemAddedCallback),
OnNoRightParenAdded = Marshal.GetFunctionPointerForDelegate(NativeDispatch._onNoRightParenAddedCallback),
SetExpressionDisplay = Marshal.GetFunctionPointerForDelegate(NativeDispatch._setExpressionDisplayCallback),
SetMemorizedNumbers = Marshal.GetFunctionPointerForDelegate(NativeDispatch._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 +162,7 @@ namespace CalculationManager
{
Debug.WriteLine($"CalculatorManager.SendCommand({command})");
CalculatorManager_SendCommand(_nativeManager, command);
NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command);
}
public List<char> SerializeCommands() => throw new NotImplementedException();

1
src/Calculator.Shared/Calculator.Shared.projitems
View file

@ -225,6 +225,7 @@
</ItemGroup>
<ItemGroup>
<Content Include="$(MSBuildThisFileDirectory)Assets\CalcMDL2.ttf" />
<Content Include="$(MSBuildThisFileDirectory)Assets\CalcMDL2.woff" />
<Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorAppList.targetsize-96.png" />
<Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorLargeTile.contrast-white_scale-400.png" />
<Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorMedTile.contrast-white_scale-400.png" />

88
src/Calculator.Shared/Styles.xaml
View file

@ -1,10 +1,14 @@
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:xamarin="http://uno.ui/xamarin"
xmlns:win="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:Controls="using:CalculatorApp.Controls"
xmlns:common="using:CalculatorApp.Common"
xmlns:converters="using:CalculatorApp.Converters"
xmlns:local="using:CalculatorApp">
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="using:CalculatorApp"
mc:Ignorable="xamarin">
<ResourceDictionary.MergedDictionaries>
<!--
@ -215,12 +219,18 @@
<SolidColorBrush x:Key="AppControlPageTextBaseMediumHighBrush"
Color="{StaticResource SystemBaseMediumHighColor}" />
<RevealBackgroundBrush x:Key="AppControlHoverButtonFaceBrush"
<win:RevealBackgroundBrush x:Key="AppControlHoverButtonFaceBrush"
Color="#18FFFFFF" />
<RevealBackgroundBrush x:Key="AppControlPressedButtonFaceBrush"
<xamarin:SolidColorBrush x:Key="AppControlHoverButtonFaceBrush"
Color="{ThemeResource SystemColorHighlightColor}" />
<win:RevealBackgroundBrush x:Key="AppControlPressedButtonFaceBrush"
Color="#30FFFFFF" />
<xamarin:SolidColorBrush x:Key="AppControlPressedButtonFaceBrush"
Color="{ThemeResource SystemColorButtonFaceColor}" />
<SolidColorBrush x:Key="AppControlTransparentAccentColorBrush"
Color="{ThemeResource SystemAccentColor}" />
@ -230,31 +240,40 @@
<SolidColorBrush x:Key="AppControlPageTextRedColorBrush"
Color="Red" />
<RevealBorderBrush x:Key="AppControlForegroundTransparentRevealBorderBrush"
<win:RevealBorderBrush x:Key="AppControlForegroundTransparentRevealBorderBrush"
FallbackColor="Transparent"
TargetTheme="Dark"
Color="Transparent" />
<RevealBackgroundBrush x:Key="AppControlHighlightAltListAccentHighRevealBackgroundBrush"
TargetTheme="Dark"
/>
<!--
UNO TODO
Color="{ThemeResource SystemAccentColorDark3}"
FallbackColor="{ThemeResource SystemAccentColorDark3}"-->
<xamarin:SolidColorBrush x:Key="AppControlForegroundTransparentRevealBorderBrush"
Color="Transparent" />
<AcrylicBrush x:Key="AppChromeAcrylicHostBackdropMediumLowBrush"
<win:RevealBackgroundBrush x:Key="AppControlHighlightAltListAccentHighRevealBackgroundBrush"
TargetTheme="Dark"
Color="{ThemeResource SystemAccentColorDark3}"
FallbackColor="{ThemeResource SystemAccentColorDark3}"
/>
<xamarin:SolidColorBrush x:Key="AppControlHighlightAltListAccentHighRevealBackgroundBrush"
Color="{ThemeResource SystemColorHighlightTextColor}" />
<win:AcrylicBrush x:Key="AppChromeAcrylicHostBackdropMediumLowBrush"
BackgroundSource="HostBackdrop"
FallbackColor="{ThemeResource SystemChromeMediumColor}"
TintColor="{ThemeResource SystemChromeLowColor}"
TintOpacity="0.7" />
<!-- UNO TODO END THEME RESOURCES -->
<xamarin:SolidColorBrush x:Key="AppChromeAcrylicHostBackdropMediumLowBrush"
Color="{ThemeResource SystemColorWindowColor}" />
<!-- UNO TODO END THEME RESOURCES -->
<!-- Min Window Height/Width -->
<x:Double x:Key="AppMinWindowHeight">500</x:Double>
<x:Double x:Key="AppMinWindowWidth">320</x:Double>
<FontFamily x:Key="CalculatorFontFamily">ms-appx:///Assets/CalcMDL2.ttf#Calculator MDL2 Assets</FontFamily>
<win:FontFamily x:Key="CalculatorFontFamily">ms-appx:///Assets/CalcMDL2.ttf#Calculator MDL2 Assets</win:FontFamily>
<xamarin:FontFamily x:Key="CalculatorFontFamily">Calculator MDL2 Assets</xamarin:FontFamily>
<x:Double x:Key="SplitViewOpenPaneLength">256</x:Double>
<Thickness x:Key="PivotPortraitThemePadding">0,1,0,0</Thickness>
@ -331,9 +350,7 @@
To="KeyBoardEntry" />
</VisualStateGroup.Transitions>
<VisualState x:Name="Normal" />
<!--
UNO TODO
<VisualState x:Name="PointerOver">
<win:VisualState x:Name="PointerOver">
<VisualState.Setters>
<Setter Target="RootGrid.(RevealBrush.State)"
Value="PointerOver" />
@ -342,17 +359,22 @@
<Setter Target="ContentPresenter.(ContentPresenter.Foreground)"
Value="{Binding HoverForeground, RelativeSource={RelativeSource TemplatedParent}}" />
</VisualState.Setters>
</VisualState>
</win:VisualState>
<VisualState x:Name="Pressed">
<VisualState.Setters>
<Setter Target="RootGrid.(RevealBrush.State)"
Value="Pressed" />
<Setter Target="RootGrid.Background"
<win:Setter Target="RootGrid.Background"
Value="{Binding PressBackground, RelativeSource={RelativeSource TemplatedParent}}" />
<Setter Target="ContentPresenter.(ContentPresenter.Foreground)"
<win:Setter Target="ContentPresenter.(ContentPresenter.Foreground)"
Value="{Binding PressForeground, RelativeSource={RelativeSource TemplatedParent}}" />
<!-- UNO TODO -->
<xamarin:Setter Target="RootGrid.Background"
Value="{ThemeResource AppControlPressedButtonFaceBrush}" />
<xamarin:Setter Target="ContentPresenter.(ContentPresenter.Foreground)"
Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}" />
</VisualState.Setters>
</VisualState>-->
</VisualState>
<VisualState x:Name="Disabled">
<VisualState.Setters>
<Setter Target="ContentPresenter.Foreground"
@ -466,9 +488,7 @@
To="KeyBoardEntry" />
</VisualStateGroup.Transitions>
<VisualState x:Name="Normal" />
<!--
UNO TODO
<VisualState x:Name="PointerOver">
<win:VisualState x:Name="PointerOver">
<VisualState.Setters>
<Setter Target="RootGrid.(RevealBrush.State)"
Value="PointerOver" />
@ -479,19 +499,25 @@
<Setter Target="ParenthesisCount.Foreground"
Value="{Binding HoverForeground, RelativeSource={RelativeSource TemplatedParent}}" />
</VisualState.Setters>
</VisualState>
</win:VisualState>
<VisualState x:Name="Pressed">
<VisualState.Setters>
<Setter Target="RootGrid.(RevealBrush.State)"
Value="Pressed" />
<Setter Target="RootGrid.Background"
<win:Setter Target="RootGrid.Background"
Value="{Binding PressBackground, RelativeSource={RelativeSource TemplatedParent}}" />
<Setter Target="ContentPresenter.Foreground"
<win:Setter Target="ContentPresenter.Foreground"
Value="{Binding PressForeground, RelativeSource={RelativeSource TemplatedParent}}" />
<Setter Target="ParenthesisCount.Foreground"
<win:Setter Target="ParenthesisCount.Foreground"
Value="{Binding PressForeground, RelativeSource={RelativeSource TemplatedParent}}" />
<xamarin:Setter Target="RootGrid.Background"
Value="{ThemeResource AppControlPressedButtonFaceBrush}" />
<xamarin:Setter Target="ContentPresenter.Foreground"
Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}" />
<xamarin:Setter Target="ParenthesisCount.Foreground"
Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}" />
</VisualState.Setters>
</VisualState>-->
</VisualState>
<VisualState x:Name="Disabled">
<VisualState.Setters>
<Setter Target="ContentPresenter.Foreground"
@ -569,8 +595,10 @@
<Style x:Key="ResultsScrollerSnapped"
BasedOn="{StaticResource ResultsScroller}"
TargetType="ScrollViewer">
<Setter Property="HorizontalScrollMode"
<win:Setter Property="HorizontalScrollMode"
Value="Enabled" />
<xamarin:Setter Property="HorizontalScrollMode"
Value="Disabled" />
<Setter Property="HorizontalScrollBarVisibility"
Value="Hidden" />
<Setter Property="IsHitTestVisible"

12
src/Calculator.Shared/ViewModels/ApplicationViewModel.cs
View file

@ -110,12 +110,15 @@ namespace CalculatorApp.ViewModel
try
{
Console.WriteLine($"ApplicationViewModel.Mode1={mode}");
Mode = mode;
}
catch (Exception e)
Console.WriteLine($"ApplicationViewModel.Mode2={Mode}");
}
catch (Exception e)
{
// TraceLogger.GetInstance().LogPlatformException(__FUNCTIONW__, e);
if (!TryRecoverFromNavigationModeFailure())
Console.WriteLine($"ApplicationViewModel.Mode3={e}");
// TraceLogger.GetInstance().LogPlatformException(__FUNCTIONW__, e);
if (!TryRecoverFromNavigationModeFailure())
{
// Could not navigate to standard mode either.
// Throw the original exception so we have a good stack to debug.
@ -152,6 +155,7 @@ namespace CalculatorApp.ViewModel
m_CalculatorViewModel = new StandardCalculatorViewModel();
}
m_CalculatorViewModel.SetCalculatorType(m_mode);
Console.WriteLine($"m_CalculatorViewMode = {m_CalculatorViewModel}");
}
else if (NavCategory.IsDateCalculatorViewMode(m_mode))
{

6
src/Calculator.Shared/ViewModels/StandardCalculatorViewModel.cs
View file

@ -510,6 +510,8 @@ namespace CalculatorApp.ViewModel
public StandardCalculatorViewModel()
{
Console.WriteLine("new StandardCalculatorViewModel()");
m_DisplayValue = "0";
m_DecimalDisplayValue = "0";
m_HexDisplayValue = "0";
@ -571,11 +573,13 @@ namespace CalculatorApp.ViewModel
m_decimalSeparator = LocalizationSettings.GetInstance().GetDecimalSeparator();
if (CoreWindow.GetForCurrentThread() != null)
#if !__WASM__
if (CoreWindow.GetForCurrentThread() != null)
{
// Must have a CoreWindow to access the resource context.
m_isRtlLanguage = LocalizationService.GetInstance().IsRtlLayout();
}
#endif
IsEditingEnabled = false;
IsUnaryOperatorEnabled = true;

5
src/Calculator.Shared/Views/Calculator.xaml
View file

@ -1,6 +1,7 @@
<UserControl x:Class="CalculatorApp.Calculator"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:win="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:xamarin="http://uno.ui/xamarin"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:automation="using:CalculatorApp.Common.Automation"
xmlns:common="using:CalculatorApp.Common"
@ -10,7 +11,7 @@
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:model="using:CalculatorApp.ViewModels"
Loaded="OnLoaded"
mc:Ignorable="">
mc:Ignorable="xamarin">
<UserControl.Resources>
<!-- DataTemplates -->
@ -188,6 +189,7 @@
<ScrollViewer x:Name="expressionContainer"
Grid.Column="1"
Padding="0,0,0,0"
xamarin:HorizontalScrollBarVisibility="Disabled"
VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
Style="{StaticResource ResultsScrollerSnapped}"
AutomationProperties.AccessibilityView="Raw">
@ -967,6 +969,7 @@
IsOperatorCommand="{x:Bind Model.IsOperatorCommand, Mode=OneWay}"
TabIndex="1" />
<controls:OverflowTextBlock x:Name="expressionText"
xamarin:Style="{StaticResource overflowTextBlockStyle}"
Grid.Row="1"
Margin="6,0,6,0"
VerticalAlignment="Bottom"

80
src/Calculator.Shared/Views/MainPage.xaml.cs
View file

@ -75,7 +75,11 @@ namespace CalculatorApp
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (m_model.CalculatorViewModel != null)
initialized = true;
NavView.DataContext = m_model;
if (m_model.CalculatorViewModel != null)
{
m_model.CalculatorViewModel.HistoryVM.ClearHistory();
}
@ -101,8 +105,14 @@ namespace CalculatorApp
}
}
m_model.Initialize(initialMode);
}
m_model.Initialize(initialMode);
EnsureCalculator();
m_calculator.DataContext = m_model.CalculatorViewModel;
Initialize();
}
void WindowSizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
{
@ -229,34 +239,46 @@ namespace CalculatorApp
}
void OnPageLoaded(object sender, RoutedEventArgs args)
{
if (m_converter == null && m_calculator == null && m_dateCalculator == null)
{
// We have just launched into our default mode (standard calc) so ensure calc is loaded
EnsureCalculator();
m_model.CalculatorViewModel.IsStandard = true;
}
{
Initialize();
}
Windows.UI.Xaml.Window.Current.SizeChanged += WindowSizeChanged;
UpdateViewState();
bool initialized = false;
private void Initialize()
{
// UNO TODO Check for Initialized (Load/OnNavigatedTo order is different)
if (initialized)
{
if (m_converter == null && m_calculator == null && m_dateCalculator == null)
{
// We have just launched into our default mode (standard calc) so ensure calc is loaded
EnsureCalculator();
m_model.CalculatorViewModel.IsStandard = true;
}
SetHeaderAutomationName();
SetDefaultFocus();
// Delay load things later when we get a chance.
this.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, () => {
// UNO TODO
//if (TraceLogger.GetInstance().UpdateWindowIdLog(ApplicationView.GetApplicationViewIdForWindow(CoreWindow.GetForCurrentThread())))
//{
// TraceLogger.GetInstance().LogAppLaunchComplete();
// AppLifecycleLogger.GetInstance().LaunchUIResponsive();
// AppLifecycleLogger.GetInstance().LaunchVisibleComplete();
//}
});
}
Windows.UI.Xaml.Window.Current.SizeChanged += WindowSizeChanged;
UpdateViewState();
void SetDefaultFocus()
SetHeaderAutomationName();
SetDefaultFocus();
// Delay load things later when we get a chance.
this.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, () =>
{
// UNO TODO
//if (TraceLogger.GetInstance().UpdateWindowIdLog(ApplicationView.GetApplicationViewIdForWindow(CoreWindow.GetForCurrentThread())))
//{
// TraceLogger.GetInstance().LogAppLaunchComplete();
// AppLifecycleLogger.GetInstance().LaunchUIResponsive();
// AppLifecycleLogger.GetInstance().LaunchVisibleComplete();
//}
});
}
}
void SetDefaultFocus()
{
if (m_calculator != null && m_calculator.Visibility == Visibility.Visible)
{
@ -281,7 +303,7 @@ namespace CalculatorApp
// delay load calculator.
m_calculator = new Calculator();
m_calculator.Name = "Calculator";
m_calculator.DataContext = m_model.CalculatorViewModel;
m_calculator.DataContext = m_model.CalculatorViewModel;
Binding isStandardBinding = new Binding();
isStandardBinding.Path = new PropertyPath("IsStandard");
m_calculator.SetBinding(CalculatorApp.Calculator.IsStandardProperty, isStandardBinding);
@ -305,7 +327,7 @@ namespace CalculatorApp
ShowHideControls(this.Model.Mode);
}
if (m_dateCalculator != null)
if (m_dateCalculator != null)
{
// UNO TODO
// m_dateCalculator.CloseCalendarFlyout();

17
src/Calculator.Wasm/Calculator.Wasm.csproj
View file

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<OutputType>Exe</OutputType>
@ -6,15 +6,20 @@
<WasmHead>true</WasmHead>
<DefineConstants>$(DefineConstants);__WASM__</DefineConstants>
<NoWarn>NU1701</NoWarn>
<WasmShellGenerateCompressedFiles Condition="'$(Configuration)'=='DEBUG'">false</WasmShellGenerateCompressedFiles>
<WasmShellGenerateCompressedFiles Condition="'$(Configuration)'=='Debug'">false</WasmShellGenerateCompressedFiles>
<!--<BuildingInsideUnoSourceGenerator>true</BuildingInsideUnoSourceGenerator>-->
</PropertyGroup>
<MonoRuntimeDebuggerEnabled Condition="'$(Configuration)'=='Debug'">true</MonoRuntimeDebuggerEnabled>
<MonoWasmRuntimeConfiguration>release-dynamic</MonoWasmRuntimeConfiguration>
<!-- This build a custom one pending a PR in mono -->
<MonoWasmSDKUri Condition="'$(Configuration)'=='Debug'">C:\Users\jerome.laban\Downloads\mono-wasm-4d023b6bf84.zip</MonoWasmSDKUri>
</PropertyGroup>
<ItemGroup>
<Content Include="..\Calculator.UWP\Assets\*.png" Link="Assets\%(FileName)%(Extension)" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="WasmCSS\Fonts.css" />
<EmbeddedResource Include="WasmScripts\AppManifest.js" />
<EmbeddedResource Include="WasmScripts\*.js" />
</ItemGroup>
<ItemGroup>
<LinkerDescriptor Include="LinkerConfig.xml" />
@ -27,6 +32,7 @@
You can safely remove this ItemGroup completely.
-->
<Compile Remove="Program.cs" />
<None Remove="WasmScripts\CalcManager.js" />
<Compile Include="Program.cs" />
<Content Include="LinkerConfig.xml" />
</ItemGroup>
@ -37,5 +43,8 @@
<PackageReference Include="Uno.Wasm.Bootstrap" Version="1.0.0-dev.269" />
<DotNetCliToolReference Include="Uno.Wasm.Bootstrap.Cli" Version="1.0.0-dev.269" />
</ItemGroup>
<ItemGroup>
<Content Include="..\CalcManager\CalcManager.wasm" Link="CalcManager.wasm" />
</ItemGroup>
<Import Project="..\Calculator.Shared\Calculator.Shared.projitems" Label="Shared" Condition="Exists('..\Calculator.Shared\Calculator.Shared.projitems')" />
</Project>

6
src/Calculator.Wasm/Program.cs
View file

@ -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());
}

11
src/Calculator.Wasm/WasmCSS/Fonts.css
View file

File diff suppressed because one or more lines are too long

44
src/Calculator.Wasm/WasmScripts/CalcManager.js Normal file
View file

@ -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;
}
}