6366e0c535
* Replacing CalculatorVector usage with std::vector Assumptions made here are that memory allocations are not recoverable. If it can be proved that an index will be in range, then the indexing operation is used. If not (without manual checks) the std::vector::at function is used to throw an exception in case of a programmer bug. * Changes based on PR feedback Using auto& in CalculatorCollector::UpdateHistoryExpression so the token.first value is properly updated. Using range for loop to GenerateExpressions. Setting isEditable directly to the result of boolean expression. Using token.second directly instead of creating a separate tokenCommandIndex variable. * Fixing issue with generating expressions strings. A space should not be added before the first item.
472 lines
20 KiB
C++
472 lines
20 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#pragma once
|
|
#include "Common/Automation/NarratorAnnouncement.h"
|
|
#include "Common/DisplayExpressionToken.h"
|
|
#include "Common/CalculatorDisplay.h"
|
|
#include "Common/EngineResourceProvider.h"
|
|
#include "Common/CalculatorButtonUser.h"
|
|
#include "HistoryViewModel.h"
|
|
#include "MemoryItemViewModel.h"
|
|
#include "Common/BitLength.h"
|
|
|
|
namespace CalculatorFunctionalTests
|
|
{
|
|
class HistoryTests;
|
|
}
|
|
|
|
namespace CalculatorUnitTests
|
|
{
|
|
class MultiWindowUnitTests;
|
|
class TimerTests;
|
|
}
|
|
|
|
namespace CalculatorApp
|
|
{
|
|
namespace WS = Windows::System;
|
|
namespace CM = CalculationManager;
|
|
|
|
namespace ViewModel
|
|
{
|
|
#define ASCII_0 48
|
|
public
|
|
delegate void HideMemoryClickedHandler();
|
|
|
|
[Windows::UI::Xaml::Data::Bindable] public ref class StandardCalculatorViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
|
|
{
|
|
public:
|
|
StandardCalculatorViewModel();
|
|
void UpdateOperand(int pos, Platform::String ^ text);
|
|
void UpdatecommandsInRecordingMode();
|
|
int GetNumberBase();
|
|
|
|
OBSERVABLE_OBJECT_CALLBACK(OnPropertyChanged);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, DisplayValue);
|
|
OBSERVABLE_PROPERTY_RW(HistoryViewModel ^, HistoryVM);
|
|
OBSERVABLE_NAMED_PROPERTY_RW(bool, IsInError);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsOperatorCommand);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, DisplayStringExpression);
|
|
OBSERVABLE_PROPERTY_R(Windows::Foundation::Collections::IObservableVector<Common::DisplayExpressionToken ^> ^, ExpressionTokens);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, DecimalDisplayValue);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, HexDisplayValue);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, OctalDisplayValue);
|
|
OBSERVABLE_NAMED_PROPERTY_RW(Platform::String ^, BinaryDisplayValue);
|
|
OBSERVABLE_NAMED_PROPERTY_R(Windows::Foundation::Collections::IVector<bool> ^, BinaryDigits);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, HexDisplayValue_AutomationName);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, DecDisplayValue_AutomationName);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, OctDisplayValue_AutomationName);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, BinDisplayValue_AutomationName);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsBinaryOperatorEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsUnaryOperatorEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsNegateEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsDecimalEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsCurrentViewPinned);
|
|
OBSERVABLE_PROPERTY_RW(Windows::Foundation::Collections::IVector<MemoryItemViewModel ^> ^, MemorizedNumbers);
|
|
OBSERVABLE_NAMED_PROPERTY_RW(bool, IsMemoryEmpty);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsFToEChecked);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsFToEEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, AreHEXButtonsEnabled);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, CalculationResultAutomationName);
|
|
OBSERVABLE_PROPERTY_RW(Platform::String ^, CalculationExpressionAutomationName);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsShiftProgrammerChecked);
|
|
OBSERVABLE_PROPERTY_RW(int, CurrentRadixType);
|
|
OBSERVABLE_PROPERTY_RW(bool, AreTokensUpdated);
|
|
OBSERVABLE_PROPERTY_RW(bool, AreAlwaysOnTopResultsUpdated);
|
|
OBSERVABLE_PROPERTY_RW(bool, AreHistoryShortcutsEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, AreProgrammerRadixOperatorsEnabled);
|
|
OBSERVABLE_PROPERTY_RW(bool, IsInputEmpty);
|
|
OBSERVABLE_PROPERTY_RW(CalculatorApp::Common::Automation::NarratorAnnouncement ^, Announcement);
|
|
OBSERVABLE_PROPERTY_R(unsigned int, OpenParenthesisCount);
|
|
|
|
COMMAND_FOR_METHOD(CopyCommand, StandardCalculatorViewModel::OnCopyCommand);
|
|
COMMAND_FOR_METHOD(PasteCommand, StandardCalculatorViewModel::OnPasteCommand);
|
|
COMMAND_FOR_METHOD(ButtonPressed, StandardCalculatorViewModel::OnButtonPressed);
|
|
COMMAND_FOR_METHOD(ClearMemoryCommand, StandardCalculatorViewModel::OnClearMemoryCommand);
|
|
COMMAND_FOR_METHOD(MemoryItemPressed, StandardCalculatorViewModel::OnMemoryItemPressed);
|
|
COMMAND_FOR_METHOD(MemoryAdd, StandardCalculatorViewModel::OnMemoryAdd);
|
|
COMMAND_FOR_METHOD(MemorySubtract, StandardCalculatorViewModel::OnMemorySubtract);
|
|
|
|
event HideMemoryClickedHandler ^ HideMemoryClicked;
|
|
|
|
property bool IsBitFlipChecked
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isBitFlipChecked;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isBitFlipChecked != value)
|
|
{
|
|
m_isBitFlipChecked = value;
|
|
IsBinaryBitFlippingEnabled = IsProgrammer && m_isBitFlipChecked;
|
|
AreProgrammerRadixOperatorsEnabled = IsProgrammer && !m_isBitFlipChecked;
|
|
RaisePropertyChanged(L"IsBitFlipChecked");
|
|
}
|
|
}
|
|
}
|
|
static property Platform::String
|
|
^ IsBitFlipCheckedPropertyName { Platform::String ^ get() { return Platform::StringReference(L"IsBitFlipChecked"); } }
|
|
|
|
property bool IsBinaryBitFlippingEnabled
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isBinaryBitFlippingEnabled;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isBinaryBitFlippingEnabled != value)
|
|
{
|
|
m_isBinaryBitFlippingEnabled = value;
|
|
RaisePropertyChanged(L"IsBinaryBitFlippingEnabled");
|
|
}
|
|
}
|
|
}
|
|
|
|
property CalculatorApp::Common::BitLength ValueBitLength
|
|
{
|
|
CalculatorApp::Common::BitLength get()
|
|
{
|
|
return m_valueBitLength;
|
|
}
|
|
void set(CalculatorApp::Common::BitLength value);
|
|
}
|
|
|
|
property bool IsStandard
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isStandard;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isStandard != value)
|
|
{
|
|
m_isStandard = value;
|
|
if (value)
|
|
{
|
|
IsScientific = false;
|
|
IsProgrammer = false;
|
|
}
|
|
RaisePropertyChanged(L"IsStandard");
|
|
}
|
|
}
|
|
}
|
|
|
|
property bool IsScientific
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isScientific;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isScientific != value)
|
|
{
|
|
m_isScientific = value;
|
|
if (value)
|
|
{
|
|
IsStandard = false;
|
|
IsProgrammer = false;
|
|
}
|
|
RaisePropertyChanged(L"IsScientific");
|
|
}
|
|
}
|
|
}
|
|
|
|
property bool IsProgrammer
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isProgrammer;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isProgrammer != value)
|
|
{
|
|
m_isProgrammer = value;
|
|
if (!m_isProgrammer)
|
|
{
|
|
IsBitFlipChecked = false;
|
|
}
|
|
IsBinaryBitFlippingEnabled = m_isProgrammer && IsBitFlipChecked;
|
|
AreProgrammerRadixOperatorsEnabled = m_isProgrammer && !IsBitFlipChecked;
|
|
if (value)
|
|
{
|
|
IsStandard = false;
|
|
IsScientific = false;
|
|
}
|
|
RaisePropertyChanged(L"IsProgrammer");
|
|
}
|
|
}
|
|
}
|
|
static property Platform::String
|
|
^ IsProgrammerPropertyName { Platform::String ^ get() { return Platform::StringReference(L"IsProgrammer"); } }
|
|
|
|
property bool IsAlwaysOnTop
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isAlwaysOnTop;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isAlwaysOnTop != value)
|
|
{
|
|
m_isAlwaysOnTop = value;
|
|
RaisePropertyChanged(L"IsAlwaysOnTop");
|
|
}
|
|
}
|
|
}
|
|
|
|
property bool IsEditingEnabled
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isEditingEnabled;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isEditingEnabled != value)
|
|
{
|
|
// Numbers::Common::KeyboardShortcutManager::IsCalculatorInEditingMode = value;
|
|
m_isEditingEnabled = value;
|
|
bool currentEditToggleValue = !m_isEditingEnabled;
|
|
IsBinaryOperatorEnabled = currentEditToggleValue;
|
|
IsUnaryOperatorEnabled = currentEditToggleValue;
|
|
IsOperandEnabled = currentEditToggleValue;
|
|
IsNegateEnabled = currentEditToggleValue;
|
|
IsDecimalEnabled = currentEditToggleValue;
|
|
RaisePropertyChanged(L"IsEditingEnabled");
|
|
}
|
|
}
|
|
}
|
|
|
|
property bool IsEngineRecording
|
|
{
|
|
bool get()
|
|
{
|
|
return m_standardCalculatorManager.IsEngineRecording();
|
|
}
|
|
}
|
|
|
|
property bool IsOperandEnabled
|
|
{
|
|
bool get()
|
|
{
|
|
return m_isOperandEnabled;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
if (m_isOperandEnabled != value)
|
|
{
|
|
m_isOperandEnabled = value;
|
|
IsDecimalEnabled = value;
|
|
AreHEXButtonsEnabled = IsProgrammer;
|
|
IsFToEEnabled = value;
|
|
RaisePropertyChanged(L"IsOperandEnabled");
|
|
}
|
|
}
|
|
}
|
|
|
|
property int TokenPosition
|
|
{
|
|
int get()
|
|
{
|
|
return m_tokenPosition;
|
|
}
|
|
void set(int value)
|
|
{
|
|
m_tokenPosition = value;
|
|
}
|
|
}
|
|
|
|
property Platform::String^ SelectedExpressionLastData
|
|
{
|
|
Platform::String^ get() { return m_selectedExpressionLastData; }
|
|
void set(Platform::String^ value) { m_selectedExpressionLastData = value; }
|
|
}
|
|
|
|
property bool KeyPressed
|
|
{
|
|
bool get()
|
|
{
|
|
return m_keyPressed;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
m_keyPressed = value;
|
|
}
|
|
}
|
|
|
|
property bool IsOperandUpdatedUsingViewModel
|
|
{
|
|
bool get()
|
|
{
|
|
return m_operandUpdated;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
m_operandUpdated = value;
|
|
}
|
|
}
|
|
|
|
property bool IsOperandTextCompletelySelected
|
|
{
|
|
bool get()
|
|
{
|
|
return m_completeTextSelection;
|
|
}
|
|
void set(bool value)
|
|
{
|
|
m_completeTextSelection = value;
|
|
}
|
|
}
|
|
|
|
internal : void OnPaste(Platform::String ^ pastedString);
|
|
void OnCopyCommand(Platform::Object ^ parameter);
|
|
void OnPasteCommand(Platform::Object ^ parameter);
|
|
|
|
NumbersAndOperatorsEnum MapCharacterToButtonId(const wchar_t ch, bool& canSendNegate);
|
|
|
|
// Memory feature related methods. They are internal because they need to called from the MainPage code-behind
|
|
void OnMemoryButtonPressed();
|
|
void OnMemoryItemPressed(Platform::Object ^ memoryItemPosition);
|
|
void OnMemoryAdd(Platform::Object ^ memoryItemPosition);
|
|
void OnMemorySubtract(Platform::Object ^ memoryItemPosition);
|
|
void OnMemoryClear(_In_ Platform::Object ^ memoryItemPosition);
|
|
void OnPinUnpinCommand(Platform::Object ^ parameter);
|
|
|
|
void OnInputChanged();
|
|
void SetPrimaryDisplay(_In_ std::wstring const& displayString, _In_ bool isError);
|
|
void DisplayPasteError();
|
|
void SetTokens(_Inout_ std::shared_ptr<std::vector<std::pair<std::wstring, int>>> const& tokens);
|
|
void SetExpressionDisplay(
|
|
_Inout_ std::shared_ptr<std::vector<std::pair<std::wstring, int>>> const& tokens,
|
|
_Inout_ std::shared_ptr<std::vector<std::shared_ptr<IExpressionCommand>>> const& commands);
|
|
void SetHistoryExpressionDisplay(
|
|
_Inout_ std::shared_ptr<std::vector<std::pair<std::wstring, int>>> const& tokens,
|
|
_Inout_ std::shared_ptr<std::vector<std::shared_ptr<IExpressionCommand>>> const& commands);
|
|
void SetParenthesisCount(_In_ unsigned int parenthesisCount);
|
|
void SetOpenParenthesisCountNarratorAnnouncement();
|
|
void OnNoRightParenAdded();
|
|
void SetNoParenAddedNarratorAnnouncement();
|
|
void OnMaxDigitsReached();
|
|
void OnBinaryOperatorReceived();
|
|
void OnMemoryItemChanged(unsigned int indexOfMemory);
|
|
|
|
Platform::String ^ GetLocalizedStringFormat(Platform::String ^ format, Platform::String ^ displayValue);
|
|
void OnPropertyChanged(Platform::String ^ propertyname);
|
|
void SetCalculatorType(CalculatorApp::Common::ViewMode targetState);
|
|
|
|
Platform::String ^ GetRawDisplayValue();
|
|
void Recalculate(bool fromHistory = false);
|
|
bool IsOperator(CalculationManager::Command cmdenum);
|
|
void FtoEButtonToggled();
|
|
void SwitchProgrammerModeBase(RADIX_TYPE calculatorBase);
|
|
void SetMemorizedNumbersString();
|
|
void SwitchAngleType(NumbersAndOperatorsEnum num);
|
|
void ResetDisplay();
|
|
RADIX_TYPE GetCurrentRadixType()
|
|
{
|
|
return (RADIX_TYPE)m_CurrentRadixType;
|
|
}
|
|
void SetPrecision(int32_t precision);
|
|
void UpdateMaxIntDigits()
|
|
{
|
|
m_standardCalculatorManager.UpdateMaxIntDigits();
|
|
}
|
|
NumbersAndOperatorsEnum GetCurrentAngleType()
|
|
{
|
|
return m_CurrentAngleType;
|
|
}
|
|
|
|
private:
|
|
void SetMemorizedNumbers(const std::vector<std::wstring>& memorizedNumbers);
|
|
void UpdateProgrammerPanelDisplay();
|
|
void HandleUpdatedOperandData(CalculationManager::Command cmdenum);
|
|
NumbersAndOperatorsEnum ConvertIntegerToNumbersAndOperatorsEnum(unsigned int parameter);
|
|
NumbersAndOperatorsEnum m_CurrentAngleType;
|
|
wchar_t m_decimalSeparator;
|
|
CalculatorDisplay m_calculatorDisplay;
|
|
CalculatorApp::EngineResourceProvider m_resourceProvider;
|
|
CalculationManager::CalculatorManager m_standardCalculatorManager;
|
|
Platform::String ^ m_expressionAutomationNameFormat;
|
|
Platform::String ^ m_localizedCalculationResultAutomationFormat;
|
|
Platform::String ^ m_localizedCalculationResultDecimalAutomationFormat;
|
|
Platform::String ^ m_localizedHexaDecimalAutomationFormat;
|
|
Platform::String ^ m_localizedDecimalAutomationFormat;
|
|
Platform::String ^ m_localizedOctalAutomationFormat;
|
|
Platform::String ^ m_localizedBinaryAutomationFormat;
|
|
Platform::String ^ m_localizedMaxDigitsReachedAutomationFormat;
|
|
Platform::String ^ m_localizedButtonPressFeedbackAutomationFormat;
|
|
Platform::String ^ m_localizedMemorySavedAutomationFormat;
|
|
Platform::String ^ m_localizedMemoryItemChangedAutomationFormat;
|
|
Platform::String ^ m_localizedMemoryItemClearedAutomationFormat;
|
|
Platform::String ^ m_localizedMemoryCleared;
|
|
Platform::String ^ m_localizedOpenParenthesisCountChangedAutomationFormat;
|
|
Platform::String ^ m_localizedNoRightParenthesisAddedFormat;
|
|
|
|
bool m_pinned;
|
|
bool m_isOperandEnabled;
|
|
bool m_isEditingEnabled;
|
|
bool m_isStandard;
|
|
bool m_isScientific;
|
|
bool m_isProgrammer;
|
|
bool m_isAlwaysOnTop;
|
|
bool m_isBinaryBitFlippingEnabled;
|
|
bool m_isBitFlipChecked;
|
|
bool m_isRtlLanguage;
|
|
int m_tokenPosition;
|
|
bool m_keyPressed;
|
|
bool m_operandUpdated;
|
|
bool m_completeTextSelection;
|
|
bool m_isLastOperationHistoryLoad;
|
|
CalculatorApp::Common::BitLength m_valueBitLength;
|
|
Platform::String ^ m_selectedExpressionLastData;
|
|
Common::DisplayExpressionToken ^ m_selectedExpressionToken;
|
|
|
|
Platform::String ^ LocalizeDisplayValue(_In_ std::wstring const& displayValue, _In_ bool isError);
|
|
Platform::String
|
|
^ CalculateNarratorDisplayValue(_In_ std::wstring const& displayValue, _In_ Platform::String ^ localizedDisplayValue, _In_ bool isError);
|
|
CalculatorApp::Common::Automation::NarratorAnnouncement ^ GetDisplayUpdatedNarratorAnnouncement();
|
|
Platform::String ^ GetCalculatorExpressionAutomationName();
|
|
Platform::String ^ GetNarratorStringReadRawNumbers(_In_ Platform::String ^ localizedDisplayValue);
|
|
|
|
CalculationManager::Command ConvertToOperatorsEnum(NumbersAndOperatorsEnum operation);
|
|
void DisableButtons(CalculationManager::CommandType selectedExpressionCommandType);
|
|
|
|
Platform::String ^ m_feedbackForButtonPress;
|
|
void OnButtonPressed(Platform::Object ^ parameter);
|
|
void OnClearMemoryCommand(Platform::Object ^ parameter);
|
|
std::wstring AddPadding(std::wstring);
|
|
size_t LengthWithoutPadding(std::wstring);
|
|
|
|
std::shared_ptr<std::vector<std::pair<std::wstring, int>>> m_tokens;
|
|
std::shared_ptr<std::vector<std::shared_ptr<IExpressionCommand>>> m_commands;
|
|
|
|
// Token types
|
|
bool IsUnaryOp(int nOpCode);
|
|
bool IsBinOp(int nOpcode);
|
|
bool IsTrigOp(int nOpCode);
|
|
bool IsOpnd(int nOpCode);
|
|
bool IsRecoverableCommand(int nOpCode);
|
|
|
|
CalculationManager::CommandType GetSelectedTokenType(_In_ unsigned int);
|
|
void SaveEditedCommand(_In_ unsigned int index, _In_ CalculationManager::Command command);
|
|
|
|
bool IsViewPinned();
|
|
void SetViewPinnedState(bool pinned);
|
|
|
|
CalculatorApp::Common::ViewMode GetCalculatorMode();
|
|
|
|
friend class CalculatorDisplay;
|
|
friend class CalculatorFunctionalTests::HistoryTests;
|
|
friend class CalculatorUnitTests::MultiWindowUnitTests;
|
|
friend class CalculatorUnitTests::TimerTests;
|
|
};
|
|
}
|
|
}
|