From d37c75fec23aa7648c6b90ae2643161864a35a1e Mon Sep 17 00:00:00 2001 From: Stephanie Anderl <46726333+sanderl@users.noreply.github.com> Date: Thu, 14 Mar 2019 16:20:05 -0700 Subject: [PATCH 1/6] Fixes #282 Narrator does not convey error information when no more Right Parenthesis can be added in expression. (#284) * Added narrator announcements when right parenthesis is clicked --- src/CalcManager/CEngine/scicomm.cpp | 5 +++ src/CalcManager/CalculatorManager.cpp | 9 ++++- src/CalcManager/CalculatorManager.h | 5 ++- src/CalcManager/Header Files/ICalcDisplay.h | 1 + .../Automation/NarratorAnnouncement.cpp | 22 ++++++++++- .../Common/Automation/NarratorAnnouncement.h | 5 ++- .../Common/CalculatorDisplay.cpp | 38 ++++++++++--------- src/CalcViewModel/Common/CalculatorDisplay.h | 1 + .../StandardCalculatorViewModel.cpp | 35 ++++++++++++++++- .../StandardCalculatorViewModel.h | 8 +++- src/Calculator/Resources/en-US/Resources.resw | 8 ++++ .../CalculatorProgrammerRadixOperators.xaml | 1 + ...alculatorProgrammerRadixOperators.xaml.cpp | 19 ++++++++-- .../CalculatorProgrammerRadixOperators.xaml.h | 6 ++- .../Views/CalculatorScientificOperators.xaml | 2 + .../CalculatorScientificOperators.xaml.cpp | 19 +++++++++- .../CalculatorScientificOperators.xaml.h | 7 +++- .../CalculatorManagerTest.cpp | 5 +++ 18 files changed, 165 insertions(+), 31 deletions(-) diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index a72cce15..2ebb0274 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -546,6 +546,11 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) if ((m_openParenCount >= MAXPRECDEPTH && nx) || (!m_openParenCount && !nx) || ((m_precedenceOpCount >= MAXPRECDEPTH && m_nPrecOp[m_precedenceOpCount - 1] != 0))) { + if (!m_openParenCount && !nx) + { + m_pCalcDisplay->OnNoRightParenAdded(); + } + HandleErrorCommand(wParam); break; } diff --git a/src/CalcManager/CalculatorManager.cpp b/src/CalcManager/CalculatorManager.cpp index 0e03afaf..946d4676 100644 --- a/src/CalcManager/CalculatorManager.cpp +++ b/src/CalcManager/CalculatorManager.cpp @@ -109,7 +109,6 @@ namespace CalculationManager /// /// Callback from the engine - /// Used to set the current unmatched open parenthesis count /// /// string containing the parenthesis count void CalculatorManager::SetParenDisplayText(const wstring& parenthesisCount) @@ -117,6 +116,14 @@ namespace CalculationManager m_displayCallback->SetParenDisplayText(parenthesisCount); } + /// + /// Callback from the engine + /// + void CalculatorManager::OnNoRightParenAdded() + { + m_displayCallback->OnNoRightParenAdded(); + } + /// /// Reset CalculatorManager. /// Set the mode to the standard calculator diff --git a/src/CalcManager/CalculatorManager.h b/src/CalcManager/CalculatorManager.h index 9f60c534..d3e354fc 100644 --- a/src/CalcManager/CalculatorManager.h +++ b/src/CalcManager/CalculatorManager.h @@ -42,7 +42,7 @@ namespace CalculationManager MemorizedNumberClear = 335 }; - class CalculatorManager sealed : public virtual ICalcDisplay + class CalculatorManager sealed : public ICalcDisplay { private: ICalcDisplay* const m_displayCallback; @@ -94,7 +94,8 @@ namespace CalculationManager void SetExpressionDisplay(_Inout_ std::shared_ptr>> const &tokens, _Inout_ std::shared_ptr>> const &commands) override; void SetMemorizedNumbers(_In_ const std::vector& memorizedNumbers) override; void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override; - void SetParenDisplayText(const std::wstring& parenthesisCount); + void SetParenDisplayText(const std::wstring& parenthesisCount) override; + void OnNoRightParenAdded() override; void DisplayPasteError(); void MaxDigitsReached() override; void BinaryOperatorReceived() override; diff --git a/src/CalcManager/Header Files/ICalcDisplay.h b/src/CalcManager/Header Files/ICalcDisplay.h index abafbc3c..2ba57e65 100644 --- a/src/CalcManager/Header Files/ICalcDisplay.h +++ b/src/CalcManager/Header Files/ICalcDisplay.h @@ -13,6 +13,7 @@ public: virtual void SetIsInError(bool isInError) = 0; virtual void SetExpressionDisplay(_Inout_ std::shared_ptr>> const &tokens, _Inout_ std::shared_ptr>> const &commands) = 0; virtual void SetParenDisplayText(const std::wstring& pszText) = 0; + virtual void OnNoRightParenAdded() = 0; virtual void MaxDigitsReached() = 0; // not an error but still need to inform UI layer. virtual void BinaryOperatorReceived() = 0; virtual void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) = 0; diff --git a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp index 72b4a712..823572f3 100644 --- a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp +++ b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #include "pch.h" @@ -20,6 +20,8 @@ namespace CalculatorApp::Common::Automation StringReference CategoryNameChanged(L"CategoryNameChanged"); StringReference UpdateCurrencyRates(L"UpdateCurrencyRates"); StringReference DisplayCopied(L"DisplayCopied"); + StringReference OpenParenthesisCountChanged(L"OpenParenthesisCountChanged"); + StringReference NoParenthesisAdded(L"NoParenthesisAdded"); } } @@ -142,3 +144,21 @@ NarratorAnnouncement^ CalculatorAnnouncement::GetDisplayCopiedAnnouncement(Strin AutomationNotificationKind::ActionCompleted, AutomationNotificationProcessing::ImportantMostRecent); } + +NarratorAnnouncement^ CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(String^ announcement) +{ + return ref new NarratorAnnouncement( + announcement, + CalculatorActivityIds::OpenParenthesisCountChanged, + AutomationNotificationKind::ActionCompleted, + AutomationNotificationProcessing::ImportantMostRecent); +} + +NarratorAnnouncement^ CalculatorAnnouncement::GetNoRightParenthesisAddedAnnouncement(String^ announcement) +{ + return ref new NarratorAnnouncement( + announcement, + CalculatorActivityIds::NoParenthesisAdded, + AutomationNotificationKind::ActionCompleted, + AutomationNotificationProcessing::ImportantMostRecent); +} diff --git a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h index 16635b4a..70067d72 100644 --- a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h +++ b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -90,5 +90,8 @@ namespace CalculatorApp::Common::Automation static NarratorAnnouncement^ GetUpdateCurrencyRatesAnnouncement(Platform::String^ announcement); static NarratorAnnouncement^ GetDisplayCopiedAnnouncement(Platform::String^ announcement); + + static NarratorAnnouncement^ GetOpenParenthesisCountChangedAnnouncement(Platform::String^ announcement); + static NarratorAnnouncement^ GetNoRightParenthesisAddedAnnouncement(Platform::String ^ announcement); }; } diff --git a/src/CalcViewModel/Common/CalculatorDisplay.cpp b/src/CalcViewModel/Common/CalculatorDisplay.cpp index 705da22c..36fe4fed 100644 --- a/src/CalcViewModel/Common/CalculatorDisplay.cpp +++ b/src/CalcViewModel/Common/CalculatorDisplay.cpp @@ -29,8 +29,7 @@ void CalculatorDisplay::SetPrimaryDisplay(_In_ const wstring& displayStringValue { if (m_callbackReference) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->SetPrimaryDisplay(displayStringValue, isError); } @@ -41,20 +40,29 @@ void CalculatorDisplay::SetParenDisplayText(_In_ const std::wstring& parenthesis { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->SetParenthesisCount(parenthesisCount); } } } +void CalculatorDisplay::OnNoRightParenAdded() +{ + if (m_callbackReference != nullptr) + { + if (auto calcVM = m_callbackReference.Resolve()) + { + calcVM->OnNoRightParenAdded(); + } + } +} + void CalculatorDisplay::SetIsInError(bool isError) { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->IsInError = isError; } @@ -65,8 +73,7 @@ void CalculatorDisplay::SetExpressionDisplay(_Inout_ std::shared_ptr(); - if (calcVM) + if(auto calcVM = m_callbackReference.Resolve()) { calcVM->SetExpressionDisplay(tokens, commands); } @@ -77,8 +84,7 @@ void CalculatorDisplay::SetMemorizedNumbers(_In_ const vector& new { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->SetMemorizedNumbers(newMemorizedNumbers); } @@ -89,8 +95,7 @@ void CalculatorDisplay::OnHistoryItemAdded(_In_ unsigned int addedItemIndex) { if (m_historyCallbackReference != nullptr) { - auto historyVM = m_historyCallbackReference.Resolve(); - if (historyVM) + if (auto historyVM = m_historyCallbackReference.Resolve()) { historyVM->OnHistoryItemAdded(addedItemIndex); } @@ -101,8 +106,7 @@ void CalculatorDisplay::MaxDigitsReached() { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->OnMaxDigitsReached(); } @@ -113,8 +117,7 @@ void CalculatorDisplay::BinaryOperatorReceived() { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->OnBinaryOperatorReceived(); } @@ -125,8 +128,7 @@ void CalculatorDisplay::MemoryItemChanged(unsigned int indexOfMemory) { if (m_callbackReference != nullptr) { - auto calcVM = m_callbackReference.Resolve(); - if (calcVM) + if (auto calcVM = m_callbackReference.Resolve()) { calcVM->OnMemoryItemChanged(indexOfMemory); } diff --git a/src/CalcViewModel/Common/CalculatorDisplay.h b/src/CalcViewModel/Common/CalculatorDisplay.h index 692af37e..9ff06a6e 100644 --- a/src/CalcViewModel/Common/CalculatorDisplay.h +++ b/src/CalcViewModel/Common/CalculatorDisplay.h @@ -22,6 +22,7 @@ namespace CalculatorApp void SetMemorizedNumbers(_In_ const std::vector& memorizedNumbers) override; void OnHistoryItemAdded(_In_ unsigned int addedItemIndex) override; void SetParenDisplayText(_In_ const std::wstring& parenthesisCount) override; + void OnNoRightParenAdded() override; void MaxDigitsReached() override; void BinaryOperatorReceived() override; void MemoryItemChanged(unsigned int indexOfMemory) override; diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index a25aeb18..e97ffbef 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -41,6 +41,7 @@ namespace CalculatorApp::ViewModel StringReference DisplayValue(L"DisplayValue"); StringReference IsInError(L"IsInError"); StringReference BinaryDisplayValue(L"BinaryDisplayValue"); + StringReference OpenParenthesisCount(L"OpenParenthesisCount"); } namespace CalculatorResourceKeys @@ -53,6 +54,8 @@ namespace CalculatorApp::ViewModel StringReference OctButton(L"Format_OctButtonValue"); StringReference BinButton(L"Format_BinButtonValue"); StringReference LeftParenthesisAutomationFormat(L"Format_OpenParenthesisAutomationNamePrefix"); + StringReference OpenParenthesisCountAutomationFormat(L"Format_OpenParenthesisCountAutomationNamePrefix"); + StringReference NoParenthesisAdded(L"NoRightParenthesisAdded_Announcement"); StringReference MaxDigitsReachedFormat(L"Format_MaxDigitsReached"); StringReference ButtonPressFeedbackFormat(L"Format_ButtonPressAuditoryFeedback"); StringReference MemorySave(L"Format_MemorySave"); @@ -92,7 +95,9 @@ StandardCalculatorViewModel::StandardCalculatorViewModel() : m_localizedMemorySavedAutomationFormat(nullptr), m_localizedMemoryItemChangedAutomationFormat(nullptr), m_localizedMemoryItemClearedAutomationFormat(nullptr), - m_localizedMemoryCleared(nullptr) + m_localizedMemoryCleared(nullptr), + m_localizedOpenParenthesisCountChangedAutomationFormat(nullptr), + m_localizedNoRightParenthesisAddedFormat(nullptr) { WeakReference calculatorViewModel(this); m_calculatorDisplay.SetCallback(calculatorViewModel); @@ -226,6 +231,34 @@ void StandardCalculatorViewModel::SetParenthesisCount(_In_ const wstring& parent } } +void StandardCalculatorViewModel::SetOpenParenthesisCountNarratorAnnouncement() +{ + String^ parenthesisCount = ((m_OpenParenthesisCount == nullptr) ? "0" : m_OpenParenthesisCount); + wstring localizedParenthesisCount = parenthesisCount->Data(); + LocalizationSettings::GetInstance().LocalizeDisplayValue(&localizedParenthesisCount); + + String^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement( + CalculatorResourceKeys::OpenParenthesisCountAutomationFormat, + m_localizedOpenParenthesisCountChangedAutomationFormat, + localizedParenthesisCount.c_str()); + + Announcement = CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(announcement); +} + +void StandardCalculatorViewModel::OnNoRightParenAdded() +{ + SetNoParenAddedNarratorAnnouncement(); +} + +void StandardCalculatorViewModel::SetNoParenAddedNarratorAnnouncement() +{ + String^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement( + CalculatorResourceKeys::NoParenthesisAdded, + m_localizedNoRightParenthesisAddedFormat); + + Announcement = CalculatorAnnouncement::GetNoRightParenthesisAddedAnnouncement(announcement); +} + void StandardCalculatorViewModel::DisableButtons(CommandType selectedExpressionCommandType) { if (selectedExpressionCommandType == CommandType::OperandCommand) diff --git a/src/CalcViewModel/StandardCalculatorViewModel.h b/src/CalcViewModel/StandardCalculatorViewModel.h index 91ff9da0..494cd5e0 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.h +++ b/src/CalcViewModel/StandardCalculatorViewModel.h @@ -36,6 +36,7 @@ namespace CalculatorApp extern Platform::StringReference IsMemoryEmpty; extern Platform::StringReference IsInError; extern Platform::StringReference BinaryDisplayValue; + extern Platform::StringReference OpenParenthesisCount; } [Windows::UI::Xaml::Data::Bindable] @@ -263,7 +264,7 @@ namespace CalculatorApp property Platform::String^ LeftParenthesisAutomationName { - Platform::String^ get() + Platform::String^ get() { return GetLeftParenthesisAutomationName(); } @@ -290,6 +291,9 @@ namespace CalculatorApp void SetExpressionDisplay(_Inout_ std::shared_ptr>> const &tokens, _Inout_ std::shared_ptr>> const &commands); void SetHistoryExpressionDisplay(_Inout_ std::shared_ptr>> const &tokens, _Inout_ std::shared_ptr>> const &commands); void SetParenthesisCount(_In_ const std::wstring& parenthesisCount); + void SetOpenParenthesisCountNarratorAnnouncement(); + void OnNoRightParenAdded(); + void SetNoParenAddedNarratorAnnouncement(); void OnMaxDigitsReached(); void OnBinaryOperatorReceived(); void OnMemoryItemChanged(unsigned int indexOfMemory); @@ -337,6 +341,8 @@ namespace CalculatorApp Platform::String^ m_localizedMemoryItemChangedAutomationFormat; Platform::String^ m_localizedMemoryItemClearedAutomationFormat; Platform::String^ m_localizedMemoryCleared; + Platform::String^ m_localizedOpenParenthesisCountChangedAutomationFormat; + Platform::String^ m_localizedNoRightParenthesisAddedFormat; bool m_pinned; bool m_isOperandEnabled; diff --git a/src/Calculator/Resources/en-US/Resources.resw b/src/Calculator/Resources/en-US/Resources.resw index ca9ee82c..3e9539b0 100644 --- a/src/Calculator/Resources/en-US/Resources.resw +++ b/src/Calculator/Resources/en-US/Resources.resw @@ -1321,6 +1321,14 @@ Right parenthesis Screen reader prompt for the Calculator ")" button on the scientific operator keypad + + Open parenthesis count %1 + {Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific and programmer operator keypad. %1 is the localized count of open parenthesis, e.g. "2". + + + There are no open parentheses to close. + {Locked="%1"} Screen reader prompt for the Calculator when the ")" button on the scientific and programmer operator keypad cannot be added to the equation. e.g. "1+)". + Scientific notation Screen reader prompt for the Calculator F-E the scientific operator keypad diff --git a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml index 05afb876..5c84f4f7 100644 --- a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml +++ b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml @@ -10,6 +10,7 @@ d:DesignHeight="395" d:DesignWidth="315" Loaded="OnLoaded" + Unloaded="OnUnloaded" mc:Ignorable="d"> diff --git a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.cpp b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.cpp index 60a628bf..85215dda 100644 --- a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.cpp +++ b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // @@ -34,8 +34,13 @@ CalculatorProgrammerRadixOperators::CalculatorProgrammerRadixOperators() : void CalculatorProgrammerRadixOperators::OnLoaded(Object^, RoutedEventArgs^) { - auto viewmodel = safe_cast(this->DataContext); - viewmodel->ProgModeRadixChange += ref new ProgModeRadixChangeHandler(this, &CalculatorProgrammerRadixOperators::ProgModeRadixChange); + m_progModeRadixChangeToken = Model->ProgModeRadixChange += ref new ProgModeRadixChangeHandler(this, &CalculatorProgrammerRadixOperators::ProgModeRadixChange); + m_propertyChangedToken = Model->PropertyChanged += ref new PropertyChangedEventHandler(this, &CalculatorProgrammerRadixOperators::OnViewModelPropertyChanged); +} +void CalculatorProgrammerRadixOperators::OnUnloaded(Object^, RoutedEventArgs^) +{ + Model->ProgModeRadixChange -= m_progModeRadixChangeToken; + Model->PropertyChanged -= m_propertyChangedToken; } void CalculatorProgrammerRadixOperators::Shift_Clicked(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) @@ -94,3 +99,11 @@ void CalculatorProgrammerRadixOperators::IsErrorVisualState::set(bool value) NumberPad->IsErrorVisualState = m_isErrorVisualState; } } + +void CalculatorProgrammerRadixOperators::OnViewModelPropertyChanged(Object^ sender, PropertyChangedEventArgs^ e) +{ + if (e->PropertyName == CalculatorViewModelProperties::OpenParenthesisCount && closeParenthesisButton->FocusState != ::FocusState::Unfocused) + { + Model->SetOpenParenthesisCountNarratorAnnouncement(); + } +} diff --git a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.h b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.h index 7aae73f4..7dd819d0 100644 --- a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.h +++ b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. #pragma once @@ -33,8 +33,12 @@ namespace CalculatorApp void Shift_Clicked(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); void SetVisibilityBinding(Windows::UI::Xaml::FrameworkElement^ element, Platform::String^ path, Windows::UI::Xaml::Data::IValueConverter^ converter); void OnLoaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void OnUnloaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); void ProgModeRadixChange(); + void OnViewModelPropertyChanged(Platform::Object^ sender, Windows::UI::Xaml::Data::PropertyChangedEventArgs ^ e); bool m_isErrorVisualState; + Windows::Foundation::EventRegistrationToken m_progModeRadixChangeToken; + Windows::Foundation::EventRegistrationToken m_propertyChangedToken; }; } diff --git a/src/Calculator/Views/CalculatorScientificOperators.xaml b/src/Calculator/Views/CalculatorScientificOperators.xaml index efc5a5e3..3db97aa9 100644 --- a/src/Calculator/Views/CalculatorScientificOperators.xaml +++ b/src/Calculator/Views/CalculatorScientificOperators.xaml @@ -11,6 +11,8 @@ x:Name="ControlRoot" d:DesignHeight="400" d:DesignWidth="315" + Loaded="OnLoaded" + Unloaded="OnUnloaded" mc:Ignorable="d"> diff --git a/src/Calculator/Views/CalculatorScientificOperators.xaml.cpp b/src/Calculator/Views/CalculatorScientificOperators.xaml.cpp index 47998496..fa7832fe 100644 --- a/src/Calculator/Views/CalculatorScientificOperators.xaml.cpp +++ b/src/Calculator/Views/CalculatorScientificOperators.xaml.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // @@ -38,6 +38,15 @@ CalculatorScientificOperators::CalculatorScientificOperators() Common::KeyboardShortcutManager::ShiftButtonChecked(false); } +void CalculatorScientificOperators::OnLoaded(Object^, RoutedEventArgs^) +{ + m_propertyChangedToken = Model->PropertyChanged += ref new PropertyChangedEventHandler(this, &CalculatorScientificOperators::OnViewModelPropertyChanged); +} +void CalculatorScientificOperators::OnUnloaded(Object^, RoutedEventArgs^) +{ + Model->PropertyChanged -= m_propertyChangedToken; +} + void CalculatorScientificOperators::ShortLayout_Completed(_In_ Platform::Object^ /*sender*/, _In_ Platform::Object^ /*e*/) { IsWideLayout = false; @@ -97,3 +106,11 @@ void CalculatorScientificOperators::SetOperatorRowVisibility() InvRow1->Visibility = invRowVis; InvRow2->Visibility = invRowVis; } + +void CalculatorScientificOperators::OnViewModelPropertyChanged(Object^ sender, PropertyChangedEventArgs^ e) +{ + if (e->PropertyName == CalculatorViewModelProperties::OpenParenthesisCount && closeParenthesisButton->FocusState != ::FocusState::Unfocused) + { + Model->SetOpenParenthesisCountNarratorAnnouncement(); + } +} diff --git a/src/Calculator/Views/CalculatorScientificOperators.xaml.h b/src/Calculator/Views/CalculatorScientificOperators.xaml.h index ae35e492..ec10191c 100644 --- a/src/Calculator/Views/CalculatorScientificOperators.xaml.h +++ b/src/Calculator/Views/CalculatorScientificOperators.xaml.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // @@ -41,5 +41,10 @@ namespace CalculatorApp void shiftButton_Check(_In_ Platform::Object^ sender, _In_ Windows::UI::Xaml::RoutedEventArgs^ e); void shiftButton_IsEnabledChanged(_In_ Platform::Object^ sender, _In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ e); void SetOperatorRowVisibility(); + void OnViewModelPropertyChanged(Platform::Object^ sender, Windows::UI::Xaml::Data::PropertyChangedEventArgs ^ e); + void OnLoaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void OnUnloaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + + Windows::Foundation::EventRegistrationToken m_propertyChangedToken; }; } diff --git a/src/CalculatorUnitTests/CalculatorManagerTest.cpp b/src/CalculatorUnitTests/CalculatorManagerTest.cpp index cdf8a6f2..1d42a285 100644 --- a/src/CalculatorUnitTests/CalculatorManagerTest.cpp +++ b/src/CalculatorUnitTests/CalculatorManagerTest.cpp @@ -62,6 +62,11 @@ namespace CalculatorManagerTest m_parenDisplay = parenthesisCount; } + void OnNoRightParenAdded() override + { + // This method is used to create a narrator announcement when a close parenthesis cannot be added because there are no open parentheses + } + const wstring& GetPrimaryDisplay() const { return m_primaryDisplay; From a5e07418df8e558170c2c8b57fb431964261cc00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Janiszewski?= Date: Fri, 15 Mar 2019 05:06:12 +0100 Subject: [PATCH 2/6] Replace custom ARRAYSIZE macro with std::size (#208) * Replace custom ARRAYSIZE macro with std::size --- src/CalcManager/CEngine/scicomm.cpp | 6 +++--- src/CalcManager/CEngine/sciset.cpp | 5 +++-- src/CalcManager/pch.h | 1 + src/CalcViewModel/Common/CopyPasteManager.cpp | 2 +- src/CalcViewModel/Common/LocalizationSettings.h | 12 +++++++----- src/CalcViewModel/StandardCalculatorViewModel.cpp | 10 +++++----- src/CalcViewModel/pch.h | 2 +- 7 files changed, 21 insertions(+), 17 deletions(-) diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index 2ebb0274..8a741bb1 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -39,11 +39,11 @@ namespace { int iPrec; iPrec = 0; - while ((iPrec < ARRAYSIZE(rgbPrec)) && (nopCode != rgbPrec[iPrec])) + while ((iPrec < size(rgbPrec)) && (nopCode != rgbPrec[iPrec])) { iPrec += 2; } - if (iPrec >= ARRAYSIZE(rgbPrec)) + if (iPrec >= size(rgbPrec)) { iPrec = 0; } @@ -947,7 +947,7 @@ wstring_view CCalcEngine::OpCodeToUnaryString(int nOpCode, bool fInv, ANGLE_TYPE // Try to lookup the ID in the UFNE table int ids = 0; int iufne = nOpCode - IDC_UNARYFIRST; - if (iufne >= 0 && iufne < ARRAYSIZE(rgUfne)) + if (iufne >= 0 && iufne < size(rgUfne)) { if (fInv) { diff --git a/src/CalcManager/CEngine/sciset.cpp b/src/CalcManager/CEngine/sciset.cpp index 01dd3d3b..d5bbe9dd 100644 --- a/src/CalcManager/CEngine/sciset.cpp +++ b/src/CalcManager/CEngine/sciset.cpp @@ -6,6 +6,7 @@ using namespace CalcEngine; using namespace CalcEngine::RationalMath; +using namespace std; // To be called when either the radix or num width changes. You can use -1 in either of these values to mean // dont change that. @@ -55,7 +56,7 @@ LONG CCalcEngine::DwWordBitWidthFromeNumWidth(NUM_WIDTH /*numwidth*/) static constexpr int nBitMax[] = { 64, 32, 16, 8 }; LONG wmax = nBitMax[0]; - if (m_numwidth >= 0 && m_numwidth < ARRAYSIZE(nBitMax)) + if (m_numwidth >= 0 && m_numwidth < size(nBitMax)) { wmax = nBitMax[m_numwidth]; } @@ -68,7 +69,7 @@ uint32_t CCalcEngine::NRadixFromRadixType(RADIX_TYPE radixtype) uint32_t radix = 10; // convert special bases into symbolic values - if (radixtype >= 0 && radixtype < ARRAYSIZE(rgnRadish)) + if (radixtype >= 0 && radixtype < size(rgnRadish)) { radix = rgnRadish[radixtype]; } diff --git a/src/CalcManager/pch.h b/src/CalcManager/pch.h index 27e01ff3..4690713c 100644 --- a/src/CalcManager/pch.h +++ b/src/CalcManager/pch.h @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include diff --git a/src/CalcViewModel/Common/CopyPasteManager.cpp b/src/CalcViewModel/Common/CopyPasteManager.cpp index 7ae2bb96..71215d49 100644 --- a/src/CalcViewModel/Common/CopyPasteManager.cpp +++ b/src/CalcViewModel/Common/CopyPasteManager.cpp @@ -404,7 +404,7 @@ wstring CopyPasteManager::SanitizeOperand(const wstring& operand) { wchar_t unWantedChars[] = { L'\'', L'_', L'`', L'(', L')', L'-' }; - return Utils::RemoveUnwantedCharsFromWstring(operand, unWantedChars, ARRAYSIZE(unWantedChars)); + return Utils::RemoveUnwantedCharsFromWstring(operand, unWantedChars, static_cast(size(unWantedChars))); } bool CopyPasteManager::TryOperandToULL(const wstring& operand, int numberBase, unsigned long long int& result) diff --git a/src/CalcViewModel/Common/LocalizationSettings.h b/src/CalcViewModel/Common/LocalizationSettings.h index c1d4dfe2..d37e9647 100644 --- a/src/CalcViewModel/Common/LocalizationSettings.h +++ b/src/CalcViewModel/Common/LocalizationSettings.h @@ -4,6 +4,8 @@ #pragma once #include "LocalizationService.h" +#include + namespace CalculatorApp { namespace Common @@ -41,7 +43,7 @@ namespace CalculatorApp result = GetLocaleInfoEx(m_resolvedName.c_str(), LOCALE_SDECIMAL, decimalString, - ARRAYSIZE(decimalString)); + static_cast(std::size(decimalString))); if (result == 0) { throw std::runtime_error("Unexpected error while getting locale info"); @@ -51,7 +53,7 @@ namespace CalculatorApp result = GetLocaleInfoEx(m_resolvedName.c_str(), LOCALE_STHOUSAND, groupingSymbolString, - ARRAYSIZE(groupingSymbolString)); + static_cast(std::size(groupingSymbolString))); if (result == 0) { throw std::runtime_error("Unexpected error while getting locale info"); @@ -61,7 +63,7 @@ namespace CalculatorApp result = GetLocaleInfoEx(m_resolvedName.c_str(), LOCALE_SGROUPING, numberGroupingString, - ARRAYSIZE(numberGroupingString)); + static_cast(std::size(numberGroupingString))); if (result == 0) { throw std::runtime_error("Unexpected error while getting locale info"); @@ -72,7 +74,7 @@ namespace CalculatorApp result = ::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SLIST, listSeparatorString, - ARRAYSIZE(listSeparatorString)); // Max length of the expected return value is 4 + static_cast(std::size(listSeparatorString))); // Max length of the expected return value is 4 if (result == 0) { throw std::runtime_error("Unexpected error while getting locale info"); @@ -122,7 +124,7 @@ namespace CalculatorApp ::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK, // The first day in a week reinterpret_cast(day), // Argument is of type PWSTR - ARRAYSIZE(day)); // Max return size are 80 characters + static_cast(std::size(day))); // Max return size are 80 characters // The LOCALE_IFIRSTDAYOFWEEK integer value varies from 0, 1, .. 6 for Monday, Tuesday, ... Sunday // DayOfWeek enum value varies from 0, 1, .. 6 for Sunday, Monday, ... Saturday diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index e97ffbef..b035c14c 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -1647,7 +1647,7 @@ bool StandardCalculatorViewModel::IsOpnd(int nOpCode) Command::CommandPNT }; - for (int i = 0; i < ARRAYSIZE(opnd); i++) + for (int i = 0; i < size(opnd); i++) { if (nOpCode == static_cast(opnd[i])) { @@ -1678,7 +1678,7 @@ bool StandardCalculatorViewModel::IsUnaryOp(int nOpCode) Command::CommandCUB }; - for (int i = 0; i < ARRAYSIZE(unaryOp); i++) + for (int i = 0; i < size(unaryOp); i++) { if (nOpCode == static_cast(unaryOp[i])) { @@ -1705,7 +1705,7 @@ bool StandardCalculatorViewModel::IsTrigOp(int nOpCode) Command::CommandATAN }; - for (int i = 0; i < ARRAYSIZE(trigOp); i++) + for (int i = 0; i < size(trigOp); i++) { if (nOpCode == static_cast(trigOp[i])) { @@ -1728,7 +1728,7 @@ bool StandardCalculatorViewModel::IsBinOp(int nOpCode) Command::CommandPWR }; - for (int i = 0; i < ARRAYSIZE(binOp); i++) + for (int i = 0; i < size(binOp); i++) { if (nOpCode == static_cast(binOp[i])) { @@ -1762,7 +1762,7 @@ bool StandardCalculatorViewModel::IsRecoverableCommand(int nOpCode) Command::CommandF }; - for (int i = 0; i < ARRAYSIZE(recoverableCommands); i++) + for (int i = 0; i < size(recoverableCommands); i++) { if (nOpCode == static_cast(recoverableCommands[i])) { diff --git a/src/CalcViewModel/pch.h b/src/CalcViewModel/pch.h index b2717d17..1d03c5e5 100644 --- a/src/CalcViewModel/pch.h +++ b/src/CalcViewModel/pch.h @@ -26,7 +26,7 @@ #include #include #include - +#include // C++\WinRT Headers #include "winrt/base.h" #include "winrt/Windows.Foundation.Diagnostics.h" From 7cad778cc08d8c9f1f9965d6aca024f8bfecae0a Mon Sep 17 00:00:00 2001 From: Satya Date: Fri, 15 Mar 2019 09:51:17 +0530 Subject: [PATCH 3/6] Fix memory leak (#300) Free memory allocated to temp before returning from the function. --- src/CalcViewModel/StandardCalculatorViewModel.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index b035c14c..a95199b9 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -558,6 +558,7 @@ void StandardCalculatorViewModel::HandleUpdatedOperandData(Command cmdenum) length = m_selectedExpressionLastData->Length() + 1; if (length > 50) { + delete [] temp; return; } for (; i < length; ++i) From 62317fd63bc03d509798a596a872b28cff0f86e2 Mon Sep 17 00:00:00 2001 From: Rudy Huyn Date: Thu, 14 Mar 2019 22:35:55 -0700 Subject: [PATCH 4/6] Activate TextSelection on all interesting values/results (#213) If we allow users to select texts, the application will feel more like a "Desktop app", will be easier to use on a tablet and users will be more prompt to use Ctrl+C to use the result in another app. --- src/Calculator/App.xaml | 27 +++++++++++++----------- src/Calculator/Views/DateCalculator.xaml | 3 +++ src/Calculator/Views/HistoryList.xaml | 4 ++++ src/Calculator/Views/MemoryListItem.xaml | 2 ++ 4 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/Calculator/App.xaml b/src/Calculator/App.xaml index b06b7336..60103662 100644 --- a/src/Calculator/App.xaml +++ b/src/Calculator/App.xaml @@ -371,12 +371,13 @@ - - + - + + + - - + - + + + - - + - + + + @@ -602,6 +604,7 @@ AutomationProperties.LiveSetting="Polite" AutomationProperties.Name="{Binding StrDateResultAutomationName}" ContextFlyout="{StaticResource ResultsContextMenu}" + IsTextSelectionEnabled="True" Text="{Binding StrDateResult}"/> diff --git a/src/Calculator/Views/HistoryList.xaml b/src/Calculator/Views/HistoryList.xaml index 62c29e8a..60e2eb1d 100644 --- a/src/Calculator/Views/HistoryList.xaml +++ b/src/Calculator/Views/HistoryList.xaml @@ -64,15 +64,19 @@ ContextFlyout="{StaticResource HistoryContextMenu}"> diff --git a/src/Calculator/Views/MemoryListItem.xaml b/src/Calculator/Views/MemoryListItem.xaml index efe67d80..edba1e62 100644 --- a/src/Calculator/Views/MemoryListItem.xaml +++ b/src/Calculator/Views/MemoryListItem.xaml @@ -56,9 +56,11 @@ Date: Fri, 15 Mar 2019 02:30:07 -0400 Subject: [PATCH 5/6] Updating comments per the C++ core guidelines and removing trailing whitespace (#194) Fixed comments that were inconsistent with the style guidelines described in C++ core guidelines and the modern C++/WinRT language projections and removed trailing whitespace. Inserted a space after the beginning of the comment so the text wasn't touching the // on all occurrences. Removed all occurrences of trailing whitespace --- src/CalcManager/CEngine/History.cpp | 4 +- src/CalcManager/CEngine/scicomm.cpp | 18 +-- src/CalcManager/CEngine/scifunc.cpp | 2 +- src/CalcManager/CEngine/sciset.cpp | 18 +-- src/CalcManager/CalculatorHistory.cpp | 2 +- src/CalcManager/CalculatorManager.cpp | 16 +-- src/CalcManager/CalculatorManager.h | 4 +- src/CalcManager/CalculatorResource.h | 2 +- src/CalcManager/CalculatorVector.h | 2 +- src/CalcManager/Command.h | 2 +- src/CalcManager/ExpressionCommand.cpp | 34 +++--- src/CalcManager/Header Files/CCommand.h | 4 +- src/CalcManager/Header Files/CalcEngine.h | 2 +- src/CalcManager/Header Files/CalcInput.h | 2 +- src/CalcManager/Header Files/EngineStrings.h | 10 +- src/CalcManager/Header Files/History.h | 8 +- src/CalcManager/Ratpack/basex.cpp | 60 ++++----- src/CalcManager/Ratpack/conv.cpp | 4 +- src/CalcManager/Ratpack/exp.cpp | 42 +++---- src/CalcManager/Ratpack/fact.cpp | 32 ++--- src/CalcManager/Ratpack/itrans.cpp | 20 +-- src/CalcManager/Ratpack/itransh.cpp | 12 +- src/CalcManager/Ratpack/logic.cpp | 17 ++- src/CalcManager/Ratpack/num.cpp | 114 +++++++++--------- src/CalcManager/Ratpack/rat.cpp | 24 ++-- src/CalcManager/Ratpack/support.cpp | 36 +++--- src/CalcManager/Ratpack/trans.cpp | 18 +-- src/CalcManager/Ratpack/transh.cpp | 4 +- src/CalcManager/UnitConverter.cpp | 40 +++--- .../Common/AlwaysSelectedCollectionView.h | 28 ++--- .../Common/Automation/NarratorAnnouncement.h | 2 +- src/CalcViewModel/Common/BindableBase.cpp | 8 +- .../Common/CalculatorButtonUser.h | 2 +- .../Common/CalculatorDisplay.cpp | 2 +- .../Common/ConversionResultTaskHelper.h | 2 +- src/CalcViewModel/Common/CopyPasteManager.cpp | 2 +- src/CalcViewModel/Common/DateCalculator.cpp | 4 +- src/CalcViewModel/Common/DelegateCommand.h | 4 +- .../Common/KeyboardShortcutManager.cpp | 34 +++--- .../Common/LocalizationService.cpp | 14 +-- .../Common/LocalizationStringUtil.h | 6 +- src/CalcViewModel/Common/NavCategory.h | 6 +- src/CalcViewModel/Common/TraceLogger.cpp | 18 +-- src/CalcViewModel/Common/TraceLogger.h | 6 +- src/CalcViewModel/Common/Utils.cpp | 10 +- src/CalcViewModel/Common/Utils.h | 18 +-- .../Common/ValidatingConverters.h | 24 ++-- .../DataLoaders/CurrencyDataLoader.cpp | 4 +- .../DataLoaders/CurrencyDataLoader.h | 2 +- .../DataLoaders/UnitConverterDataLoader.cpp | 2 +- src/CalcViewModel/DateCalculatorViewModel.cpp | 4 +- src/CalcViewModel/HistoryItemViewModel.h | 8 +- src/CalcViewModel/HistoryViewModel.cpp | 2 +- .../StandardCalculatorViewModel.cpp | 22 ++-- .../StandardCalculatorViewModel.h | 2 +- src/CalcViewModel/UnitConverterViewModel.cpp | 22 ++-- src/CalcViewModel/UnitConverterViewModel.h | 18 +-- .../Common/AlwaysSelectedCollectionView.h | 30 ++--- src/Calculator/Common/AppLifecycleLogger.cpp | 2 +- src/Calculator/Common/AppLifecycleLogger.h | 6 +- src/Calculator/Common/BindableBase.cpp | 8 +- src/Calculator/Controls/CalculationResult.cpp | 20 +-- src/Calculator/Controls/CalculatorButton.cpp | 2 +- src/Calculator/Controls/CalculatorButton.h | 2 +- src/Calculator/Controls/FlipButtons.cpp | 2 +- src/Calculator/Controls/FlipButtons.h | 2 +- src/Calculator/Controls/OperandTextBox.cpp | 2 +- src/Calculator/Controls/OverflowTextBlock.cpp | 8 +- src/Calculator/Controls/OverflowTextBlock.h | 2 +- .../Converters/BooleanToVisibilityConverter.h | 2 +- src/Calculator/Views/UnitConverter.xaml.cpp | 4 +- src/Calculator/WindowFrameService.cpp | 2 +- src/Calculator/WindowFrameService.h | 14 +-- .../CalculatorManagerTest.cpp | 8 +- .../CurrencyConverterUnitTests.cpp | 2 +- .../MultiWindowUnitTests.cpp | 14 +-- .../StandardViewModelUnitTests.cpp | 22 ++-- src/CalculatorUnitTests/UnitConverterTest.cpp | 8 +- .../UnitConverterViewModelUnitTests.cpp | 20 +-- src/CalculatorUnitTests/UnitTestApp.xaml.cpp | 4 +- src/CalculatorUnitTests/pch.h | 2 +- src/CalculatorUnitTests/resource.h | 2 +- 82 files changed, 509 insertions(+), 510 deletions(-) diff --git a/src/CalcManager/CEngine/History.cpp b/src/CalcManager/CEngine/History.cpp index c91bc8a5..8dda170e 100644 --- a/src/CalcManager/CEngine/History.cpp +++ b/src/CalcManager/CEngine/History.cpp @@ -413,7 +413,7 @@ int CHistoryCollector::AddCommand(_In_ const std::shared_ptr return nCommands - 1; } -//To Update the operands in the Expression according to the current Radix +// To Update the operands in the Expression according to the current Radix void CHistoryCollector::UpdateHistoryExpression(uint32_t radix, int32_t precision) { if (m_spTokens != nullptr) @@ -451,7 +451,7 @@ void CHistoryCollector::SetDecimalSymbol(wchar_t decimalSymbol) m_decimalSymbol = decimalSymbol; } -//Update the commands corresponding to the passed string Number +// Update the commands corresponding to the passed string Number std::shared_ptr> CHistoryCollector::GetOperandCommandsFromString(wstring_view numStr) { std::shared_ptr> commands = std::make_shared>(); diff --git a/src/CalcManager/CEngine/scicomm.cpp b/src/CalcManager/CEngine/scicomm.cpp index 8a741bb1..cf23cf66 100644 --- a/src/CalcManager/CEngine/scicomm.cpp +++ b/src/CalcManager/CEngine/scicomm.cpp @@ -29,7 +29,7 @@ using namespace CalcEngine; namespace { // NPrecedenceOfOp // - // returns a virtual number for precedence for the operator. We expect binary operator only, otherwise the lowest number + // returns a virtual number for precedence for the operator. We expect binary operator only, otherwise the lowest number // 0 is returned. Higher the number, higher the precedence of the operator. INT NPrecedenceOfOp(int nopCode) { @@ -54,13 +54,13 @@ namespace { // HandleErrorCommand // -// When it is discovered by the state machine that at this point the input is not valid (eg. "1+)"), we want to proceed as though this input never +// When it is discovered by the state machine that at this point the input is not valid (eg. "1+)"), we want to proceed as though this input never // occurred and may be some feedback to user like Beep. The rest of input can then continue by just ignoring this command. void CCalcEngine::HandleErrorCommand(WPARAM idc) { if (!IsGuiSettingOpCode(idc)) { - // we would have saved the prev command. Need to forget this state + // We would have saved the prev command. Need to forget this state m_nTempCom = m_nLastCom; } } @@ -128,7 +128,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) } } - // Toggle Record/Display mode if appropriate. + // Toggle Record/Display mode if appropriate. if (m_bRecord) { if (IsOpInRange(wParam, IDC_AND, IDC_MMINUS) || @@ -182,7 +182,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) // BINARY OPERATORS: if (IsBinOpCode(wParam)) { - /* Change the operation if last input was operation. */ + // Change the operation if last input was operation. if (IsBinOpCode(m_nLastCom)) { INT nPrev; @@ -574,7 +574,7 @@ void CCalcEngine::ProcessCommandWorker(WPARAM wParam) m_lastVal = 0; if (IsBinOpCode(m_nLastCom)) { - // We want 1 + ( to start as 1 + (0. Any number you type replaces 0. But if it is 1 + 3 (, it is + // We want 1 + ( to start as 1 + (0. Any number you type replaces 0. But if it is 1 + 3 (, it is // treated as 1 + (3 m_currentVal = 0; } @@ -803,7 +803,7 @@ void CCalcEngine::CheckAndAddLastBinOpToHistory(bool addToHistory) { if (m_HistoryCollector.FOpndAddedToHistory()) { - // if last time opnd was added but the last command was not a binary operator, then it must have come + // if last time opnd was added but the last command was not a binary operator, then it must have come // from commands which add the operand, like unary operator. So history at this is showing 1 + sqrt(4) // but in reality the sqrt(4) is getting replaced by new number (may be unary op, or MR or SUM etc.) // So erase the last operand @@ -855,7 +855,7 @@ void CCalcEngine::DisplayAnnounceBinaryOperator() } // Unary operator Function Name table Element -// since unary operators button names aren't exactly friendly for history purpose, +// since unary operators button names aren't exactly friendly for history purpose, // we have this separate table to get its localized name and for its Inv function if it exists. typedef struct { @@ -1027,7 +1027,7 @@ wstring CCalcEngine::GetCurrentResultForRadix(uint32_t radix, int32_t precision) wstring numberString = GetStringForDisplay(rat, radix); if (!numberString.empty()) { - //revert the precision to previously stored precision + // Revert the precision to previously stored precision ChangeConstants(m_radix, m_precision); } diff --git a/src/CalcManager/CEngine/scifunc.cpp b/src/CalcManager/CEngine/scifunc.cpp index 75fbbfcf..9c7ef7a3 100644 --- a/src/CalcManager/CEngine/scifunc.cpp +++ b/src/CalcManager/CEngine/scifunc.cpp @@ -70,7 +70,7 @@ CalcEngine::Rational CCalcEngine::SciCalcFunctions(CalcEngine::Rational const& r uint64_t w64Bits = result.ToUInt64_t(); uint64_t lsb = ((w64Bits & 0x01) == 1) ? 1 : 0; - w64Bits >>= 1; //RShift by 1 + w64Bits >>= 1; // RShift by 1 w64Bits |= (lsb << (m_dwWordBitWidth - 1)); result = w64Bits; diff --git a/src/CalcManager/CEngine/sciset.cpp b/src/CalcManager/CEngine/sciset.cpp index d5bbe9dd..99f0b0b6 100644 --- a/src/CalcManager/CEngine/sciset.cpp +++ b/src/CalcManager/CEngine/sciset.cpp @@ -12,10 +12,10 @@ using namespace std; // dont change that. void CCalcEngine::SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwidth) { - // When in integer mode, the number is represented in 2's complement form. When a bit width is changing, we can - // change the number representation back to sign, abs num form in ratpak. Soon when display sees this, it will - // convert to 2's complement form, but this time all high bits will be propagated. Eg. -127, in byte mode is - // represented as 1000,0001. This puts it back as sign=-1, 01111111 . But DisplayNum will see this and convert it + // When in integer mode, the number is represented in 2's complement form. When a bit width is changing, we can + // change the number representation back to sign, abs num form in ratpak. Soon when display sees this, it will + // convert to 2's complement form, but this time all high bits will be propagated. Eg. -127, in byte mode is + // represented as 1000,0001. This puts it back as sign=-1, 01111111 . But DisplayNum will see this and convert it // back to 1111,1111,1000,0001 when in Word mode. if (m_fIntegerMode) { @@ -46,7 +46,7 @@ void CCalcEngine::SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwid // inform ratpak that a change in base or precision has occurred BaseOrPrecisionChanged(); - // display the correct number for the new state (ie convert displayed + // display the correct number for the new state (ie convert displayed // number to correct base) DisplayNum(); } @@ -143,7 +143,7 @@ void CCalcEngine::UpdateMaxIntDigits() if (m_fIntegerMode) { m_cIntDigitsSav = static_cast(m_maxDecimalValueStrings[m_numwidth].length()) - 1; - // This is the max digits you can enter a decimal in fixed width mode aka integer mode -1. The last digit + // This is the max digits you can enter a decimal in fixed width mode aka integer mode -1. The last digit // has to be checked separately } else @@ -161,10 +161,10 @@ void CCalcEngine::ChangeBaseConstants(uint32_t radix, int maxIntDigits, int32_t { if (10 == radix) { - ChangeConstants(radix, precision); // Base 10 precision for internal computing still needs to be 32, to + ChangeConstants(radix, precision); // Base 10 precision for internal computing still needs to be 32, to // take care of decimals precisely. For eg. to get the HI word of a qword, we do a rsh, which depends on getting - // 18446744073709551615 / 4294967296 = 4294967295.9999917... This is important it works this and doesn't reduce - // the precision to number of digits allowed to enter. In other words, precision and # of allowed digits to be + // 18446744073709551615 / 4294967296 = 4294967295.9999917... This is important it works this and doesn't reduce + // the precision to number of digits allowed to enter. In other words, precision and # of allowed digits to be // entered are different. } else diff --git a/src/CalcManager/CalculatorHistory.cpp b/src/CalcManager/CalculatorHistory.cpp index a34ca272..6b18a8e8 100644 --- a/src/CalcManager/CalculatorHistory.cpp +++ b/src/CalcManager/CalculatorHistory.cpp @@ -23,7 +23,7 @@ unsigned int CalculatorHistory::AddToHistory(_In_ shared_ptrGetString(&generatedExpression); - // Prefixing and suffixing the special Unicode markers to ensure that the expression + // Prefixing and suffixing the special Unicode markers to ensure that the expression // in the history doesn't get broken for RTL languages spHistoryItem->historyItemVector.expression = L'\u202d' + generatedExpression + L'\u202c'; spHistoryItem->historyItemVector.result = wstring(result); diff --git a/src/CalcManager/CalculatorManager.cpp b/src/CalcManager/CalculatorManager.cpp index 946d4676..0f6ccd49 100644 --- a/src/CalcManager/CalculatorManager.cpp +++ b/src/CalcManager/CalculatorManager.cpp @@ -300,7 +300,7 @@ namespace CalculationManager } /// - /// Convert Command to unsigned char. + /// Convert Command to unsigned char. /// Since some Commands are higher than 255, they are saved after subtracting 255 /// The smallest Command is CommandSIGN = 80, thus, subtracted value does not overlap with other values. /// @@ -435,9 +435,9 @@ namespace CalculationManager if (*commandItr >= MEMORY_COMMAND_TO_UNSIGNED_CHAR(MemoryCommand::MemorizeNumber) && *commandItr <= MEMORY_COMMAND_TO_UNSIGNED_CHAR(MemoryCommand::MemorizedNumberClearAll)) { - //MemoryCommands(which have values above 255) are pushed on m_savedCommands upon casting to unsigned char. - //SerializeCommands uses m_savedCommands, which is then used in DeSerializeCommands. - //Hence, a simple cast to MemoryCommand is not sufficient. + // MemoryCommands(which have values above 255) are pushed on m_savedCommands upon casting to unsigned char. + // SerializeCommands uses m_savedCommands, which is then used in DeSerializeCommands. + // Hence, a simple cast to MemoryCommand is not sufficient. MemoryCommand memoryCommand = static_cast(*commandItr + UCHAR_MAX + 1); unsigned int indexOfMemory = 0; switch (memoryCommand) @@ -761,7 +761,7 @@ namespace CalculationManager } void CalculatorManager::UpdateMaxIntDigits() - { + { m_currentCalculatorEngine->UpdateMaxIntDigits(); } @@ -785,7 +785,7 @@ namespace CalculationManager /// How Rational is serialized : /// Serialized Rational.P(Number) + Serialized Rational.Q(Number) /// How Number is saved : - /// [0] = Rational.P.Sign + /// [0] = Rational.P.Sign /// [1] = Rational.P.Mantissa.size /// [2] = Rational.P.Exp /// [3] = Rational.P.Mantissa[0] @@ -823,7 +823,7 @@ namespace CalculationManager /// /// Serialize Number to vector of long /// How Number is saved : - /// [0] = Number.Sign + /// [0] = Number.Sign /// [1] = Number.Mantissa.size /// [2] = Number.Exp /// [3] = Number.Mantissa[0] @@ -850,7 +850,7 @@ namespace CalculationManager /// /// DeserializeNumber vector and construct a Number /// How Number is saved : - /// [0] = Number.Sign + /// [0] = Number.Sign /// [1] = Number.Mantissa.size /// [2] = Number.Exp /// [3] = Number.Mantissa[0] diff --git a/src/CalcManager/CalculatorManager.h b/src/CalcManager/CalculatorManager.h index d3e354fc..69f4f75c 100644 --- a/src/CalcManager/CalculatorManager.h +++ b/src/CalcManager/CalculatorManager.h @@ -27,9 +27,9 @@ namespace CalculationManager ProgrammerModePrecision = 64 }; - // Numbering continues from the Enum Command from Command.h + // Numbering continues from the Enum Command from Command.h // with some gap to ensure there is no overlap of these ids - // when static_cast is performed on these ids + // when static_cast is performed on these ids // they shouldn't fall in any number range greater than 80. So never // make the memory command ids go below 330 enum class MemoryCommand diff --git a/src/CalcManager/CalculatorResource.h b/src/CalcManager/CalculatorResource.h index 51bdd8b6..3493234a 100644 --- a/src/CalcManager/CalculatorResource.h +++ b/src/CalcManager/CalculatorResource.h @@ -10,7 +10,7 @@ namespace CalculationManager public: virtual ~IResourceProvider() { } - // Should return a string from the resource table for strings used + // Should return a string from the resource table for strings used // by the calculation engine. The strings that must be defined // and the ids to define them with can be seen in EngineStrings.h // with SIDS prefix. Additionally it must provide values for string diff --git a/src/CalcManager/CalculatorVector.h b/src/CalcManager/CalculatorVector.h index 9e8c1a72..7fad7e7d 100644 --- a/src/CalcManager/CalculatorVector.h +++ b/src/CalcManager/CalculatorVector.h @@ -4,7 +4,7 @@ #pragma once template -class CalculatorVector +class CalculatorVector { public: HRESULT GetAt(_In_opt_ unsigned int index, _Out_ TType *item) diff --git a/src/CalcManager/Command.h b/src/CalcManager/Command.h index 25ad7cf0..e6eeb8ac 100644 --- a/src/CalcManager/Command.h +++ b/src/CalcManager/Command.h @@ -94,7 +94,7 @@ namespace CalculationManager CommandFAC = 113, CommandREC = 114, CommandDMS = 115, - CommandCUBEROOT = 116, //x ^ 1/3 + CommandCUBEROOT = 116, // x ^ 1/3 CommandPOW10 = 117, // 10 ^ x CommandPERCENT = 118, diff --git a/src/CalcManager/ExpressionCommand.cpp b/src/CalcManager/ExpressionCommand.cpp index 906104a6..08ee293c 100644 --- a/src/CalcManager/ExpressionCommand.cpp +++ b/src/CalcManager/ExpressionCommand.cpp @@ -75,19 +75,19 @@ void CUnaryCommand::Accept(_In_ ISerializeCommandVisitor &commandVisitor) CBinaryCommand::CBinaryCommand(int command) :m_command(command) {} -void CBinaryCommand::SetCommand(int command) -{ - m_command = command; +void CBinaryCommand::SetCommand(int command) +{ + m_command = command; } int CBinaryCommand::GetCommand() const -{ - return m_command; +{ + return m_command; } CalculationManager::CommandType CBinaryCommand::GetCommandType() const -{ - return CalculationManager::CommandType::BinaryCommand; +{ + return CalculationManager::CommandType::BinaryCommand; } void CBinaryCommand::Accept(_In_ ISerializeCommandVisitor &commandVisitor) @@ -111,8 +111,8 @@ void COpndCommand::Initialize(Rational const& rat) } const shared_ptr> & COpndCommand::GetCommands() const -{ - return m_commands; +{ + return m_commands; } void COpndCommand::SetCommands(shared_ptr> const& commands) @@ -166,7 +166,7 @@ void COpndCommand::RemoveFromEnd() { unsigned int nCommands; m_commands->GetSize(&nCommands); - + if (nCommands == 1) { ClearAllAndAppendCommand(CalculationManager::Command::Command0); @@ -185,8 +185,8 @@ void COpndCommand::RemoveFromEnd() } bool COpndCommand::IsNegative() const -{ - return m_fNegative; +{ + return m_fNegative; } bool COpndCommand::IsSciFmt() const @@ -195,13 +195,13 @@ bool COpndCommand::IsSciFmt() const } bool COpndCommand::IsDecimalPresent() const -{ - return m_fDecimal; +{ + return m_fDecimal; } CalculationManager::CommandType COpndCommand::GetCommandType() const -{ - return CalculationManager::CommandType::OperandCommand; +{ + return CalculationManager::CommandType::OperandCommand; } void COpndCommand::ClearAllAndAppendCommand(CalculationManager::Command command) @@ -283,7 +283,7 @@ const wstring & COpndCommand::GetToken(wchar_t decimalSymbol) m_token.clear(); m_token.append(&chZero); } - + return m_token; } diff --git a/src/CalcManager/Header Files/CCommand.h b/src/CalcManager/Header Files/CCommand.h index 1944061b..2fc08b3c 100644 --- a/src/CalcManager/Header Files/CCommand.h +++ b/src/CalcManager/Header Files/CCommand.h @@ -45,7 +45,7 @@ // Key IDs: -// These id's must be consecutive from IDC_FIRSTCONTROL to IDC_LASTCONTROL. +// These id's must be consecutive from IDC_FIRSTCONTROL to IDC_LASTCONTROL. // The actual values don't matter but the order and sequence are very important. // Also, the order of the controls must match the order of the control names // in the string table. @@ -97,7 +97,7 @@ #define IDC_FAC 113 #define IDC_REC 114 #define IDC_DMS 115 -#define IDC_CUBEROOT 116 //x ^ 1/3 +#define IDC_CUBEROOT 116 // x ^ 1/3 #define IDC_POW10 117 // 10 ^ x #define IDC_PERCENT 118 #define IDC_UNARYLAST IDC_PERCENT diff --git a/src/CalcManager/Header Files/CalcEngine.h b/src/CalcManager/Header Files/CalcEngine.h index a0a44ffd..3e151e2a 100644 --- a/src/CalcManager/Header Files/CalcEngine.h +++ b/src/CalcManager/Header Files/CalcEngine.h @@ -85,7 +85,7 @@ private: // if it hasn't yet been computed bool m_bChangeOp; /* Flag for changing operation. */ bool m_bRecord; // Global mode: recording or displaying - bool m_bSetCalcState; //Flag for setting the engine result state + bool m_bSetCalcState; // Flag for setting the engine result state CalcEngine::CalcInput m_input; // Global calc input object for decimal strings eNUMOBJ_FMT m_nFE; /* Scientific notation conversion flag. */ CalcEngine::Rational m_maxTrigonometricNum; diff --git a/src/CalcManager/Header Files/CalcInput.h b/src/CalcManager/Header Files/CalcInput.h index 4238e598..60d628c1 100644 --- a/src/CalcManager/Header Files/CalcInput.h +++ b/src/CalcManager/Header Files/CalcInput.h @@ -6,7 +6,7 @@ #include "Rational.h" // Space to hold enough digits for a quadword binary number (64) plus digit separator strings for that number (20) -constexpr int MAX_STRLEN = 84; +constexpr int MAX_STRLEN = 84; namespace CalcEngine { diff --git a/src/CalcManager/Header Files/EngineStrings.h b/src/CalcManager/Header Files/EngineStrings.h index 7a420c8c..2ada6bba 100644 --- a/src/CalcManager/Header Files/EngineStrings.h +++ b/src/CalcManager/Header Files/EngineStrings.h @@ -128,7 +128,7 @@ #define SIDS_NFACTORIAL L"33" #define SIDS_RECIPROCAL L"34" #define SIDS_DMS L"35" -#define SIDS_CUBEROOT L"36" +#define SIDS_CUBEROOT L"36" #define SIDS_POWTEN L"37" #define SIDS_PERCENT L"38" #define SIDS_SCIENTIFIC_NOTATION L"39" @@ -200,7 +200,7 @@ #define SIDS_NOMEM L"105" #define SIDS_TOOMANY L"106" #define SIDS_OVERFLOW L"107" -#define SIDS_NORESULT L"108" +#define SIDS_NORESULT L"108" #define SIDS_INSUFFICIENT_DATA L"109" // 110 is skipped by CSTRINGSENGMAX #define SIDS_ERR_UNK_CH L"111" @@ -214,7 +214,7 @@ #define SIDS_ERR_INPUT_OVERFLOW L"119" #define SIDS_ERR_OUTPUT_OVERFLOW L"120" -__declspec(selectany) std::wstring g_sids[] = +__declspec(selectany) std::wstring g_sids[] = { std::wstring(SIDS_PLUS_MINUS), std::wstring(SIDS_C), @@ -252,7 +252,7 @@ __declspec(selectany) std::wstring g_sids[] = std::wstring(SIDS_NFACTORIAL), std::wstring(SIDS_RECIPROCAL), std::wstring(SIDS_DMS), - std::wstring(SIDS_CUBEROOT), + std::wstring(SIDS_CUBEROOT), std::wstring(SIDS_POWTEN), std::wstring(SIDS_PERCENT), std::wstring(SIDS_SCIENTIFIC_NOTATION), @@ -324,7 +324,7 @@ __declspec(selectany) std::wstring g_sids[] = std::wstring(SIDS_NOMEM), std::wstring(SIDS_TOOMANY), std::wstring(SIDS_OVERFLOW), - std::wstring(SIDS_NORESULT), + std::wstring(SIDS_NORESULT), std::wstring(SIDS_INSUFFICIENT_DATA), std::wstring(SIDS_ERR_UNK_CH), std::wstring(SIDS_ERR_UNK_FN), diff --git a/src/CalcManager/Header Files/History.h b/src/CalcManager/Header Files/History.h index c8f418cb..4f82088f 100644 --- a/src/CalcManager/Header Files/History.h +++ b/src/CalcManager/Header Files/History.h @@ -10,8 +10,8 @@ // maximum depth you can get by precedence. It is just an array's size limit. static constexpr size_t MAXPRECDEPTH = 25; -// Helper class really a internal class to CCalcEngine, to accumulate each history line of text by collecting the -// operands, operator, unary operator etc. Since it is a separate entity, it can be unit tested on its own but does +// Helper class really a internal class to CCalcEngine, to accumulate each history line of text by collecting the +// operands, operator, unary operator etc. Since it is a separate entity, it can be unit tested on its own but does // rely on CCalcEngine calling it in appropriate order. class CHistoryCollector { public: @@ -39,13 +39,13 @@ private: ICalcDisplay *m_pCalcDisplay; int m_iCurLineHistStart; // index of the beginning of the current equation - // a sort of state, set to the index before 2 after 2 in the expression 2 + 3 say. Useful for auto correct portion of history and for + // a sort of state, set to the index before 2 after 2 in the expression 2 + 3 say. Useful for auto correct portion of history and for // attaching the unary op around the last operand int m_lastOpStartIndex; // index of the beginning of the last operand added to the history int m_lastBinOpStartIndex; // index of the beginning of the last binary operator added to the history std::array m_operandIndices; // Stack of index of opnd's beginning for each '('. A parallel array to m_hnoParNum, but abstracted independently of that int m_curOperandIndex; // Stack index for the above stack - bool m_bLastOpndBrace; // iff the last opnd in history is already braced so we can avoid putting another one for unary operator + bool m_bLastOpndBrace; // iff the last opnd in history is already braced so we can avoid putting another one for unary operator wchar_t m_decimalSymbol; std::shared_ptr>> m_spTokens; std::shared_ptr>> m_spCommands; diff --git a/src/CalcManager/Ratpack/basex.cpp b/src/CalcManager/Ratpack/basex.cpp index d36d7031..1d4a7303 100644 --- a/src/CalcManager/Ratpack/basex.cpp +++ b/src/CalcManager/Ratpack/basex.cpp @@ -2,17 +2,17 @@ // Licensed under the MIT License. //----------------------------------------------------------------------------- -// Package Title ratpak -// File basex.c -// Copyright (C) 1995-97 Microsoft -// Date 03-14-97 -// -// -// Description -// -// Contains number routines for internal base computations, these assume -// internal base is a power of 2. -// +// Package Title ratpak +// File basex.c +// Copyright (C) 1995-97 Microsoft +// Date 03-14-97 +// +// +// Description +// +// Contains number routines for internal base computations, these assume +// internal base is a power of 2. +// //----------------------------------------------------------------------------- #include "pch.h" #include "ratpak.h" @@ -41,7 +41,7 @@ void __inline mulnumx( PNUMBER *pa, PNUMBER b ) { // If b is not one we multiply if ( (*pa)->cdigit > 1 || (*pa)->mant[0] != 1 || (*pa)->exp != 0 ) - { + { // pa and b are both non-one. _mulnumx( pa, b ); } @@ -91,7 +91,7 @@ void _mulnumx( PNUMBER *pa, PNUMBER b ) MANTTYPE da=0; // da is the digit from the fist number. TWO_MANTTYPE cy=0; // cy is the carry resulting from the addition of // a multiplied row into the result. - TWO_MANTTYPE mcy=0; // mcy is the resultant from a single + TWO_MANTTYPE mcy=0; // mcy is the resultant from a single // multiply, AND the carry of that multiply. long icdigit=0; // Index of digit being calculated in final result. @@ -110,8 +110,8 @@ void _mulnumx( PNUMBER *pa, PNUMBER b ) { da = *ptra++; ptrb = b->mant; - - // Shift ptrc, and ptrcoffset, one for each digit + + // Shift ptrc, and ptrcoffset, one for each digit ptrc = ptrcoffset++; for ( ibdigit = b->cdigit; ibdigit > 0; ibdigit-- ) @@ -126,28 +126,28 @@ void _mulnumx( PNUMBER *pa, PNUMBER b ) c->cdigit++; } } - + // If result is nonzero, or while result of carry is nonzero... while ( mcy || cy ) { - + // update carry from addition(s) and multiply. cy += (TWO_MANTTYPE)ptrc[icdigit]+((DWORD)mcy&((DWORD)~BASEX)); - - // update result digit from + + // update result digit from ptrc[icdigit++]=(MANTTYPE)((DWORD)cy&((DWORD)~BASEX)); - + // update carries from mcy >>= BASEXPWR; cy >>= BASEXPWR; } - + ptrb++; ptrc++; - + } } - + // prevent different kinds of zeros, by stripping leading duplicate zeros. // digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) @@ -198,7 +198,7 @@ void numpowlongx( _Inout_ PNUMBER *proot, _In_ long power ) } destroynum( *proot ); *proot=lret; - + } void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision); @@ -275,14 +275,14 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) a=*pa; if ( thismax < a->cdigit ) { - // a has more digits than precision specified, bump up digits to shoot + // a has more digits than precision specified, bump up digits to shoot // for. thismax = a->cdigit; } if ( thismax < b->cdigit ) { - // b has more digits than precision specified, bump up digits to shoot + // b has more digits than precision specified, bump up digits to shoot // for. thismax = b->cdigit; } @@ -317,7 +317,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) digit *= 2; } if ( lessnum( rem, tmp ) ) - { + { // too far, back up... destroynum( tmp ); digit /= 2; @@ -326,7 +326,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) } tmp->sign *= -1; - addnum( &rem, tmp, BASEX ); + addnum( &rem, tmp, BASEX ); destroynum( tmp ); destroynum( lasttmp ); *ptrc |= digit; @@ -341,7 +341,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) } if ( !cdigits ) - { + { // A zero, make sure no weird exponents creep in c->exp = 0; c->cdigit = 1; @@ -350,7 +350,7 @@ void _divnumx( PNUMBER *pa, PNUMBER b, int32_t precision) { c->cdigit = cdigits; c->exp -= cdigits; - // prevent different kinds of zeros, by stripping leading duplicate + // prevent different kinds of zeros, by stripping leading duplicate // zeros. digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) { diff --git a/src/CalcManager/Ratpack/conv.cpp b/src/CalcManager/Ratpack/conv.cpp index 4e752246..ff7b18d5 100644 --- a/src/CalcManager/Ratpack/conv.cpp +++ b/src/CalcManager/Ratpack/conv.cpp @@ -801,7 +801,7 @@ PNUMBER longtonum( long inlong, uint32_t radix) // RETURN: number // // DESCRIPTION: Returns a number representation in the -// base requested of the unsigned long value passed in. Being unsigned number it has no +// base requested of the unsigned long value passed in. Being unsigned number it has no // negative number and takes the full range of unsigned number // //----------------------------------------------------------------------------- @@ -817,7 +817,7 @@ PNUMBER Ulongtonum(unsigned long inlong, uint32_t radix) pnumret->cdigit = 0; pnumret->exp = 0; pnumret->sign = 1; - + do { *pmant++ = (MANTTYPE)(inlong % radix); inlong /= radix; diff --git a/src/CalcManager/Ratpack/exp.cpp b/src/CalcManager/Ratpack/exp.cpp index 97d02c6b..8e0e58af 100644 --- a/src/CalcManager/Ratpack/exp.cpp +++ b/src/CalcManager/Ratpack/exp.cpp @@ -46,8 +46,8 @@ void _exprat( PRAT *px, int32_t precision) { CREATETAYLOR(); - addnum(&(pret->pp),num_one, BASEX); - addnum(&(pret->pq),num_one, BASEX); + addnum(&(pret->pp),num_one, BASEX); + addnum(&(pret->pq),num_one, BASEX); DUPRAT(thisterm,pret); n2=longtonum(0L, BASEX); @@ -81,7 +81,7 @@ void exprat( PRAT *px, uint32_t radix, int32_t precision) ratpowlong( &pwr, intpwr, precision); subrat(px, pint, precision); - + // It just so happens to be an integral power of e. if ( rat_gt( *px, rat_negsmallest, precision) && rat_lt( *px, rat_smallest, precision) ) { @@ -131,7 +131,7 @@ void _lograt( PRAT *px, int32_t precision) CREATETAYLOR(); createrat(thisterm); - + // sub one from x (*px)->pq->sign *= -1; addnum(&((*px)->pp),(*px)->pq, BASEX); @@ -158,14 +158,14 @@ void lograt( PRAT *px, int32_t precision) bool fneglog; PRAT pwr = nullptr; // pwr is the large scaling factor. PRAT offset = nullptr; // offset is the incremental scaling factor. - - + + // Check for someone taking the log of zero or a negative number. if ( rat_le( *px, rat_zero, precision) ) { throw( CALC_E_DOMAIN ); } - + // Get number > 1, for scaling fneglog = rat_lt( *px, rat_one, precision); if ( fneglog ) @@ -176,12 +176,12 @@ void lograt( PRAT *px, int32_t precision) (*px)->pp = (*px)->pq; (*px)->pq = pnumtemp; } - + // Scale the number within BASEX factor of 1, for the large scale. // log(x*2^(BASEXPWR*k)) = BASEXPWR*k*log(2)+log(x) if ( LOGRAT2(*px) > 1 ) { - // Take advantage of px's base BASEX to scale quickly down to + // Take advantage of px's base BASEX to scale quickly down to // a reasonable range. long intpwr; intpwr=LOGRAT2(*px)-1; @@ -206,17 +206,17 @@ void lograt( PRAT *px, int32_t precision) } _lograt(px, precision); - + // Add the large and small scaling factors, take into account // small scaling was done in e_to_one_half chunks. divrat(&offset, rat_two, precision); addrat(&pwr, offset, precision); - + // And add the resulting scaling factor to the answer. addrat(px, pwr, precision); trimit(px, precision); - + // If number started out < 1 rescale answer to negative. if ( fneglog ) { @@ -224,9 +224,9 @@ void lograt( PRAT *px, int32_t precision) } destroyrat(offset); - destroyrat(pwr); + destroyrat(pwr); } - + void log10rat( PRAT *px, int32_t precision) { @@ -235,7 +235,7 @@ void log10rat( PRAT *px, int32_t precision) } // -// return if the given x is even number. The assumption here is its denominator is 1 and we are testing the numerator is +// return if the given x is even number. The assumption here is its denominator is 1 and we are testing the numerator is // even or not bool IsEven(PRAT x, uint32_t radix, int32_t precision) { @@ -318,7 +318,7 @@ void powratNumeratorDenominator(PRAT *px, PRAT y, uint32_t radix, int32_t precis // 1. Initialize result. PRAT pxPow = nullptr; DUPRAT(pxPow, *px); - + // 2. Calculate pxPow = px ^ yNumerator // if yNumerator is not 1 if (!rat_equ(yNumerator, rat_one, precision)) @@ -341,7 +341,7 @@ void powratNumeratorDenominator(PRAT *px, PRAT y, uint32_t radix, int32_t precis PRAT originalResult = nullptr; DUPRAT(originalResult, pxPow); powratcomp(&originalResult, oneoveryDenom, radix, precision); - + // ################################## // Round the originalResult to roundedResult // ################################## @@ -375,7 +375,7 @@ void powratNumeratorDenominator(PRAT *px, PRAT y, uint32_t radix, int32_t precis else { DUPRAT(*px, originalResult); - } + } destroyrat(oneoveryDenom); destroyrat(originalResult); @@ -429,7 +429,7 @@ void powratcomp(PRAT *px, PRAT y, uint32_t radix, int32_t precision) sign = 1; } } - else + else { PRAT pxint= nullptr; DUPRAT(pxint,*px); @@ -491,7 +491,7 @@ void powratcomp(PRAT *px, PRAT y, uint32_t radix, int32_t precision) PRAT pNumerator = nullptr; PRAT pDenominator = nullptr; bool fBadExponent = false; - + // Get the numbers in arbitrary precision rational number format DUPRAT(pNumerator, rat_zero); // pNumerator->pq is 1 one DUPRAT(pDenominator, rat_zero); // pDenominator->pq is 1 one @@ -516,7 +516,7 @@ void powratcomp(PRAT *px, PRAT y, uint32_t radix, int32_t precision) } destroyrat(pNumerator); destroyrat(pDenominator); - + if (fBadExponent) { throw( CALC_E_DOMAIN ); diff --git a/src/CalcManager/Ratpack/fact.cpp b/src/CalcManager/Ratpack/fact.cpp index ab11451f..1a992bc0 100644 --- a/src/CalcManager/Ratpack/fact.cpp +++ b/src/CalcManager/Ratpack/fact.cpp @@ -73,17 +73,17 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) PRAT ratprec = nullptr; PRAT ratRadix = nullptr; long oldprec; - + // Set up constants and initial conditions oldprec = precision; ratprec = longtorat( oldprec ); - + // Find the best 'A' for convergence to the required precision. a=longtorat( radix ); lograt(&a, precision); mulrat(&a, ratprec, precision); - // Really is -ln(n)+1, but -ln(n) will be < 1 + // Really is -ln(n)+1, but -ln(n) will be < 1 // if we scale n between 0.5 and 1.5 addrat(&a, rat_two, precision); DUPRAT(tmp,a); @@ -91,9 +91,9 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) mulrat(&tmp, *pn, precision); addrat(&a, tmp, precision); addrat(&a, rat_one, precision); - + // Calculate the necessary bump in precision and up the precision. - // The following code is equivalent to + // The following code is equivalent to // precision += ln(exp(a)*pow(a,n+1.5))-ln(radix)); DUPRAT(tmp,*pn); one_pt_five=longtorat( 3L ); @@ -110,7 +110,7 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) lograt( &tmp, precision); subrat( &term, tmp, precision); precision += rattolong( term, radix, precision); - + // Set up initial terms for series, refer to series in above comment block. DUPRAT(factorial,rat_one); // Start factorial out with one count = longtonum( 0L, BASEX ); @@ -120,7 +120,7 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) // a2=a^2 DUPRAT(a2,a); mulrat(&a2, a, precision); - + // sum=(1/n)-(a/(n+1)) DUPRAT(sum,rat_one); divrat(&sum, *pn, precision); @@ -136,14 +136,14 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) divrat(&err, ratRadix, precision); // Just get something not tiny in term - DUPRAT(term, rat_two ); + DUPRAT(term, rat_two ); // Loop until precision is reached, or asked to halt. while ( !zerrat( term ) && rat_gt( term, err, precision) ) { addrat(pn, rat_two, precision); - - // WARNING: mixing numbers and rationals here. + + // WARNING: mixing numbers and rationals here. // for speed and efficiency. INC(count); mulnumx(&(factorial->pp),count); @@ -166,15 +166,15 @@ void _gamma( PRAT *pn, uint32_t radix, int32_t precision) DUPRAT(term,rat_one); divrat( &term, *pn, precision); subrat( &term, tmp, precision); - + divrat (&term, factorial, precision); addrat( &sum, term, precision); ABSRAT(term); } - + // Multiply by factor. mulrat( &sum, mpy, precision); - + // And cleanup precision = oldprec; destroyrat(ratprec); @@ -199,13 +199,13 @@ void factrat( PRAT *px, uint32_t radix, int32_t precision) PRAT fact = nullptr; PRAT frac = nullptr; PRAT neg_rat_one = nullptr; - + if ( rat_gt( *px, rat_max_fact, precision) || rat_lt( *px, rat_min_fact, precision) ) { // Don't attempt factorial of anything too large or small. throw CALC_E_OVERFLOW; } - + DUPRAT(fact,rat_one); DUPRAT(neg_rat_one,rat_one); @@ -226,7 +226,7 @@ void factrat( PRAT *px, uint32_t radix, int32_t precision) mulrat( &fact, *px, precision); subrat( px, rat_one, precision); } - + // Added to make numbers 'close enough' to integers use integer factorial. if ( LOGRATRADIX(*px) <= -precision) { diff --git a/src/CalcManager/Ratpack/itrans.cpp b/src/CalcManager/Ratpack/itrans.cpp index 66e6fc62..ef687b93 100644 --- a/src/CalcManager/Ratpack/itrans.cpp +++ b/src/CalcManager/Ratpack/itrans.cpp @@ -69,13 +69,13 @@ void _asinrat( PRAT *px, int32_t precision) { CREATETAYLOR(); - DUPRAT(pret,*px); + DUPRAT(pret,*px); DUPRAT(thisterm,*px); DUPNUM(n2,num_one); do { - NEXTTERM(xx,MULNUM(n2) MULNUM(n2) + NEXTTERM(xx,MULNUM(n2) MULNUM(n2) INC(n2) DIVNUM(n2) INC(n2) DIVNUM(n2), precision); } while ( !SMALL_ENOUGH_RAT( thisterm, precision) ); @@ -100,7 +100,7 @@ void asinrat( PRAT *px, uint32_t radix, int32_t precision) (*px)->pp->sign = 1; (*px)->pq->sign = 1; - + // Avoid the really bad part of the asin curve near +/-1. DUPRAT(phack,*px); subrat(&phack, rat_one, precision); @@ -185,15 +185,15 @@ void _acosrat( PRAT *px, int32_t precision) { CREATETAYLOR(); - createrat(thisterm); + createrat(thisterm); thisterm->pp=longtonum( 1L, BASEX ); - thisterm->pq=longtonum( 1L, BASEX ); + thisterm->pq=longtonum( 1L, BASEX ); DUPNUM(n2,num_one); do { - NEXTTERM(xx,MULNUM(n2) MULNUM(n2) + NEXTTERM(xx,MULNUM(n2) MULNUM(n2) INC(n2) DIVNUM(n2) INC(n2) DIVNUM(n2), precision); } while ( !SMALL_ENOUGH_RAT( thisterm, precision) ); @@ -210,7 +210,7 @@ void acosrat( PRAT *px, uint32_t radix, int32_t precision) (*px)->pp->sign = 1; (*px)->pq->sign = 1; - + if ( rat_equ( *px, rat_one, precision) ) { if ( sgn == -1 ) @@ -274,7 +274,7 @@ void _atanrat( PRAT *px, int32_t precision) { CREATETAYLOR(); - DUPRAT(pret,*px); + DUPRAT(pret,*px); DUPRAT(thisterm,*px); DUPNUM(n2,num_one); @@ -298,7 +298,7 @@ void atanrat( PRAT *px, uint32_t radix, int32_t precision) (*px)->pp->sign = 1; (*px)->pq->sign = 1; - + if ( rat_gt( (*px), pt_eight_five, precision) ) { if ( rat_gt( (*px), rat_two, precision) ) @@ -314,7 +314,7 @@ void atanrat( PRAT *px, uint32_t radix, int32_t precision) subrat(px, tmpx, precision); destroyrat( tmpx ); } - else + else { (*px)->pp->sign = sgn; DUPRAT(tmpx,*px); diff --git a/src/CalcManager/Ratpack/itransh.cpp b/src/CalcManager/Ratpack/itransh.cpp index 7b75e703..d6734a1f 100644 --- a/src/CalcManager/Ratpack/itransh.cpp +++ b/src/CalcManager/Ratpack/itransh.cpp @@ -60,7 +60,7 @@ void asinhrat( PRAT *px, uint32_t radix, int32_t precision) if ( rat_gt( *px, pt_eight_five, precision) || rat_lt( *px, neg_pt_eight_five, precision) ) { PRAT ptmp = nullptr; - DUPRAT(ptmp,(*px)); + DUPRAT(ptmp,(*px)); mulrat(&ptmp, *px, precision); addrat(&ptmp, rat_one, precision); rootrat(&ptmp, rat_two, radix, precision); @@ -73,14 +73,14 @@ void asinhrat( PRAT *px, uint32_t radix, int32_t precision) CREATETAYLOR(); xx->pp->sign *= -1; - DUPRAT(pret,(*px)); + DUPRAT(pret,(*px)); DUPRAT(thisterm,(*px)); DUPNUM(n2,num_one); do { - NEXTTERM(xx,MULNUM(n2) MULNUM(n2) + NEXTTERM(xx,MULNUM(n2) MULNUM(n2) INC(n2) DIVNUM(n2) INC(n2) DIVNUM(n2), precision); } while ( !SMALL_ENOUGH_RAT( thisterm, precision) ); @@ -99,7 +99,7 @@ void asinhrat( PRAT *px, uint32_t radix, int32_t precision) // hyperbolic cose of // RETURN: acosh of x in PRAT form. // -// EXPLANATION: This uses +// EXPLANATION: This uses // // acosh(x)=ln(x+sqrt(x^2-1)) // @@ -117,7 +117,7 @@ void acoshrat( PRAT *px, uint32_t radix, int32_t precision) else { PRAT ptmp = nullptr; - DUPRAT(ptmp,(*px)); + DUPRAT(ptmp,(*px)); mulrat(&ptmp, *px, precision); subrat(&ptmp, rat_one, precision); rootrat(&ptmp,rat_two, radix, precision); @@ -148,7 +148,7 @@ void atanhrat( PRAT *px, int32_t precision) { PRAT ptmp = nullptr; - DUPRAT(ptmp,(*px)); + DUPRAT(ptmp,(*px)); subrat(&ptmp, rat_one, precision); addrat(px, rat_one, precision); divrat(px, ptmp, precision); diff --git a/src/CalcManager/Ratpack/logic.cpp b/src/CalcManager/Ratpack/logic.cpp index ed598eca..ab5a63ed 100644 --- a/src/CalcManager/Ratpack/logic.cpp +++ b/src/CalcManager/Ratpack/logic.cpp @@ -49,7 +49,7 @@ void rshrat( PRAT *pa, PRAT b, uint32_t radix, int32_t precision) intrat(pa, radix, precision); if ( !zernum( (*pa)->pp ) ) - { + { // If input is zero we're done. if ( rat_lt( b, rat_min_exp, precision) ) { @@ -155,11 +155,11 @@ void boolnum( PNUMBER *pa, PNUMBER b, int func ) pchc = c->mant; for ( ;cdigits > 0; cdigits--, mexp++ ) { - da = ( ( ( mexp >= a->exp ) && ( cdigits + a->exp - c->exp > - (c->cdigit - a->cdigit) ) ) ? + da = ( ( ( mexp >= a->exp ) && ( cdigits + a->exp - c->exp > + (c->cdigit - a->cdigit) ) ) ? *pcha++ : 0 ); - db = ( ( ( mexp >= b->exp ) && ( cdigits + b->exp - c->exp > - (c->cdigit - b->cdigit) ) ) ? + db = ( ( ( mexp >= b->exp ) && ( cdigits + b->exp - c->exp > + (c->cdigit - b->cdigit) ) ) ? *pchb++ : 0 ); switch ( func ) { @@ -205,15 +205,14 @@ void modrat( PRAT *pa, PRAT b ) throw CALC_E_INDEFINITE; } DUPRAT(tmp,b); - + mulnumx( &((*pa)->pp), tmp->pq ); mulnumx( &(tmp->pp), (*pa)->pq ); remnum( &((*pa)->pp), tmp->pp, BASEX ); mulnumx( &((*pa)->pq), tmp->pq ); - - //Get *pa back in the integer over integer form. + + // Get *pa back in the integer over integer form. RENORMALIZE(*pa); destroyrat( tmp ); } - diff --git a/src/CalcManager/Ratpack/num.cpp b/src/CalcManager/Ratpack/num.cpp index 76fa91a1..817fe02c 100644 --- a/src/CalcManager/Ratpack/num.cpp +++ b/src/CalcManager/Ratpack/num.cpp @@ -2,20 +2,20 @@ // Licensed under the MIT License. //----------------------------------------------------------------------------- -// Package Title ratpak -// File num.c -// Copyright (C) 1995-97 Microsoft -// Date 01-16-95 -// -// -// Description -// -// Contains number routines for add, mul, div, rem and other support -// and longs. -// -// Special Information -// -// +// Package Title ratpak +// File num.c +// Copyright (C) 1995-97 Microsoft +// Date 01-16-95 +// +// +// Description +// +// Contains number routines for add, mul, div, rem and other support +// and longs. +// +// Special Information +// +// //----------------------------------------------------------------------------- #include "pch.h" #include "ratpak.h" @@ -76,8 +76,8 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) long fcomplb = 0; // fcomplb is a flag to signal b is negative. a=*pa; - - + + // Calculate the overlap of the numbers after alignment, this includes // necessary padding 0's cdigits = max( a->cdigit+a->exp, b->cdigit+b->exp ) - @@ -90,7 +90,7 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) pcha = a->mant; pchb = b->mant; pchc = c->mant; - + // Figure out the sign of the numbers if ( a->sign != b->sign ) { @@ -98,21 +98,21 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) fcompla = ( a->sign == -1 ); fcomplb = ( b->sign == -1 ); } - + // Loop over all the digits, real and 0 padded. Here we know a and b are - // aligned + // aligned for ( ;cdigits > 0; cdigits--, mexp++ ) { - + // Get digit from a, taking padding into account. - da = ( ( ( mexp >= a->exp ) && ( cdigits + a->exp - c->exp > - (c->cdigit - a->cdigit) ) ) ? + da = ( ( ( mexp >= a->exp ) && ( cdigits + a->exp - c->exp > + (c->cdigit - a->cdigit) ) ) ? *pcha++ : 0 ); // Get digit from b, taking padding into account. - db = ( ( ( mexp >= b->exp ) && ( cdigits + b->exp - c->exp > - (c->cdigit - b->cdigit) ) ) ? + db = ( ( ( mexp >= b->exp ) && ( cdigits + b->exp - c->exp > + (c->cdigit - b->cdigit) ) ) ? *pchb++ : 0 ); - + // Handle complementing for a and b digit. Might be a better way, but // haven't found it yet. if ( fcompla ) @@ -123,20 +123,20 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) { db = (MANTTYPE)(radix) - 1 - db; } - + // Update carry as necessary cy = da + db + cy; *pchc++ = (MANTTYPE)(cy % (MANTTYPE)radix); cy /= (MANTTYPE)radix; } - + // Handle carry from last sum as extra digit if ( cy && !(fcompla || fcomplb) ) { *pchc++ = cy; c->cdigit++; } - + // Compute sign of result if ( !(fcompla || fcomplb) ) { @@ -150,14 +150,14 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) } else { - // In this particular case an overflow or underflow has occurred - // and all the digits need to be complemented, at one time an - // attempt to handle this above was made, it turned out to be much + // In this particular case an overflow or underflow has occurred + // and all the digits need to be complemented, at one time an + // attempt to handle this above was made, it turned out to be much // slower on average. c->sign = -1; cy = 1; for ( ( cdigits = c->cdigit ), (pchc = c->mant); - cdigits > 0; + cdigits > 0; cdigits-- ) { cy = (MANTTYPE)radix - (MANTTYPE)1 - *pchc + cy; @@ -166,7 +166,7 @@ void _addnum( PNUMBER *pa, PNUMBER b, uint32_t radix) } } } - + // Remove leading zeros, remember digits are in order of // increasing significance. i.e. 100 would be 0,0,1 while ( c->cdigit > 1 && *(--pchc) == 0 ) @@ -231,7 +231,7 @@ void _mulnum( PNUMBER *pa, PNUMBER b, uint32_t radix) MANTTYPE da = 0; // da is the digit from the fist number. TWO_MANTTYPE cy = 0; // cy is the carry resulting from the addition of // a multiplied row into the result. - TWO_MANTTYPE mcy = 0; // mcy is the resultant from a single + TWO_MANTTYPE mcy = 0; // mcy is the resultant from a single // multiply, AND the carry of that multiply. long icdigit = 0; // Index of digit being calculated in final result. @@ -249,8 +249,8 @@ void _mulnum( PNUMBER *pa, PNUMBER b, uint32_t radix) { da = *pcha++; pchb = b->mant; - - // Shift pchc, and pchcoffset, one for each digit + + // Shift pchc, and pchcoffset, one for each digit pchc = pchcoffset++; for ( ibdigit = b->cdigit; ibdigit > 0; ibdigit-- ) @@ -268,23 +268,23 @@ void _mulnum( PNUMBER *pa, PNUMBER b, uint32_t radix) // If result is nonzero, or while result of carry is nonzero... while ( mcy || cy ) { - + // update carry from addition(s) and multiply. cy += (TWO_MANTTYPE)pchc[icdigit]+(mcy%(TWO_MANTTYPE)radix); - - // update result digit from + + // update result digit from pchc[icdigit++]=(MANTTYPE)(cy%(TWO_MANTTYPE)radix); - + // update carries from mcy /= (TWO_MANTTYPE)radix; cy /= (TWO_MANTTYPE)radix; } - + pchb++; pchc++; } } - + // prevent different kinds of zeros, by stripping leading duplicate zeros. // digits are in order of increasing significance. while ( c->cdigit > 1 && c->mant[c->cdigit-1] == 0 ) @@ -317,7 +317,7 @@ void remnum( PNUMBER *pa, PNUMBER b, uint32_t radix) { PNUMBER tmp = nullptr; // tmp is the working remainder. PNUMBER lasttmp = nullptr; // lasttmp is the last remainder which worked. - + // Once *pa is less than b, *pa is the remainder. while ( !lessnum( *pa, b ) ) { @@ -336,20 +336,20 @@ void remnum( PNUMBER *pa, PNUMBER b, uint32_t radix) destroynum( lasttmp ); lasttmp=longtonum( 0, radix); - while ( lessnum( tmp, *pa ) ) + while ( lessnum( tmp, *pa ) ) { DUPNUM( lasttmp, tmp ); addnum( &tmp, tmp, radix); } if ( lessnum( *pa, tmp ) ) - { + { // too far, back up... destroynum( tmp ); tmp=lasttmp; lasttmp= nullptr; } - + // Subtract the working remainder from the remainder holder. tmp->sign = -1*(*pa)->sign; addnum( pa, tmp, radix); @@ -357,7 +357,7 @@ void remnum( PNUMBER *pa, PNUMBER b, uint32_t radix) destroynum( tmp ); destroynum( lasttmp ); - } + } } @@ -381,7 +381,7 @@ void __inline divnum( PNUMBER *pa, PNUMBER b, uint32_t radix, int32_t precision) { if ( b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0 ) - { + { // b is not one _divnum( pa, b, radix, precision); } @@ -418,7 +418,7 @@ void _divnum( PNUMBER *pa, PNUMBER b, uint32_t radix, int32_t precision) tmp->sign = a->sign; rem->exp = b->cdigit + b->exp - rem->cdigit; - // Build a table of multiplications of the divisor, this is quicker for + // Build a table of multiplications of the divisor, this is quicker for // more than radix 'digits' list numberList{ longtonum(0L, radix) }; for (unsigned long i = 1; i < radix; i++) @@ -535,21 +535,21 @@ bool equnum( PNUMBER a, PNUMBER b ) pb += b->cdigit - 1; cdigits = max( a->cdigit, b->cdigit ); ccdigits = cdigits; - + // Loop over all digits until we run out of digits or there is a // difference in the digits. for ( ;cdigits > 0; cdigits-- ) { - da = ( (cdigits > (ccdigits - a->cdigit) ) ? + da = ( (cdigits > (ccdigits - a->cdigit) ) ? *pa-- : 0 ); - db = ( (cdigits > (ccdigits - b->cdigit) ) ? + db = ( (cdigits > (ccdigits - b->cdigit) ) ? *pb-- : 0 ); if ( da != db ) { return false; } } - + // In this case, they are equal. return true; } @@ -604,9 +604,9 @@ bool lessnum( PNUMBER a, PNUMBER b ) ccdigits = cdigits; for ( ;cdigits > 0; cdigits-- ) { - da = ( (cdigits > (ccdigits - a->cdigit) ) ? + da = ( (cdigits > (ccdigits - a->cdigit) ) ? *pa-- : 0 ); - db = ( (cdigits > (ccdigits - b->cdigit) ) ? + db = ( (cdigits > (ccdigits - b->cdigit) ) ? *pb-- : 0 ); diff = da-db; if ( diff ) @@ -639,8 +639,8 @@ bool zernum( PNUMBER a ) MANTTYPE *pcha; length = a->cdigit; pcha = a->mant; - - // loop over all the digits until you find a nonzero or until you run + + // loop over all the digits until you find a nonzero or until you run // out of digits while ( length-- > 0 ) { diff --git a/src/CalcManager/Ratpack/rat.cpp b/src/CalcManager/Ratpack/rat.cpp index 2d71dc24..e101458a 100644 --- a/src/CalcManager/Ratpack/rat.cpp +++ b/src/CalcManager/Ratpack/rat.cpp @@ -56,7 +56,7 @@ void gcdrat( PRAT *pa, int32_t precision) destroynum( pgcd ); *pa=a; - RENORMALIZE(*pa); + RENORMALIZE(*pa); } //----------------------------------------------------------------------------- @@ -82,7 +82,7 @@ void fracrat( PRAT *pa , uint32_t radix, int32_t precision) remnum( &((*pa)->pp), (*pa)->pq, BASEX ); - //Get *pa back in the integer over integer form. + // Get *pa back in the integer over integer form. RENORMALIZE(*pa); } @@ -100,7 +100,7 @@ void fracrat( PRAT *pa , uint32_t radix, int32_t precision) //----------------------------------------------------------------------------- void mulrat( PRAT *pa, PRAT b, int32_t precision) - + { // Only do the multiply if it isn't zero. if ( !zernum( (*pa)->pp ) ) @@ -170,7 +170,7 @@ void divrat( PRAT *pa, PRAT b, int32_t precision) #ifdef DIVGCD gcdrat( pa ); -#endif +#endif } @@ -215,13 +215,13 @@ void addrat( PRAT *pa, PRAT b, int32_t precision) if ( equnum( (*pa)->pq, b->pq ) ) { - // Very special case, q's match., + // Very special case, q's match., // make sure signs are involved in the calculation - // we have to do this since the optimization here is only + // we have to do this since the optimization here is only // working with the top half of the rationals. - (*pa)->pp->sign *= (*pa)->pq->sign; + (*pa)->pp->sign *= (*pa)->pq->sign; (*pa)->pq->sign = 1; - b->pp->sign *= b->pq->sign; + b->pp->sign *= b->pq->sign; b->pq->sign = 1; addnum( &((*pa)->pp), b->pp, BASEX ); } @@ -236,15 +236,15 @@ void addrat( PRAT *pa, PRAT b, int32_t precision) destroynum( (*pa)->pq ); (*pa)->pq = bot; trimit(pa, precision); - + // Get rid of negative zeros here. - (*pa)->pp->sign *= (*pa)->pq->sign; + (*pa)->pp->sign *= (*pa)->pq->sign; (*pa)->pq->sign = 1; } #ifdef ADDGCD gcdrat( pa ); -#endif +#endif } @@ -264,7 +264,7 @@ void addrat( PRAT *pa, PRAT b, int32_t precision) //----------------------------------------------------------------------------- void rootrat( PRAT *py, PRAT n, uint32_t radix, int32_t precision) -{ +{ // Initialize 1/n PRAT oneovern= nullptr; DUPRAT(oneovern,rat_one); diff --git a/src/CalcManager/Ratpack/support.cpp b/src/CalcManager/Ratpack/support.cpp index a0deaceb..f3b00d2f 100644 --- a/src/CalcManager/Ratpack/support.cpp +++ b/src/CalcManager/Ratpack/support.cpp @@ -58,7 +58,7 @@ static int cbitsofprecision = RATIO_FOR_DECIMAL * DECIMAL * CALC_DECIMAL_DIGITS_ #endif -bool g_ftrueinfinite = false; // Set to true if you don't want +bool g_ftrueinfinite = false; // Set to true if you don't want // chopping internally // precision used internally @@ -119,8 +119,8 @@ PRAT rat_max_long= nullptr; // max signed long void ChangeConstants(uint32_t radix, int32_t precision) { - // ratio is set to the number of digits in the current radix, you can get - // in the internal BASEX radix, this is important for length calculations + // ratio is set to the number of digits in the current radix, you can get + // in the internal BASEX radix, this is important for length calculations // in translating from radix to BASEX and back. uint64_t limit = static_cast(BASEX) / static_cast(radix); @@ -213,7 +213,7 @@ void ChangeConstants(uint32_t radix, int32_t precision) cbitsofprecision = g_ratio * radix * precision; - // Apparently when dividing 180 by pi, another (internal) digit of + // Apparently when dividing 180 by pi, another (internal) digit of // precision is needed. long extraPrecision = precision + g_ratio; DUPRAT(pi, rat_half); @@ -348,7 +348,7 @@ bool rat_ge( PRAT a, PRAT b, int32_t precision) b->pp->sign *= -1; addrat( &rattmp, b, precision); b->pp->sign *= -1; - bool bret = ( zernum( rattmp->pp ) || + bool bret = ( zernum( rattmp->pp ) || rattmp->pp->sign * rattmp->pq->sign == 1 ); destroyrat( rattmp ); return( bret ); @@ -472,10 +472,10 @@ void scale( PRAT *px, PRAT scalefact, uint32_t radix, int32_t precision ) { PRAT pret = nullptr; DUPRAT(pret,*px); - - // Logscale is a quick way to tell how much extra precision is needed for + + // Logscale is a quick way to tell how much extra precision is needed for // scaling by scalefact. - long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - + long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - (pret->pq->cdigit+pret->pq->exp) ); if ( logscale > 0 ) { @@ -508,9 +508,9 @@ void scale2pi( PRAT *px, uint32_t radix, int32_t precision ) PRAT my_two_pi = nullptr; DUPRAT(pret,*px); - // Logscale is a quick way to tell how much extra precision is needed for + // Logscale is a quick way to tell how much extra precision is needed for // scaling by 2 pi. - long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - + long logscale = g_ratio * ( (pret->pp->cdigit+pret->pp->exp) - (pret->pq->cdigit+pret->pq->exp) ); if ( logscale > 0 ) { @@ -663,16 +663,16 @@ void _readconstants( void ) // ARGUMENTS: PRAT *px, long precision // // -// DESCRIPTION: Chops off digits from rational numbers to avoid time -// explosions in calculations of functions using series. -// It can be shown that it is enough to only keep the first n digits -// of the largest of p or q in the rational p over q form, and of course -// scale the smaller by the same number of digits. This will give you -// n-1 digits of accuracy. This dramatically speeds up calculations +// DESCRIPTION: Chops off digits from rational numbers to avoid time +// explosions in calculations of functions using series. +// It can be shown that it is enough to only keep the first n digits +// of the largest of p or q in the rational p over q form, and of course +// scale the smaller by the same number of digits. This will give you +// n-1 digits of accuracy. This dramatically speeds up calculations // involving hundreds of digits or more. // The last part of this trim dealing with exponents never affects accuracy // -// RETURN: none, modifies the pointed to PRAT +// RETURN: none, modifies the pointed to PRAT // //--------------------------------------------------------------------------- @@ -680,7 +680,7 @@ void trimit( PRAT *px, int32_t precision) { if ( !g_ftrueinfinite ) - { + { long trim; PNUMBER pp=(*px)->pp; PNUMBER pq=(*px)->pq; diff --git a/src/CalcManager/Ratpack/trans.cpp b/src/CalcManager/Ratpack/trans.cpp index ad82a94d..5b46a936 100644 --- a/src/CalcManager/Ratpack/trans.cpp +++ b/src/CalcManager/Ratpack/trans.cpp @@ -47,8 +47,8 @@ void scalerat( _Inout_ PRAT *pa, ANGLE_TYPE angletype, uint32_t radix, int32_t p // EXPLANATION: This uses Taylor series // // n -// ___ 2j+1 -// \ ] j X +// ___ 2j+1 +// \ ] j X // \ -1 * --------- // / (2j+1)! // /__] @@ -73,7 +73,7 @@ void _sinrat( PRAT *px, int32_t precision) { CREATETAYLOR(); - DUPRAT(pret,*px); + DUPRAT(pret,*px); DUPRAT(thisterm,*px); DUPNUM(n2,num_one); @@ -84,11 +84,11 @@ void _sinrat( PRAT *px, int32_t precision) } while ( !SMALL_ENOUGH_RAT( thisterm, precision) ); DESTROYTAYLOR(); - - // Since *px might be epsilon above 1 or below -1, due to TRIMIT we need + + // Since *px might be epsilon above 1 or below -1, due to TRIMIT we need // this trick here. inbetween(px, rat_one, precision); - + // Since *px might be epsilon near zero we must set it to zero. if ( rat_le(*px, rat_smallest, precision) && rat_ge(*px, rat_negsmallest, precision) ) { @@ -166,13 +166,13 @@ void _cosrat( PRAT *px, uint32_t radix, int32_t precision) CREATETAYLOR(); destroynum(pret->pp); - destroynum(pret->pq); + destroynum(pret->pq); pret->pp=longtonum( 1L, radix); pret->pq=longtonum( 1L, radix); DUPRAT(thisterm,pret) - + n2=longtonum(0L, radix); xx->pp->sign *= -1; @@ -181,7 +181,7 @@ void _cosrat( PRAT *px, uint32_t radix, int32_t precision) } while ( !SMALL_ENOUGH_RAT( thisterm, precision) ); DESTROYTAYLOR(); - // Since *px might be epsilon above 1 or below -1, due to TRIMIT we need + // Since *px might be epsilon above 1 or below -1, due to TRIMIT we need // this trick here. inbetween(px, rat_one, precision); // Since *px might be epsilon near zero we must set it to zero. diff --git a/src/CalcManager/Ratpack/transh.cpp b/src/CalcManager/Ratpack/transh.cpp index fb756516..8a835341 100644 --- a/src/CalcManager/Ratpack/transh.cpp +++ b/src/CalcManager/Ratpack/transh.cpp @@ -80,7 +80,7 @@ void _sinhrat( PRAT *px, int32_t precision) CREATETAYLOR(); - DUPRAT(pret,*px); + DUPRAT(pret,*px); DUPRAT(thisterm,pret); DUPNUM(n2,num_one); @@ -194,7 +194,7 @@ void coshrat( PRAT *px, uint32_t radix, int32_t precision) { _coshrat( px, radix, precision); } - // Since *px might be epsilon below 1 due to TRIMIT + // Since *px might be epsilon below 1 due to TRIMIT // we need this trick here. if ( rat_lt(*px, rat_one, precision) ) { diff --git a/src/CalcManager/UnitConverter.cpp b/src/CalcManager/UnitConverter.cpp index e30934f4..bb1df9d6 100644 --- a/src/CalcManager/UnitConverter.cpp +++ b/src/CalcManager/UnitConverter.cpp @@ -46,7 +46,7 @@ UnitConverter::UnitConverter(_In_ const shared_ptr& dataLo { m_dataLoader = dataLoader; m_currencyDataLoader = currencyDataLoader; - //declaring the delimiter character conversion map + // declaring the delimiter character conversion map quoteConversions[L'|'] = L"{p}"; quoteConversions[L'['] = L"{lc}"; quoteConversions[L']'] = L"{rc}"; @@ -90,7 +90,7 @@ vector UnitConverter::GetCategories() } /// -/// Sets the current category in use by this converter, +/// Sets the current category in use by this converter, /// and returns a list of unit types that exist under the given category. /// /// Category struct which we are setting @@ -170,7 +170,7 @@ void UnitConverter::SetCurrentUnitTypes(const Unit& fromType, const Unit& toType /// /// Switches the active field, indicating that we are now entering data into /// what was originally the return field, and storing results into what was -/// originally the current field. We swap appropriate values, +/// originally the current field. We swap appropriate values, /// but do not callback, as values have not changed. /// /// @@ -420,7 +420,7 @@ void UnitConverter::RestoreUserPreferences(const wstring& userPreferences) /// /// Serializes the Category and Associated Units in the converter and returns it as a string -/// +/// wstring UnitConverter::SaveUserPreferences() { wstringstream out(wstringstream::out); @@ -441,7 +441,7 @@ wstring UnitConverter::Quote(const wstring& s) { wstringstream quotedString(wstringstream::out); - //Iterate over the delimiter characters we need to quote + // Iterate over the delimiter characters we need to quote wstring::const_iterator cursor = s.begin(); while(cursor != s.end()) { @@ -479,7 +479,7 @@ wstring UnitConverter::Unquote(const wstring& s) } if (cursor == s.end()) { - //badly formatted + // Badly formatted break; } else @@ -505,7 +505,7 @@ void UnitConverter::SendCommand(Command command) { if (CheckLoad()) { - //TODO: Localization of characters + // TODO: Localization of characters bool clearFront = false; if (m_currentDisplay == L"0") { @@ -625,7 +625,7 @@ void UnitConverter::SendCommand(Command command) default: break; } - + if (clearFront) { @@ -728,7 +728,7 @@ vector> UnitConverter::CalculateSuggested() vector intermediateVector; vector intermediateWhimsicalVector; unordered_map ratios = m_ratioMap[m_fromType]; - //Calculate converted values for every other unit type in this category, along with their magnitude + // Calculate converted values for every other unit type in this category, along with their magnitude for (const auto& cur : ratios) { if (cur.first != m_fromType && cur.first != m_toType) @@ -745,21 +745,21 @@ vector> UnitConverter::CalculateSuggested() } } - //Sort the resulting list by absolute magnitude, breaking ties by choosing the positive value + // Sort the resulting list by absolute magnitude, breaking ties by choosing the positive value sort(intermediateVector.begin(), intermediateVector.end(), [] (SuggestedValueIntermediate first, SuggestedValueIntermediate second) - { - if (abs(first.magnitude) == abs(second.magnitude)) - { - return first.magnitude > second.magnitude; - } - else - { + { + if (abs(first.magnitude) == abs(second.magnitude)) + { + return first.magnitude > second.magnitude; + } + else + { return abs(first.magnitude) < abs(second.magnitude); } }); - //Now that the list is sorted, iterate over it and populate the return vector with properly rounded and formatted return strings + // Now that the list is sorted, iterate over it and populate the return vector with properly rounded and formatted return strings for (const auto& entry : intermediateVector) { wstring roundedString; @@ -783,7 +783,7 @@ vector> UnitConverter::CalculateSuggested() } // The Whimsicals are determined differently - //Sort the resulting list by absolute magnitude, breaking ties by choosing the positive value + // Sort the resulting list by absolute magnitude, breaking ties by choosing the positive value sort(intermediateWhimsicalVector.begin(), intermediateWhimsicalVector.end(), [] (SuggestedValueIntermediate first, SuggestedValueIntermediate second) { @@ -797,7 +797,7 @@ vector> UnitConverter::CalculateSuggested() } }); - //Now that the list is sorted, iterate over it and populate the return vector with properly rounded and formatted return strings + // Now that the list is sorted, iterate over it and populate the return vector with properly rounded and formatted return strings vector> whimsicalReturnVector; for (const auto& entry : intermediateWhimsicalVector) diff --git a/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h b/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h index 40dd5cf3..54c3b67c 100644 --- a/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h +++ b/src/CalcViewModel/Common/AlwaysSelectedCollectionView.h @@ -3,9 +3,9 @@ #pragma once -namespace CalculatorApp { namespace Common +namespace CalculatorApp { namespace Common { - ref class AlwaysSelectedCollectionView sealed: + ref class AlwaysSelectedCollectionView sealed: public Windows::UI::Xaml::DependencyObject, public Windows::UI::Xaml::Data::ICollectionView { @@ -14,11 +14,11 @@ namespace CalculatorApp { namespace Common m_currentPosition(-1) { m_source = source; - + Windows::UI::Xaml::Interop::IBindableObservableVector^ observable = dynamic_cast(source); if (observable) { - observable->VectorChanged += + observable->VectorChanged += ref new Windows::UI::Xaml::Interop::BindableVectorChangedEventHandler(this, &AlwaysSelectedCollectionView::OnSourceBindableVectorChanged); } } @@ -53,7 +53,7 @@ namespace CalculatorApp { namespace Common return ref new Platform::Collections::Vector(); } } - property bool HasMoreItems + property bool HasMoreItems { virtual bool get() = Windows::UI::Xaml::Data::ICollectionView::HasMoreItems::get { @@ -77,7 +77,7 @@ namespace CalculatorApp { namespace Common } // The item is not in the collection - // We're going to schedule a call back later so we + // We're going to schedule a call back later so we // restore the selection to the way we wanted it to begin with if (m_currentPosition >= 0 && m_currentPosition < static_cast(m_source->Size)) { @@ -161,7 +161,7 @@ namespace CalculatorApp { namespace Common m_currentChanging -= token; } } - + // IVector // Not implemented methods virtual void Append(Platform::Object^ /*item*/) = Windows::Foundation::Collections::IVector::Append @@ -219,7 +219,7 @@ namespace CalculatorApp { namespace Common return m_source->Size; } } - + // IObservableVector event Windows::Foundation::Collections::VectorChangedEventHandler^ VectorChanged { @@ -262,9 +262,9 @@ namespace CalculatorApp { namespace Common private: virtual Platform::Object^ Convert( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert { auto result = dynamic_cast(value); @@ -276,9 +276,9 @@ namespace CalculatorApp { namespace Common } virtual Platform::Object^ ConvertBack( - Platform::Object^ /*value*/, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ /*value*/, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack { return Windows::UI::Xaml::DependencyProperty::UnsetValue; diff --git a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h index 70067d72..3ec6a5e3 100644 --- a/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h +++ b/src/CalcViewModel/Common/Automation/NarratorAnnouncement.h @@ -88,7 +88,7 @@ namespace CalculatorApp::Common::Automation static NarratorAnnouncement^ GetCategoryNameChangedAnnouncement(Platform::String^ announcement); static NarratorAnnouncement^ GetUpdateCurrencyRatesAnnouncement(Platform::String^ announcement); - + static NarratorAnnouncement^ GetDisplayCopiedAnnouncement(Platform::String^ announcement); static NarratorAnnouncement^ GetOpenParenthesisCountChangedAnnouncement(Platform::String^ announcement); diff --git a/src/CalcViewModel/Common/BindableBase.cpp b/src/CalcViewModel/Common/BindableBase.cpp index 270e68ac..b1fdcc78 100644 --- a/src/CalcViewModel/Common/BindableBase.cpp +++ b/src/CalcViewModel/Common/BindableBase.cpp @@ -18,17 +18,17 @@ void BindableBase::OnPropertyChanged(String^ propertyName) PropertyChanged(this, ref new PropertyChangedEventArgs(propertyName)); } -Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetCustomProperty(Platform::String^ name) +Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetCustomProperty(Platform::String^ name) { return nullptr; } -Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetIndexedProperty(Platform::String^ name, Windows::UI::Xaml::Interop::TypeName type) +Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetIndexedProperty(Platform::String^ name, Windows::UI::Xaml::Interop::TypeName type) { return nullptr; } -Platform::String^ BindableBase::GetStringRepresentation() +Platform::String^ BindableBase::GetStringRepresentation() { - return this->ToString(); + return this->ToString(); } diff --git a/src/CalcViewModel/Common/CalculatorButtonUser.h b/src/CalcViewModel/Common/CalculatorButtonUser.h index cd602c69..cc6647d9 100644 --- a/src/CalcViewModel/Common/CalculatorButtonUser.h +++ b/src/CalcViewModel/Common/CalculatorButtonUser.h @@ -80,7 +80,7 @@ namespace CalculatorApp D = (int) CM::Command::CommandD, E = (int) CM::Command::CommandE, F = (int) CM::Command::CommandF, - Memory, // This is the memory button. Doesn't have a direct mapping to the CalcEngine. + Memory, // This is the memory button. Doesn't have a direct mapping to the CalcEngine. Sinh = (int) CM::Command::CommandSINH, Cosh = (int) CM::Command::CommandCOSH, Tanh = (int) CM::Command::CommandTANH, diff --git a/src/CalcViewModel/Common/CalculatorDisplay.cpp b/src/CalcViewModel/Common/CalculatorDisplay.cpp index 36fe4fed..cd531e01 100644 --- a/src/CalcViewModel/Common/CalculatorDisplay.cpp +++ b/src/CalcViewModel/Common/CalculatorDisplay.cpp @@ -2,7 +2,7 @@ // Licensed under the MIT License. // This class provides the concrete implementation for the ICalcDisplay interface -// that is declared in the Calculation Manager Library. +// that is declared in the Calculation Manager Library. #include "pch.h" #include "CalculatorDisplay.h" #include "StandardCalculatorViewModel.h" diff --git a/src/CalcViewModel/Common/ConversionResultTaskHelper.h b/src/CalcViewModel/Common/ConversionResultTaskHelper.h index a89f3f14..2fe543c3 100644 --- a/src/CalcViewModel/Common/ConversionResultTaskHelper.h +++ b/src/CalcViewModel/Common/ConversionResultTaskHelper.h @@ -12,7 +12,7 @@ namespace CalculatorApp public: ConversionResultTaskHelper(unsigned int delay, const std::function functionToRun); ~ConversionResultTaskHelper(); - + private: concurrency::task CompleteAfter(unsigned int timeout); diff --git a/src/CalcViewModel/Common/CopyPasteManager.cpp b/src/CalcViewModel/Common/CopyPasteManager.cpp index 71215d49..c11630c4 100644 --- a/src/CalcViewModel/Common/CopyPasteManager.cpp +++ b/src/CalcViewModel/Common/CopyPasteManager.cpp @@ -135,7 +135,7 @@ String^ CopyPasteManager::ValidatePasteExpression(String^ pastedText, ViewMode m wstring pasteExpression = pastedText->Data(); - // Get english translated expression + // Get english translated expression String^ englishString = LocalizationSettings::GetInstance().GetEnglishValueFromLocalizedDigits(pasteExpression); // Removing the spaces, comma separator from the pasteExpression to allow pasting of expressions like 1 + 2+1,333 diff --git a/src/CalcViewModel/Common/DateCalculator.cpp b/src/CalcViewModel/Common/DateCalculator.cpp index 79092216..f00ae3c1 100644 --- a/src/CalcViewModel/Common/DateCalculator.cpp +++ b/src/CalcViewModel/Common/DateCalculator.cpp @@ -15,7 +15,7 @@ DateCalculationEngine::DateCalculationEngine(_In_ String^ calendarIdentifier) m_calendar->ChangeCalendarSystem(calendarIdentifier); } -// Adding Duration to a Date +// Adding Duration to a Date // Returns: True if function succeeds to calculate the date else returns False bool DateCalculationEngine::AddDuration(_In_ DateTime startDate, _In_ const DateDifference& duration, _Out_ DateTime *endDate) { @@ -52,7 +52,7 @@ bool DateCalculationEngine::AddDuration(_In_ DateTime startDate, _In_ const Date bool DateCalculationEngine::SubtractDuration(_In_ DateTime startDate, _In_ const DateDifference& duration, _Out_ DateTime *endDate) { // For Subtract the Algorithm is different than Add. Here the smaller units are subtracted first - // and then the larger units. + // and then the larger units. try { m_calendar->SetDateTime(startDate); diff --git a/src/CalcViewModel/Common/DelegateCommand.h b/src/CalcViewModel/Common/DelegateCommand.h index 0cd4fd79..ba29bb7c 100644 --- a/src/CalcViewModel/Common/DelegateCommand.h +++ b/src/CalcViewModel/Common/DelegateCommand.h @@ -21,10 +21,10 @@ namespace CalculatorApp private: - // Explicit, and private, implementation of ICommand, this way of programming makes it so + // Explicit, and private, implementation of ICommand, this way of programming makes it so // the ICommand methods will only be available if the ICommand interface is requested via a dynamic_cast // The ICommand interface is meant to be consumed by Xaml and not by the app, this is a defensive measure against - // code in the app calling Execute. + // code in the app calling Execute. virtual void ExecuteImpl(Platform::Object^ parameter) sealed = Windows::UI::Xaml::Input::ICommand::Execute { TTarget^ target = m_weakTarget.Resolve(); diff --git a/src/CalcViewModel/Common/KeyboardShortcutManager.cpp b/src/CalcViewModel/Common/KeyboardShortcutManager.cpp index 977ca13d..d7b87c96 100644 --- a/src/CalcViewModel/Common/KeyboardShortcutManager.cpp +++ b/src/CalcViewModel/Common/KeyboardShortcutManager.cpp @@ -56,7 +56,7 @@ namespace CalculatorApp { // Lights up all of the buttons in the given range // The range is defined by a pair of iterators - template + template void LightUpButtons(const T& buttons) { auto iterator = buttons.first; @@ -72,14 +72,14 @@ namespace CalculatorApp void LightUpButton(ButtonBase^ button) { - // If the button is a toggle button then we don't need + // If the button is a toggle button then we don't need // to change the UI of the button if (dynamic_cast(button)) { return; } - // The button will go into the visual Pressed state with this call + // The button will go into the visual Pressed state with this call VisualStateManager::GoToState(button, "Pressed", true); // This timer will fire after lightUpTime and make the button @@ -89,7 +89,7 @@ namespace CalculatorApp TimeSpan lightUpTime{}; lightUpTime.Duration = 500000L; // Half second (in 100-ns units) timer->Interval = lightUpTime; - + WeakReference timerWeakReference(timer); WeakReference buttonWeakReference(button); timer->Tick += ref new EventHandler( @@ -206,7 +206,7 @@ void KeyboardShortcutManager::HonorEscape() } void KeyboardShortcutManager::OnCharacterPropertyChanged( - DependencyObject^ target, + DependencyObject^ target, String^ oldValue, String^ newValue) { @@ -263,10 +263,10 @@ void KeyboardShortcutManager::OnVirtualKeyPropertyChanged( reader_writer_lock::scoped_lock lock(s_keyboardShortcutMapLock); auto button = static_cast(target); - + int viewId = Utils::GetWindowId(); auto iterViewMap = s_VirtualKeysForButtons.find(viewId); - + // Check if the View Id has already been registered if (iterViewMap != s_VirtualKeysForButtons.end()) { @@ -281,7 +281,7 @@ void KeyboardShortcutManager::OnVirtualKeyPropertyChanged( } void KeyboardShortcutManager::OnVirtualKeyControlChordPropertyChanged( - DependencyObject^ target, + DependencyObject^ target, MyVirtualKey /*oldValue*/, MyVirtualKey newValue) { @@ -537,7 +537,7 @@ void KeyboardShortcutManager::OnKeyDownHandler(CoreWindow^ sender, KeyEventArgs^ // Handle Ctrl + E for DateCalculator if ((key == VirtualKey::E) && - isControlKeyPressed && + isControlKeyPressed && !isShiftKeyPressed) { const auto& lookupMap = GetCurrentKeyDictionary(static_cast(key)); @@ -710,7 +710,7 @@ void KeyboardShortcutManager::OnAcceleratorKeyActivated(CoreDispatcher^, Acceler { int viewId = Utils::GetWindowId(); auto iterViewMap = s_AboutFlyout.find(viewId); - + if ((iterViewMap != s_AboutFlyout.end()) && (iterViewMap->second != nullptr)) { iterViewMap->second->Hide(); @@ -721,9 +721,9 @@ void KeyboardShortcutManager::OnAcceleratorKeyActivated(CoreDispatcher^, Acceler void KeyboardShortcutManager::Initialize() { auto coreWindow = Window::Current->CoreWindow; - coreWindow->CharacterReceived += + coreWindow->CharacterReceived += ref new TypedEventHandler(&KeyboardShortcutManager::OnCharacterReceivedHandler); - coreWindow->KeyDown += + coreWindow->KeyDown += ref new TypedEventHandler(&KeyboardShortcutManager::OnKeyDownHandler); coreWindow->KeyUp += ref new TypedEventHandler(&KeyboardShortcutManager::OnKeyUpHandler); @@ -758,7 +758,7 @@ void KeyboardShortcutManager::UpdateDropDownState(bool isOpen) void KeyboardShortcutManager::UpdateDropDownState(Flyout^ aboutPageFlyout) { int viewId = Utils::GetWindowId(); - + if (s_AboutFlyout.find(viewId) != s_AboutFlyout.end()) { s_AboutFlyout.erase(viewId); @@ -803,7 +803,7 @@ void KeyboardShortcutManager::RegisterNewAppViewId() { s_CharacterForButtons.insert(std::make_pair(appViewId, std::multimap())); } - + if (s_VirtualKeysForButtons.find(appViewId) == s_VirtualKeysForButtons.end()) { s_VirtualKeysForButtons.insert(std::make_pair(appViewId, std::multimap())); @@ -823,17 +823,17 @@ void KeyboardShortcutManager::RegisterNewAppViewId() { s_VirtualKeyAltChordsForButtons.insert(std::make_pair(appViewId, std::multimap())); } - + if (s_VirtualKeyControlShiftChordsForButtons.find(appViewId) == s_VirtualKeyControlShiftChordsForButtons.end()) { s_VirtualKeyControlShiftChordsForButtons.insert(std::make_pair(appViewId, std::multimap())); } - + if (s_VirtualKeyInverseChordsForButtons.find(appViewId) == s_VirtualKeyInverseChordsForButtons.end()) { s_VirtualKeyInverseChordsForButtons.insert(std::make_pair(appViewId, std::multimap())); } - + if (s_VirtualKeyControlInverseChordsForButtons.find(appViewId) == s_VirtualKeyControlInverseChordsForButtons.end()) { s_VirtualKeyControlInverseChordsForButtons.insert(std::make_pair(appViewId, std::multimap())); diff --git a/src/CalcViewModel/Common/LocalizationService.cpp b/src/CalcViewModel/Common/LocalizationService.cpp index df1d85b3..25c2f8a6 100644 --- a/src/CalcViewModel/Common/LocalizationService.cpp +++ b/src/CalcViewModel/Common/LocalizationService.cpp @@ -206,7 +206,7 @@ FontWeight LocalizationService::GetFontWeightOverride() double LocalizationService::GetFontScaleFactorOverride(LanguageFontType fontType) { assert(m_overrideFontApiValues); - + switch (fontType) { case LanguageFontType::UIText: @@ -271,12 +271,12 @@ void LocalizationService::UpdateFontFamilyAndSize(DependencyObject^ target) { control->FontSize = sizeToUse; } - else + else { control->ClearValue(Control::FontSizeProperty); } } - else + else { auto textBlock = dynamic_cast(target); if (textBlock) @@ -290,7 +290,7 @@ void LocalizationService::UpdateFontFamilyAndSize(DependencyObject^ target) { textBlock->FontSize = sizeToUse; } - else + else { textBlock->ClearValue(TextBlock::FontSizeProperty); } @@ -309,7 +309,7 @@ void LocalizationService::UpdateFontFamilyAndSize(DependencyObject^ target) { richTextBlock->FontSize = sizeToUse; } - else + else { richTextBlock->ClearValue(RichTextBlock::FontSizeProperty); } @@ -328,7 +328,7 @@ void LocalizationService::UpdateFontFamilyAndSize(DependencyObject^ target) { textElement->FontSize = sizeToUse; } - else + else { textElement->ClearValue(TextElement::FontSizeProperty); } @@ -416,7 +416,7 @@ IIterable^ LocalizationService::GetLanguageIdentifiers() int result = GetUserDefaultLocaleName(currentLocale, LOCALE_NAME_MAX_LENGTH); if (result != 0) { - // GetUserDefaultLocaleName may return an invalid bcp47 language tag with trailing non-BCP47 friendly characters, + // GetUserDefaultLocaleName may return an invalid bcp47 language tag with trailing non-BCP47 friendly characters, // which if present would start with an underscore, for example sort order // (see https://msdn.microsoft.com/en-us/library/windows/desktop/dd373814(v=vs.85).aspx). // Therefore, if there is an underscore in the locale name, trim all characters from the underscore onwards. diff --git a/src/CalcViewModel/Common/LocalizationStringUtil.h b/src/CalcViewModel/Common/LocalizationStringUtil.h index f3b69413..0516ae5a 100644 --- a/src/CalcViewModel/Common/LocalizationStringUtil.h +++ b/src/CalcViewModel/Common/LocalizationStringUtil.h @@ -20,11 +20,11 @@ namespace CalculatorApp va_list args = NULL; va_start(args, pMessage); DWORD fmtReturnVal = FormatMessage(FORMAT_MESSAGE_FROM_STRING, - pMessage, + pMessage, 0, 0, - spBuffer.get(), - length, + spBuffer.get(), + length, &args); va_end(args); diff --git a/src/CalcViewModel/Common/NavCategory.h b/src/CalcViewModel/Common/NavCategory.h index 61a8dbfc..33e6915a 100644 --- a/src/CalcViewModel/Common/NavCategory.h +++ b/src/CalcViewModel/Common/NavCategory.h @@ -141,7 +141,7 @@ namespace CalculatorApp property Platform::String^ AccessKey { - Platform::String^ get() + Platform::String^ get() { return m_accessKey; } @@ -220,11 +220,11 @@ namespace CalculatorApp static Windows::Foundation::Collections::IObservableVector^ CreateMenuOptions(); static Platform::String^ GetHeaderResourceKey(CategoryGroupType type); - + internal: static NavCategoryGroup^ CreateCalculatorCategory(); static NavCategoryGroup^ CreateConverterCategory(); - + private: NavCategoryGroup(const NavCategoryGroupInitializer& groupInitializer); diff --git a/src/CalcViewModel/Common/TraceLogger.cpp b/src/CalcViewModel/Common/TraceLogger.cpp index c83752b1..bbf6e605 100644 --- a/src/CalcViewModel/Common/TraceLogger.cpp +++ b/src/CalcViewModel/Common/TraceLogger.cpp @@ -103,7 +103,7 @@ namespace CalculatorApp g_calculatorProvider( L"MicrosoftCalculator", LoggingChannelOptions(GUID{ 0x4f50731a, 0x89cf, 0x4782, 0xb3, 0xe0, 0xdc, 0xe8, 0xc9, 0x4, 0x76, 0xba }), // Microsoft Telemetry group - GUID{ 0x905ca09, 0x610e, 0x401e, 0xb6, 0x50, 0x2f, 0x21, 0x29, 0x80, 0xb9, 0xe0 }), //Unique providerID {0905CA09-610E-401E-B650-2F212980B9E0} + GUID{ 0x905ca09, 0x610e, 0x401e, 0xb6, 0x50, 0x2f, 0x21, 0x29, 0x80, 0xb9, 0xe0 }), // Unique providerID {0905CA09-610E-401E-B650-2F212980B9E0} m_appLaunchActivity{ nullptr } { // initialize the function array @@ -248,7 +248,7 @@ namespace CalculatorApp { windowIdLog.insert(pair(windowId, false)); } - // if the event is not logged already for the present mode + // if the event is not logged already for the present mode if (currentMode != mode) { currentMode = mode; @@ -271,7 +271,7 @@ namespace CalculatorApp { windowIdLog.insert(pair(windowId, false)); } - // if the event is not logged already for the present mode + // if the event is not logged already for the present mode if (currentMode != mode) { currentMode = mode; @@ -293,7 +293,7 @@ namespace CalculatorApp { windowIdLog.insert(pair(windowId, false)); } - // if the event is not logged already for the present mode + // if the event is not logged already for the present mode if (currentMode != mode) { currentMode = mode; @@ -482,9 +482,9 @@ namespace CalculatorApp LogTelemetryEvent(EVENT_NAME_MEMORY_BODY_OPENED, fields); } - //If calculator is launched in any mode other than standard then this call will come which is not intended. But there is no way to avoid it. - //So don't use this function to analyze the count of mode change in session instead use CalculatorViewedInSession and ConverterViewedInSession to do that. - //Use of this function is to analyze perf of mode change. + // If calculator is launched in any mode other than standard then this call will come which is not intended. But there is no way to avoid it. + // So don't use this function to analyze the count of mode change in session instead use CalculatorViewedInSession and ConverterViewedInSession to do that. + // Use of this function is to analyze perf of mode change. void TraceLogger::LogModeChangeBegin(ViewMode fromMode, ViewMode toMode, int windowId) { if (!GetTraceLoggingProviderEnabled()) return; @@ -499,7 +499,7 @@ namespace CalculatorApp } } - //comment: same as LogModeChangeBegin + // comment: same as LogModeChangeBegin void TraceLogger::LogModeChangeEnd(ViewMode toMode, int windowId) const { if (!GetTraceLoggingProviderEnabled()) return; @@ -578,7 +578,7 @@ namespace CalculatorApp // Writer lock for the static resources reader_writer_lock::scoped_lock lock(s_traceLoggerLock); auto iterMap = s_memoryMap.find(windowId); - + LoggingFields fields{}; LogTelemetryEvent(EVENT_NAME_MEMORY_CLEAR_ALL, fields); diff --git a/src/CalcViewModel/Common/TraceLogger.h b/src/CalcViewModel/Common/TraceLogger.h index 9c348dca..2b659047 100644 --- a/src/CalcViewModel/Common/TraceLogger.h +++ b/src/CalcViewModel/Common/TraceLogger.h @@ -9,8 +9,8 @@ static const int maxFunctionSize = (int)CalculationManager::Command::CommandBINEDITEND; -// A trace logging provider can only be instantiated and registered once per module. -// This class implements a singleton model ensure that only one instance is created. +// A trace logging provider can only be instantiated and registered once per module. +// This class implements a singleton model ensure that only one instance is created. namespace CalculatorApp { struct FuncLog @@ -105,7 +105,7 @@ namespace CalculatorApp // Any new Log method should // a) decide the level of logging. This will help us in limiting recording of events only up to a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx - // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios + // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios // b) should decide whether or not to log to telemetry and pass TraceLoggingKeyword(MICROSOFT_KEYWORD_TELEMETRY) accordingly // c) Should accept a variable number of additional data arguments if needed void LogTelemetryEvent(std::wstring_view eventName, winrt::Windows::Foundation::Diagnostics::LoggingFields fields) const; diff --git a/src/CalcViewModel/Common/Utils.cpp b/src/CalcViewModel/Common/Utils.cpp index 55e78e6c..0ab05b1d 100644 --- a/src/CalcViewModel/Common/Utils.cpp +++ b/src/CalcViewModel/Common/Utils.cpp @@ -54,7 +54,7 @@ double Utils::GetDoubleFromWstring(wstring input) return ::atof(inputString.c_str()); } -//returns windowId for the current view +// Returns windowId for the current view int Utils::GetWindowId() { int windowId = -1; @@ -80,20 +80,20 @@ void Utils::RunOnUIThreadNonblocking(std::function&& function, _In_ Core } } -// returns if the last character of a wstring is the target wchar_t +// Returns if the last character of a wstring is the target wchar_t bool Utils::IsLastCharacterTarget(_In_ wstring const &input, _In_ wchar_t target) { return !input.empty() && input.back() == target; } -//return wstring after removing characters like space, comma, and double quotes +// Returns wstring after removing characters like space, comma, and double quotes wstring Utils::RemoveUnwantedCharsFromWstring(wstring input) { wchar_t unWantedChars[] = { L' ', L',', L'"', 8234, 8235, 8236, 8237 }; return RemoveUnwantedCharsFromWstring(input, unWantedChars, 6); } -//return wstring after removing characters specified by unwantedChars array +// Returns wstring after removing characters specified by unwantedChars array wstring Utils::RemoveUnwantedCharsFromWstring(wstring input, wchar_t* unwantedChars, unsigned int size) { for (unsigned int i = 0; i < size; ++i) @@ -110,7 +110,7 @@ void Utils::SerializeCommandsAndTokens(_In_ shared_ptrGetSize(&commandsSize)); - // save the size of the commands vector + // Save the size of the commands vector writer->WriteUInt32(commandsSize); SerializeCommandVisitor cmdVisitor(writer); diff --git a/src/CalcViewModel/Common/Utils.h b/src/CalcViewModel/Common/Utils.h index d682a76a..37d6c6ba 100644 --- a/src/CalcViewModel/Common/Utils.h +++ b/src/CalcViewModel/Common/Utils.h @@ -54,11 +54,11 @@ #ifndef UNIT_TESTS #define OBSERVABLE_OBJECT() virtual event Windows::UI::Xaml::Data::PropertyChangedEventHandler^ PropertyChanged;\ internal: void RaisePropertyChanged(Platform::String^ p) {\ - PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); } public: + PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p)); } public: #else #define OBSERVABLE_OBJECT() virtual event Windows::UI::Xaml::Data::PropertyChangedEventHandler^ PropertyChanged;\ internal: void RaisePropertyChanged(Platform::String^ p) {\ - } public: + } public: #endif // The callback specified in the macro is a method in the class that will be called every time the object changes @@ -68,21 +68,21 @@ internal: void RaisePropertyChanged(Platform::String^ p) {\ PropertyChanged(this, ref new Windows::UI::Xaml::Data::PropertyChangedEventArgs(p));\ c(p);\ - } public: + } public: #else #define OBSERVABLE_OBJECT_CALLBACK(c) virtual event Windows::UI::Xaml::Data::PropertyChangedEventHandler^ PropertyChanged;\ internal: void RaisePropertyChanged(Platform::String^ p) {\ c(p);\ - } public: + } public: #endif -// The variable member generated by this macro should not be used in the class code, use the -// property getter instead. +// The variable member generated by this macro should not be used in the class code, use the +// property getter instead. #define COMMAND_FOR_METHOD(p, m) property Windows::UI::Xaml::Input::ICommand^ p {\ Windows::UI::Xaml::Input::ICommand^ get() {\ if (!donotuse_##p) {\ donotuse_##p = CalculatorApp::Common::MakeDelegate(this, &m);\ - } return donotuse_##p; }} private: Windows::UI::Xaml::Input::ICommand^ donotuse_##p; public: + } return donotuse_##p; }} private: Windows::UI::Xaml::Input::ICommand^ donotuse_##p; public: #define DEPENDENCY_PROPERTY_DECLARATION(t, n)\ property t n {\ @@ -141,7 +141,7 @@ namespace Utils const wchar_t PDF = 0x202c; // Pop Directional Formatting const wchar_t LRO = 0x202d; // Left-to-Right Override - // Regular DependencyProperty + // Regular DependencyProperty template Windows::UI::Xaml::DependencyProperty^ RegisterDependencyProperty( _In_ const wchar_t* const name, @@ -205,7 +205,7 @@ namespace Utils ref new Windows::UI::Xaml::PropertyChangedCallback(callback))); } - // Attached DependencyProperty + // Attached DependencyProperty template Windows::UI::Xaml::DependencyProperty^ RegisterDependencyPropertyAttached( _In_ const wchar_t* const name, diff --git a/src/CalcViewModel/Common/ValidatingConverters.h b/src/CalcViewModel/Common/ValidatingConverters.h index 9b99cbcd..b33c148f 100644 --- a/src/CalcViewModel/Common/ValidatingConverters.h +++ b/src/CalcViewModel/Common/ValidatingConverters.h @@ -14,9 +14,9 @@ namespace CalculatorApp { namespace Common private: virtual Platform::Object^ Convert( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert { // Pass through as we don't want to change the value from the source @@ -24,9 +24,9 @@ namespace CalculatorApp { namespace Common } virtual Platform::Object^ ConvertBack( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack { if (value) @@ -47,9 +47,9 @@ namespace CalculatorApp { namespace Common private: virtual Platform::Object^ Convert( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert { // Pass through as we don't want to change the value from the source @@ -57,9 +57,9 @@ namespace CalculatorApp { namespace Common } virtual Platform::Object^ ConvertBack( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack { // The value to be valid has to be a boxed int32 value diff --git a/src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp b/src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp index 4bb4f727..48c64d42 100644 --- a/src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp +++ b/src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp @@ -203,7 +203,7 @@ void CurrencyDataLoader::LoadData() } } - co_return didLoad; + co_return didLoad; }).then([this](bool didLoad) { UpdateDisplayedTimestamp(); @@ -329,7 +329,7 @@ task CurrencyDataLoader::TryLoadDataFromCacheAsync() { loadComplete = co_await TryLoadDataFromWebAsync(); } - + if (!loadComplete) { loadComplete = co_await TryFinishLoadFromCacheAsync(); diff --git a/src/CalcViewModel/DataLoaders/CurrencyDataLoader.h b/src/CalcViewModel/DataLoaders/CurrencyDataLoader.h index cdb006bb..eba76641 100644 --- a/src/CalcViewModel/DataLoaders/CurrencyDataLoader.h +++ b/src/CalcViewModel/DataLoaders/CurrencyDataLoader.h @@ -87,7 +87,7 @@ namespace CalculatorApp bool TryParseWebResponses( _In_ Platform::String^ staticDataJson, - _In_ Platform::String^ allRatiosJson, + _In_ Platform::String^ allRatiosJson, _Inout_ std::vector& staticData, _Inout_ CurrencyRatioMap& allRatiosData); bool TryParseStaticData(_In_ Platform::String^ rawJson, _Inout_ std::vector& staticData); diff --git a/src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp b/src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp index dea93bbb..45411c1d 100644 --- a/src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp +++ b/src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp @@ -200,7 +200,7 @@ void UnitConverterDataLoader::GetUnits(_In_ unordered_map>> const &spTokens, _In_ std::shared_ptr>> const &spCommands); std::shared_ptr>> const& GetTokens() { - return m_spTokens; + return m_spTokens; } std::shared_ptr>> const& GetCommands() - { - return m_spCommands; + { + return m_spCommands; } public: diff --git a/src/CalcViewModel/HistoryViewModel.cpp b/src/CalcViewModel/HistoryViewModel.cpp index 4e9fb839..e3cda23e 100644 --- a/src/CalcViewModel/HistoryViewModel.cpp +++ b/src/CalcViewModel/HistoryViewModel.cpp @@ -64,7 +64,7 @@ void HistoryViewModel::ReloadHistory(_In_ ViewMode currentMode) if (historyListModel.size() > 0) { for (auto ritr = historyListModel.rbegin(); ritr != historyListModel.rend(); ++ritr) - { + { wstring expression = (*ritr)->historyItemVector.expression; wstring result = (*ritr)->historyItemVector.result; localizer.LocalizeDisplayValue(&expression); diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index a95199b9..7f4b6332 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -43,7 +43,7 @@ namespace CalculatorApp::ViewModel StringReference BinaryDisplayValue(L"BinaryDisplayValue"); StringReference OpenParenthesisCount(L"OpenParenthesisCount"); } - + namespace CalculatorResourceKeys { StringReference CalculatorExpression(L"Format_CalculatorExpression"); @@ -516,7 +516,7 @@ void StandardCalculatorViewModel::HandleUpdatedOperandData(Command cmdenum) if (IsOperandTextCompletelySelected) { - //Clear older text; + // Clear older text; m_selectedExpressionLastData = L""; if (ch == L'x') { @@ -606,7 +606,7 @@ void StandardCalculatorViewModel::OnButtonPressed(Object^ parameter) if (IsInError) { m_standardCalculatorManager.SendCommand(Command::CommandCLEAR); - + if (!IsRecoverableCommand((int)numOpEnum)) { return; @@ -869,8 +869,8 @@ void StandardCalculatorViewModel::OnPaste(String^ pastedString, ViewMode mode) Command cmdenum = ConvertToOperatorsEnum(mappedNumOp); m_standardCalculatorManager.SendCommand(cmdenum); - // The CalcEngine state machine won't allow the negate command to be sent before any - // other digits, so instead a flag is set and the command is sent after the first appropriate + // The CalcEngine state machine won't allow the negate command to be sent before any + // other digits, so instead a flag is set and the command is sent after the first appropriate // command. if (sendNegate) { @@ -1196,10 +1196,10 @@ Array^ StandardCalculatorViewModel::Serialize() writer->WriteInt32(data); } - //For ProgrammerMode + // For ProgrammerMode writer->WriteUInt32(static_cast(CurrentRadixType)); - //Serialize commands of calculator manager + // Serialize commands of calculator manager vector serializedCommand = m_standardCalculatorManager.SerializeCommands(); writer->WriteUInt32(static_cast(serializedCommand.size())); writer->WriteBytes(ref new Array(serializedCommand.data(), static_cast(serializedCommand.size()))); @@ -1209,7 +1209,7 @@ Array^ StandardCalculatorViewModel::Serialize() Utils::SerializeCommandsAndTokens(m_tokens, m_commands, writer); } - //Convert viewmodel data in writer to bytes + // Convert viewmodel data in writer to bytes IBuffer^ buffer = writer->DetachBuffer(); DataReader^ reader = DataReader::FromBuffer(buffer); Platform::Array^ viewModelDataAsBytes = ref new Array(buffer->Length); @@ -1257,7 +1257,7 @@ void StandardCalculatorViewModel::Deserialize(Array^ state) m_standardCalculatorManager.DeSerializePrimaryDisplay(serializedPrimaryDisplay); CurrentRadixType = reader->ReadUInt32(); - //Read command data and Deserialize + // Read command data and Deserialize UINT32 modeldatalength = reader->ReadUInt32(); Array^ modelDataAsBytes = ref new Array(modeldatalength); reader->ReadBytes(modelDataAsBytes); @@ -1604,7 +1604,7 @@ void StandardCalculatorViewModel::Recalculate(bool fromHistory) m_standardCalculatorManager.SendCommand(static_cast(currentCommands[i])); } - if (fromHistory) // This is for the cases where the expression is loaded from history + if (fromHistory) // This is for the cases where the expression is loaded from history { // To maintain F-E state of the engine, as the last operand hasn't reached engine by now m_standardCalculatorManager.SendCommand(Command::CommandFE); @@ -1981,7 +1981,7 @@ void StandardCalculatorViewModel::UpdatecommandsInRecordingMode() } else { - //reset all vars + // Reset all vars isDecimal = false; isNegative = false; isExpMode = false; diff --git a/src/CalcViewModel/StandardCalculatorViewModel.h b/src/CalcViewModel/StandardCalculatorViewModel.h index 494cd5e0..d7d3abde 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.h +++ b/src/CalcViewModel/StandardCalculatorViewModel.h @@ -277,7 +277,7 @@ namespace CalculatorApp NumbersAndOperatorsEnum MapCharacterToButtonId(const wchar_t ch, bool& canSendNegate); - //Memory feature related methods. They are internal because they need to called from the MainPage code-behind + // Memory feature related methods. They are internal because they need to called from the MainPage code-behind void OnMemoryButtonPressed(); void OnMemoryItemPressed(Platform::Object^ memoryItemPosition); void OnMemoryAdd(Platform::Object^ memoryItemPosition); diff --git a/src/CalcViewModel/UnitConverterViewModel.cpp b/src/CalcViewModel/UnitConverterViewModel.cpp index 393165eb..7ae1eb2b 100644 --- a/src/CalcViewModel/UnitConverterViewModel.cpp +++ b/src/CalcViewModel/UnitConverterViewModel.cpp @@ -142,7 +142,7 @@ UnitConverterViewModel::UnitConverterViewModel(const shared_ptrMode = CurrencyFormatterMode::UseCurrencyCode; m_currencyFormatter->ApplyRoundingForCurrency(RoundingAlgorithm::RoundHalfDown); m_currencyMaxFractionDigits = m_currencyFormatter->FractionDigits; - + auto resourceLoader = AppResourceProvider::GetInstance(); m_localizedValueFromFormat = resourceLoader.GetResourceString(UnitConverterResourceKeys::ValueFromFormat); m_localizedValueToFormat = resourceLoader.GetResourceString(UnitConverterResourceKeys::ValueToFormat); @@ -257,7 +257,7 @@ void UnitConverterViewModel::OnUnitChanged(Object^ parameter) void UnitConverterViewModel::OnSwitchActive(Platform::Object^ unused) { - // this can be false if this switch occurs without the user having explicitly updated any strings + // this can be false if this switch occurs without the user having explicitly updated any strings // (for example, during deserialization). We only want to try this cleanup if there's actually // something to clean up. if (m_relocalizeStringOnSwitch) @@ -279,7 +279,7 @@ void UnitConverterViewModel::OnSwitchActive(Platform::Object^ unused) m_valueFromUnlocalized.swap(m_valueToUnlocalized); Utils::Swap(&m_localizedValueFromFormat, &m_localizedValueToFormat); - + Utils::Swap(&m_Unit1AutomationName, &m_Unit2AutomationName); RaisePropertyChanged(UnitConverterViewModelProperties::Unit1AutomationName); RaisePropertyChanged(UnitConverterViewModelProperties::Unit2AutomationName); @@ -324,7 +324,7 @@ String^ UnitConverterViewModel::ConvertToLocalizedString(const std::wstring& str if (allowPartialStrings) { // allow "in progress" strings, like "3." that occur during the composition of - // a final number. Without this, when typing the three characters in "3.2" + // a final number. Without this, when typing the three characters in "3.2" // you don't see the decimal point when typing it, you only see it once you've finally // typed a post-decimal digit. @@ -341,7 +341,7 @@ String^ UnitConverterViewModel::ConvertToLocalizedString(const std::wstring& str { wstring currencyResult = m_currencyFormatter->Format(stod(stringToLocalize))->Data(); wstring currencyCode = m_currencyFormatter->Currency->Data(); - + // CurrencyFormatter always includes LangCode or Symbol. Make it include LangCode // because this includes a non-breaking space. Remove the LangCode. auto pos = currencyResult.find(currencyCode); @@ -367,7 +367,7 @@ String^ UnitConverterViewModel::ConvertToLocalizedString(const std::wstring& str if (hasDecimal) { // Since the output from GetLocaleInfoEx() and DecimalFormatter are differing for decimal string - // we are adding the below work-around of editing the string returned by DecimalFormatter + // we are adding the below work-around of editing the string returned by DecimalFormatter // and replacing the decimal separator with the one returned by GetLocaleInfoEx() String^ formattedSampleString = m_decimalFormatter->Format(stod("1.1")); wstring formattedSampleWString = wstring(formattedSampleString->Data()); @@ -378,7 +378,7 @@ String^ UnitConverterViewModel::ConvertToLocalizedString(const std::wstring& str { resultWithDecimal.replace(pos, 1, &m_decimalSeparator); } - + // Copy back the edited string to the result result = ref new String(resultWithDecimal.c_str()); } @@ -479,7 +479,7 @@ void UnitConverterViewModel::OnButtonPressed(Platform::Object^ parameter) NumbersAndOperatorsEnum numOpEnum = CalculatorButtonPressedEventArgs::GetOperationFromCommandParameter(parameter); UCM::Command command = CommandFromButtonId(numOpEnum); - //Don't clear the display if combo box is open and escape is pressed + // Don't clear the display if combo box is open and escape is pressed if (command == UCM::Command::Clear && IsDropDownOpen) { return; @@ -674,7 +674,7 @@ void UnitConverterViewModel::Deserialize(Platform::String^ state) RaisePropertyChanged(nullptr); // Update since all props have been updated. } -//Saving User Preferences of Category and Associated-Units across Sessions. +// Saving User Preferences of Category and Associated-Units across Sessions. void UnitConverterViewModel::SaveUserPreferences() { if (UnitsAreValid()) @@ -695,7 +695,7 @@ void UnitConverterViewModel::SaveUserPreferences() } } -//Restoring User Preferences of Category and Associated-Units. +// Restoring User Preferences of Category and Associated-Units. void UnitConverterViewModel::RestoreUserPreferences() { if (!IsCurrencyCurrentCategory) @@ -973,7 +973,7 @@ void UnitConverterViewModel::OnPaste(String^ stringToPaste, ViewMode mode) { if (isFirstLegalChar) { - // Send Clear before sending something that will actually apply + // Send Clear before sending something that will actually apply // to the field. m_model->SendCommand(UCM::Command::Clear); isFirstLegalChar = false; diff --git a/src/CalcViewModel/UnitConverterViewModel.h b/src/CalcViewModel/UnitConverterViewModel.h index baabd860..bd7b8bd5 100644 --- a/src/CalcViewModel/UnitConverterViewModel.h +++ b/src/CalcViewModel/UnitConverterViewModel.h @@ -19,7 +19,7 @@ namespace CalculatorApp public ref class Category sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged { internal: - Category(const UnitConversionManager::Category& category) : + Category(const UnitConversionManager::Category& category) : m_original(category) { } @@ -52,7 +52,7 @@ namespace CalculatorApp public ref class Unit sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged { internal: - Unit(const UnitConversionManager::Unit& unit) : + Unit(const UnitConversionManager::Unit& unit) : m_original(unit) { } @@ -163,7 +163,7 @@ namespace CalculatorApp internal: UnitConverterViewModel(const std::shared_ptr& model); - public: + public: OBSERVABLE_OBJECT_CALLBACK(OnPropertyChanged); OBSERVABLE_PROPERTY_R(Windows::Foundation::Collections::IObservableVector^, Categories); @@ -224,7 +224,7 @@ namespace CalculatorApp COMMAND_FOR_METHOD(PasteCommand, UnitConverterViewModel::OnPasteCommand); void AnnounceConversionResult(); - + internal: void ResetView(); void PopulateData(); @@ -242,8 +242,8 @@ namespace CalculatorApp void UpdateValue2AutomationName(); Platform::String^ Serialize(); void Deserialize(Platform::String^ state); - - //Saving And Restoring User Preferences of Category and Associated-Units across Sessions. + + // Saving And Restoring User Preferences of Category and Associated-Units across Sessions. void SaveUserPreferences(); void RestoreUserPreferences(); @@ -360,9 +360,9 @@ namespace CalculatorApp UnitConverterVMCallback(UnitConverterViewModel^ viewModel) : m_viewModel(viewModel) {} - void DisplayCallback(const std::wstring& from, const std::wstring& to) override - { - m_viewModel->UpdateDisplay(from, to); + void DisplayCallback(const std::wstring& from, const std::wstring& to) override + { + m_viewModel->UpdateDisplay(from, to); } void SuggestedValueCallback( diff --git a/src/Calculator/Common/AlwaysSelectedCollectionView.h b/src/Calculator/Common/AlwaysSelectedCollectionView.h index 2cc85101..6e702c79 100644 --- a/src/Calculator/Common/AlwaysSelectedCollectionView.h +++ b/src/Calculator/Common/AlwaysSelectedCollectionView.h @@ -3,9 +3,9 @@ #pragma once -namespace CalculatorApp { namespace Common +namespace CalculatorApp { namespace Common { - ref class AlwaysSelectedCollectionView sealed: + ref class AlwaysSelectedCollectionView sealed: public Windows::UI::Xaml::DependencyObject, public Windows::UI::Xaml::Data::ICollectionView { @@ -14,11 +14,11 @@ namespace CalculatorApp { namespace Common m_currentPosition(-1) { m_source = source; - + Windows::UI::Xaml::Interop::IBindableObservableVector^ observable = dynamic_cast(source); if (observable) { - observable->VectorChanged += + observable->VectorChanged += ref new Windows::UI::Xaml::Interop::BindableVectorChangedEventHandler(this, &AlwaysSelectedCollectionView::OnSourceBindableVectorChanged); } } @@ -53,7 +53,7 @@ namespace CalculatorApp { namespace Common return ref new Platform::Collections::Vector(); } } - property bool HasMoreItems + property bool HasMoreItems { virtual bool get() = Windows::UI::Xaml::Data::ICollectionView::HasMoreItems::get { @@ -77,11 +77,11 @@ namespace CalculatorApp { namespace Common } // The item is not in the collection - // We're going to schedule a call back later so we + // We're going to schedule a call back later so we // restore the selection to the way we wanted it to begin with if (m_currentPosition >= 0 && m_currentPosition < static_cast(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]() { @@ -161,7 +161,7 @@ namespace CalculatorApp { namespace Common m_currentChanging -= token; } } - + // IVector // Not implemented methods virtual void Append(Platform::Object^ /*item*/) = Windows::Foundation::Collections::IVector::Append @@ -219,7 +219,7 @@ namespace CalculatorApp { namespace Common return m_source->Size; } } - + // IObservableVector event Windows::Foundation::Collections::VectorChangedEventHandler^ VectorChanged { @@ -262,9 +262,9 @@ namespace CalculatorApp { namespace Common private: virtual Platform::Object^ Convert( - Platform::Object^ value, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ value, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert { auto result = dynamic_cast(value); @@ -276,9 +276,9 @@ namespace CalculatorApp { namespace Common } virtual Platform::Object^ ConvertBack( - Platform::Object^ /*value*/, - Windows::UI::Xaml::Interop::TypeName /*targetType*/, - Platform::Object^ /*parameter*/, + Platform::Object^ /*value*/, + Windows::UI::Xaml::Interop::TypeName /*targetType*/, + Platform::Object^ /*parameter*/, Platform::String^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack { return Windows::UI::Xaml::DependencyProperty::UnsetValue; diff --git a/src/Calculator/Common/AppLifecycleLogger.cpp b/src/Calculator/Common/AppLifecycleLogger.cpp index 983deac6..5bfb6141 100644 --- a/src/Calculator/Common/AppLifecycleLogger.cpp +++ b/src/Calculator/Common/AppLifecycleLogger.cpp @@ -37,7 +37,7 @@ namespace CalculatorApp m_appLifecycleProvider( L"Microsoft.Windows.AppLifeCycle", LoggingChannelOptions(GUID{ 0x4f50731a, 0x89cf, 0x4782, 0xb3, 0xe0, 0xdc, 0xe8, 0xc9, 0x4, 0x76, 0xba }), // Microsoft Telemetry group - GUID{ 0xef00584a, 0x2655, 0x462c, 0xbc, 0x24, 0xe7, 0xde, 0x63, 0xe, 0x7f, 0xbf }) //Unique provider ID {EF00584A-2655-462C-BC24-E7DE630E7FBF} + GUID{ 0xef00584a, 0x2655, 0x462c, 0xbc, 0x24, 0xe7, 0xde, 0x63, 0xe, 0x7f, 0xbf }) // Unique provider ID {EF00584A-2655-462C-BC24-E7DE630E7FBF} { } diff --git a/src/Calculator/Common/AppLifecycleLogger.h b/src/Calculator/Common/AppLifecycleLogger.h index d1d88bad..ca7ac65c 100644 --- a/src/Calculator/Common/AppLifecycleLogger.h +++ b/src/Calculator/Common/AppLifecycleLogger.h @@ -29,9 +29,9 @@ namespace CalculatorApp AppLifecycleLogger(); // Any new Log method should - // a) decide the level of logging. This will help us in limiting recording of events only up to a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx - // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios - // b) should decide whether or not to log to telemetry and pass TraceLoggingKeyword(MICROSOFT_KEYWORD_TELEMETRY) accordingly + // a) Decide the level of logging. This will help us in limiting recording of events only up to a certain level. See this link for guidance https://msdn.microsoft.com/en-us/library/windows/desktop/aa363742(v=vs.85).aspx + // We're using Verbose level for events that are called frequently and needed only for debugging or capturing perf for specific scenarios + // b) Should decide whether or not to log to telemetry and pass TraceLoggingKeyword(MICROSOFT_KEYWORD_TELEMETRY) accordingly // c) Should accept a variable number of additional data arguments if needed void LogAppLifecycleEvent(winrt::hstring const& eventName, winrt::Windows::Foundation::Diagnostics::LoggingFields const& fields) const; void PopulateAppInfo(winrt::Windows::Foundation::Diagnostics::LoggingFields& fields) const; diff --git a/src/Calculator/Common/BindableBase.cpp b/src/Calculator/Common/BindableBase.cpp index 270e68ac..b1fdcc78 100644 --- a/src/Calculator/Common/BindableBase.cpp +++ b/src/Calculator/Common/BindableBase.cpp @@ -18,17 +18,17 @@ void BindableBase::OnPropertyChanged(String^ propertyName) PropertyChanged(this, ref new PropertyChangedEventArgs(propertyName)); } -Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetCustomProperty(Platform::String^ name) +Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetCustomProperty(Platform::String^ name) { return nullptr; } -Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetIndexedProperty(Platform::String^ name, Windows::UI::Xaml::Interop::TypeName type) +Windows::UI::Xaml::Data::ICustomProperty^ BindableBase::GetIndexedProperty(Platform::String^ name, Windows::UI::Xaml::Interop::TypeName type) { return nullptr; } -Platform::String^ BindableBase::GetStringRepresentation() +Platform::String^ BindableBase::GetStringRepresentation() { - return this->ToString(); + return this->ToString(); } diff --git a/src/Calculator/Controls/CalculationResult.cpp b/src/Calculator/Controls/CalculationResult.cpp index 90563752..5ee59944 100644 --- a/src/Calculator/Controls/CalculationResult.cpp +++ b/src/Calculator/Controls/CalculationResult.cpp @@ -76,7 +76,7 @@ void CalculationResult::OnApplyTemplate() if (m_textContainer) { m_textContainer->SizeChanged += ref new SizeChangedEventHandler(this, &CalculationResult::TextContainerSizeChanged); - // We want to know when the size of the container changes so + // We want to know when the size of the container changes so // we can rescale the textbox m_textContainerLayoutChangedToken = m_textContainer->LayoutUpdated += ref new EventHandler(this, &CalculationResult::OnTextContainerLayoutUpdated); @@ -154,15 +154,15 @@ void CalculationResult::OnIsInErrorPropertyChanged(bool /*oldValue*/, bool newVa if (newValue) { // If there's an error message we need to override the normal display font - // with the font appropriate for this language. This is because the error + // with the font appropriate for this language. This is because the error // message is localized and therefore can contain characters that are not - // available in the normal font. + // available in the normal font. // We use UIText as the font type because this is the most common font type to use m_textBlock->FontFamily = LocalizationService::GetInstance()->GetLanguageFontFamilyForType(LanguageFontType::UIText); } else { - // The error result is no longer an error so we will restore the + // The error result is no longer an error so we will restore the // value to FontFamily property to the value provided in the style // for the TextBlock in the template. m_textBlock->ClearValue(TextBlock::FontFamilyProperty); @@ -175,7 +175,7 @@ void CalculationResult::UpdateVisualState() { VisualStateManager::GoToState(this, "Active", true); } - else + else { VisualStateManager::GoToState(this, "Normal", true); } @@ -192,8 +192,8 @@ void CalculationResult::UpdateTextState() String^ oldText = m_textBlock->Text; String^ newText = Utils::LRO + DisplayValue + Utils::PDF; - //Initiate the scaling operation - //UpdateLayout will keep calling us until we make it through the below 2 if-statements + // Initiate the scaling operation + // UpdateLayout will keep calling us until we make it through the below 2 if-statements if (!m_isScalingText || oldText != newText) { m_textBlock->Text = newText; @@ -329,17 +329,17 @@ void CalculationResult::ShowHideScrollButtons(::Visibility vLeft, ::Visibility v void CalculationResult::UpdateScrollButtons() { // When the width is smaller than the container, don't show any - if (m_textBlock->ActualWidth < m_textContainer->ActualWidth) + if (m_textBlock->ActualWidth < m_textContainer->ActualWidth) { ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed); } // We have more number on both side. Show both arrows - else if (m_textContainer->HorizontalOffset > 0 && m_textContainer->HorizontalOffset < (m_textContainer->ExtentWidth - m_textContainer->ViewportWidth)) + else if (m_textContainer->HorizontalOffset > 0 && m_textContainer->HorizontalOffset < (m_textContainer->ExtentWidth - m_textContainer->ViewportWidth)) { ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Visible); } // Width is larger than the container and left most part of the number is shown. Should be able to scroll left. - else if (m_textContainer->HorizontalOffset == 0) + else if (m_textContainer->HorizontalOffset == 0) { ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Visible); } diff --git a/src/Calculator/Controls/CalculatorButton.cpp b/src/Calculator/Controls/CalculatorButton.cpp index 68efc005..abd00b92 100644 --- a/src/Calculator/Controls/CalculatorButton.cpp +++ b/src/Calculator/Controls/CalculatorButton.cpp @@ -54,7 +54,7 @@ void CalculatorButton::OnKeyUp(KeyRoutedEventArgs^ e) } void CalculatorButton::OnButtonIdPropertyChanged( - NumbersAndOperatorsEnum /*oldValue*/, + NumbersAndOperatorsEnum /*oldValue*/, NumbersAndOperatorsEnum newValue) { this->CommandParameter = ref new CalculatorButtonPressedEventArgs(AuditoryFeedback, newValue); diff --git a/src/Calculator/Controls/CalculatorButton.h b/src/Calculator/Controls/CalculatorButton.h index 71c29a9b..daad7382 100644 --- a/src/Calculator/Controls/CalculatorButton.h +++ b/src/Calculator/Controls/CalculatorButton.h @@ -13,7 +13,7 @@ namespace CalculatorApp public ref class CalculatorButton sealed: Windows::UI::Xaml::Controls::Button { public: - + CalculatorButton(); DEPENDENCY_PROPERTY_OWNER(CalculatorButton); diff --git a/src/Calculator/Controls/FlipButtons.cpp b/src/Calculator/Controls/FlipButtons.cpp index cb1d6b34..1ab2b4b9 100644 --- a/src/Calculator/Controls/FlipButtons.cpp +++ b/src/Calculator/Controls/FlipButtons.cpp @@ -43,7 +43,7 @@ void FlipButtons::OnKeyUp(KeyRoutedEventArgs^ e) } void FlipButtons::OnButtonIdPropertyChanged( - NumbersAndOperatorsEnum /*oldValue*/, + NumbersAndOperatorsEnum /*oldValue*/, NumbersAndOperatorsEnum newValue) { this->CommandParameter = newValue; diff --git a/src/Calculator/Controls/FlipButtons.h b/src/Calculator/Controls/FlipButtons.h index ab3ef8e7..67df4057 100644 --- a/src/Calculator/Controls/FlipButtons.h +++ b/src/Calculator/Controls/FlipButtons.h @@ -29,7 +29,7 @@ namespace CalculatorApp private: void OnButtonIdPropertyChanged( - NumbersAndOperatorsEnum oldValue, + NumbersAndOperatorsEnum oldValue, NumbersAndOperatorsEnum newValue); }; } diff --git a/src/Calculator/Controls/OperandTextBox.cpp b/src/Calculator/Controls/OperandTextBox.cpp index 3a5224aa..31e814c2 100644 --- a/src/Calculator/Controls/OperandTextBox.cpp +++ b/src/Calculator/Controls/OperandTextBox.cpp @@ -23,7 +23,7 @@ using namespace Windows::UI::Xaml::Media; using namespace Windows::UI::Xaml::Navigation; void OperandTextBox::OnApplyTemplate() -{ +{ this->IsEnabled = false; this->IsHitTestVisible = false; this->IsTapEnabled = false; diff --git a/src/Calculator/Controls/OverflowTextBlock.cpp b/src/Calculator/Controls/OverflowTextBlock.cpp index b5633eaa..85baebc4 100644 --- a/src/Calculator/Controls/OverflowTextBlock.cpp +++ b/src/Calculator/Controls/OverflowTextBlock.cpp @@ -34,22 +34,22 @@ void OverflowTextBlock::OnApplyTemplate() m_expressionContainer = safe_cast(GetTemplateChild("expressionContainer")); m_expressionContainer->ChangeView(m_expressionContainer->ExtentWidth - m_expressionContainer->ViewportWidth, nullptr, nullptr); - + m_scrollLeft = safe_cast(GetTemplateChild("scrollLeft")); m_scrollRight = safe_cast(GetTemplateChild("scrollRight")); - + m_scrollLeftClickEventToken = m_scrollLeft->Click += ref new RoutedEventHandler(this, &OverflowTextBlock::OnScrollClick); m_scrollRightClickEventToken = m_scrollRight->Click += ref new RoutedEventHandler(this, &OverflowTextBlock::OnScrollClick); m_scrollingLeft = false; m_scrollingRight = false; - + auto borderContainer = safe_cast(GetTemplateChild("expressionborder")); m_pointerEnteredEventToken = borderContainer->PointerEntered += ref new PointerEventHandler(this, &OverflowTextBlock::OnPointerEntered); m_pointerExitedEventToken = borderContainer->PointerExited += ref new PointerEventHandler(this, &OverflowTextBlock::OnPointerExited); m_listView = safe_cast(GetTemplateChild("TokenList")); - + UpdateAllState(); } diff --git a/src/Calculator/Controls/OverflowTextBlock.h b/src/Calculator/Controls/OverflowTextBlock.h index 1fe3dd95..13b2e828 100644 --- a/src/Calculator/Controls/OverflowTextBlock.h +++ b/src/Calculator/Controls/OverflowTextBlock.h @@ -12,7 +12,7 @@ namespace CalculatorApp public ref class OverflowTextBlock sealed : public Windows::UI::Xaml::Controls::Control { public: - OverflowTextBlock() + OverflowTextBlock() { } diff --git a/src/Calculator/Converters/BooleanToVisibilityConverter.h b/src/Calculator/Converters/BooleanToVisibilityConverter.h index 4ee40701..3c31e61c 100644 --- a/src/Calculator/Converters/BooleanToVisibilityConverter.h +++ b/src/Calculator/Converters/BooleanToVisibilityConverter.h @@ -16,7 +16,7 @@ namespace CalculatorApp public: static constexpr Windows::UI::Xaml::Visibility Convert(bool visibility) { - return visibility + return visibility ? Windows::UI::Xaml::Visibility::Visible : Windows::UI::Xaml::Visibility::Collapsed; } diff --git a/src/Calculator/Views/UnitConverter.xaml.cpp b/src/Calculator/Views/UnitConverter.xaml.cpp index a4889a55..6cae71e4 100644 --- a/src/Calculator/Views/UnitConverter.xaml.cpp +++ b/src/Calculator/Views/UnitConverter.xaml.cpp @@ -51,7 +51,7 @@ UnitConverter::UnitConverter() : { InitializeComponent(); - //adding ESC key shortcut binding to clear button + // adding ESC key shortcut binding to clear button clearEntryButtonPos0->SetValue(Common::KeyboardShortcutManager::VirtualKeyProperty, Common::MyVirtualKey::Escape); m_layoutDirection = LocalizationService::GetInstance()->GetFlowDirection(); @@ -278,7 +278,7 @@ void UnitConverter::AnimateConverter() void UnitConverter::OnValueSelected(_In_ Platform::Object^ sender) { auto value = safe_cast(sender); - //update the font size since the font is changed to bold + // update the font size since the font is changed to bold value->UpdateTextState(); safe_cast(this->DataContext)->OnValueActivated(AsActivatable(value)); } diff --git a/src/Calculator/WindowFrameService.cpp b/src/Calculator/WindowFrameService.cpp index 14266c27..a827f9fd 100644 --- a/src/Calculator/WindowFrameService.cpp +++ b/src/Calculator/WindowFrameService.cpp @@ -82,7 +82,7 @@ namespace CalculatorApp assert(frame->BackStackDepth == 0); m_frame = frame; } - + void WindowFrameService::RegisterOnWindowClosingHandler(function onWindowClosingHandler) { m_onWindowClosingHandlers.push_back(onWindowClosingHandler); diff --git a/src/Calculator/WindowFrameService.h b/src/Calculator/WindowFrameService.h index 76e74a35..94a9cad3 100644 --- a/src/Calculator/WindowFrameService.h +++ b/src/Calculator/WindowFrameService.h @@ -6,7 +6,7 @@ namespace CalculatorApp { - + public ref class WindowFrameService sealed { public: @@ -16,16 +16,16 @@ namespace CalculatorApp internal: // createdByUs means any window that we create. // !createdByUs means the main window - static WindowFrameService^ CreateNewWindowFrameService(_In_ Windows::UI::Xaml::Controls::Frame^ viewFrame, - bool createdByUs, + static WindowFrameService^ CreateNewWindowFrameService(_In_ Windows::UI::Xaml::Controls::Frame^ viewFrame, + bool createdByUs, Platform::WeakReference parent); - + Windows::UI::Core::CoreDispatcher^ GetCoreDispatcher(); int GetViewId(); - + void RegisterOnWindowClosingHandler(std::function onWindowClosingHandler); concurrency::task HandleViewRelease(); - + // Throws InvalidArgumentException if a service is already registered with the specified id void RegisterRuntimeWindowService(Windows::UI::Xaml::Interop::TypeName serviceId, _In_opt_ Platform::Object^ service); @@ -53,7 +53,7 @@ namespace CalculatorApp Platform::Agile m_currentWindow; Platform::Agile m_coreDispatcher; Windows::UI::Xaml::Controls::Frame^ m_frame; - int m_viewId; + int m_viewId; Platform::WeakReference m_parent; std::unordered_map m_runtimeServicesMap; diff --git a/src/CalculatorUnitTests/CalculatorManagerTest.cpp b/src/CalculatorUnitTests/CalculatorManagerTest.cpp index 1d42a285..14939d34 100644 --- a/src/CalculatorUnitTests/CalculatorManagerTest.cpp +++ b/src/CalculatorUnitTests/CalculatorManagerTest.cpp @@ -526,7 +526,7 @@ namespace CalculatorManagerTest Command commands22[] = { Command::Command0, Command::CommandSQRT, Command::CommandNULL }; TestDriver::Test(L"0", L"\x221A(0)", commands22); - + Command commands23[] = { Command::Command1, Command::Command0, Command::Command2, Command::Command4, Command::CommandSQRT, Command::CommandSUB, Command::Command3, Command::Command2, Command::CommandADD, Command::CommandNULL }; @@ -593,11 +593,11 @@ namespace CalculatorManagerTest Command commands17[] = { Command::Command5, Command::CommandPWR, Command::Command0, Command::CommandADD, Command::CommandNULL }; TestDriver::Test(L"1", L"5 ^ 0 + ", commands17); - + Command commands18[] = { Command::Command0, Command::CommandPWR, Command::Command0, Command::CommandADD, Command::CommandNULL }; TestDriver::Test(L"1", L"0 ^ 0 + ", commands18); - + Command commands19[] = { Command::Command2, Command::Command7, Command::CommandSIGN, Command::CommandROOT, Command::Command3, Command::CommandADD, Command::CommandNULL }; TestDriver::Test(L"-3", L"-27 yroot 3 + ", commands19, true, true); @@ -859,7 +859,7 @@ namespace CalculatorManagerTest memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers(); VERIFY_ARE_EQUAL(wstring(L"2"), memorizedNumbers.at(0)); - // Test for trying to memorize invalid value + // Test for trying to memorize invalid value m_calculatorManager->SendCommand(Command::Command2); m_calculatorManager->SendCommand(Command::CommandSIGN); m_calculatorManager->SendCommand(Command::CommandSQRT); diff --git a/src/CalculatorUnitTests/CurrencyConverterUnitTests.cpp b/src/CalculatorUnitTests/CurrencyConverterUnitTests.cpp index 756e7085..2f9c5657 100644 --- a/src/CalculatorUnitTests/CurrencyConverterUnitTests.cpp +++ b/src/CalculatorUnitTests/CurrencyConverterUnitTests.cpp @@ -264,7 +264,7 @@ namespace CalculatorUnitTests VERIFY_IS_FALSE(loader.LoadFinished()); VERIFY_IS_FALSE(loader.LoadedFromCache()); } - + TEST_METHOD(LoadFromCache_Fail_ResponseLanguageChanged) { DateTime now = Utils::GetUniversalSystemTime(); diff --git a/src/CalculatorUnitTests/MultiWindowUnitTests.cpp b/src/CalculatorUnitTests/MultiWindowUnitTests.cpp index fcb82171..f114c322 100644 --- a/src/CalculatorUnitTests/MultiWindowUnitTests.cpp +++ b/src/CalculatorUnitTests/MultiWindowUnitTests.cpp @@ -354,7 +354,7 @@ namespace CalculatorUnitTests { NumbersAndOperatorsEnum::HexButton, L"0", L"" }, { NumbersAndOperatorsEnum::None, L"", L"" } }; - + ValidateViewModelByCommands(programmerViewModel1, programmerModeInitializeItems1, false); // Bit Length: Word & Radix Type: Oct @@ -369,7 +369,7 @@ namespace CalculatorUnitTests TESTITEM programmerModeTestItems1[] = { { NumbersAndOperatorsEnum::F, L"F", L"" }, { NumbersAndOperatorsEnum::F, L"FF", L"" }, - // One more F shouldn't have any effect, testing for precision + // One more F shouldn't have any effect, testing for precision { NumbersAndOperatorsEnum::F, L"FF", L"" }, { NumbersAndOperatorsEnum::None, L"", L"" } }; @@ -663,7 +663,7 @@ namespace CalculatorUnitTests // needs to be updated with correct expected value and viewmodel needs // to be updated to calculate correct value. - //DateCalculatorViewModel^ viewModels[4]; + // DateCalculatorViewModel^ viewModels[4]; //// Initialize the view models //for (int i = 0; i < 4; i++) @@ -776,7 +776,7 @@ namespace CalculatorUnitTests VERIFY_IS_TRUE(CAT1 == viewModels[0]->CurrentCategory->GetModelCategory()); VERIFY_IS_TRUE(CAT2 == viewModels[1]->CurrentCategory->GetModelCategory()); VERIFY_IS_TRUE(CAT3 == viewModels[2]->CurrentCategory->GetModelCategory()); - + VERIFY_IS_TRUE(UNIT1 == viewModels[0]->Unit1->GetModelUnit()); VERIFY_IS_TRUE(UNIT2 == viewModels[0]->Unit2->GetModelUnit()); @@ -925,7 +925,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(GetStringValue(standardViewModel->DisplayValue), StringReference(L"1")); // Again perform calculations on Standard Calc instance and validate that the Converter remains unaffected - + // Standard Mode: Expression 1+2= TESTITEM standardModeTestItems2[] = { { NumbersAndOperatorsEnum::One, L"1", L"" }, @@ -978,7 +978,7 @@ namespace CalculatorUnitTests }; ValidateViewModelByCommands(viewModels[0], standardModeTestItems, false /*doReset*/); - //Launch a new instance in standard mode + // Launch a new instance in standard mode viewModels[2] = ref new StandardCalculatorViewModel(); ChangeMode(viewModels[2], 0); @@ -994,7 +994,7 @@ namespace CalculatorUnitTests }; ValidateViewModelByCommands(viewModels[2], standardModeTestItemsNew, false /*doReset*/); - //Radix in the programmer mode launched should still be hex. + // Radix in the programmer mode launched should still be hex. // A + 1 = B TESTITEM programmerModeTestItemsNew[] = { { NumbersAndOperatorsEnum::A, L"A", L"" }, diff --git a/src/CalculatorUnitTests/StandardViewModelUnitTests.cpp b/src/CalculatorUnitTests/StandardViewModelUnitTests.cpp index 214c612f..e2ddad86 100644 --- a/src/CalculatorUnitTests/StandardViewModelUnitTests.cpp +++ b/src/CalculatorUnitTests/StandardViewModelUnitTests.cpp @@ -779,7 +779,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false); } - //When memory button is pressed - verify if display value is being stored in vector + // When memory button is pressed - verify if display value is being stored in vector TEST_METHOD(OnMemoryButtonPressed) { StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel(); @@ -790,7 +790,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL((int)viewModel->MemorizedNumbers->Size, 2); } - //when memory list is empty and M+ is pressed + // When memory list is empty and M+ is pressed TEST_METHOD(OnMemoryAddWhenMemoryEmpty) { m_viewModel->IsStandard = true; @@ -808,7 +808,7 @@ namespace CalculatorUnitTests } - //when memory list is empty and M- is pressed + // When memory list is empty and M- is pressed TEST_METHOD(OnMemorySubtractWhenMemoryEmpty) { m_viewModel->IsStandard = true; @@ -825,7 +825,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), m_viewModel->DisplayValue); } - //when negative number is saved in memory + // When negative number is saved in memory TEST_METHOD(OnNegativeEntryInMemory) { ChangeMode(m_viewModel, 0/*Standard*/); @@ -851,7 +851,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotProgrammer->Value)); } - //when decimal number is saved in memory + // When decimal number is saved in memory TEST_METHOD(OnDecimalEntryInMemory) { ChangeMode(m_viewModel, 0/*Standard*/); @@ -878,7 +878,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), Utils::GetStringValue(memorySlotProgrammer->Value)); } - //when negative decimal number is saved in memory + // When negative decimal number is saved in memory TEST_METHOD(OnNegativeDecimalInMemory) { m_viewModel->IsStandard = true; @@ -898,7 +898,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001.1"), m_viewModel->DisplayValue); } - //when decimal number is added to the memory + // When decimal number is added to the memory TEST_METHOD(OnDecimalAddedToMemory) { m_viewModel->IsStandard = true; @@ -928,7 +928,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"2,002.1"), m_viewModel->DisplayValue); } - //when memory is saved in programmer as Hex value and then we switch to standard mode, test to see that memory gets converted to decimal + // When memory is saved in programmer as Hex value and then we switch to standard mode, test to see that memory gets converted to decimal TEST_METHOD(OnMemorySavedInHexRadixAndSwitchedToStandardMode) { ChangeMode(m_viewModel, 2/*programmer*/); @@ -971,8 +971,8 @@ namespace CalculatorUnitTests } - //When memory button is pressed more than max number of slots allowed, - //the MemorizedNumbers vector size should not increase. + // When memory button is pressed more than max number of slots allowed, + // the MemorizedNumbers vector size should not increase. TEST_METHOD(OnMemoryButtonPressedMaxTimes) { StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel(); @@ -1014,7 +1014,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), m_viewModel->DisplayValue); } - // verify nothing happens if there is no memory and the memory slot pressed action is taken + // Verify nothing happens if there is no memory and the memory slot pressed action is taken TEST_METHOD(OnMemoryItemPressedNoMemory) { TESTITEM items[] = { diff --git a/src/CalculatorUnitTests/UnitConverterTest.cpp b/src/CalculatorUnitTests/UnitConverterTest.cpp index 91902e98..8c0f7287 100644 --- a/src/CalculatorUnitTests/UnitConverterTest.cpp +++ b/src/CalculatorUnitTests/UnitConverterTest.cpp @@ -76,7 +76,7 @@ namespace UnitConverterUnitTests SetConversionDataParams(&conversion4, 0.453592, 0, false); SetConversionDataParams(&conversion5, 2.20462, 0, false); - //Setting the conversion ratios for testing + // Setting the conversion ratios for testing unit1Map[u1] = conversion1; unit1Map[u2] = conversion2; @@ -95,7 +95,7 @@ namespace UnitConverterUnitTests m_ratioMaps[u3] = unit3Map; m_ratioMaps[u4] = unit4Map; } - + void LoadData() { m_loadDataCallCount++; @@ -105,12 +105,12 @@ namespace UnitConverterUnitTests { return m_categories; } - + vector LoadOrderedUnits(const Category& c) { return m_units[c]; } - + unordered_map LoadOrderedRatios(const Unit& u) { return m_ratioMaps[u]; diff --git a/src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp b/src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp index 7a36cd1e..1df945c7 100644 --- a/src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp +++ b/src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp @@ -286,7 +286,7 @@ namespace CalculatorUnitTests VM::UnitConverterViewModel^ vm = ref new UnitConverterViewModel(make_shared(make_shared(ref new GeographicRegion()), nullptr)); IObservableVector^ categoryList = vm->Categories; ResourceLoader^ m_resLoader = ResourceLoader::GetForViewIndependentUse("Test"); - double epsilon = 0.1; //Could be more precise like 0.001 except atm to pascal conversion + double epsilon = 0.1; // Could be more precise like 0.001 except atm to pascal conversion for (unsigned int k = 0; k < categoryList->Size; k++) { @@ -302,7 +302,7 @@ namespace CalculatorUnitTests vm->Value1Active = false; vm->Unit2 = unitList->GetAt(j); wstring unit2Name = vm->Unit2->Name->Data(); - //change value2 as 1. + // Change value2 as 1. vm->ButtonPressed->Execute(NumbersAndOperatorsEnum::One); String^ expectedResult = m_resLoader->GetString(ref new String((unit1Name + L"-" + unit2Name).c_str())); @@ -315,10 +315,10 @@ namespace CalculatorUnitTests double actualConversion = GetDoubleFromWstring(GetStringValue(vm->Value1)->Data()); double diff = abs(expectedConversion - actualConversion); - // assert for diff less than epsilonth fraction of expected conversion result + // Assert for diff less than epsilonth fraction of expected conversion result VERIFY_IS_LESS_THAN_OR_EQUAL(diff, epsilon*expectedConversion); } - //clearing the value1 + // Clearing the value1 vm->ButtonPressed->Execute(NumbersAndOperatorsEnum::Clear); } } @@ -356,7 +356,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL((UINT)1, mock->m_setVMCallbackCallCount); } - // Test that we've set up all categories on load and that the first + // Test that we've set up all categories on load and that the first // category is selected. TEST_METHOD(TestUnitConverterLoadSetsUpCategories) { @@ -393,7 +393,7 @@ namespace CalculatorUnitTests shared_ptr mock = make_shared(); VM::UnitConverterViewModel vm(mock); vm.Unit1 = vm.Units->GetAt(1); // Change from u4 to u5 - // count will be 2 here since it was already called once at init + // Count will be 2 here since it was already called once at init VERIFY_ARE_EQUAL((UINT)2, mock->m_setCurUnitTypesCallCount); VERIFY_IS_TRUE(UNIT5 == mock->m_curFrom); VERIFY_IS_TRUE(UNIT6 == mock->m_curTo); @@ -409,7 +409,7 @@ namespace CalculatorUnitTests shared_ptr mock = make_shared(); VM::UnitConverterViewModel vm(mock); vm.CurrentCategory = vm.Categories->GetAt(2); // Change from cat1 to cat3 - // counts will be 2 here since the first call should have happened during init + // Counts will be 2 here since the first call should have happened during init VERIFY_IS_GREATER_THAN_OR_EQUAL(2u, mock->m_setCurrentCategoryCallCount); VERIFY_ARE_EQUAL((UINT)3, vm.Units->Size); VERIFY_IS_TRUE(UNIT7 == vm.Units->GetAt(0)->GetModelUnit()); @@ -424,7 +424,7 @@ namespace CalculatorUnitTests shared_ptr mock = make_shared(); VM::UnitConverterViewModel vm(mock); vm.CurrentCategory = vm.Categories->GetAt(2); // Change from cat1 to cat3 - // counts will be 2 here since the first call should have happened during init + // Counts will be 2 here since the first call should have happened during init VERIFY_IS_GREATER_THAN_OR_EQUAL(2u, mock->m_setCurrentCategoryCallCount); VERIFY_IS_TRUE(UNIT9 == vm.Unit1->GetModelUnit()); VERIFY_IS_TRUE(UNIT7 == vm.Unit2->GetModelUnit()); @@ -451,7 +451,7 @@ namespace CalculatorUnitTests shared_ptr mock = make_shared(); VM::UnitConverterViewModel vm(mock); - // Call count is being set to 1 because we send 'CE' command as the first call + // Call count is being set to 1 because we send 'CE' command as the first call UINT callCount = 1; vm.ButtonPressed->Execute(CalculatorApp::NumbersAndOperatorsEnum::Zero); @@ -1045,7 +1045,7 @@ namespace CalculatorUnitTests VERIFY_ARE_EQUAL((UCM::EMPTY_UNIT).id, (vm.Units->GetAt(0)->GetModelUnit()).id); } - // Test that a valid model unit list vuilds + // Test that a valid model unit list vuilds TEST_METHOD(TestUnitsListBuildsFromValidModelUnitList) { shared_ptr mock = make_shared(); diff --git a/src/CalculatorUnitTests/UnitTestApp.xaml.cpp b/src/CalculatorUnitTests/UnitTestApp.xaml.cpp index de9d5bb1..05e0bcdd 100644 --- a/src/CalculatorUnitTests/UnitTestApp.xaml.cpp +++ b/src/CalculatorUnitTests/UnitTestApp.xaml.cpp @@ -76,7 +76,7 @@ void App::OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEvent // Place the frame in the current Window Window::Current->Content = rootFrame; } - + Microsoft::VisualStudio::TestPlatform::TestExecutor::WinRTCore::UnitTestClient::CreateDefaultUI(); Window::Current->Activate(); @@ -96,7 +96,7 @@ void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e) (void) sender; // Unused parameter (void) e; // Unused parameter - //TODO: Save application state and stop any background activity + // TODO: Save application state and stop any background activity } /// diff --git a/src/CalculatorUnitTests/pch.h b/src/CalculatorUnitTests/pch.h index 7f46aeac..a7e7c976 100644 --- a/src/CalculatorUnitTests/pch.h +++ b/src/CalculatorUnitTests/pch.h @@ -73,7 +73,7 @@ namespace StandardPeers = Windows::UI::Xaml::Automation::Peers; namespace CalculatorApp::Common::Automation {} namespace CustomPeers = CalculatorApp::Common::Automation; -//CalcManager Headers +// CalcManager Headers #include "CalcManager/CalculatorVector.h" #include "CalcManager/ExpressionCommand.h" #include "CalcManager/CalculatorResource.h" diff --git a/src/CalculatorUnitTests/resource.h b/src/CalculatorUnitTests/resource.h index 25edf81e..f978b58e 100644 --- a/src/CalculatorUnitTests/resource.h +++ b/src/CalculatorUnitTests/resource.h @@ -3,7 +3,7 @@ // Used by CalculatorUnitTests_VS.rc // Next default values for new objects -// +// #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 101 From 244fd8deeee4f1d79510b7033e5931aebab2e440 Mon Sep 17 00:00:00 2001 From: Nikita Potapenko Date: Fri, 15 Mar 2019 11:06:10 +0200 Subject: [PATCH 6/6] Fix grid.Row (#279) Fixes #265 Fixes invalid grid.Row assignment for decimalSeparatorButton --- src/Calculator/Views/NumberPad.xaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Calculator/Views/NumberPad.xaml b/src/Calculator/Views/NumberPad.xaml index d5673fd8..eb490483 100644 --- a/src/Calculator/Views/NumberPad.xaml +++ b/src/Calculator/Views/NumberPad.xaml @@ -109,7 +109,7 @@ -->