Merge pull request #6 from microsoft/master

Merge with master

.clang-format

@@ -1,11 +1,11 @@
 AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
+AlignAfterOpenBracket: AlwaysBreak
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignEscapedNewlines: Right
 AlignOperands: true
 AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: None
@@ -15,8 +15,8 @@ AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: true
-BinPackArguments: true
+BinPackArguments: false
-BinPackParameters: true
+BinPackParameters: false
 BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeBraces: Allman
 BreakBeforeInheritanceComma: false
@@ -28,7 +28,7 @@ BreakStringLiterals: true
 ColumnLimit: 160
 CommentPragmas: '^ IWYU pragma:'
 CompactNamespaces: true
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: false

.github/ISSUE_TEMPLATE/bug_report.md

@@ -34,9 +34,9 @@ Steps to reproduce the behavior:
  - OS Build:
  - Architecture:
  - Application Version:
- - Region: 
+ - Region:
- - Dev Version Installed: 
+ - Dev Version Installed:
- 
+
 <!--
 Run the following commands in Powershell and copy/paste the output.
 " - OS Build: $([Environment]::OSVersion.Version)"
@@ -48,3 +48,13 @@ Run the following commands in Powershell and copy/paste the output.
 
 **Additional context**
 <!-- Add any other context about the problem here. -->
+
+**Requested Assignment**
+<!--
+Some people just want to report a bug and let someone else fix it.
+Other people want to not only submit the bug report, but fix it as well.
+Both scenarios are completely ok. We just want to know which one it is.
+Please indicate which bucket you fall into by keeping one and removing the other.
+-->
+If possible, I would like to fix this.
+I'm just reporting this problem.  I don't want to fix it.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -13,7 +13,7 @@ See https://github.com/Microsoft/calculator/blob/master/docs/NewFeatureProcess.m
 
 **Problem Statement**
 <!--
-What problem are we trying to solve? Who’s the target audience? Is there a customer need or pain point we need to remedy? Is there a business goal or metric we are trying to improve? Do we have a hypothesis we want to prove or disprove? 
+What problem are we trying to solve? Who’s the target audience? Is there a customer need or pain point we need to remedy? Is there a business goal or metric we are trying to improve? Do we have a hypothesis we want to prove or disprove?
 -->
 
 **Evidence or User Insights**
@@ -41,3 +41,14 @@ Things we are explicitly not doing or supporting or that are out of scope, inclu
 <!--
 Show as much of the experience as needed to explain the idea. This can be as simple as a napkin drawing but can also be a code prototype, or a design comp. Keep it simple at this stage, as it can be refined later during the pre-production stage.
 -->
+
+**Requested Assignment**
+<!--
+Some people just want to suggest a feature and let someone else implement it.
+Other people want to not only suggest a feature, but implement it as well.
+Both scenarios are completely ok. We just want to know which one it is.
+We are likely to prioritize the review of feature requests if they already have someone who can implement them.
+Please indicate which bucket you fall into by keeping one and removing the other.
+-->
+If possible, I would like to implement this.
+I'm just suggesting this idea.  I don't want to implement it.

Tools/Scripts/clang-format/clang-format-all.ps1

@@ -0,0 +1,91 @@
+<#
+    .DESCRIPTION
+        Helper script to format all header and source files in the repository.
+
+        By default, the script will recursively search under the repo root for
+        files to format.  Users can give explicit parameters indicating how the
+        search should include and exclude filetypes.
+
+        If users don't want the search functionality, they can instead provide
+        an explicit list of files to format.
+
+    .PARAMETER RepoRoot
+        Full path to the root of the repository which is the target of the search.
+        Will default to the root of the current working directory.
+
+    .PARAMETER Include
+        Array of filetype extensions to target for formatting.
+        By default, targets standard extensions for header and source files.
+        Follows the same rules as the -Include parameter for Get-ChildItem.
+
+    .PARAMETER Exclude
+        Array of filetype extensions to exclude from formatting.
+        By default, excludes generated XAML files.
+        Follows the same rules as the -Exclude paramter for Get-ChildItem.
+
+    .PARAMETER Files
+        Array of files to format. The script will exit if one of the provided
+        filepaths does not exist.
+
+    .EXAMPLE
+        .\clang-format-all.ps1
+
+        Formats all header and source files under the repository root.
+
+    .EXAMPLE
+        .\clang-format-all.ps1 -RepoRoot 'S:\repos\calculator' -Include '*.h', '*.cpp' -Exclude '*.g.*'
+
+        Formats all *.h and *.cpp files under 'S:\repos\calculator', excluding files with an extension
+        like *.g.*
+
+    .EXAMPLE
+        .\clang-format-all.ps1 -File 'S:\repos\calculator\src\CalcViewModel\UnitConverterViewModel.h', 'S:\repos\calculator\src\CalcViewModel\MemoryItemViewModel.cpp'
+
+        Formats the specified files.
+#>
+[CmdletBinding( DefaultParameterSetName = 'Search' )]
+param(
+    [Parameter( ParameterSetName = 'Search' )]
+    [ValidateScript({ Test-Path -PathType Container -Path $_ })]
+    [string] $RepoRoot = "$( git rev-parse --show-toplevel )",
+
+    [Parameter( ParameterSetName = 'Search' )]
+    [string[]] $Include = ( '*.h', '*.hh', '*.hpp', '*.c', '*.cc', '*.cpp' ),
+
+    [Parameter( ParameterSetName = 'Search' )]
+    [string[]] $Exclude = '*.g.*',
+
+    [Parameter(
+        ParameterSetName = 'Explicit',
+        Mandatory)]
+    [ValidateScript({
+        $_ | Where-Object { -not (Test-Path -PathType Leaf -Path $_) } |
+             ForEach-Object { throw "Could not find file: [$_]" }
+
+        return $true
+    })]
+    [string[]] $Files
+)
+
+if ($PSCmdlet.ParameterSetName -eq 'Explicit')
+{
+    # Use the file paths we were given.
+    $targetFiles = @($Files)
+}
+else
+{
+    # Gather the files to be formatted.
+    $targetFiles = @(
+        Get-ChildItem -Recurse -Path $RepoRoot -Include $Include -Exclude $Exclude |
+            Select-Object -ExpandProperty FullName
+    )
+}
+
+# Format the files.
+$formatParams = @(
+    '-i'          # In-place
+    '-style=file' # Search for a .clang-format file in the parent directory of the source file.
+    '-verbose'
+)
+
+clang-format $formatParams $targetFiles

build/pipelines/azure-pipelines.release.yaml

@@ -9,8 +9,8 @@ pr: none
 
 variables:
   versionMajor: 10
-  versionMinor: 1904
+  versionMinor: 1905
-  versionBuild: $[counter('10.1904.*', 0)]
+  versionBuild: $[counter('10.1905.*', 0)]
   versionPatch: 0
 
 name: '$(versionMajor).$(versionMinor).$(versionBuild).$(versionPatch)'

docs/ApplicationArchitecture.md

@@ -201,4 +201,5 @@ instead of regular floating point arithmetic). The interface to this layer is de
 [CalcManager folder]:                 ../src/CalcManager
 [CalculatorManager.h]:                ../src/CalcManager/CalculatorManager.h
 [CalcEngine.h]:                       ../src/CalcManager/Header Files/CalcEngine.h
+[Infinite Precision]:                 https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic
 [ratpak.h]:                           ../src/CalcManager/Ratpack/ratpak.h

docs/NewFeatureProcess.md

@@ -29,26 +29,26 @@ idea until it is ready for review.
 
 We review pitches regularly, and will approve or close issues based on whether they broadly align with the 
 [Calculator roadmap](https://github.com/Microsoft/calculator/blob/master/docs/Roadmap.md). Approved pitches are moved 
-into [pre-production](https://github.com/Microsoft/calculator/projects/1) on the feature tracking board.
+into [planning](https://github.com/Microsoft/calculator/projects/1) on the feature tracking board.
 
-## Step 2: Pre-production
+## Step 2: Planning
 For most features, the output of this phase is a specification which describes how the feature will work, supported by 
 design renderings and code prototypes as needed. The original issue will continue to track the overall progress of the 
 feature, but we will create and iterate on spec documentation in the 
 [Calculator Spec repo](https://github.com/Microsoft/calculator-specs). Sometimes we'll learn new things about a feature 
-proposal during pre-production, and we'll edit or close the original pitch.
+proposal during planning, and we'll edit or close the original pitch.
 
-We welcome community participation throughout pre-production. The best ideas often come from trying many ideas during 
+We welcome community participation throughout planning. The best ideas often come from trying many ideas during 
-the pre-production phase. To enable rapid
+the planning phase. To enable rapid
 experimentation, we encourage developing and sharing rough ideas—maybe even with pencil and
 paper—before making designs pixel-perfect or making code robust and maintainable.
 
 After the [spec review](https://github.com/Microsoft/calculator-specs#spec-review) is completed, we will move the issue 
-into [production](https://github.com/Microsoft/calculator/projects/1) on the feature tracking board. In _some_ cases, 
+into [implementation](https://github.com/Microsoft/calculator/projects/1) on the feature tracking board. In _some_ cases, 
 all of the details of an idea can be captured concisely in original feature pitch. When that happens, we may move ideas
-directly into production.
+directly into implementation.
 
-## Step 3: Production
+## Step 3: Implementation
 A feature can be implemented by the original submitter, a Microsoft team member, or by other
 community members. Code contributions and testing help are greatly appreciated. Please let everyone know if you're 
 actively working on a feature to help avoid duplicated efforts from others.

src/CalcManager/CEngine/History.cpp

@@ -40,7 +40,10 @@ void CHistoryCollector::ReinitHistory()
 // Constructor
 // Can throw Out of memory error
 CHistoryCollector::CHistoryCollector(ICalcDisplay* pCalcDisplay, std::shared_ptr<IHistoryDisplay> pHistoryDisplay, wchar_t decimalSymbol)
-    : m_pHistoryDisplay(pHistoryDisplay), m_pCalcDisplay(pCalcDisplay), m_iCurLineHistStart(-1), m_decimalSymbol(decimalSymbol)
+    : m_pHistoryDisplay(pHistoryDisplay)
+    , m_pCalcDisplay(pCalcDisplay)
+    , m_iCurLineHistStart(-1)
+    , m_decimalSymbol(decimalSymbol)
 {
     ReinitHistory();
 }
@@ -300,8 +303,8 @@ void CHistoryCollector::CompleteHistoryLine(wstring_view numStr)
 {
     if (nullptr != m_pCalcDisplay)
     {
-        m_pCalcDisplay->SetExpressionDisplay(std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(),
+        m_pCalcDisplay->SetExpressionDisplay(
-                                             std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
+            std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
     }
 
     if (nullptr != m_pHistoryDisplay)
@@ -322,8 +325,8 @@ void CHistoryCollector::ClearHistoryLine(wstring_view errStr)
     {
         if (nullptr != m_pCalcDisplay)
         {
-            m_pCalcDisplay->SetExpressionDisplay(std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(),
+            m_pCalcDisplay->SetExpressionDisplay(
-                                                 std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
+                std::make_shared<CalculatorVector<std::pair<std::wstring, int>>>(), std::make_shared<CalculatorVector<std::shared_ptr<IExpressionCommand>>>());
         }
         m_iCurLineHistStart = -1; // It will get recomputed at the first Opnd
         ReinitHistory();

src/CalcManager/CEngine/Number.cpp

@@ -7,15 +7,22 @@ using namespace std;
 
 namespace CalcEngine
 {
-    Number::Number() noexcept : Number(1, 0, { 0 })
+    Number::Number() noexcept
+        : Number(1, 0, { 0 })
     {
     }
 
-    Number::Number(int32_t sign, int32_t exp, vector<uint32_t> const& mantissa) noexcept : m_sign{ sign }, m_exp{ exp }, m_mantissa{ mantissa }
+    Number::Number(int32_t sign, int32_t exp, vector<uint32_t> const& mantissa) noexcept
+        : m_sign{ sign }
+        , m_exp{ exp }
+        , m_mantissa{ mantissa }
     {
     }
 
-    Number::Number(PNUMBER p) noexcept : m_sign{ p->sign }, m_exp{ p->exp }, m_mantissa{}
+    Number::Number(PNUMBER p) noexcept
+        : m_sign{ p->sign }
+        , m_exp{ p->exp }
+        , m_mantissa{}
     {
         m_mantissa.reserve(p->cdigit);
         copy(p->mant, p->mant + p->cdigit, back_inserter(m_mantissa));

src/CalcManager/CEngine/Rational.cpp

@@ -7,7 +7,9 @@ using namespace std;
 
 namespace CalcEngine
 {
-    Rational::Rational() noexcept : m_p{}, m_q{ 1, 0, { 1 } }
+    Rational::Rational() noexcept
+        : m_p{}
+        , m_q{ 1, 0, { 1 } }
     {
     }
 
@@ -23,7 +25,9 @@ namespace CalcEngine
         m_q = Number(1, qExp, { 1 });
     }
 
-    Rational::Rational(Number const& p, Number const& q) noexcept : m_p{ p }, m_q{ q }
+    Rational::Rational(Number const& p, Number const& q) noexcept
+        : m_p{ p }
+        , m_q{ q }
     {
     }
 
@@ -58,7 +62,9 @@ namespace CalcEngine
         m_q = Number{ temp.Q() };
     }
 
-    Rational::Rational(PRAT prat) noexcept : m_p{ Number{ prat->pp } }, m_q{ Number{ prat->pq } }
+    Rational::Rational(PRAT prat) noexcept
+        : m_p{ Number{ prat->pp } }
+        , m_q{ Number{ prat->pq } }
     {
     }
 

src/CalcManager/CEngine/calc.cpp

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

src/CalcManager/CEngine/scicomm.cpp

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

src/CalcManager/CalculatorHistory.cpp

@@ -7,12 +7,15 @@
 using namespace std;
 using namespace CalculationManager;
 
-CalculatorHistory::CalculatorHistory(size_t maxSize) : m_maxHistorySize(maxSize)
+CalculatorHistory::CalculatorHistory(size_t maxSize)
+    : m_maxHistorySize(maxSize)
 {
 }
 
-unsigned int CalculatorHistory::AddToHistory(_In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
+unsigned int CalculatorHistory::AddToHistory(
-                                             _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands, _In_ wstring_view result)
+    _In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
+    _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands,
+    _In_ wstring_view result)
 {
     unsigned int addedIndex;
     wstring generatedExpression;

src/CalcManager/CalculatorHistory.h

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

src/CalcManager/CalculatorManager.cpp

@@ -85,8 +85,9 @@ namespace CalculationManager
     /// Used to set the expression display value on ViewModel
     /// </summary>
     /// <param name="expressionString">wstring representing expression to be displayed</param>
-    void CalculatorManager::SetExpressionDisplay(_Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
+    void CalculatorManager::SetExpressionDisplay(
-                                                 _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
+        _Inout_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
+        _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
     {
         if (!m_inHistoryItemLoadMode)
         {
@@ -243,8 +244,6 @@ namespace CalculationManager
             {
                 m_savedCommands.push_back(MapCommandForSerialize(command));
             }
-            this->SerializePrimaryDisplay();
-            this->SerializeMemory();
             m_savedDegreeMode = m_currentDegreeMode;
             return;
         }
@@ -329,47 +328,6 @@ namespace CalculationManager
         return commandToLoad;
     }
 
-    /// <summary>
-    /// Return saved degree mode which is saved when last time the expression was cleared.
-    /// </summary>
-    Command CalculatorManager::SerializeSavedDegreeMode()
-    {
-        return m_savedDegreeMode;
-    }
-
-    void CalculatorManager::SerializePrimaryDisplay()
-    {
-        m_savedPrimaryValue.clear();
-        m_currentCalculatorEngine->ProcessCommand(IDC_STORE);
-        auto memoryObject = m_currentCalculatorEngine->PersistedMemObject();
-        if (memoryObject != nullptr)
-        {
-            m_savedPrimaryValue = SerializeRational(*memoryObject);
-        }
-    }
-
-    /// <summary>
-    /// Return serialized primary display that is saved when the expression line was cleared.
-    /// </summary>
-    vector<long> CalculatorManager::GetSerializedPrimaryDisplay()
-    {
-        return m_savedPrimaryValue;
-    }
-
-    /// <summary>
-    /// DeSerialize the primary display from vector of long
-    /// </summary>
-    /// <param name = "serializedPrimaryDisplay">Serialized Rational of primary display</param>
-    void CalculatorManager::DeSerializePrimaryDisplay(const vector<long>& serializedPrimaryDisplay)
-    {
-        if (serializedPrimaryDisplay.empty())
-        {
-            return;
-        }
-        m_persistedPrimaryValue = DeSerializeRational(serializedPrimaryDisplay.begin());
-        this->LoadPersistedPrimaryValue();
-    }
-
     /// <summary>
     /// Load the persisted value that is saved in memory of CalcEngine
     /// </summary>
@@ -379,112 +337,6 @@ namespace CalculationManager
         m_currentCalculatorEngine->ProcessCommand(IDC_RECALL);
     }
 
-    /// <summary>
-    /// Serialize the Memory to vector of long
-    /// </summary>
-    /// <return type = "std::vector<long>">Serialized Rational of memory</return>
-    void CalculatorManager::SerializeMemory()
-    {
-        m_serializedMemory.clear();
-
-        for (auto const& memoryItem : m_memorizedNumbers)
-        {
-            auto serialMem = SerializeRational(memoryItem);
-            m_serializedMemory.insert(m_serializedMemory.end(), serialMem.begin(), serialMem.end());
-        }
-    }
-
-    vector<long> CalculatorManager::GetSerializedMemory()
-    {
-        return m_serializedMemory;
-    }
-
-    /// <summary>
-    /// DeSerialize the Memory from vector of long
-    /// </summary>
-    /// <param name = "serializedMemory">Serialized Rational of memory</param>
-    void CalculatorManager::DeSerializeMemory(const vector<long>& serializedMemory)
-    {
-        vector<long>::const_iterator itr = serializedMemory.begin();
-        while (itr != serializedMemory.end())
-        {
-            Rational memoryItem = DeSerializeRational(itr);
-            auto lengthMemoryItem = (2 * SERIALIZED_NUMBER_MINSIZE) + memoryItem.P().Mantissa().size() + memoryItem.Q().Mantissa().size();
-            m_memorizedNumbers.push_back(memoryItem);
-            itr += lengthMemoryItem;
-        }
-        this->SetMemorizedNumbersString();
-    }
-
-    /// <summary>
-    /// Return the commands saved since the expression has been cleared.
-    /// </summary>
-    vector<unsigned char> CalculatorManager::SerializeCommands()
-    {
-        return m_savedCommands;
-    }
-
-    /// <summary>
-    /// Replay the serialized commands
-    /// </summary>
-    /// <param name = "serializedData">Serialized commands</param>
-    void CalculatorManager::DeSerializeCommands(_In_ const vector<unsigned char>& serializedData)
-    {
-        m_savedCommands.clear();
-
-        for (auto commandItr = serializedData.begin(); commandItr != serializedData.end(); ++commandItr)
-        {
-            if (*commandItr >= MEMORY_COMMAND_TO_UNSIGNED_CHAR(MemoryCommand::MemorizeNumber)
-                && *commandItr <= MEMORY_COMMAND_TO_UNSIGNED_CHAR(MemoryCommand::MemorizedNumberClearAll))
-            {
-                // MemoryCommands(which have values above 255) are pushed on m_savedCommands upon casting to unsigned char.
-                // SerializeCommands uses m_savedCommands, which is then used in DeSerializeCommands.
-                // Hence, a simple cast to MemoryCommand is not sufficient.
-                MemoryCommand memoryCommand = static_cast<MemoryCommand>(*commandItr + UCHAR_MAX + 1);
-                unsigned int indexOfMemory = 0;
-                switch (memoryCommand)
-                {
-                case MemoryCommand::MemorizeNumber:
-                    this->MemorizeNumber();
-                    break;
-                case MemoryCommand::MemorizedNumberLoad:
-                    if (commandItr + 1 == serializedData.end())
-                    {
-                        throw out_of_range("Expecting index of memory, data ended prematurely");
-                    }
-                    indexOfMemory = *(++commandItr);
-                    this->MemorizedNumberLoad(indexOfMemory);
-                    break;
-                case MemoryCommand::MemorizedNumberAdd:
-                    if (commandItr + 1 == serializedData.end())
-                    {
-                        throw out_of_range("Expecting index of memory, data ended prematurely");
-                    }
-                    indexOfMemory = *(++commandItr);
-                    this->MemorizedNumberAdd(indexOfMemory);
-                    break;
-                case MemoryCommand::MemorizedNumberSubtract:
-                    if (commandItr + 1 == serializedData.end())
-                    {
-                        throw out_of_range("Expecting index of memory, data ended prematurely");
-                    }
-                    indexOfMemory = *(++commandItr);
-                    this->MemorizedNumberSubtract(indexOfMemory);
-                    break;
-                case MemoryCommand::MemorizedNumberClearAll:
-                    this->MemorizedNumberClearAll();
-                    break;
-                default:
-                    break;
-                }
-            }
-            else
-            {
-                this->SendCommand(static_cast<Command>(MapCommandForDeSerialize(*commandItr)));
-            }
-        }
-    }
-
     /// <summary>
     /// Memorize the current displayed value
     /// Notify the client with new the new memorize value vector

src/CalcManager/CalculatorManager.h

@@ -63,7 +63,6 @@ namespace CalculationManager
         // For persistence
         std::vector<unsigned char> m_savedCommands;
         std::vector<long> m_savedPrimaryValue;
-        std::vector<long> m_serializedMemory;
         std::vector<long> m_currentSerializedMemory;
         Command m_currentDegreeMode;
         Command m_savedDegreeMode;
@@ -91,8 +90,9 @@ namespace CalculationManager
         // ICalcDisplay
         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,
+        void SetExpressionDisplay(
-                                  _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override;
+            _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;
@@ -110,15 +110,6 @@ namespace CalculationManager
         void SetScientificMode();
         void SetProgrammerMode();
         void SendCommand(_In_ Command command);
-        std::vector<unsigned char> SerializeCommands();
-        void DeSerializeCommands(_In_ const std::vector<unsigned char>& serializedData);
-        void SerializeMemory();
-        std::vector<long> GetSerializedMemory();
-        void DeSerializeMemory(const std::vector<long>& serializedMemory);
-        void SerializePrimaryDisplay();
-        std::vector<long> GetSerializedPrimaryDisplay();
-        void DeSerializePrimaryDisplay(const std::vector<long>& serializedPrimaryDisplay);
-        Command SerializeSavedDegreeMode();
 
         void MemorizeNumber();
         void MemorizedNumberLoad(_In_ unsigned int);

src/CalcManager/ExpressionCommand.cpp

@@ -13,7 +13,8 @@ constexpr wchar_t chNegate = L'-';
 constexpr wchar_t chExp = L'e';
 constexpr wchar_t chPlus = L'+';
 
-CParentheses::CParentheses(_In_ int command) : m_command(command)
+CParentheses::CParentheses(_In_ int command)
+    : m_command(command)
 {
 }
 
@@ -73,7 +74,8 @@ void CUnaryCommand::Accept(_In_ ISerializeCommandVisitor& commandVisitor)
     commandVisitor.Visit(*this);
 }
 
-CBinaryCommand::CBinaryCommand(int command) : m_command(command)
+CBinaryCommand::CBinaryCommand(int command)
+    : m_command(command)
 {
 }
 
@@ -98,7 +100,12 @@ void CBinaryCommand::Accept(_In_ ISerializeCommandVisitor& commandVisitor)
 }
 
 COpndCommand::COpndCommand(shared_ptr<CalculatorVector<int>> const& commands, bool fNegative, bool fDecimal, bool fSciFmt)
-    : m_commands(commands), m_fNegative(fNegative), m_fSciFmt(fSciFmt), m_fDecimal(fDecimal), m_fInitialized(false), m_value{}
+    : m_commands(commands)
+    , m_fNegative(fNegative)
+    , m_fSciFmt(fSciFmt)
+    , m_fDecimal(fDecimal)
+    , m_fInitialized(false)
+    , m_value{}
 {
 }
 

src/CalcManager/Header Files/CalcEngine.h

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

src/CalcManager/Header Files/CalcInput.h

@@ -13,7 +13,9 @@ namespace CalcEngine
     class CalcNumSec
     {
     public:
-        CalcNumSec() : value(), m_isNegative(false)
+        CalcNumSec()
+            : value()
+            , m_isNegative(false)
         {
         }
 
@@ -41,11 +43,18 @@ namespace CalcEngine
     class CalcInput
     {
     public:
-        CalcInput() : CalcInput(L'.')
+        CalcInput()
+            : CalcInput(L'.')
         {
         }
 
-        CalcInput(wchar_t decSymbol) : m_hasExponent(false), m_hasDecimal(false), m_decPtIndex(0), m_decSymbol(decSymbol), m_base(), m_exponent()
+        CalcInput(wchar_t decSymbol)
+            : m_hasExponent(false)
+            , m_hasDecimal(false)
+            , m_decPtIndex(0)
+            , m_decSymbol(decSymbol)
+            , m_base()
+            , m_exponent()
         {
         }
 

src/CalcManager/Header Files/ICalcDisplay.h

@@ -12,8 +12,9 @@ class ICalcDisplay
 public:
     virtual void SetPrimaryDisplay(const std::wstring& pszText, bool isError) = 0;
     virtual void SetIsInError(bool isInError) = 0;
-    virtual void SetExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
+    virtual void SetExpressionDisplay(
-                                      _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) = 0;
+        _Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
+        _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) = 0;
     virtual void SetParenthesisNumber(_In_ unsigned int count) = 0;
     virtual void OnNoRightParenAdded() = 0;
     virtual void MaxDigitsReached() = 0; // not an error but still need to inform UI layer.

src/CalcManager/Header Files/IHistoryDisplay.h

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

src/CalcManager/Ratpack/ratpak.h

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

src/CalcManager/UnitConverter.cpp

@@ -11,8 +11,6 @@ using namespace concurrency;
 using namespace std;
 using namespace UnitConversionManager;
 
-static constexpr uint32_t EXPECTEDSERIALIZEDTOKENCOUNT = 7;
-static constexpr uint32_t EXPECTEDSERIALIZEDCONVERSIONDATATOKENCOUNT = 3;
 static constexpr uint32_t EXPECTEDSERIALIZEDCATEGORYTOKENCOUNT = 3;
 static constexpr uint32_t EXPECTEDSERIALIZEDUNITTOKENCOUNT = 6;
 static constexpr uint32_t EXPECTEDSTATEDATATOKENCOUNT = 5;
@@ -34,7 +32,8 @@ unordered_map<wstring, wchar_t> unquoteConversions;
 /// Constructor, sets up all the variables and requires a configLoader
 /// </summary>
 /// <param name="dataLoader">An instance of the IConverterDataLoader interface which we use to read in category/unit names and conversion data</param>
-UnitConverter::UnitConverter(_In_ const shared_ptr<IConverterDataLoader>& dataLoader) : UnitConverter::UnitConverter(dataLoader, nullptr)
+UnitConverter::UnitConverter(_In_ const shared_ptr<IConverterDataLoader>& dataLoader)
+    : UnitConverter::UnitConverter(dataLoader, nullptr)
 {
 }
 
@@ -216,18 +215,6 @@ vector<wstring> UnitConverter::StringToVector(const wstring& w, const wchar_t* d
     }
     return serializedTokens;
 }
-
-Category UnitConverter::StringToCategory(const wstring& w)
-{
-    vector<wstring> tokenList = StringToVector(w, L";");
-    assert(tokenList.size() == EXPECTEDSERIALIZEDCATEGORYTOKENCOUNT);
-    Category serializedCategory;
-    serializedCategory.id = _wtoi(Unquote(tokenList[0]).c_str());
-    serializedCategory.supportsNegative = (tokenList[1].compare(L"1") == 0);
-    serializedCategory.name = Unquote(tokenList[2]);
-    return serializedCategory;
-}
-
 wstring UnitConverter::UnitToString(const Unit& u, const wchar_t* delimiter)
 {
     wstringstream out(wstringstream::out);
@@ -252,150 +239,15 @@ Unit UnitConverter::StringToUnit(const wstring& w)
     return serializedUnit;
 }
 
-ConversionData UnitConverter::StringToConversionData(const wstring& w)
+Category UnitConverter::StringToCategory(const wstring& w)
 {
     vector<wstring> tokenList = StringToVector(w, L";");
-    assert(tokenList.size() == EXPECTEDSERIALIZEDCONVERSIONDATATOKENCOUNT);
+    assert(tokenList.size() == EXPECTEDSERIALIZEDCATEGORYTOKENCOUNT);
-    ConversionData serializedConversionData;
+    Category serializedCategory;
-    serializedConversionData.ratio = stod(Unquote(tokenList[0]).c_str());
+    serializedCategory.id = _wtoi(Unquote(tokenList[0]).c_str());
-    serializedConversionData.offset = stod(Unquote(tokenList[1]).c_str());
+    serializedCategory.supportsNegative = (tokenList[1].compare(L"1") == 0);
-    serializedConversionData.offsetFirst = (tokenList[2].compare(L"1") == 0);
+    serializedCategory.name = Unquote(tokenList[2]);
-    return serializedConversionData;
+    return serializedCategory;
-}
-
-wstring UnitConverter::ConversionDataToString(ConversionData d, const wchar_t* delimiter)
-{
-    wstringstream out(wstringstream::out);
-    out.precision(32);
-    out << fixed << d.ratio;
-    wstring ratio = out.str();
-    out.str(L"");
-    out << fixed << d.offset;
-    wstring offset = out.str();
-    out.str(L"");
-    TrimString(ratio);
-    TrimString(offset);
-    out << Quote(ratio) << delimiter << Quote(offset) << delimiter << std::to_wstring(d.offsetFirst) << delimiter;
-    return out.str();
-}
-
-/// <summary>
-/// Serializes the data in the converter and returns it as a string
-/// </summary>
-wstring UnitConverter::Serialize()
-{
-    if (!CheckLoad())
-    {
-        return wstring();
-    }
-
-    wstringstream out(wstringstream::out);
-    const wchar_t* delimiter = L";";
-
-    out << UnitToString(m_fromType, delimiter) << "|";
-    out << UnitToString(m_toType, delimiter) << "|";
-    out << CategoryToString(m_currentCategory, delimiter) << "|";
-    out << std::to_wstring(m_currentHasDecimal) << delimiter << std::to_wstring(m_returnHasDecimal) << delimiter << std::to_wstring(m_switchedActive)
-        << delimiter;
-    out << m_currentDisplay << delimiter << m_returnDisplay << delimiter << "|";
-    wstringstream categoryString(wstringstream::out);
-    wstringstream categoryToUnitString(wstringstream::out);
-    wstringstream unitToUnitToDoubleString(wstringstream::out);
-    for (const Category& c : m_categories)
-    {
-        categoryString << CategoryToString(c, delimiter) << ",";
-    }
-
-    for (const auto& cur : m_categoryToUnits)
-    {
-        categoryToUnitString << CategoryToString(cur.first, delimiter) << "[";
-        for (const Unit& u : cur.second)
-        {
-            categoryToUnitString << UnitToString(u, delimiter) << ",";
-        }
-        categoryToUnitString << "["
-                             << "]";
-    }
-
-    for (const auto& cur : m_ratioMap)
-    {
-        unitToUnitToDoubleString << UnitToString(cur.first, delimiter) << "[";
-        for (const auto& curConversion : cur.second)
-        {
-            unitToUnitToDoubleString << UnitToString(curConversion.first, delimiter) << ":";
-            unitToUnitToDoubleString << ConversionDataToString(curConversion.second, delimiter) << ":,";
-        }
-        unitToUnitToDoubleString << "["
-                                 << "]";
-    }
-
-    out << categoryString.str() << "|";
-    out << categoryToUnitString.str() << "|";
-    out << unitToUnitToDoubleString.str() << "|";
-    wstring test = out.str();
-    return test;
-}
-
-/// <summary>
-/// De-Serializes the data in the converter from a string
-/// </summary>
-/// <param name="serializedData">wstring holding the serialized data. If it does not have expected number of parameters, we will ignore it</param>
-void UnitConverter::DeSerialize(const wstring& serializedData)
-{
-    ClearValues();
-    ResetCategoriesAndRatios();
-
-    if (serializedData.empty())
-    {
-        return;
-    }
-
-    vector<wstring> outerTokens = StringToVector(serializedData, L"|");
-    assert(outerTokens.size() == EXPECTEDSERIALIZEDTOKENCOUNT);
-    m_fromType = StringToUnit(outerTokens[0]);
-    m_toType = StringToUnit(outerTokens[1]);
-    m_currentCategory = StringToCategory(outerTokens[2]);
-    vector<wstring> stateDataTokens = StringToVector(outerTokens[3], L";");
-    assert(stateDataTokens.size() == EXPECTEDSTATEDATATOKENCOUNT);
-    m_currentHasDecimal = (stateDataTokens[0].compare(L"1") == 0);
-    m_returnHasDecimal = (stateDataTokens[1].compare(L"1") == 0);
-    m_switchedActive = (stateDataTokens[2].compare(L"1") == 0);
-    m_currentDisplay = stateDataTokens[3];
-    m_returnDisplay = stateDataTokens[4];
-    vector<wstring> categoryListTokens = StringToVector(outerTokens[4], L",");
-    for (wstring token : categoryListTokens)
-    {
-        m_categories.push_back(StringToCategory(token));
-    }
-    vector<wstring> unitVectorTokens = StringToVector(outerTokens[5], L"]");
-    for (wstring unitVector : unitVectorTokens)
-    {
-        vector<wstring> mapcomponents = StringToVector(unitVector, L"[");
-        assert(mapcomponents.size() == EXPECTEDMAPCOMPONENTTOKENCOUNT);
-        Category key = StringToCategory(mapcomponents[0]);
-        vector<wstring> units = StringToVector(mapcomponents[1], L",");
-        for (wstring unit : units)
-        {
-            m_categoryToUnits[key].push_back(StringToUnit(unit));
-        }
-    }
-    vector<wstring> ratioMapTokens = StringToVector(outerTokens[6], L"]");
-    for (wstring token : ratioMapTokens)
-    {
-        vector<wstring> ratioMapComponentTokens = StringToVector(token, L"[");
-        assert(ratioMapComponentTokens.size() == EXPECTEDMAPCOMPONENTTOKENCOUNT);
-        Unit key = StringToUnit(ratioMapComponentTokens[0]);
-        vector<wstring> ratioMapList = StringToVector(ratioMapComponentTokens[1], L",");
-        for (wstring subtoken : ratioMapList)
-        {
-            vector<wstring> ratioMapSubComponentTokens = StringToVector(subtoken, L":");
-            assert(ratioMapSubComponentTokens.size() == EXPECTEDMAPCOMPONENTTOKENCOUNT);
-            Unit subkey = StringToUnit(ratioMapSubComponentTokens[0]);
-            ConversionData conversion = StringToConversionData(ratioMapSubComponentTokens[1]);
-            m_ratioMap[key][subkey] = conversion;
-        }
-    }
-    UpdateViewModel();
 }
 
 /// <summary>

src/CalcManager/UnitConverter.h

@@ -29,9 +29,19 @@ namespace UnitConversionManager
         {
         }
 
-        Unit(int id, std::wstring currencyName, std::wstring countryName, std::wstring abbreviation, bool isRtlLanguage, bool isConversionSource,
+        Unit(
-             bool isConversionTarget)
+            int id,
-            : id(id), abbreviation(abbreviation), isConversionSource(isConversionSource), isConversionTarget(isConversionTarget), isWhimsical(false)
+            std::wstring currencyName,
+            std::wstring countryName,
+            std::wstring abbreviation,
+            bool isRtlLanguage,
+            bool isConversionSource,
+            bool isConversionTarget)
+            : id(id)
+            , abbreviation(abbreviation)
+            , isConversionSource(isConversionSource)
+            , isConversionTarget(isConversionTarget)
+            , isWhimsical(false)
         {
             std::wstring nameValue1 = isRtlLanguage ? currencyName : countryName;
             std::wstring nameValue2 = isRtlLanguage ? countryName : currencyName;
@@ -76,7 +86,10 @@ namespace UnitConversionManager
         {
         }
 
-        Category(int id, std::wstring name, bool supportsNegative) : id(id), name(name), supportsNegative(supportsNegative)
+        Category(int id, std::wstring name, bool supportsNegative)
+            : id(id)
+            , name(name)
+            , supportsNegative(supportsNegative)
         {
         }
 
@@ -125,7 +138,10 @@ namespace UnitConversionManager
         ConversionData()
         {
         }
-        ConversionData(double ratio, double offset, bool offsetFirst) : ratio(ratio), offset(offset), offsetFirst(offsetFirst)
+        ConversionData(double ratio, double offset, bool offsetFirst)
+            : ratio(ratio)
+            , offset(offset)
+            , offsetFirst(offsetFirst)
         {
         }
 
@@ -155,9 +171,10 @@ namespace UnitConversionManager
     };
 
     typedef std::tuple<std::vector<UnitConversionManager::Unit>, UnitConversionManager::Unit, UnitConversionManager::Unit> CategorySelectionInitializer;
-    typedef std::unordered_map<UnitConversionManager::Unit,
+    typedef std::unordered_map<
-                               std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>,
+        UnitConversionManager::Unit,
-                               UnitConversionManager::UnitHash>
+        std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>,
+        UnitConversionManager::UnitHash>
         UnitToUnitToConversionDataMap;
     typedef std::unordered_map<UnitConversionManager::Category, std::vector<UnitConversionManager::Unit>, UnitConversionManager::CategoryHash>
         CategoryToUnitVectorMap;
@@ -188,10 +205,10 @@ namespace UnitConversionManager
     {
     public:
         virtual void SetViewModelCallback(const std::shared_ptr<UnitConversionManager::IViewModelCurrencyCallback>& callback) = 0;
-        virtual std::pair<std::wstring, std::wstring> GetCurrencySymbols(_In_ const UnitConversionManager::Unit& unit1,
+        virtual std::pair<std::wstring, std::wstring>
-                                                                         _In_ const UnitConversionManager::Unit& unit2) = 0;
+        GetCurrencySymbols(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) = 0;
-        virtual std::pair<std::wstring, std::wstring> GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1,
+        virtual std::pair<std::wstring, std::wstring>
-                                                                               _In_ const UnitConversionManager::Unit& unit2) = 0;
+        GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) = 0;
         virtual std::wstring GetCurrencyTimestamp() = 0;
 
         virtual concurrency::task<bool> TryLoadDataFromCacheAsync() = 0;
@@ -220,8 +237,6 @@ namespace UnitConversionManager
         virtual Category GetCurrentCategory() = 0;
         virtual void SetCurrentUnitTypes(const Unit& fromType, const Unit& toType) = 0;
         virtual void SwitchActive(const std::wstring& newValue) = 0;
-        virtual std::wstring Serialize() = 0;
-        virtual void DeSerialize(const std::wstring& serializedData) = 0;
         virtual std::wstring SaveUserPreferences() = 0;
         virtual void RestoreUserPreferences(_In_ const std::wstring& userPreferences) = 0;
         virtual void SendCommand(Command command) = 0;
@@ -245,8 +260,6 @@ namespace UnitConversionManager
         Category GetCurrentCategory() override;
         void SetCurrentUnitTypes(const Unit& fromType, const Unit& toType) override;
         void SwitchActive(const std::wstring& newValue) override;
-        std::wstring Serialize() override;
-        void DeSerialize(const std::wstring& serializedData) override;
         std::wstring SaveUserPreferences() override;
         void RestoreUserPreferences(const std::wstring& userPreference) override;
         void SendCommand(Command command) override;
@@ -273,8 +286,6 @@ namespace UnitConversionManager
         std::wstring CategoryToString(const Category& c, const wchar_t* delimiter);
         std::wstring UnitToString(const Unit& u, const wchar_t* delimiter);
         Unit StringToUnit(const std::wstring& w);
-        ConversionData StringToConversionData(const std::wstring& w);
-        std::wstring ConversionDataToString(ConversionData d, const wchar_t* delimiter);
         void UpdateCurrencySymbols();
         void UpdateViewModel();
         bool AnyUnitIsEmpty();

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
+                virtual Windows::Foundation::Collections::IObservableVector<
-                                                                            ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
+                    Platform::Object ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
                 {
                     return ref new Platform::Collections::Vector<Platform::Object ^>();
                 }
@@ -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,
+                    this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, ref new Windows::UI::Core::DispatchedHandler([this]() {
-                                               ref new Windows::UI::Core::DispatchedHandler([this]() { m_currentChanged(this, nullptr); }));
+                                                   m_currentChanged(this, nullptr);
+                                               }));
                 }
                 return false;
             }
@@ -167,14 +169,14 @@ namespace CalculatorApp
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual unsigned int
+            virtual unsigned int GetMany(
-            GetMany(unsigned int /*startIndex*/,
+                unsigned int /*startIndex*/,
-                    Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
+                Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<Platform::Object
+            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<
-                                                                                                                                              ^>::GetView
+                Platform::Object ^>::GetView
             {
                 throw ref new Platform::NotImplementedException();
             }
@@ -263,8 +265,11 @@ namespace CalculatorApp
 
         private:
             virtual Platform::Object
-                ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
+                ^ Convert(
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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*/,
+                ^ ConvertBack(
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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,
+NarratorAnnouncement::NarratorAnnouncement(
-                                           AutomationNotificationProcessing processing)
+    String ^ announcement,
-    : m_announcement(announcement), m_activityId(activityId), m_kind(kind), m_processing(processing)
+    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,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement, CalculatorActivityIds::DisplayUpdated, AutomationNotificationKind::Other, AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetMaxDigitsReachedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MaxDigitsReached, AutomationNotificationKind::Other,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement, CalculatorActivityIds::MaxDigitsReached, AutomationNotificationKind::Other, AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryClearedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryCleared, AutomationNotificationKind::ItemRemoved,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement, CalculatorActivityIds::MemoryCleared, AutomationNotificationKind::ItemRemoved, AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemChangedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryItemChanged, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::MostRecent);
+        announcement, CalculatorActivityIds::MemoryItemChanged, AutomationNotificationKind::ActionCompleted, AutomationNotificationProcessing::MostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::MemoryItemAdded, AutomationNotificationKind::ItemAdded,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::MostRecent);
+        announcement, CalculatorActivityIds::MemoryItemAdded, AutomationNotificationKind::ItemAdded, AutomationNotificationProcessing::MostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetHistoryClearedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::HistoryCleared, AutomationNotificationKind::ItemRemoved,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::MostRecent);
+        announcement, CalculatorActivityIds::HistoryCleared, AutomationNotificationKind::ItemRemoved, AutomationNotificationProcessing::MostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetCategoryNameChangedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::CategoryNameChanged, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement,
+        CalculatorActivityIds::CategoryNameChanged,
+        AutomationNotificationKind::ActionCompleted,
+        AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetUpdateCurrencyRatesAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::UpdateCurrencyRates, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement,
+        CalculatorActivityIds::UpdateCurrencyRates,
+        AutomationNotificationKind::ActionCompleted,
+        AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetDisplayCopiedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::DisplayCopied, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement, CalculatorActivityIds::DisplayCopied, AutomationNotificationKind::ActionCompleted, AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetOpenParenthesisCountChangedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::OpenParenthesisCountChanged, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        announcement,
+        CalculatorActivityIds::OpenParenthesisCountChanged,
+        AutomationNotificationKind::ActionCompleted,
+        AutomationNotificationProcessing::ImportantMostRecent);
 }
 
 NarratorAnnouncement ^ CalculatorAnnouncement::GetNoRightParenthesisAddedAnnouncement(String ^ announcement)
 {
-    return ref new NarratorAnnouncement(announcement, CalculatorActivityIds::NoParenthesisAdded, AutomationNotificationKind::ActionCompleted,
+    return ref new NarratorAnnouncement(
-                                        AutomationNotificationProcessing::ImportantMostRecent);
+        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,
+        NarratorAnnouncement(
-                             AutomationNotificationProcessing processing);
+            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.
+    s_announcementProperty = DependencyProperty::Register(
-                                                          NarratorAnnouncement::typeid,     // The type of the dependency property.
+        L"Announcement",              // The name of the dependency property.
-                                                          NarratorNotifier::typeid,         // The owner of the dependency property.
+        NarratorAnnouncement::typeid, // The type of the dependency property.
-                                                          ref new PropertyMetadata(nullptr, // Default value of the dependency property.
+        NarratorNotifier::typeid,     // The owner of the dependency property.
-                                                                                   ref new PropertyChangedCallback(OnAnnouncementChanged)));
+        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
+            ^ GetAnnouncement(
-                              ^ element) { return safe_cast<NarratorAnnouncement ^>(element->GetValue(s_announcementProperty)); }
+                Windows::UI::Xaml::DependencyObject ^ element) { return safe_cast<NarratorAnnouncement ^>(element->GetValue(s_announcementProperty)); }
 
             static void SetAnnouncement(Windows::UI::Xaml::DependencyObject ^ element, NarratorAnnouncement ^ value)
         {
@@ -40,8 +40,9 @@ public
         }
 
     private:
-        static void OnAnnouncementChanged(_In_ Windows::UI::Xaml::DependencyObject ^ dependencyObject,
+        static void OnAnnouncementChanged(
-                                          _In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ eventArgs);
+            _In_ Windows::UI::Xaml::DependencyObject ^ dependencyObject,
+            _In_ Windows::UI::Xaml::DependencyPropertyChangedEventArgs ^ eventArgs);
 
         static Windows::UI::Xaml::DependencyProperty ^ s_announcementProperty;
 

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),
+        peer->RaiseNotificationEvent(
-                                     announcement->Announcement, announcement->ActivityId);
+            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,
+void CalculatorDisplay::SetExpressionDisplay(
-                                             _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands)
+    _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,
+        void SetExpressionDisplay(
-                                  _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands) override;
+            _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),
+static const array<wregex, 2> scientificModePatterns = {
-                                                         wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat
+    wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat + c_wspcRParens),
-                                                                + L"[e]([+]|[-])+\\d+" + c_wspcRParens) };
+    wregex(L"(" + c_wspc + L"[-+]?)|(" + c_wspcLParenSigned + L")" + c_signedDecFloat + L"e[+-]?\\d+" + c_wspcRParens)
+};
 static const array<array<wregex, 5>, 4> programmerModePatterns = {
     { // 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,
+        .then(
-               bitLengthType](String ^ pastedText) { return ValidatePasteExpression(pastedText, mode, modeType, programmerNumberBase, bitLengthType); },
+            [mode, modeType, programmerNumberBase, bitLengthType](String ^ pastedText) {
-              task_continuation_context::use_arbitrary());
+                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,
+        static concurrency::task<Platform::String ^> GetStringToPaste(
-                                                                      int programmerNumberBase = -1, int bitLengthType = -1);
+            CalculatorApp::Common::ViewMode mode,
+            CalculatorApp::Common::CategoryGroupType modeType,
+            int programmerNumberBase = -1,
+            int bitLengthType = -1);
         static bool HasStringToPaste()
         {
             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,
+            ^ ValidatePasteExpression(
-                                      int programmerNumberBase, int bitLengthType);
+                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,
+        static std::vector<std::wstring>
-                                                         int programmerNumberBase = -1, int bitLengthType = -1);
+        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,
+        static bool ExpressionRegExMatch(
-                                         CalculatorApp::Common::CategoryGroupType modeType, int programmerNumberBase = -1, int bitLengthType = -1);
+            std::vector<std::wstring> operands,
+            CalculatorApp::Common::ViewMode mode,
+            CalculatorApp::Common::CategoryGroupType modeType,
+            int programmerNumberBase = -1,
+            int bitLengthType = -1);
 
-        static std::pair<size_t, uint64_t> GetMaxOperandLengthAndValue(CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType,
+        static std::pair<size_t, uint64_t> GetMaxOperandLengthAndValue(
-                                                                       int programmerNumberBase = -1, int bitLengthType = -1);
+            CalculatorApp::Common::ViewMode mode,
+            CalculatorApp::Common::CategoryGroupType modeType,
+            int programmerNumberBase = -1,
+            int bitLengthType = -1);
         static std::wstring SanitizeOperand(const std::wstring& operand);
         static bool TryOperandToULL(const std::wstring& operand, int numberBase, unsigned long long int& result);
-        static size_t OperandLength(const std::wstring& operand, CalculatorApp::Common::ViewMode mode, CalculatorApp::Common::CategoryGroupType modeType,
+        static size_t OperandLength(
-                                    int programmerNumberBase = -1);
+            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,
+                bool __nothrow
-                                           _Out_ Windows::Foundation::DateTime* endDate);
+                AddDuration(_In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration, _Out_ Windows::Foundation::DateTime* endDate);
-                bool __nothrow SubtractDuration(_In_ Windows::Foundation::DateTime startDate, _In_ const DateDifference& duration,
+                bool __nothrow SubtractDuration(
-                                                _Out_ Windows::Foundation::DateTime* endDate);
+                    _In_ Windows::Foundation::DateTime startDate,
-                void __nothrow GetDateDifference(_In_ Windows::Foundation::DateTime date1, _In_ Windows::Foundation::DateTime date2, _In_ DateUnit outputFormat,
+                    _In_ const DateDifference& duration,
-                                                 _Out_ DateDifference* difference);
+                    _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)
+    else if (
-             && ((Window::Current->CoreWindow->GetKeyState(VirtualKey::Control) & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down))
+        (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,
+            static void
-                                                                       MyVirtualKey newValue);
+            OnVirtualKeyControlInverseChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
 
             static void OnVirtualKeyAltChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
 
-            static void OnVirtualKeyControlShiftChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue,
+            static void
-                                                                     MyVirtualKey newValue);
+            OnVirtualKeyControlShiftChordPropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, MyVirtualKey oldValue, MyVirtualKey newValue);
 
             static void OnCharacterReceivedHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::CharacterReceivedEventArgs ^ args);
             static void OnKeyDownHandler(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Core::KeyEventArgs ^ args);

src/CalcViewModel/Common/LocalizationService.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
 #include "pch.h"
@@ -49,17 +49,34 @@ LocalizationService ^ LocalizationService::GetInstance()
 
         if (s_singletonInstance == nullptr)
         {
-            s_singletonInstance = ref new LocalizationService();
+            s_singletonInstance = ref new LocalizationService(nullptr);
         }
     }
     return s_singletonInstance;
 }
 
-LocalizationService::LocalizationService()
+/// <summary>
+/// Replace (or create) the single instance of this singleton class by one with the language passed as parameter
+/// </summary>
+/// <param name="language">RFC-5646 identifier of the language to use</param>
+/// <remarks>
+/// Should only be used for test purpose
+/// </remarks>
+void LocalizationService::OverrideWithLanguage(_In_ const wchar_t * const language)
 {
-    m_language = ApplicationLanguages::Languages->GetAt(0);
+    s_singletonInstance = ref new LocalizationService(language);
-    m_flowDirection =
+}
-        ResourceContext::GetForCurrentView()->QualifierValues->Lookup(L"LayoutDirection") != L"LTR" ? FlowDirection::RightToLeft : FlowDirection::LeftToRight;
+
+/// <summary>
+/// Constructor
+/// </summary>
+/// <param name="overridedLanguage">RFC-5646 identifier of the language to use, if null, will use the current language of the system</param>
+LocalizationService::LocalizationService(_In_ const wchar_t * const overridedLanguage)
+{
+    m_isLanguageOverrided = overridedLanguage != nullptr;
+    m_language = m_isLanguageOverrided ? ref new Platform::String(overridedLanguage) : ApplicationLanguages::Languages->GetAt(0);
+    m_flowDirection = ResourceContext::GetForCurrentView()->QualifierValues->Lookup(L"LayoutDirection")
+        != L"LTR" ? FlowDirection::RightToLeft : FlowDirection::LeftToRight;
 
     auto resourceLoader = AppResourceProvider::GetInstance();
     m_fontFamilyOverride = resourceLoader.GetResourceString(L"LocalizedFontFamilyOverride");
@@ -339,7 +356,7 @@ void LocalizationService::UpdateFontFamilyAndSize(DependencyObject ^ target)
 
 // If successful, returns a formatter that respects the user's regional format settings,
 // as configured by running intl.cpl.
-DecimalFormatter ^ LocalizationService::GetRegionalSettingsAwareDecimalFormatter()
+DecimalFormatter ^ LocalizationService::GetRegionalSettingsAwareDecimalFormatter() const
 {
     IIterable<String ^> ^ languageIdentifiers = LocalizationService::GetLanguageIdentifiers();
     if (languageIdentifiers != nullptr)
@@ -354,7 +371,7 @@ DecimalFormatter ^ LocalizationService::GetRegionalSettingsAwareDecimalFormatter
 // as configured by running intl.cpl.
 //
 // This helper function creates a DateTimeFormatter with a TwentyFour hour clock
-DateTimeFormatter ^ LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(_In_ String ^ format)
+DateTimeFormatter ^ LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(_In_ String^ format) const
 {
     IIterable<String ^> ^ languageIdentifiers = LocalizationService::GetLanguageIdentifiers();
     if (languageIdentifiers == nullptr)
@@ -367,8 +384,7 @@ DateTimeFormatter ^ LocalizationService::GetRegionalSettingsAwareDateTimeFormatt
 
 // If successful, returns a formatter that respects the user's regional format settings,
 // as configured by running intl.cpl.
-DateTimeFormatter
+DateTimeFormatter^ LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(_In_ String ^ format, _In_ String ^ calendarIdentifier, _In_ String ^ clockIdentifier) const
-    ^ LocalizationService::GetRegionalSettingsAwareDateTimeFormatter(_In_ String ^ format, _In_ String ^ calendarIdentifier, _In_ String ^ clockIdentifier)
 {
     IIterable<String ^> ^ languageIdentifiers = LocalizationService::GetLanguageIdentifiers();
     if (languageIdentifiers == nullptr)
@@ -379,12 +395,12 @@ DateTimeFormatter
     return ref new DateTimeFormatter(format, languageIdentifiers, GlobalizationPreferences::HomeGeographicRegion, calendarIdentifier, clockIdentifier);
 }
 
-CurrencyFormatter ^ LocalizationService::GetRegionalSettingsAwareCurrencyFormatter()
+CurrencyFormatter ^ LocalizationService::GetRegionalSettingsAwareCurrencyFormatter() const
 {
     String ^ userCurrency =
         (GlobalizationPreferences::Currencies->Size > 0) ? GlobalizationPreferences::Currencies->GetAt(0) : StringReference(DefaultCurrencyCode.data());
 
-    IIterable<String ^> ^ languageIdentifiers = LocalizationService::GetLanguageIdentifiers();
+    IIterable<String ^> ^ languageIdentifiers = GetLanguageIdentifiers();
     if (languageIdentifiers == nullptr)
     {
         languageIdentifiers = ApplicationLanguages::Languages;
@@ -398,10 +414,18 @@ CurrencyFormatter ^ LocalizationService::GetRegionalSettingsAwareCurrencyFormatt
     return currencyFormatter;
 }
 
-IIterable<String ^> ^ LocalizationService::GetLanguageIdentifiers()
+IIterable<String ^> ^ LocalizationService::GetLanguageIdentifiers() const
 {
     WCHAR currentLocale[LOCALE_NAME_MAX_LENGTH] = {};
     int result = GetUserDefaultLocaleName(currentLocale, LOCALE_NAME_MAX_LENGTH);
+
+    if (m_isLanguageOverrided)
+    {
+        auto overridedLanguageList = ref new Vector<String^>();
+        overridedLanguageList->Append(m_language);
+        return overridedLanguageList;
+    }
+
     if (result != 0)
     {
         // GetUserDefaultLocaleName may return an invalid bcp47 language tag with trailing non-BCP47 friendly characters,
@@ -434,28 +458,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 = {
+    static vector<pair<wstring, wstring>> s_parenEngineKeyResourceMap = { // Sine permutations
-        // Sine permutations
+                                                                          make_pair<wstring, wstring>(L"67", L"SineDegrees"),
-        make_pair<wstring, wstring>(L"67", L"SineDegrees"), make_pair<wstring, wstring>(L"73", L"SineRadians"),
+                                                                          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"79", L"SineGradians"),
-        make_pair<wstring, wstring>(L"76", L"InverseSineRadians"), make_pair<wstring, wstring>(L"82", L"InverseSineGradians"),
+                                                                          make_pair<wstring, wstring>(L"70", L"InverseSineDegrees"),
-        make_pair<wstring, wstring>(L"25", L"HyperbolicSine"), make_pair<wstring, wstring>(L"85", L"InverseHyperbolicSine"),
+                                                                          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
+                                                                          // Cosine permutations
-        make_pair<wstring, wstring>(L"68", L"CosineDegrees"), make_pair<wstring, wstring>(L"74", L"CosineRadians"),
+                                                                          make_pair<wstring, wstring>(L"68", L"CosineDegrees"),
-        make_pair<wstring, wstring>(L"80", L"CosineGradians"), make_pair<wstring, wstring>(L"71", L"InverseCosineDegrees"),
+                                                                          make_pair<wstring, wstring>(L"74", L"CosineRadians"),
-        make_pair<wstring, wstring>(L"77", L"InverseCosineRadians"), make_pair<wstring, wstring>(L"83", L"InverseCosineGradians"),
+                                                                          make_pair<wstring, wstring>(L"80", L"CosineGradians"),
-        make_pair<wstring, wstring>(L"26", L"HyperbolicCosine"), make_pair<wstring, wstring>(L"86", L"InverseHyperbolicCosine"),
+                                                                          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
+                                                                          // Tangent permutations
-        make_pair<wstring, wstring>(L"69", L"TangentDegrees"), make_pair<wstring, wstring>(L"75", L"TangentRadians"),
+                                                                          make_pair<wstring, wstring>(L"69", L"TangentDegrees"),
-        make_pair<wstring, wstring>(L"81", L"TangentGradians"), make_pair<wstring, wstring>(L"72", L"InverseTangentDegrees"),
+                                                                          make_pair<wstring, wstring>(L"75", L"TangentRadians"),
-        make_pair<wstring, wstring>(L"78", L"InverseTangentRadians"), make_pair<wstring, wstring>(L"84", L"InverseTangentGradians"),
+                                                                          make_pair<wstring, wstring>(L"81", L"TangentGradians"),
-        make_pair<wstring, wstring>(L"27", L"HyperbolicTangent"), make_pair<wstring, wstring>(L"87", L"InverseHyperbolicTangent"),
+                                                                          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
+                                                                          // Miscellaneous Scientific functions
-        make_pair<wstring, wstring>(L"94", L"Factorial"), make_pair<wstring, wstring>(L"35", L"DegreeMinuteSecond"),
+                                                                          make_pair<wstring, wstring>(L"94", L"Factorial"),
-        make_pair<wstring, wstring>(L"28", L"NaturalLog"), make_pair<wstring, wstring>(L"91", L"Square")
+                                                                          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

@@ -30,7 +30,9 @@ namespace CalculatorApp
             DEPENDENCY_PROPERTY_ATTACHED_WITH_DEFAULT_AND_CALLBACK(LanguageFontType, FontType, LanguageFontType::UIText);
             DEPENDENCY_PROPERTY_ATTACHED_WITH_CALLBACK(double, FontSize);
 
-            internal : static LocalizationService ^ GetInstance();
+    internal:
+        static LocalizationService^ GetInstance();
+        static void OverrideWithLanguage(_In_ const wchar_t * const language);
 
             Windows::UI::Xaml::FlowDirection GetFlowDirection();
             bool IsRtlLayout();
@@ -41,46 +43,48 @@ namespace CalculatorApp
             Windows::UI::Text::FontWeight GetFontWeightOverride();
             double GetFontScaleFactorOverride(LanguageFontType fontType);
 
-            static Windows::Globalization::NumberFormatting::DecimalFormatter ^ GetRegionalSettingsAwareDecimalFormatter();
+            Windows::Globalization::NumberFormatting::DecimalFormatter ^ GetRegionalSettingsAwareDecimalFormatter() const;
-            static Windows::Globalization::DateTimeFormatting::DateTimeFormatter ^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format);
+            Windows::Globalization::DateTimeFormatting::DateTimeFormatter ^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format) const;
-            static Windows::Globalization::DateTimeFormatting::DateTimeFormatter
+            Windows::Globalization::DateTimeFormatting::DateTimeFormatter ^ GetRegionalSettingsAwareDateTimeFormatter(
-                ^ GetRegionalSettingsAwareDateTimeFormatter(_In_ Platform::String ^ format, _In_ Platform::String ^ calendarIdentifier,
+                _In_ Platform::String ^ format,
-                                                            _In_ Platform::String ^ clockIdentifier);
+                _In_ Platform::String ^ calendarIdentifier,
+                _In_ Platform::String ^ clockIdentifier) const;
 
-            static Windows::Globalization::NumberFormatting::CurrencyFormatter ^ GetRegionalSettingsAwareCurrencyFormatter();
+            Windows::Globalization::NumberFormatting::CurrencyFormatter ^ GetRegionalSettingsAwareCurrencyFormatter() const;
 
             static Platform::String ^ GetNarratorReadableToken(Platform::String ^ rawToken);
             static Platform::String ^ GetNarratorReadableString(Platform::String ^ rawString);
 
         private:
+            LocalizationService(_In_ const wchar_t* const overridedLanguage);
             Windows::Globalization::Fonts::LanguageFont ^ GetLanguageFont(LanguageFontType fontType);
             Windows::UI::Text::FontWeight ParseFontWeight(Platform::String ^ fontWeight);
 
-            static Windows::Foundation::Collections::IIterable<Platform::String ^> ^ GetLanguageIdentifiers();
+            Windows::Foundation::Collections::IIterable<Platform::String ^> ^ GetLanguageIdentifiers() const;
 
             // 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,
+            static void OnFontWeightPropertyChanged(
-                                                    Windows::UI::Text::FontWeight newValue);
+                Windows::UI::Xaml::DependencyObject ^ target,
+                Windows::UI::Text::FontWeight oldValue,
+                Windows::UI::Text::FontWeight newValue);
             static void OnFontSizePropertyChanged(Windows::UI::Xaml::DependencyObject ^ target, double oldValue, double newValue);
 
             static void UpdateFontFamilyAndSize(Windows::UI::Xaml::DependencyObject ^ target);
 
             static std::unordered_map<std::wstring, std::wstring> GetTokenToReadableNameMap();
 
-        private:
-            LocalizationService();
-
             static LocalizationService ^ s_singletonInstance;
 
-            Windows::Globalization::Fonts::LanguageFontGroup ^ m_fontGroup;
+		    Windows::Globalization::Fonts::LanguageFontGroup ^ m_fontGroup;
-            Platform::String ^ m_language;
+		    Platform::String ^ m_language;
-            Windows::UI::Xaml::FlowDirection m_flowDirection;
+		    Windows::UI::Xaml::FlowDirection m_flowDirection;
-            bool m_overrideFontApiValues;
+		    bool m_overrideFontApiValues;
-            Platform::String ^ m_fontFamilyOverride;
+		    Platform::String ^ m_fontFamilyOverride;
-            Windows::UI::Text::FontWeight m_fontWeightOverride;
+		    bool m_isLanguageOverrided;
-            double m_uiTextFontScaleFactorOverride;
+		    Windows::UI::Text::FontWeight m_fontWeightOverride;
-            double m_uiCaptionFontScaleFactorOverride;
+		    double m_uiTextFontScaleFactorOverride;
+		    double m_uiCaptionFontScaleFactorOverride;
         };
 
     }

src/CalcViewModel/Common/LocalizationSettings.h

@@ -19,7 +19,7 @@ namespace CalculatorApp
 
                 // Use DecimalFormatter as it respects the locale and the user setting
                 Windows::Globalization::NumberFormatting::DecimalFormatter ^ formatter;
-                formatter = CalculatorApp::Common::LocalizationService::GetRegionalSettingsAwareDecimalFormatter();
+                formatter = LocalizationService::GetInstance()->GetRegionalSettingsAwareDecimalFormatter();
                 formatter->FractionDigits = 0;
                 formatter->IsDecimalPointAlwaysDisplayed = false;
 
@@ -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,
+                    result = ::GetLocaleInfoEx(
-                                               static_cast<int>(std::size(listSeparatorString))); // Max length of the expected return value is 4
+                        m_resolvedName.c_str(),
+                        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,
+                    result = GetLocaleInfoEx(
-                                             sizeof(currencyTrailingDigits) / sizeof(WCHAR));
+                        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,
+                    result = GetLocaleInfoEx(
-                                             sizeof(currencySymbolPrecedence) / sizeof(WCHAR));
+                        m_resolvedName.c_str(),
+                        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.
@@ -95,16 +104,17 @@ namespace CalculatorApp
                 // Note: This function returns 0 on failure.
                 // We'll ignore the failure in that case and the CalendarIdentifier would get set to GregorianCalendar.
                 CALID calId;
-                ::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_ICALENDARTYPE | LOCALE_RETURN_NUMBER, reinterpret_cast<PWSTR>(&calId), sizeof(calId));
+                ::GetLocaleInfoEx(m_resolvedName.c_str(), LOCALE_ICALENDARTYPE | LOCALE_RETURN_NUMBER, reinterpret_cast<PWSTR>(&calId), sizeof(calId));
 
                 m_calendarIdentifier = GetCalendarIdentifierFromCalid(calId);
 
                 // Get FirstDayOfWeek Date and Time setting
                 wchar_t day[80] = L"";
-                ::GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT,
+                ::GetLocaleInfoEx(
-                                  LOCALE_IFIRSTDAYOFWEEK,            // The first day in a week
+                    m_resolvedName.c_str(),
-                                  reinterpret_cast<PWSTR>(day),      // Argument is of type PWSTR
+                    LOCALE_IFIRSTDAYOFWEEK,            // The first day in a week
-                                  static_cast<int>(std::size(day))); // Max return size are 80 characters
+                    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 = {
+static constexpr array<const NavCategoryInitializer, 17> s_categoryManifest = { NavCategoryInitializer{ ViewMode::Standard,
-    NavCategoryInitializer{ ViewMode::Standard, STANDARD_ID, L"Standard", L"StandardMode", L"\uE8EF", CategoryGroupType::Calculator, MyVirtualKey::Number1,
+                                                                                                        STANDARD_ID,
-                            SUPPORTS_ALL },
+                                                                                                        L"Standard",
-    NavCategoryInitializer{ ViewMode::Scientific, SCIENTIFIC_ID, L"Scientific", L"ScientificMode", L"\uF196", CategoryGroupType::Calculator,
+                                                                                                        L"StandardMode",
-                            MyVirtualKey::Number2, SUPPORTS_ALL },
+                                                                                                        L"\uE8EF",
-    NavCategoryInitializer{ ViewMode::Programmer, PROGRAMMER_ID, L"Programmer", L"ProgrammerMode", L"\uECCE", CategoryGroupType::Calculator,
+                                                                                                        CategoryGroupType::Calculator,
-                            MyVirtualKey::Number3, SUPPORTS_ALL },
+                                                                                                        MyVirtualKey::Number1,
-    NavCategoryInitializer{ ViewMode::Date, DATE_ID, L"Date", L"DateCalculationMode", L"\uE787", CategoryGroupType::Calculator, MyVirtualKey::Number4,
+                                                                                                        SUPPORTS_ALL },
-                            SUPPORTS_ALL },
+                                                                                NavCategoryInitializer{ ViewMode::Scientific,
-    NavCategoryInitializer{ ViewMode::Currency, CURRENCY_ID, L"Currency", L"CategoryName_Currency", L"\uEB0D", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        SCIENTIFIC_ID,
-                            POSITIVE_ONLY },
+                                                                                                        L"Scientific",
-    NavCategoryInitializer{ ViewMode::Volume, VOLUME_ID, L"Volume", L"CategoryName_Volume", L"\uF1AA", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        L"ScientificMode",
-                            POSITIVE_ONLY },
+                                                                                                        L"\uF196",
-    NavCategoryInitializer{ ViewMode::Length, LENGTH_ID, L"Length", L"CategoryName_Length", L"\uECC6", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        CategoryGroupType::Calculator,
-                            POSITIVE_ONLY },
+                                                                                                        MyVirtualKey::Number2,
-    NavCategoryInitializer{ ViewMode::Weight, WEIGHT_ID, L"Weight and Mass", L"CategoryName_Weight", L"\uF4C1", CategoryGroupType::Converter,
+                                                                                                        SUPPORTS_ALL },
-                            MyVirtualKey::None, POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Programmer,
-    NavCategoryInitializer{ ViewMode::Temperature, TEMPERATURE_ID, L"Temperature", L"CategoryName_Temperature", L"\uE7A3", CategoryGroupType::Converter,
+                                                                                                        PROGRAMMER_ID,
-                            MyVirtualKey::None, SUPPORTS_NEGATIVE },
+                                                                                                        L"Programmer",
-    NavCategoryInitializer{ ViewMode::Energy, ENERGY_ID, L"Energy", L"CategoryName_Energy", L"\uECAD", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        L"ProgrammerMode",
-                            POSITIVE_ONLY },
+                                                                                                        L"\uECCE",
-    NavCategoryInitializer{ ViewMode::Area, AREA_ID, L"Area", L"CategoryName_Area", L"\uE809", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        CategoryGroupType::Calculator,
-                            POSITIVE_ONLY },
+                                                                                                        MyVirtualKey::Number3,
-    NavCategoryInitializer{ ViewMode::Speed, SPEED_ID, L"Speed", L"CategoryName_Speed", L"\uEADA", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        SUPPORTS_ALL },
-                            POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Date,
-    NavCategoryInitializer{ ViewMode::Time, TIME_ID, L"Time", L"CategoryName_Time", L"\uE917", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        DATE_ID,
-                            POSITIVE_ONLY },
+                                                                                                        L"Date",
-    NavCategoryInitializer{ ViewMode::Power, POWER_ID, L"Power", L"CategoryName_Power", L"\uE945", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        L"DateCalculationMode",
-                            POSITIVE_ONLY },
+                                                                                                        L"\uE787",
-    NavCategoryInitializer{ ViewMode::Data, DATA_ID, L"Data", L"CategoryName_Data", L"\uF20F", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        CategoryGroupType::Calculator,
-                            POSITIVE_ONLY },
+                                                                                                        MyVirtualKey::Number4,
-    NavCategoryInitializer{ ViewMode::Pressure, PRESSURE_ID, L"Pressure", L"CategoryName_Pressure", L"\uEC4A", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        SUPPORTS_ALL },
-                            POSITIVE_ONLY },
+                                                                                NavCategoryInitializer{ ViewMode::Currency,
-    NavCategoryInitializer{ ViewMode::Angle, ANGLE_ID, L"Angle", L"CategoryName_Angle", L"\uF515", CategoryGroupType::Converter, MyVirtualKey::None,
+                                                                                                        CURRENCY_ID,
-                            POSITIVE_ONLY }
+                                                                                                        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),
+        auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [serializationId](const NavCategoryInitializer& initializer) {
-                            [serializationId](const NavCategoryInitializer& initializer) { return initializer.serializationId == serializationId; });
+            return initializer.serializationId == serializationId;
+        });
 
         if (iter != s_categoryManifest.end())
         {
@@ -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),
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [mode, type](const NavCategoryInitializer& initializer) {
-                        [mode, type](const NavCategoryInitializer& initializer) { return initializer.viewMode == mode && initializer.groupType == type; });
+        return initializer.viewMode == mode && initializer.groupType == type;
+    });
 
     return iter != s_categoryManifest.end();
 }
@@ -160,8 +262,9 @@ String ^ NavCategory::GetFriendlyName(ViewMode mode)
 
 ViewMode NavCategory::GetViewModeForFriendlyName(String ^ name)
 {
-    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [name](const NavCategoryInitializer& initializer) {
-                        [name](const NavCategoryInitializer& initializer) { return wcscmp(initializer.friendlyName, name->Data()) == 0; });
+        return wcscmp(initializer.friendlyName, name->Data()) == 0;
+    });
 
     return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
 }
@@ -238,8 +341,9 @@ int NavCategory::GetPosition(ViewMode mode)
 
 ViewMode NavCategory::GetViewModeForVirtualKey(MyVirtualKey virtualKey)
 {
-    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest),
+    auto iter = find_if(begin(s_categoryManifest), end(s_categoryManifest), [virtualKey](const NavCategoryInitializer& initializer) {
-                        [virtualKey](const NavCategoryInitializer& initializer) { return initializer.virtualKey == virtualKey; });
+        return initializer.virtualKey == virtualKey;
+    });
 
     return (iter != s_categoryManifest.end()) ? iter->viewMode : ViewMode::None;
 }
@@ -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),
+            m_Categories->Append(ref new NavCategory(
-                                                     resProvider.GetResourceString(nameResourceKey + "AccessKey"), groupMode, categoryInitializer.viewMode,
+                categoryName,
-                                                     categoryInitializer.supportsNegative));
+                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),
+    copy_if(begin(s_categoryManifest), end(s_categoryManifest), back_inserter(initializers), [groupType](const NavCategoryInitializer& initializer) {
-            [groupType](const NavCategoryInitializer& initializer) { return initializer.groupType == groupType; });
+        return initializer.groupType == groupType;
+    });
 
     return initializers;
 }
 
 String ^ NavCategoryGroup::GetHeaderResourceKey(CategoryGroupType type)
 {
-    auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest),
+    auto iter = find_if(begin(s_categoryGroupManifest), end(s_categoryGroupManifest), [type](const NavCategoryGroupInitializer& initializer) {
-                        [type](const NavCategoryGroupInitializer& initializer) { return initializer.type == type; });
+        return initializer.type == type;
+    });
 
     return (iter != s_categoryGroupManifest.end()) ? StringReference(iter->headerResourceKey) : nullptr;
 }

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,
+            constexpr NavCategoryInitializer(
-                                             MyVirtualKey vKey, bool categorySupportsNegative)
+                ViewMode mode,
+                int id,
+                wchar_t const* name,
+                wchar_t const* nameKey,
+                wchar_t const* glyph,
+                CategoryGroupType group,
+                MyVirtualKey vKey,
+                bool categorySupportsNegative)
                 : viewMode(mode)
                 , 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,
+            internal : NavCategory(
-                                   Platform::String ^ mode, ViewMode viewMode, bool supportsNegative)
+                           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,
+        TraceActivity(
-                      winrt::Windows::Foundation::Diagnostics::LoggingFields fields)
+            winrt::Windows::Foundation::Diagnostics::LoggingChannel channel,
-            : m_channel(channel), m_activityName(activityName), m_fields(fields), m_activity(nullptr)
+            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,
+            m_activity = m_channel.StartActivity(
-                                                 winrt::Windows::Foundation::Diagnostics::LoggingOptions(WINEVENT_KEYWORD_RESPONSE_TIME));
+                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,
+    void
-                                    unsigned int memorySize) const
+    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,
+        void
-                                               winrt::Windows::Foundation::DateTime const& clippedTime) const;
+        LogDateClippedTimeDifferenceFound(winrt::Windows::Globalization::Calendar const& today, winrt::Windows::Foundation::DateTime const& clippedTime) const;
 
         void LogStandardException(std::wstring_view functionName, _In_ const std::exception& e) const;
         void 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,
+void Utils::SerializeCommandsAndTokens(
-                                       _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands, DataWriter ^ writer)
+    _In_ shared_ptr<CalculatorVector<pair<wstring, int>>> const& tokens,
+    _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands,
+    DataWriter ^ writer)
 {
     unsigned int commandsSize;
     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,
+    void SerializeCommandsAndTokens(
-                                    _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands,
+        _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
-                                    Windows::Storage::Streams::DataWriter ^ writer);
+        _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands,
+        Windows::Storage::Streams::DataWriter ^ writer);
 
     const std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> DeserializeCommands(Windows::Storage::Streams::DataReader ^ reader);
     const std::shared_ptr<CalculatorVector<std::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,
+    concurrency::task<void> WriteFileToFolder(
-                                              Windows::Storage::CreationCollisionOption collisionOption);
+        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*/,
+                ^ Convert(
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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*/,
+                ^ ConvertBack(
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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*/,
+                ^ Convert(
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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*/,
+                ^ ConvertBack(
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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 },
+static constexpr array<wstring_view, 5> STATIC_DATA_PROPERTIES = { wstring_view{ L"CountryCode", 11 },
-                                                                   wstring_view{ L"CurrencyCode", 12 }, wstring_view{ L"CurrencyName", 12 },
+                                                                   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";
@@ -85,7 +87,7 @@ namespace CalculatorApp
     }
 }
 
-CurrencyDataLoader::CurrencyDataLoader(_In_ unique_ptr<ICurrencyHttpClient> client)
+CurrencyDataLoader::CurrencyDataLoader(_In_ unique_ptr<ICurrencyHttpClient> client, const wchar_t * forcedResponseLanguage)
     : m_client(move(client))
     , m_loadStatus(CurrencyLoadStatus::NotLoaded)
     , m_responseLanguage(L"en-US")
@@ -94,9 +96,20 @@ CurrencyDataLoader::CurrencyDataLoader(_In_ unique_ptr<ICurrencyHttpClient> clie
     , m_networkManager(ref new NetworkManager())
     , m_meteredOverrideSet(false)
 {
-    if (GlobalizationPreferences::Languages->Size > 0)
+    if (forcedResponseLanguage != nullptr)
     {
-        m_responseLanguage = GlobalizationPreferences::Languages->GetAt(0);
+        m_responseLanguage = ref new Platform::String(forcedResponseLanguage);
+    }
+    else
+    {
+        if (GlobalizationPreferences::Languages->Size > 0)
+        {
+            m_responseLanguage = GlobalizationPreferences::Languages->GetAt(0);
+        }
+        else
+        {
+            m_responseLanguage = L"en-US";
+        }
     }
 
     if (m_client != nullptr)
@@ -105,13 +118,14 @@ CurrencyDataLoader::CurrencyDataLoader(_In_ unique_ptr<ICurrencyHttpClient> clie
         m_client->SetResponseLanguage(m_responseLanguage);
     }
 
+    auto localizationService = LocalizationService::GetInstance();
     if (CoreWindow::GetForCurrentThread() != nullptr)
     {
         // Must have a CoreWindow to access the resource context.
-        m_isRtlLanguage = LocalizationService::GetInstance()->IsRtlLayout();
+        m_isRtlLanguage = localizationService->IsRtlLayout();
     }
 
-    m_ratioFormatter = LocalizationService::GetRegionalSettingsAwareDecimalFormatter();
+    m_ratioFormatter = localizationService->GetRegionalSettingsAwareDecimalFormatter();
     m_ratioFormatter->IsGrouped = true;
     m_ratioFormatter->IsDecimalPointAlwaysDisplayed = true;
     m_ratioFormatter->FractionDigits = FORMATTER_DIGIT_COUNT;
@@ -275,8 +289,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(),
+                wstring ratioString = LocalizationStringUtil::GetLocalizedString(
-                                                                                 roundedFormat.c_str(), unit2.abbreviation.c_str());
+                    m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.abbreviation.c_str(), roundedFormat.c_str(), unit2.abbreviation.c_str());
 
                 wstring accessibleRatioString = LocalizationStringUtil::GetLocalizedString(
                     m_ratioFormat.c_str(), digitSymbol.c_str(), unit1.accessibleName.c_str(), roundedFormat.c_str(), unit2.accessibleName.c_str());
@@ -459,8 +473,11 @@ task<bool> CurrencyDataLoader::TryLoadDataFromWebOverrideAsync()
 };
 #pragma optimize("", on)
 
-bool CurrencyDataLoader::TryParseWebResponses(_In_ String ^ staticDataJson, _In_ String ^ allRatiosJson, _Inout_ vector<UCM::CurrencyStaticData>& staticData,
+bool CurrencyDataLoader::TryParseWebResponses(
-                                              _Inout_ CurrencyRatioMap& allRatiosData)
+    _In_ String ^ staticDataJson,
+    _In_ String ^ allRatiosJson,
+    _Inout_ vector<UCM::CurrencyStaticData>& staticData,
+    _Inout_ CurrencyRatioMap& allRatiosData)
 {
     return TryParseStaticData(staticDataJson, staticData) && TryParseAllRatiosData(allRatiosJson, allRatiosData);
 }

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)
             {
             }
 
@@ -53,7 +54,7 @@ namespace CalculatorApp
         class CurrencyDataLoader : public UCM::IConverterDataLoader, public UCM::ICurrencyConverterDataLoader
         {
         public:
-            CurrencyDataLoader(_In_ std::unique_ptr<CalculatorApp::DataLoaders::ICurrencyHttpClient> client);
+            CurrencyDataLoader(_In_ std::unique_ptr<CalculatorApp::DataLoaders::ICurrencyHttpClient> client, const wchar_t* overrideLanguage = nullptr);
             ~CurrencyDataLoader();
 
             bool LoadFinished();
@@ -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,
+            std::pair<std::wstring, std::wstring>
-                                                                           _In_ const UnitConversionManager::Unit& unit2) override;
+            GetCurrencyRatioEquality(_In_ const UnitConversionManager::Unit& unit1, _In_ const UnitConversionManager::Unit& unit2) override;
             std::wstring GetCurrencyTimestamp() override;
 
             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,
+            bool TryParseWebResponses(
-                                      _Inout_ std::vector<UCM::CurrencyStaticData>& staticData, _Inout_ CurrencyRatioMap& allRatiosData);
+                _In_ Platform::String ^ staticDataJson,
+                _In_ Platform::String ^ allRatiosJson,
+                _Inout_ std::vector<UCM::CurrencyStaticData>& staticData,
+                _Inout_ CurrencyRatioMap& allRatiosData);
             bool TryParseStaticData(_In_ Platform::String ^ rawJson, _Inout_ std::vector<UCM::CurrencyStaticData>& staticData);
             bool 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(),
+    auto itr = find_if(supportedCategories->begin(), supportedCategories->end(), [&](const UCM::Category& category) {
-                       [&](const UCM::Category& category) { return currencyId != category.id && target.id == category.id; });
+        return currencyId != category.id && target.id == category.id;
+    });
 
     return itr != supportedCategories->end();
 }
@@ -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"),
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareCentimeter,
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareCentimeter"), 2 });
+                                     GetLocalizedStringName(L"UnitName_SquareCentimeter"),
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareFoot, GetLocalizedStringName(L"UnitName_SquareFoot"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareCentimeter"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareFoot"), 7, useSI, useUSCustomary, false });
+                                     2 });
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareInch, GetLocalizedStringName(L"UnitName_SquareInch"),
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareFoot,
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareInch"), 6 });
+                                     GetLocalizedStringName(L"UnitName_SquareFoot"),
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareKilometer, GetLocalizedStringName(L"UnitName_SquareKilometer"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareFoot"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareKilometer"), 5 });
+                                     7,
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMeter, GetLocalizedStringName(L"UnitName_SquareMeter"),
+                                     useSI,
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMeter"), 3, useUSCustomary, useSI, false });
+                                     useUSCustomary,
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMile, GetLocalizedStringName(L"UnitName_SquareMile"),
+                                     false });
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMile"), 10 });
+    areaUnits.push_back(OrderedUnit{
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMillimeter, GetLocalizedStringName(L"UnitName_SquareMillimeter"),
+        UnitConverterUnits::Area_SquareInch, GetLocalizedStringName(L"UnitName_SquareInch"), GetLocalizedStringName(L"UnitAbbreviation_SquareInch"), 6 });
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMillimeter"), 1 });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareKilometer,
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareYard, GetLocalizedStringName(L"UnitName_SquareYard"),
+                                     GetLocalizedStringName(L"UnitName_SquareKilometer"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_SquareYard"), 8 });
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareKilometer"),
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Hand, GetLocalizedStringName(L"UnitName_Hand"), GetLocalizedStringName(L"UnitAbbreviation_Hand"),
+                                     5 });
-                                     11, false, false, true });
+    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SquareMeter,
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Paper, GetLocalizedStringName(L"UnitName_Paper"),
+                                     GetLocalizedStringName(L"UnitName_SquareMeter"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Paper"), 12, false, false, true });
+                                     GetLocalizedStringName(L"UnitAbbreviation_SquareMeter"),
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_SoccerField, GetLocalizedStringName(L"UnitName_SoccerField"),
+                                     3,
-                                     GetLocalizedStringName(L"UnitAbbreviation_SoccerField"), 13, false, false, true });
+                                     useUSCustomary,
-    areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Castle, GetLocalizedStringName(L"UnitName_Castle"),
+                                     useSI,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Castle"), 14, false, false, true });
+                                     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"),
+        areaUnits.push_back(OrderedUnit{ UnitConverterUnits::Area_Pyeong,
-                                         GetLocalizedStringName(L"UnitAbbreviation_Pyeong"), 15, false, false, false });
+                                         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"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exabytes"), 25 });
+        UnitConverterUnits::Data_Exabytes, GetLocalizedStringName(L"UnitName_Exabytes"), GetLocalizedStringName(L"UnitAbbreviation_Exabytes"), 25 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Exbibits, GetLocalizedStringName(L"UnitName_Exbibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exbibits"), 24 });
+        UnitConverterUnits::Data_Exbibits, GetLocalizedStringName(L"UnitName_Exbibits"), GetLocalizedStringName(L"UnitAbbreviation_Exbibits"), 24 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Exbibytes, GetLocalizedStringName(L"UnitName_Exbibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Exbibytes"), 26 });
+        UnitConverterUnits::Data_Exbibytes, GetLocalizedStringName(L"UnitName_Exbibytes"), GetLocalizedStringName(L"UnitAbbreviation_Exbibytes"), 26 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gibibits, GetLocalizedStringName(L"UnitName_Gibibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gibibits"), 12 });
+        UnitConverterUnits::Data_Gibibits, GetLocalizedStringName(L"UnitName_Gibibits"), GetLocalizedStringName(L"UnitAbbreviation_Gibibits"), 12 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gibibytes, GetLocalizedStringName(L"UnitName_Gibibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gibibytes"), 14 });
+        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"),
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Gigabyte,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Gigabyte"), 13, true, false, false });
+                                     GetLocalizedStringName(L"UnitName_Gigabyte"),
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Kibibits, GetLocalizedStringName(L"UnitName_Kibibits"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Gigabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kibibits"), 4 });
+                                     13,
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Kibibytes, GetLocalizedStringName(L"UnitName_Kibibytes"),
+                                     true,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kibibytes"), 6 });
+                                     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"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kilobyte"), 5 });
+        UnitConverterUnits::Data_Kilobyte, GetLocalizedStringName(L"UnitName_Kilobyte"), GetLocalizedStringName(L"UnitAbbreviation_Kilobyte"), 5 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Mebibits, GetLocalizedStringName(L"UnitName_Mebibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Mebibits"), 8 });
+        UnitConverterUnits::Data_Mebibits, GetLocalizedStringName(L"UnitName_Mebibits"), GetLocalizedStringName(L"UnitAbbreviation_Mebibits"), 8 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Mebibytes, GetLocalizedStringName(L"UnitName_Mebibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Mebibytes"), 10 });
+        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"),
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Megabyte,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Megabyte"), 9, false, true, false });
+                                     GetLocalizedStringName(L"UnitName_Megabyte"),
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Pebibits, GetLocalizedStringName(L"UnitName_Pebibits"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_Megabyte"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_Pebibits"), 20 });
+                                     9,
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Pebibytes, GetLocalizedStringName(L"UnitName_Pebibytes"),
+                                     false,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Pebibytes"), 22 });
+                                     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"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Petabyte"), 21 });
+        UnitConverterUnits::Data_Petabyte, GetLocalizedStringName(L"UnitName_Petabyte"), GetLocalizedStringName(L"UnitAbbreviation_Petabyte"), 21 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Tebibits, GetLocalizedStringName(L"UnitName_Tebibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Tebibits"), 16 });
+        UnitConverterUnits::Data_Tebibits, GetLocalizedStringName(L"UnitName_Tebibits"), GetLocalizedStringName(L"UnitAbbreviation_Tebibits"), 16 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Tebibytes, GetLocalizedStringName(L"UnitName_Tebibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Tebibytes"), 18 });
+        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"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Terabyte"), 17 });
+        UnitConverterUnits::Data_Terabyte, GetLocalizedStringName(L"UnitName_Terabyte"), GetLocalizedStringName(L"UnitAbbreviation_Terabyte"), 17 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yobibits, GetLocalizedStringName(L"UnitName_Yobibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yobibits"), 32 });
+        UnitConverterUnits::Data_Yobibits, GetLocalizedStringName(L"UnitName_Yobibits"), GetLocalizedStringName(L"UnitAbbreviation_Yobibits"), 32 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yobibytes, GetLocalizedStringName(L"UnitName_Yobibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yobibytes"), 34 });
+        UnitConverterUnits::Data_Yobibytes, GetLocalizedStringName(L"UnitName_Yobibytes"), GetLocalizedStringName(L"UnitAbbreviation_Yobibytes"), 34 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yottabit, GetLocalizedStringName(L"UnitName_Yottabit"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yottabit"), 31 });
+        UnitConverterUnits::Data_Yottabit, GetLocalizedStringName(L"UnitName_Yottabit"), GetLocalizedStringName(L"UnitAbbreviation_Yottabit"), 31 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Yottabyte, GetLocalizedStringName(L"UnitName_Yottabyte"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Yottabyte"), 33 });
+        UnitConverterUnits::Data_Yottabyte, GetLocalizedStringName(L"UnitName_Yottabyte"), GetLocalizedStringName(L"UnitAbbreviation_Yottabyte"), 33 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zebibits, GetLocalizedStringName(L"UnitName_Zebibits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zebibits"), 28 });
+        UnitConverterUnits::Data_Zebibits, GetLocalizedStringName(L"UnitName_Zebibits"), GetLocalizedStringName(L"UnitAbbreviation_Zebibits"), 28 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zebibytes, GetLocalizedStringName(L"UnitName_Zebibytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zebibytes"), 30 });
+        UnitConverterUnits::Data_Zebibytes, GetLocalizedStringName(L"UnitName_Zebibytes"), GetLocalizedStringName(L"UnitAbbreviation_Zebibytes"), 30 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zetabits, GetLocalizedStringName(L"UnitName_Zetabits"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zetabits"), 27 });
+        UnitConverterUnits::Data_Zetabits, GetLocalizedStringName(L"UnitName_Zetabits"), GetLocalizedStringName(L"UnitAbbreviation_Zetabits"), 27 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_Zetabytes, GetLocalizedStringName(L"UnitName_Zetabytes"),
+    dataUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Zetabytes"), 29 });
+        UnitConverterUnits::Data_Zetabytes, GetLocalizedStringName(L"UnitName_Zetabytes"), GetLocalizedStringName(L"UnitAbbreviation_Zetabytes"), 29 });
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_FloppyDisk, GetLocalizedStringName(L"UnitName_FloppyDisk"),
+    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_FloppyDisk,
-                                     GetLocalizedStringName(L"UnitAbbreviation_FloppyDisk"), 13, false, false, true });
+                                     GetLocalizedStringName(L"UnitName_FloppyDisk"),
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_CD, GetLocalizedStringName(L"UnitName_CD"), GetLocalizedStringName(L"UnitAbbreviation_CD"), 14,
+                                     GetLocalizedStringName(L"UnitAbbreviation_FloppyDisk"),
-                                     false, false, true });
+                                     13,
-    dataUnits.push_back(OrderedUnit{ UnitConverterUnits::Data_DVD, GetLocalizedStringName(L"UnitName_DVD"), GetLocalizedStringName(L"UnitAbbreviation_DVD"), 15,
+                                     false,
-                                     false, false, true });
+                                     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"),
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_BritishThermalUnit,
-                                       GetLocalizedStringName(L"UnitAbbreviation_BritishThermalUnit"), 7 });
+                                       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"),
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_ElectronVolt,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Electron-Volt"), 1 });
+                                       GetLocalizedStringName(L"UnitName_Electron-Volt"),
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_FootPound, GetLocalizedStringName(L"UnitName_Foot-Pound"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Electron-Volt"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Foot-Pound"), 6 });
+                                       1 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Joule, GetLocalizedStringName(L"UnitName_Joule"),
+    energyUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Joule"), 2, true, false, false });
+        UnitConverterUnits::Energy_FootPound, GetLocalizedStringName(L"UnitName_Foot-Pound"), GetLocalizedStringName(L"UnitAbbreviation_Foot-Pound"), 6 });
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilocalorie, GetLocalizedStringName(L"UnitName_Kilocalorie"),
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Joule,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilocalorie"), 5, false, true, false });
+                                       GetLocalizedStringName(L"UnitName_Joule"),
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilojoule, GetLocalizedStringName(L"UnitName_Kilojoule"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Joule"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilojoule"), 3 });
+                                       2,
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Battery, GetLocalizedStringName(L"UnitName_Battery"),
+                                       true,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Battery"), 8, false, false, true });
+                                       false,
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Banana, GetLocalizedStringName(L"UnitName_Banana"),
+                                       false });
-                                       GetLocalizedStringName(L"UnitAbbreviation_Banana"), 9, false, false, true });
+    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_Kilocalorie,
-    energyUnits.push_back(OrderedUnit{ UnitConverterUnits::Energy_SliceOfCake, GetLocalizedStringName(L"UnitName_SliceOfCake"),
+                                       GetLocalizedStringName(L"UnitName_Kilocalorie"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SliceOfCake"), 10, false, false, true });
+                                       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"),
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Centimeter,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Centimeter"), 4, useUSCustomary, useSI, false });
+                                       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"),
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Inch,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Inch"), 7, useSI, useUSCustomary, false });
+                                       GetLocalizedStringName(L"UnitName_Inch"),
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Kilometer, GetLocalizedStringName(L"UnitName_Kilometer"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Inch"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilometer"), 6 });
+                                       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"),
+    lengthUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Millimeter"), 3 });
+        UnitConverterUnits::Length_Millimeter, GetLocalizedStringName(L"UnitName_Millimeter"), GetLocalizedStringName(L"UnitAbbreviation_Millimeter"), 3 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Nanometer, GetLocalizedStringName(L"UnitName_Nanometer"),
+    lengthUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Nanometer"), 1 });
+        UnitConverterUnits::Length_Nanometer, GetLocalizedStringName(L"UnitName_Nanometer"), GetLocalizedStringName(L"UnitAbbreviation_Nanometer"), 1 });
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_NauticalMile, GetLocalizedStringName(L"UnitName_NauticalMile"),
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_NauticalMile,
-                                       GetLocalizedStringName(L"UnitAbbreviation_NauticalMile"), 11 });
+                                       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"),
+    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Paperclip,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Paperclip"), 12, false, false, true });
+                                       GetLocalizedStringName(L"UnitName_Paperclip"),
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_Hand, GetLocalizedStringName(L"UnitName_Hand"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Paperclip"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_Hand"), 13, false, false, true });
+                                       12,
-    lengthUnits.push_back(OrderedUnit{ UnitConverterUnits::Length_JumboJet, GetLocalizedStringName(L"UnitName_JumboJet"),
+                                       false,
-                                       GetLocalizedStringName(L"UnitAbbreviation_JumboJet"), 14, false, false, true });
+                                       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"),
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_BritishThermalUnitPerMinute,
-                                      GetLocalizedStringName(L"UnitAbbreviation_BTUPerMinute"), 5 });
+                                      GetLocalizedStringName(L"UnitName_BTUPerMinute"),
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_FootPoundPerMinute, GetLocalizedStringName(L"UnitName_Foot-PoundPerMinute"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_BTUPerMinute"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Foot-PoundPerMinute"), 4 });
+                                      5 });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horsepower, GetLocalizedStringName(L"UnitName_Horsepower"),
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_FootPoundPerMinute,
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horsepower"), 3, false, true, false });
+                                      GetLocalizedStringName(L"UnitName_Foot-PoundPerMinute"),
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Kilowatt, GetLocalizedStringName(L"UnitName_Kilowatt"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Foot-PoundPerMinute"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Kilowatt"), 2, !useWattInsteadOfKilowatt });
+                                      4 });
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Watt, GetLocalizedStringName(L"UnitName_Watt"),
+    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horsepower,
-                                      GetLocalizedStringName(L"UnitAbbreviation_Watt"), 1, useWattInsteadOfKilowatt });
+                                      GetLocalizedStringName(L"UnitName_Horsepower"),
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_LightBulb, GetLocalizedStringName(L"UnitName_LightBulb"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Horsepower"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_LightBulb"), 6, false, false, true });
+                                      3,
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_Horse, GetLocalizedStringName(L"UnitName_Horse"),
+                                      false,
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horse"), 7, false, false, true });
+                                      true,
-    powerUnits.push_back(OrderedUnit{ UnitConverterUnits::Power_TrainEngine, GetLocalizedStringName(L"UnitName_TrainEngine"),
+                                      false });
-                                      GetLocalizedStringName(L"UnitAbbreviation_TrainEngine"), 8, false, false, true });
+    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"),
+    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesCelsius,
-                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesCelsius"), 1, useFahrenheit, !useFahrenheit, false });
+                                     GetLocalizedStringName(L"UnitName_DegreesCelsius"),
-    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_DegreesFahrenheit, GetLocalizedStringName(L"UnitName_DegreesFahrenheit"),
+                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesCelsius"),
-                                     GetLocalizedStringName(L"UnitAbbreviation_DegreesFahrenheit"), 2, !useFahrenheit, useFahrenheit, false });
+                                     1,
-    tempUnits.push_back(OrderedUnit{ UnitConverterUnits::Temperature_Kelvin, GetLocalizedStringName(L"UnitName_Kelvin"),
+                                     useFahrenheit,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Kelvin"), 3 });
+                                     !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"),
+    timeUnits.push_back(OrderedUnit{
-                                     5, true, false, false });
+        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"),
+    timeUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Microsecond"), 1 });
+        UnitConverterUnits::Time_Microsecond, GetLocalizedStringName(L"UnitName_Microsecond"), GetLocalizedStringName(L"UnitAbbreviation_Microsecond"), 1 });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Millisecond, GetLocalizedStringName(L"UnitName_Millisecond"),
+    timeUnits.push_back(OrderedUnit{
-                                     GetLocalizedStringName(L"UnitAbbreviation_Millisecond"), 2 });
+        UnitConverterUnits::Time_Millisecond, GetLocalizedStringName(L"UnitName_Millisecond"), GetLocalizedStringName(L"UnitAbbreviation_Millisecond"), 2 });
-    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Minute, GetLocalizedStringName(L"UnitName_Minute"),
+    timeUnits.push_back(OrderedUnit{ UnitConverterUnits::Time_Minute,
-                                     GetLocalizedStringName(L"UnitAbbreviation_Minute"), 4, false, true, false });
+                                     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"),
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_CentimetersPerSecond,
-                                      GetLocalizedStringName(L"UnitAbbreviation_CentimetersPerSecond"), 1 });
+                                      GetLocalizedStringName(L"UnitName_CentimetersPerSecond"),
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_FeetPerSecond, GetLocalizedStringName(L"UnitName_FeetPerSecond"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_CentimetersPerSecond"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_FeetPerSecond"), 4 });
+                                      1 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_KilometersPerHour, GetLocalizedStringName(L"UnitName_KilometersPerHour"),
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_FeetPerSecond,
-                                      GetLocalizedStringName(L"UnitAbbreviation_KilometersPerHour"), 3, useUSCustomary, useSI, false });
+                                      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"),
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MetersPerSecond,
-                                      GetLocalizedStringName(L"UnitAbbreviation_MetersPerSecond"), 2 });
+                                      GetLocalizedStringName(L"UnitName_MetersPerSecond"),
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MilesPerHour, GetLocalizedStringName(L"UnitName_MilesPerHour"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_MetersPerSecond"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_MilesPerHour"), 5, useSI, useUSCustomary, false });
+                                      2 });
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Turtle, GetLocalizedStringName(L"UnitName_Turtle"),
+    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_MilesPerHour,
-                                      GetLocalizedStringName(L"UnitAbbreviation_Turtle"), 8, false, false, true });
+                                      GetLocalizedStringName(L"UnitName_MilesPerHour"),
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Horse, GetLocalizedStringName(L"UnitName_Horse"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_MilesPerHour"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Horse"), 9, false, false, true });
+                                      5,
-    speedUnits.push_back(OrderedUnit{ UnitConverterUnits::Speed_Jet, GetLocalizedStringName(L"UnitName_Jet"), GetLocalizedStringName(L"UnitAbbreviation_Jet"),
+                                      useSI,
-                                      10, false, false, true });
+                                      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"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicCentimeter,
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicCentimeter"), 2 });
+                                       GetLocalizedStringName(L"UnitName_CubicCentimeter"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicFoot, GetLocalizedStringName(L"UnitName_CubicFoot"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_CubicCentimeter"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicFoot"), 13 });
+                                       2 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicInch, GetLocalizedStringName(L"UnitName_CubicInch"),
+    volumeUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicInch"), 12 });
+        UnitConverterUnits::Volume_CubicFoot, GetLocalizedStringName(L"UnitName_CubicFoot"), GetLocalizedStringName(L"UnitAbbreviation_CubicFoot"), 13 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicMeter, GetLocalizedStringName(L"UnitName_CubicMeter"),
+    volumeUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicMeter"), 4 });
+        UnitConverterUnits::Volume_CubicInch, GetLocalizedStringName(L"UnitName_CubicInch"), GetLocalizedStringName(L"UnitAbbreviation_CubicInch"), 12 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CubicYard, GetLocalizedStringName(L"UnitName_CubicYard"),
+    volumeUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_CubicYard"), 14 });
+        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"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUK,
-                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUK"), 17 });
+                                       GetLocalizedStringName(L"UnitName_FluidOunceUK"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUS, GetLocalizedStringName(L"UnitName_FluidOunceUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUS"), 7 });
+                                       17 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_GallonUK, GetLocalizedStringName(L"UnitName_GallonUK"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_FluidOunceUS,
-                                       GetLocalizedStringName(L"UnitAbbreviation_GallonUK"), 20 });
+                                       GetLocalizedStringName(L"UnitName_FluidOunceUS"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_GallonUS, GetLocalizedStringName(L"UnitName_GallonUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_FluidOunceUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_GallonUS"), 11 });
+                                       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"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Milliliter,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Milliliter"), 1, useUSCustomary, useSI });
+                                       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"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUS,
-                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUS"), 6 });
+                                       GetLocalizedStringName(L"UnitName_TablespoonUS"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUS, GetLocalizedStringName(L"UnitName_TeaspoonUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUS"), 5, useSI, useUSCustomary && m_currentRegionCode != "GB" });
+                                       6 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_QuartUK, GetLocalizedStringName(L"UnitName_QuartUK"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUS,
-                                       GetLocalizedStringName(L"UnitAbbreviation_QuartUK"), 19 });
+                                       GetLocalizedStringName(L"UnitName_TeaspoonUS"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_QuartUS, GetLocalizedStringName(L"UnitName_QuartUS"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUS"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_QuartUS"), 10 });
+                                       5,
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUK, GetLocalizedStringName(L"UnitName_TeaspoonUK"),
+                                       useSI,
-                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUK"), 15, false, useUSCustomary && m_currentRegionCode == "GB" });
+                                       useUSCustomary && m_currentRegionCode != "GB" });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TablespoonUK, GetLocalizedStringName(L"UnitName_TablespoonUK"),
+    volumeUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_TablespoonUK"), 16 });
+        UnitConverterUnits::Volume_QuartUK, GetLocalizedStringName(L"UnitName_QuartUK"), GetLocalizedStringName(L"UnitAbbreviation_QuartUK"), 19 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_CoffeeCup, GetLocalizedStringName(L"UnitName_CoffeeCup"),
+    volumeUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_CoffeeCup"), 22, false, false, true });
+        UnitConverterUnits::Volume_QuartUS, GetLocalizedStringName(L"UnitName_QuartUS"), GetLocalizedStringName(L"UnitAbbreviation_QuartUS"), 10 });
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_Bathtub, GetLocalizedStringName(L"UnitName_Bathtub"),
+    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_TeaspoonUK,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Bathtub"), 23, false, false, true });
+                                       GetLocalizedStringName(L"UnitName_TeaspoonUK"),
-    volumeUnits.push_back(OrderedUnit{ UnitConverterUnits::Volume_SwimmingPool, GetLocalizedStringName(L"UnitName_SwimmingPool"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_TeaspoonUK"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SwimmingPool"), 24, false, false, true });
+                                       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"),
+    weightUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Centigram"), 3 });
+        UnitConverterUnits::Weight_Centigram, GetLocalizedStringName(L"UnitName_Centigram"), GetLocalizedStringName(L"UnitAbbreviation_Centigram"), 3 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Decigram, GetLocalizedStringName(L"UnitName_Decigram"),
+    weightUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Decigram"), 4 });
+        UnitConverterUnits::Weight_Decigram, GetLocalizedStringName(L"UnitName_Decigram"), GetLocalizedStringName(L"UnitAbbreviation_Decigram"), 4 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Decagram, GetLocalizedStringName(L"UnitName_Decagram"),
+    weightUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Decagram"), 6 });
+        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"),
+    weightUnits.push_back(OrderedUnit{
-                                       GetLocalizedStringName(L"UnitAbbreviation_Hectogram"), 7 });
+        UnitConverterUnits::Weight_Hectogram, GetLocalizedStringName(L"UnitName_Hectogram"), GetLocalizedStringName(L"UnitAbbreviation_Hectogram"), 7 });
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Kilogram, GetLocalizedStringName(L"UnitName_Kilogram"),
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Kilogram,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Kilogram"), 8, useUSCustomary, useSI });
+                                       GetLocalizedStringName(L"UnitName_Kilogram"),
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_LongTon, GetLocalizedStringName(L"UnitName_LongTon"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Kilogram"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_LongTon"), 14 });
+                                       8,
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Milligram, GetLocalizedStringName(L"UnitName_Milligram"),
+                                       useUSCustomary,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Milligram"), 2 });
+                                       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"),
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Pound,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Pound"), 11, useSI, useUSCustomary });
+                                       GetLocalizedStringName(L"UnitName_Pound"),
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_ShortTon, GetLocalizedStringName(L"UnitName_ShortTon"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Pound"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_ShortTon"), 13 });
+                                       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"),
+    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Snowflake,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Snowflake"), 15, false, false, true });
+                                       GetLocalizedStringName(L"UnitName_Snowflake"),
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_SoccerBall, GetLocalizedStringName(L"UnitName_SoccerBall"),
+                                       GetLocalizedStringName(L"UnitAbbreviation_Snowflake"),
-                                       GetLocalizedStringName(L"UnitAbbreviation_SoccerBall"), 16, false, false, true });
+                                       15,
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Elephant, GetLocalizedStringName(L"UnitName_Elephant"),
+                                       false,
-                                       GetLocalizedStringName(L"UnitAbbreviation_Elephant"), 17, false, false, true });
+                                       false,
-    weightUnits.push_back(OrderedUnit{ UnitConverterUnits::Weight_Whale, GetLocalizedStringName(L"UnitName_Whale"),
+                                       true });
-                                       GetLocalizedStringName(L"UnitAbbreviation_Whale"), 18, 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"),
+    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_Atmosphere,
-                                         GetLocalizedStringName(L"UnitAbbreviation_Atmosphere"), 1, true, false, false });
+                                         GetLocalizedStringName(L"UnitName_Atmosphere"),
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_Bar, GetLocalizedStringName(L"UnitName_Bar"),
+                                         GetLocalizedStringName(L"UnitAbbreviation_Atmosphere"),
-                                         GetLocalizedStringName(L"UnitAbbreviation_Bar"), 2, false, true, false });
+                                         1,
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_KiloPascal, GetLocalizedStringName(L"UnitName_KiloPascal"),
+                                         true,
-                                         GetLocalizedStringName(L"UnitAbbreviation_KiloPascal"), 3 });
+                                         false,
-    pressureUnits.push_back(OrderedUnit{ UnitConverterUnits::Pressure_MillimeterOfMercury, GetLocalizedStringName(L"UnitName_MillimeterOfMercury "),
+                                         false });
-                                         GetLocalizedStringName(L"UnitAbbreviation_MillimeterOfMercury "), 4 });
+    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"),
+    pressureUnits.push_back(OrderedUnit{
-                                         GetLocalizedStringName(L"UnitAbbreviation_PSI"), 6, false, false, false });
+        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"),
+    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Degree,
-                                      GetLocalizedStringName(L"UnitAbbreviation_Degree"), 1, true, false, false });
+                                      GetLocalizedStringName(L"UnitName_Degree"),
-    angleUnits.push_back(OrderedUnit{ UnitConverterUnits::Angle_Radian, GetLocalizedStringName(L"UnitName_Radian"),
+                                      GetLocalizedStringName(L"UnitAbbreviation_Degree"),
-                                      GetLocalizedStringName(L"UnitAbbreviation_Radian"), 2, false, true, false });
+                                      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,
+        { ViewMode::Temperature,
-          0.55555555555555555555555555555556, -32, CONVERT_WITH_OFFSET_FIRST },
+          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,
+        { ViewMode::Temperature,
-          459.67, CONVERT_WITH_OFFSET_FIRST },
+          UnitConverterUnits::Temperature_DegreesFahrenheit,
-        { ViewMode::Temperature, UnitConverterUnits::Temperature_Kelvin, UnitConverterUnits::Temperature_DegreesCelsius, 1, -273.15,
+          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,
+            OrderedUnit(
-                        bool isWhimsical = false)
+                int id,
-                : UnitConversionManager::Unit(id, name, abbreviation, isConversionSource, isConversionTarget, isWhimsical), order(order)
+                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,
+            ExplicitUnitConversionData(
-                                       bool offsetFirst = false)
+                CalculatorApp::Common::ViewMode categoryId,
-                : categoryId(categoryId), parentUnitId(parentUnitId), unitId(unitId), UnitConversionManager::ConversionData(ratio, offset, offsetFirst)
+                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
+    else if (
-             && prop != StrDateResultAutomationNamePropertyName && prop != IsDiffInDaysPropertyName)
+        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,
+    m_dateTimeFormatter = LocalizationService::GetInstance()->GetRegionalSettingsAwareDateTimeFormatter(
-                                                                                         ClockIdentifiers::TwentyFourHour); // Clock Identifier is not used
+        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,
+HistoryItemViewModel::HistoryItemViewModel(
-                                           _In_ const shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>>& spCommands)
+    String ^ expression,
-    : m_expression(expression), m_result(result), m_spTokens(spTokens), m_spCommands(spCommands)
+    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,
+    ^ HistoryItemViewModel::GetAccessibleExpressionFromTokens(
-                                                              _In_ String ^ fallbackExpression)
+        _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,
+                HistoryItemViewModel(
-                                     _In_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& spTokens,
+                    Platform::String ^ expression,
-                                     _In_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& spCommands);
+                    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,
+                          ^ GetAccessibleExpressionFromTokens(
-                                                              _In_ Platform::String ^ fallbackExpression);
+                              _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()),
+            auto item = ref new HistoryItemViewModel(
-                                                     (*ritr)->historyItemVector.spTokens, (*ritr)->historyItemVector.spCommands);
+                ref new Platform::String(expression.c_str()),
+                ref new Platform::String(result.c_str()),
+                (*ritr)->historyItemVector.spTokens,
+                (*ritr)->historyItemVector.spCommands);
             historyListVM->Append(item);
         }
     }
@@ -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()),
+    auto item = ref new HistoryItemViewModel(
-                                             newItem->historyItemVector.spTokens, newItem->historyItemVector.spCommands);
+        ref new Platform::String(expression.c_str()),
+        ref new Platform::String(result.c_str()),
+        newItem->historyItemVector.spTokens,
+        newItem->historyItemVector.spCommands);
 
     // check if we have not hit the max items
     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,
+CalculationManager::HISTORYITEM
-                                                                         _In_ ApplicationDataContainer ^ historyContainer)
+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
+    return (
-            && (bool)item.historyItemVector.spTokens);
+        !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,
+            CalculationManager::HISTORYITEM
-                                                                   _In_ Windows::Storage::ApplicationDataContainer ^ historyContainer);
+            DeserializeHistoryItem(_In_ Platform::String ^ historyItemKey, _In_ Windows::Storage::ApplicationDataContainer ^ historyContainer);
             Windows::Storage::ApplicationDataContainer ^ GetHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode);
             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 =
+    String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
-        LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::OpenParenthesisCountAutomationFormat,
+        CalculatorResourceKeys::OpenParenthesisCountAutomationFormat,
-                                                                 m_localizedOpenParenthesisCountChangedAutomationFormat, localizedParenthesisCount.c_str());
+        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,
+void StandardCalculatorViewModel::SetExpressionDisplay(
-                                                       _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
+    _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,
+void StandardCalculatorViewModel::SetHistoryExpressionDisplay(
-                                                              _Inout_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const& commands)
+    _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);
@@ -878,14 +881,25 @@ void StandardCalculatorViewModel::OnPaste(String ^ pastedString, ViewMode mode)
             }
         }
 
-        // Handle exponent and exponent sign (...e+... or ...e-...)
+        // Handle exponent and exponent sign (...e+... or ...e-... or ...e...)
         if (mappedNumOp == NumbersAndOperatorsEnum::Exp)
         {
-            ++it;
+            //Check the following item
-            if (!(MapCharacterToButtonId(*it, canSendNegate) == NumbersAndOperatorsEnum::Add))
+            switch (MapCharacterToButtonId(*(it + 1), canSendNegate))
+            {
+            case NumbersAndOperatorsEnum::Subtract:
             {
                 Command cmdNegate = ConvertToOperatorsEnum(NumbersAndOperatorsEnum::Negate);
                 m_standardCalculatorManager.SendCommand(cmdNegate);
+                ++it;
+            }
+            break;
+            case NumbersAndOperatorsEnum::Add:
+            {
+                //Nothing to do, skip to the next item
+                ++it;
+            }
+            break;
             }
         }
 
@@ -1035,8 +1049,8 @@ void StandardCalculatorViewModel::OnMemoryButtonPressed()
     int windowId = Utils::GetWindowId();
     TraceLogger::GetInstance().InsertIntoMemoryMap(windowId, IsStandard, IsScientific, IsProgrammer);
 
-    String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::MemorySave, m_localizedMemorySavedAutomationFormat,
+    String ^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
-                                                                                     m_DisplayValue->Data());
+        CalculatorResourceKeys::MemorySave, m_localizedMemorySavedAutomationFormat, m_DisplayValue->Data());
 
     Announcement = CalculatorAnnouncement::GetMemoryItemAddedAnnouncement(announcement);
 }
@@ -1149,110 +1163,6 @@ void StandardCalculatorViewModel::OnMemoryClear(_In_ Object ^ memoryItemPosition
     }
 }
 
-Array<unsigned char> ^ StandardCalculatorViewModel::Serialize()
-{
-    DataWriter ^ writer = ref new DataWriter();
-    writer->WriteUInt32(static_cast<UINT32>(m_CurrentAngleType));
-    writer->WriteBoolean(IsFToEChecked);
-    writer->WriteBoolean(IsCurrentViewPinned);
-    writer->WriteUInt32(static_cast<UINT32>(m_standardCalculatorManager.SerializeSavedDegreeMode()));
-
-    // Serialize Memory
-    vector<long> serializedMemory;
-    serializedMemory = m_standardCalculatorManager.GetSerializedMemory();
-    size_t lengthOfSerializedMemory = serializedMemory.size();
-    writer->WriteUInt32(static_cast<UINT32>(lengthOfSerializedMemory));
-    for (auto data : serializedMemory)
-    {
-        writer->WriteInt32(data);
-    }
-
-    // Serialize Primary Display
-    vector<long> serializedPrimaryDisplay = m_standardCalculatorManager.GetSerializedPrimaryDisplay();
-    writer->WriteUInt32(static_cast<UINT32>(serializedPrimaryDisplay.size()));
-    for (auto data : serializedPrimaryDisplay)
-    {
-        writer->WriteInt32(data);
-    }
-
-    // For ProgrammerMode
-    writer->WriteUInt32(static_cast<UINT32>(CurrentRadixType));
-
-    // Serialize commands of calculator manager
-    vector<unsigned char> serializedCommand = m_standardCalculatorManager.SerializeCommands();
-    writer->WriteUInt32(static_cast<UINT32>(serializedCommand.size()));
-    writer->WriteBytes(ref new Array<unsigned char>(serializedCommand.data(), static_cast<unsigned int>(serializedCommand.size())));
-
-    if (IsInError)
-    {
-        Utils::SerializeCommandsAndTokens(m_tokens, m_commands, writer);
-    }
-
-    // Convert viewmodel data in writer to bytes
-    IBuffer ^ buffer = writer->DetachBuffer();
-    DataReader ^ reader = DataReader::FromBuffer(buffer);
-    Platform::Array<unsigned char> ^ viewModelDataAsBytes = ref new Array<unsigned char>(buffer->Length);
-    reader->ReadBytes(viewModelDataAsBytes);
-
-    // Return byte array
-    return viewModelDataAsBytes;
-}
-
-void StandardCalculatorViewModel::Deserialize(Array<unsigned char> ^ state)
-{
-    // Read byte array into a buffer
-    DataWriter ^ writer = ref new DataWriter();
-    writer->WriteBytes(state);
-    IBuffer ^ buffer = writer->DetachBuffer();
-
-    // Read view model data
-    if (buffer->Length != 0)
-    {
-        DataReader ^ reader = DataReader::FromBuffer(buffer);
-        m_CurrentAngleType = ConvertIntegerToNumbersAndOperatorsEnum(reader->ReadUInt32());
-
-        IsFToEChecked = reader->ReadBoolean();
-        IsCurrentViewPinned = reader->ReadBoolean();
-        Command serializedDegreeMode = static_cast<Command>(reader->ReadUInt32());
-
-        m_standardCalculatorManager.SendCommand(serializedDegreeMode);
-
-        // Deserialize Memory
-        UINT32 memoryDataLength = reader->ReadUInt32();
-        vector<long> serializedMemory;
-        for (unsigned int i = 0; i < memoryDataLength; i++)
-        {
-            serializedMemory.push_back(reader->ReadInt32());
-        }
-        m_standardCalculatorManager.DeSerializeMemory(serializedMemory);
-
-        // Serialize Primary Display
-        UINT32 serializedPrimaryDisplayLength = reader->ReadUInt32();
-        vector<long> serializedPrimaryDisplay;
-        for (unsigned int i = 0; i < serializedPrimaryDisplayLength; i++)
-        {
-            serializedPrimaryDisplay.push_back(reader->ReadInt32());
-        }
-        m_standardCalculatorManager.DeSerializePrimaryDisplay(serializedPrimaryDisplay);
-
-        CurrentRadixType = reader->ReadUInt32();
-        // Read command data and Deserialize
-        UINT32 modeldatalength = reader->ReadUInt32();
-        Array<unsigned char> ^ modelDataAsBytes = ref new Array<unsigned char>(modeldatalength);
-        reader->ReadBytes(modelDataAsBytes);
-        m_standardCalculatorManager.DeSerializeCommands(vector<unsigned char>(modelDataAsBytes->begin(), modelDataAsBytes->end()));
-
-        // After recalculation. If there is an error then
-        // IsInError should be set synchronously.
-        if (IsInError)
-        {
-            shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> commandVector = Utils::DeserializeCommands(reader);
-            shared_ptr<CalculatorVector<pair<wstring, int>>> tokenVector = Utils::DeserializeTokens(reader);
-            SetExpressionDisplay(tokenVector, commandVector);
-        }
-    }
-}
-
 void StandardCalculatorViewModel::OnPropertyChanged(String ^ propertyname)
 {
     if (propertyname == IsScientificPropertyName)
@@ -1313,13 +1223,18 @@ void StandardCalculatorViewModel::SetCalculatorType(ViewMode targetState)
     }
 }
 
-Platform::String ^ StandardCalculatorViewModel::GetRawDisplayValue()
+String^ StandardCalculatorViewModel::GetRawDisplayValue()
 {
-    wstring rawValue;
+    if (IsInError)
-
+    {
-    LocalizationSettings::GetInstance().RemoveGroupSeparators(DisplayValue->Data(), DisplayValue->Length(), &rawValue);
+        return DisplayValue;
-
+    }
-    return ref new Platform::String(rawValue.c_str());
+    else
+    {
+        wstring rawValue;
+        LocalizationSettings::GetInstance().RemoveGroupSeparators(DisplayValue->Data(), DisplayValue->Length(), &rawValue);
+        return ref new String(rawValue.c_str());
+    }
 }
 
 // Given a format string, returns a string with the input display value inserted.
@@ -1957,9 +1872,11 @@ NarratorAnnouncement ^ StandardCalculatorViewModel::GetDisplayUpdatedNarratorAnn
     }
     else
     {
-        announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(CalculatorResourceKeys::ButtonPressFeedbackFormat,
+        announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(
-                                                                                m_localizedButtonPressFeedbackAutomationFormat,
+            CalculatorResourceKeys::ButtonPressFeedbackFormat,
-                                                                                m_CalculationResultAutomationName->Data(), m_feedbackForButtonPress->Data());
+            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,
+            void SetExpressionDisplay(
-                                      _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands);
+                _Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
-            void SetHistoryExpressionDisplay(_Inout_ std::shared_ptr<CalculatorVector<std::pair<std::wstring, int>>> const& tokens,
+                _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands);
-                                             _Inout_ std::shared_ptr<CalculatorVector<std::shared_ptr<IExpressionCommand>>> const& commands);
+            void 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();
@@ -346,8 +348,6 @@ namespace CalculatorApp
             void OnBinaryOperatorReceived();
             void OnMemoryItemChanged(unsigned int indexOfMemory);
 
-            Platform::Array<unsigned char> ^ Serialize();
-            void Deserialize(Platform::Array<unsigned char> ^ state);
 
             Platform::String ^ GetLocalizedStringFormat(Platform::String ^ format, Platform::String ^ displayValue);
             void OnPropertyChanged(Platform::String ^ propertyname);

src/CalcViewModel/UnitConverterViewModel.cpp

@@ -122,14 +122,15 @@ UnitConverterViewModel::UnitConverterViewModel(const shared_ptr<UCM::IUnitConver
     , m_isInputBlocked(false)
     , m_CurrencyDataLoadFailed(false)
 {
+    auto localizationService = LocalizationService::GetInstance();
     m_model->SetViewModelCallback(make_shared<UnitConverterVMCallback>(this));
     m_model->SetViewModelCurrencyCallback(make_shared<ViewModelCurrencyCallback>(this));
-    m_decimalFormatter = LocalizationService::GetRegionalSettingsAwareDecimalFormatter();
+    m_decimalFormatter = localizationService->GetRegionalSettingsAwareDecimalFormatter();
     m_decimalFormatter->FractionDigits = 0;
     m_decimalFormatter->IsGrouped = true;
     m_decimalSeparator = LocalizationSettings::GetInstance().GetDecimalSeparator();
 
-    m_currencyFormatter = LocalizationService::GetRegionalSettingsAwareCurrencyFormatter();
+    m_currencyFormatter = localizationService->GetRegionalSettingsAwareCurrencyFormatter();
     m_currencyFormatter->IsGrouped = true;
     m_currencyFormatter->Mode = CurrencyFormatterMode::UseCurrencyCode;
     m_currencyFormatter->ApplyRoundingForCurrency(RoundingAlgorithm::RoundHalfDown);
@@ -463,7 +464,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));
 }
 
@@ -611,52 +613,6 @@ void UnitConverterViewModel::OnPropertyChanged(Platform::String ^ prop)
     }
 }
 
-String ^ UnitConverterViewModel::Serialize()
-{
-    wstringstream out(wstringstream::out);
-    const wchar_t* delimiter = L"[;;;]";
-    out << std::to_wstring(m_resettingTimer) << delimiter;
-    out << std::to_wstring(static_cast<int>(m_value1cp)) << delimiter;
-    out << m_Value1Active << delimiter << m_Value2Active << delimiter;
-    out << m_Value1->Data() << delimiter << m_Value2->Data() << delimiter;
-    out << m_valueFromUnlocalized << delimiter << m_valueToUnlocalized << delimiter << L"[###]";
-    wstring unitConverterSerializedData = m_model->Serialize();
-
-    if (!unitConverterSerializedData.empty())
-    {
-        out << m_model->Serialize() << L"[###]";
-        String ^ serializedData = ref new String(wstring(out.str()).c_str());
-        return serializedData;
-    }
-
-    return nullptr;
-}
-
-void UnitConverterViewModel::Deserialize(Platform::String ^ state)
-{
-    wstring serializedData = wstring(state->Data());
-    vector<wstring> tokens = UCM::UnitConverter::StringToVector(serializedData, L"[###]");
-    assert(tokens.size() >= 2);
-    vector<wstring> viewModelData = UCM::UnitConverter::StringToVector(tokens[0], L"[;;;]");
-    assert(viewModelData.size() == EXPECTEDVIEWMODELDATATOKENS);
-    m_resettingTimer = (viewModelData[0].compare(L"1") == 0);
-    m_value1cp = (ConversionParameter)_wtoi(viewModelData[1].c_str());
-    m_Value1Active = (viewModelData[2].compare(L"1") == 0);
-    m_Value2Active = (viewModelData[3].compare(L"1") == 0);
-    m_Value1 = ref new String(viewModelData[4].c_str());
-    m_Value2 = ref new String(viewModelData[5].c_str());
-    m_valueFromUnlocalized = viewModelData[6];
-    m_valueToUnlocalized = viewModelData[7];
-    wstringstream modelData(wstringstream::out);
-    for (unsigned int i = 1; i < tokens.size(); i++)
-    {
-        modelData << tokens[i] << L"[###]";
-    }
-    m_model->DeSerialize(modelData.str());
-    InitializeView();
-    RaisePropertyChanged(nullptr); // Update since all props have been updated.
-}
-
 // Saving User Preferences of Category and Associated-Units across Sessions.
 void UnitConverterViewModel::SaveUserPreferences()
 {
@@ -1010,12 +966,16 @@ String ^ UnitConverterViewModel::GetLocalizedAutomationName(_In_ String ^ displa
 }
 
 String
-    ^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(_In_ String ^ fromValue, _In_ String ^ fromUnit, _In_ String ^ toValue,
+    ^ UnitConverterViewModel::GetLocalizedConversionResultStringFormat(
-                                                                       _In_ String ^ toUnit)
+        _In_ String ^ fromValue,
+        _In_ String ^ fromUnit,
+        _In_ String ^ toValue,
+        _In_ String ^ toUnit)
 {
-    String ^ localizedString = ref new String(LocalizationStringUtil::GetLocalizedString(m_localizedConversionResultFormat->Data(), fromValue->Data(),
+    String ^ localizedString =
-                                                                                         fromUnit->Data(), toValue->Data(), toUnit->Data())
+        ref new String(LocalizationStringUtil::GetLocalizedString(
-                                                  .c_str());
+                           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,13 +212,13 @@ 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,
+                ^ GetLocalizedConversionResultStringFormat(
-                                                           _In_ Platform::String ^ toUnit);
+                    _In_ Platform::String ^ fromValue,
+                    _In_ Platform::String ^ fromUnit,
+                    _In_ Platform::String ^ toValue,
+                    _In_ Platform::String ^ toUnit);
             void UpdateValue1AutomationName();
             void UpdateValue2AutomationName();
-            Platform::String ^ Serialize();
-            void Deserialize(Platform::String ^ state);
-            void ResetCategoriesAndRatio();
 
             // Saving And Restoring User Preferences of Category and Associated-Units across Sessions.
             void SaveUserPreferences();
@@ -330,7 +335,8 @@ namespace CalculatorApp
         class UnitConverterVMCallback : public UnitConversionManager::IUnitConverterVMCallback
         {
         public:
-            UnitConverterVMCallback(UnitConverterViewModel ^ viewModel) : m_viewModel(viewModel)
+            UnitConverterVMCallback(UnitConverterViewModel ^ viewModel)
+                : m_viewModel(viewModel)
             {
             }
 
@@ -356,7 +362,8 @@ namespace CalculatorApp
         class ViewModelCurrencyCallback : public UnitConversionManager::IViewModelCurrencyCallback
         {
         public:
-            ViewModelCurrencyCallback(UnitConverterViewModel ^ viewModel) : m_viewModel(viewModel)
+            ViewModelCurrencyCallback(UnitConverterViewModel ^ viewModel)
+                : m_viewModel(viewModel)
             {
             }
 

src/Calculator.sln

@@ -9,8 +9,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CalcManager", "CalcManager\
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{3A5DF651-B8A1-45CA-9135-964A6FC7F5D1}"
 	ProjectSection(SolutionItems) = preProject
-		.clang-format = .clang-format
+		..\.clang-format = ..\.clang-format
-		clang-format-all.sh = clang-format-all.sh
 		nuget.config = nuget.config
 	EndProjectSection
 EndProject

src/Calculator/App.xaml

@@ -353,8 +353,7 @@
                 <Setter Property="ZoomMode" Value="Disabled"/>
             </Style>
 
-            <Style x:Key="CalculationResultStyle"
+            <Style x:Key="CalculationResultStyle" TargetType="Controls:CalculationResult">
-                   TargetType="Controls:CalculationResult">
                 <Setter Property="Background" Value="Transparent"/>
                 <Setter Property="Foreground" Value="{ThemeResource SystemControlPageTextBaseHighBrush}"/>
                 <Setter Property="HorizontalAlignment" Value="Stretch"/>
@@ -401,6 +400,7 @@
                                                TextWrapping="NoWrap"/>
                                 </ScrollViewer>
                                 <HyperlinkButton x:Name="ScrollLeft"
+                                                 x:Uid="CalculationResultScrollLeft"
                                                  Grid.Column="0"
                                                  Width="20"
                                                  MinWidth="20"
@@ -412,6 +412,7 @@
                                                  VerticalContentAlignment="Center"
                                                  Foreground="{ThemeResource SystemControlForegroundAccentBrush}"
                                                  BorderThickness="0"
+                                                 AutomationProperties.AutomationId="CalculationResultScrollLeft"
                                                  Visibility="Collapsed">
                                     <FontIcon x:Name="ScrollLeftText"
                                               FontFamily="{ThemeResource SymbolThemeFontFamily}"
@@ -419,6 +420,7 @@
                                               Glyph="&#xE26C;"/>
                                 </HyperlinkButton>
                                 <HyperlinkButton x:Name="ScrollRight"
+                                                 x:Uid="CalculationResultScrollRight"
                                                  Grid.Column="2"
                                                  Width="20"
                                                  MinWidth="20"
@@ -430,6 +432,7 @@
                                                  VerticalContentAlignment="Center"
                                                  Foreground="{ThemeResource SystemControlForegroundAccentBrush}"
                                                  BorderThickness="0"
+                                                 AutomationProperties.AutomationId="CalculationResultScrollRight"
                                                  Visibility="Collapsed">
                                     <FontIcon x:Name="ScrollRightText"
                                               FontFamily="{ThemeResource SymbolThemeFontFamily}"

src/Calculator/App.xaml.cpp

@@ -180,7 +180,6 @@ task<void> App::SetupJumpList()
             ViewMode mode = option->Mode;
             auto item = JumpListItem::CreateWithArguments(((int)mode).ToString(), L"ms-resource:///Resources/" + NavCategory::GetNameResourceKey(mode));
             item->Description = L"ms-resource:///Resources/" + NavCategory::GetNameResourceKey(mode);
-            item->GroupName = L"ms-resource:///Resources/" + NavCategoryGroup::GetHeaderResourceKey(calculatorOptions->GroupType);
             item->Logo = ref new Uri("ms-appx:///Assets/" + mode.ToString() + ".png");
 
             jumpList->Items->Append(item);
@@ -356,9 +355,11 @@ void App::OnAppLaunch(IActivatedEventArgs ^ args, String ^ argument)
                                 auto activatedEventArgs = dynamic_cast<IApplicationViewActivatedEventArgs ^>(args);
                                 if ((activatedEventArgs != nullptr) && (activatedEventArgs->CurrentlyShownApplicationViewId != 0))
                                 {
-                                    create_task(ApplicationViewSwitcher::TryShowAsStandaloneAsync(frameService->GetViewId(), ViewSizePreference::Default,
+                                    create_task(ApplicationViewSwitcher::TryShowAsStandaloneAsync(
-                                                                                                  activatedEventArgs->CurrentlyShownApplicationViewId,
+                                                    frameService->GetViewId(),
-                                                                                                  ViewSizePreference::Default))
+                                                    ViewSizePreference::Default,
+                                                    activatedEventArgs->CurrentlyShownApplicationViewId,
+                                                    ViewSizePreference::Default))
                                         .then(
                                             [safeFrameServiceCreation](bool viewShown) {
                                                 // SafeFrameServiceCreation is used to automatically remove the frame
@@ -385,8 +386,8 @@ void App::OnAppLaunch(IActivatedEventArgs ^ args, String ^ argument)
 
                 if (activationViewSwitcher != nullptr)
                 {
-                    activationViewSwitcher->ShowAsStandaloneAsync(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()),
+                    activationViewSwitcher->ShowAsStandaloneAsync(
-                                                                  ViewSizePreference::Default);
+                        ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()), ViewSizePreference::Default);
                     TraceLogger::GetInstance().LogNewWindowCreationEnd(ApplicationView::GetApplicationViewIdForWindow(CoreWindow::GetForCurrentThread()));
                     TraceLogger::GetInstance().LogPrelaunchedAppActivatedByUser();
                 }

src/Calculator/App.xaml.h

@@ -47,7 +47,9 @@ namespace CalculatorApp
         {
         public:
             SafeFrameWindowCreation(_In_ WindowFrameService ^ frameService, App ^ parent)
-                : m_frameService(frameService), m_frameOpenedInWindow(false), m_parent(parent)
+                : m_frameService(frameService)
+                , m_frameOpenedInWindow(false)
+                , m_parent(parent)
             {
             }
 

src/Calculator/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
+                virtual Windows::Foundation::Collections::IObservableVector<
-                                                                            ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
+                    Platform::Object ^> ^ get() = Windows::UI::Xaml::Data::ICollectionView::CollectionGroups::get
                 {
                     return ref new Platform::Collections::Vector<Platform::Object ^>();
                 }
@@ -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,
+                    this->Dispatcher->RunAsync(Windows::UI::Core::CoreDispatcherPriority::Normal, ref new Windows::UI::Core::DispatchedHandler([this]() {
-                                               ref new Windows::UI::Core::DispatchedHandler([this]() { m_currentChanged(this, nullptr); }));
+                                                   m_currentChanged(this, nullptr);
+                                               }));
                 }
                 return false;
             }
@@ -167,14 +169,14 @@ namespace CalculatorApp
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual unsigned int
+            virtual unsigned int GetMany(
-            GetMany(unsigned int /*startIndex*/,
+                unsigned int /*startIndex*/,
-                    Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
+                Platform::WriteOnlyArray<Platform::Object ^> ^ /*items*/) = Windows::Foundation::Collections::IVector<Platform::Object ^>::GetMany
             {
                 throw ref new Platform::NotImplementedException();
             }
-            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<Platform::Object
+            virtual Windows::Foundation::Collections::IVectorView<Platform::Object ^> ^ GetView() = Windows::Foundation::Collections::IVector<
-                                                                                                                                              ^>::GetView
+                Platform::Object ^>::GetView
             {
                 throw ref new Platform::NotImplementedException();
             }
@@ -263,8 +265,11 @@ namespace CalculatorApp
 
         private:
             virtual Platform::Object
-                ^ Convert(Platform::Object ^ value, Windows::UI::Xaml::Interop::TypeName /*targetType*/, Platform::Object ^ /*parameter*/,
+                ^ Convert(
-                          Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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*/,
+                ^ ConvertBack(
-                              Platform::String ^ /*language*/) = Windows::UI::Xaml::Data::IValueConverter::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/Calculator/Common/AppLifecycleLogger.cpp

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

src/Calculator/Controls/CalculationResult.cpp

@@ -50,7 +50,9 @@ DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, DisplayStringExpression);
 StringReference CalculationResult::s_FocusedState(L"Focused");
 StringReference CalculationResult::s_UnfocusedState(L"Unfocused");
 
-CalculationResult::CalculationResult() : m_isScalingText(false), m_haveCalculatedMax(false)
+CalculationResult::CalculationResult()
+    : m_isScalingText(false)
+    , m_haveCalculatedMax(false)
 {
 }
 

src/Calculator/Controls/CalculationResultAutomationPeer.cpp

@@ -9,7 +9,8 @@ using namespace Windows::UI::Xaml::Automation::Peers;
 
 namespace CalculatorApp::Controls
 {
-    CalculationResultAutomationPeer::CalculationResultAutomationPeer(FrameworkElement ^ owner) : FrameworkElementAutomationPeer(owner)
+    CalculationResultAutomationPeer::CalculationResultAutomationPeer(FrameworkElement ^ owner)
+        : FrameworkElementAutomationPeer(owner)
     {
     }
 

src/Calculator/Controls/OverflowTextBlock.cpp

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

src/Calculator/Controls/OverflowTextBlockAutomationPeer.cpp

@@ -10,7 +10,8 @@ using namespace Windows::Foundation::Collections;
 
 namespace CalculatorApp::Controls
 {
-    OverflowTextBlockAutomationPeer::OverflowTextBlockAutomationPeer(OverflowTextBlock ^ owner) : FrameworkElementAutomationPeer(owner)
+    OverflowTextBlockAutomationPeer::OverflowTextBlockAutomationPeer(OverflowTextBlock ^ owner)
+        : FrameworkElementAutomationPeer(owner)
     {
     }
 

src/Calculator/Converters/BitFlipAutomationNameConverter.h

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

src/Calculator/Converters/BooleanNegationConverter.h

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

src/Calculator/Converters/BooleanToVisibilityConverter.h

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

src/Calculator/Converters/ItemSizeToVisibilityConverter.h

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

src/Calculator/Converters/RadixToStringConverter.h

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

src/Calculator/Converters/VisibilityNegationConverter.h

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

src/Calculator/DesignData/DesignStandardCalculatorViewModel.h

@@ -13,7 +13,9 @@ namespace Numbers
         ref class MemorySlot sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
         public:
-            MemorySlot(int slotPosition, Platform::String ^ value) : m_SlotPosition(slotPosition), m_SlotValue(value)
+            MemorySlot(int slotPosition, Platform::String ^ value)
+                : m_SlotPosition(slotPosition)
+                , m_SlotValue(value)
             {
             }
 
@@ -35,7 +37,10 @@ namespace Numbers
         {
         public:
             StandardCalculatorViewModel()
-                : m_DisplayValue("1234569"), m_DisplayStringExpression("14560 x 1890"), m_DegreeButtonContent("Deg"), m_IsMemoryEmpty(false)
+                : m_DisplayValue("1234569")
+                , m_DisplayStringExpression("14560 x 1890")
+                , m_DegreeButtonContent("Deg")
+                , m_IsMemoryEmpty(false)
             {
                 m_MemorizedNumbers = ref new Platform::Collections::Vector<MemorySlot ^>();
                 for (int i = 1000; i < 1100; i++)

src/Calculator/DesignData/DesignUnitConverterViewModel.h

@@ -21,11 +21,15 @@ namespace Numbers
         ref class CategoryViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
         public:
-            CategoryViewModel(Platform::String ^ name) : m_Name(name), m_NegateVisibility(Windows::UI::Xaml::Visibility::Collapsed)
+            CategoryViewModel(Platform::String ^ name)
+                : m_Name(name)
+                , m_NegateVisibility(Windows::UI::Xaml::Visibility::Collapsed)
             {
             }
 
-            CategoryViewModel(Platform::String ^ name, Windows::UI::Xaml::Visibility negateVisibility) : m_Name(name), m_NegateVisibility(negateVisibility)
+            CategoryViewModel(Platform::String ^ name, Windows::UI::Xaml::Visibility negateVisibility)
+                : m_Name(name)
+                , m_NegateVisibility(negateVisibility)
             {
             }
 
@@ -39,7 +43,9 @@ namespace Numbers
         ref class UnitViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
         public:
-            UnitViewModel(Platform::String ^ unit, Platform::String ^ abbr) : m_Name(unit), m_Abbreviation(abbr)
+            UnitViewModel(Platform::String ^ unit, Platform::String ^ abbr)
+                : m_Name(unit)
+                , m_Abbreviation(abbr)
             {
             }
 
@@ -53,7 +59,8 @@ namespace Numbers
         ref class UnitConverterSupplementaryResultViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
         public:
-            UnitConverterSupplementaryResultViewModel(Platform::String ^ value, Platform::String ^ unit, Platform::String ^ abbr) : m_Value(value)
+            UnitConverterSupplementaryResultViewModel(Platform::String ^ value, Platform::String ^ unit, Platform::String ^ abbr)
+                : m_Value(value)
             {
                 m_Unit = ref new UnitViewModel(unit, abbr);
             }
@@ -68,7 +75,11 @@ namespace Numbers
         ref class UnitConverterViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
         {
         public:
-            UnitConverterViewModel() : m_Value1("Åy24"), m_Value2("Åy183"), m_Value1Active(true), m_Value2Active(false)
+            UnitConverterViewModel()
+                : m_Value1("Åy24")
+                , m_Value2("Åy183")
+                , m_Value1Active(true)
+                , m_Value2Active(false)
             {
                 m_SupplementaryResults = ref new Platform::Collections::Vector<UnitConverterSupplementaryResultViewModel ^>();
                 m_SupplementaryResults->Append(ref new UnitConverterSupplementaryResultViewModel("128", "Kilograms", "Kgs"));

src/Calculator/Resources/af-ZA/Resources.resw

@@ -2907,4 +2907,12 @@
     <value>Microsoft-Dienste-ooreenkoms</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/am-ET/Resources.resw

@@ -901,7 +901,10 @@
     <value>የግራ ቅንፍ</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>የግራ ቅንፍ፣ የክፍት ቅንፍ ቁጥር %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>የቀኝ ቅንፍ</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>የ Microsoft አገልግሎቶች ስምምነት</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>ፒዮንግ</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>ፒዮንግ</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/ar-SA/Resources.resw

@@ -901,7 +901,10 @@
     <value>أقواس يسرى</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>القوس الأيسر، عدد الأقواس المفتوحة %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>أقواس يمنى</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2905,4 +2908,12 @@
     <value>اتفاقية خدمات Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>بيونغ</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>بيونغ</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/az-Latn-AZ/Resources.resw

@@ -901,7 +901,10 @@
     <value>Sol mötərizə</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Sol mötərizə, açıq mötərizənin sayı %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Sağ mötərizə</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Microsoft Xidmət Müqaviləsi</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/be-BY/Resources.resw

@@ -901,7 +901,10 @@
     <value>Левая дужка</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Левая дужка, пачатак адліку дужак (%1)</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Правая дужка</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Пагадненне аб выкарыстанні сэрвісаў Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Пхён</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Пхён</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/bg-BG/Resources.resw

@@ -901,7 +901,10 @@
     <value>Лява скоба</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Лява скоба, брой на отваряща скоба %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Дясна скоба</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Споразумение за услуги на Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/bn-BD/Resources.resw

@@ -2907,4 +2907,12 @@
     <value>Microsoft পরিষেবা চুক্তি</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>পিয়ং</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>পিয়ং</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/ca-ES/Resources.resw

@@ -901,7 +901,10 @@
     <value>Parèntesi d'obertura</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Parèntesi d'obertura, recompte de parèntesis d'obertura %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Parèntesi de tancament</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Contracte de serveis de Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/cs-CZ/Resources.resw

@@ -901,7 +901,10 @@
     <value>Levá závorka</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Levá závorka, počet otevřených závorek %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Pravá závorka</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Smlouva o poskytování služeb společnosti Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/da-DK/Resources.resw

@@ -901,7 +901,10 @@
     <value>Venstreparentes</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Venstre parentes, åben parentes antal %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Højreparentes</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Microsoft-serviceaftale</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/de-DE/Resources.resw

@@ -901,7 +901,10 @@
     <value>Öffnende Klammer</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Runde Klammer links, Anzahl der öffnenden Klammern: %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Schließende Klammer</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Microsoft-Servicevertrag</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>

src/Calculator/Resources/el-GR/Resources.resw

@@ -901,7 +901,10 @@
     <value>Αριστερή παρένθεση</value>
     <comment>Screen reader prompt for the Calculator "(" button on the scientific operator keypad</comment>
   </data>
-  
+  <data name="Format_OpenParenthesisAutomationNamePrefix" xml:space="preserve">
+    <value>Αριστερή παρένθεση, πλήθος ανοιχτών παρενθέσεων %1</value>
+    <comment>{Locked="%1"} Screen reader prompt for the Calculator "(" button on the scientific operator keypad. %1 is the localized count of open parenthesis, e.g. "2".</comment>
+  </data>
   <data name="closeParenthesisButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Δεξιά παρένθεση</value>
     <comment>Screen reader prompt for the Calculator ")" button on the scientific operator keypad</comment>
@@ -2904,4 +2907,12 @@
     <value>Σύμβαση παροχής υπηρεσιών της Microsoft</value>
     <comment>Displayed on a link to the Microsoft Services Agreement in the about this app information</comment>
   </data>
+  <data name="UnitAbbreviation_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>An abbreviation for a measurement unit of area.</comment>
+  </data>
+  <data name="UnitName_Pyeong" xml:space="preserve">
+    <value>Pyeong</value>
+    <comment>A measurement unit for area.</comment>
+  </data>
 </root>