9f01c8168b
Description of the changes: Adjusted some of the values in .clang-format Add clang-format-all.ps1 Fix path to .clang-format in Calculator.sln How changes were validated: Manual.
429 lines
14 KiB
C++
429 lines
14 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#include "pch.h"
|
|
#include "CalculationResult.h"
|
|
#include "CalculationResultAutomationPeer.h"
|
|
#include "CalcViewModel/Common/LocalizationSettings.h"
|
|
|
|
using namespace CalculatorApp;
|
|
using namespace CalculatorApp::Controls;
|
|
using namespace CalculatorApp::Common;
|
|
|
|
using namespace Platform;
|
|
using namespace Windows::Devices::Input;
|
|
using namespace Windows::Foundation;
|
|
using namespace Windows::Foundation::Collections;
|
|
using namespace Windows::UI::Xaml;
|
|
using namespace Windows::UI::Xaml::Controls;
|
|
using namespace Windows::UI::Xaml::Controls::Primitives;
|
|
using namespace Windows::UI::Xaml::Data;
|
|
using namespace Windows::UI::Xaml::Input;
|
|
using namespace Windows::UI::Xaml::Media;
|
|
using namespace Windows::UI::Xaml::Navigation;
|
|
using namespace Windows::UI::Xaml::Automation;
|
|
using namespace Windows::UI::Xaml::Automation::Peers;
|
|
using namespace std;
|
|
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, IsActive);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, AccentColor);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, MinFontSize);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, MaxFontSize);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, DisplayMargin);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, MaxExpressionHistoryCharacters);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, ExpressionVisibility);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, DisplayValue);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, IsInError);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, IsOperatorCommand);
|
|
DEPENDENCY_PROPERTY_INITIALIZATION(CalculationResult, DisplayStringExpression);
|
|
|
|
#define SCALEFACTOR 0.357143
|
|
#define SMALLHEIGHTSCALEFACTOR 0
|
|
#define HEIGHTCUTOFF 100
|
|
#define INCREMENTOFFSET 1
|
|
#define MAXFONTINCREMENT 5
|
|
#define WIDTHTOFONTSCALAR 0.0556513
|
|
#define WIDTHTOFONTOFFSET 3
|
|
#define WIDTHCUTOFF 50
|
|
#define FONTTOLERANCE 0.001
|
|
|
|
StringReference CalculationResult::s_FocusedState(L"Focused");
|
|
StringReference CalculationResult::s_UnfocusedState(L"Unfocused");
|
|
|
|
CalculationResult::CalculationResult()
|
|
: m_isScalingText(false)
|
|
, m_haveCalculatedMax(false)
|
|
{
|
|
}
|
|
|
|
Platform::String ^ CalculationResult::GetRawDisplayValue()
|
|
{
|
|
std::wstring rawValue;
|
|
|
|
LocalizationSettings::GetInstance().RemoveGroupSeparators(DisplayValue->Data(), DisplayValue->Length(), &rawValue);
|
|
|
|
return ref new Platform::String(rawValue.c_str());
|
|
}
|
|
|
|
void CalculationResult::OnApplyTemplate()
|
|
{
|
|
assert((m_scrollLeft == nullptr && m_scrollRight == nullptr) || (m_scrollLeft != nullptr && m_scrollRight != nullptr));
|
|
if (m_textContainer)
|
|
{
|
|
m_textContainer->LayoutUpdated -= m_textContainerLayoutChangedToken;
|
|
}
|
|
m_textContainer = dynamic_cast<ScrollViewer ^>(GetTemplateChild("TextContainer"));
|
|
if (m_textContainer)
|
|
{
|
|
m_textContainer->SizeChanged += ref new SizeChangedEventHandler(this, &CalculationResult::TextContainerSizeChanged);
|
|
// We want to know when the size of the container changes so
|
|
// we can rescale the textbox
|
|
m_textContainerLayoutChangedToken = m_textContainer->LayoutUpdated +=
|
|
ref new EventHandler<Object ^>(this, &CalculationResult::OnTextContainerLayoutUpdated);
|
|
|
|
m_textContainer->ChangeView(m_textContainer->ExtentWidth - m_textContainer->ViewportWidth, nullptr, nullptr);
|
|
m_scrollLeft = dynamic_cast<HyperlinkButton ^>(GetTemplateChild("ScrollLeft"));
|
|
m_scrollRight = dynamic_cast<HyperlinkButton ^>(GetTemplateChild("ScrollRight"));
|
|
auto borderContainer = dynamic_cast<UIElement ^>(GetTemplateChild("Border"));
|
|
if (m_scrollLeft && m_scrollRight)
|
|
{
|
|
m_scrollLeft->Click += ref new RoutedEventHandler(this, &CalculationResult::OnScrollClick);
|
|
m_scrollRight->Click += ref new RoutedEventHandler(this, &CalculationResult::OnScrollClick);
|
|
borderContainer->PointerEntered += ref new PointerEventHandler(this, &CalculationResult::OnPointerEntered);
|
|
borderContainer->PointerExited += ref new PointerEventHandler(this, &CalculationResult::OnPointerExited);
|
|
}
|
|
m_textBlock = dynamic_cast<TextBlock ^>(m_textContainer->FindName("NormalOutput"));
|
|
if (m_textBlock)
|
|
{
|
|
m_textBlock->Visibility = ::Visibility::Visible;
|
|
}
|
|
}
|
|
UpdateAllState();
|
|
VisualStateManager::GoToState(this, s_UnfocusedState, false);
|
|
}
|
|
|
|
void CalculationResult::OnPointerPressed(PointerRoutedEventArgs ^ e)
|
|
{
|
|
if (m_scrollLeft && m_scrollRight && e->Pointer->PointerDeviceType == PointerDeviceType::Touch)
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnTextContainerLayoutUpdated(Object ^ /*sender*/, Object ^ /*e*/)
|
|
{
|
|
if (m_isScalingText)
|
|
{
|
|
UpdateTextState();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::TextContainerSizeChanged(Object ^ /*sender*/, SizeChangedEventArgs ^ /*e*/)
|
|
{
|
|
UpdateTextState();
|
|
}
|
|
|
|
void CalculationResult::OnIsActivePropertyChanged(bool /*oldValue*/, bool /*newValue */)
|
|
{
|
|
UpdateVisualState();
|
|
}
|
|
|
|
void CalculationResult::OnAccentColorPropertyChanged(Brush ^ /*oldValue*/, Brush ^ /*newValue*/)
|
|
{
|
|
// Force the "Active" transition to happen again
|
|
if (IsActive)
|
|
{
|
|
VisualStateManager::GoToState(this, "Normal", true);
|
|
VisualStateManager::GoToState(this, "Active", true);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnDisplayValuePropertyChanged(String ^ /*oldValue*/, String ^ /*newValue*/)
|
|
{
|
|
UpdateTextState();
|
|
}
|
|
|
|
void CalculationResult::OnMinFontSizePropertyChanged(double /*oldValue*/, double /*newValue*/)
|
|
{
|
|
UpdateTextState();
|
|
}
|
|
|
|
void CalculationResult::OnMaxFontSizePropertyChanged(double /*oldValue*/, double /*newValue*/)
|
|
{
|
|
UpdateTextState();
|
|
}
|
|
|
|
void CalculationResult::OnIsInErrorPropertyChanged(bool /*oldValue*/, bool newValue)
|
|
{
|
|
// We need to have a good template for this to work
|
|
if (m_textBlock == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (newValue)
|
|
{
|
|
// If there's an error message we need to override the normal display font
|
|
// with the font appropriate for this language. This is because the error
|
|
// message is localized and therefore can contain characters that are not
|
|
// available in the normal font.
|
|
// We use UIText as the font type because this is the most common font type to use
|
|
m_textBlock->FontFamily = LocalizationService::GetInstance()->GetLanguageFontFamilyForType(LanguageFontType::UIText);
|
|
}
|
|
else
|
|
{
|
|
// The error result is no longer an error so we will restore the
|
|
// value to FontFamily property to the value provided in the style
|
|
// for the TextBlock in the template.
|
|
m_textBlock->ClearValue(TextBlock::FontFamilyProperty);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::UpdateVisualState()
|
|
{
|
|
if (IsActive)
|
|
{
|
|
VisualStateManager::GoToState(this, "Active", true);
|
|
}
|
|
else
|
|
{
|
|
VisualStateManager::GoToState(this, "Normal", true);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::UpdateTextState()
|
|
{
|
|
if ((m_textContainer == nullptr) || (m_textBlock == nullptr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
auto containerSize = m_textContainer->ActualWidth;
|
|
String ^ oldText = m_textBlock->Text;
|
|
String ^ newText = Utils::LRO + DisplayValue + Utils::PDF;
|
|
|
|
// Initiate the scaling operation
|
|
// UpdateLayout will keep calling us until we make it through the below 2 if-statements
|
|
if (!m_isScalingText || oldText != newText)
|
|
{
|
|
m_textBlock->Text = newText;
|
|
|
|
m_isScalingText = true;
|
|
m_haveCalculatedMax = false;
|
|
m_textBlock->InvalidateArrange();
|
|
return;
|
|
}
|
|
if (containerSize > 0)
|
|
{
|
|
double widthDiff = abs(m_textBlock->ActualWidth - containerSize);
|
|
double fontSizeChange = INCREMENTOFFSET;
|
|
|
|
if (widthDiff > WIDTHCUTOFF)
|
|
{
|
|
fontSizeChange = min<double>(max<double>(floor(WIDTHTOFONTSCALAR * widthDiff) - WIDTHTOFONTOFFSET, INCREMENTOFFSET), MAXFONTINCREMENT);
|
|
}
|
|
if (m_textBlock->ActualWidth < containerSize && abs(m_textBlock->FontSize - MaxFontSize) > FONTTOLERANCE && !m_haveCalculatedMax)
|
|
{
|
|
ModifyFontAndMargin(m_textBlock, fontSizeChange);
|
|
m_textBlock->InvalidateArrange();
|
|
return;
|
|
}
|
|
if (fontSizeChange < 5)
|
|
{
|
|
m_haveCalculatedMax = true;
|
|
}
|
|
if (m_textBlock->ActualWidth >= containerSize && abs(m_textBlock->FontSize - MinFontSize) > FONTTOLERANCE)
|
|
{
|
|
ModifyFontAndMargin(m_textBlock, -1 * fontSizeChange);
|
|
m_textBlock->InvalidateArrange();
|
|
return;
|
|
}
|
|
assert(m_textBlock->FontSize >= MinFontSize && m_textBlock->FontSize <= MaxFontSize);
|
|
m_isScalingText = false;
|
|
if (IsOperatorCommand)
|
|
{
|
|
m_textContainer->ChangeView(0.0, nullptr, nullptr);
|
|
}
|
|
else
|
|
{
|
|
m_textContainer->ChangeView(m_textContainer->ExtentWidth - m_textContainer->ViewportWidth, nullptr, nullptr);
|
|
}
|
|
|
|
if (m_scrollLeft && m_scrollRight)
|
|
{
|
|
if (m_textBlock->ActualWidth < containerSize)
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed);
|
|
}
|
|
else
|
|
{
|
|
if (IsOperatorCommand)
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Visible);
|
|
}
|
|
else
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Collapsed);
|
|
}
|
|
}
|
|
}
|
|
m_textBlock->InvalidateArrange();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::ScrollLeft()
|
|
{
|
|
if (m_textContainer->HorizontalOffset > 0)
|
|
{
|
|
double offset = m_textContainer->HorizontalOffset - (scrollRatio * m_textContainer->ViewportWidth);
|
|
m_textContainer->ChangeView(offset, nullptr, nullptr);
|
|
m_textContainer->UpdateLayout();
|
|
UpdateScrollButtons();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::ScrollRight()
|
|
{
|
|
if (m_textContainer->HorizontalOffset < m_textContainer->ExtentWidth - m_textContainer->ViewportWidth)
|
|
{
|
|
double offset = m_textContainer->HorizontalOffset + (scrollRatio * m_textContainer->ViewportWidth);
|
|
m_textContainer->ChangeView(offset, nullptr, nullptr);
|
|
m_textContainer->UpdateLayout();
|
|
UpdateScrollButtons();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnKeyDown(KeyRoutedEventArgs ^ e)
|
|
{
|
|
if (m_scrollLeft != nullptr && m_scrollRight != nullptr)
|
|
{
|
|
auto key = e->Key;
|
|
if (key == Windows::System::VirtualKey::Left)
|
|
{
|
|
this->ScrollLeft();
|
|
}
|
|
else if (key == Windows::System::VirtualKey::Right)
|
|
{
|
|
this->ScrollRight();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnScrollClick(Object ^ sender, RoutedEventArgs ^ /*e*/)
|
|
{
|
|
auto clicked = dynamic_cast<HyperlinkButton ^>(sender);
|
|
if (clicked == m_scrollLeft)
|
|
{
|
|
this->ScrollLeft();
|
|
}
|
|
else
|
|
{
|
|
this->ScrollRight();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnPointerEntered(Platform::Object ^ sender, PointerRoutedEventArgs ^ e)
|
|
{
|
|
if (e->Pointer->PointerDeviceType == PointerDeviceType::Mouse && m_textBlock->ActualWidth >= m_textContainer->ActualWidth)
|
|
{
|
|
UpdateScrollButtons();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::ShowHideScrollButtons(::Visibility vLeft, ::Visibility vRight)
|
|
{
|
|
m_scrollLeft->Visibility = vLeft;
|
|
m_scrollRight->Visibility = vRight;
|
|
}
|
|
|
|
void CalculationResult::UpdateScrollButtons()
|
|
{
|
|
// When the width is smaller than the container, don't show any
|
|
if (m_textBlock->ActualWidth < m_textContainer->ActualWidth)
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Collapsed);
|
|
}
|
|
// We have more number on both side. Show both arrows
|
|
else if (m_textContainer->HorizontalOffset > 0 && m_textContainer->HorizontalOffset < (m_textContainer->ExtentWidth - m_textContainer->ViewportWidth))
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Visible);
|
|
}
|
|
// Width is larger than the container and left most part of the number is shown. Should be able to scroll left.
|
|
else if (m_textContainer->HorizontalOffset == 0)
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Collapsed, ::Visibility::Visible);
|
|
}
|
|
else // Width is larger than the container and right most part of the number is shown. Should be able to scroll left.
|
|
{
|
|
ShowHideScrollButtons(::Visibility::Visible, ::Visibility::Collapsed);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnPointerExited(Platform::Object ^ sender, PointerRoutedEventArgs ^ e)
|
|
{
|
|
if (e->Pointer->PointerDeviceType == PointerDeviceType::Mouse)
|
|
{
|
|
UpdateScrollButtons();
|
|
}
|
|
}
|
|
|
|
void CalculationResult::ModifyFontAndMargin(TextBlock ^ textBox, double fontChange)
|
|
{
|
|
double cur = textBox->FontSize;
|
|
double newFontSize = 0.0;
|
|
double scaleFactor = SCALEFACTOR;
|
|
if (m_textContainer->ActualHeight <= HEIGHTCUTOFF)
|
|
{
|
|
scaleFactor = SMALLHEIGHTSCALEFACTOR;
|
|
}
|
|
|
|
newFontSize = min(max(cur + fontChange, MinFontSize), MaxFontSize);
|
|
m_textContainer->Padding = Thickness(0, 0, 0, scaleFactor * abs(cur - newFontSize));
|
|
textBox->FontSize = newFontSize;
|
|
}
|
|
|
|
void CalculationResult::UpdateAllState()
|
|
{
|
|
UpdateVisualState();
|
|
UpdateTextState();
|
|
}
|
|
|
|
void CalculationResult::OnTapped(TappedRoutedEventArgs ^ e)
|
|
{
|
|
this->Focus(::FocusState::Programmatic);
|
|
RaiseSelectedEvent();
|
|
}
|
|
|
|
void CalculationResult::OnRightTapped(RightTappedRoutedEventArgs ^ e)
|
|
{
|
|
this->Focus(::FocusState::Programmatic);
|
|
}
|
|
|
|
void CalculationResult::OnGotFocus(RoutedEventArgs ^ e)
|
|
{
|
|
if (this->FocusState == ::FocusState::Keyboard)
|
|
{
|
|
VisualStateManager::GoToState(this, s_FocusedState, true);
|
|
}
|
|
}
|
|
|
|
void CalculationResult::OnLostFocus(RoutedEventArgs ^ e)
|
|
{
|
|
VisualStateManager::GoToState(this, s_UnfocusedState, true);
|
|
}
|
|
|
|
AutomationPeer ^ CalculationResult::OnCreateAutomationPeer()
|
|
{
|
|
return ref new CalculationResultAutomationPeer(this);
|
|
}
|
|
|
|
void CalculationResult::ProgrammaticSelect()
|
|
{
|
|
RaiseSelectedEvent();
|
|
}
|
|
|
|
void CalculationResult::RaiseSelectedEvent()
|
|
{
|
|
Selected(this);
|
|
}
|