diff --git a/src/CalcViewModel/ApplicationViewModel.cpp b/src/CalcViewModel/ApplicationViewModel.cpp index 7a54182d..d3bdaa19 100644 --- a/src/CalcViewModel/ApplicationViewModel.cpp +++ b/src/CalcViewModel/ApplicationViewModel.cpp @@ -38,445 +38,445 @@ namespace StringReference CategoriesPropertyName(L"Categories"); StringReference ClearMemoryVisibilityPropertyName(L"ClearMemoryVisibility"); - struct SnapshotHelper - { - static constexpr int SnapshotVersion = 0; + //struct SnapshotHelper + //{ + // static constexpr int SnapshotVersion = 0; - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const ApplicationSnapshot& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"SnapshotVersion", Windows::Data::Json::JsonValue::CreateNumberValue(value.SnapshotVersion)); - jsonObject->SetNamedValue(L"Mode", Windows::Data::Json::JsonValue::CreateNumberValue(value.Mode)); - if (value.StandardCalc.has_value()) - { - jsonObject->SetNamedValue(L"StandardCalculatorSnapshot", SaveSnapshotToJson(*value.StandardCalc)); - } - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const ApplicationSnapshot& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"SnapshotVersion", Windows::Data::Json::JsonValue::CreateNumberValue(value.SnapshotVersion)); + // jsonObject->SetNamedValue(L"Mode", Windows::Data::Json::JsonValue::CreateNumberValue(value.Mode)); + // if (value.StandardCalc.has_value()) + // { + // jsonObject->SetNamedValue(L"StandardCalculatorSnapshot", SaveSnapshotToJson(*value.StandardCalc)); + // } + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const StandardCalculatorSnapshot& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"CalculatorManagerSnapshot", SaveSnapshotToJson(value.CalcManager)); - jsonObject->SetNamedValue(L"PrimaryDisplay", SaveSnapshotToJson(value.PrimaryDisplay)); - if (value.ExpressionDisplay.has_value()) - { - jsonObject->SetNamedValue(L"ExpressionDisplay", SaveSnapshotToJson(*value.ExpressionDisplay)); - } - auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& command : value.DisplayCommands) - { - commandsJsonArray->Append(SaveSnapshotToJson(command)); - } - jsonObject->SetNamedValue(L"DisplayCommands", commandsJsonArray); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const StandardCalculatorSnapshot& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"CalculatorManagerSnapshot", SaveSnapshotToJson(value.CalcManager)); + // jsonObject->SetNamedValue(L"PrimaryDisplay", SaveSnapshotToJson(value.PrimaryDisplay)); + // if (value.ExpressionDisplay.has_value()) + // { + // jsonObject->SetNamedValue(L"ExpressionDisplay", SaveSnapshotToJson(*value.ExpressionDisplay)); + // } + // auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& command : value.DisplayCommands) + // { + // commandsJsonArray->Append(SaveSnapshotToJson(command)); + // } + // jsonObject->SetNamedValue(L"DisplayCommands", commandsJsonArray); + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const PrimaryDisplaySnapshot& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"DisplayValue", Windows::Data::Json::JsonValue::CreateStringValue(value.DisplayValue)); - jsonObject->SetNamedValue(L"IsError", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsError)); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const PrimaryDisplaySnapshot& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"DisplayValue", Windows::Data::Json::JsonValue::CreateStringValue(value.DisplayValue)); + // jsonObject->SetNamedValue(L"IsError", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsError)); + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const ExpressionDisplaySnapshot& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - auto tokensJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& token : value.Tokens) - { - auto tokenJsonArray = ref new Windows::Data::Json::JsonArray(); - tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(token.first.c_str()))); - tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(token.second)); - tokensJsonArray->Append(tokenJsonArray); - } - jsonObject->SetNamedValue(L"Tokens", tokensJsonArray); + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const ExpressionDisplaySnapshot& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // auto tokensJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& token : value.Tokens) + // { + // auto tokenJsonArray = ref new Windows::Data::Json::JsonArray(); + // tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(token.first.c_str()))); + // tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(token.second)); + // tokensJsonArray->Append(tokenJsonArray); + // } + // jsonObject->SetNamedValue(L"Tokens", tokensJsonArray); - auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& command : value.Commands) - { - commandsJsonArray->Append(SaveSnapshotToJson(command)); - } - jsonObject->SetNamedValue(L"Commands", commandsJsonArray); + // auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& command : value.Commands) + // { + // commandsJsonArray->Append(SaveSnapshotToJson(command)); + // } + // jsonObject->SetNamedValue(L"Commands", commandsJsonArray); - return jsonObject; - } + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CalculatorManagerSnapshot& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - if (value.HistoryItems.has_value()) - { - auto historyJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& item : *value.HistoryItems) - { - historyJsonArray->Append(SaveSnapshotToJson(*item)); - } - jsonObject->SetNamedValue(L"HistoryItems", historyJsonArray); - } - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CalculatorManagerSnapshot& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // if (value.HistoryItems.has_value()) + // { + // auto historyJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& item : *value.HistoryItems) + // { + // historyJsonArray->Append(SaveSnapshotToJson(*item)); + // } + // jsonObject->SetNamedValue(L"HistoryItems", historyJsonArray); + // } + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CalculationManager::HISTORYITEM& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"Expression", Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(value.historyItemVector.expression.c_str()))); - jsonObject->SetNamedValue(L"Result", Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(value.historyItemVector.result.c_str()))); + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CalculationManager::HISTORYITEM& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"Expression", Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(value.historyItemVector.expression.c_str()))); + // jsonObject->SetNamedValue(L"Result", Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(value.historyItemVector.result.c_str()))); - auto tokensJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& token : *value.historyItemVector.spTokens) - { - auto tokenJsonArray = ref new Windows::Data::Json::JsonArray(); - tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(token.first.c_str()))); - tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(token.second)); - tokensJsonArray->Append(tokenJsonArray); - } - jsonObject->SetNamedValue(L"Tokens", tokensJsonArray); + // auto tokensJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& token : *value.historyItemVector.spTokens) + // { + // auto tokenJsonArray = ref new Windows::Data::Json::JsonArray(); + // tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateStringValue(ref new Platform::String(token.first.c_str()))); + // tokenJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(token.second)); + // tokensJsonArray->Append(tokenJsonArray); + // } + // jsonObject->SetNamedValue(L"Tokens", tokensJsonArray); - auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& command : *value.historyItemVector.spCommands) - { - commandsJsonArray->Append(SaveSnapshotToJson(command)); - } - jsonObject->SetNamedValue(L"Commands", commandsJsonArray); + // auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& command : *value.historyItemVector.spCommands) + // { + // commandsJsonArray->Append(SaveSnapshotToJson(command)); + // } + // jsonObject->SetNamedValue(L"Commands", commandsJsonArray); - return jsonObject; - } + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const std::shared_ptr& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - auto opndCommand = dynamic_cast(value.get()); - if (opndCommand != nullptr) - { - jsonObject = SaveSnapshotToJson(*opndCommand); - } - auto unaryCommand = dynamic_cast(value.get()); - if (unaryCommand != nullptr) - { - jsonObject = SaveSnapshotToJson(*unaryCommand); - } - auto binaryCommand = dynamic_cast(value.get()); - if (binaryCommand != nullptr) - { - jsonObject = SaveSnapshotToJson(*binaryCommand); - } - auto parenthesesCommand = dynamic_cast(value.get()); - if (parenthesesCommand != nullptr) - { - jsonObject = SaveSnapshotToJson(*parenthesesCommand); - } - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const std::shared_ptr& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // auto opndCommand = dynamic_cast(value.get()); + // if (opndCommand != nullptr) + // { + // jsonObject = SaveSnapshotToJson(*opndCommand); + // } + // auto unaryCommand = dynamic_cast(value.get()); + // if (unaryCommand != nullptr) + // { + // jsonObject = SaveSnapshotToJson(*unaryCommand); + // } + // auto binaryCommand = dynamic_cast(value.get()); + // if (binaryCommand != nullptr) + // { + // jsonObject = SaveSnapshotToJson(*binaryCommand); + // } + // auto parenthesesCommand = dynamic_cast(value.get()); + // if (parenthesesCommand != nullptr) + // { + // jsonObject = SaveSnapshotToJson(*parenthesesCommand); + // } + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const COpndCommand& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); - jsonObject->SetNamedValue(L"IsNegative", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsNegative())); - jsonObject->SetNamedValue(L"IsDecimalPresent", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsDecimalPresent())); - jsonObject->SetNamedValue(L"IsSciFmt", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsSciFmt())); - auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& command : *value.GetCommands()) - { - commandsJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(command)); - } - jsonObject->SetNamedValue(L"Commands", commandsJsonArray); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const COpndCommand& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); + // jsonObject->SetNamedValue(L"IsNegative", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsNegative())); + // jsonObject->SetNamedValue(L"IsDecimalPresent", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsDecimalPresent())); + // jsonObject->SetNamedValue(L"IsSciFmt", Windows::Data::Json::JsonValue::CreateBooleanValue(value.IsSciFmt())); + // auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& command : *value.GetCommands()) + // { + // commandsJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(command)); + // } + // jsonObject->SetNamedValue(L"Commands", commandsJsonArray); + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CUnaryCommand& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); - auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); - for (const auto& command : *value.GetCommands()) - { - commandsJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(command)); - } - jsonObject->SetNamedValue(L"Commands", commandsJsonArray); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CUnaryCommand& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); + // auto commandsJsonArray = ref new Windows::Data::Json::JsonArray(); + // for (const auto& command : *value.GetCommands()) + // { + // commandsJsonArray->Append(Windows::Data::Json::JsonValue::CreateNumberValue(command)); + // } + // jsonObject->SetNamedValue(L"Commands", commandsJsonArray); + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CBinaryCommand& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); - jsonObject->SetNamedValue(L"Command", Windows::Data::Json::JsonValue::CreateNumberValue(value.GetCommand())); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CBinaryCommand& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); + // jsonObject->SetNamedValue(L"Command", Windows::Data::Json::JsonValue::CreateNumberValue(value.GetCommand())); + // return jsonObject; + // } - static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CParentheses& value) - { - auto jsonObject = ref new Windows::Data::Json::JsonObject(); - jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); - jsonObject->SetNamedValue(L"Command", Windows::Data::Json::JsonValue::CreateNumberValue(value.GetCommand())); - return jsonObject; - } + // static Windows::Data::Json::JsonObject ^ SaveSnapshotToJson(const CParentheses& value) + // { + // auto jsonObject = ref new Windows::Data::Json::JsonObject(); + // jsonObject->SetNamedValue(L"CommandType", Windows::Data::Json::JsonValue::CreateNumberValue(static_cast(value.GetCommandType()))); + // jsonObject->SetNamedValue(L"Command", Windows::Data::Json::JsonValue::CreateNumberValue(value.GetCommand())); + // return jsonObject; + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - ApplicationSnapshot applicationSnapshot; - applicationSnapshot.SnapshotVersion = static_cast(jsonObject->GetNamedNumber(L"SnapshotVersion")); - if (applicationSnapshot.SnapshotVersion > SnapshotVersion) - { - return; - } - applicationSnapshot.Mode = static_cast(jsonObject->GetNamedNumber(L"Mode")); - if (jsonObject->HasKey(L"StandardCalculatorSnapshot")) - { - std::optional standardCalculatorSnapshot; - RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"StandardCalculatorSnapshot"), standardCalculatorSnapshot); - if (standardCalculatorSnapshot.has_value()) - { - applicationSnapshot.StandardCalc = std::move(*standardCalculatorSnapshot); - } - else - { - return; - } - } - value = std::move(applicationSnapshot); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // ApplicationSnapshot applicationSnapshot; + // applicationSnapshot.SnapshotVersion = static_cast(jsonObject->GetNamedNumber(L"SnapshotVersion")); + // if (applicationSnapshot.SnapshotVersion > SnapshotVersion) + // { + // return; + // } + // applicationSnapshot.Mode = static_cast(jsonObject->GetNamedNumber(L"Mode")); + // if (jsonObject->HasKey(L"StandardCalculatorSnapshot")) + // { + // std::optional standardCalculatorSnapshot; + // RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"StandardCalculatorSnapshot"), standardCalculatorSnapshot); + // if (standardCalculatorSnapshot.has_value()) + // { + // applicationSnapshot.StandardCalc = std::move(*standardCalculatorSnapshot); + // } + // else + // { + // return; + // } + // } + // value = std::move(applicationSnapshot); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - StandardCalculatorSnapshot standardCalculatorSnapshot; - std::optional calcManagerSnapshot; - RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"CalculatorManagerSnapshot"), calcManagerSnapshot); - if (calcManagerSnapshot.has_value()) - { - standardCalculatorSnapshot.CalcManager = std::move(*calcManagerSnapshot); - } - else - { - return; - } - std::optional primaryDisplaySnapshot; - RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"PrimaryDisplay"), primaryDisplaySnapshot); - if (primaryDisplaySnapshot.has_value()) - { - standardCalculatorSnapshot.PrimaryDisplay = std::move(*primaryDisplaySnapshot); - } - else - { - return; - } - if (jsonObject->HasKey(L"ExpressionDisplay")) - { - std::optional expressionDisplaySnapshot; - RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"ExpressionDisplay"), expressionDisplaySnapshot); - if (expressionDisplaySnapshot.has_value()) - { - standardCalculatorSnapshot.ExpressionDisplay = std::move(*expressionDisplaySnapshot); - } - else - { - return; - } - } - standardCalculatorSnapshot.DisplayCommands = RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"DisplayCommands")); - value = std::move(standardCalculatorSnapshot); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // StandardCalculatorSnapshot standardCalculatorSnapshot; + // std::optional calcManagerSnapshot; + // RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"CalculatorManagerSnapshot"), calcManagerSnapshot); + // if (calcManagerSnapshot.has_value()) + // { + // standardCalculatorSnapshot.CalcManager = std::move(*calcManagerSnapshot); + // } + // else + // { + // return; + // } + // std::optional primaryDisplaySnapshot; + // RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"PrimaryDisplay"), primaryDisplaySnapshot); + // if (primaryDisplaySnapshot.has_value()) + // { + // standardCalculatorSnapshot.PrimaryDisplay = std::move(*primaryDisplaySnapshot); + // } + // else + // { + // return; + // } + // if (jsonObject->HasKey(L"ExpressionDisplay")) + // { + // std::optional expressionDisplaySnapshot; + // RestoreJsonToSnapshot(jsonObject->GetNamedObject(L"ExpressionDisplay"), expressionDisplaySnapshot); + // if (expressionDisplaySnapshot.has_value()) + // { + // standardCalculatorSnapshot.ExpressionDisplay = std::move(*expressionDisplaySnapshot); + // } + // else + // { + // return; + // } + // } + // standardCalculatorSnapshot.DisplayCommands = RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"DisplayCommands")); + // value = std::move(standardCalculatorSnapshot); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - value = PrimaryDisplaySnapshot{ jsonObject->GetNamedString(L"DisplayValue"), jsonObject->GetNamedBoolean(L"IsError") }; - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // value = PrimaryDisplaySnapshot{ jsonObject->GetNamedString(L"DisplayValue"), jsonObject->GetNamedBoolean(L"IsError") }; + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - ExpressionDisplaySnapshot expressionDisplaySnapshot; - expressionDisplaySnapshot.Tokens = RestoreExpressionTokensFromJsonArray(jsonObject->GetNamedArray(L"Tokens")); - if (expressionDisplaySnapshot.Tokens.empty()) - { - return; - } - expressionDisplaySnapshot.Commands = RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"Commands")); - if (expressionDisplaySnapshot.Commands.empty()) - { - return; - } - value = std::move(expressionDisplaySnapshot); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // ExpressionDisplaySnapshot expressionDisplaySnapshot; + // expressionDisplaySnapshot.Tokens = RestoreExpressionTokensFromJsonArray(jsonObject->GetNamedArray(L"Tokens")); + // if (expressionDisplaySnapshot.Tokens.empty()) + // { + // return; + // } + // expressionDisplaySnapshot.Commands = RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"Commands")); + // if (expressionDisplaySnapshot.Commands.empty()) + // { + // return; + // } + // value = std::move(expressionDisplaySnapshot); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - CalculatorManagerSnapshot calcManagerSnapshot; - if (jsonObject->HasKey(L"HistoryItems")) - { - std::vector> historyItems; - auto historyJsonArray = jsonObject->GetNamedArray(L"HistoryItems"); - for (uint32_t i = 0; i < historyJsonArray->Size; ++i) - { - std::optional historyItem; - RestoreJsonToSnapshot(historyJsonArray->GetObjectAt(i), historyItem); - if (historyItem.has_value()) - { - historyItems.push_back(std::make_shared(*historyItem)); - } - else - { - return; - } - } - calcManagerSnapshot.HistoryItems = std::move(historyItems); - } - value = std::move(calcManagerSnapshot); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // CalculatorManagerSnapshot calcManagerSnapshot; + // if (jsonObject->HasKey(L"HistoryItems")) + // { + // std::vector> historyItems; + // auto historyJsonArray = jsonObject->GetNamedArray(L"HistoryItems"); + // for (uint32_t i = 0; i < historyJsonArray->Size; ++i) + // { + // std::optional historyItem; + // RestoreJsonToSnapshot(historyJsonArray->GetObjectAt(i), historyItem); + // if (historyItem.has_value()) + // { + // historyItems.push_back(std::make_shared(*historyItem)); + // } + // else + // { + // return; + // } + // } + // calcManagerSnapshot.HistoryItems = std::move(historyItems); + // } + // value = std::move(calcManagerSnapshot); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - CalculationManager::HISTORYITEM historyItem; - historyItem.historyItemVector.expression = std::wstring(jsonObject->GetNamedString(L"Expression")->Data()); - historyItem.historyItemVector.result = std::wstring(jsonObject->GetNamedString(L"Result")->Data()); - historyItem.historyItemVector.spTokens = - std::make_shared>>(RestoreExpressionTokensFromJsonArray(jsonObject->GetNamedArray(L"Tokens"))); - if (historyItem.historyItemVector.spTokens->empty()) - { - return; - } - historyItem.historyItemVector.spCommands = std::make_shared>>( - RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"Commands"))); - if (historyItem.historyItemVector.spCommands->empty()) - { - return; - } - value = std::move(historyItem); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // CalculationManager::HISTORYITEM historyItem; + // historyItem.historyItemVector.expression = std::wstring(jsonObject->GetNamedString(L"Expression")->Data()); + // historyItem.historyItemVector.result = std::wstring(jsonObject->GetNamedString(L"Result")->Data()); + // historyItem.historyItemVector.spTokens = + // std::make_shared>>(RestoreExpressionTokensFromJsonArray(jsonObject->GetNamedArray(L"Tokens"))); + // if (historyItem.historyItemVector.spTokens->empty()) + // { + // return; + // } + // historyItem.historyItemVector.spCommands = std::make_shared>>( + // RestoreExpressionCommandsFromJsonArray(jsonObject->GetNamedArray(L"Commands"))); + // if (historyItem.historyItemVector.spCommands->empty()) + // { + // return; + // } + // value = std::move(historyItem); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional>& value) - { - auto commandType = static_cast(jsonObject->GetNamedNumber(L"CommandType")); - switch (commandType) - { - case CalculationManager::CommandType::OperandCommand: - { - std::optional opndCommand; - RestoreJsonToSnapshot(jsonObject, opndCommand); - if (opndCommand.has_value()) - { - value = std::make_shared(*opndCommand); - } - break; - } - case CalculationManager::CommandType::UnaryCommand: - { - std::optional unaryCommand; - RestoreJsonToSnapshot(jsonObject, unaryCommand); - if (unaryCommand.has_value()) - { - value = std::make_shared(*unaryCommand); - } - break; - } - case CalculationManager::CommandType::BinaryCommand: - { - std::optional binaryCommand; - RestoreJsonToSnapshot(jsonObject, binaryCommand); - if (binaryCommand.has_value()) - { - value = std::make_shared(*binaryCommand); - } - break; - } - case CalculationManager::CommandType::Parentheses: - { - std::optional parenthesesCommand; - RestoreJsonToSnapshot(jsonObject, parenthesesCommand); - if (parenthesesCommand.has_value()) - { - value = std::make_shared(*parenthesesCommand); - } - break; - } - default: - throw std::logic_error{ "c8cba597-dfec-447a-bd1c-e78a9ffaad95" }; - } - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional>& value) + // { + // auto commandType = static_cast(jsonObject->GetNamedNumber(L"CommandType")); + // switch (commandType) + // { + // case CalculationManager::CommandType::OperandCommand: + // { + // std::optional opndCommand; + // RestoreJsonToSnapshot(jsonObject, opndCommand); + // if (opndCommand.has_value()) + // { + // value = std::make_shared(*opndCommand); + // } + // break; + // } + // case CalculationManager::CommandType::UnaryCommand: + // { + // std::optional unaryCommand; + // RestoreJsonToSnapshot(jsonObject, unaryCommand); + // if (unaryCommand.has_value()) + // { + // value = std::make_shared(*unaryCommand); + // } + // break; + // } + // case CalculationManager::CommandType::BinaryCommand: + // { + // std::optional binaryCommand; + // RestoreJsonToSnapshot(jsonObject, binaryCommand); + // if (binaryCommand.has_value()) + // { + // value = std::make_shared(*binaryCommand); + // } + // break; + // } + // case CalculationManager::CommandType::Parentheses: + // { + // std::optional parenthesesCommand; + // RestoreJsonToSnapshot(jsonObject, parenthesesCommand); + // if (parenthesesCommand.has_value()) + // { + // value = std::make_shared(*parenthesesCommand); + // } + // break; + // } + // default: + // throw std::logic_error{ "c8cba597-dfec-447a-bd1c-e78a9ffaad95" }; + // } + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - auto isNegative = jsonObject->GetNamedBoolean(L"IsNegative"); - auto isDecimalPresent = jsonObject->GetNamedBoolean(L"IsDecimalPresent"); - auto isSciFmt = jsonObject->GetNamedBoolean(L"IsSciFmt"); - std::vector commands; - auto commandsJsonArray = jsonObject->GetNamedArray(L"Commands"); - for (uint32_t i = 0; i < commandsJsonArray->Size; ++i) - { - commands.push_back(static_cast(commandsJsonArray->GetNumberAt(i))); - } - value = COpndCommand(std::make_shared>(std::move(commands)), isNegative, isDecimalPresent, isSciFmt); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // auto isNegative = jsonObject->GetNamedBoolean(L"IsNegative"); + // auto isDecimalPresent = jsonObject->GetNamedBoolean(L"IsDecimalPresent"); + // auto isSciFmt = jsonObject->GetNamedBoolean(L"IsSciFmt"); + // std::vector commands; + // auto commandsJsonArray = jsonObject->GetNamedArray(L"Commands"); + // for (uint32_t i = 0; i < commandsJsonArray->Size; ++i) + // { + // commands.push_back(static_cast(commandsJsonArray->GetNumberAt(i))); + // } + // value = COpndCommand(std::make_shared>(std::move(commands)), isNegative, isDecimalPresent, isSciFmt); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - std::vector commands; - auto commandsJsonArray = jsonObject->GetNamedArray(L"Commands"); - if (commandsJsonArray->Size == 1) - { - value = CUnaryCommand(static_cast(commandsJsonArray->GetNumberAt(0))); - } - else if (commandsJsonArray->Size == 2) - { - value = CUnaryCommand(static_cast(commandsJsonArray->GetNumberAt(0)), static_cast(commandsJsonArray->GetNumberAt(1))); - } - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // std::vector commands; + // auto commandsJsonArray = jsonObject->GetNamedArray(L"Commands"); + // if (commandsJsonArray->Size == 1) + // { + // value = CUnaryCommand(static_cast(commandsJsonArray->GetNumberAt(0))); + // } + // else if (commandsJsonArray->Size == 2) + // { + // value = CUnaryCommand(static_cast(commandsJsonArray->GetNumberAt(0)), static_cast(commandsJsonArray->GetNumberAt(1))); + // } + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - value = CBinaryCommand(static_cast(jsonObject->GetNamedNumber(L"Command"))); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // value = CBinaryCommand(static_cast(jsonObject->GetNamedNumber(L"Command"))); + // } - static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) - { - value = CParentheses(static_cast(jsonObject->GetNamedNumber(L"Command"))); - } + // static void RestoreJsonToSnapshot(Windows::Data::Json::JsonObject ^ jsonObject, std::optional& value) + // { + // value = CParentheses(static_cast(jsonObject->GetNamedNumber(L"Command"))); + // } - static std::vector> RestoreExpressionTokensFromJsonArray(Windows::Data::Json::JsonArray ^ jsonArray) - { - std::vector> tokens; - for (uint32_t i = 0; i < jsonArray->Size; ++i) - { - auto tokenJsonArray = jsonArray->GetArrayAt(i); - if (tokenJsonArray->Size == 2 && tokenJsonArray->GetAt(0)->ValueType == Windows::Data::Json::JsonValueType::String - && tokenJsonArray->GetAt(1)->ValueType == Windows::Data::Json::JsonValueType::Number) - { - tokens.emplace_back(std::wstring(tokenJsonArray->GetAt(0)->GetString()->Data()), static_cast(tokenJsonArray->GetAt(1)->GetNumber())); - } - else - { - return {}; - } - } - return tokens; - } + // static std::vector> RestoreExpressionTokensFromJsonArray(Windows::Data::Json::JsonArray ^ jsonArray) + // { + // std::vector> tokens; + // for (uint32_t i = 0; i < jsonArray->Size; ++i) + // { + // auto tokenJsonArray = jsonArray->GetArrayAt(i); + // if (tokenJsonArray->Size == 2 && tokenJsonArray->GetAt(0)->ValueType == Windows::Data::Json::JsonValueType::String + // && tokenJsonArray->GetAt(1)->ValueType == Windows::Data::Json::JsonValueType::Number) + // { + // tokens.emplace_back(std::wstring(tokenJsonArray->GetAt(0)->GetString()->Data()), static_cast(tokenJsonArray->GetAt(1)->GetNumber())); + // } + // else + // { + // return {}; + // } + // } + // return tokens; + // } - static std::vector> RestoreExpressionCommandsFromJsonArray(Windows::Data::Json::JsonArray ^ jsonArray) - { - std::vector> commands; - for (uint32_t i = 0; i < jsonArray->Size; ++i) - { - std::optional> command; - RestoreJsonToSnapshot(jsonArray->GetObjectAt(i), command); - if (command.has_value()) - { - commands.push_back(*command); - } - else - { - return {}; - } - } - return commands; - } + // static std::vector> RestoreExpressionCommandsFromJsonArray(Windows::Data::Json::JsonArray ^ jsonArray) + // { + // std::vector> commands; + // for (uint32_t i = 0; i < jsonArray->Size; ++i) + // { + // std::optional> command; + // RestoreJsonToSnapshot(jsonArray->GetObjectAt(i), command); + // if (command.has_value()) + // { + // commands.push_back(*command); + // } + // else + // { + // return {}; + // } + // } + // return commands; + // } - static bool IsJsonParsingException(Platform::COMException ^ e) - { - return e->HResult == WEB_E_JSON_VALUE_NOT_FOUND || e->HResult == E_ILLEGAL_METHOD_CALL; - } - }; + // static bool IsJsonParsingException(Platform::COMException ^ e) + // { + // return e->HResult == WEB_E_JSON_VALUE_NOT_FOUND || e->HResult == E_ILLEGAL_METHOD_CALL; + // } + //}; } ApplicationViewModel::ApplicationViewModel() @@ -712,47 +712,47 @@ void ApplicationViewModel::SetDisplayNormalAlwaysOnTopOption() m_mode == ViewMode::Standard && ApplicationView::GetForCurrentView()->IsViewModeSupported(ApplicationViewMode::CompactOverlay) && !IsAlwaysOnTop; } -Windows::Data::Json::JsonObject ^ ApplicationViewModel::SaveApplicationSnapshot() -{ - ApplicationSnapshot applicationSnapshot; - applicationSnapshot.SnapshotVersion = SnapshotHelper::SnapshotVersion; - applicationSnapshot.Mode = static_cast(Mode); - if (m_CalculatorViewModel != nullptr && m_mode == ViewMode::Standard) - { - // Standard calculator is the only supported mode so far. - applicationSnapshot.StandardCalc = m_CalculatorViewModel->GetStandardCalculatorSnapshot(); - } - return SnapshotHelper::SaveSnapshotToJson(applicationSnapshot); -} - -bool ApplicationViewModel::TryRestoreFromSnapshot(Windows::Data::Json::JsonObject ^ jsonObject) -{ - std::optional applicationSnapshot; - try - { - SnapshotHelper::RestoreJsonToSnapshot(jsonObject, applicationSnapshot); - } - catch (Platform::COMException ^ e) - { - if (SnapshotHelper::IsJsonParsingException(e)) - { - return false; - } - throw; - } - - if (applicationSnapshot.has_value()) - { - Mode = static_cast(applicationSnapshot->Mode); - if (applicationSnapshot->StandardCalc.has_value()) - { - if (m_CalculatorViewModel == nullptr) - { - m_CalculatorViewModel = ref new StandardCalculatorViewModel(); - } - m_CalculatorViewModel->SetStandardCalculatorSnapshot(applicationSnapshot->StandardCalc.value()); - } - return true; - } - return false; -} +//Windows::Data::Json::JsonObject ^ ApplicationViewModel::SaveApplicationSnapshot() +//{ +// ApplicationSnapshot applicationSnapshot; +// applicationSnapshot.SnapshotVersion = SnapshotHelper::SnapshotVersion; +// applicationSnapshot.Mode = static_cast(Mode); +// if (m_CalculatorViewModel != nullptr && m_mode == ViewMode::Standard) +// { +// // Standard calculator is the only supported mode so far. +// applicationSnapshot.StandardCalc = m_CalculatorViewModel->GetStandardCalculatorSnapshot(); +// } +// return SnapshotHelper::SaveSnapshotToJson(applicationSnapshot); +//} +// +//bool ApplicationViewModel::TryRestoreFromSnapshot(Windows::Data::Json::JsonObject ^ jsonObject) +//{ +// std::optional applicationSnapshot; +// try +// { +// SnapshotHelper::RestoreJsonToSnapshot(jsonObject, applicationSnapshot); +// } +// catch (Platform::COMException ^ e) +// { +// if (SnapshotHelper::IsJsonParsingException(e)) +// { +// return false; +// } +// throw; +// } +// +// if (applicationSnapshot.has_value()) +// { +// Mode = static_cast(applicationSnapshot->Mode); +// if (applicationSnapshot->StandardCalc.has_value()) +// { +// if (m_CalculatorViewModel == nullptr) +// { +// m_CalculatorViewModel = ref new StandardCalculatorViewModel(); +// } +// m_CalculatorViewModel->SetStandardCalculatorSnapshot(applicationSnapshot->StandardCalc.value()); +// } +// return true; +// } +// return false; +//} diff --git a/src/CalcViewModel/ApplicationViewModel.h b/src/CalcViewModel/ApplicationViewModel.h index 542144fa..992754d5 100644 --- a/src/CalcViewModel/ApplicationViewModel.h +++ b/src/CalcViewModel/ApplicationViewModel.h @@ -16,7 +16,7 @@ namespace CalculatorApp { int SnapshotVersion; int Mode; - std::optional StandardCalc; + //std::optional StandardCalc; }; [Windows::UI::Xaml::Data::Bindable] public ref class ApplicationViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged @@ -103,8 +103,8 @@ namespace CalculatorApp void ToggleAlwaysOnTop(float width, float height); - Windows::Data::Json::JsonObject ^ SaveApplicationSnapshot(); - bool TryRestoreFromSnapshot(Windows::Data::Json::JsonObject ^ jsonObject); + //Windows::Data::Json::JsonObject ^ SaveApplicationSnapshot(); + //bool TryRestoreFromSnapshot(Windows::Data::Json::JsonObject ^ jsonObject); private: bool TryRecoverFromNavigationModeFailure(); diff --git a/src/CalcViewModel/CalcViewModel.vcxproj b/src/CalcViewModel/CalcViewModel.vcxproj index b8869d4b..aedd8d8f 100644 --- a/src/CalcViewModel/CalcViewModel.vcxproj +++ b/src/CalcViewModel/CalcViewModel.vcxproj @@ -338,6 +338,7 @@ + @@ -380,6 +381,7 @@ Create Create + diff --git a/src/CalcViewModel/CalcViewModel.vcxproj.filters b/src/CalcViewModel/CalcViewModel.vcxproj.filters index 46ee7fd0..9de55c39 100644 --- a/src/CalcViewModel/CalcViewModel.vcxproj.filters +++ b/src/CalcViewModel/CalcViewModel.vcxproj.filters @@ -89,6 +89,7 @@ + @@ -203,6 +204,7 @@ + diff --git a/src/CalcViewModel/Snapshots.cpp b/src/CalcViewModel/Snapshots.cpp new file mode 100644 index 00000000..1af643c9 --- /dev/null +++ b/src/CalcViewModel/Snapshots.cpp @@ -0,0 +1,59 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include + +#include "Snapshots.h" + +namespace CalculatorApp::ViewModel +{ + CalcEngineHistoryToken::CalcEngineHistoryToken(Platform::String ^ opCodeName, int cmdIndex) + { + assert(opCodeName != nullptr && "opCodeName is mandatory."); + OpCodeName = opCodeName; + CommandIndex = cmdIndex; + } + + CalcEnginHistoryItem::CalcEnginHistoryItem(const CalculationManager::HISTORYITEM& item) + { + Tokens = ref new Platform::Collections::Vector(); + if (item.historyItemVector.spTokens != nullptr) + { + for (auto& [opCode, cmdIdx] : *item.historyItemVector.spTokens) + { + Tokens->Append(ref new CalcEngineHistoryToken(ref new Platform::String(opCode.c_str()), cmdIdx)); + } + } + Expression = ref new Platform::String(item.historyItemVector.expression.c_str()); + Result = ref new Platform::String(item.historyItemVector.result.c_str()); + } + + CalcManagerSnapshot::CalcManagerSnapshot(const CalculationManager::CalculatorManager& calcMgr) + { + auto& items = calcMgr.GetHistoryItems(); + if (!items.empty()) + { + for (auto& item : items) + { + HistoryItems->Append(ref new CalcEnginHistoryItem(*item)); + } + } + } + + PrimaryDisplaySnapshot::PrimaryDisplaySnapshot(Platform::String ^ display, bool isError) + { + assert(display != nullptr && "display is mandatory"); + DisplayValue = display; + IsError = isError; + } + + ExpressionDisplaySnapshot::ExpressionDisplaySnapshot(const std::vector& tokens) + { + Tokens = ref new Platform::Collections::Vector(); + for (auto& [opCode, cmdIdx] : tokens) + { + Tokens->Append(ref new CalcEngineHistoryToken(ref new Platform::String(opCode.c_str()), cmdIdx)); + } + } +} diff --git a/src/CalcViewModel/Snapshots.h b/src/CalcViewModel/Snapshots.h new file mode 100644 index 00000000..91ee1a44 --- /dev/null +++ b/src/CalcViewModel/Snapshots.h @@ -0,0 +1,69 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "CalcManager/CalculatorManager.h" + +namespace CalculatorApp::ViewModel +{ +public + ref struct CalcEngineHistoryToken sealed + { + property Platform::String ^ OpCodeName; // mandatory + property int CommandIndex; + + internal :; + explicit CalcEngineHistoryToken(Platform::String ^ opCodeName, int cmdIndex); + }; + +public + ref struct CalcEnginHistoryItem sealed + { + property Windows::Foundation::Collections::IVector ^ Tokens; // mandatory + // TODO: commands + property Platform::String ^ Expression; // mandatory + property Platform::String ^ Result; // mandatory + + internal :; + explicit CalcEnginHistoryItem(const CalculationManager::HISTORYITEM& item); + }; + +public + ref struct CalcManagerSnapshot sealed + { + property Windows::Foundation::Collections::IVector ^ HistoryItems; // optional + + internal :; + explicit CalcManagerSnapshot(const CalculationManager::CalculatorManager& calcMgr); + }; + +public + ref struct PrimaryDisplaySnapshot sealed + { + property Platform::String ^ DisplayValue; // mandatory + property bool IsError; + + internal :; + explicit PrimaryDisplaySnapshot(Platform::String ^ display, bool isError); + }; + +public + ref struct ExpressionDisplaySnapshot sealed + { + property Windows::Foundation::Collections::IVector ^ Tokens; + // TODO: commands + + internal :; + using CalcHistoryToken = std::pair; + explicit ExpressionDisplaySnapshot(const std::vector& tokens); + }; + +public + ref struct StandardCalculatorSnapshot sealed + { + property CalcManagerSnapshot ^ CalcManager; // mandatory + property PrimaryDisplaySnapshot ^ PrimaryDisplay; // mandatory + property ExpressionDisplaySnapshot ^ ExpressionDisplay; // optional + // TODO: commands + }; +} diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index 04735680..d39e5848 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -227,7 +227,7 @@ String ^ StandardCalculatorViewModel::CalculateNarratorDisplayValue(_In_ wstring String ^ StandardCalculatorViewModel::GetNarratorStringReadRawNumbers(_In_ String ^ localizedDisplayValue) { wstring ws; - LocalizationSettings^ locSettings = LocalizationSettings::GetInstance(); + LocalizationSettings ^ locSettings = LocalizationSettings::GetInstance(); // Insert a space after each digit in the string, to force Narrator to read them as separate numbers. for (const wchar_t& c : localizedDisplayValue) @@ -386,7 +386,7 @@ void StandardCalculatorViewModel::SetTokens(_Inout_ shared_ptr& newMemorizedNumbers) { - LocalizationSettings^ localizer = LocalizationSettings::GetInstance(); + LocalizationSettings ^ localizer = LocalizationSettings::GetInstance(); if (newMemorizedNumbers.size() == 0) // Memory has been cleared { MemorizedNumbers->Clear(); @@ -1060,8 +1060,8 @@ ButtonInfo StandardCalculatorViewModel::MapCharacterToButtonId(char16 ch) { if (LocalizationSettings::GetInstance()->IsLocalizedDigit(ch)) { - result.buttonId = - NumbersAndOperatorsEnum::Zero + static_cast(ch - LocalizationSettings::GetInstance()->GetDigitSymbolFromEnUsDigit('0')); + result.buttonId = NumbersAndOperatorsEnum::Zero + + static_cast(ch - LocalizationSettings::GetInstance()->GetDigitSymbolFromEnUsDigit('0')); result.canSendNegate = true; } } @@ -1588,7 +1588,7 @@ void StandardCalculatorViewModel::UpdateProgrammerPanelDisplay() binaryDisplayString = m_standardCalculatorManager.GetResultForRadix(2, precision, true); } } - LocalizationSettings^ localizer = LocalizationSettings::GetInstance(); + LocalizationSettings ^ localizer = LocalizationSettings::GetInstance(); binaryDisplayString = AddPadding(binaryDisplayString); localizer->LocalizeDisplayValue(&hexDisplayString); @@ -1787,49 +1787,57 @@ void StandardCalculatorViewModel::SetBitshiftRadioButtonCheckedAnnouncement(Plat Announcement = CalculatorAnnouncement::GetBitShiftRadioButtonCheckedAnnouncement(announcement); } -StandardCalculatorSnapshot StandardCalculatorViewModel::GetStandardCalculatorSnapshot() const +StandardCalculatorSnapshot ^ StandardCalculatorViewModel::GetSnapshot() const { - StandardCalculatorSnapshot snapshot; - auto& historyItems = m_standardCalculatorManager.GetHistoryItems(); - if (!historyItems.empty()) - { - snapshot.CalcManager.HistoryItems = std::move(historyItems); - } - snapshot.PrimaryDisplay = PrimaryDisplaySnapshot{ m_DisplayValue, m_IsInError }; - if (!m_tokens->empty() && !m_commands->empty()) - { - snapshot.ExpressionDisplay = { *m_tokens, *m_commands }; - } - snapshot.DisplayCommands = m_standardCalculatorManager.GetDisplayCommandsSnapshot(); - return snapshot; -} - -void StandardCalculatorViewModel::SetStandardCalculatorSnapshot(const StandardCalculatorSnapshot& snapshot) -{ - if (snapshot.CalcManager.HistoryItems.has_value()) - { - m_standardCalculatorManager.SetHistoryItems(snapshot.CalcManager.HistoryItems.value()); - } - - std::vector commands; - if (snapshot.ExpressionDisplay.has_value() && snapshot.ExpressionDisplay->Tokens.back().first == L"=") - { - commands = GetCommandsFromExpressionCommands(snapshot.ExpressionDisplay->Commands); - } - if (commands.empty() && !snapshot.DisplayCommands.empty()) - { - commands = GetCommandsFromExpressionCommands(snapshot.DisplayCommands); - } - for (const auto& command : commands) - { - m_standardCalculatorManager.SendCommand(static_cast(command)); - } - - if (snapshot.ExpressionDisplay.has_value()) - { - SetExpressionDisplay( - std::make_shared>>(snapshot.ExpressionDisplay->Tokens), - std::make_shared>>(snapshot.ExpressionDisplay->Commands)); - } - SetPrimaryDisplay(snapshot.PrimaryDisplay.DisplayValue, snapshot.PrimaryDisplay.IsError); + auto result = ref new StandardCalculatorSnapshot(); + result->CalcManager = ref new CalcManagerSnapshot(m_standardCalculatorManager); + result->PrimaryDisplay = ref new PrimaryDisplaySnapshot(m_DisplayValue, m_IsInError); + result->ExpressionDisplay = ref new ExpressionDisplaySnapshot(*m_tokens); + return nullptr; } +// StandardCalculatorSnapshot StandardCalculatorViewModel::GetStandardCalculatorSnapshot() const +//{ +// StandardCalculatorSnapshot snapshot; +// auto& historyItems = m_standardCalculatorManager.GetHistoryItems(); +// if (!historyItems.empty()) +// { +// snapshot.CalcManager.HistoryItems = std::move(historyItems); +// } +// snapshot.PrimaryDisplay = PrimaryDisplaySnapshot{ m_DisplayValue, m_IsInError }; +// if (!m_tokens->empty() && !m_commands->empty()) +// { +// snapshot.ExpressionDisplay = { *m_tokens, *m_commands }; +// } +// snapshot.DisplayCommands = m_standardCalculatorManager.GetDisplayCommandsSnapshot(); +// return snapshot; +// } +// +// void StandardCalculatorViewModel::SetStandardCalculatorSnapshot(const StandardCalculatorSnapshot& snapshot) +//{ +// if (snapshot.CalcManager.HistoryItems.has_value()) +// { +// m_standardCalculatorManager.SetHistoryItems(snapshot.CalcManager.HistoryItems.value()); +// } +// +// std::vector commands; +// if (snapshot.ExpressionDisplay.has_value() && snapshot.ExpressionDisplay->Tokens.back().first == L"=") +// { +// commands = GetCommandsFromExpressionCommands(snapshot.ExpressionDisplay->Commands); +// } +// if (commands.empty() && !snapshot.DisplayCommands.empty()) +// { +// commands = GetCommandsFromExpressionCommands(snapshot.DisplayCommands); +// } +// for (const auto& command : commands) +// { +// m_standardCalculatorManager.SendCommand(static_cast(command)); +// } +// +// if (snapshot.ExpressionDisplay.has_value()) +// { +// SetExpressionDisplay( +// std::make_shared>>(snapshot.ExpressionDisplay->Tokens), +// std::make_shared>>(snapshot.ExpressionDisplay->Commands)); +// } +// SetPrimaryDisplay(snapshot.PrimaryDisplay.DisplayValue, snapshot.PrimaryDisplay.IsError); +// } diff --git a/src/CalcViewModel/StandardCalculatorViewModel.h b/src/CalcViewModel/StandardCalculatorViewModel.h index 160a7fe8..93fe41f7 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.h +++ b/src/CalcViewModel/StandardCalculatorViewModel.h @@ -7,11 +7,13 @@ #include "Common/CalculatorDisplay.h" #include "Common/EngineResourceProvider.h" #include "Common/CalculatorButtonUser.h" -#include "HistoryViewModel.h" -#include "MemoryItemViewModel.h" #include "Common/BitLength.h" #include "Common/NumberBase.h" +#include "HistoryViewModel.h" +#include "MemoryItemViewModel.h" +#include "Snapshots.h" + namespace CalculatorUnitTests { class MultiWindowUnitTests; @@ -25,38 +27,40 @@ namespace CalculatorApp namespace ViewModel { #define ASCII_0 48 - public delegate void HideMemoryClickedHandler(); + public + delegate void HideMemoryClickedHandler(); - public value struct ButtonInfo + public + value struct ButtonInfo { CalculatorApp::ViewModel::Common::NumbersAndOperatorsEnum buttonId; bool canSendNegate; }; - struct CalculatorManagerSnapshot - { - std::optional>> HistoryItems; - }; + // struct CalculatorManagerSnapshot + //{ + // std::optional>> HistoryItems; + // }; - struct PrimaryDisplaySnapshot - { - Platform::String ^ DisplayValue; - bool IsError = false; - }; + // struct PrimaryDisplaySnapshot + //{ + // Platform::String ^ DisplayValue; + // bool IsError = false; + // }; - struct ExpressionDisplaySnapshot - { - std::vector> Tokens; - std::vector> Commands; - }; + // struct ExpressionDisplaySnapshot + //{ + // std::vector> Tokens; + // std::vector> Commands; + // }; - struct StandardCalculatorSnapshot - { - CalculatorManagerSnapshot CalcManager; - PrimaryDisplaySnapshot PrimaryDisplay; - std::optional ExpressionDisplay; - std::vector> DisplayCommands; - }; + // struct StandardCalculatorSnapshot + //{ + // CalculatorManagerSnapshot CalcManager; + // PrimaryDisplaySnapshot PrimaryDisplay; + // std::optional ExpressionDisplay; + // std::vector> DisplayCommands; + // }; [Windows::UI::Xaml::Data::Bindable] public ref class StandardCalculatorViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged { @@ -136,7 +140,7 @@ namespace CalculatorApp static property Platform::String ^ IsBitFlipCheckedPropertyName { Platform::String ^ get() { return Platform::StringReference(L"IsBitFlipChecked"); } } - property CalculatorApp::ViewModel::Common::BitLength ValueBitLength + property CalculatorApp::ViewModel::Common::BitLength ValueBitLength { CalculatorApp::ViewModel::Common::BitLength get() { @@ -216,7 +220,7 @@ namespace CalculatorApp static property Platform::String ^ IsProgrammerPropertyName { Platform::String ^ get() { return Platform::StringReference(L"IsProgrammer"); } } - property bool IsEditingEnabled + property bool IsEditingEnabled { bool get() { @@ -265,6 +269,8 @@ namespace CalculatorApp } } + property StandardCalculatorSnapshot ^ Snapshot { StandardCalculatorSnapshot ^ get() { return GetSnapshot(); } } + // Used by unit tests void ResetCalcManager(bool clearMemory); void SendCommandToCalcManager(int command); @@ -284,8 +290,7 @@ namespace CalculatorApp void SwitchAngleType(CalculatorApp::ViewModel::Common::NumbersAndOperatorsEnum num); void FtoEButtonToggled(); - internal: - void OnPaste(Platform::String ^ pastedString); + internal : void OnPaste(Platform::String ^ pastedString); void OnCopyCommand(Platform::Object ^ parameter); void OnPasteCommand(Platform::Object ^ parameter); @@ -307,9 +312,9 @@ namespace CalculatorApp Platform::String ^ GetRawDisplayValue(); void Recalculate(bool fromHistory = false); bool IsOperator(CalculationManager::Command cmdenum); - void SetMemorizedNumbersString(); + void SetMemorizedNumbersString(); void ResetRadixAndUpdateMemory(bool resetRadix); - + void SetPrecision(int32_t precision); void UpdateMaxIntDigits() { @@ -320,10 +325,10 @@ namespace CalculatorApp return m_CurrentAngleType; } - StandardCalculatorSnapshot GetStandardCalculatorSnapshot() const; - void SetStandardCalculatorSnapshot(const StandardCalculatorSnapshot& state); - + // void SetStandardCalculatorSnapshot(const StandardCalculatorSnapshot& state); + private: + StandardCalculatorSnapshot ^ GetSnapshot() const; void SetMemorizedNumbers(const std::vector& memorizedNumbers); void UpdateProgrammerPanelDisplay(); void HandleUpdatedOperandData(CalculationManager::Command cmdenum); @@ -372,8 +377,7 @@ namespace CalculatorApp Common::DisplayExpressionToken ^ m_selectedExpressionToken; Platform::String ^ LocalizeDisplayValue(_In_ std::wstring const& displayValue); - Platform::String - ^ CalculateNarratorDisplayValue(_In_ std::wstring const& displayValue, _In_ Platform::String ^ localizedDisplayValue); + Platform::String ^ CalculateNarratorDisplayValue(_In_ std::wstring const& displayValue, _In_ Platform::String ^ localizedDisplayValue); CalculatorApp::ViewModel::Common::Automation::NarratorAnnouncement ^ GetDisplayUpdatedNarratorAnnouncement(); Platform::String ^ GetCalculatorExpressionAutomationName(); Platform::String ^ GetNarratorStringReadRawNumbers(_In_ Platform::String ^ localizedDisplayValue);