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

- AlignAfterOpenBracket: AlwaysBreak

Browse source
This commit is contained in:
Daniel Belcher 2019-05-02 11:18:53 -07:00
commit 60be5e8185
76 changed files with 554 additions and 415 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.clang-format
View file

@ -1,5 +1,5 @@
AccessModifierOffset: -4 AccessModifierOffset: -4
AlignAfterOpenBracket: Align AlignAfterOpenBracket: AlwaysBreak
AlignConsecutiveAssignments: false AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right AlignEscapedNewlines: Right

8
src/CalcManager/CEngine/History.cpp
View file

@ -300,8 +300,8 @@ void CHistoryCollector::CompleteHistoryLine(wstring_view numStr)
{ {
if (nullptr != m_pCalcDisplay) if (nullptr != m_pCalcDisplay)
{ {
m_pCalcDisplay->SetExpressionDisplay(std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), m_pCalcDisplay->SetExpressionDisplay(
std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>()); std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
} }
if (nullptr != m_pHistoryDisplay) if (nullptr != m_pHistoryDisplay)
@ -322,8 +322,8 @@ void CHistoryCollector::ClearHistoryLine(wstring_view errStr)
{ {
if (nullptr != m_pCalcDisplay) if (nullptr != m_pCalcDisplay)
{ {
m_pCalcDisplay->SetExpressionDisplay(std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), m_pCalcDisplay->SetExpressionDisplay(
std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>()); std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
} }
m_iCurLineHistStart = -1; // It will get recomputed at the first Opnd m_iCurLineHistStart = -1; // It will get recomputed at the first Opnd
ReinitHistory(); ReinitHistory();

5
src/CalcManager/CEngine/calc.cpp
View file

@ -58,8 +58,9 @@ void CCalcEngine::InitialOneTimeOnlySetup(CalculationManager::IResourceProvider&
// CCalcEngine::CCalcEngine // CCalcEngine::CCalcEngine
// //
////////////////////////////////////////////////// //////////////////////////////////////////////////
CCalcEngine::CCalcEngine(bool fPrecedence, bool fIntegerMode, CalculationManager::IResourceProvider* const pResourceProvider, CCalcEngine::CCalcEngine(
__in_opt ICalcDisplay* pCalcDisplay, __in_opt shared_ptr<IHistoryDisplay> pHistoryDisplay) bool fPrecedence, bool fIntegerMode, CalculationManager::IResourceProvider* const pResourceProvider, __in_opt ICalcDisplay* pCalcDisplay,
__in_opt shared_ptr<IHistoryDisplay> pHistoryDisplay)
: m_fPrecedence(fPrecedence) : m_fPrecedence(fPrecedence)
, m_fIntegerMode(fIntegerMode) , m_fIntegerMode(fIntegerMode)
, m_pCalcDisplay(pCalcDisplay) , m_pCalcDisplay(pCalcDisplay)

8
src/CalcManager/CEngine/scicomm.cpp
View file

@ -382,8 +382,8 @@ void CCalcEngine::ProcessCommandWorker(OpCode wParam)
if (nullptr != m_pCalcDisplay) if (nullptr != m_pCalcDisplay)
{ {
m_pCalcDisplay->SetParenthesisNumber(0); m_pCalcDisplay->SetParenthesisNumber(0);
m_pCalcDisplay->SetExpressionDisplay(make_shared<CalculatorVector<pair<wstring, int>>>(), m_pCalcDisplay->SetExpressionDisplay(
make_shared<CalculatorVector<shared_ptr<IExpressionCommand>>>()); make_shared<CalculatorVector<pair<wstring, int>>>(), make_shared<CalculatorVector<shared_ptr<IExpressionCommand>>>());
} }
m_HistoryCollector.ClearHistoryLine(wstring()); m_HistoryCollector.ClearHistoryLine(wstring());
@ -476,8 +476,8 @@ void CCalcEngine::ProcessCommandWorker(OpCode wParam)
m_HistoryCollector.CompleteHistoryLine(groupedString); m_HistoryCollector.CompleteHistoryLine(groupedString);
if (nullptr != m_pCalcDisplay) if (nullptr != m_pCalcDisplay)
{ {
m_pCalcDisplay->SetExpressionDisplay(make_shared<CalculatorVector<pair<wstring, int>>>(), m_pCalcDisplay->SetExpressionDisplay(
make_shared<CalculatorVector<shared_ptr<IExpressionCommand>>>()); make_shared<CalculatorVector<pair<wstring, int>>>(), make_shared<CalculatorVector<shared_ptr<IExpressionCommand>>>());
} }
} }

5
src/CalcManager/CalculatorHistory.cpp
View file

@ -11,8 +11,9 @@ CalculatorHistory::CalculatorHistory(size_t maxSize) : m_maxHistorySize(maxSize)
{ {
} }
unsigned int CalculatorHistory::AddToHistory(_In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, unsigned int CalculatorHistory::AddToHistory(
_In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands, _In_ wstring_view result) _In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands,
_In_ wstring_view result)
{ {
unsigned int addedIndex; unsigned int addedIndex;
wstring generatedExpression; wstring generatedExpression;

3
src/CalcManager/CalculatorHistory.h
View file

@ -30,7 +30,8 @@ namespace CalculationManager
{ {
public: public:
CalculatorHistory(const size_t maxSize); CalculatorHistory(const size_t maxSize);
unsigned int AddToHistory(_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens, unsigned int AddToHistory(
_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens,
_In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& spCommands, std::wstring_view result); _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& spCommands, std::wstring_view result);
std::vector<std::shared_ptr<HISTORYITEM>> const& GetHistory(); std::vector<std::shared_ptr<HISTORYITEM>> const& GetHistory();
std::shared_ptr<HISTORYITEM> const& GetHistoryItem(unsigned int uIdx); std::shared_ptr<HISTORYITEM> const& GetHistoryItem(unsigned int uIdx);

3
src/CalcManager/CalculatorManager.cpp
View file

@ -85,7 +85,8 @@ namespace CalculationManager
/// Used to set the expression display value on ViewModel /// Used to set the expression display value on ViewModel
/// </summary> /// </summary>
/// <param name="expressionString">wstring representing expression to be displayed</param> /// <param name="expressionString">wstring representing expression to be displayed</param>
void CalculatorManager::SetExpressionDisplay(_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, void CalculatorManager::SetExpressionDisplay(
_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
_Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands) _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
{ {
if (!m_inHistoryItemLoadMode) if (!m_inHistoryItemLoadMode)

3
src/CalcManager/CalculatorManager.h
View file

@ -91,7 +91,8 @@ namespace CalculationManager
// ICalcDisplay // ICalcDisplay
void SetPrimaryDisplay(_In_ const std::wstring& displayString, _In_ bool isError) override; void SetPrimaryDisplay(_In_ const std::wstring& displayString, _In_ bool isError) override;
void SetIsInError(bool isError) override; void SetIsInError(bool isError) override;
void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override; _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override;
void SetMemorizedNumbers(_In_ const std::vector<std::wstring>& memorizedNumbers) override; void SetMemorizedNumbers(_In_ const std::vector<std::wstring>& memorizedNumbers) override;
void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override; void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override;

3
src/CalcManager/Header Files/CalcEngine.h
View file

@ -54,7 +54,8 @@ namespace CalculatorEngineTests
class CCalcEngine class CCalcEngine
{ {
public: public:
CCalcEngine(bool fPrecedence, bool fIntegerMode, CalculationManager::IResourceProvider* const pResourceProvider, __in_opt ICalcDisplay* pCalcDisplay, CCalcEngine(
bool fPrecedence, bool fIntegerMode, CalculationManager::IResourceProvider* const pResourceProvider, __in_opt ICalcDisplay* pCalcDisplay,
__in_opt std::shared_ptr<IHistoryDisplay> pHistoryDisplay); __in_opt std::shared_ptr<IHistoryDisplay> pHistoryDisplay);
void ProcessCommand(OpCode wID); void ProcessCommand(OpCode wID);
void DisplayError(uint32_t nError); void DisplayError(uint32_t nError);

3
src/CalcManager/Header Files/ICalcDisplay.h
View file

@ -12,7 +12,8 @@ class ICalcDisplay
public: public:
virtual void SetPrimaryDisplay(const std::wstring& pszText, bool isError) = 0; virtual void SetPrimaryDisplay(const std::wstring& pszText, bool isError) = 0;
virtual void SetIsInError(bool isInError) = 0; virtual void SetIsInError(bool isInError) = 0;
virtual void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, virtual void SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) = 0; _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) = 0;
virtual void SetParenthesisNumber(_In_ unsigned int count) = 0; virtual void SetParenthesisNumber(_In_ unsigned int count) = 0;
virtual void OnNoRightParenAdded() = 0; virtual void OnNoRightParenAdded() = 0;

6
src/CalcManager/Header Files/IHistoryDisplay.h
View file

@ -8,7 +8,7 @@ class IHistoryDisplay
{ {
public: public:
virtual ~IHistoryDisplay(){}; virtual ~IHistoryDisplay(){};
virtual unsigned int AddToHistory(_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, virtual unsigned int AddToHistory(
_In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands, _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_In_ std::wstring_view result) = 0; _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands, _In_ std::wstring_view result) = 0;
}; };

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

@ -356,12 +356,13 @@ uint64_t rattoUi64(_In_ PRAT prat, uint32_t radix, int32_t precision);
extern PNUMBER _createnum(_In_ uint32_t size); // returns an empty number structure with size digits extern PNUMBER _createnum(_In_ uint32_t size); // returns an empty number structure with size digits
extern PNUMBER nRadixxtonum(_In_ PNUMBER a, uint32_t radix, int32_t precision); extern PNUMBER nRadixxtonum(_In_ PNUMBER a, uint32_t radix, int32_t precision);
extern PNUMBER gcd(_In_ PNUMBER a, _In_ PNUMBER b); extern PNUMBER gcd(_In_ PNUMBER a, _In_ PNUMBER b);
extern PNUMBER StringToNumber(std::wstring_view numberString, uint32_t radix, extern PNUMBER StringToNumber(
std::wstring_view numberString, uint32_t radix,
int32_t precision); // takes a text representation of a number and returns a number. int32_t precision); // takes a text representation of a number and returns a number.
// takes a text representation of a number as a mantissa with sign and an exponent with sign. // takes a text representation of a number as a mantissa with sign and an exponent with sign.
extern PRAT StringToRat(bool mantissaIsNegative, std::wstring_view mantissa, bool exponentIsNegative, std::wstring_view exponent, uint32_t radix, extern PRAT
int32_t precision); StringToRat(bool mantissaIsNegative, std::wstring_view mantissa, bool exponentIsNegative, std::wstring_view exponent, uint32_t radix, int32_t precision);
extern PNUMBER i32factnum(int32_t ini32, uint32_t radix); extern PNUMBER i32factnum(int32_t ini32, uint32_t radix);
extern PNUMBER i32prodnum(int32_t start, int32_t stop, uint32_t radix); extern PNUMBER i32prodnum(int32_t start, int32_t stop, uint32_t radix);

15
src/CalcManager/UnitConverter.h
View file

@ -29,7 +29,8 @@ namespace UnitConversionManager
{ {
} }
Unit(int id, std::wstring currencyName, std::wstring countryName, std::wstring abbreviation, bool isRtlLanguage, bool isConversionSource, Unit(
int id, std::wstring currencyName, std::wstring countryName, std::wstring abbreviation, bool isRtlLanguage, bool isConversionSource,
bool isConversionTarget) bool isConversionTarget)
: id(id), abbreviation(abbreviation), isConversionSource(isConversionSource), isConversionTarget(isConversionTarget), isWhimsical(false) : id(id), abbreviation(abbreviation), isConversionSource(isConversionSource), isConversionTarget(isConversionTarget), isWhimsical(false)
{ {
@ -155,8 +156,8 @@ namespace UnitConversionManager
}; };
typedef std::tuple<std::vector<UnitConversionManager::Unit>, UnitConversionManager::Unit, UnitConversionManager::Unit> CategorySelectionInitializer; typedef std::tuple<std::vector<UnitConversionManager::Unit>, UnitConversionManager::Unit, UnitConversionManager::Unit> CategorySelectionInitializer;
typedef std::unordered_map<UnitConversionManager::Unit, typedef std::unordered_map<
std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>, UnitConversionManager::Unit, std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>,
UnitConversionManager::UnitHash> UnitConversionManager::UnitHash>
UnitToUnitToConversionDataMap; UnitToUnitToConversionDataMap;
typedef std::unordered_map<UnitConversionManager::Category, std::vector<UnitConversionManager::Unit>, UnitConversionManager::CategoryHash> typedef std::unordered_map<UnitConversionManager::Category, std::vector<UnitConversionManager::Unit>, UnitConversionManager::CategoryHash>
@ -188,10 +189,10 @@ namespace UnitConversionManager
{ {
public: public:
virtual void SetViewModelCallback(const std::shared_ptr<UnitConversionManager::IViewModelCurrencyCallback>& callback) = 0; virtual void SetViewModelCallback(const std::shared_ptr<UnitConversionManager::IViewModelCurrencyCallback>& callback) = 0;
virtual std::pair<std::wstring, std::wstring> GetCurrencySymbols(_In_ const UnitConversionManager::Unit& unit1, virtual std::pair<std::wstring, std::wstring>
_In_ const UnitConversionManager::Unit& unit2) = 0; 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, virtual std::pair<std::wstring, std::wstring>
_In_ const UnitConversionManager::Unit& unit2) = 0; GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) = 0;
virtual std::wstring GetCurrencyTimestamp() = 0; virtual std::wstring GetCurrencyTimestamp() = 0;
virtual concurrency::task<bool> TryLoadDataFromCacheAsync() = 0; virtual concurrency::task<bool> TryLoadDataFromCacheAsync() = 0;

23
src/CalcViewModel/Common/AlwaysSelectedCollectionView.h
View file

@ -47,8 +47,8 @@ namespace CalculatorApp
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
property Windows::Foundation::Collections::IObservableVector<Platform::Object ^> ^ CollectionGroups { property Windows::Foundation::Collections::IObservableVector<Platform::Object ^> ^ CollectionGroups {
virtual Windows::Foundation::Collections::IObservableVector<Platform::Object virtual Windows::Foundation::Collections::IObservableVector<
^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get Platform::Object ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
{ {
return ref new Platform::Collections::Vector<Platform::Object ^>(); return ref new Platform::Collections::Vector<Platform::Object ^>();
} }
@ -80,8 +80,9 @@ namespace CalculatorApp
// restore the selection to the way we wanted it to begin with // restore the selection to the way we wanted it to begin with
if (m_currentPosition >= 0 && m_currentPosition < static_cast<int>(m_source->Size)) if (m_currentPosition >= 0 && m_currentPosition < static_cast<int>(m_source->Size))
{ {
this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, ref new Windows::UI::Core::DispatchedHandler([this]() {
ref new Windows::UI::Core::DispatchedHandler([this]() { m_currentChanged(this, nullptr); })); m_currentChanged(this, nullptr);
}));
} }
return false; return false;
} }
@ -167,14 +168,14 @@ namespace CalculatorApp
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
virtual unsigned int virtual unsigned int GetMany(
GetMany(unsigned int /*startIndex*/, unsigned int /*startIndex*/,
Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<Platform::Object virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<
^>::GetView Platform::Object ^>::GetView
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
@ -263,7 +264,8 @@ namespace CalculatorApp
private: private:
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ Convert(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
{ {
auto result = dynamic_cast<Windows::UI::Xaml::Interop::IBindableVector ^>(value); auto result = dynamic_cast<Windows::UI::Xaml::Interop::IBindableVector ^>(value);
@ -275,7 +277,8 @@ namespace CalculatorApp
} }
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ /*value*/, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ ConvertBack(
Platform::Object ^ /*value*/, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
{ {
return Windows::UI::Xaml::DependencyProperty::UnsetValue; return Windows::UI::Xaml::DependencyProperty::UnsetValue;

44
src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp
View file

@ -25,8 +25,8 @@ namespace CalculatorApp::Common::Automation
} }
} }
NarratorAnnouncement::NarratorAnnouncement(String ^ announcement, String ^ activityId, AutomationNotificationKind kind, NarratorAnnouncement::NarratorAnnouncement(
AutomationNotificationProcessing processing) String ^ announcement, String ^ activityId, AutomationNotificationKind kind, AutomationNotificationProcessing processing)
: m_announcement(announcement), m_activityId(activityId), m_kind(kind), m_processing(processing) : m_announcement(announcement), m_activityId(activityId), m_kind(kind), m_processing(processing)
{ {
} }
@ -58,66 +58,70 @@ bool NarratorAnnouncement::IsValid(NarratorAnnouncement ^ announcement)
NarratorAnnouncement ^ CalculatorAnnouncement::GetDisplayUpdatedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetDisplayUpdatedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::DisplayUpdated, AutomationNotificationKind::Other, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::ImportantMostRecent); announcement, CalculatorActivityIds::DisplayUpdated, AutomationNotificationKind::Other, AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetMaxDigitsReachedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetMaxDigitsReachedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MaxDigitsReached, AutomationNotificationKind::Other, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::ImportantMostRecent); announcement, CalculatorActivityIds::MaxDigitsReached, AutomationNotificationKind::Other, AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryClearedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryClearedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryCleared, AutomationNotificationKind::ItemRemoved, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::ImportantMostRecent); announcement, CalculatorActivityIds::MemoryCleared, AutomationNotificationKind::ItemRemoved, AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemChangedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemChangedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryItemChanged, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::MostRecent); announcement, CalculatorActivityIds::MemoryItemChanged, AutomationNotificationKind::ActionCompleted, AutomationNotificationProcessing::MostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryItemAdded, AutomationNotificationKind::ItemAdded, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::MostRecent); announcement, CalculatorActivityIds::MemoryItemAdded, AutomationNotificationKind::ItemAdded, AutomationNotificationProcessing::MostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetHistoryClearedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetHistoryClearedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::HistoryCleared, AutomationNotificationKind::ItemRemoved, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::MostRecent); announcement, CalculatorActivityIds::HistoryCleared, AutomationNotificationKind::ItemRemoved, AutomationNotificationProcessing::MostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetCategoryNameChangedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetCategoryNameChangedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::CategoryNameChanged, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
announcement, CalculatorActivityIds::CategoryNameChanged, AutomationNotificationKind::ActionCompleted,
AutomationNotificationProcessing::ImportantMostRecent); AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetUpdateCurrencyRatesAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetUpdateCurrencyRatesAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::UpdateCurrencyRates, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
announcement, CalculatorActivityIds::UpdateCurrencyRates, AutomationNotificationKind::ActionCompleted,
AutomationNotificationProcessing::ImportantMostRecent); AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetDisplayCopiedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetDisplayCopiedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::DisplayCopied, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
AutomationNotificationProcessing::ImportantMostRecent); announcement, CalculatorActivityIds::DisplayCopied, AutomationNotificationKind::ActionCompleted, AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::OpenParenthesisCountChanged, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
announcement, CalculatorActivityIds::OpenParenthesisCountChanged, AutomationNotificationKind::ActionCompleted,
AutomationNotificationProcessing::ImportantMostRecent); AutomationNotificationProcessing::ImportantMostRecent);
} }
NarratorAnnouncement ^ CalculatorAnnouncement::GetNoRightParenthesisAddedAnnouncement(String ^ announcement) NarratorAnnouncement ^ CalculatorAnnouncement::GetNoRightParenthesisAddedAnnouncement(String ^ announcement)
{ {
return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::NoParenthesisAdded, AutomationNotificationKind::ActionCompleted, return ref new NarratorAnnouncement(
announcement, CalculatorActivityIds::NoParenthesisAdded, AutomationNotificationKind::ActionCompleted,
AutomationNotificationProcessing::ImportantMostRecent); AutomationNotificationProcessing::ImportantMostRecent);
} }

4
src/CalcViewModel/Common/Automation/NarratorAnnouncement.h
View file

@ -58,8 +58,8 @@ public
// class that can access the private constructor. // class that can access the private constructor.
friend class CalculatorAnnouncement; friend class CalculatorAnnouncement;
NarratorAnnouncement(Platform::String ^ announcement, Platform::String ^ activityId, AutomationNotificationKind kind, NarratorAnnouncement(
AutomationNotificationProcessing processing); Platform::String ^ announcement, Platform::String ^ activityId, AutomationNotificationKind kind, AutomationNotificationProcessing processing);
Platform::String ^ m_announcement; Platform::String ^ m_announcement;
Platform::String ^ m_activityId; Platform::String ^ m_activityId;

6
src/CalcViewModel/Common/Automation/NarratorNotifier.cpp
View file

@ -30,10 +30,12 @@ void NarratorNotifier::Announce(NarratorAnnouncement ^ announcement)
void NarratorNotifier::RegisterDependencyProperties() void NarratorNotifier::RegisterDependencyProperties()
{ {
s_announcementProperty = DependencyProperty::Register(L"Announcement", // The name of the dependency property. s_announcementProperty = DependencyProperty::Register(
L"Announcement", // The name of the dependency property.
NarratorAnnouncement::typeid, // The type of the dependency property. NarratorAnnouncement::typeid, // The type of the dependency property.
NarratorNotifier::typeid, // The owner of the dependency property. NarratorNotifier::typeid, // The owner of the dependency property.
ref new PropertyMetadata(nullptr, // Default value of the dependency property. ref new PropertyMetadata(
nullptr, // Default value of the dependency property.
ref new PropertyChangedCallback(OnAnnouncementChanged))); ref new PropertyChangedCallback(OnAnnouncementChanged)));
} }

8
src/CalcViewModel/Common/Automation/NarratorNotifier.h
View file

@ -31,8 +31,8 @@ public
^ AnnouncementProperty { Windows::UI::Xaml::DependencyProperty ^ get() { return s_announcementProperty; } } ^ AnnouncementProperty { Windows::UI::Xaml::DependencyProperty ^ get() { return s_announcementProperty; } }
static NarratorAnnouncement static NarratorAnnouncement
^ GetAnnouncement(Windows::UI::Xaml::DependencyObject ^ GetAnnouncement(
^ element) { return safe_cast<NarratorAnnouncement ^>(element->GetValue(s_announcementProperty)); } Windows::UI::Xaml::DependencyObject ^ element) { return safe_cast<NarratorAnnouncement ^>(element->GetValue(s_announcementProperty)); }
static void SetAnnouncement(Windows::UI::Xaml::DependencyObject ^ element, NarratorAnnouncement ^ value) static void SetAnnouncement(Windows::UI::Xaml::DependencyObject ^ element, NarratorAnnouncement ^ value)
{ {
@ -40,8 +40,8 @@ public
} }
private: private:
static void OnAnnouncementChanged(_In_ Windows::UI::Xaml::DependencyObject ^ dependencyObject, static void OnAnnouncementChanged(
_In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ eventArgs); _In_ Windows::UI::Xaml::DependencyObject ^ dependencyObject, _In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ eventArgs);
static Windows::UI::Xaml::DependencyProperty ^ s_announcementProperty; static Windows::UI::Xaml::DependencyProperty ^ s_announcementProperty;

5
src/CalcViewModel/Common/Automation/NotificationHost.cpp
View file

@ -34,8 +34,9 @@ void NotificationHost::Announce(NarratorAnnouncement ^ announcement)
auto peer = FrameworkElementAutomationPeer::FromElement(m_host); auto peer = FrameworkElementAutomationPeer::FromElement(m_host);
if (peer != nullptr) if (peer != nullptr)
{ {
peer->RaiseNotificationEvent(GetWindowsNotificationKind(announcement->Kind), GetWindowsNotificationProcessing(announcement->Processing), peer->RaiseNotificationEvent(
announcement->Announcement, announcement->ActivityId); GetWindowsNotificationKind(announcement->Kind), GetWindowsNotificationProcessing(announcement->Processing), announcement->Announcement,
announcement->ActivityId);
} }
} }

3
src/CalcViewModel/Common/CalculatorDisplay.cpp
View file

@ -69,7 +69,8 @@ void CalculatorDisplay::SetIsInError(bool isError)
} }
} }
void CalculatorDisplay::SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void CalculatorDisplay::SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands)
{ {
if (m_callbackReference != nullptr) if (m_callbackReference != nullptr)

3
src/CalcViewModel/Common/CalculatorDisplay.h
View file

@ -18,7 +18,8 @@ namespace CalculatorApp
private: private:
void SetPrimaryDisplay(_In_ const std::wstring& displayString, _In_ bool isError) override; void SetPrimaryDisplay(_In_ const std::wstring& displayString, _In_ bool isError) override;
void SetIsInError(bool isError) override; void SetIsInError(bool isError) override;
void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override; _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override;
void SetMemorizedNumbers(_In_ const std::vector<std::wstring>& memorizedNumbers) override; void SetMemorizedNumbers(_In_ const std::vector<std::wstring>& memorizedNumbers) override;
void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override; void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override;

13
src/CalcViewModel/Common/CopyPasteManager.cpp
View file

@ -38,9 +38,10 @@ static const wstring c_uIntSuffixes = L"[uU]?[lL]{0,2}";
// RegEx Patterns used by various modes // RegEx Patterns used by various modes
static const array<wregex, 1> standardModePatterns = { wregex(c_wspc + c_signedDecFloat + c_wspc) }; static const array<wregex, 1> standardModePatterns = { wregex(c_wspc + c_signedDecFloat + c_wspc) };
static const array<wregex, 2> scientificModePatterns = { wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat + c_wspcRParens), static const array<wregex, 2> scientificModePatterns = {
wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat + c_wspcRParens),
+ L"[e]([+]|[-])+\\d+" + c_wspcRParens) }; wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat + L"[e]([+]|[-])+\\d+" + c_wspcRParens)
};
static const array<array<wregex, 5>, 4> programmerModePatterns = { static const array<array<wregex, 5>, 4> programmerModePatterns = {
{ // Hex numbers like 5F, 4A0C, 0xa9, 0xFFull, 47CDh { // Hex numbers like 5F, 4A0C, 0xa9, 0xFFull, 47CDh
{ wregex(c_wspcLParens + L"(0[xX])?" + c_hexProgrammerChars + c_uIntSuffixes + c_wspcRParens), { wregex(c_wspcLParens + L"(0[xX])?" + c_hexProgrammerChars + c_uIntSuffixes + c_wspcRParens),
@ -75,8 +76,10 @@ task<String ^> CopyPasteManager::GetStringToPaste(ViewMode mode, CategoryGroupTy
//-- add support to allow pasting for expressions like 1.3e12(as of now we allow 1.3e+12) //-- add support to allow pasting for expressions like 1.3e12(as of now we allow 1.3e+12)
return create_task((dataPackageView->GetTextAsync(::StandardDataFormats::Text))) return create_task((dataPackageView->GetTextAsync(::StandardDataFormats::Text)))
.then([mode, modeType, programmerNumberBase, .then(
bitLengthType](String ^ pastedText) { return ValidatePasteExpression(pastedText, mode, modeType, programmerNumberBase, bitLengthType); }, [mode, modeType, programmerNumberBase, bitLengthType](String ^ pastedText) {
return ValidatePasteExpression(pastedText, mode, modeType, programmerNumberBase, bitLengthType);
},
task_continuation_context::use_arbitrary()); task_continuation_context::use_arbitrary());
} }

21
src/CalcViewModel/Common/CopyPasteManager.h
View file

@ -26,8 +26,8 @@ namespace CalculatorApp
{ {
public: public:
static void CopyToClipboard(Platform::String ^ stringToCopy); static void CopyToClipboard(Platform::String ^ stringToCopy);
static concurrency::task<Platform::String ^> GetStringToPaste(CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, static concurrency::task<Platform::String ^> GetStringToPaste(
int programmerNumberBase = -1, int bitLengthType = -1); CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, int programmerNumberBase = -1, int bitLengthType = -1);
static bool HasStringToPaste() static bool HasStringToPaste()
{ {
return ClipboardTextFormat() >= 0; return ClipboardTextFormat() >= 0;
@ -40,19 +40,22 @@ namespace CalculatorApp
static Platform::String static Platform::String
^ ValidatePasteExpression(Platform::String ^ pastedText, CalculatorApp::Common::ViewMode mode, int programmerNumberBase, int bitLengthType); ^ ValidatePasteExpression(Platform::String ^ pastedText, CalculatorApp::Common::ViewMode mode, int programmerNumberBase, int bitLengthType);
static Platform::String static Platform::String
^ ValidatePasteExpression(Platform::String ^ pastedText, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, ^ ValidatePasteExpression(
Platform::String ^ pastedText, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType,
int programmerNumberBase, int bitLengthType); int programmerNumberBase, int bitLengthType);
static std::vector<std::wstring> ExtractOperands(const std::wstring& pasteExpression, CalculatorApp::Common::ViewMode mode, static std::vector<std::wstring>
ExtractOperands(const std::wstring& pasteExpression, CalculatorApp::Common::ViewMode mode, int programmerNumberBase = -1, int bitLengthType = -1);
static bool ExpressionRegExMatch(
std::vector<std::wstring> operands, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType,
int programmerNumberBase = -1, int bitLengthType = -1); int programmerNumberBase = -1, int bitLengthType = -1);
static bool ExpressionRegExMatch(std::vector<std::wstring> operands, CalculatorApp::Common::ViewMode mode,
CalculatorApp::Common::CategoryGroupType modeType, int programmerNumberBase = -1, int bitLengthType = -1);
static std::pair<size_t, uint64_t> GetMaxOperandLengthAndValue(CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, static std::pair<size_t, uint64_t> GetMaxOperandLengthAndValue(
int programmerNumberBase = -1, int bitLengthType = -1); CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, int programmerNumberBase = -1, int bitLengthType = -1);
static std::wstring SanitizeOperand(const std::wstring& operand); static std::wstring SanitizeOperand(const std::wstring& operand);
static bool TryOperandToULL(const std::wstring& operand, int numberBase, unsigned long long int& result); static bool TryOperandToULL(const std::wstring& operand, int numberBase, unsigned long long int& result);
static size_t OperandLength(const std::wstring& operand, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType, static size_t OperandLength(
const std::wstring& operand, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType,
int programmerNumberBase = -1); int programmerNumberBase = -1);
static size_t StandardScientificOperandLength(const std::wstring& operand); static size_t StandardScientificOperandLength(const std::wstring& operand);
static size_t ProgrammerOperandLength(const std::wstring& operand, int numberBase); static size_t ProgrammerOperandLength(const std::wstring& operand, int numberBase);

11
src/CalcViewModel/Common/DateCalculator.h
View file

@ -44,11 +44,12 @@ namespace CalculatorApp
DateCalculationEngine(_In_ Platform::String ^ calendarIdentifier); DateCalculationEngine(_In_ Platform::String ^ calendarIdentifier);
// Public Methods // Public Methods
bool __nothrow AddDuration(_In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration, bool __nothrow
_Out_ Windows::Foundation::DateTime* endDate); AddDuration(_In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration, _Out_ Windows::Foundation::DateTime* endDate);
bool __nothrow SubtractDuration(_In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration, bool __nothrow SubtractDuration(
_Out_ Windows::Foundation::DateTime* endDate); _In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration, _Out_ Windows::Foundation::DateTime* endDate);
void __nothrow GetDateDifference(_In_ Windows::Foundation::DateTime date1, _In_ Windows::Foundation::DateTime date2, _In_ DateUnit outputFormat, void __nothrow GetDateDifference(
_In_ Windows::Foundation::DateTime date1, _In_ Windows::Foundation::DateTime date2, _In_ DateUnit outputFormat,
_Out_ DateDifference* difference); _Out_ DateDifference* difference);
private: private:

3
src/CalcViewModel/Common/KeyboardShortcutManager.cpp
View file

@ -446,7 +446,8 @@ const std::multimap<MyVirtualKey, WeakReference>& GetCurrentKeyDictionary(MyVirt
{ {
return s_VirtualKeyAltChordsForButtons.find(viewId)->second; return s_VirtualKeyAltChordsForButtons.find(viewId)->second;
} }
else if ((s_ShiftKeyPressed.find(viewId)->second) else if (
(s_ShiftKeyPressed.find(viewId)->second)
&& ((Window::Current->CoreWindow->GetKeyState(VirtualKey::Control) & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down)) && ((Window::Current->CoreWindow->GetKeyState(VirtualKey::Control) & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down))
{ {
return s_VirtualKeyControlShiftChordsForButtons.find(viewId)->second; return s_VirtualKeyControlShiftChordsForButtons.find(viewId)->second;

8
src/CalcViewModel/Common/KeyboardShortcutManager.h
View file

@ -62,13 +62,13 @@ namespace CalculatorApp
static void OnVirtualKeyInverseChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue); static void OnVirtualKeyInverseChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
static void OnVirtualKeyControlInverseChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, static void
MyVirtualKey newValue); OnVirtualKeyControlInverseChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
static void OnVirtualKeyAltChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue); static void OnVirtualKeyAltChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
static void OnVirtualKeyControlShiftChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, static void
MyVirtualKey newValue); OnVirtualKeyControlShiftChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
static void OnCharacterReceivedHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::CharacterReceivedEventArgs ^ args); static void OnCharacterReceivedHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::CharacterReceivedEventArgs ^ args);
static void OnKeyDownHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args); static void OnKeyDownHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args);

8
src/CalcViewModel/Common/LocalizationService.h
View file

@ -44,8 +44,8 @@ namespace CalculatorApp
static Windows::Globalization::NumberFormatting::DecimalFormatter ^ GetRegionalSettingsAwareDecimalFormatter(); static Windows::Globalization::NumberFormatting::DecimalFormatter ^ GetRegionalSettingsAwareDecimalFormatter();
static Windows::Globalization::DateTimeFormatting::DateTimeFormatter ^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format); static Windows::Globalization::DateTimeFormatting::DateTimeFormatter ^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format);
static Windows::Globalization::DateTimeFormatting::DateTimeFormatter static Windows::Globalization::DateTimeFormatting::DateTimeFormatter
^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format, _In_ Platform::String ^ calendarIdentifier, ^ GetRegionalSettingsAwareDateTimeFormatter(
_In_ Platform::String ^ clockIdentifier); _In_ Platform::String ^ format, _In_ Platform::String ^ calendarIdentifier, _In_ Platform::String ^ clockIdentifier);
static Windows::Globalization::NumberFormatting::CurrencyFormatter ^ GetRegionalSettingsAwareCurrencyFormatter(); static Windows::Globalization::NumberFormatting::CurrencyFormatter ^ GetRegionalSettingsAwareCurrencyFormatter();
@ -60,8 +60,8 @@ namespace CalculatorApp
// Attached property callbacks // Attached property callbacks
static void OnFontTypePropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, LanguageFontType oldValue, LanguageFontType newValue); static void OnFontTypePropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, LanguageFontType oldValue, LanguageFontType newValue);
static void OnFontWeightPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, Windows::UI::Text::FontWeight oldValue, static void OnFontWeightPropertyChanged(
Windows::UI::Text::FontWeight newValue); Windows::UI::Xaml::DependencyObject ^ target, Windows::UI::Text::FontWeight oldValue, Windows::UI::Text::FontWeight newValue);
static void OnFontSizePropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, double oldValue, double newValue); static void OnFontSizePropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, double oldValue, double newValue);
static void UpdateFontFamilyAndSize(Windows::UI::Xaml::DependencyObject ^ target); static void UpdateFontFamilyAndSize(Windows::UI::Xaml::DependencyObject ^ target);

12
src/CalcViewModel/Common/LocalizationSettings.h
View file

@ -60,7 +60,8 @@ namespace CalculatorApp
// Get locale info for List Separator, eg. comma is used in many locales // Get locale info for List Separator, eg. comma is used in many locales
wchar_t listSeparatorString[4] = L""; wchar_t listSeparatorString[4] = L"";
result = ::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SLIST, listSeparatorString, result = ::GetLocaleInfoEx(
LOCALE_NAME_USER_DEFAULT, LOCALE_SLIST, listSeparatorString,
static_cast<int>(std::size(listSeparatorString))); // Max length of the expected return value is 4 static_cast<int>(std::size(listSeparatorString))); // Max length of the expected return value is 4
if (result == 0) if (result == 0)
{ {
@ -68,7 +69,8 @@ namespace CalculatorApp
} }
int currencyTrailingDigits = 0; int currencyTrailingDigits = 0;
result = GetLocaleInfoEx(m_resolvedName.c_str(), LOCALE_ICURRDIGITS | LOCALE_RETURN_NUMBER, (LPWSTR)&currencyTrailingDigits, result = GetLocaleInfoEx(
m_resolvedName.c_str(), LOCALE_ICURRDIGITS | LOCALE_RETURN_NUMBER, (LPWSTR)&currencyTrailingDigits,
sizeof(currencyTrailingDigits) / sizeof(WCHAR)); sizeof(currencyTrailingDigits) / sizeof(WCHAR));
if (result == 0) if (result == 0)
{ {
@ -78,7 +80,8 @@ namespace CalculatorApp
// Currency symbol precedence is either 0 or 1. // Currency symbol precedence is either 0 or 1.
// A value of 0 indicates the symbol follows the currency value. // A value of 0 indicates the symbol follows the currency value.
int currencySymbolPrecedence = 1; int currencySymbolPrecedence = 1;
result = GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_IPOSSYMPRECEDES | LOCALE_RETURN_NUMBER, (LPWSTR)&currencySymbolPrecedence, result = GetLocaleInfoEx(
LOCALE_NAME_USER_DEFAULT, LOCALE_IPOSSYMPRECEDES | LOCALE_RETURN_NUMBER, (LPWSTR)&currencySymbolPrecedence,
sizeof(currencySymbolPrecedence) / sizeof(WCHAR)); sizeof(currencySymbolPrecedence) / sizeof(WCHAR));
// As CalcEngine only supports the first character of the decimal separator, // As CalcEngine only supports the first character of the decimal separator,
@ -101,7 +104,8 @@ namespace CalculatorApp
// Get FirstDayOfWeek Date and Time setting // Get FirstDayOfWeek Date and Time setting
wchar_t day[80] = L""; wchar_t day[80] = L"";
::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, ::GetLocaleInfoEx(
LOCALE_NAME_USER_DEFAULT,
LOCALE_IFIRSTDAYOFWEEK, // The first day in a week LOCALE_IFIRSTDAYOFWEEK, // The first day in a week
reinterpret_cast<PWSTR>(day), // Argument is of type PWSTR reinterpret_cast<PWSTR>(day), // Argument is of type PWSTR
static_cast<int>(std::size(day))); // Max return size are 80 characters static_cast<int>(std::size(day))); // Max return size are 80 characters

36
src/CalcViewModel/Common/NavCategory.cpp
View file

@ -105,8 +105,9 @@ ViewMode NavCategory::Deserialize(Platform::Object ^ obj)
if (boxed != nullptr) if (boxed != nullptr)
{ {
int serializationId = boxed->Value; int serializationId = boxed->Value;
auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [serializationId](const NavCategoryInitializer& initializer) {
[serializationId](const NavCategoryInitializer& initializer) { return initializer.serializationId == serializationId; }); return initializer.serializationId == serializationId;
});
if (iter != s_categoryManifest.end()) if (iter != s_categoryManifest.end())
{ {
@ -144,8 +145,9 @@ bool NavCategory::IsConverterViewMode(ViewMode mode)
bool NavCategory::IsModeInCategoryGroup(ViewMode mode, CategoryGroupType type) bool NavCategory::IsModeInCategoryGroup(ViewMode mode, CategoryGroupType type)
{ {
auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [mode, type](const NavCategoryInitializer& initializer) {
[mode, type](const NavCategoryInitializer& initializer) { return initializer.viewMode == mode && initializer.groupType == type; }); return initializer.viewMode == mode && initializer.groupType == type;
});
return iter != s_categoryManifest.end(); return iter != s_categoryManifest.end();
} }
@ -160,8 +162,9 @@ String ^ NavCategory::GetFriendlyName(ViewMode mode)
ViewMode NavCategory::GetViewModeForFriendlyName(String ^ name) ViewMode NavCategory::GetViewModeForFriendlyName(String ^ name)
{ {
auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [name](const NavCategoryInitializer& initializer) {
[name](const NavCategoryInitializer& initializer) { return wcscmp(initializer.friendlyName, name->Data()) == 0; }); return wcscmp(initializer.friendlyName, name->Data()) == 0;
});
return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None; return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
} }
@ -238,8 +241,9 @@ int NavCategory::GetPosition(ViewMode mode)
ViewMode NavCategory::GetViewModeForVirtualKey(MyVirtualKey virtualKey) ViewMode NavCategory::GetViewModeForVirtualKey(MyVirtualKey virtualKey)
{ {
auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [virtualKey](const NavCategoryInitializer& initializer) {
[virtualKey](const NavCategoryInitializer& initializer) { return initializer.virtualKey == virtualKey; }); return initializer.virtualKey == virtualKey;
});
return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None; return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
} }
@ -285,9 +289,9 @@ NavCategoryGroup::NavCategoryGroup(const NavCategoryGroupInitializer& groupIniti
String ^ categoryAutomationName = ref new String( String ^ categoryAutomationName = ref new String(
LocalizationStringUtil::GetLocalizedString(navCategoryItemAutomationNameFormat->Data(), categoryName->Data(), m_Name->Data()).c_str()); LocalizationStringUtil::GetLocalizedString(navCategoryItemAutomationNameFormat->Data(), categoryName->Data(), m_Name->Data()).c_str());
m_Categories->Append(ref new NavCategory(categoryName, categoryAutomationName, StringReference(categoryInitializer.glyph), m_Categories->Append(ref new NavCategory(
resProvider.GetResourceString(nameResourceKey + "AccessKey"), groupMode, categoryInitializer.viewMode, categoryName, categoryAutomationName, StringReference(categoryInitializer.glyph), resProvider.GetResourceString(nameResourceKey + "AccessKey"),
categoryInitializer.supportsNegative)); groupMode, categoryInitializer.viewMode, categoryInitializer.supportsNegative));
} }
} }
} }
@ -313,16 +317,18 @@ NavCategoryGroup ^ NavCategoryGroup::CreateConverterCategory()
vector<NavCategoryInitializer> NavCategoryGroup::GetInitializerCategoryGroup(CategoryGroupType groupType) vector<NavCategoryInitializer> NavCategoryGroup::GetInitializerCategoryGroup(CategoryGroupType groupType)
{ {
vector<NavCategoryInitializer> initializers{}; vector<NavCategoryInitializer> initializers{};
copy_if(begin(s_categoryManifest), end(s_categoryManifest), back_inserter(initializers), copy_if(begin(s_categoryManifest), end(s_categoryManifest), back_inserter(initializers), [groupType](const NavCategoryInitializer& initializer) {
[groupType](const NavCategoryInitializer& initializer) { return initializer.groupType == groupType; }); return initializer.groupType == groupType;
});
return initializers; return initializers;
} }
String ^ NavCategoryGroup::GetHeaderResourceKey(CategoryGroupType type) String ^ NavCategoryGroup::GetHeaderResourceKey(CategoryGroupType type)
{ {
auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest), auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest), [type](const NavCategoryGroupInitializer& initializer) {
[type](const NavCategoryGroupInitializer& initializer) { return initializer.type == type; }); return initializer.type == type;
});
return (iter != s_categoryGroupManifest.end()) ? StringReference(iter->headerResourceKey) : nullptr; return (iter != s_categoryGroupManifest.end()) ? StringReference(iter->headerResourceKey) : nullptr;
} }

8
src/CalcViewModel/Common/NavCategory.h
View file

@ -58,8 +58,9 @@ namespace CalculatorApp
private private
struct NavCategoryInitializer struct NavCategoryInitializer
{ {
constexpr NavCategoryInitializer(ViewMode mode, int id, wchar_t const* name, wchar_t const* nameKey, wchar_t const* glyph, CategoryGroupType group, constexpr NavCategoryInitializer(
MyVirtualKey vKey, bool categorySupportsNegative) ViewMode mode, int id, wchar_t const* name, wchar_t const* nameKey, wchar_t const* glyph, CategoryGroupType group, MyVirtualKey vKey,
bool categorySupportsNegative)
: viewMode(mode) : viewMode(mode)
, serializationId(id) , serializationId(id)
, friendlyName(name) , friendlyName(name)
@ -161,7 +162,8 @@ namespace CalculatorApp
static ViewMode GetViewModeForVirtualKey(MyVirtualKey virtualKey); static ViewMode GetViewModeForVirtualKey(MyVirtualKey virtualKey);
internal : NavCategory(Platform::String ^ name, Platform::String ^ automationName, Platform::String ^ glyph, Platform::String ^ accessKey, internal : NavCategory(
Platform::String ^ name, Platform::String ^ automationName, Platform::String ^ glyph, Platform::String ^ accessKey,
Platform::String ^ mode, ViewMode viewMode, bool supportsNegative) Platform::String ^ mode, ViewMode viewMode, bool supportsNegative)
: m_name(name) : m_name(name)
, m_automationName(automationName) , m_automationName(automationName)

6
src/CalcViewModel/Common/TraceActivity.h
View file

@ -15,14 +15,16 @@ namespace CalculatorApp
{ {
} }
TraceActivity(winrt::Windows::Foundation::Diagnostics::LoggingChannel channel, std::wstring_view activityName, TraceActivity(
winrt::Windows::Foundation::Diagnostics::LoggingChannel channel, std::wstring_view activityName,
winrt::Windows::Foundation::Diagnostics::LoggingFields fields) winrt::Windows::Foundation::Diagnostics::LoggingFields fields)
: m_channel(channel), m_activityName(activityName), m_fields(fields), m_activity(nullptr) : m_channel(channel), m_activityName(activityName), m_fields(fields), m_activity(nullptr)
{ {
// Write the activity's START event. Note that you must not specify keyword // Write the activity's START event. Note that you must not specify keyword
// or level for START and STOP events because they always use the activity's // or level for START and STOP events because they always use the activity's
// keyword and level. // keyword and level.
m_activity = m_channel.StartActivity(m_activityName, m_fields, winrt::Windows::Foundation::Diagnostics::LoggingLevel::Verbose, m_activity = m_channel.StartActivity(
m_activityName, m_fields, winrt::Windows::Foundation::Diagnostics::LoggingLevel::Verbose,
winrt::Windows::Foundation::Diagnostics::LoggingOptions(WINEVENT_KEYWORD_RESPONSE_TIME)); winrt::Windows::Foundation::Diagnostics::LoggingOptions(WINEVENT_KEYWORD_RESPONSE_TIME));
} }

4
src/CalcViewModel/Common/TraceLogger.cpp
View file

@ -607,8 +607,8 @@ namespace CalculatorApp
} }
} }
void TraceLogger::LogMemoryUsed(int windowId, unsigned int slotPosition, bool isStandard, bool isScientific, bool isProgrammer, void
unsigned int memorySize) const TraceLogger::LogMemoryUsed(int windowId, unsigned int slotPosition, bool isStandard, bool isScientific, bool isProgrammer, unsigned int memorySize) const
{ {
if (!GetTraceLoggingProviderEnabled()) if (!GetTraceLoggingProviderEnabled())
return; return;

4
src/CalcViewModel/Common/TraceLogger.h
View file

@ -96,8 +96,8 @@ namespace CalculatorApp
// Trace methods for Date Calculator usage // Trace methods for Date Calculator usage
void LogDateDifferenceModeUsed(int windowId); void LogDateDifferenceModeUsed(int windowId);
void LogDateAddSubtractModeUsed(int windowId, bool isAddMode); void LogDateAddSubtractModeUsed(int windowId, bool isAddMode);
void LogDateClippedTimeDifferenceFound(winrt::Windows::Globalization::Calendar const& today, void
winrt::Windows::Foundation::DateTime const& clippedTime) const; LogDateClippedTimeDifferenceFound(winrt::Windows::Globalization::Calendar const& today, winrt::Windows::Foundation::DateTime const& clippedTime) const;
void LogStandardException(std::wstring_view functionName, _In_ const std::exception& e) const; void LogStandardException(std::wstring_view functionName, _In_ const std::exception& e) const;
void LogWinRTException(std::wstring_view functionName, _In_ winrt::hresult_error const& e) const; void LogWinRTException(std::wstring_view functionName, _In_ winrt::hresult_error const& e) const;

5
src/CalcViewModel/Common/Utils.cpp
View file

@ -92,8 +92,9 @@ wstring Utils::RemoveUnwantedCharsFromWstring(wstring input, wchar_t* unwantedCh
return input; return input;
} }
void Utils::SerializeCommandsAndTokens(_In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, void Utils::SerializeCommandsAndTokens(
_In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands, DataWriter ^ writer) _In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands,
DataWriter ^ writer)
{ {
unsigned int commandsSize; unsigned int commandsSize;
IFTPlatformException(commands->GetSize(&commandsSize)); IFTPlatformException(commands->GetSize(&commandsSize));

38
src/CalcViewModel/Common/Utils.h
View file

@ -23,8 +23,10 @@
m_##n = value; \ m_##n = value; \
} \ } \
} \ } \
\
private: \ private: \
t m_##n; \ t m_##n; \
\
public: public:
#define PROPERTY_RW(t, n) \ #define PROPERTY_RW(t, n) \
@ -39,8 +41,10 @@ public:
m_##n = value; \ m_##n = value; \
} \ } \
} \ } \
\
private: \ private: \
t m_##n; \ t m_##n; \
\
public: public:
#define OBSERVABLE_PROPERTY_R(t, n) \ #define OBSERVABLE_PROPERTY_R(t, n) \
@ -61,8 +65,10 @@ public:
} \ } \
} \ } \
} \ } \
\
private: \ private: \
t m_##n; \ t m_##n; \
\
public: public:
#define OBSERVABLE_PROPERTY_RW(t, n) \ #define OBSERVABLE_PROPERTY_RW(t, n) \
@ -81,8 +87,10 @@ public:
} \ } \
} \ } \
} \ } \
\
private: \ private: \
t m_##n; \ t m_##n; \
\
public: public:
#define OBSERVABLE_NAMED_PROPERTY_R(t, n) \ #define OBSERVABLE_NAMED_PROPERTY_R(t, n) \
@ -92,6 +100,7 @@ public:
{ \ { \
Platform::String ^ get() { return Platform::StringReference(L#n); } \ Platform::String ^ get() { return Platform::StringReference(L#n); } \
} \ } \
\
public: public:
#define OBSERVABLE_NAMED_PROPERTY_RW(t, n) \ #define OBSERVABLE_NAMED_PROPERTY_RW(t, n) \
@ -101,6 +110,7 @@ public:
{ \ { \
Platform::String ^ get() { return Platform::StringReference(L#n); } \ Platform::String ^ get() { return Platform::StringReference(L#n); } \
} \ } \
\
public: public:
#define OBSERVABLE_PROPERTY_FIELD(n) m_##n #define OBSERVABLE_PROPERTY_FIELD(n) m_##n
@ -114,6 +124,7 @@ public:
{ \ { \
PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); \ PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); \
} \ } \
\
public: public:
#else #else
#define OBSERVABLE_OBJECT() \ #define OBSERVABLE_OBJECT() \
@ -122,6 +133,7 @@ public:
void RaisePropertyChanged(Platform::String ^ p) \ void RaisePropertyChanged(Platform::String ^ p) \
{ \ { \
} \ } \
\
public: public:
#endif #endif
@ -136,6 +148,7 @@ public:
PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); \ PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); \
c(p); \ c(p); \
} \ } \
\
public: public:
#else #else
#define OBSERVABLE_OBJECT_CALLBACK(c) \ #define OBSERVABLE_OBJECT_CALLBACK(c) \
@ -145,6 +158,7 @@ public:
{ \ { \
c(p); \ c(p); \
} \ } \
\
public: public:
#endif #endif
@ -156,6 +170,7 @@ public:
if (!donotuse_##p) {\ if (!donotuse_##p) {\
donotuse_##p = CalculatorApp::Common::MakeDelegate(this, &m);\ donotuse_##p = CalculatorApp::Common::MakeDelegate(this, &m);\
} return donotuse_##p; }} private: Windows::UI::Xaml::Input::ICommand^ donotuse_##p; \ } return donotuse_##p; }} private: Windows::UI::Xaml::Input::ICommand^ donotuse_##p; \
\
public: public:
#define DEPENDENCY_PROPERTY_DECLARATION(t, n) \ #define DEPENDENCY_PROPERTY_DECLARATION(t, n) \
@ -173,6 +188,7 @@ public:
\ \
private: \ private: \
static Windows::UI::Xaml::DependencyProperty ^ s_##n##Property; \ static Windows::UI::Xaml::DependencyProperty ^ s_##n##Property; \
\
public: public:
// Utilities for DependencyProperties // Utilities for DependencyProperties
@ -368,9 +384,9 @@ namespace Utils
double GetDoubleFromWstring(std::wstring input); double GetDoubleFromWstring(std::wstring input);
int GetWindowId(); int GetWindowId();
void RunOnUIThreadNonblocking(std::function<void()>&& function, _In_ Windows::UI::Core::CoreDispatcher ^ currentDispatcher); void RunOnUIThreadNonblocking(std::function<void()>&& function, _In_ Windows::UI::Core::CoreDispatcher ^ currentDispatcher);
void SerializeCommandsAndTokens(_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SerializeCommandsAndTokens(
_In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands, _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
Windows::Storage::Streams::DataWriter ^ writer); _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands, Windows::Storage::Streams::DataWriter ^ writer);
const std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> DeserializeCommands(Windows::Storage::Streams::DataReader ^ reader); const std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> DeserializeCommands(Windows::Storage::Streams::DataReader ^ reader);
const std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> DeserializeTokens(Windows::Storage::Streams::DataReader ^ reader); const std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> DeserializeTokens(Windows::Storage::Streams::DataReader ^ reader);
@ -378,7 +394,8 @@ namespace Utils
Windows::Foundation::DateTime GetUniversalSystemTime(); Windows::Foundation::DateTime GetUniversalSystemTime();
bool IsDateTimeOlderThan(Windows::Foundation::DateTime dateTime, const long long duration); bool IsDateTimeOlderThan(Windows::Foundation::DateTime dateTime, const long long duration);
concurrency::task<void> WriteFileToFolder(Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName, Platform::String ^ contents, concurrency::task<void> WriteFileToFolder(
Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName, Platform::String ^ contents,
Windows::Storage::CreationCollisionOption collisionOption); Windows::Storage::CreationCollisionOption collisionOption);
concurrency::task<Platform::String ^> ReadFileFromFolder(Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName); concurrency::task<Platform::String ^> ReadFileFromFolder(Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName);
} }
@ -387,6 +404,7 @@ namespace Utils
#define DEPENDENCY_PROPERTY_OWNER(owner) \ #define DEPENDENCY_PROPERTY_OWNER(owner) \
private: \ private: \
typedef owner DependencyPropertiesOwner; \ typedef owner DependencyPropertiesOwner; \
\
public: public:
// Normal DependencyProperty // Normal DependencyProperty
@ -402,6 +420,7 @@ public:
SetValue(s_##name##Property, value); \ SetValue(s_##name##Property, value); \
} \ } \
} \ } \
\
private: \ private: \
static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \ static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \
\ \
@ -419,6 +438,7 @@ private:
{ \ { \
return Utils::RegisterDependencyProperty<DependencyPropertiesOwner, type>(L#name); \ return Utils::RegisterDependencyProperty<DependencyPropertiesOwner, type>(L#name); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_WITH_DEFAULT(type, name, defaultValue) \ #define DEPENDENCY_PROPERTY_WITH_DEFAULT(type, name, defaultValue) \
@ -433,6 +453,7 @@ public:
SetValue(s_##name##Property, value); \ SetValue(s_##name##Property, value); \
} \ } \
} \ } \
\
private: \ private: \
static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \ static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \
\ \
@ -450,6 +471,7 @@ private:
{ \ { \
return Utils::RegisterDependencyProperty<DependencyPropertiesOwner, type>(L#name, defaultValue); \ return Utils::RegisterDependencyProperty<DependencyPropertiesOwner, type>(L#name, defaultValue); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_WITH_CALLBACK(type, name) \ #define DEPENDENCY_PROPERTY_WITH_CALLBACK(type, name) \
@ -464,6 +486,7 @@ public:
SetValue(s_##name##Property, value); \ SetValue(s_##name##Property, value); \
} \ } \
} \ } \
\
private: \ private: \
static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \ static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \
\ \
@ -486,6 +509,7 @@ private:
auto self = safe_cast<DependencyPropertiesOwner ^>(sender); \ auto self = safe_cast<DependencyPropertiesOwner ^>(sender); \
self->On##name##PropertyChanged(safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \ self->On##name##PropertyChanged(safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(type, name, defaultValue) \ #define DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(type, name, defaultValue) \
@ -500,6 +524,7 @@ public:
SetValue(s_##name##Property, value); \ SetValue(s_##name##Property, value); \
} \ } \
} \ } \
\
private: \ private: \
static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \ static Windows::UI::Xaml::DependencyProperty ^ s_##name##Property; \
\ \
@ -522,6 +547,7 @@ private:
auto self = safe_cast<DependencyPropertiesOwner ^>(sender); \ auto self = safe_cast<DependencyPropertiesOwner ^>(sender); \
self->On##name##PropertyChanged(safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \ self->On##name##PropertyChanged(safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \
} \ } \
\
public: public:
// Attached DependencyProperty // Attached DependencyProperty
@ -552,6 +578,7 @@ private:
{ \ { \
return Utils::RegisterDependencyPropertyAttached<DependencyPropertiesOwner, type>(L#name); \ return Utils::RegisterDependencyPropertyAttached<DependencyPropertiesOwner, type>(L#name); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_ATTACHED_WITH_DEFAULT(type, name, defaultValue) \ #define DEPENDENCY_PROPERTY_ATTACHED_WITH_DEFAULT(type, name, defaultValue) \
@ -581,6 +608,7 @@ private:
{ \ { \
return Utils::RegisterDependencyPropertyAttached<DependencyPropertiesOwner, type>(L#name, defaultValue); \ return Utils::RegisterDependencyPropertyAttached<DependencyPropertiesOwner, type>(L#name, defaultValue); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_ATTACHED_WITH_CALLBACK(type, name) \ #define DEPENDENCY_PROPERTY_ATTACHED_WITH_CALLBACK(type, name) \
@ -614,6 +642,7 @@ private:
{ \ { \
On##name##PropertyChanged(sender, safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \ On##name##PropertyChanged(sender, safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \
} \ } \
\
public: public:
#define DEPENDENCY_PROPERTY_ATTACHED_WITH_DEFAULT_AND_CALLBACK(type, name, defaultValue) \ #define DEPENDENCY_PROPERTY_ATTACHED_WITH_DEFAULT_AND_CALLBACK(type, name, defaultValue) \
@ -647,6 +676,7 @@ private:
{ \ { \
On##name##PropertyChanged(sender, safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \ On##name##PropertyChanged(sender, safe_cast<type>(args->OldValue), safe_cast<type>(args->NewValue)); \
} \ } \
\
public: public:
// This goes into the cpp to initialize the static variable // This goes into the cpp to initialize the static variable

12
src/CalcViewModel/Common/ValidatingConverters.h
View file

@ -17,7 +17,8 @@ namespace CalculatorApp
private: private:
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ Convert(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
{ {
// Pass through as we don't want to change the value from the source // Pass through as we don't want to change the value from the source
@ -25,7 +26,8 @@ namespace CalculatorApp
} }
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ ConvertBack(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
{ {
if (value) if (value)
@ -47,7 +49,8 @@ namespace CalculatorApp
private: private:
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ Convert(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
{ {
// Pass through as we don't want to change the value from the source // Pass through as we don't want to change the value from the source
@ -55,7 +58,8 @@ namespace CalculatorApp
} }
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ ConvertBack(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
{ {
// The value to be valid has to be a boxed int32 value // The value to be valid has to be a boxed int32 value

8
src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp
View file

@ -275,8 +275,8 @@ pair<wstring, wstring> CurrencyDataLoader::GetCurrencyRatioEquality(_In_ const U
wstring digitSymbol = wstring{ LocalizationSettings::GetInstance().GetDigitSymbolFromEnUsDigit(L'1') }; wstring digitSymbol = wstring{ LocalizationSettings::GetInstance().GetDigitSymbolFromEnUsDigit(L'1') };
wstring roundedFormat = m_ratioFormatter->Format(rounded)->Data(); wstring roundedFormat = m_ratioFormatter->Format(rounded)->Data();
wstring ratioString = LocalizationStringUtil::GetLocalizedString(m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.abbreviation.c_str(), wstring ratioString = LocalizationStringUtil::GetLocalizedString(
roundedFormat.c_str(), unit2.abbreviation.c_str()); m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.abbreviation.c_str(), roundedFormat.c_str(), unit2.abbreviation.c_str());
wstring accessibleRatioString = LocalizationStringUtil::GetLocalizedString( wstring accessibleRatioString = LocalizationStringUtil::GetLocalizedString(
m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.accessibleName.c_str(), roundedFormat.c_str(), unit2.accessibleName.c_str()); m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.accessibleName.c_str(), roundedFormat.c_str(), unit2.accessibleName.c_str());
@ -459,8 +459,8 @@ task<bool> CurrencyDataLoader::TryLoadDataFromWebOverrideAsync()
}; };
#pragma optimize("", on) #pragma optimize("", on)
bool CurrencyDataLoader::TryParseWebResponses(_In_ String ^ staticDataJson, _In_ String ^ allRatiosJson, _Inout_ vector<UCM::CurrencyStaticData>& staticData, bool CurrencyDataLoader::TryParseWebResponses(
_Inout_ CurrencyRatioMap& allRatiosData) _In_ String ^ staticDataJson, _In_ String ^ allRatiosJson, _Inout_ vector<UCM::CurrencyStaticData>& staticData, _Inout_ CurrencyRatioMap& allRatiosData)
{ {
return TryParseStaticData(staticDataJson, staticData) && TryParseAllRatiosData(allRatiosJson, allRatiosData); return TryParseStaticData(staticDataJson, staticData) && TryParseAllRatiosData(allRatiosJson, allRatiosData);
} }

9
src/CalcViewModel/DataLoaders/CurrencyDataLoader.h
View file

@ -71,8 +71,8 @@ namespace CalculatorApp
// ICurrencyConverterDataLoader // ICurrencyConverterDataLoader
void SetViewModelCallback(const std::shared_ptr<UCM::IViewModelCurrencyCallback>& callback) override; void SetViewModelCallback(const std::shared_ptr<UCM::IViewModelCurrencyCallback>& callback) override;
std::pair<std::wstring, std::wstring> GetCurrencySymbols(const UCM::Unit& unit1, const UCM::Unit& unit2) override; std::pair<std::wstring, std::wstring> GetCurrencySymbols(const UCM::Unit& unit1, const UCM::Unit& unit2) override;
std::pair<std::wstring, std::wstring> GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, std::pair<std::wstring, std::wstring>
_In_ const UnitConversionManager::Unit& unit2) override; GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) override;
std::wstring GetCurrencyTimestamp() override; std::wstring GetCurrencyTimestamp() override;
concurrency::task<bool> TryLoadDataFromCacheAsync() override; concurrency::task<bool> TryLoadDataFromCacheAsync() override;
@ -88,8 +88,9 @@ namespace CalculatorApp
concurrency::task<bool> TryFinishLoadFromCacheAsync(); concurrency::task<bool> TryFinishLoadFromCacheAsync();
bool TryParseWebResponses(_In_ Platform::String ^ staticDataJson, _In_ Platform::String ^ allRatiosJson, bool TryParseWebResponses(
_Inout_ std::vector<UCM::CurrencyStaticData>& staticData, _Inout_ CurrencyRatioMap& allRatiosData); _In_ Platform::String ^ staticDataJson, _In_ Platform::String ^ allRatiosJson, _Inout_ std::vector<UCM::CurrencyStaticData>& staticData,
_Inout_ CurrencyRatioMap& allRatiosData);
bool TryParseStaticData(_In_ Platform::String ^ rawJson, _Inout_ std::vector<UCM::CurrencyStaticData>& staticData); bool TryParseStaticData(_In_ Platform::String ^ rawJson, _Inout_ std::vector<UCM::CurrencyStaticData>& staticData);
bool TryParseAllRatiosData(_In_ Platform::String ^ rawJson, _Inout_ CurrencyRatioMap& allRatiosData); bool TryParseAllRatiosData(_In_ Platform::String ^ rawJson, _Inout_ CurrencyRatioMap& allRatiosData);
concurrency::task<void> FinalizeUnits(_In_ const std::vector<UCM::CurrencyStaticData>& staticData, _In_ const CurrencyRatioMap& ratioMap); concurrency::task<void> FinalizeUnits(_In_ const std::vector<UCM::CurrencyStaticData>& staticData, _In_ const CurrencyRatioMap& ratioMap);

5
src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp
View file

@ -53,8 +53,9 @@ bool UnitConverterDataLoader::SupportsCategory(const UCM::Category& target)
} }
static int currencyId = NavCategory::Serialize(ViewMode::Currency); static int currencyId = NavCategory::Serialize(ViewMode::Currency);
auto itr = find_if(supportedCategories->begin(), supportedCategories->end(), auto itr = find_if(supportedCategories->begin(), supportedCategories->end(), [&](const UCM::Category& category) {
[&](const UCM::Category& category) { return currencyId != category.id && target.id == category.id; }); return currencyId != category.id && target.id == category.id;
});
return itr != supportedCategories->end(); return itr != supportedCategories->end();
} }

7
src/CalcViewModel/DataLoaders/UnitConverterDataLoader.h
View file

@ -16,7 +16,8 @@ namespace CalculatorApp
{ {
} }
OrderedUnit(int id, std::wstring name, std::wstring abbreviation, int order, bool isConversionSource = false, bool isConversionTarget = false, OrderedUnit(
int id, std::wstring name, std::wstring abbreviation, int order, bool isConversionSource = false, bool isConversionTarget = false,
bool isWhimsical = false) bool isWhimsical = false)
: UnitConversionManager::Unit(id, name, abbreviation, isConversionSource, isConversionTarget, isWhimsical), order(order) : UnitConversionManager::Unit(id, name, abbreviation, isConversionSource, isConversionTarget, isWhimsical), order(order)
{ {
@ -37,8 +38,8 @@ namespace CalculatorApp
ExplicitUnitConversionData() ExplicitUnitConversionData()
{ {
} }
ExplicitUnitConversionData(CalculatorApp::Common::ViewMode categoryId, int parentUnitId, int unitId, double ratio, double offset, ExplicitUnitConversionData(
bool offsetFirst = false) CalculatorApp::Common::ViewMode categoryId, int parentUnitId, int unitId, double ratio, double offset, bool offsetFirst = false)
: categoryId(categoryId), parentUnitId(parentUnitId), unitId(unitId), UnitConversionManager::ConversionData(ratio, offset, offsetFirst) : categoryId(categoryId), parentUnitId(parentUnitId), unitId(unitId), UnitConversionManager::ConversionData(ratio, offset, offsetFirst)
{ {
} }

8
src/CalcViewModel/DateCalculatorViewModel.cpp
View file

@ -105,8 +105,9 @@ void DateCalculatorViewModel::OnPropertyChanged(_In_ String ^ prop)
{ {
UpdateStrDateResultAutomationName(); UpdateStrDateResultAutomationName();
} }
else if (prop != StrDateDiffResultAutomationNamePropertyName && prop != StrDateDiffResultInDaysPropertyName else if (
&& prop != StrDateResultAutomationNamePropertyName && prop != IsDiffInDaysPropertyName) prop != StrDateDiffResultAutomationNamePropertyName && prop != StrDateDiffResultInDaysPropertyName && prop != StrDateResultAutomationNamePropertyName
&& prop != IsDiffInDaysPropertyName)
{ {
OnInputsChanged(); OnInputsChanged();
} }
@ -216,7 +217,8 @@ void DateCalculatorViewModel::UpdateStrDateResultAutomationName()
void DateCalculatorViewModel::InitializeDateOutputFormats(_In_ String ^ calendarIdentifier) void DateCalculatorViewModel::InitializeDateOutputFormats(_In_ String ^ calendarIdentifier)
{ {
// Format for Add/Subtract days // Format for Add/Subtract days
m_dateTimeFormatter = LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(L"longdate", calendarIdentifier, m_dateTimeFormatter = LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(
L"longdate", calendarIdentifier,
ClockIdentifiers::TwentyFourHour); // Clock Identifier is not used ClockIdentifiers::TwentyFourHour); // Clock Identifier is not used
// Format for Date Difference // Format for Date Difference

7
src/CalcViewModel/HistoryItemViewModel.cpp
View file

@ -10,7 +10,8 @@ using namespace CalculatorApp::ViewModel;
using namespace std; using namespace std;
using namespace Platform; using namespace Platform;
HistoryItemViewModel::HistoryItemViewModel(String ^ expression, String ^ result, _In_ const shared_ptr<CalculatorVector<pair<wstring, int>>>& spTokens, HistoryItemViewModel::HistoryItemViewModel(
String ^ expression, String ^ result, _In_ const shared_ptr<CalculatorVector<pair<wstring, int>>>& spTokens,
_In_ const shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>>& spCommands) _In_ const shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>>& spCommands)
: m_expression(expression), m_result(result), m_spTokens(spTokens), m_spCommands(spCommands) : m_expression(expression), m_result(result), m_spTokens(spTokens), m_spCommands(spCommands)
{ {
@ -20,8 +21,8 @@ HistoryItemViewModel::HistoryItemViewModel(String ^ expression, String ^ result,
} }
String String
^ HistoryItemViewModel::GetAccessibleExpressionFromTokens(_In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& spTokens, ^ HistoryItemViewModel::GetAccessibleExpressionFromTokens(
_In_ String ^ fallbackExpression) _In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& spTokens, _In_ String ^ fallbackExpression)
{ {
// updating accessibility names for expression and result // updating accessibility names for expression and result
wstringstream accExpression{}; wstringstream accExpression{};

7
src/CalcViewModel/HistoryItemViewModel.h
View file

@ -14,7 +14,8 @@ namespace CalculatorApp
{ {
internal : internal :
HistoryItemViewModel(Platform::String ^ expression, Platform::String ^ result, HistoryItemViewModel(
Platform::String ^ expression, Platform::String ^ result,
_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens, _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens,
_In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& spCommands); _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& spCommands);
@ -59,8 +60,8 @@ namespace CalculatorApp
^ GetStringRepresentation() { return m_accExpression + " " + m_accResult; } ^ GetStringRepresentation() { return m_accExpression + " " + m_accResult; }
private : static Platform::String private : static Platform::String
^ GetAccessibleExpressionFromTokens(_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens, ^ GetAccessibleExpressionFromTokens(
_In_ Platform::String ^ fallbackExpression); _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens, _In_ Platform::String ^ fallbackExpression);
private: private:
Platform::String ^ m_expression; Platform::String ^ m_expression;

17
src/CalcViewModel/HistoryViewModel.cpp
View file

@ -69,8 +69,9 @@ void HistoryViewModel::ReloadHistory(_In_ ViewMode currentMode)
localizer.LocalizeDisplayValue(&expression); localizer.LocalizeDisplayValue(&expression);
localizer.LocalizeDisplayValue(&result); localizer.LocalizeDisplayValue(&result);
auto item = ref new HistoryItemViewModel(ref new Platform::String(expression.c_str()), ref new Platform::String(result.c_str()), auto item = ref new HistoryItemViewModel(
(*ritr)->historyItemVector.spTokens, (*ritr)->historyItemVector.spCommands); ref new Platform::String(expression.c_str()), ref new Platform::String(result.c_str()), (*ritr)->historyItemVector.spTokens,
(*ritr)->historyItemVector.spCommands);
historyListVM->Append(item); historyListVM->Append(item);
} }
} }
@ -87,8 +88,9 @@ void HistoryViewModel::OnHistoryItemAdded(_In_ unsigned int addedItemIndex)
wstring result = newItem->historyItemVector.result; wstring result = newItem->historyItemVector.result;
localizer.LocalizeDisplayValue(&expression); localizer.LocalizeDisplayValue(&expression);
localizer.LocalizeDisplayValue(&result); localizer.LocalizeDisplayValue(&result);
auto item = ref new HistoryItemViewModel(ref new Platform::String(expression.c_str()), ref new Platform::String(result.c_str()), auto item = ref new HistoryItemViewModel(
newItem->historyItemVector.spTokens, newItem->historyItemVector.spCommands); ref new Platform::String(expression.c_str()), ref new Platform::String(result.c_str()), newItem->historyItemVector.spTokens,
newItem->historyItemVector.spCommands);
// check if we have not hit the max items // check if we have not hit the max items
if (Items->Size >= m_calculatorManager->MaxHistorySize()) if (Items->Size >= m_calculatorManager->MaxHistorySize())
@ -310,8 +312,8 @@ Platform::String ^ HistoryViewModel::SerializeHistoryItem(_In_ std::shared_ptr<C
return CryptographicBuffer::EncodeToBase64String(buffer); return CryptographicBuffer::EncodeToBase64String(buffer);
} }
CalculationManager::HISTORYITEM HistoryViewModel::DeserializeHistoryItem(_In_ Platform::String ^ historyItemKey, CalculationManager::HISTORYITEM
_In_ ApplicationDataContainer ^ historyContainer) HistoryViewModel::DeserializeHistoryItem(_In_ Platform::String ^ historyItemKey, _In_ ApplicationDataContainer ^ historyContainer)
{ {
CalculationManager::HISTORYITEM historyItem; CalculationManager::HISTORYITEM historyItem;
if (historyContainer->Values->HasKey(historyItemKey)) if (historyContainer->Values->HasKey(historyItemKey))
@ -352,7 +354,8 @@ CalculationManager::HISTORYITEM HistoryViewModel::DeserializeHistoryItem(_In_ Pl
bool HistoryViewModel::IsValid(_In_ CalculationManager::HISTORYITEM item) bool HistoryViewModel::IsValid(_In_ CalculationManager::HISTORYITEM item)
{ {
return (!item.historyItemVector.expression.empty() && !item.historyItemVector.result.empty() && (bool)item.historyItemVector.spCommands return (
!item.historyItemVector.expression.empty() && !item.historyItemVector.result.empty() && (bool)item.historyItemVector.spCommands
&& (bool)item.historyItemVector.spTokens); && (bool)item.historyItemVector.spTokens);
} }

4
src/CalcViewModel/HistoryViewModel.h
View file

@ -60,8 +60,8 @@ namespace CalculatorApp
Platform::String ^ m_localizedHistoryCleared; Platform::String ^ m_localizedHistoryCleared;
void RestoreHistory(_In_ CalculationManager::CALCULATOR_MODE cMode); void RestoreHistory(_In_ CalculationManager::CALCULATOR_MODE cMode);
CalculationManager::HISTORYITEM DeserializeHistoryItem(_In_ Platform::String ^ historyItemKey, CalculationManager::HISTORYITEM
_In_ Windows::Storage::ApplicationDataContainer ^ historyContainer); DeserializeHistoryItem(_In_ Platform::String ^ historyItemKey, _In_ Windows::Storage::ApplicationDataContainer ^ historyContainer);
Windows::Storage::ApplicationDataContainer ^ GetHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode); Windows::Storage::ApplicationDataContainer ^ GetHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode);
Platform::String ^ GetHistoryContainerKey(_In_ CalculationManager::CALCULATOR_MODE cMode); Platform::String ^ GetHistoryContainerKey(_In_ CalculationManager::CALCULATOR_MODE cMode);
void ClearHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode); void ClearHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode);

22
src/CalcViewModel/StandardCalculatorViewModel.cpp
View file

@ -235,9 +235,9 @@ void StandardCalculatorViewModel::SetOpenParenthesisCountNarratorAnnouncement()
wstring localizedParenthesisCount = to_wstring(m_OpenParenthesisCount).c_str(); wstring localizedParenthesisCount = to_wstring(m_OpenParenthesisCount).c_str();
LocalizationSettings::GetInstance().LocalizeDisplayValue(&localizedParenthesisCount); LocalizationSettings::GetInstance().LocalizeDisplayValue(&localizedParenthesisCount);
String ^ announcement = String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::OpenParenthesisCountAutomationFormat, CalculatorResourceKeys::OpenParenthesisCountAutomationFormat, m_localizedOpenParenthesisCountChangedAutomationFormat,
m_localizedOpenParenthesisCountChangedAutomationFormat, localizedParenthesisCount.c_str()); localizedParenthesisCount.c_str());
Announcement = CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(announcement); Announcement = CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(announcement);
} }
@ -283,7 +283,8 @@ void StandardCalculatorViewModel::DisableButtons(CommandType selectedExpressionC
} }
} }
void StandardCalculatorViewModel::SetExpressionDisplay(_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, void StandardCalculatorViewModel::SetExpressionDisplay(
_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
_Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands) _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
{ {
m_tokens = tokens; m_tokens = tokens;
@ -298,7 +299,8 @@ void StandardCalculatorViewModel::SetExpressionDisplay(_Inout_ shared_ptr<Calcul
AreTokensUpdated = true; AreTokensUpdated = true;
} }
void StandardCalculatorViewModel::SetHistoryExpressionDisplay(_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens, void StandardCalculatorViewModel::SetHistoryExpressionDisplay(
_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
_Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands) _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
{ {
m_tokens = make_shared<CalculatorVector<pair<wstring, int>>>(*tokens); m_tokens = make_shared<CalculatorVector<pair<wstring, int>>>(*tokens);
@ -1035,8 +1037,8 @@ void StandardCalculatorViewModel::OnMemoryButtonPressed()
int windowId = Utils::GetWindowId(); int windowId = Utils::GetWindowId();
TraceLogger::GetInstance().InsertIntoMemoryMap(windowId, IsStandard, IsScientific, IsProgrammer); TraceLogger::GetInstance().InsertIntoMemoryMap(windowId, IsStandard, IsScientific, IsProgrammer);
String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::MemorySave, m_localizedMemorySavedAutomationFormat, String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
m_DisplayValue->Data()); CalculatorResourceKeys::MemorySave, m_localizedMemorySavedAutomationFormat, m_DisplayValue->Data());
Announcement = CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(announcement); Announcement = CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(announcement);
} }
@ -1957,9 +1959,9 @@ NarratorAnnouncement ^ StandardCalculatorViewModel::GetDisplayUpdatedNarratorAnn
} }
else else
{ {
announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::ButtonPressFeedbackFormat, announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
m_localizedButtonPressFeedbackAutomationFormat, CalculatorResourceKeys::ButtonPressFeedbackFormat, m_localizedButtonPressFeedbackAutomationFormat, m_CalculationResultAutomationName->Data(),
m_CalculationResultAutomationName->Data(), m_feedbackForButtonPress->Data()); m_feedbackForButtonPress->Data());
} }
// Make sure we don't accidentally repeat an announcement. // Make sure we don't accidentally repeat an announcement.

6
src/CalcViewModel/StandardCalculatorViewModel.h
View file

@ -334,9 +334,11 @@ namespace CalculatorApp
void SetPrimaryDisplay(_In_ std::wstring const& displayString, _In_ bool isError); void SetPrimaryDisplay(_In_ std::wstring const& displayString, _In_ bool isError);
void DisplayPasteError(); void DisplayPasteError();
void SetTokens(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens); void SetTokens(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens);
void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands); _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands);
void SetHistoryExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SetHistoryExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands); _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands);
void SetParenthesisCount(_In_ unsigned int parenthesisCount); void SetParenthesisCount(_In_ unsigned int parenthesisCount);
void SetOpenParenthesisCountNarratorAnnouncement(); void SetOpenParenthesisCountNarratorAnnouncement();

9
src/CalcViewModel/UnitConverterViewModel.cpp
View file

@ -1010,11 +1010,12 @@ String ^ UnitConverterViewModel::GetLocalizedAutomationName(_In_ String ^ displa
} }
String String
^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(_In_ String ^ fromValue, _In_ String ^ fromUnit, _In_ String ^ toValue, ^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(
_In_ String ^ toUnit) _In_ String ^ fromValue, _In_ String ^ fromUnit, _In_ String ^ toValue, _In_ String ^ toUnit)
{ {
String ^ localizedString = ref new String(LocalizationStringUtil::GetLocalizedString(m_localizedConversionResultFormat->Data(), fromValue->Data(), String ^ localizedString =
fromUnit->Data(), toValue->Data(), toUnit->Data()) ref new String(LocalizationStringUtil::GetLocalizedString(
m_localizedConversionResultFormat->Data(), fromValue->Data(), fromUnit->Data(), toValue->Data(), toUnit->Data())
.c_str()); .c_str());
return localizedString; return localizedString;
} }

4
src/CalcViewModel/UnitConverterViewModel.h
View file

@ -207,8 +207,8 @@ namespace CalculatorApp
Platform::String Platform::String
^ GetLocalizedAutomationName(_In_ Platform::String ^ displayvalue, _In_ Platform::String ^ unitname, _In_ Platform::String ^ format); ^ GetLocalizedAutomationName(_In_ Platform::String ^ displayvalue, _In_ Platform::String ^ unitname, _In_ Platform::String ^ format);
Platform::String Platform::String
^ GetLocalizedConversionResultStringFormat(_In_ Platform::String ^ fromValue, _In_ Platform::String ^ fromUnit, _In_ Platform::String ^ toValue, ^ GetLocalizedConversionResultStringFormat(
_In_ Platform::String ^ toUnit); _In_ Platform::String ^ fromValue, _In_ Platform::String ^ fromUnit, _In_ Platform::String ^ toValue, _In_ Platform::String ^ toUnit);
void UpdateValue1AutomationName(); void UpdateValue1AutomationName();
void UpdateValue2AutomationName(); void UpdateValue2AutomationName();
Platform::String ^ Serialize(); Platform::String ^ Serialize();

8
src/Calculator/App.xaml.cpp
View file

@ -356,8 +356,8 @@ void App::OnAppLaunch(IActivatedEventArgs ^ args, String ^ argument)
auto activatedEventArgs = dynamic_cast<IApplicationViewActivatedEventArgs ^>(args); auto activatedEventArgs = dynamic_cast<IApplicationViewActivatedEventArgs ^>(args);
if ((activatedEventArgs != nullptr) && (activatedEventArgs->CurrentlyShownApplicationViewId != 0)) if ((activatedEventArgs != nullptr) && (activatedEventArgs->CurrentlyShownApplicationViewId != 0))
{ {
create_task(ApplicationViewSwitcher::TryShowAsStandaloneAsync(frameService->GetViewId(), ViewSizePreference::Default, create_task(ApplicationViewSwitcher::TryShowAsStandaloneAsync(
activatedEventArgs->CurrentlyShownApplicationViewId, frameService->GetViewId(), ViewSizePreference::Default, activatedEventArgs->CurrentlyShownApplicationViewId,
ViewSizePreference::Default)) ViewSizePreference::Default))
.then( .then(
[safeFrameServiceCreation](bool viewShown) { [safeFrameServiceCreation](bool viewShown) {
@ -385,8 +385,8 @@ void App::OnAppLaunch(IActivatedEventArgs ^ args, String ^ argument)
if (activationViewSwitcher != nullptr) if (activationViewSwitcher != nullptr)
{ {
activationViewSwitcher->ShowAsStandaloneAsync(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), activationViewSwitcher->ShowAsStandaloneAsync(
ViewSizePreference::Default); ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), ViewSizePreference::Default);
TraceLogger::GetInstance().LogNewWindowCreationEnd(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread())); TraceLogger::GetInstance().LogNewWindowCreationEnd(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()));
TraceLogger::GetInstance().LogPrelaunchedAppActivatedByUser(); TraceLogger::GetInstance().LogPrelaunchedAppActivatedByUser();
} }

23
src/Calculator/Common/AlwaysSelectedCollectionView.h
View file

@ -47,8 +47,8 @@ namespace CalculatorApp
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
property Windows::Foundation::Collections::IObservableVector<Platform::Object ^> ^ CollectionGroups { property Windows::Foundation::Collections::IObservableVector<Platform::Object ^> ^ CollectionGroups {
virtual Windows::Foundation::Collections::IObservableVector<Platform::Object virtual Windows::Foundation::Collections::IObservableVector<
^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get Platform::Object ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
{ {
return ref new Platform::Collections::Vector<Platform::Object ^>(); return ref new Platform::Collections::Vector<Platform::Object ^>();
} }
@ -80,8 +80,9 @@ namespace CalculatorApp
// restore the selection to the way we wanted it to begin with // restore the selection to the way we wanted it to begin with
if (m_currentPosition >= 0 && m_currentPosition < static_cast<int>(m_source->Size)) if (m_currentPosition >= 0 && m_currentPosition < static_cast<int>(m_source->Size))
{ {
this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, ref new Windows::UI::Core::DispatchedHandler([this]() {
ref new Windows::UI::Core::DispatchedHandler([this]() { m_currentChanged(this, nullptr); })); m_currentChanged(this, nullptr);
}));
} }
return false; return false;
} }
@ -167,14 +168,14 @@ namespace CalculatorApp
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
virtual unsigned int virtual unsigned int GetMany(
GetMany(unsigned int /*startIndex*/, unsigned int /*startIndex*/,
Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<Platform::Object virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<
^>::GetView Platform::Object ^>::GetView
{ {
throw ref new Platform::NotImplementedException(); throw ref new Platform::NotImplementedException();
} }
@ -263,7 +264,8 @@ namespace CalculatorApp
private: private:
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ Convert(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
{ {
auto result = dynamic_cast<Windows::UI::Xaml::Interop::IBindableVector ^>(value); auto result = dynamic_cast<Windows::UI::Xaml::Interop::IBindableVector ^>(value);
@ -275,7 +277,8 @@ namespace CalculatorApp
} }
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ /*value*/, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/, ^ ConvertBack(
Platform::Object ^ /*value*/, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
{ {
return Windows::UI::Xaml::DependencyProperty::UnsetValue; return Windows::UI::Xaml::DependencyProperty::UnsetValue;

4
src/Calculator/Common/AppLifecycleLogger.cpp
View file

@ -58,8 +58,8 @@ namespace CalculatorApp
#pragma region Tracing methods #pragma region Tracing methods
void AppLifecycleLogger::LogAppLifecycleEvent(hstring const& eventName, LoggingFields const& fields) const void AppLifecycleLogger::LogAppLifecycleEvent(hstring const& eventName, LoggingFields const& fields) const
{ {
m_appLifecycleProvider.LogEvent(eventName, fields, LoggingLevel::Information, m_appLifecycleProvider.LogEvent(
LoggingOptions(MICROSOFT_KEYWORD_TELEMETRY | WINEVENT_KEYWORD_RESPONSE_TIME)); eventName, fields, LoggingLevel::Information, LoggingOptions(MICROSOFT_KEYWORD_TELEMETRY | WINEVENT_KEYWORD_RESPONSE_TIME));
} }
#pragma endregion #pragma endregion

3
src/Calculator/Controls/OverflowTextBlock.cpp
View file

@ -155,7 +155,8 @@ void OverflowTextBlock::UpdateScrollButtons()
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed); ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed);
} }
// We have more number on both side. Show both arrows // We have more number on both side. Show both arrows
else if ((m_expressionContainer->HorizontalOffset > 0) else if (
(m_expressionContainer->HorizontalOffset > 0)
&& (m_expressionContainer->HorizontalOffset < (m_expressionContainer->ExtentWidth - m_expressionContainer->ViewportWidth))) && (m_expressionContainer->HorizontalOffset < (m_expressionContainer->ExtentWidth - m_expressionContainer->ViewportWidth)))
{ {
ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Visible); ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Visible);

6
src/Calculator/Converters/BitFlipAutomationNameConverter.h
View file

@ -14,10 +14,12 @@ namespace CalculatorApp
{ {
public: public:
virtual Platform::Object virtual Platform::Object
^ Convert(_In_ Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, _In_ Platform::Object ^ parameter, ^ Convert(
_In_ Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, _In_ Platform::Object ^ parameter,
_In_ Platform::String ^ language); _In_ Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(_In_ Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, _In_ Platform::Object ^ parameter, ^ ConvertBack(
_In_ Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, _In_ Platform::Object ^ parameter,
_In_ Platform::String ^ language); _In_ Platform::String ^ language);
}; };
} }

4
src/Calculator/Converters/BooleanNegationConverter.h
View file

@ -16,8 +16,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
} }
} }

8
src/Calculator/Converters/BooleanToVisibilityConverter.h
View file

@ -23,8 +23,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
/// <summary> /// <summary>
@ -38,8 +38,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
} }

8
src/Calculator/Converters/ItemSizeToVisibilityConverter.h
View file

@ -13,8 +13,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
public public
@ -24,8 +24,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
} }
} }

4
src/Calculator/Converters/RadixToStringConverter.h
View file

@ -16,8 +16,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
} }
} }

4
src/Calculator/Converters/VisibilityNegationConverter.h
View file

@ -16,8 +16,8 @@ namespace CalculatorApp
virtual Platform::Object virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language); ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::String ^ language); Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);
}; };
} }
} }

8
src/Calculator/Views/Calculator.xaml.h
View file

@ -109,8 +109,8 @@ public
bool m_IsDigit = false; bool m_IsDigit = false;
Memory ^ m_memory; Memory ^ m_memory;
void HistoryFlyout_Opened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args); void HistoryFlyout_Opened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args);
void HistoryFlyout_Closing(_In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBase ^ sender, void HistoryFlyout_Closing(
_In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBaseClosingEventArgs ^ args); _In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBase ^ sender, _In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBaseClosingEventArgs ^ args);
void HistoryFlyout_Closed(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args); void HistoryFlyout_Closed(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args);
void OnHideHistoryClicked(); void OnHideHistoryClicked();
void OnHideMemoryClicked(); void OnHideMemoryClicked();
@ -121,8 +121,8 @@ public
bool m_fIsHistoryFlyoutOpen; bool m_fIsHistoryFlyoutOpen;
bool m_fIsMemoryFlyoutOpen; bool m_fIsMemoryFlyoutOpen;
void OnMemoryFlyoutOpened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args); void OnMemoryFlyoutOpened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args);
void OnMemoryFlyoutClosing(_In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBase ^ sender, void OnMemoryFlyoutClosing(
_In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBaseClosingEventArgs ^ args); _In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBase ^ sender, _In_ Windows::UI::Xaml::Controls::Primitives::FlyoutBaseClosingEventArgs ^ args);
void OnMemoryFlyoutClosed(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args); void OnMemoryFlyoutClosed(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ args);
void SetChildAsMemory(); void SetChildAsMemory();
void SetChildAsHistory(); void SetChildAsHistory();

4
src/Calculator/Views/CalculatorProgrammerBitFlipPanel.xaml.h
View file

@ -34,8 +34,8 @@ namespace CalculatorApp
void AssignFlipButtons(); void AssignFlipButtons();
void SetVisibilityBinding(_In_ Windows::UI::Xaml::FrameworkElement ^ element, _In_ Platform::String ^ path, void SetVisibilityBinding(
_In_ Windows::UI::Xaml::Data::IValueConverter ^ converter); _In_ Windows::UI::Xaml::FrameworkElement ^ element, _In_ Platform::String ^ path, _In_ Windows::UI::Xaml::Data::IValueConverter ^ converter);
void OnBitToggled(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e); void OnBitToggled(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e);
void UpdateCheckedStates(); void UpdateCheckedStates();

4
src/Calculator/Views/CalculatorScientificOperators.xaml.cpp
View file

@ -68,8 +68,8 @@ void CalculatorScientificOperators::shiftButton_Check(_In_ Platform::Object ^ /*
SetOperatorRowVisibility(); SetOperatorRowVisibility();
} }
void CalculatorScientificOperators::shiftButton_IsEnabledChanged(_In_ Platform::Object ^ /*sender*/, void CalculatorScientificOperators::shiftButton_IsEnabledChanged(
_In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ /*e*/) _In_ Platform::Object ^ /*sender*/, _In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ /*e*/)
{ {
SetOperatorRowVisibility(); SetOperatorRowVisibility();
Common::KeyboardShortcutManager::ShiftButtonChecked(ShiftButton->IsEnabled && ShiftButton->IsChecked->Value); Common::KeyboardShortcutManager::ShiftButtonChecked(ShiftButton->IsEnabled && ShiftButton->IsChecked->Value);

12
src/Calculator/Views/DateCalculator.xaml.cpp
View file

@ -79,8 +79,8 @@ DateCalculator::DateCalculator()
DateDiff_ToDate->MaxDate = maxYear; DateDiff_ToDate->MaxDate = maxYear;
// Set the PlaceHolderText for CalendarDatePicker // Set the PlaceHolderText for CalendarDatePicker
DateTimeFormatter ^ dateTimeFormatter = DateTimeFormatter ^ dateTimeFormatter = LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(
LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(L"day month year", localizationSettings.GetCalendarIdentifier(), L"day month year", localizationSettings.GetCalendarIdentifier(),
ClockIdentifiers::TwentyFourHour); // Clock Identifier is not used ClockIdentifiers::TwentyFourHour); // Clock Identifier is not used
DateDiff_FromDate->DateFormat = L"day month year"; DateDiff_FromDate->DateFormat = L"day month year";
@ -130,8 +130,8 @@ void DateCalculator::AddSubtract_DateChanged(_In_ CalendarDatePicker ^ sender, _
{ {
auto dateCalcViewModel = safe_cast<DateCalculatorViewModel ^>(this->DataContext); auto dateCalcViewModel = safe_cast<DateCalculatorViewModel ^>(this->DataContext);
dateCalcViewModel->StartDate = e->NewDate->Value; dateCalcViewModel->StartDate = e->NewDate->Value;
TraceLogger::GetInstance().LogDateAddSubtractModeUsed(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), TraceLogger::GetInstance().LogDateAddSubtractModeUsed(
dateCalcViewModel->IsAddMode); ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), dateCalcViewModel->IsAddMode);
} }
else else
{ {
@ -142,8 +142,8 @@ void DateCalculator::AddSubtract_DateChanged(_In_ CalendarDatePicker ^ sender, _
void CalculatorApp::DateCalculator::OffsetValue_Changed(_In_ Platform::Object ^ sender, _In_ SelectionChangedEventArgs ^ e) void CalculatorApp::DateCalculator::OffsetValue_Changed(_In_ Platform::Object ^ sender, _In_ SelectionChangedEventArgs ^ e)
{ {
auto dateCalcViewModel = safe_cast<DateCalculatorViewModel ^>(this->DataContext); auto dateCalcViewModel = safe_cast<DateCalculatorViewModel ^>(this->DataContext);
TraceLogger::GetInstance().LogDateAddSubtractModeUsed(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), TraceLogger::GetInstance().LogDateAddSubtractModeUsed(
dateCalcViewModel->IsAddMode); ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), dateCalcViewModel->IsAddMode);
} }
void DateCalculator::OnCopyMenuItemClicked(_In_ Object ^ sender, _In_ RoutedEventArgs ^ e) void DateCalculator::OnCopyMenuItemClicked(_In_ Object ^ sender, _In_ RoutedEventArgs ^ e)

12
src/Calculator/Views/DateCalculator.xaml.h
View file

@ -29,12 +29,12 @@ namespace CalculatorApp
void SetDefaultFocus(); void SetDefaultFocus();
private: private:
void FromDate_DateChanged(_In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, void FromDate_DateChanged(
_In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e); _In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, _In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e);
void ToDate_DateChanged(_In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, void ToDate_DateChanged(
_In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e); _In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, _In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e);
void AddSubtract_DateChanged(_In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, void AddSubtract_DateChanged(
_In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e); _In_ Windows::UI::Xaml::Controls::CalendarDatePicker ^ sender, _In_ Windows::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs ^ e);
void OffsetValue_Changed(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::Controls::SelectionChangedEventArgs ^ e); void OffsetValue_Changed(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::Controls::SelectionChangedEventArgs ^ e);
void OnCopyMenuItemClicked(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e); void OnCopyMenuItemClicked(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e);
void OnLoaded(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e); void OnLoaded(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs ^ e);

4
src/Calculator/Views/MainPage.xaml.h
View file

@ -49,8 +49,8 @@ public
void OnNavPaneOpened(_In_ Microsoft::UI::Xaml::Controls::NavigationView ^ sender, _In_ Platform::Object ^ args); void OnNavPaneOpened(_In_ Microsoft::UI::Xaml::Controls::NavigationView ^ sender, _In_ Platform::Object ^ args);
void OnNavPaneClosed(_In_ Microsoft::UI::Xaml::Controls::NavigationView ^ sender, _In_ Platform::Object ^ args); void OnNavPaneClosed(_In_ Microsoft::UI::Xaml::Controls::NavigationView ^ sender, _In_ Platform::Object ^ args);
void OnNavSelectionChanged(_In_ Platform::Object ^ sender, _In_ Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs ^ e); void OnNavSelectionChanged(_In_ Platform::Object ^ sender, _In_ Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs ^ e);
void OnNavItemInvoked(Microsoft::UI::Xaml::Controls::NavigationView ^ /*sender*/, void OnNavItemInvoked(
_In_ Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs ^ e); Microsoft::UI::Xaml::Controls::NavigationView ^ /*sender*/, _In_ Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs ^ e);
void OnAboutButtonClick(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::Controls::ItemClickEventArgs ^ e); void OnAboutButtonClick(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::Controls::ItemClickEventArgs ^ e);
void OnAboutFlyoutOpened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ e); void OnAboutFlyoutOpened(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ e);

6
src/Calculator/Views/SupplementaryResults.xaml.h
View file

@ -26,10 +26,12 @@ public
} }
internal : virtual Platform::Object internal : virtual Platform::Object
^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ Convert(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter,
Platform::String ^ language) = Windows::UI::Xaml::Data::IValueConverter::Convert; Platform::String ^ language) = Windows::UI::Xaml::Data::IValueConverter::Convert;
virtual Platform::Object virtual Platform::Object
^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter, ^ ConvertBack(
Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^ parameter,
Platform::String ^ language) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack; Platform::String ^ language) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack;
private: private:

4
src/Calculator/Views/TitleBar.xaml.cpp
View file

@ -163,7 +163,7 @@ namespace CalculatorApp
void TitleBar::OnWindowActivated(_In_ Object ^ /*sender*/, _In_ WindowActivatedEventArgs ^ e) void TitleBar::OnWindowActivated(_In_ Object ^ /*sender*/, _In_ WindowActivatedEventArgs ^ e)
{ {
VisualStateManager::GoToState(this, e->WindowActivationState == CoreWindowActivationState::Deactivated ? WindowNotFocused->Name : WindowFocused->Name, VisualStateManager::GoToState(
false); this, e->WindowActivationState == CoreWindowActivationState::Deactivated ? WindowNotFocused->Name : WindowFocused->Name, false);
} }
} }

4
src/Calculator/WindowFrameService.h
View file

@ -43,8 +43,8 @@ public
WindowFrameService(_In_ Windows::UI::Xaml::Controls::Frame ^ viewFrame, Platform::WeakReference parent); WindowFrameService(_In_ Windows::UI::Xaml::Controls::Frame ^ viewFrame, Platform::WeakReference parent);
void InitializeFrameService(bool createdByUs); void InitializeFrameService(bool createdByUs);
void OnConsolidated(_In_ Windows::UI::ViewManagement::ApplicationView ^ sender, void
_In_ Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs ^ e); OnConsolidated(_In_ Windows::UI::ViewManagement::ApplicationView ^ sender, _In_ Windows::UI::ViewManagement::ApplicationViewConsolidatedEventArgs ^ e);
void OnClosed(_In_ Windows::UI::Core::CoreWindow ^ sender, _In_ Windows::UI::Core::CoreWindowEventArgs ^ args); void OnClosed(_In_ Windows::UI::Core::CoreWindow ^ sender, _In_ Windows::UI::Core::CoreWindowEventArgs ^ args);
void LogOnViewClosed(_In_ Windows::UI::Core::CoreWindow ^ coreWindow); void LogOnViewClosed(_In_ Windows::UI::Core::CoreWindow ^ coreWindow);

15
src/CalculatorUnitTests/CalcEngineTests.cpp
View file

@ -22,8 +22,8 @@ namespace CalculatorEngineTests
m_resourceProvider = make_shared<EngineResourceProvider>(); m_resourceProvider = make_shared<EngineResourceProvider>();
m_history = make_shared<CalculatorHistory>(MAX_HISTORY_SIZE); m_history = make_shared<CalculatorHistory>(MAX_HISTORY_SIZE);
CCalcEngine::InitialOneTimeOnlySetup(*(m_resourceProvider.get())); CCalcEngine::InitialOneTimeOnlySetup(*(m_resourceProvider.get()));
m_calcEngine = make_unique<CCalcEngine>(false /* Respect Order of Operations */, false /* Set to Integer Mode */, m_resourceProvider.get(), nullptr, m_calcEngine = make_unique<CCalcEngine>(
m_history); false /* Respect Order of Operations */, false /* Set to Integer Mode */, m_resourceProvider.get(), nullptr, m_history);
} }
TEST_METHOD_CLEANUP(Cleanup) TEST_METHOD_CLEANUP(Cleanup)
{ {
@ -52,8 +52,8 @@ namespace CalculatorEngineTests
VERIFY_ARE_EQUAL(L"1,234,567,890", m_calcEngine->GroupDigitsPerRadix(L"1234567890", 10), L"Verify grouping in base10."); VERIFY_ARE_EQUAL(L"1,234,567,890", m_calcEngine->GroupDigitsPerRadix(L"1234567890", 10), L"Verify grouping in base10.");
VERIFY_ARE_EQUAL(L"1,234,567.89", m_calcEngine->GroupDigitsPerRadix(L"1234567.89", 10), L"Verify grouping in base10 with decimal."); VERIFY_ARE_EQUAL(L"1,234,567.89", m_calcEngine->GroupDigitsPerRadix(L"1234567.89", 10), L"Verify grouping in base10 with decimal.");
VERIFY_ARE_EQUAL(L"1,234,567e89", m_calcEngine->GroupDigitsPerRadix(L"1234567e89", 10), L"Verify grouping in base10 with exponent."); VERIFY_ARE_EQUAL(L"1,234,567e89", m_calcEngine->GroupDigitsPerRadix(L"1234567e89", 10), L"Verify grouping in base10 with exponent.");
VERIFY_ARE_EQUAL(L"1,234,567.89e5", m_calcEngine->GroupDigitsPerRadix(L"1234567.89e5", 10), VERIFY_ARE_EQUAL(
L"Verify grouping in base10 with decimal and exponent."); L"1,234,567.89e5", m_calcEngine->GroupDigitsPerRadix(L"1234567.89e5", 10), L"Verify grouping in base10 with decimal and exponent.");
VERIFY_ARE_EQUAL(L"-123,456,789", m_calcEngine->GroupDigitsPerRadix(L"-123456789", 10), L"Verify grouping in base10 with negative."); VERIFY_ARE_EQUAL(L"-123,456,789", m_calcEngine->GroupDigitsPerRadix(L"-123456789", 10), L"Verify grouping in base10 with negative.");
} }
@ -204,15 +204,16 @@ namespace CalculatorEngineTests
VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 3, 0, 0 }, L"1234567890123456", false), L"Verify expanded form non-repeating grouping."); VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 3, 0, 0 }, L"1234567890123456", false), L"Verify expanded form non-repeating grouping.");
result = L"12,34,56,78,901,23456"; result = L"12,34,56,78,901,23456";
VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 5, 3, 2, 0 }, L"1234567890123456", false), VERIFY_ARE_EQUAL(
L"Verify multigroup with repeating grouping."); result, m_calcEngine->GroupDigits(L",", { 5, 3, 2, 0 }, L"1234567890123456", false), L"Verify multigroup with repeating grouping.");
result = L"1234,5678,9012,3456"; result = L"1234,5678,9012,3456";
VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 4, 0 }, L"1234567890123456", false), L"Verify repeating non-standard grouping."); VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 4, 0 }, L"1234567890123456", false), L"Verify repeating non-standard grouping.");
result = L"123456,78,901,23456"; result = L"123456,78,901,23456";
VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 5, 3, 2 }, L"1234567890123456", false), L"Verify multigroup non-repeating grouping."); VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 5, 3, 2 }, L"1234567890123456", false), L"Verify multigroup non-repeating grouping.");
VERIFY_ARE_EQUAL(result, m_calcEngine->GroupDigits(L",", { 5, 3, 2, 0, 0 }, L"1234567890123456", false), VERIFY_ARE_EQUAL(
result, m_calcEngine->GroupDigits(L",", { 5, 3, 2, 0, 0 }, L"1234567890123456", false),
L"Verify expanded form multigroup non-repeating grouping."); L"Verify expanded form multigroup non-repeating grouping.");
} }

4
src/CalculatorUnitTests/CalcInputTest.cpp
View file

@ -173,8 +173,8 @@ namespace CalculatorEngineTests
m_calcInput.Backspace(); m_calcInput.Backspace();
m_calcInput.TryToggleSign(true, L"127"); m_calcInput.TryToggleSign(true, L"127");
VERIFY_IS_FALSE(m_calcInput.TryAddDigit(9, 10, true, L"127", 8, 2), L"Negative value: verify we cannot add a digit if digit exceeds max value."); VERIFY_IS_FALSE(m_calcInput.TryAddDigit(9, 10, true, L"127", 8, 2), L"Negative value: verify we cannot add a digit if digit exceeds max value.");
VERIFY_IS_TRUE(m_calcInput.TryAddDigit(8, 10, true, L"127", 8, 2), VERIFY_IS_TRUE(
L"Negative value: verify we can add a digit if digit does not exceed max value."); m_calcInput.TryAddDigit(8, 10, true, L"127", 8, 2), L"Negative value: verify we can add a digit if digit does not exceed max value.");
} }
TEST_METHOD(TryAddDecimalPtEmpty) TEST_METHOD(TryAddDecimalPtEmpty)

3
src/CalculatorUnitTests/CalculatorManagerTest.cpp
View file

@ -40,7 +40,8 @@ namespace CalculatorManagerTest
{ {
m_isError = isError; m_isError = isError;
} }
void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens, void SetExpressionDisplay(
_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
_Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& /*commands*/) _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& /*commands*/)
{ {
m_expression.clear(); m_expression.clear();

136
src/CalculatorUnitTests/CopyPasteManagerTest.cpp
View file

@ -66,14 +66,17 @@ namespace CalculatorUnitTests
m_CopyPasteManager.ValidatePasteExpression(StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1), m_CopyPasteManager.ValidatePasteExpression(StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
StringReference(L"NoOp"), L"Verify ValidatePasteExpression returns NoOp for strings over max length"); StringReference(L"NoOp"), L"Verify ValidatePasteExpression returns NoOp for strings over max length");
VERIFY_ARE_EQUAL(m_CopyPasteManager.ValidatePasteExpression(StringReference(L""), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1), VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(L""), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
StringReference(L"NoOp"), L"Verify empty string is invalid"); StringReference(L"NoOp"), L"Verify empty string is invalid");
VERIFY_ARE_EQUAL(m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123e456"), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1), VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123e456"), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
StringReference(L"NoOp"), L"Verify pasting unsupported strings for the current mode is invalid"); StringReference(L"NoOp"), L"Verify pasting unsupported strings for the current mode is invalid");
VERIFY_ARE_EQUAL(m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123"), ViewMode::None, CategoryGroupType::None, -1, -1), VERIFY_ARE_EQUAL(
StringReference(L"NoOp"), L"Verify pasting without a ViewMode or Category is invalid"); m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123"), ViewMode::None, CategoryGroupType::None, -1, -1), StringReference(L"NoOp"),
L"Verify pasting without a ViewMode or Category is invalid");
}; };
TEST_METHOD(ValidateExtractOperands) TEST_METHOD(ValidateExtractOperands)
@ -107,53 +110,63 @@ namespace CalculatorUnitTests
{ {
exp_OperandLimit += L"+1"; exp_OperandLimit += L"+1";
} }
VERIFY_ARE_EQUAL(m_CopyPasteManager.ExtractOperands(exp_OperandLimit, ViewMode::Standard).size(), 100, VERIFY_ARE_EQUAL(
m_CopyPasteManager.ExtractOperands(exp_OperandLimit, ViewMode::Standard).size(), 100,
L"Verify ExtractOperands handles up to MaxOperandCount operands"); L"Verify ExtractOperands handles up to MaxOperandCount operands");
exp_OperandLimit += L"+1"; exp_OperandLimit += L"+1";
VERIFY_ARE_EQUAL(m_CopyPasteManager.ExtractOperands(exp_OperandLimit, ViewMode::Standard).size(), 0, VERIFY_ARE_EQUAL(
m_CopyPasteManager.ExtractOperands(exp_OperandLimit, ViewMode::Standard).size(), 0,
L"Verify ExtractOperands returns empty vector on too many operands"); L"Verify ExtractOperands returns empty vector on too many operands");
VERIFY_ARE_EQUAL(m_CopyPasteManager.ExtractOperands(L"12e9999", ViewMode::Standard).size(), 1, VERIFY_ARE_EQUAL(
L"Verify ExtractOperands handles up to 4 digit exponents"); m_CopyPasteManager.ExtractOperands(L"12e9999", ViewMode::Standard).size(), 1, L"Verify ExtractOperands handles up to 4 digit exponents");
VERIFY_ARE_EQUAL(m_CopyPasteManager.ExtractOperands(L"12e10000", ViewMode::Standard).size(), 0, VERIFY_ARE_EQUAL(
m_CopyPasteManager.ExtractOperands(L"12e10000", ViewMode::Standard).size(), 0,
L"Verify ExtractOperands returns empty vector when the exponent is too long"); L"Verify ExtractOperands returns empty vector when the exponent is too long");
}; };
TEST_METHOD(ValidateExpressionRegExMatch) TEST_METHOD(ValidateExpressionRegExMatch)
{ {
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{}, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1), VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{}, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
L"Verify empty list of operands returns false."); L"Verify empty list of operands returns false.");
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::None, CategoryGroupType::Calculator, -1, -1), VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::None, CategoryGroupType::Calculator, -1, -1),
L"Verify invalid ViewMode/CategoryGroups return false."); L"Verify invalid ViewMode/CategoryGroups return false.");
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::Currency, CategoryGroupType::None, -1, -1), VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::Currency, CategoryGroupType::None, -1, -1),
L"Verify invalid ViewMode/CategoryGroups return false."); L"Verify invalid ViewMode/CategoryGroups return false.");
Logger::WriteMessage(L"Verify operand lengths > max return false."); Logger::WriteMessage(L"Verify operand lengths > max return false.");
VERIFY_IS_FALSE( VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1)); m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123456789012345678901234567890123" }, ViewMode::Scientific, VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
CategoryGroupType::Calculator, -1, -1)); vector<wstring>{ L"123456789012345678901234567890123" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_FALSE( VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::None, CategoryGroupType::Converter, -1, -1)); m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::None, CategoryGroupType::Converter, -1, -1));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"11111111111111111" }, ViewMode::Programmer, VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
CategoryGroupType::Calculator, HexBase, QwordType)); vector<wstring>{ L"11111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, HexBase, QwordType));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567890" }, ViewMode::Programmer, VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
CategoryGroupType::Calculator, DecBase, QwordType)); vector<wstring>{ L"12345678901234567890" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"11111111111111111111111" }, ViewMode::Programmer, VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
CategoryGroupType::Calculator, OctBase, QwordType)); vector<wstring>{ L"11111111111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, OctBase, QwordType));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"10000000000000000000000000000000000000000000000000000000000000000" }, VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
ViewMode::Programmer, CategoryGroupType::Calculator, BinBase, QwordType)); vector<wstring>{ L"10000000000000000000000000000000000000000000000000000000000000000" }, ViewMode::Programmer, CategoryGroupType::Calculator,
BinBase, QwordType));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"9223372036854775808" }, ViewMode::Programmer, VERIFY_IS_FALSE(
CategoryGroupType::Calculator, DecBase, QwordType), m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"9223372036854775808" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
L"Verify operand values > max return false."); L"Verify operand values > max return false.");
VERIFY_IS_TRUE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"((((((((((((((((((((123))))))))))))))))))))" }, ViewMode::Scientific, VERIFY_IS_TRUE(
CategoryGroupType::Calculator, -1, -1), m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"((((((((((((((((((((123))))))))))))))))))))" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1),
L"Verify sanitized operand is detected as within max length."); L"Verify sanitized operand is detected as within max length.");
VERIFY_IS_TRUE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"9223372036854775807" }, ViewMode::Programmer, VERIFY_IS_TRUE(
CategoryGroupType::Calculator, DecBase, QwordType), m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"9223372036854775807" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
L"Verify operand values == max return true."); L"Verify operand values == max return true.");
Logger::WriteMessage(L"Verify all operands must match patterns."); Logger::WriteMessage(L"Verify all operands must match patterns.");
@ -166,11 +179,13 @@ namespace CalculatorUnitTests
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"1.23e+456" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1), m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"1.23e+456" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1),
L"Verify operand only needs to match one pattern."); L"Verify operand only needs to match one pattern.");
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123", L"12345678901234567" }, ViewMode::Standard, VERIFY_IS_FALSE(
CategoryGroupType::Calculator, -1, -1), m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
L"Verify all operands must be within maxlength"); L"Verify all operands must be within maxlength");
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123", L"9223372036854775808" }, ViewMode::Programmer, VERIFY_IS_FALSE(
CategoryGroupType::Calculator, DecBase, QwordType), m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"9223372036854775808" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
L"Verify all operand must be within max value."); L"Verify all operand must be within max value.");
}; };
@ -179,11 +194,14 @@ namespace CalculatorUnitTests
pair<size_t, unsigned long long int> standardModeMaximums = make_pair(m_CopyPasteManager.MaxStandardOperandLength, 0); pair<size_t, unsigned long long int> standardModeMaximums = make_pair(m_CopyPasteManager.MaxStandardOperandLength, 0);
pair<size_t, unsigned long long int> scientificModeMaximums = make_pair(m_CopyPasteManager.MaxScientificOperandLength, 0); pair<size_t, unsigned long long int> scientificModeMaximums = make_pair(m_CopyPasteManager.MaxScientificOperandLength, 0);
pair<size_t, unsigned long long int> converterModeMaximums = make_pair(m_CopyPasteManager.MaxConverterInputLength, 0); pair<size_t, unsigned long long int> converterModeMaximums = make_pair(m_CopyPasteManager.MaxConverterInputLength, 0);
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Standard, CategoryGroupType::None, -1, -1), standardModeMaximums, VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Standard, CategoryGroupType::None, -1, -1), standardModeMaximums,
L"Verify Standard mode maximum values"); L"Verify Standard mode maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Scientific, CategoryGroupType::None, -1, -1), scientificModeMaximums, VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Scientific, CategoryGroupType::None, -1, -1), scientificModeMaximums,
L"Verify Scientific mode maximum values"); L"Verify Scientific mode maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::Converter, -1, -1), converterModeMaximums, VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::Converter, -1, -1), converterModeMaximums,
L"Verify Converter mode maximum values"); L"Verify Converter mode maximum values");
unsigned long long int ullQwordMax = UINT64_MAX; unsigned long long int ullQwordMax = UINT64_MAX;
@ -191,43 +209,59 @@ namespace CalculatorUnitTests
unsigned long long int ullWordMax = UINT16_MAX; unsigned long long int ullWordMax = UINT16_MAX;
unsigned long long int ullByteMax = UINT8_MAX; unsigned long long int ullByteMax = UINT8_MAX;
Logger::WriteMessage(L"Verify Programmer Mode HexBase maximum values"); Logger::WriteMessage(L"Verify Programmer Mode HexBase maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, QwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, QwordType),
make_pair((size_t)16u, ullQwordMax)); make_pair((size_t)16u, ullQwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, DwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, DwordType),
make_pair((size_t)8u, ullDwordMax)); make_pair((size_t)8u, ullDwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, WordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, WordType),
make_pair((size_t)4u, ullWordMax)); make_pair((size_t)4u, ullWordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, ByteType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, ByteType),
make_pair((size_t)2u, ullByteMax)); make_pair((size_t)2u, ullByteMax));
Logger::WriteMessage(L"Verify Programmer Mode DecBase maximum values"); Logger::WriteMessage(L"Verify Programmer Mode DecBase maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, QwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, QwordType),
make_pair((size_t)19u, ullQwordMax >> 1)); make_pair((size_t)19u, ullQwordMax >> 1));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, DwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, DwordType),
make_pair((size_t)10u, ullDwordMax >> 1)); make_pair((size_t)10u, ullDwordMax >> 1));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, WordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, WordType),
make_pair((size_t)5u, ullWordMax >> 1)); make_pair((size_t)5u, ullWordMax >> 1));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, ByteType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, ByteType),
make_pair((size_t)3u, ullByteMax >> 1)); make_pair((size_t)3u, ullByteMax >> 1));
Logger::WriteMessage(L"Verify Programmer Mode OctBase maximum values"); Logger::WriteMessage(L"Verify Programmer Mode OctBase maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, QwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, QwordType),
make_pair((size_t)22u, ullQwordMax)); make_pair((size_t)22u, ullQwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, DwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, DwordType),
make_pair((size_t)11u, ullDwordMax)); make_pair((size_t)11u, ullDwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, WordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, WordType),
make_pair((size_t)6u, ullWordMax)); make_pair((size_t)6u, ullWordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, ByteType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, ByteType),
make_pair((size_t)3u, ullByteMax)); make_pair((size_t)3u, ullByteMax));
Logger::WriteMessage(L"Verify Programmer Mode BinBase maximum values"); Logger::WriteMessage(L"Verify Programmer Mode BinBase maximum values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, QwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, QwordType),
make_pair((size_t)64u, ullQwordMax)); make_pair((size_t)64u, ullQwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, DwordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, DwordType),
make_pair((size_t)32u, ullDwordMax)); make_pair((size_t)32u, ullDwordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, WordType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, WordType),
make_pair((size_t)16u, ullWordMax)); make_pair((size_t)16u, ullWordMax));
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, ByteType), VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, ByteType),
make_pair((size_t)8u, ullByteMax)); make_pair((size_t)8u, ullByteMax));
Logger::WriteMessage(L"Verify invalid ViewModes/Categories return 0 for max values"); Logger::WriteMessage(L"Verify invalid ViewModes/Categories return 0 for max values");

4
src/CalculatorUnitTests/DateCalculatorUnitTests.cpp
View file

@ -343,8 +343,8 @@ TEST_METHOD(TestSubtractOob)
DateTime endDate; DateTime endDate;
// Subtract Duration // Subtract Duration
bool isValid = m_DateCalcEngine.SubtractDuration(DateUtils::SystemTimeToDateTime(datetimeBoundSubtract[testIndex].startDate), bool isValid = m_DateCalcEngine.SubtractDuration(
datetimeBoundSubtract[testIndex].dateDiff, &endDate); DateUtils::SystemTimeToDateTime(datetimeBoundSubtract[testIndex].startDate), datetimeBoundSubtract[testIndex].dateDiff, &endDate);
// Assert for the result // Assert for the result
VERIFY_IS_FALSE(isValid); VERIFY_IS_FALSE(isValid);

3
src/CalculatorUnitTests/HistoryTests.cpp
View file

@ -221,7 +221,8 @@ namespace CalculatorFunctionalTests
m_historyViewModel->SaveHistory(); m_historyViewModel->SaveHistory();
m_historyViewModel->ReloadHistory(ViewMode::Scientific); m_historyViewModel->ReloadHistory(ViewMode::Scientific);
auto itemAfterSerializeDeserialize = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto itemAfterSerializeDeserialize = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0);
VERIFY_IS_TRUE((itemBeforeSerializeDeserialize->historyItemVector.expression == itemAfterSerializeDeserialize->historyItemVector.expression) VERIFY_IS_TRUE(
(itemBeforeSerializeDeserialize->historyItemVector.expression == itemAfterSerializeDeserialize->historyItemVector.expression)
&& (itemBeforeSerializeDeserialize->historyItemVector.result == itemAfterSerializeDeserialize->historyItemVector.result) && (itemBeforeSerializeDeserialize->historyItemVector.result == itemAfterSerializeDeserialize->historyItemVector.result)
&& (itemBeforeSerializeDeserialize->historyItemVector.spCommands == itemAfterSerializeDeserialize->historyItemVector.spCommands) && (itemBeforeSerializeDeserialize->historyItemVector.spCommands == itemAfterSerializeDeserialize->historyItemVector.spCommands)
&& (itemBeforeSerializeDeserialize->historyItemVector.spTokens == itemAfterSerializeDeserialize->historyItemVector.spTokens)); && (itemBeforeSerializeDeserialize->historyItemVector.spTokens == itemAfterSerializeDeserialize->historyItemVector.spTokens));

4
src/CalculatorUnitTests/MultiWindowUnitTests.cpp
View file

@ -632,9 +632,9 @@ TEST_METHOD(MultipleDateCalculatorTest)
//// Diff in viewModels[0] //// Diff in viewModels[0]
// SYSTEMTIME date1, date2, resultDate; // SYSTEMTIME date1, date2, resultDate;
///* 01-10-2015 */ date1.wDay = 1; date1.wMonth = 10; date1.wYear = 2015; date1.wDayOfWeek = 4; date1.wHour = 0; date1.wMinute = 0; date1.wSecond = 0; ///* 01-10-2015 */ date1.wDay = 1; date1.wMonth = 10; date1.wYear = 2015; date1.wDayOfWeek = 4; date1.wHour = 0; date1.wMinute = 0; date1.wSecond = 0;
///date1.wMilliseconds = 0; /// date1.wMilliseconds = 0;
///* 15-02-2016 */ date2.wDay = 15; date2.wMonth = 2; date2.wYear = 2016; date2.wDayOfWeek = 1; date2.wHour = 0; date2.wMinute = 0; date2.wSecond = 0; ///* 15-02-2016 */ date2.wDay = 15; date2.wMonth = 2; date2.wYear = 2016; date2.wDayOfWeek = 1; date2.wHour = 0; date2.wMinute = 0; date2.wSecond = 0;
///date2.wMilliseconds = 0; /// date2.wMilliseconds = 0;
// viewModels[0]->FromDate = DateUtils::SystemTimeToDateTime(date1); // viewModels[0]->FromDate = DateUtils::SystemTimeToDateTime(date1);
// viewModels[0]->ToDate = DateUtils::SystemTimeToDateTime(date2); // viewModels[0]->ToDate = DateUtils::SystemTimeToDateTime(date2);

3
src/CalculatorUnitTests/StandardViewModelUnitTests.cpp
View file

@ -549,7 +549,8 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"FFFF FFFF FFFF FFFE")); VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"FFFF FFFF FFFF FFFE"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"-2")); VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"-2"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"1 777 777 777 777 777 777 776")); VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"1 777 777 777 777 777 777 776"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), VERIFY_ARE_EQUAL(
Utils::GetStringValue(m_viewModel->BinaryDisplayValue),
StringReference(L"1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1110")); StringReference(L"1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1110"));
VERIFY_ARE_EQUAL(m_viewModel->DisplayValue, StringReference(L"-2")); VERIFY_ARE_EQUAL(m_viewModel->DisplayValue, StringReference(L"-2"));
} }