1113ff4b86
Fixed comments that were inconsistent with the style guidelines described in C++ core guidelines and the modern C++/WinRT language projections and removed trailing whitespace. Inserted a space after the beginning of the comment so the text wasn't touching the // on all occurrences. Removed all occurrences of trailing whitespace
373 lines
13 KiB
C++
373 lines
13 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#include "pch.h"
|
|
#include "HistoryViewModel.h"
|
|
#include "Common/TraceLogger.h"
|
|
#include "Common/LocalizationStringUtil.h"
|
|
#include "Common/LocalizationSettings.h"
|
|
|
|
using namespace CalculatorApp;
|
|
using namespace CalculatorApp::Common;
|
|
using namespace CalculatorApp::Common::Automation;
|
|
using namespace CalculatorApp::ViewModel;
|
|
using namespace Platform;
|
|
using namespace std;
|
|
using namespace Windows::Foundation;
|
|
using namespace Windows::Storage;
|
|
using namespace Windows::Storage::Streams;
|
|
using namespace Windows::Security::Cryptography;
|
|
using namespace Windows::Foundation::Collections;
|
|
|
|
static StringReference HistoryVectorLengthKey{ L"HistoryVectorLength" };
|
|
|
|
namespace CalculatorApp::ViewModel::HistoryResourceKeys
|
|
{
|
|
StringReference HistoryCleared(L"HistoryList_Cleared");
|
|
}
|
|
|
|
HistoryViewModel::HistoryViewModel(_In_ CalculationManager::CalculatorManager* calculatorManager) :
|
|
m_calculatorManager(calculatorManager),
|
|
m_localizedHistoryCleared(nullptr)
|
|
{
|
|
AreHistoryShortcutsEnabled = true;
|
|
|
|
Items = ref new Platform::Collections::Vector<HistoryItemViewModel^>();
|
|
ItemSize = 0;
|
|
}
|
|
|
|
void HistoryViewModel::RestoreCompleteHistory()
|
|
{
|
|
RestoreHistory(CalculationManager::CALCULATOR_MODE::CM_STD);
|
|
RestoreHistory(CalculationManager::CALCULATOR_MODE::CM_SCI);
|
|
}
|
|
|
|
// this will reload Items with the history list based on current mode
|
|
void HistoryViewModel::ReloadHistory(_In_ ViewMode currentMode)
|
|
{
|
|
if (currentMode == ViewMode::Standard)
|
|
{
|
|
m_currentMode = CalculationManager::CALCULATOR_MODE::CM_STD;
|
|
}
|
|
else if (currentMode == ViewMode::Scientific)
|
|
{
|
|
m_currentMode = CalculationManager::CALCULATOR_MODE::CM_SCI;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto historyListModel = m_calculatorManager->GetHistoryItems(m_currentMode);
|
|
auto historyListVM = ref new Platform::Collections::Vector<HistoryItemViewModel^>();
|
|
const auto& localizer = LocalizationSettings::GetInstance();
|
|
if (historyListModel.size() > 0)
|
|
{
|
|
for (auto ritr = historyListModel.rbegin(); ritr != historyListModel.rend(); ++ritr)
|
|
{
|
|
wstring expression = (*ritr)->historyItemVector.expression;
|
|
wstring result = (*ritr)->historyItemVector.result;
|
|
localizer.LocalizeDisplayValue(&expression);
|
|
localizer.LocalizeDisplayValue(&result);
|
|
|
|
auto item = ref new HistoryItemViewModel(ref new Platform::String( expression.c_str()),
|
|
ref new Platform::String(result.c_str()),
|
|
(*ritr)->historyItemVector.spTokens, (*ritr)->historyItemVector.spCommands);
|
|
historyListVM->Append(item);
|
|
}
|
|
}
|
|
|
|
Items = historyListVM;
|
|
UpdateItemSize();
|
|
}
|
|
|
|
void HistoryViewModel::OnHistoryItemAdded(_In_ unsigned int addedItemIndex)
|
|
{
|
|
auto newItem = m_calculatorManager->GetHistoryItem(addedItemIndex);
|
|
const auto& localizer = LocalizationSettings::GetInstance();
|
|
wstring expression = newItem->historyItemVector.expression;
|
|
wstring result = newItem->historyItemVector.result;
|
|
localizer.LocalizeDisplayValue(&expression);
|
|
localizer.LocalizeDisplayValue(&result);
|
|
auto item = ref new HistoryItemViewModel(ref new Platform::String(expression.c_str()),
|
|
ref new Platform::String(result.c_str()),
|
|
newItem->historyItemVector.spTokens, newItem->historyItemVector.spCommands );
|
|
|
|
// check if we have not hit the max items
|
|
if (Items->Size >= m_calculatorManager->MaxHistorySize())
|
|
{
|
|
// this means the item already exists
|
|
Items->RemoveAt(Items->Size -1);
|
|
}
|
|
|
|
assert(addedItemIndex <= m_calculatorManager->MaxHistorySize() && addedItemIndex >= 0);
|
|
Items->InsertAt(0, item);
|
|
UpdateItemSize();
|
|
SaveHistory();
|
|
}
|
|
|
|
void HistoryViewModel::SetCalculatorDisplay(CalculatorDisplay &calculatorDisplay)
|
|
{
|
|
WeakReference historyViewModel(this);
|
|
calculatorDisplay.SetHistoryCallback(historyViewModel);
|
|
}
|
|
|
|
void HistoryViewModel::ShowItem(_In_ HistoryItemViewModel^ e)
|
|
{
|
|
HistoryItemClicked(e);
|
|
}
|
|
|
|
void HistoryViewModel::DeleteItem(_In_ HistoryItemViewModel^ e)
|
|
{
|
|
uint32_t itemIndex;
|
|
if (Items->IndexOf(e, &itemIndex))
|
|
{
|
|
if (m_calculatorManager->RemoveHistoryItem(itemIndex))
|
|
{
|
|
// Keys for the history container are index based.
|
|
// SaveHistory() re-inserts the items anyway, so it's faster to just clear out the container.
|
|
CalculationManager::CALCULATOR_MODE currentMode = m_currentMode;
|
|
ApplicationDataContainer^ historyContainer = GetHistoryContainer(currentMode);
|
|
historyContainer->Values->Clear();
|
|
|
|
Items->RemoveAt(itemIndex);
|
|
UpdateItemSize();
|
|
SaveHistory();
|
|
}
|
|
}
|
|
}
|
|
|
|
void HistoryViewModel::OnHideCommand(_In_ Platform::Object^ e)
|
|
{
|
|
// added at VM layer so that the views do not have to individually raise events
|
|
HideHistoryClicked();
|
|
}
|
|
|
|
void HistoryViewModel::OnClearCommand(_In_ Platform::Object^ e)
|
|
{
|
|
TraceLogger::GetInstance().LogClearHistory();
|
|
if (AreHistoryShortcutsEnabled == true)
|
|
{
|
|
m_calculatorManager->ClearHistory();
|
|
|
|
if (Items->Size > 0)
|
|
{
|
|
CalculationManager::CALCULATOR_MODE currentMode = m_currentMode;
|
|
ClearHistoryContainer(currentMode);
|
|
Items->Clear();
|
|
UpdateItemSize();
|
|
}
|
|
|
|
MakeHistoryClearedNarratorAnnouncement(HistoryResourceKeys::HistoryCleared, m_localizedHistoryCleared);
|
|
}
|
|
}
|
|
|
|
// this method restores history vector per mode
|
|
void HistoryViewModel::RestoreHistory(_In_ CalculationManager::CALCULATOR_MODE cMode)
|
|
{
|
|
ApplicationDataContainer^ historyContainer = GetHistoryContainer(cMode);
|
|
std::shared_ptr<std::vector<std::shared_ptr<CalculationManager::HISTORYITEM>>> historyVector = std::make_shared<std::vector<std::shared_ptr<CalculationManager::HISTORYITEM>>>();
|
|
auto historyVectorLength = static_cast<int>(historyContainer->Values->Lookup(HistoryVectorLengthKey));
|
|
bool failure = false;
|
|
|
|
if (historyVectorLength > 0)
|
|
{
|
|
for (int i = 0; i < historyVectorLength; ++i)
|
|
{
|
|
try
|
|
{
|
|
// deserialize each item
|
|
auto item = DeserializeHistoryItem(i.ToString(), historyContainer);
|
|
std::shared_ptr<CalculationManager::HISTORYITEM> Item = std::make_shared<CalculationManager::HISTORYITEM>(item);
|
|
historyVector->push_back(Item);
|
|
}
|
|
catch (Platform::Exception^ e)
|
|
{
|
|
failure = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!failure)
|
|
{
|
|
// if task has been cancelled set history to 0
|
|
m_calculatorManager->SetHistory(cMode, *historyVector);
|
|
|
|
// update length once again for consistency between stored number of items and length
|
|
UpdateHistoryVectorLength(static_cast<int>(historyVector->size()), cMode);
|
|
}
|
|
else
|
|
{
|
|
// in case of failure do not show any item
|
|
UpdateHistoryVectorLength(0, cMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
Platform::String^ HistoryViewModel::GetHistoryContainerKey(_In_ CalculationManager::CALCULATOR_MODE cMode)
|
|
{
|
|
Platform::ValueType^ modeValue = static_cast<int>(cMode);
|
|
return Platform::String::Concat(modeValue->ToString(), L"_History");
|
|
}
|
|
|
|
ApplicationDataContainer^ HistoryViewModel::GetHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode)
|
|
{
|
|
ApplicationDataContainer^ localSettings = ApplicationData::Current->LocalSettings;
|
|
ApplicationDataContainer^ historyContainer;
|
|
|
|
// naming container based on mode
|
|
Platform::String^ historyContainerKey = GetHistoryContainerKey(cMode);
|
|
|
|
if (localSettings->Containers->HasKey(historyContainerKey))
|
|
{
|
|
historyContainer = localSettings->Containers->Lookup(historyContainerKey);
|
|
}
|
|
else
|
|
{
|
|
// create container for adding data
|
|
historyContainer = localSettings->CreateContainer(historyContainerKey, ApplicationDataCreateDisposition::Always);
|
|
int initialHistoryVectorLength = 0;
|
|
historyContainer->Values->Insert(HistoryVectorLengthKey, initialHistoryVectorLength);
|
|
}
|
|
|
|
return historyContainer;
|
|
}
|
|
|
|
void HistoryViewModel::ClearHistoryContainer(_In_ CalculationManager::CALCULATOR_MODE cMode)
|
|
{
|
|
ApplicationDataContainer^ localSettings = ApplicationData::Current->LocalSettings;
|
|
localSettings->DeleteContainer(GetHistoryContainerKey(cMode));
|
|
}
|
|
|
|
// this method will be used to update the history item length
|
|
void HistoryViewModel::UpdateHistoryVectorLength(_In_ int newValue, _In_ CalculationManager::CALCULATOR_MODE cMode)
|
|
{
|
|
ApplicationDataContainer^ historyContainer = GetHistoryContainer(cMode);
|
|
historyContainer->Values->Remove(HistoryVectorLengthKey);
|
|
historyContainer->Values->Insert(HistoryVectorLengthKey, newValue);
|
|
}
|
|
|
|
void HistoryViewModel::ClearHistory()
|
|
{
|
|
ClearHistoryContainer(CalculationManager::CALCULATOR_MODE::CM_STD);
|
|
ClearHistoryContainer(CalculationManager::CALCULATOR_MODE::CM_SCI);
|
|
}
|
|
|
|
void HistoryViewModel::SaveHistory()
|
|
{
|
|
ApplicationDataContainer^ historyContainer = GetHistoryContainer(m_currentMode);
|
|
auto currentHistoryVector = m_calculatorManager->GetHistoryItems(m_currentMode);
|
|
bool failure = false;
|
|
int index = 0;
|
|
Platform::String^ serializedHistoryItem;
|
|
|
|
for (auto iter = currentHistoryVector.begin(); iter != currentHistoryVector.end(); ++iter)
|
|
{
|
|
try
|
|
{
|
|
serializedHistoryItem = SerializeHistoryItem(*iter);
|
|
historyContainer->Values->Insert(index.ToString(), serializedHistoryItem);
|
|
}
|
|
catch (Platform::Exception^)
|
|
{
|
|
failure = true;
|
|
break;
|
|
}
|
|
|
|
++index;
|
|
}
|
|
|
|
if (!failure)
|
|
{
|
|
// insertion is successful
|
|
UpdateHistoryVectorLength(static_cast<int>(currentHistoryVector.size()), m_currentMode);
|
|
}
|
|
else
|
|
{
|
|
UpdateHistoryVectorLength(0, m_currentMode);
|
|
}
|
|
}
|
|
|
|
// this serializes a history item into a base64 encoded string
|
|
Platform::String^ HistoryViewModel::SerializeHistoryItem(_In_ std::shared_ptr<CalculationManager::HISTORYITEM> const &item)
|
|
{
|
|
DataWriter^ writer = ref new DataWriter();
|
|
auto expr = item->historyItemVector.expression;
|
|
auto result = item->historyItemVector.result;
|
|
auto platformExpr = ref new Platform::String(expr.c_str());
|
|
writer->WriteUInt32(writer->MeasureString(platformExpr));
|
|
writer->WriteString(platformExpr);
|
|
auto platformResult = ref new Platform::String(result.c_str());
|
|
writer->WriteUInt32(writer->MeasureString(platformResult));
|
|
writer->WriteString(platformResult);
|
|
|
|
Utils::SerializeCommandsAndTokens(item->historyItemVector.spTokens, item->historyItemVector.spCommands, writer);
|
|
|
|
IBuffer^ buffer = writer->DetachBuffer();
|
|
if (buffer == nullptr)
|
|
{
|
|
throw ref new Platform::Exception(E_POINTER, ref new Platform::String(L"History Item is NULL"));
|
|
}
|
|
|
|
return CryptographicBuffer::EncodeToBase64String(buffer);
|
|
}
|
|
|
|
CalculationManager::HISTORYITEM HistoryViewModel::DeserializeHistoryItem(_In_ Platform::String^ historyItemKey, _In_ ApplicationDataContainer^ historyContainer)
|
|
{
|
|
CalculationManager::HISTORYITEM historyItem;
|
|
if (historyContainer->Values->HasKey(historyItemKey))
|
|
{
|
|
Object^ historyItemValues = historyContainer->Values->Lookup(historyItemKey);
|
|
|
|
if (historyItemValues == nullptr)
|
|
{
|
|
throw ref new Platform::Exception(E_POINTER, ref new Platform::String(L"History Item is NULL"));
|
|
}
|
|
|
|
String^ historyData = safe_cast<Platform::String^>(historyItemValues);
|
|
IBuffer^ buffer = CryptographicBuffer::DecodeFromBase64String(historyData);
|
|
|
|
if (buffer == nullptr)
|
|
{
|
|
throw ref new Platform::Exception(E_POINTER, ref new Platform::String(L"History Item is NULL"));
|
|
}
|
|
|
|
DataReader^ reader = DataReader::FromBuffer(buffer);
|
|
auto exprLen = reader->ReadUInt32();
|
|
auto expression = reader->ReadString(exprLen);
|
|
historyItem.historyItemVector.expression = expression->Data();
|
|
|
|
auto resultLen = reader->ReadUInt32();
|
|
auto result = reader->ReadString(resultLen);
|
|
historyItem.historyItemVector.result = result->Data();
|
|
|
|
historyItem.historyItemVector.spCommands = Utils::DeserializeCommands(reader);
|
|
historyItem.historyItemVector.spTokens = Utils::DeserializeTokens(reader);
|
|
}
|
|
else
|
|
{
|
|
throw ref new Platform::Exception(E_ACCESSDENIED, ref new Platform::String(L"History Item not found"));
|
|
}
|
|
return historyItem;
|
|
}
|
|
|
|
bool HistoryViewModel::IsValid(_In_ CalculationManager::HISTORYITEM item)
|
|
{
|
|
return (!item.historyItemVector.expression.empty() &&
|
|
!item.historyItemVector.result.empty() &&
|
|
(bool)item.historyItemVector.spCommands &&
|
|
(bool)item.historyItemVector.spTokens);
|
|
}
|
|
|
|
void HistoryViewModel::UpdateItemSize()
|
|
{
|
|
ItemSize = Items->Size;
|
|
}
|
|
|
|
void HistoryViewModel::MakeHistoryClearedNarratorAnnouncement(String^ resourceKey, String^& formatVariable)
|
|
{
|
|
String^ announcement = LocalizationStringUtil::GetLocalizedNarratorAnnouncement(resourceKey, formatVariable);
|
|
|
|
HistoryAnnouncement = CalculatorAnnouncement::GetHistoryClearedAnnouncement(announcement);
|
|
}
|