diff --git a/docs/ManualTests.md b/docs/ManualTests.md index a1d9de5..ddc38ac 100644 --- a/docs/ManualTests.md +++ b/docs/ManualTests.md @@ -54,6 +54,59 @@ Steps: 2. Select “miles” as the unit type in the output field *Expected: The output starts with is “3.106856”* +### Always-on-Top + +**Test 1** +Steps: +1. Launch the "Calculator" app and navigate to "Standard" Calculator +*Expected: Always-on-Top button's tooltip says "Keep on top"* +2. Click the Always-on-Top button +*Expected: Always-on-Top button's tooltip now says "Back to full view"* +3. Launch the "Notepad" app and put it in full-screen mode +*Expected: Calculator is still on top of Notepad and in Always-on-Top mode* + +**Test 2** +Steps: +1. Launch the "Calculator" app and from "Standard" Calculator, input “3”, “+”, “3” (do not press “Enter”) +2. Tab over the Always-on-Top button and press "Enter" on the keyboard +*Expected: The application title, hamburger menu, calculator type title, calculation expression (the secondary line above the main display), history button and memory buttons are no longer visible. The main display shows "3"* +2. Press “Enter” +*Expected: The main display shows "6"* +3. Press "Ctrl-H" on the keyboard +*Expected: Nothing happens (history keyboard shortcuts are disabled)* +4. Press "Ctrl-P" on the keyboard, then tab over the Always-on-Top button and press "Enter" on the keyboard again +5. Open the Memory panel +*Expected: Nothing is stored in memory (memory keyboard shortcuts are disabled in Always-on-Top mode) and "6" is in history* + +**Test 3** +Steps: +1. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button +2. Resize the window horizontally +*Expected: The buttons automatically expand or shrink to fit the available screen size* +3. Resize the window vertically +*Expected: The buttons automatically expand or shrink to fit the available screen size and the percent, square-root, squared and reciprocal buttons disappear when the screen height is small* +4. Click the Always-on-Top button again +*Expected: Calculator is in Standard mode and the original window layout from before Step 1 is restored* +5. Click the Always-on-Top button again +*Expected: Calculator is in Always-on-Top mode and the window size from after Step 3 is restored* +6. Close the "Calculator" app +7. Launch the "Calculator" app again and click the Always-on-Top button +*Expected: The window size from right before closing from Always-on-Top mode (ie. after Step 5) is restored* + +**Test 4** +Steps: +1. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button +2. Input "/", "0", “Enter” on the keyboard +*Expected: "Result is undefined" is displayed in the system default app language* +3. Click the Always-on-Top button again +*Expected: Calculator is in Standard mode and all operator (except for "CE", "C", "Delete" and "=") and memory buttons are disabled + +**Test 5** +Steps: +1. Launch the "Calculator" app and navigate to "Scientific" Calculator +*Expected: The Always-on-Top button is hidden* +2. Navigate to "Standard" Calculator +*Expected: The Always-on-Top button is visible* ## Basic Verification Tests @@ -278,7 +331,7 @@ Steps: Steps: 1. Launch the "Calculator" app. - For All Applicable Modes verify the following: + For All Applicable Modes verify the following (note: only 11-15 and 20 work in Always-on-Top mode): 2. Press **Alt +1** to Enter "Standard" mode *Expected: Move to "Standard" screen.* 3. Press **Alt +2** to Enter "Scientific" mode @@ -353,3 +406,30 @@ Steps: 61. Press **|** to Select 'Or' 62. Press **~** to Select 'Not' 63. Press **&** to Select 'And' + +## Localization Tests + +### Always-on-Top + +**Test 1** +Steps: +1. Change the system default app language to Arabic +2. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button +*Expected: UI/Menu is localized (for example, the title bar buttons is in right-to-left order)* +3. Input "/", "0", “Enter” on the keyboard +*Expected: Error message is in Arabic* + +## Ease of Access Tests + +### Always-on-Top + +**Test 1** +Steps: +1. Open the "Narrator" app +2. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button +3. Tab over the Always-on-Top button +*Expected: Narrator reads the localized version of "Back to full view"* +4. Tab over the main results field +*Expected: Narrator reads the localized version of exactly what's displayed (ie. "0")* +5. Tab over the rest of the UI elements +*Expected: Narrator reads the localized version of the UI elements' contents* diff --git a/src/CalcViewModel/ApplicationViewModel.cpp b/src/CalcViewModel/ApplicationViewModel.cpp index 25c3703..67318fd 100644 --- a/src/CalcViewModel/ApplicationViewModel.cpp +++ b/src/CalcViewModel/ApplicationViewModel.cpp @@ -31,6 +31,8 @@ using namespace Windows::UI::Xaml::Controls; using namespace Windows::UI::Xaml::Data; using namespace Windows::UI::Xaml::Input; using namespace Windows::UI::Xaml::Media; +using namespace Windows::Foundation; +using namespace Concurrency; namespace { @@ -55,6 +57,7 @@ void ApplicationViewModel::Mode::set(ViewMode value) { PreviousMode = m_mode; m_mode = value; + SetDisplayNormalAlwaysOnTopOption(); OnModeChanged(); RaisePropertyChanged(ModePropertyName); } @@ -204,3 +207,60 @@ void ApplicationViewModel::SetMenuCategories() // property setter logic. Categories = NavCategoryGroup::CreateMenuOptions(); } + +void ApplicationViewModel::ToggleAlwaysOnTop(float width, float height) +{ + HandleToggleAlwaysOnTop(width, height); +} + +task ApplicationViewModel::HandleToggleAlwaysOnTop(float width, float height) +{ + if (ApplicationView::GetForCurrentView()->ViewMode == ApplicationViewMode::CompactOverlay) + { + ApplicationDataContainer ^ localSettings = ApplicationData::Current->LocalSettings; + localSettings->Values->Insert(WidthLocalSettings, width); + localSettings->Values->Insert(HeightLocalSettings, height); + + bool success = co_await ApplicationView::GetForCurrentView()->TryEnterViewModeAsync(ApplicationViewMode::Default); + CalculatorViewModel->AreHistoryShortcutsEnabled = success; + CalculatorViewModel->HistoryVM->AreHistoryShortcutsEnabled = success; + CalculatorViewModel->IsAlwaysOnTop = !success; + IsAlwaysOnTop = !success; + } + else + { + ApplicationDataContainer ^ localSettings = ApplicationData::Current->LocalSettings; + ViewModePreferences ^ compactOptions = ViewModePreferences::CreateDefault(ApplicationViewMode::CompactOverlay); + if (!localSettings->Values->GetView()->HasKey(LaunchedLocalSettings)) + { + compactOptions->CustomSize = Size(320, 394); + localSettings->Values->Insert(LaunchedLocalSettings, true); + } + else + { + if (localSettings->Values->GetView()->HasKey(WidthLocalSettings) && localSettings->Values->GetView()->HasKey(HeightLocalSettings)) + { + float oldWidth = safe_cast(localSettings->Values->GetView()->Lookup(WidthLocalSettings))->GetSingle(); + float oldHeight = safe_cast(localSettings->Values->GetView()->Lookup(HeightLocalSettings))->GetSingle(); + compactOptions->CustomSize = Size(oldWidth, oldHeight); + } + else + { + compactOptions->CustomSize = Size(320, 394); + } + } + + bool success = co_await ApplicationView::GetForCurrentView()->TryEnterViewModeAsync(ApplicationViewMode::CompactOverlay, compactOptions); + CalculatorViewModel->AreHistoryShortcutsEnabled = !success; + CalculatorViewModel->HistoryVM->AreHistoryShortcutsEnabled = !success; + CalculatorViewModel->IsAlwaysOnTop = success; + IsAlwaysOnTop = success; + } + SetDisplayNormalAlwaysOnTopOption(); +} + +void ApplicationViewModel::SetDisplayNormalAlwaysOnTopOption() +{ + DisplayNormalAlwaysOnTopOption = + m_mode == ViewMode::Standard && ApplicationView::GetForCurrentView()->IsViewModeSupported(ApplicationViewMode::CompactOverlay) && !IsAlwaysOnTop; +} diff --git a/src/CalcViewModel/ApplicationViewModel.h b/src/CalcViewModel/ApplicationViewModel.h index dffa3b9..c35595e 100644 --- a/src/CalcViewModel/ApplicationViewModel.h +++ b/src/CalcViewModel/ApplicationViewModel.h @@ -25,6 +25,9 @@ namespace CalculatorApp OBSERVABLE_PROPERTY_RW(CalculatorApp::Common::ViewMode, PreviousMode); OBSERVABLE_NAMED_PROPERTY_RW(Platform::String ^, CategoryName); + // Indicates whether calculator is currently in standard mode _and_ supports CompactOverlay _and_ is not in Always-on-Top mode + OBSERVABLE_PROPERTY_RW(bool, DisplayNormalAlwaysOnTopOption); + COMMAND_FOR_METHOD(CopyCommand, ApplicationViewModel::OnCopyCommand); COMMAND_FOR_METHOD(PasteCommand, ApplicationViewModel::OnPasteCommand); @@ -64,6 +67,48 @@ namespace CalculatorApp } } + static property Platform::String ^ LaunchedLocalSettings + { + Platform::String ^ get() + { + return Platform::StringReference(L"calculatorAlwaysOnTopLaunched"); + } + } + + static property Platform::String ^ WidthLocalSettings + { + Platform::String ^ get() + { + return Platform::StringReference(L"calculatorAlwaysOnTopLastWidth"); + } + } + + static property Platform::String ^ HeightLocalSettings + { + Platform::String ^ get() + { + return Platform::StringReference(L"calculatorAlwaysOnTopLastHeight"); + } + } + + property bool IsAlwaysOnTop + { + bool get() + { + return m_isAlwaysOnTop; + } + void set(bool value) + { + if (m_isAlwaysOnTop != value) + { + m_isAlwaysOnTop = value; + RaisePropertyChanged(L"IsAlwaysOnTop"); + } + } + } + + void ToggleAlwaysOnTop(float width, float height); + private: bool TryRecoverFromNavigationModeFailure(); @@ -76,6 +121,10 @@ namespace CalculatorApp CalculatorApp::Common::ViewMode m_mode; Windows::Foundation::Collections::IObservableVector ^ m_categories; + Concurrency::task HandleToggleAlwaysOnTop(float width, float height); + void SetDisplayNormalAlwaysOnTopOption(); + + bool m_isAlwaysOnTop; }; } } diff --git a/src/CalcViewModel/Common/KeyboardShortcutManager.cpp b/src/CalcViewModel/Common/KeyboardShortcutManager.cpp index 7d9cfff..8b2ca30 100644 --- a/src/CalcViewModel/Common/KeyboardShortcutManager.cpp +++ b/src/CalcViewModel/Common/KeyboardShortcutManager.cpp @@ -668,10 +668,11 @@ void KeyboardShortcutManager::OnAcceleratorKeyActivated(CoreDispatcher ^, Accele if (nullptr != vm) { ViewMode toMode = NavCategory::GetViewModeForVirtualKey(static_cast(key)); - if (NavCategory::IsValidViewMode(toMode)) + auto nvi = dynamic_cast(menuItems->GetAt(NavCategory::GetFlatIndex(toMode))); + if (nvi && nvi->IsEnabled && NavCategory::IsValidViewMode(toMode)) { vm->Mode = toMode; - navView->SelectedItem = menuItems->GetAt(NavCategory::GetFlatIndex(toMode)); + navView->SelectedItem = nvi; } } } diff --git a/src/CalcViewModel/Common/TraceLogger.cpp b/src/CalcViewModel/Common/TraceLogger.cpp index ddf4186..6537554 100644 --- a/src/CalcViewModel/Common/TraceLogger.cpp +++ b/src/CalcViewModel/Common/TraceLogger.cpp @@ -117,7 +117,7 @@ namespace CalculatorApp return true; } - void TraceLogger::LogVisualStateChanged(ViewMode mode, wstring_view state) const + void TraceLogger::LogVisualStateChanged(ViewMode mode, wstring_view state, bool isAlwaysOnTop) const { if (!GetTraceLoggingProviderEnabled()) { @@ -128,6 +128,7 @@ namespace CalculatorApp fields.AddGuid(L"SessionGuid", sessionGuid); fields.AddString(L"CalcMode", NavCategory::GetFriendlyName(mode)->Data()); fields.AddString(L"VisualState", state); + fields.AddBoolean(L"IsAlwaysOnTop", isAlwaysOnTop); fields.AddUInt64(PDT_PRIVACY_DATA_TAG, PDT_PRODUCT_AND_SERVICE_USAGE); LogLevel2Event(EVENT_NAME_VISUAL_STATE_CHANGED, fields); } diff --git a/src/CalcViewModel/Common/TraceLogger.h b/src/CalcViewModel/Common/TraceLogger.h index 77201ff..d8a4289 100644 --- a/src/CalcViewModel/Common/TraceLogger.h +++ b/src/CalcViewModel/Common/TraceLogger.h @@ -45,7 +45,7 @@ namespace CalculatorApp void LogDateCalculationModeUsed(bool AddSubtractMode); void UpdateWindowCount(size_t windowCount = 0); bool IsWindowIdInLog(int windowId); - void LogVisualStateChanged(CalculatorApp::Common::ViewMode mode, std::wstring_view state) const; + void LogVisualStateChanged(CalculatorApp::Common::ViewMode mode, std::wstring_view state, bool isAlwaysOnTop = false) const; void LogWindowCreated(CalculatorApp::Common::ViewMode mode, int windowId); void LogConverterInputReceived(CalculatorApp::Common::ViewMode mode) const; void LogNavBarOpened() const; diff --git a/src/CalcViewModel/StandardCalculatorViewModel.cpp b/src/CalcViewModel/StandardCalculatorViewModel.cpp index a0fe4e6..c9717b8 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.cpp +++ b/src/CalcViewModel/StandardCalculatorViewModel.cpp @@ -35,6 +35,7 @@ namespace StringReference IsStandardPropertyName(L"IsStandard"); StringReference IsScientificPropertyName(L"IsScientific"); StringReference IsProgrammerPropertyName(L"IsProgrammer"); + StringReference IsAlwaysOnTopPropertyName(L"IsAlwaysOnTop"); StringReference DisplayValuePropertyName(L"DisplayValue"); StringReference CalculationResultAutomationNamePropertyName(L"CalculationResultAutomationName"); StringReference IsBitFlipCheckedPropertyName(L"IsBitFlipChecked"); @@ -202,7 +203,12 @@ void StandardCalculatorViewModel::SetPrimaryDisplay(_In_ wstring const& displayS // not match what the narrator is saying m_CalculationResultAutomationName = CalculateNarratorDisplayValue(displayStringValue, localizedDisplayStringValue, isError); - DisplayValue = localizedDisplayStringValue; + AreAlwaysOnTopResultsUpdated = false; + if (DisplayValue != localizedDisplayStringValue) + { + DisplayValue = localizedDisplayStringValue; + AreAlwaysOnTopResultsUpdated = true; + } IsInError = isError; @@ -415,7 +421,7 @@ void StandardCalculatorViewModel::SetMemorizedNumbers(const vector& new memorySlot->Value = Utils::LRO + ref new String(stringValue.c_str()) + Utils::PDF; MemorizedNumbers->InsertAt(0, memorySlot); - IsMemoryEmpty = false; + IsMemoryEmpty = IsAlwaysOnTop; // Update the slot position for the rest of the slots for (unsigned int i = 1; i < MemorizedNumbers->Size; i++) diff --git a/src/CalcViewModel/StandardCalculatorViewModel.h b/src/CalcViewModel/StandardCalculatorViewModel.h index 03f5c0b..350155d 100644 --- a/src/CalcViewModel/StandardCalculatorViewModel.h +++ b/src/CalcViewModel/StandardCalculatorViewModel.h @@ -78,6 +78,7 @@ namespace CalculatorApp OBSERVABLE_PROPERTY_RW(bool, IsByteEnabled); 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(CalculatorApp::Common::Automation::NarratorAnnouncement ^, Announcement); @@ -213,6 +214,22 @@ namespace CalculatorApp } } + 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() @@ -406,6 +423,7 @@ namespace CalculatorApp bool m_isStandard; bool m_isScientific; bool m_isProgrammer; + bool m_isAlwaysOnTop; bool m_isBinaryBitFlippingEnabled; bool m_isBitFlipChecked; bool m_isShiftChecked; diff --git a/src/CalcViewModel/pch.h b/src/CalcViewModel/pch.h index 142e05f..575a1f0 100644 --- a/src/CalcViewModel/pch.h +++ b/src/CalcViewModel/pch.h @@ -30,6 +30,7 @@ #include #include #include +#include // C++\WinRT Headers #include "winrt/base.h" #include "winrt/Windows.Foundation.Diagnostics.h" diff --git a/src/Calculator/App.xaml b/src/Calculator/App.xaml index 910a585..d9b2d7b 100644 --- a/src/Calculator/App.xaml +++ b/src/Calculator/App.xaml @@ -128,6 +128,8 @@ 24 20 + 15 + 12 15 @@ -210,11 +212,21 @@ TargetType="Controls:CalculatorButton"> + + + + + + + + @@ -236,7 +368,6 @@ - @@ -246,6 +377,11 @@ OperatorTemplate="{StaticResource Operator}" SeparatorTemplate="{StaticResource Separator}"/> + + @@ -288,6 +424,28 @@ + + + + + + + + + + + + + + + + + + + + + + @@ -364,7 +522,7 @@ - + @@ -377,6 +535,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + @@ -419,19 +601,29 @@ + MinHeight="0"/> + MinHeight="20"/> + MinHeight="0"/> + - + + AutomationProperties.AutomationId="CalculatorAlwaysOnTopResults" + AutomationProperties.HeadingLevel="Level1" + AutomationProperties.Name="{x:Bind Model.CalculationResultAutomationName, Mode=OneWay}" + TokensUpdated="{x:Bind Model.AreAlwaysOnTopResultsUpdated, Mode=OneWay}" + HorizontalContentAlignment="Right" + IsActive="True" + UseSystemFocusVisuals="True" + Visibility="{x:Bind Model.IsAlwaysOnTop, Mode=OneWay}"/> - - + + + + + + diff --git a/src/Calculator/Views/Calculator.xaml.cpp b/src/Calculator/Views/Calculator.xaml.cpp index 2545830..ce84bb7 100644 --- a/src/Calculator/Views/Calculator.xaml.cpp +++ b/src/Calculator/Views/Calculator.xaml.cpp @@ -40,6 +40,7 @@ using namespace Windows::UI::ViewManagement; DEPENDENCY_PROPERTY_INITIALIZATION(Calculator, IsStandard); DEPENDENCY_PROPERTY_INITIALIZATION(Calculator, IsScientific); DEPENDENCY_PROPERTY_INITIALIZATION(Calculator, IsProgrammer); +DEPENDENCY_PROPERTY_INITIALIZATION(Calculator, IsAlwaysOnTop); Calculator::Calculator() : m_doAnimate(false) @@ -60,6 +61,8 @@ Calculator::Calculator() auto resLoader = AppResourceProvider::GetInstance(); CopyMenuItem->Text = resLoader.GetResourceString(L"copyMenuItem"); PasteMenuItem->Text = resLoader.GetResourceString(L"pasteMenuItem"); + + this->SizeChanged += ref new SizeChangedEventHandler(this, &Calculator::Calculator_SizeChanged); } void Calculator::LoadResourceStrings() @@ -97,7 +100,7 @@ void Calculator::SetFontSizeResources() { L"Tibt", 104, 29.333, 20, 40, 56, 40, 56 }, { L"Default", 104, 29.333, 23, 40, 56, 40, 56 } }; - DecimalFormatter^ formatter = LocalizationService::GetInstance()->GetRegionalSettingsAwareDecimalFormatter(); + DecimalFormatter ^ formatter = LocalizationService::GetInstance()->GetRegionalSettingsAwareDecimalFormatter(); const FontTable* currentItem = fontTables; while (currentItem->numericSystem.compare(std::wstring(L"Default")) != 0 && currentItem->numericSystem.compare(formatter->NumeralSystem->Data()) != 0) @@ -279,6 +282,35 @@ void Calculator::OnIsProgrammerPropertyChanged(bool /*oldValue*/, bool newValue) UpdatePanelViewState(); } +void Calculator::OnIsAlwaysOnTopPropertyChanged(bool /*oldValue*/, bool newValue) +{ + if (newValue) + { + VisualStateManager::GoToState(this, L"AlwaysOnTop", false); + } + else + { + VisualStateManager::GoToState(this, L"Normal", false); + if (Model->IsInError) + { + VisualStateManager::GoToState(this, L"ErrorLayout", false); + } + else + { + EnableMemoryControls(true); + } + } + + Model->IsMemoryEmpty = (Model->MemorizedNumbers->Size == 0) || IsAlwaysOnTop; + + AlwaysOnTopResults->UpdateScrollButtons(); + Results->UpdateTextState(); + + UpdateViewState(); + UpdatePanelViewState(); + SetDefaultFocus(); +} + void Calculator::OnIsInErrorPropertyChanged() { bool isError = Model->IsInError; @@ -395,33 +427,36 @@ void Calculator::UpdateHistoryState() void Calculator::UpdateMemoryState() { - if (!Model->IsMemoryEmpty) + if (!IsAlwaysOnTop) { - MemRecall->IsEnabled = true; - ClearMemoryButton->IsEnabled = true; - } - else - { - MemRecall->IsEnabled = false; - ClearMemoryButton->IsEnabled = false; - } - - String ^ viewState = App::GetAppViewState(); - if (viewState == ViewState::DockedView) - { - CloseMemoryFlyout(); - SetChildAsMemory(); - MemoryButton->Visibility = ::Visibility::Collapsed; - - if (m_IsLastFlyoutMemory && !IsProgrammer) + if (!Model->IsMemoryEmpty) { - DockPivot->SelectedIndex = 1; + MemRecall->IsEnabled = true; + ClearMemoryButton->IsEnabled = true; + } + else + { + MemRecall->IsEnabled = false; + ClearMemoryButton->IsEnabled = false; + } + + String ^ viewState = App::GetAppViewState(); + if (viewState == ViewState::DockedView) + { + CloseMemoryFlyout(); + SetChildAsMemory(); + MemoryButton->Visibility = ::Visibility::Collapsed; + + if (m_IsLastFlyoutMemory && !IsProgrammer) + { + DockPivot->SelectedIndex = 1; + } + } + else + { + MemoryButton->Visibility = ::Visibility::Visible; + DockMemoryHolder->Child = nullptr; } - } - else - { - MemoryButton->Visibility = ::Visibility::Visible; - DockMemoryHolder->Child = nullptr; } } @@ -507,7 +542,14 @@ void Calculator::CloseMemoryFlyout() void Calculator::SetDefaultFocus() { - Results->Focus(::FocusState::Programmatic); + if (!IsAlwaysOnTop) + { + Results->Focus(::FocusState::Programmatic); + } + else + { + AlwaysOnTopResults->Focus(::FocusState::Programmatic); + } } void Calculator::ToggleHistoryFlyout(Object ^ /*parameter*/) @@ -696,5 +738,13 @@ void CalculatorApp::Calculator::OnVisualStateChanged(Platform::Object ^ sender, { auto mode = IsStandard ? ViewMode::Standard : IsScientific ? ViewMode::Scientific : ViewMode::Programmer; auto state = std::wstring(e->NewState->Name->Begin()); - TraceLogger::GetInstance().LogVisualStateChanged(mode, state); + TraceLogger::GetInstance().LogVisualStateChanged(mode, state, IsAlwaysOnTop); +} + +void Calculator::Calculator_SizeChanged(Object ^ /*sender*/, SizeChangedEventArgs ^ /*e*/) +{ + if (Model->IsAlwaysOnTop) + { + AlwaysOnTopResults->UpdateScrollButtons(); + } } diff --git a/src/Calculator/Views/Calculator.xaml.h b/src/Calculator/Views/Calculator.xaml.h index 04099f8..a1094a4 100644 --- a/src/Calculator/Views/Calculator.xaml.h +++ b/src/Calculator/Views/Calculator.xaml.h @@ -53,6 +53,7 @@ public DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(bool, IsStandard, false); DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(bool, IsScientific, false); DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(bool, IsProgrammer, false); + DEPENDENCY_PROPERTY_WITH_DEFAULT_AND_CALLBACK(bool, IsAlwaysOnTop, false); COMMAND_FOR_METHOD(HistoryButtonPressed, Calculator::ToggleHistoryFlyout); @@ -75,12 +76,12 @@ public void UpdateMemoryState(); void UpdateHistoryState(); - void CalculationResultsOnSelected(_In_ Platform::Object ^ sender); void OnContextRequested(Windows::UI::Xaml::UIElement ^ sender, Windows::UI::Xaml::Input::ContextRequestedEventArgs ^ e); void OnContextCanceled(Windows::UI::Xaml::UIElement ^ sender, Windows::UI::Xaml::RoutedEventArgs ^ e); void OnIsScientificPropertyChanged(bool oldValue, bool newValue); void OnIsProgrammerPropertyChanged(bool oldValue, bool newValue); void OnIsStandardPropertyChanged(bool oldValue, bool newValue); + void OnIsAlwaysOnTopPropertyChanged(bool oldValue, bool newValue); void OnIsInErrorPropertyChanged(); void OnCalcPropertyChanged(_In_ Platform::Object ^ sender, _In_ Windows::UI::Xaml::Data::PropertyChangedEventArgs ^ e); void OnStoryboardCompleted(_In_ Platform::Object ^ sender, _In_ Platform::Object ^ e); @@ -89,6 +90,7 @@ public void EnsureProgrammer(); void SetFontSizeResources(); std::wstring GetCurrentLayoutState(); + void Calculator_SizeChanged(Object ^ sender, Windows::UI::Xaml::SizeChangedEventArgs ^ e); private: Windows::UI::Xaml::Controls::ListView ^ m_tokenList; diff --git a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml index 6cd455b..eefbb75 100644 --- a/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml +++ b/src/Calculator/Views/CalculatorProgrammerRadixOperators.xaml @@ -216,7 +216,7 @@ FontSize="16" AutomationProperties.AutomationId="shiftButton" Checked="Shift_Clicked" - Content="" + Content="" Unchecked="Shift_Clicked"/> + Content=""/> diff --git a/src/Calculator/Views/CalculatorScientificOperators.xaml b/src/Calculator/Views/CalculatorScientificOperators.xaml index 15f6600..e98ad4e 100644 --- a/src/Calculator/Views/CalculatorScientificOperators.xaml +++ b/src/Calculator/Views/CalculatorScientificOperators.xaml @@ -511,7 +511,7 @@ Style="{StaticResource SymbolOperatorButtonStyle}" AutomationProperties.AutomationId="squareRootButton" ButtonId="Sqrt" - Content=""/> + Content=""/> @@ -718,7 +718,7 @@ FontSize="16" AutomationProperties.AutomationId="negateButton" ButtonId="Negate" - Content="" + Content="" IsEnabled="{x:Bind Model.IsNegateEnabled, Mode=OneWay}"/> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -238,11 +292,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -279,7 +363,7 @@ Style="{StaticResource SymbolOperatorButtonStyle}" AutomationProperties.AutomationId="squareRootButton" ButtonId="Sqrt" - Content=""/> + Content=""/> + Content=""/> diff --git a/src/Calculator/Views/CalculatorStandardOperators.xaml.cpp b/src/Calculator/Views/CalculatorStandardOperators.xaml.cpp index 7ebd592..62dcec6 100644 --- a/src/Calculator/Views/CalculatorStandardOperators.xaml.cpp +++ b/src/Calculator/Views/CalculatorStandardOperators.xaml.cpp @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // diff --git a/src/Calculator/Views/CalculatorStandardOperators.xaml.h b/src/Calculator/Views/CalculatorStandardOperators.xaml.h index ebd71b9..3fb1069 100644 --- a/src/Calculator/Views/CalculatorStandardOperators.xaml.h +++ b/src/Calculator/Views/CalculatorStandardOperators.xaml.h @@ -1,4 +1,4 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. +// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. // diff --git a/src/Calculator/Views/MainPage.xaml b/src/Calculator/Views/MainPage.xaml index bcf2908..ca372ea 100644 --- a/src/Calculator/Views/MainPage.xaml +++ b/src/Calculator/Views/MainPage.xaml @@ -32,6 +32,9 @@ + + + @@ -83,8 +86,21 @@ Command="{x:Bind Model.PasteCommand}"/> - - + + + + + + + + + + + + + + + - + + + + - - - - - - - - - - + Text="{x:Bind Model.CategoryName, Mode=OneWay}" + Grid.Column="0"/> +