Secondary formatting changes (#489)

Description of the changes:
Adjusted some of the values in .clang-format
Add clang-format-all.ps1
Fix path to .clang-format in Calculator.sln

How changes were validated:
Manual.

src/CalcViewModel/Common/AlwaysSelectedCollectionView.h

@@ -9,7 +9,8 @@ namespace CalculatorApp
     {
         ref class AlwaysSelectedCollectionView sealed : public Windows::UI::Xaml::DependencyObject, public Windows::UI::Xaml::Data::ICollectionView
         {
-            internal : AlwaysSelectedCollectionView(Windows::UI::Xaml::Interop::IBindableVector ^ source) : m_currentPosition(-1)
+            internal : AlwaysSelectedCollectionView(Windows::UI::Xaml::Interop::IBindableVector ^ source)
+                : m_currentPosition(-1)
             {
                 m_source = source;
 
@@ -47,8 +48,8 @@ namespace CalculatorApp
                 throw ref new Platform::NotImplementedException();
             }
             property Windows::Foundation::Collections::IObservableVector<Platform::Object ^> ^ CollectionGroups {
-                virtual Windows::Foundation::Collections::IObservableVector<Platform::Object
-                                                                            ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
+                virtual Windows::Foundation::Collections::IObservableVector<
+                    Platform::Object ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
                 {
                     return ref new Platform::Collections::Vector<Platform::Object ^>();
                 }
@@ -80,8 +81,9 @@ namespace CalculatorApp
                 // restore the selection to the way we wanted it to begin with
                 if (m_currentPosition >= 0 && m_currentPosition < static_cast<int>(m_source->Size))
                 {
-                    this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal,
-                                               ref new Windows::UI::Core::DispatchedHandler([this]() { m_currentChanged(this, nullptr); }));
+                    this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, ref new Windows::UI::Core::DispatchedHandler([this]() {
+                                                   m_currentChanged(this, nullptr);
+                                               }));
                 }
                 return false;
             }
@@ -167,14 +169,14 @@ namespace CalculatorApp
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual unsigned int
-            GetMany(unsigned int /*startIndex*/,
-                    Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
+            virtual unsigned int GetMany(
+                unsigned int /*startIndex*/,
+                Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<Platform::Object
-                                                                                                                                              ^>::GetView
+            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<
+                Platform::Object ^>::GetView
             {
                 throw ref new Platform::NotImplementedException();
             }
@@ -263,8 +265,11 @@ namespace CalculatorApp
 
         private:
             virtual Platform::Object
-                ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
+                ^ Convert(
+                    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<Windows::UI::Xaml::Interop::IBindableVector ^>(value);
                 if (result)
@@ -275,8 +280,11 @@ namespace CalculatorApp
             }
 
             virtual Platform::Object
-                ^ ConvertBack(Platform::Object ^ /*value*/, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
+                ^ ConvertBack(
+                    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;
             }

src/CalcViewModel/Common/Automation/LiveRegionHost.cpp

@@ -9,7 +9,8 @@ using namespace Windows::UI::Xaml::Automation;
 using namespace Windows::UI::Xaml::Automation::Peers;
 using namespace Windows::UI::Xaml::Controls;
 
-LiveRegionHost::LiveRegionHost() : m_host(nullptr)
+LiveRegionHost::LiveRegionHost()
+    : m_host(nullptr)
 {
 }
 

src/CalcViewModel/Common/Automation/NarratorAnnouncement.cpp

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

src/CalcViewModel/Common/Automation/NarratorAnnouncement.h

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

src/CalcViewModel/Common/Automation/NarratorNotifier.cpp

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

src/CalcViewModel/Common/Automation/NarratorNotifier.h

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

src/CalcViewModel/Common/Automation/NotificationHost.cpp

@@ -10,7 +10,8 @@ using namespace Windows::UI::Xaml::Automation;
 using namespace Windows::UI::Xaml::Automation::Peers;
 using namespace Windows::UI::Xaml::Controls;
 
-NotificationHost::NotificationHost() : m_host(nullptr)
+NotificationHost::NotificationHost()
+    : m_host(nullptr)
 {
 }
 
@@ -34,8 +35,11 @@ void NotificationHost::Announce(NarratorAnnouncement ^ announcement)
     auto peer = FrameworkElementAutomationPeer::FromElement(m_host);
     if (peer != nullptr)
     {
-        peer->RaiseNotificationEvent(GetWindowsNotificationKind(announcement->Kind), GetWindowsNotificationProcessing(announcement->Processing),
-                                     announcement->Announcement, announcement->ActivityId);
+        peer->RaiseNotificationEvent(
+            GetWindowsNotificationKind(announcement->Kind),
+            GetWindowsNotificationProcessing(announcement->Processing),
+            announcement->Announcement,
+            announcement->ActivityId);
     }
 }
 

src/CalcViewModel/Common/CalculatorButtonPressedEventArgs.h

@@ -18,7 +18,8 @@ namespace CalculatorApp
             PROPERTY_R(CalculatorApp::NumbersAndOperatorsEnum, Operation);
 
             CalculatorButtonPressedEventArgs(Platform::String ^ feedback, CalculatorApp::NumbersAndOperatorsEnum operation)
-                : m_AuditoryFeedback(feedback), m_Operation(operation)
+                : m_AuditoryFeedback(feedback)
+                , m_Operation(operation)
             {
             }
 

src/CalcViewModel/Common/CalculatorDisplay.cpp

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

src/CalcViewModel/Common/CalculatorDisplay.h

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

src/CalcViewModel/Common/ConversionResultTaskHelper.cpp

@@ -9,7 +9,8 @@ using namespace concurrency;
 using namespace std;
 
 ConversionResultTaskHelper::ConversionResultTaskHelper(unsigned int delay, const function<void()> functionToRun)
-    : m_delay{ delay }, m_storedFunction{ functionToRun }
+    : m_delay{ delay }
+    , m_storedFunction{ functionToRun }
 {
     auto token = m_cts.get_token();
     auto delayTask = CompleteAfter(delay);

src/CalcViewModel/Common/CopyPasteManager.cpp

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

src/CalcViewModel/Common/CopyPasteManager.h

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

src/CalcViewModel/Common/DateCalculator.h

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

src/CalcViewModel/Common/DelegateCommand.h

@@ -14,7 +14,9 @@ namespace CalculatorApp
 
                 typedef void (TTarget::*CommandHandlerFunc)(Platform::Object ^);
 
-            DelegateCommand(TTarget ^ target, CommandHandlerFunc func) : m_weakTarget(target), m_function(func)
+            DelegateCommand(TTarget ^ target, CommandHandlerFunc func)
+                : m_weakTarget(target)
+                , m_function(func)
             {
             }
 

src/CalcViewModel/Common/DisplayExpressionToken.h

@@ -18,7 +18,12 @@ public
     [Windows::UI::Xaml::Data::Bindable] public ref class DisplayExpressionToken sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
     {
         internal : DisplayExpressionToken(Platform::String ^ token, int tokenPosition, bool fEditable, TokenType type)
-            : m_Token(token), m_TokenPosition(tokenPosition), m_IsTokenEditable(fEditable), m_Type(type), m_OriginalToken(token), m_InEditMode(false)
+            : m_Token(token)
+            , m_TokenPosition(tokenPosition)
+            , m_IsTokenEditable(fEditable)
+            , m_Type(type)
+            , m_OriginalToken(token)
+            , m_InEditMode(false)
         {
         }
 

src/CalcViewModel/Common/ExpressionCommandDeserializer.cpp

@@ -7,7 +7,8 @@
 using namespace CalculatorApp::Common;
 using namespace Windows::Storage::Streams;
 
-CommandDeserializer::CommandDeserializer(_In_ DataReader ^ dataReader) : m_dataReader(dataReader)
+CommandDeserializer::CommandDeserializer(_In_ DataReader ^ dataReader)
+    : m_dataReader(dataReader)
 {
 }
 

src/CalcViewModel/Common/ExpressionCommandSerializer.cpp

@@ -7,7 +7,8 @@
 using namespace CalculatorApp::Common;
 using namespace Windows::Storage::Streams;
 
-SerializeCommandVisitor::SerializeCommandVisitor(_In_ DataWriter ^ dataWriter) : m_dataWriter(dataWriter)
+SerializeCommandVisitor::SerializeCommandVisitor(_In_ DataWriter ^ dataWriter)
+    : m_dataWriter(dataWriter)
 {
 }
 

src/CalcViewModel/Common/KeyboardShortcutManager.cpp

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

src/CalcViewModel/Common/KeyboardShortcutManager.h

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

src/CalcViewModel/Common/LocalizationService.cpp

@@ -434,28 +434,41 @@ unordered_map<wstring, wstring> LocalizationService::GetTokenToReadableNameMap()
     // change given that the engine heavily relies on perfect ordering of certain elements.
     // To compromise, we'll declare a map from engine resource key to automation name from the
     // standard project resources.
-    static vector<pair<wstring, wstring>> s_parenEngineKeyResourceMap = {
-        // Sine permutations
-        make_pair<wstring, wstring>(L"67", L"SineDegrees"), make_pair<wstring, wstring>(L"73", L"SineRadians"),
-        make_pair<wstring, wstring>(L"79", L"SineGradians"), make_pair<wstring, wstring>(L"70", L"InverseSineDegrees"),
-        make_pair<wstring, wstring>(L"76", L"InverseSineRadians"), make_pair<wstring, wstring>(L"82", L"InverseSineGradians"),
-        make_pair<wstring, wstring>(L"25", L"HyperbolicSine"), make_pair<wstring, wstring>(L"85", L"InverseHyperbolicSine"),
+    static vector<pair<wstring, wstring>> s_parenEngineKeyResourceMap = { // Sine permutations
+                                                                          make_pair<wstring, wstring>(L"67", L"SineDegrees"),
+                                                                          make_pair<wstring, wstring>(L"73", L"SineRadians"),
+                                                                          make_pair<wstring, wstring>(L"79", L"SineGradians"),
+                                                                          make_pair<wstring, wstring>(L"70", L"InverseSineDegrees"),
+                                                                          make_pair<wstring, wstring>(L"76", L"InverseSineRadians"),
+                                                                          make_pair<wstring, wstring>(L"82", L"InverseSineGradians"),
+                                                                          make_pair<wstring, wstring>(L"25", L"HyperbolicSine"),
+                                                                          make_pair<wstring, wstring>(L"85", L"InverseHyperbolicSine"),
 
-        // Cosine permutations
-        make_pair<wstring, wstring>(L"68", L"CosineDegrees"), make_pair<wstring, wstring>(L"74", L"CosineRadians"),
-        make_pair<wstring, wstring>(L"80", L"CosineGradians"), make_pair<wstring, wstring>(L"71", L"InverseCosineDegrees"),
-        make_pair<wstring, wstring>(L"77", L"InverseCosineRadians"), make_pair<wstring, wstring>(L"83", L"InverseCosineGradians"),
-        make_pair<wstring, wstring>(L"26", L"HyperbolicCosine"), make_pair<wstring, wstring>(L"86", L"InverseHyperbolicCosine"),
+                                                                          // Cosine permutations
+                                                                          make_pair<wstring, wstring>(L"68", L"CosineDegrees"),
+                                                                          make_pair<wstring, wstring>(L"74", L"CosineRadians"),
+                                                                          make_pair<wstring, wstring>(L"80", L"CosineGradians"),
+                                                                          make_pair<wstring, wstring>(L"71", L"InverseCosineDegrees"),
+                                                                          make_pair<wstring, wstring>(L"77", L"InverseCosineRadians"),
+                                                                          make_pair<wstring, wstring>(L"83", L"InverseCosineGradians"),
+                                                                          make_pair<wstring, wstring>(L"26", L"HyperbolicCosine"),
+                                                                          make_pair<wstring, wstring>(L"86", L"InverseHyperbolicCosine"),
 
-        // Tangent permutations
-        make_pair<wstring, wstring>(L"69", L"TangentDegrees"), make_pair<wstring, wstring>(L"75", L"TangentRadians"),
-        make_pair<wstring, wstring>(L"81", L"TangentGradians"), make_pair<wstring, wstring>(L"72", L"InverseTangentDegrees"),
-        make_pair<wstring, wstring>(L"78", L"InverseTangentRadians"), make_pair<wstring, wstring>(L"84", L"InverseTangentGradians"),
-        make_pair<wstring, wstring>(L"27", L"HyperbolicTangent"), make_pair<wstring, wstring>(L"87", L"InverseHyperbolicTangent"),
+                                                                          // Tangent permutations
+                                                                          make_pair<wstring, wstring>(L"69", L"TangentDegrees"),
+                                                                          make_pair<wstring, wstring>(L"75", L"TangentRadians"),
+                                                                          make_pair<wstring, wstring>(L"81", L"TangentGradians"),
+                                                                          make_pair<wstring, wstring>(L"72", L"InverseTangentDegrees"),
+                                                                          make_pair<wstring, wstring>(L"78", L"InverseTangentRadians"),
+                                                                          make_pair<wstring, wstring>(L"84", L"InverseTangentGradians"),
+                                                                          make_pair<wstring, wstring>(L"27", L"HyperbolicTangent"),
+                                                                          make_pair<wstring, wstring>(L"87", L"InverseHyperbolicTangent"),
 
-        // Miscellaneous Scientific functions
-        make_pair<wstring, wstring>(L"94", L"Factorial"), make_pair<wstring, wstring>(L"35", L"DegreeMinuteSecond"),
-        make_pair<wstring, wstring>(L"28", L"NaturalLog"), make_pair<wstring, wstring>(L"91", L"Square")
+                                                                          // Miscellaneous Scientific functions
+                                                                          make_pair<wstring, wstring>(L"94", L"Factorial"),
+                                                                          make_pair<wstring, wstring>(L"35", L"DegreeMinuteSecond"),
+                                                                          make_pair<wstring, wstring>(L"28", L"NaturalLog"),
+                                                                          make_pair<wstring, wstring>(L"91", L"Square")
     };
 
     static vector<pair<wstring, wstring>> s_noParenEngineKeyResourceMap = { // Programmer mode functions

src/CalcViewModel/Common/LocalizationService.h

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

src/CalcViewModel/Common/LocalizationSettings.h

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

src/CalcViewModel/Common/NavCategory.cpp

@@ -49,42 +49,142 @@ static constexpr int CURRENCY_ID = 16;
 // ^^^ THESE CONSTANTS SHOULD NEVER CHANGE ^^^
 
 // The order of items in this list determines the order of items in the menu.
-static constexpr array<const NavCategoryInitializer, 17> s_categoryManifest = {
-    NavCategoryInitializer{ ViewMode::Standard, STANDARD_ID, L"Standard", L"StandardMode", L"\uE8EF", CategoryGroupType::Calculator, MyVirtualKey::Number1,
-                            SUPPORTS_ALL },
-    NavCategoryInitializer{ ViewMode::Scientific, SCIENTIFIC_ID, L"Scientific", L"ScientificMode", L"\uF196", CategoryGroupType::Calculator,
-                            MyVirtualKey::Number2, SUPPORTS_ALL },
-    NavCategoryInitializer{ ViewMode::Programmer, PROGRAMMER_ID, L"Programmer", L"ProgrammerMode", L"\uECCE", CategoryGroupType::Calculator,
-                            MyVirtualKey::Number3, SUPPORTS_ALL },
-    NavCategoryInitializer{ ViewMode::Date, DATE_ID, L"Date", L"DateCalculationMode", L"\uE787", CategoryGroupType::Calculator, MyVirtualKey::Number4,
-                            SUPPORTS_ALL },
-    NavCategoryInitializer{ ViewMode::Currency, CURRENCY_ID, L"Currency", L"CategoryName_Currency", L"\uEB0D", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Volume, VOLUME_ID, L"Volume", L"CategoryName_Volume", L"\uF1AA", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Length, LENGTH_ID, L"Length", L"CategoryName_Length", L"\uECC6", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Weight, WEIGHT_ID, L"Weight and Mass", L"CategoryName_Weight", L"\uF4C1", CategoryGroupType::Converter,
-                            MyVirtualKey::None, POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Temperature, TEMPERATURE_ID, L"Temperature", L"CategoryName_Temperature", L"\uE7A3", CategoryGroupType::Converter,
-                            MyVirtualKey::None, SUPPORTS_NEGATIVE },
-    NavCategoryInitializer{ ViewMode::Energy, ENERGY_ID, L"Energy", L"CategoryName_Energy", L"\uECAD", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Area, AREA_ID, L"Area", L"CategoryName_Area", L"\uE809", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Speed, SPEED_ID, L"Speed", L"CategoryName_Speed", L"\uEADA", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Time, TIME_ID, L"Time", L"CategoryName_Time", L"\uE917", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Power, POWER_ID, L"Power", L"CategoryName_Power", L"\uE945", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Data, DATA_ID, L"Data", L"CategoryName_Data", L"\uF20F", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Pressure, PRESSURE_ID, L"Pressure", L"CategoryName_Pressure", L"\uEC4A", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY },
-    NavCategoryInitializer{ ViewMode::Angle, ANGLE_ID, L"Angle", L"CategoryName_Angle", L"\uF515", CategoryGroupType::Converter, MyVirtualKey::None,
-                            POSITIVE_ONLY }
-};
+static constexpr array<const NavCategoryInitializer, 17> s_categoryManifest = { NavCategoryInitializer{ ViewMode::Standard,
+                                                                                                        STANDARD_ID,
+                                                                                                        L"Standard",
+                                                                                                        L"StandardMode",
+                                                                                                        L"\uE8EF",
+                                                                                                        CategoryGroupType::Calculator,
+                                                                                                        MyVirtualKey::Number1,
+                                                                                                        SUPPORTS_ALL },
+                                                                                NavCategoryInitializer{ ViewMode::Scientific,
+                                                                                                        SCIENTIFIC_ID,
+                                                                                                        L"Scientific",
+                                                                                                        L"ScientificMode",
+                                                                                                        L"\uF196",
+                                                                                                        CategoryGroupType::Calculator,
+                                                                                                        MyVirtualKey::Number2,
+                                                                                                        SUPPORTS_ALL },
+                                                                                NavCategoryInitializer{ ViewMode::Programmer,
+                                                                                                        PROGRAMMER_ID,
+                                                                                                        L"Programmer",
+                                                                                                        L"ProgrammerMode",
+                                                                                                        L"\uECCE",
+                                                                                                        CategoryGroupType::Calculator,
+                                                                                                        MyVirtualKey::Number3,
+                                                                                                        SUPPORTS_ALL },
+                                                                                NavCategoryInitializer{ ViewMode::Date,
+                                                                                                        DATE_ID,
+                                                                                                        L"Date",
+                                                                                                        L"DateCalculationMode",
+                                                                                                        L"\uE787",
+                                                                                                        CategoryGroupType::Calculator,
+                                                                                                        MyVirtualKey::Number4,
+                                                                                                        SUPPORTS_ALL },
+                                                                                NavCategoryInitializer{ ViewMode::Currency,
+                                                                                                        CURRENCY_ID,
+                                                                                                        L"Currency",
+                                                                                                        L"CategoryName_Currency",
+                                                                                                        L"\uEB0D",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Volume,
+                                                                                                        VOLUME_ID,
+                                                                                                        L"Volume",
+                                                                                                        L"CategoryName_Volume",
+                                                                                                        L"\uF1AA",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Length,
+                                                                                                        LENGTH_ID,
+                                                                                                        L"Length",
+                                                                                                        L"CategoryName_Length",
+                                                                                                        L"\uECC6",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Weight,
+                                                                                                        WEIGHT_ID,
+                                                                                                        L"Weight and Mass",
+                                                                                                        L"CategoryName_Weight",
+                                                                                                        L"\uF4C1",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Temperature,
+                                                                                                        TEMPERATURE_ID,
+                                                                                                        L"Temperature",
+                                                                                                        L"CategoryName_Temperature",
+                                                                                                        L"\uE7A3",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        SUPPORTS_NEGATIVE },
+                                                                                NavCategoryInitializer{ ViewMode::Energy,
+                                                                                                        ENERGY_ID,
+                                                                                                        L"Energy",
+                                                                                                        L"CategoryName_Energy",
+                                                                                                        L"\uECAD",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Area,
+                                                                                                        AREA_ID,
+                                                                                                        L"Area",
+                                                                                                        L"CategoryName_Area",
+                                                                                                        L"\uE809",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Speed,
+                                                                                                        SPEED_ID,
+                                                                                                        L"Speed",
+                                                                                                        L"CategoryName_Speed",
+                                                                                                        L"\uEADA",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Time,
+                                                                                                        TIME_ID,
+                                                                                                        L"Time",
+                                                                                                        L"CategoryName_Time",
+                                                                                                        L"\uE917",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Power,
+                                                                                                        POWER_ID,
+                                                                                                        L"Power",
+                                                                                                        L"CategoryName_Power",
+                                                                                                        L"\uE945",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Data,
+                                                                                                        DATA_ID,
+                                                                                                        L"Data",
+                                                                                                        L"CategoryName_Data",
+                                                                                                        L"\uF20F",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Pressure,
+                                                                                                        PRESSURE_ID,
+                                                                                                        L"Pressure",
+                                                                                                        L"CategoryName_Pressure",
+                                                                                                        L"\uEC4A",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Angle,
+                                                                                                        ANGLE_ID,
+                                                                                                        L"Angle",
+                                                                                                        L"CategoryName_Angle",
+                                                                                                        L"\uF515",
+                                                                                                        CategoryGroupType::Converter,
+                                                                                                        MyVirtualKey::None,
+                                                                                                        POSITIVE_ONLY } };
 
 // This function should only be used when storing the mode to app data.
 int NavCategory::Serialize(ViewMode mode)
@@ -105,8 +205,9 @@ ViewMode NavCategory::Deserialize(Platform::Object ^ obj)
     if (boxed != nullptr)
     {
         int serializationId = boxed->Value;
-        auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
-                            [serializationId](const NavCategoryInitializer& initializer) { return initializer.serializationId == serializationId; });
+        auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [serializationId](const NavCategoryInitializer& initializer) {
+            return initializer.serializationId == serializationId;
+        });
 
         if (iter != s_categoryManifest.end())
         {
@@ -144,8 +245,9 @@ bool NavCategory::IsConverterViewMode(ViewMode mode)
 
 bool NavCategory::IsModeInCategoryGroup(ViewMode mode, CategoryGroupType type)
 {
-    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
-                        [mode, type](const NavCategoryInitializer& initializer) { return initializer.viewMode == mode && initializer.groupType == type; });
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [mode, type](const NavCategoryInitializer& initializer) {
+        return initializer.viewMode == mode && initializer.groupType == type;
+    });
 
     return iter != s_categoryManifest.end();
 }
@@ -160,8 +262,9 @@ String ^ NavCategory::GetFriendlyName(ViewMode mode)
 
 ViewMode NavCategory::GetViewModeForFriendlyName(String ^ name)
 {
-    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
-                        [name](const NavCategoryInitializer& initializer) { return wcscmp(initializer.friendlyName, name->Data()) == 0; });
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [name](const NavCategoryInitializer& initializer) {
+        return wcscmp(initializer.friendlyName, name->Data()) == 0;
+    });
 
     return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
 }
@@ -238,8 +341,9 @@ int NavCategory::GetPosition(ViewMode mode)
 
 ViewMode NavCategory::GetViewModeForVirtualKey(MyVirtualKey virtualKey)
 {
-    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
-                        [virtualKey](const NavCategoryInitializer& initializer) { return initializer.virtualKey == virtualKey; });
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [virtualKey](const NavCategoryInitializer& initializer) {
+        return initializer.virtualKey == virtualKey;
+    });
 
     return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
 }
@@ -258,7 +362,8 @@ vector<MyVirtualKey> NavCategory::GetCategoryAcceleratorKeys()
     return accelerators;
 }
 
-NavCategoryGroup::NavCategoryGroup(const NavCategoryGroupInitializer& groupInitializer) : m_Categories(ref new Vector<NavCategory ^>())
+NavCategoryGroup::NavCategoryGroup(const NavCategoryGroupInitializer& groupInitializer)
+    : m_Categories(ref new Vector<NavCategory ^>())
 {
     m_GroupType = groupInitializer.type;
 
@@ -285,9 +390,14 @@ NavCategoryGroup::NavCategoryGroup(const NavCategoryGroupInitializer& groupIniti
             String ^ categoryAutomationName = ref new String(
                 LocalizationStringUtil::GetLocalizedString(navCategoryItemAutomationNameFormat->Data(), categoryName->Data(), m_Name->Data()).c_str());
 
-            m_Categories->Append(ref new NavCategory(categoryName, categoryAutomationName, StringReference(categoryInitializer.glyph),
-                                                     resProvider.GetResourceString(nameResourceKey + "AccessKey"), groupMode, categoryInitializer.viewMode,
-                                                     categoryInitializer.supportsNegative));
+            m_Categories->Append(ref new NavCategory(
+                categoryName,
+                categoryAutomationName,
+                StringReference(categoryInitializer.glyph),
+                resProvider.GetResourceString(nameResourceKey + "AccessKey"),
+                groupMode,
+                categoryInitializer.viewMode,
+                categoryInitializer.supportsNegative));
         }
     }
 }
@@ -313,16 +423,18 @@ NavCategoryGroup ^ NavCategoryGroup::CreateConverterCategory()
 vector<NavCategoryInitializer> NavCategoryGroup::GetInitializerCategoryGroup(CategoryGroupType groupType)
 {
     vector<NavCategoryInitializer> initializers{};
-    copy_if(begin(s_categoryManifest), end(s_categoryManifest), back_inserter(initializers),
-            [groupType](const NavCategoryInitializer& initializer) { return initializer.groupType == groupType; });
+    copy_if(begin(s_categoryManifest), end(s_categoryManifest), back_inserter(initializers), [groupType](const NavCategoryInitializer& initializer) {
+        return initializer.groupType == groupType;
+    });
 
     return initializers;
 }
 
 String ^ NavCategoryGroup::GetHeaderResourceKey(CategoryGroupType type)
 {
-    auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest),
-                        [type](const NavCategoryGroupInitializer& initializer) { return initializer.type == type; });
+    auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest), [type](const NavCategoryGroupInitializer& initializer) {
+        return initializer.type == type;
+    });
 
     return (iter != s_categoryGroupManifest.end()) ? StringReference(iter->headerResourceKey) : nullptr;
 }

src/CalcViewModel/Common/NavCategory.h

@@ -58,8 +58,15 @@ namespace CalculatorApp
     private
         struct NavCategoryInitializer
         {
-            constexpr NavCategoryInitializer(ViewMode mode, int id, wchar_t const* name, wchar_t const* nameKey, wchar_t const* glyph, CategoryGroupType group,
-                                             MyVirtualKey vKey, bool categorySupportsNegative)
+            constexpr NavCategoryInitializer(
+                ViewMode mode,
+                int id,
+                wchar_t const* name,
+                wchar_t const* nameKey,
+                wchar_t const* glyph,
+                CategoryGroupType group,
+                MyVirtualKey vKey,
+                bool categorySupportsNegative)
                 : viewMode(mode)
                 , serializationId(id)
                 , friendlyName(name)
@@ -85,7 +92,10 @@ namespace CalculatorApp
         struct NavCategoryGroupInitializer
         {
             constexpr NavCategoryGroupInitializer(CategoryGroupType t, wchar_t const* h, wchar_t const* n, wchar_t const* a)
-                : type(t), headerResourceKey(h), modeResourceKey(n), automationResourceKey(a)
+                : type(t)
+                , headerResourceKey(h)
+                , modeResourceKey(n)
+                , automationResourceKey(a)
             {
             }
 
@@ -161,8 +171,14 @@ namespace CalculatorApp
 
             static ViewMode GetViewModeForVirtualKey(MyVirtualKey virtualKey);
 
-            internal : NavCategory(Platform::String ^ name, Platform::String ^ automationName, Platform::String ^ glyph, Platform::String ^ accessKey,
-                                   Platform::String ^ mode, ViewMode viewMode, bool supportsNegative)
+            internal : NavCategory(
+                           Platform::String ^ name,
+                           Platform::String ^ automationName,
+                           Platform::String ^ glyph,
+                           Platform::String ^ accessKey,
+                           Platform::String ^ mode,
+                           ViewMode viewMode,
+                           bool supportsNegative)
                 : m_name(name)
                 , m_automationName(automationName)
                 , m_glyph(glyph)

src/CalcViewModel/Common/TraceActivity.h

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

src/CalcViewModel/Common/TraceLogger.cpp

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

src/CalcViewModel/Common/TraceLogger.h

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

src/CalcViewModel/Common/Utils.cpp

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

src/CalcViewModel/Common/Utils.h

@@ -384,9 +384,10 @@ namespace Utils
     double GetDoubleFromWstring(std::wstring input);
     int GetWindowId();
     void RunOnUIThreadNonblocking(std::function<void()>&& function, _In_ Windows::UI::Core::CoreDispatcher ^ currentDispatcher);
-    void SerializeCommandsAndTokens(_In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
-                                    _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands,
-                                    Windows::Storage::Streams::DataWriter ^ writer);
+    void SerializeCommandsAndTokens(
+        _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
+        _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands,
+        Windows::Storage::Streams::DataWriter ^ writer);
 
     const std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> DeserializeCommands(Windows::Storage::Streams::DataReader ^ reader);
     const std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> DeserializeTokens(Windows::Storage::Streams::DataReader ^ reader);
@@ -394,8 +395,11 @@ namespace Utils
     Windows::Foundation::DateTime GetUniversalSystemTime();
     bool IsDateTimeOlderThan(Windows::Foundation::DateTime dateTime, const long long duration);
 
-    concurrency::task<void> WriteFileToFolder(Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName, Platform::String ^ contents,
-                                              Windows::Storage::CreationCollisionOption collisionOption);
+    concurrency::task<void> WriteFileToFolder(
+        Windows::Storage::IStorageFolder ^ folder,
+        Platform::String ^ fileName,
+        Platform::String ^ contents,
+        Windows::Storage::CreationCollisionOption collisionOption);
     concurrency::task<Platform::String ^> ReadFileFromFolder(Windows::Storage::IStorageFolder ^ folder, Platform::String ^ fileName);
 }
 

src/CalcViewModel/Common/ValidatingConverters.h

@@ -17,16 +17,22 @@ namespace CalculatorApp
 
         private:
             virtual Platform::Object
-                ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
+                ^ Convert(
+                    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
                 return value;
             }
 
             virtual Platform::Object
-                ^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
+                ^ ConvertBack(
+                    Platform::Object ^ value,
+                    Windows::UI::Xaml::Interop::TypeName /*targetType*/,
+                    Platform::Object ^ /*parameter*/,
+                    Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
             {
                 if (value)
                 {
@@ -47,16 +53,22 @@ namespace CalculatorApp
 
         private:
             virtual Platform::Object
-                ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::Convert
+                ^ Convert(
+                    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
                 return value;
             }
 
             virtual Platform::Object
-                ^ ConvertBack(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::ConvertBack
+                ^ ConvertBack(
+                    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
                 // extract that value and ensure it is valid, ie >= 0

src/CalcViewModel/DataLoaders/CurrencyDataLoader.cpp

@@ -46,8 +46,10 @@ static constexpr auto CACHE_LANGCODE_KEY = L"CURRENCY_CONVERTER_LANGCODE";
 static constexpr auto CACHE_DELIMITER = L"%";
 
 static constexpr auto STATIC_DATA_FILENAME = L"CURRENCY_CONVERTER_STATIC_DATA.txt";
-static constexpr array<wstring_view, 5> STATIC_DATA_PROPERTIES = { wstring_view{ L"CountryCode", 11 }, wstring_view{ L"CountryName", 11 },
-                                                                   wstring_view{ L"CurrencyCode", 12 }, wstring_view{ L"CurrencyName", 12 },
+static constexpr array<wstring_view, 5> STATIC_DATA_PROPERTIES = { wstring_view{ L"CountryCode", 11 },
+                                                                   wstring_view{ L"CountryName", 11 },
+                                                                   wstring_view{ L"CurrencyCode", 12 },
+                                                                   wstring_view{ L"CurrencyName", 12 },
                                                                    wstring_view{ L"CurrencySymbol", 14 } };
 
 static constexpr auto ALL_RATIOS_DATA_FILENAME = L"CURRENCY_CONVERTER_ALL_RATIOS_DATA.txt";
@@ -275,8 +277,8 @@ pair<wstring, wstring> CurrencyDataLoader::GetCurrencyRatioEquality(_In_ const U
                 wstring digitSymbol = wstring{ LocalizationSettings::GetInstance().GetDigitSymbolFromEnUsDigit(L'1') };
                 wstring roundedFormat = m_ratioFormatter->Format(rounded)->Data();
 
-                wstring ratioString = LocalizationStringUtil::GetLocalizedString(m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.abbreviation.c_str(),
-                                                                                 roundedFormat.c_str(), unit2.abbreviation.c_str());
+                wstring ratioString = LocalizationStringUtil::GetLocalizedString(
+                    m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.abbreviation.c_str(), roundedFormat.c_str(), unit2.abbreviation.c_str());
 
                 wstring accessibleRatioString = LocalizationStringUtil::GetLocalizedString(
                     m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.accessibleName.c_str(), roundedFormat.c_str(), unit2.accessibleName.c_str());
@@ -459,8 +461,11 @@ task<bool> CurrencyDataLoader::TryLoadDataFromWebOverrideAsync()
 };
 #pragma optimize("", on)
 
-bool CurrencyDataLoader::TryParseWebResponses(_In_ String ^ staticDataJson, _In_ String ^ allRatiosJson, _Inout_ vector<UCM::CurrencyStaticData>& staticData,
-                                              _Inout_ CurrencyRatioMap& allRatiosData)
+bool CurrencyDataLoader::TryParseWebResponses(
+    _In_ String ^ staticDataJson,
+    _In_ String ^ allRatiosJson,
+    _Inout_ vector<UCM::CurrencyStaticData>& staticData,
+    _Inout_ CurrencyRatioMap& allRatiosData)
 {
     return TryParseStaticData(staticDataJson, staticData) && TryParseAllRatiosData(allRatiosJson, allRatiosData);
 }

src/CalcViewModel/DataLoaders/CurrencyDataLoader.h

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

src/CalcViewModel/DataLoaders/CurrencyHttpClient.cpp

@@ -13,7 +13,9 @@ using namespace Windows::Web::Http;
 static constexpr auto sc_MetadataUriLocalizeFor = L"https://go.microsoft.com/fwlink/?linkid=2041093&localizeFor=";
 static constexpr auto sc_RatiosUriRelativeTo = L"https://go.microsoft.com/fwlink/?linkid=2041339&localCurrency=";
 
-CurrencyHttpClient::CurrencyHttpClient() : m_client(ref new HttpClient()), m_responseLanguage(L"en-US")
+CurrencyHttpClient::CurrencyHttpClient()
+    : m_client(ref new HttpClient())
+    , m_responseLanguage(L"en-US")
 {
 }
 

src/CalcViewModel/DataLoaders/UnitConverterDataLoader.cpp

@@ -18,7 +18,8 @@ using namespace Windows::Globalization;
 
 static constexpr bool CONVERT_WITH_OFFSET_FIRST = true;
 
-UnitConverterDataLoader::UnitConverterDataLoader(GeographicRegion ^ region) : m_currentRegionCode(region->CodeTwoLetter)
+UnitConverterDataLoader::UnitConverterDataLoader(GeographicRegion ^ region)
+    : m_currentRegionCode(region->CodeTwoLetter)
 {
     m_categoryList = make_shared<vector<UCM::Category>>();
     m_categoryToUnits = make_shared<UCM::CategoryToUnitVectorMap>();
@@ -53,8 +54,9 @@ bool UnitConverterDataLoader::SupportsCategory(const UCM::Category& target)
     }
 
     static int currencyId = NavCategory::Serialize(ViewMode::Currency);
-    auto itr = find_if(supportedCategories->begin(), supportedCategories->end(),
-                       [&](const UCM::Category& category) { return currencyId != category.id && target.id == category.id; });
+    auto itr = find_if(supportedCategories->begin(), supportedCategories->end(), [&](const UCM::Category& category) {
+        return currencyId != category.id && target.id == category.id;
+    });
 
     return itr != supportedCategories->end();
 }
@@ -182,34 +184,65 @@ void UnitConverterDataLoader::GetUnits(_In_ unordered_map<ViewMode, vector<Order
         OrderedUnit{ UnitConverterUnits::Area_Acre, GetLocalizedStringName(L"UnitName_Acre"), GetLocalizedStringName(L"UnitAbbreviation_Acre"), 9 });
     areaUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Area_Hectare, GetLocalizedStringName(L"UnitName_Hectare"), GetLocalizedStringName(L"UnitAbbreviation_Hectare"), 4 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareCentimeter, GetLocalizedStringName(L"UnitName_SquareCentimeter"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareCentimeter"), 2 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareFoot, GetLocalizedStringName(L"UnitName_SquareFoot"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareFoot"), 7, useSI, useUSCustomary, false });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareInch, GetLocalizedStringName(L"UnitName_SquareInch"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareInch"), 6 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareKilometer, GetLocalizedStringName(L"UnitName_SquareKilometer"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareKilometer"), 5 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMeter, GetLocalizedStringName(L"UnitName_SquareMeter"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMeter"), 3, useUSCustomary, useSI, false });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMile, GetLocalizedStringName(L"UnitName_SquareMile"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMile"), 10 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMillimeter, GetLocalizedStringName(L"UnitName_SquareMillimeter"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMillimeter"), 1 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareYard, GetLocalizedStringName(L"UnitName_SquareYard"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareYard"), 8 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Hand, GetLocalizedStringName(L"UnitName_Hand"), GetLocalizedStringName(L"UnitAbbreviation_Hand"),
-                                     11, false, false, true });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Paper, GetLocalizedStringName(L"UnitName_Paper"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Paper"), 12, false, false, true });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SoccerField, GetLocalizedStringName(L"UnitName_SoccerField"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SoccerField"), 13, false, false, true });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Castle, GetLocalizedStringName(L"UnitName_Castle"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Castle"), 14, false, false, true });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareCentimeter,
+                                     GetLocalizedStringName(L"UnitName_SquareCentimeter"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareCentimeter"),
+                                     2 });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareFoot,
+                                     GetLocalizedStringName(L"UnitName_SquareFoot"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareFoot"),
+                                     7,
+                                     useSI,
+                                     useUSCustomary,
+                                     false });
+    areaUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Area_SquareInch, GetLocalizedStringName(L"UnitName_SquareInch"), GetLocalizedStringName(L"UnitAbbreviation_SquareInch"), 6 });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareKilometer,
+                                     GetLocalizedStringName(L"UnitName_SquareKilometer"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareKilometer"),
+                                     5 });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMeter,
+                                     GetLocalizedStringName(L"UnitName_SquareMeter"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMeter"),
+                                     3,
+                                     useUSCustomary,
+                                     useSI,
+                                     false });
+    areaUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Area_SquareMile, GetLocalizedStringName(L"UnitName_SquareMile"), GetLocalizedStringName(L"UnitAbbreviation_SquareMile"), 10 });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMillimeter,
+                                     GetLocalizedStringName(L"UnitName_SquareMillimeter"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMillimeter"),
+                                     1 });
+    areaUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Area_SquareYard, GetLocalizedStringName(L"UnitName_SquareYard"), GetLocalizedStringName(L"UnitAbbreviation_SquareYard"), 8 });
+    areaUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Area_Hand, GetLocalizedStringName(L"UnitName_Hand"), GetLocalizedStringName(L"UnitAbbreviation_Hand"), 11, false, false, true });
+    areaUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Area_Paper, GetLocalizedStringName(L"UnitName_Paper"), GetLocalizedStringName(L"UnitAbbreviation_Paper"), 12, false, false, true });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SoccerField,
+                                     GetLocalizedStringName(L"UnitName_SoccerField"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SoccerField"),
+                                     13,
+                                     false,
+                                     false,
+                                     true });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Castle,
+                                     GetLocalizedStringName(L"UnitName_Castle"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Castle"),
+                                     14,
+                                     false,
+                                     false,
+                                     true });
     if (usePyeong)
     {
-        areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Pyeong, GetLocalizedStringName(L"UnitName_Pyeong"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_Pyeong"), 15, false, false, false });
+        areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Pyeong,
+                                         GetLocalizedStringName(L"UnitName_Pyeong"),
+                                         GetLocalizedStringName(L"UnitAbbreviation_Pyeong"),
+                                         15,
+                                         false,
+                                         false,
+                                         false });
     }
     unitMap.emplace(ViewMode::Area, areaUnits);
 
@@ -220,169 +253,275 @@ void UnitConverterDataLoader::GetUnits(_In_ unordered_map<ViewMode, vector<Order
         OrderedUnit{ UnitConverterUnits::Data_Byte, GetLocalizedStringName(L"UnitName_Byte"), GetLocalizedStringName(L"UnitAbbreviation_Byte"), 2 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Exabits, GetLocalizedStringName(L"UnitName_Exabits"), GetLocalizedStringName(L"UnitAbbreviation_Exabits"), 23 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Exabytes, GetLocalizedStringName(L"UnitName_Exabytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exabytes"), 25 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Exbibits, GetLocalizedStringName(L"UnitName_Exbibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exbibits"), 24 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Exbibytes, GetLocalizedStringName(L"UnitName_Exbibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exbibytes"), 26 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gibibits, GetLocalizedStringName(L"UnitName_Gibibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gibibits"), 12 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gibibytes, GetLocalizedStringName(L"UnitName_Gibibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gibibytes"), 14 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Exabytes, GetLocalizedStringName(L"UnitName_Exabytes"), GetLocalizedStringName(L"UnitAbbreviation_Exabytes"), 25 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Exbibits, GetLocalizedStringName(L"UnitName_Exbibits"), GetLocalizedStringName(L"UnitAbbreviation_Exbibits"), 24 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Exbibytes, GetLocalizedStringName(L"UnitName_Exbibytes"), GetLocalizedStringName(L"UnitAbbreviation_Exbibytes"), 26 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Gibibits, GetLocalizedStringName(L"UnitName_Gibibits"), GetLocalizedStringName(L"UnitAbbreviation_Gibibits"), 12 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Gibibytes, GetLocalizedStringName(L"UnitName_Gibibytes"), GetLocalizedStringName(L"UnitAbbreviation_Gibibytes"), 14 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Gigabit, GetLocalizedStringName(L"UnitName_Gigabit"), GetLocalizedStringName(L"UnitAbbreviation_Gigabit"), 11 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gigabyte, GetLocalizedStringName(L"UnitName_Gigabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gigabyte"), 13, true, false, false });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Kibibits, GetLocalizedStringName(L"UnitName_Kibibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kibibits"), 4 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Kibibytes, GetLocalizedStringName(L"UnitName_Kibibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kibibytes"), 6 });
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gigabyte,
+                                     GetLocalizedStringName(L"UnitName_Gigabyte"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Gigabyte"),
+                                     13,
+                                     true,
+                                     false,
+                                     false });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Kibibits, GetLocalizedStringName(L"UnitName_Kibibits"), GetLocalizedStringName(L"UnitAbbreviation_Kibibits"), 4 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Kibibytes, GetLocalizedStringName(L"UnitName_Kibibytes"), GetLocalizedStringName(L"UnitAbbreviation_Kibibytes"), 6 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Kilobit, GetLocalizedStringName(L"UnitName_Kilobit"), GetLocalizedStringName(L"UnitAbbreviation_Kilobit"), 3 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Kilobyte, GetLocalizedStringName(L"UnitName_Kilobyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kilobyte"), 5 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Mebibits, GetLocalizedStringName(L"UnitName_Mebibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Mebibits"), 8 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Mebibytes, GetLocalizedStringName(L"UnitName_Mebibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Mebibytes"), 10 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Kilobyte, GetLocalizedStringName(L"UnitName_Kilobyte"), GetLocalizedStringName(L"UnitAbbreviation_Kilobyte"), 5 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Mebibits, GetLocalizedStringName(L"UnitName_Mebibits"), GetLocalizedStringName(L"UnitAbbreviation_Mebibits"), 8 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Mebibytes, GetLocalizedStringName(L"UnitName_Mebibytes"), GetLocalizedStringName(L"UnitAbbreviation_Mebibytes"), 10 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Megabit, GetLocalizedStringName(L"UnitName_Megabit"), GetLocalizedStringName(L"UnitAbbreviation_Megabit"), 7 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Megabyte, GetLocalizedStringName(L"UnitName_Megabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Megabyte"), 9, false, true, false });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Pebibits, GetLocalizedStringName(L"UnitName_Pebibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Pebibits"), 20 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Pebibytes, GetLocalizedStringName(L"UnitName_Pebibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Pebibytes"), 22 });
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Megabyte,
+                                     GetLocalizedStringName(L"UnitName_Megabyte"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Megabyte"),
+                                     9,
+                                     false,
+                                     true,
+                                     false });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Pebibits, GetLocalizedStringName(L"UnitName_Pebibits"), GetLocalizedStringName(L"UnitAbbreviation_Pebibits"), 20 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Pebibytes, GetLocalizedStringName(L"UnitName_Pebibytes"), GetLocalizedStringName(L"UnitAbbreviation_Pebibytes"), 22 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Petabit, GetLocalizedStringName(L"UnitName_Petabit"), GetLocalizedStringName(L"UnitAbbreviation_Petabit"), 19 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Petabyte, GetLocalizedStringName(L"UnitName_Petabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Petabyte"), 21 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Tebibits, GetLocalizedStringName(L"UnitName_Tebibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Tebibits"), 16 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Tebibytes, GetLocalizedStringName(L"UnitName_Tebibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Tebibytes"), 18 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Petabyte, GetLocalizedStringName(L"UnitName_Petabyte"), GetLocalizedStringName(L"UnitAbbreviation_Petabyte"), 21 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Tebibits, GetLocalizedStringName(L"UnitName_Tebibits"), GetLocalizedStringName(L"UnitAbbreviation_Tebibits"), 16 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Tebibytes, GetLocalizedStringName(L"UnitName_Tebibytes"), GetLocalizedStringName(L"UnitAbbreviation_Tebibytes"), 18 });
     dataUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Data_Terabit, GetLocalizedStringName(L"UnitName_Terabit"), GetLocalizedStringName(L"UnitAbbreviation_Terabit"), 15 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Terabyte, GetLocalizedStringName(L"UnitName_Terabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Terabyte"), 17 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yobibits, GetLocalizedStringName(L"UnitName_Yobibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yobibits"), 32 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yobibytes, GetLocalizedStringName(L"UnitName_Yobibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yobibytes"), 34 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yottabit, GetLocalizedStringName(L"UnitName_Yottabit"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yottabit"), 31 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yottabyte, GetLocalizedStringName(L"UnitName_Yottabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yottabyte"), 33 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zebibits, GetLocalizedStringName(L"UnitName_Zebibits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zebibits"), 28 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zebibytes, GetLocalizedStringName(L"UnitName_Zebibytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zebibytes"), 30 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zetabits, GetLocalizedStringName(L"UnitName_Zetabits"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zetabits"), 27 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zetabytes, GetLocalizedStringName(L"UnitName_Zetabytes"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zetabytes"), 29 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_FloppyDisk, GetLocalizedStringName(L"UnitName_FloppyDisk"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_FloppyDisk"), 13, false, false, true });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_CD, GetLocalizedStringName(L"UnitName_CD"), GetLocalizedStringName(L"UnitAbbreviation_CD"), 14,
-                                     false, false, true });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_DVD, GetLocalizedStringName(L"UnitName_DVD"), GetLocalizedStringName(L"UnitAbbreviation_DVD"), 15,
-                                     false, false, true });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Terabyte, GetLocalizedStringName(L"UnitName_Terabyte"), GetLocalizedStringName(L"UnitAbbreviation_Terabyte"), 17 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Yobibits, GetLocalizedStringName(L"UnitName_Yobibits"), GetLocalizedStringName(L"UnitAbbreviation_Yobibits"), 32 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Yobibytes, GetLocalizedStringName(L"UnitName_Yobibytes"), GetLocalizedStringName(L"UnitAbbreviation_Yobibytes"), 34 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Yottabit, GetLocalizedStringName(L"UnitName_Yottabit"), GetLocalizedStringName(L"UnitAbbreviation_Yottabit"), 31 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Yottabyte, GetLocalizedStringName(L"UnitName_Yottabyte"), GetLocalizedStringName(L"UnitAbbreviation_Yottabyte"), 33 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Zebibits, GetLocalizedStringName(L"UnitName_Zebibits"), GetLocalizedStringName(L"UnitAbbreviation_Zebibits"), 28 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Zebibytes, GetLocalizedStringName(L"UnitName_Zebibytes"), GetLocalizedStringName(L"UnitAbbreviation_Zebibytes"), 30 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Zetabits, GetLocalizedStringName(L"UnitName_Zetabits"), GetLocalizedStringName(L"UnitAbbreviation_Zetabits"), 27 });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_Zetabytes, GetLocalizedStringName(L"UnitName_Zetabytes"), GetLocalizedStringName(L"UnitAbbreviation_Zetabytes"), 29 });
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_FloppyDisk,
+                                     GetLocalizedStringName(L"UnitName_FloppyDisk"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_FloppyDisk"),
+                                     13,
+                                     false,
+                                     false,
+                                     true });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_CD, GetLocalizedStringName(L"UnitName_CD"), GetLocalizedStringName(L"UnitAbbreviation_CD"), 14, false, false, true });
+    dataUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Data_DVD, GetLocalizedStringName(L"UnitName_DVD"), GetLocalizedStringName(L"UnitAbbreviation_DVD"), 15, false, false, true });
     unitMap.emplace(ViewMode::Data, dataUnits);
 
     vector<OrderedUnit> energyUnits;
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_BritishThermalUnit, GetLocalizedStringName(L"UnitName_BritishThermalUnit"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_BritishThermalUnit"), 7 });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_BritishThermalUnit,
+                                       GetLocalizedStringName(L"UnitName_BritishThermalUnit"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_BritishThermalUnit"),
+                                       7 });
     energyUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Energy_Calorie, GetLocalizedStringName(L"UnitName_Calorie"), GetLocalizedStringName(L"UnitAbbreviation_Calorie"), 4 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_ElectronVolt, GetLocalizedStringName(L"UnitName_Electron-Volt"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Electron-Volt"), 1 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_FootPound, GetLocalizedStringName(L"UnitName_Foot-Pound"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Foot-Pound"), 6 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Joule, GetLocalizedStringName(L"UnitName_Joule"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Joule"), 2, true, false, false });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilocalorie, GetLocalizedStringName(L"UnitName_Kilocalorie"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilocalorie"), 5, false, true, false });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilojoule, GetLocalizedStringName(L"UnitName_Kilojoule"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilojoule"), 3 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Battery, GetLocalizedStringName(L"UnitName_Battery"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Battery"), 8, false, false, true });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Banana, GetLocalizedStringName(L"UnitName_Banana"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Banana"), 9, false, false, true });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_SliceOfCake, GetLocalizedStringName(L"UnitName_SliceOfCake"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SliceOfCake"), 10, false, false, true });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_ElectronVolt,
+                                       GetLocalizedStringName(L"UnitName_Electron-Volt"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Electron-Volt"),
+                                       1 });
+    energyUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Energy_FootPound, GetLocalizedStringName(L"UnitName_Foot-Pound"), GetLocalizedStringName(L"UnitAbbreviation_Foot-Pound"), 6 });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Joule,
+                                       GetLocalizedStringName(L"UnitName_Joule"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Joule"),
+                                       2,
+                                       true,
+                                       false,
+                                       false });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilocalorie,
+                                       GetLocalizedStringName(L"UnitName_Kilocalorie"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Kilocalorie"),
+                                       5,
+                                       false,
+                                       true,
+                                       false });
+    energyUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Energy_Kilojoule, GetLocalizedStringName(L"UnitName_Kilojoule"), GetLocalizedStringName(L"UnitAbbreviation_Kilojoule"), 3 });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Battery,
+                                       GetLocalizedStringName(L"UnitName_Battery"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Battery"),
+                                       8,
+                                       false,
+                                       false,
+                                       true });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Banana,
+                                       GetLocalizedStringName(L"UnitName_Banana"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Banana"),
+                                       9,
+                                       false,
+                                       false,
+                                       true });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_SliceOfCake,
+                                       GetLocalizedStringName(L"UnitName_SliceOfCake"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_SliceOfCake"),
+                                       10,
+                                       false,
+                                       false,
+                                       true });
     unitMap.emplace(ViewMode::Energy, energyUnits);
 
     vector<OrderedUnit> lengthUnits;
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Centimeter, GetLocalizedStringName(L"UnitName_Centimeter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Centimeter"), 4, useUSCustomary, useSI, false });
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Centimeter,
+                                       GetLocalizedStringName(L"UnitName_Centimeter"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Centimeter"),
+                                       4,
+                                       useUSCustomary,
+                                       useSI,
+                                       false });
     lengthUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Length_Foot, GetLocalizedStringName(L"UnitName_Foot"), GetLocalizedStringName(L"UnitAbbreviation_Foot"), 8 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Inch, GetLocalizedStringName(L"UnitName_Inch"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Inch"), 7, useSI, useUSCustomary, false });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Kilometer, GetLocalizedStringName(L"UnitName_Kilometer"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilometer"), 6 });
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Inch,
+                                       GetLocalizedStringName(L"UnitName_Inch"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Inch"),
+                                       7,
+                                       useSI,
+                                       useUSCustomary,
+                                       false });
+    lengthUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Length_Kilometer, GetLocalizedStringName(L"UnitName_Kilometer"), GetLocalizedStringName(L"UnitAbbreviation_Kilometer"), 6 });
     lengthUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Length_Meter, GetLocalizedStringName(L"UnitName_Meter"), GetLocalizedStringName(L"UnitAbbreviation_Meter"), 5 });
     lengthUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Length_Micron, GetLocalizedStringName(L"UnitName_Micron"), GetLocalizedStringName(L"UnitAbbreviation_Micron"), 2 });
     lengthUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Length_Mile, GetLocalizedStringName(L"UnitName_Mile"), GetLocalizedStringName(L"UnitAbbreviation_Mile"), 10 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Millimeter, GetLocalizedStringName(L"UnitName_Millimeter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Millimeter"), 3 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Nanometer, GetLocalizedStringName(L"UnitName_Nanometer"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Nanometer"), 1 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_NauticalMile, GetLocalizedStringName(L"UnitName_NauticalMile"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_NauticalMile"), 11 });
+    lengthUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Length_Millimeter, GetLocalizedStringName(L"UnitName_Millimeter"), GetLocalizedStringName(L"UnitAbbreviation_Millimeter"), 3 });
+    lengthUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Length_Nanometer, GetLocalizedStringName(L"UnitName_Nanometer"), GetLocalizedStringName(L"UnitAbbreviation_Nanometer"), 1 });
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_NauticalMile,
+                                       GetLocalizedStringName(L"UnitName_NauticalMile"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_NauticalMile"),
+                                       11 });
     lengthUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Length_Yard, GetLocalizedStringName(L"UnitName_Yard"), GetLocalizedStringName(L"UnitAbbreviation_Yard"), 9 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Paperclip, GetLocalizedStringName(L"UnitName_Paperclip"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Paperclip"), 12, false, false, true });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Hand, GetLocalizedStringName(L"UnitName_Hand"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Hand"), 13, false, false, true });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_JumboJet, GetLocalizedStringName(L"UnitName_JumboJet"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_JumboJet"), 14, false, false, true });
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Paperclip,
+                                       GetLocalizedStringName(L"UnitName_Paperclip"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Paperclip"),
+                                       12,
+                                       false,
+                                       false,
+                                       true });
+    lengthUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Length_Hand, GetLocalizedStringName(L"UnitName_Hand"), GetLocalizedStringName(L"UnitAbbreviation_Hand"), 13, false, false, true });
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_JumboJet,
+                                       GetLocalizedStringName(L"UnitName_JumboJet"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_JumboJet"),
+                                       14,
+                                       false,
+                                       false,
+                                       true });
     unitMap.emplace(ViewMode::Length, lengthUnits);
 
     vector<OrderedUnit> powerUnits;
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_BritishThermalUnitPerMinute, GetLocalizedStringName(L"UnitName_BTUPerMinute"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_BTUPerMinute"), 5 });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_FootPoundPerMinute, GetLocalizedStringName(L"UnitName_Foot-PoundPerMinute"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Foot-PoundPerMinute"), 4 });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horsepower, GetLocalizedStringName(L"UnitName_Horsepower"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horsepower"), 3, false, true, false });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Kilowatt, GetLocalizedStringName(L"UnitName_Kilowatt"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Kilowatt"), 2, !useWattInsteadOfKilowatt });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Watt, GetLocalizedStringName(L"UnitName_Watt"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Watt"), 1, useWattInsteadOfKilowatt });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_LightBulb, GetLocalizedStringName(L"UnitName_LightBulb"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_LightBulb"), 6, false, false, true });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horse, GetLocalizedStringName(L"UnitName_Horse"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horse"), 7, false, false, true });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_TrainEngine, GetLocalizedStringName(L"UnitName_TrainEngine"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_TrainEngine"), 8, false, false, true });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_BritishThermalUnitPerMinute,
+                                      GetLocalizedStringName(L"UnitName_BTUPerMinute"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_BTUPerMinute"),
+                                      5 });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_FootPoundPerMinute,
+                                      GetLocalizedStringName(L"UnitName_Foot-PoundPerMinute"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Foot-PoundPerMinute"),
+                                      4 });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horsepower,
+                                      GetLocalizedStringName(L"UnitName_Horsepower"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Horsepower"),
+                                      3,
+                                      false,
+                                      true,
+                                      false });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Kilowatt,
+                                      GetLocalizedStringName(L"UnitName_Kilowatt"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Kilowatt"),
+                                      2,
+                                      !useWattInsteadOfKilowatt });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Watt,
+                                      GetLocalizedStringName(L"UnitName_Watt"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Watt"),
+                                      1,
+                                      useWattInsteadOfKilowatt });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_LightBulb,
+                                      GetLocalizedStringName(L"UnitName_LightBulb"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_LightBulb"),
+                                      6,
+                                      false,
+                                      false,
+                                      true });
+    powerUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Power_Horse, GetLocalizedStringName(L"UnitName_Horse"), GetLocalizedStringName(L"UnitAbbreviation_Horse"), 7, false, false, true });
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_TrainEngine,
+                                      GetLocalizedStringName(L"UnitName_TrainEngine"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_TrainEngine"),
+                                      8,
+                                      false,
+                                      false,
+                                      true });
     unitMap.emplace(ViewMode::Power, powerUnits);
 
     vector<OrderedUnit> tempUnits;
-    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesCelsius, GetLocalizedStringName(L"UnitName_DegreesCelsius"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesCelsius"), 1, useFahrenheit, !useFahrenheit, false });
-    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesFahrenheit, GetLocalizedStringName(L"UnitName_DegreesFahrenheit"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesFahrenheit"), 2, !useFahrenheit, useFahrenheit, false });
-    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_Kelvin, GetLocalizedStringName(L"UnitName_Kelvin"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kelvin"), 3 });
+    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesCelsius,
+                                     GetLocalizedStringName(L"UnitName_DegreesCelsius"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesCelsius"),
+                                     1,
+                                     useFahrenheit,
+                                     !useFahrenheit,
+                                     false });
+    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesFahrenheit,
+                                     GetLocalizedStringName(L"UnitName_DegreesFahrenheit"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesFahrenheit"),
+                                     2,
+                                     !useFahrenheit,
+                                     useFahrenheit,
+                                     false });
+    tempUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Temperature_Kelvin, GetLocalizedStringName(L"UnitName_Kelvin"), GetLocalizedStringName(L"UnitAbbreviation_Kelvin"), 3 });
     unitMap.emplace(ViewMode::Temperature, tempUnits);
 
     vector<OrderedUnit> timeUnits;
     timeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Time_Day, GetLocalizedStringName(L"UnitName_Day"), GetLocalizedStringName(L"UnitAbbreviation_Day"), 6 });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Hour, GetLocalizedStringName(L"UnitName_Hour"), GetLocalizedStringName(L"UnitAbbreviation_Hour"),
-                                     5, true, false, false });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Microsecond, GetLocalizedStringName(L"UnitName_Microsecond"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Microsecond"), 1 });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Millisecond, GetLocalizedStringName(L"UnitName_Millisecond"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Millisecond"), 2 });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Minute, GetLocalizedStringName(L"UnitName_Minute"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Minute"), 4, false, true, false });
+    timeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Time_Hour, GetLocalizedStringName(L"UnitName_Hour"), GetLocalizedStringName(L"UnitAbbreviation_Hour"), 5, true, false, false });
+    timeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Time_Microsecond, GetLocalizedStringName(L"UnitName_Microsecond"), GetLocalizedStringName(L"UnitAbbreviation_Microsecond"), 1 });
+    timeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Time_Millisecond, GetLocalizedStringName(L"UnitName_Millisecond"), GetLocalizedStringName(L"UnitAbbreviation_Millisecond"), 2 });
+    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Minute,
+                                     GetLocalizedStringName(L"UnitName_Minute"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Minute"),
+                                     4,
+                                     false,
+                                     true,
+                                     false });
     timeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Time_Second, GetLocalizedStringName(L"UnitName_Second"), GetLocalizedStringName(L"UnitAbbreviation_Second"), 3 });
     timeUnits.push_back(
@@ -392,136 +531,239 @@ void UnitConverterDataLoader::GetUnits(_In_ unordered_map<ViewMode, vector<Order
     unitMap.emplace(ViewMode::Time, timeUnits);
 
     vector<OrderedUnit> speedUnits;
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_CentimetersPerSecond, GetLocalizedStringName(L"UnitName_CentimetersPerSecond"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_CentimetersPerSecond"), 1 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_FeetPerSecond, GetLocalizedStringName(L"UnitName_FeetPerSecond"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_FeetPerSecond"), 4 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_KilometersPerHour, GetLocalizedStringName(L"UnitName_KilometersPerHour"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_KilometersPerHour"), 3, useUSCustomary, useSI, false });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_CentimetersPerSecond,
+                                      GetLocalizedStringName(L"UnitName_CentimetersPerSecond"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_CentimetersPerSecond"),
+                                      1 });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_FeetPerSecond,
+                                      GetLocalizedStringName(L"UnitName_FeetPerSecond"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_FeetPerSecond"),
+                                      4 });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_KilometersPerHour,
+                                      GetLocalizedStringName(L"UnitName_KilometersPerHour"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_KilometersPerHour"),
+                                      3,
+                                      useUSCustomary,
+                                      useSI,
+                                      false });
     speedUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Speed_Knot, GetLocalizedStringName(L"UnitName_Knot"), GetLocalizedStringName(L"UnitAbbreviation_Knot"), 6 });
     speedUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Speed_Mach, GetLocalizedStringName(L"UnitName_Mach"), GetLocalizedStringName(L"UnitAbbreviation_Mach"), 7 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MetersPerSecond, GetLocalizedStringName(L"UnitName_MetersPerSecond"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_MetersPerSecond"), 2 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MilesPerHour, GetLocalizedStringName(L"UnitName_MilesPerHour"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_MilesPerHour"), 5, useSI, useUSCustomary, false });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Turtle, GetLocalizedStringName(L"UnitName_Turtle"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Turtle"), 8, false, false, true });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Horse, GetLocalizedStringName(L"UnitName_Horse"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horse"), 9, false, false, true });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Jet, GetLocalizedStringName(L"UnitName_Jet"), GetLocalizedStringName(L"UnitAbbreviation_Jet"),
-                                      10, false, false, true });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MetersPerSecond,
+                                      GetLocalizedStringName(L"UnitName_MetersPerSecond"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_MetersPerSecond"),
+                                      2 });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MilesPerHour,
+                                      GetLocalizedStringName(L"UnitName_MilesPerHour"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_MilesPerHour"),
+                                      5,
+                                      useSI,
+                                      useUSCustomary,
+                                      false });
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Turtle,
+                                      GetLocalizedStringName(L"UnitName_Turtle"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Turtle"),
+                                      8,
+                                      false,
+                                      false,
+                                      true });
+    speedUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Speed_Horse, GetLocalizedStringName(L"UnitName_Horse"), GetLocalizedStringName(L"UnitAbbreviation_Horse"), 9, false, false, true });
+    speedUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Speed_Jet, GetLocalizedStringName(L"UnitName_Jet"), GetLocalizedStringName(L"UnitAbbreviation_Jet"), 10, false, false, true });
     unitMap.emplace(ViewMode::Speed, speedUnits);
 
     vector<OrderedUnit> volumeUnits;
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicCentimeter, GetLocalizedStringName(L"UnitName_CubicCentimeter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicCentimeter"), 2 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicFoot, GetLocalizedStringName(L"UnitName_CubicFoot"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicFoot"), 13 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicInch, GetLocalizedStringName(L"UnitName_CubicInch"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicInch"), 12 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicMeter, GetLocalizedStringName(L"UnitName_CubicMeter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicMeter"), 4 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicYard, GetLocalizedStringName(L"UnitName_CubicYard"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicYard"), 14 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicCentimeter,
+                                       GetLocalizedStringName(L"UnitName_CubicCentimeter"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_CubicCentimeter"),
+                                       2 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_CubicFoot, GetLocalizedStringName(L"UnitName_CubicFoot"), GetLocalizedStringName(L"UnitAbbreviation_CubicFoot"), 13 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_CubicInch, GetLocalizedStringName(L"UnitName_CubicInch"), GetLocalizedStringName(L"UnitAbbreviation_CubicInch"), 12 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_CubicMeter, GetLocalizedStringName(L"UnitName_CubicMeter"), GetLocalizedStringName(L"UnitAbbreviation_CubicMeter"), 4 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_CubicYard, GetLocalizedStringName(L"UnitName_CubicYard"), GetLocalizedStringName(L"UnitAbbreviation_CubicYard"), 14 });
     volumeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Volume_CupUS, GetLocalizedStringName(L"UnitName_CupUS"), GetLocalizedStringName(L"UnitAbbreviation_CupUS"), 8 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUK, GetLocalizedStringName(L"UnitName_FluidOunceUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUK"), 17 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUS, GetLocalizedStringName(L"UnitName_FluidOunceUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUS"), 7 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_GallonUK, GetLocalizedStringName(L"UnitName_GallonUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_GallonUK"), 20 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_GallonUS, GetLocalizedStringName(L"UnitName_GallonUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_GallonUS"), 11 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUK,
+                                       GetLocalizedStringName(L"UnitName_FluidOunceUK"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUK"),
+                                       17 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUS,
+                                       GetLocalizedStringName(L"UnitName_FluidOunceUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUS"),
+                                       7 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_GallonUK, GetLocalizedStringName(L"UnitName_GallonUK"), GetLocalizedStringName(L"UnitAbbreviation_GallonUK"), 20 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_GallonUS, GetLocalizedStringName(L"UnitName_GallonUS"), GetLocalizedStringName(L"UnitAbbreviation_GallonUS"), 11 });
     volumeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Volume_Liter, GetLocalizedStringName(L"UnitName_Liter"), GetLocalizedStringName(L"UnitAbbreviation_Liter"), 3 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Milliliter, GetLocalizedStringName(L"UnitName_Milliliter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Milliliter"), 1, useUSCustomary, useSI });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Milliliter,
+                                       GetLocalizedStringName(L"UnitName_Milliliter"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Milliliter"),
+                                       1,
+                                       useUSCustomary,
+                                       useSI });
     volumeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Volume_PintUK, GetLocalizedStringName(L"UnitName_PintUK"), GetLocalizedStringName(L"UnitAbbreviation_PintUK"), 18 });
     volumeUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Volume_PintUS, GetLocalizedStringName(L"UnitName_PintUS"), GetLocalizedStringName(L"UnitAbbreviation_PintUS"), 9 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUS, GetLocalizedStringName(L"UnitName_TablespoonUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUS"), 6 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUS, GetLocalizedStringName(L"UnitName_TeaspoonUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUS"), 5, useSI, useUSCustomary && m_currentRegionCode != "GB" });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_QuartUK, GetLocalizedStringName(L"UnitName_QuartUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_QuartUK"), 19 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_QuartUS, GetLocalizedStringName(L"UnitName_QuartUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_QuartUS"), 10 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUK, GetLocalizedStringName(L"UnitName_TeaspoonUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUK"), 15, false, useUSCustomary && m_currentRegionCode == "GB" });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUK, GetLocalizedStringName(L"UnitName_TablespoonUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUK"), 16 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CoffeeCup, GetLocalizedStringName(L"UnitName_CoffeeCup"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CoffeeCup"), 22, false, false, true });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Bathtub, GetLocalizedStringName(L"UnitName_Bathtub"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Bathtub"), 23, false, false, true });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_SwimmingPool, GetLocalizedStringName(L"UnitName_SwimmingPool"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SwimmingPool"), 24, false, false, true });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUS,
+                                       GetLocalizedStringName(L"UnitName_TablespoonUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUS"),
+                                       6 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUS,
+                                       GetLocalizedStringName(L"UnitName_TeaspoonUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUS"),
+                                       5,
+                                       useSI,
+                                       useUSCustomary && m_currentRegionCode != "GB" });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_QuartUK, GetLocalizedStringName(L"UnitName_QuartUK"), GetLocalizedStringName(L"UnitAbbreviation_QuartUK"), 19 });
+    volumeUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Volume_QuartUS, GetLocalizedStringName(L"UnitName_QuartUS"), GetLocalizedStringName(L"UnitAbbreviation_QuartUS"), 10 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUK,
+                                       GetLocalizedStringName(L"UnitName_TeaspoonUK"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUK"),
+                                       15,
+                                       false,
+                                       useUSCustomary && m_currentRegionCode == "GB" });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUK,
+                                       GetLocalizedStringName(L"UnitName_TablespoonUK"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUK"),
+                                       16 });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CoffeeCup,
+                                       GetLocalizedStringName(L"UnitName_CoffeeCup"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_CoffeeCup"),
+                                       22,
+                                       false,
+                                       false,
+                                       true });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Bathtub,
+                                       GetLocalizedStringName(L"UnitName_Bathtub"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Bathtub"),
+                                       23,
+                                       false,
+                                       false,
+                                       true });
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_SwimmingPool,
+                                       GetLocalizedStringName(L"UnitName_SwimmingPool"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_SwimmingPool"),
+                                       24,
+                                       false,
+                                       false,
+                                       true });
     unitMap.emplace(ViewMode::Volume, volumeUnits);
 
     vector<OrderedUnit> weightUnits;
     weightUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Weight_Carat, GetLocalizedStringName(L"UnitName_Carat"), GetLocalizedStringName(L"UnitAbbreviation_Carat"), 1 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Centigram, GetLocalizedStringName(L"UnitName_Centigram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Centigram"), 3 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Decigram, GetLocalizedStringName(L"UnitName_Decigram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Decigram"), 4 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Decagram, GetLocalizedStringName(L"UnitName_Decagram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Decagram"), 6 });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_Centigram, GetLocalizedStringName(L"UnitName_Centigram"), GetLocalizedStringName(L"UnitAbbreviation_Centigram"), 3 });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_Decigram, GetLocalizedStringName(L"UnitName_Decigram"), GetLocalizedStringName(L"UnitAbbreviation_Decigram"), 4 });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_Decagram, GetLocalizedStringName(L"UnitName_Decagram"), GetLocalizedStringName(L"UnitAbbreviation_Decagram"), 6 });
     weightUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Weight_Gram, GetLocalizedStringName(L"UnitName_Gram"), GetLocalizedStringName(L"UnitAbbreviation_Gram"), 5 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Hectogram, GetLocalizedStringName(L"UnitName_Hectogram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Hectogram"), 7 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Kilogram, GetLocalizedStringName(L"UnitName_Kilogram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilogram"), 8, useUSCustomary, useSI });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_LongTon, GetLocalizedStringName(L"UnitName_LongTon"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_LongTon"), 14 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Milligram, GetLocalizedStringName(L"UnitName_Milligram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Milligram"), 2 });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_Hectogram, GetLocalizedStringName(L"UnitName_Hectogram"), GetLocalizedStringName(L"UnitAbbreviation_Hectogram"), 7 });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Kilogram,
+                                       GetLocalizedStringName(L"UnitName_Kilogram"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Kilogram"),
+                                       8,
+                                       useUSCustomary,
+                                       useSI });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_LongTon, GetLocalizedStringName(L"UnitName_LongTon"), GetLocalizedStringName(L"UnitAbbreviation_LongTon"), 14 });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_Milligram, GetLocalizedStringName(L"UnitName_Milligram"), GetLocalizedStringName(L"UnitAbbreviation_Milligram"), 2 });
     weightUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Weight_Ounce, GetLocalizedStringName(L"UnitName_Ounce"), GetLocalizedStringName(L"UnitAbbreviation_Ounce"), 10 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Pound, GetLocalizedStringName(L"UnitName_Pound"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Pound"), 11, useSI, useUSCustomary });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_ShortTon, GetLocalizedStringName(L"UnitName_ShortTon"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_ShortTon"), 13 });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Pound,
+                                       GetLocalizedStringName(L"UnitName_Pound"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Pound"),
+                                       11,
+                                       useSI,
+                                       useUSCustomary });
+    weightUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Weight_ShortTon, GetLocalizedStringName(L"UnitName_ShortTon"), GetLocalizedStringName(L"UnitAbbreviation_ShortTon"), 13 });
     weightUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Weight_Stone, GetLocalizedStringName(L"UnitName_Stone"), GetLocalizedStringName(L"UnitAbbreviation_Stone"), 12 });
     weightUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Weight_Tonne, GetLocalizedStringName(L"UnitName_Tonne"), GetLocalizedStringName(L"UnitAbbreviation_Tonne"), 9 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Snowflake, GetLocalizedStringName(L"UnitName_Snowflake"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Snowflake"), 15, false, false, true });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_SoccerBall, GetLocalizedStringName(L"UnitName_SoccerBall"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SoccerBall"), 16, false, false, true });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Elephant, GetLocalizedStringName(L"UnitName_Elephant"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Elephant"), 17, false, false, true });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Whale, GetLocalizedStringName(L"UnitName_Whale"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Whale"), 18, false, false, true });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Snowflake,
+                                       GetLocalizedStringName(L"UnitName_Snowflake"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Snowflake"),
+                                       15,
+                                       false,
+                                       false,
+                                       true });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_SoccerBall,
+                                       GetLocalizedStringName(L"UnitName_SoccerBall"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_SoccerBall"),
+                                       16,
+                                       false,
+                                       false,
+                                       true });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Elephant,
+                                       GetLocalizedStringName(L"UnitName_Elephant"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Elephant"),
+                                       17,
+                                       false,
+                                       false,
+                                       true });
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Whale,
+                                       GetLocalizedStringName(L"UnitName_Whale"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Whale"),
+                                       18,
+                                       false,
+                                       false,
+                                       true });
     unitMap.emplace(ViewMode::Weight, weightUnits);
 
     vector<OrderedUnit> pressureUnits;
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_Atmosphere, GetLocalizedStringName(L"UnitName_Atmosphere"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_Atmosphere"), 1, true, false, false });
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_Bar, GetLocalizedStringName(L"UnitName_Bar"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_Bar"), 2, false, true, false });
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_KiloPascal, GetLocalizedStringName(L"UnitName_KiloPascal"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_KiloPascal"), 3 });
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_MillimeterOfMercury, GetLocalizedStringName(L"UnitName_MillimeterOfMercury "),
-                                         GetLocalizedStringName(L"UnitAbbreviation_MillimeterOfMercury "), 4 });
+    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_Atmosphere,
+                                         GetLocalizedStringName(L"UnitName_Atmosphere"),
+                                         GetLocalizedStringName(L"UnitAbbreviation_Atmosphere"),
+                                         1,
+                                         true,
+                                         false,
+                                         false });
+    pressureUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Pressure_Bar, GetLocalizedStringName(L"UnitName_Bar"), GetLocalizedStringName(L"UnitAbbreviation_Bar"), 2, false, true, false });
+    pressureUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Pressure_KiloPascal, GetLocalizedStringName(L"UnitName_KiloPascal"), GetLocalizedStringName(L"UnitAbbreviation_KiloPascal"), 3 });
+    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_MillimeterOfMercury,
+                                         GetLocalizedStringName(L"UnitName_MillimeterOfMercury "),
+                                         GetLocalizedStringName(L"UnitAbbreviation_MillimeterOfMercury "),
+                                         4 });
     pressureUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Pressure_Pascal, GetLocalizedStringName(L"UnitName_Pascal"), GetLocalizedStringName(L"UnitAbbreviation_Pascal"), 5 });
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_PSI, GetLocalizedStringName(L"UnitName_PSI"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_PSI"), 6, false, false, false });
+    pressureUnits.push_back(OrderedUnit{
+        UnitConverterUnits::Pressure_PSI, GetLocalizedStringName(L"UnitName_PSI"), GetLocalizedStringName(L"UnitAbbreviation_PSI"), 6, false, false, false });
     unitMap.emplace(ViewMode::Pressure, pressureUnits);
 
     vector<OrderedUnit> angleUnits;
-    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Degree, GetLocalizedStringName(L"UnitName_Degree"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Degree"), 1, true, false, false });
-    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Radian, GetLocalizedStringName(L"UnitName_Radian"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Radian"), 2, false, true, false });
+    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Degree,
+                                      GetLocalizedStringName(L"UnitName_Degree"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Degree"),
+                                      1,
+                                      true,
+                                      false,
+                                      false });
+    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Radian,
+                                      GetLocalizedStringName(L"UnitName_Radian"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Radian"),
+                                      2,
+                                      false,
+                                      true,
+                                      false });
     angleUnits.push_back(
         OrderedUnit{ UnitConverterUnits::Angle_Gradian, GetLocalizedStringName(L"UnitName_Gradian"), GetLocalizedStringName(L"UnitAbbreviation_Gradian"), 3 });
     unitMap.emplace(ViewMode::Angle, angleUnits);
@@ -721,12 +963,24 @@ void UnitConverterDataLoader::GetExplicitConversionData(_In_ unordered_map<int,
         { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesCelsius, UnitConverterUnits::Temperature_DegreesCelsius, 1, 0 },
         { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesCelsius, UnitConverterUnits::Temperature_DegreesFahrenheit, 1.8, 32 },
         { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesCelsius, UnitConverterUnits::Temperature_Kelvin, 1, 273.15 },
-        { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesFahrenheit, UnitConverterUnits::Temperature_DegreesCelsius,
-          0.55555555555555555555555555555556, -32, CONVERT_WITH_OFFSET_FIRST },
+        { ViewMode::Temperature,
+          UnitConverterUnits::Temperature_DegreesFahrenheit,
+          UnitConverterUnits::Temperature_DegreesCelsius,
+          0.55555555555555555555555555555556,
+          -32,
+          CONVERT_WITH_OFFSET_FIRST },
         { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesFahrenheit, UnitConverterUnits::Temperature_DegreesFahrenheit, 1, 0 },
-        { ViewMode::Temperature, UnitConverterUnits::Temperature_DegreesFahrenheit, UnitConverterUnits::Temperature_Kelvin, 0.55555555555555555555555555555556,
-          459.67, CONVERT_WITH_OFFSET_FIRST },
-        { ViewMode::Temperature, UnitConverterUnits::Temperature_Kelvin, UnitConverterUnits::Temperature_DegreesCelsius, 1, -273.15,
+        { ViewMode::Temperature,
+          UnitConverterUnits::Temperature_DegreesFahrenheit,
+          UnitConverterUnits::Temperature_Kelvin,
+          0.55555555555555555555555555555556,
+          459.67,
+          CONVERT_WITH_OFFSET_FIRST },
+        { ViewMode::Temperature,
+          UnitConverterUnits::Temperature_Kelvin,
+          UnitConverterUnits::Temperature_DegreesCelsius,
+          1,
+          -273.15,
           CONVERT_WITH_OFFSET_FIRST },
         { ViewMode::Temperature, UnitConverterUnits::Temperature_Kelvin, UnitConverterUnits::Temperature_DegreesFahrenheit, 1.8, -459.67 },
         { ViewMode::Temperature, UnitConverterUnits::Temperature_Kelvin, UnitConverterUnits::Temperature_Kelvin, 1, 0 }

src/CalcViewModel/DataLoaders/UnitConverterDataLoader.h

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

src/CalcViewModel/DateCalculatorViewModel.cpp

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

src/CalcViewModel/HistoryItemViewModel.cpp

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

src/CalcViewModel/HistoryItemViewModel.h

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

src/CalcViewModel/HistoryViewModel.cpp

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

src/CalcViewModel/HistoryViewModel.h

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

src/CalcViewModel/MemoryItemViewModel.h

@@ -18,7 +18,9 @@ namespace CalculatorApp
                                                                                           Windows::UI::Xaml::Data::ICustomPropertyProvider
         {
         public:
-            MemoryItemViewModel(StandardCalculatorViewModel ^ calcVM) : m_Position(-1), m_calcVM(calcVM)
+            MemoryItemViewModel(StandardCalculatorViewModel ^ calcVM)
+                : m_Position(-1)
+                , m_calcVM(calcVM)
             {
             }
             OBSERVABLE_OBJECT();

src/CalcViewModel/StandardCalculatorViewModel.cpp

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

src/CalcViewModel/StandardCalculatorViewModel.h

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

src/CalcViewModel/UnitConverterViewModel.cpp

@@ -463,7 +463,8 @@ void UnitConverterViewModel::UpdateSupplementaryResults(const std::vector<std::t
 
     // Schedule the timer
     m_supplementaryResultsTimer = ThreadPoolTimer::CreateTimer(
-        ref new TimerElapsedHandler(this, &UnitConverterViewModel::SupplementaryResultsTimerTick, TIMER_CALLBACK_CONTEXT), SUPPLEMENTARY_VALUES_INTERVAL,
+        ref new TimerElapsedHandler(this, &UnitConverterViewModel::SupplementaryResultsTimerTick, TIMER_CALLBACK_CONTEXT),
+        SUPPLEMENTARY_VALUES_INTERVAL,
         ref new TimerDestroyedHandler(this, &UnitConverterViewModel::SupplementaryResultsTimerCancel, TIMER_CALLBACK_CONTEXT));
 }
 
@@ -1010,12 +1011,16 @@ String ^ UnitConverterViewModel::GetLocalizedAutomationName(_In_ String ^ displa
 }
 
 String
-    ^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(_In_ String ^ fromValue, _In_ String ^ fromUnit, _In_ String ^ toValue,
-                                                                       _In_ String ^ toUnit)
+    ^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(
+        _In_ String ^ fromValue,
+        _In_ String ^ fromUnit,
+        _In_ String ^ toValue,
+        _In_ String ^ toUnit)
 {
-    String ^ localizedString = ref new String(LocalizationStringUtil::GetLocalizedString(m_localizedConversionResultFormat->Data(), fromValue->Data(),
-                                                                                         fromUnit->Data(), toValue->Data(), toUnit->Data())
-                                                  .c_str());
+    String ^ localizedString =
+        ref new String(LocalizationStringUtil::GetLocalizedString(
+                           m_localizedConversionResultFormat->Data(), fromValue->Data(), fromUnit->Data(), toValue->Data(), toUnit->Data())
+                           .c_str());
     return localizedString;
 }
 

src/CalcViewModel/UnitConverterViewModel.h

@@ -17,7 +17,8 @@ namespace CalculatorApp
     {
         [Windows::UI::Xaml::Data::Bindable] public ref class Category sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
-            internal : Category(const UnitConversionManager::Category& category) : m_original(category)
+            internal : Category(const UnitConversionManager::Category& category)
+                : m_original(category)
             {
             }
 
@@ -46,7 +47,8 @@ namespace CalculatorApp
 
         [Windows::UI::Xaml::Data::Bindable] public ref class Unit sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
-            internal : Unit(const UnitConversionManager::Unit& unit) : m_original(unit)
+            internal : Unit(const UnitConversionManager::Unit& unit)
+                : m_original(unit)
             {
             }
 
@@ -80,7 +82,9 @@ namespace CalculatorApp
 
         [Windows::UI::Xaml::Data::Bindable] public ref class SupplementaryResult sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
-            internal : SupplementaryResult(Platform::String ^ value, Unit ^ unit) : m_Value(value), m_Unit(unit)
+            internal : SupplementaryResult(Platform::String ^ value, Unit ^ unit)
+                : m_Value(value)
+                , m_Unit(unit)
             {
             }
 
@@ -110,7 +114,8 @@ namespace CalculatorApp
             TActivatable m_activatable;
 
         public:
-            Activatable(TActivatable activatable) : m_activatable(activatable)
+            Activatable(TActivatable activatable)
+                : m_activatable(activatable)
             {
             }
 
@@ -207,8 +212,11 @@ namespace CalculatorApp
             Platform::String
                 ^ GetLocalizedAutomationName(_In_ Platform::String ^ displayvalue, _In_ Platform::String ^ unitname, _In_ Platform::String ^ format);
             Platform::String
-                ^ GetLocalizedConversionResultStringFormat(_In_ Platform::String ^ fromValue, _In_ Platform::String ^ fromUnit, _In_ Platform::String ^ toValue,
-                                                           _In_ Platform::String ^ toUnit);
+                ^ GetLocalizedConversionResultStringFormat(
+                    _In_ Platform::String ^ fromValue,
+                    _In_ Platform::String ^ fromUnit,
+                    _In_ Platform::String ^ toValue,
+                    _In_ Platform::String ^ toUnit);
             void UpdateValue1AutomationName();
             void UpdateValue2AutomationName();
             Platform::String ^ Serialize();
@@ -330,7 +338,8 @@ namespace CalculatorApp
         class UnitConverterVMCallback : public UnitConversionManager::IUnitConverterVMCallback
         {
         public:
-            UnitConverterVMCallback(UnitConverterViewModel ^ viewModel) : m_viewModel(viewModel)
+            UnitConverterVMCallback(UnitConverterViewModel ^ viewModel)
+                : m_viewModel(viewModel)
             {
             }
 
@@ -356,7 +365,8 @@ namespace CalculatorApp
         class ViewModelCurrencyCallback : public UnitConversionManager::IViewModelCurrencyCallback
         {
         public:
-            ViewModelCurrencyCallback(UnitConverterViewModel ^ viewModel) : m_viewModel(viewModel)
+            ViewModelCurrencyCallback(UnitConverterViewModel ^ viewModel)
+                : m_viewModel(viewModel)
             {
             }