Dela via

Skärmläsare och maskinvarusystemknappar

Skärmläsare, till exempel Skärmläsaren, måste kunna identifiera och hantera händelser från hårdvaruknappssystem och kommunicera deras tillstånd till användarna. I vissa fall kan skärmläsaren behöva hantera dessa maskinvaruknappshändelser exklusivt och inte låta dem bubbla upp till andra hanterare.

Från och med Windows 10 version 2004 kan UWP-program lyssna efter och hantera knapphändelserna för Fn-maskinvarusystem på samma sätt som andra maskinvaruknappar. Tidigare fungerade den här systemknappen bara som en modifierare för hur andra maskinvaruknappar rapporterade sina händelser och tillstånd.

Anmärkning

Stöd för Fn-knappen är OEM-specifik och kan innehålla funktioner som möjligheten att växla/låsa på eller av (jämfört med en kombination av tangenttryckningar och hållningar), tillsammans med motsvarande låsindikatorlampa (som kanske inte är till hjälp för användare som är blinda eller har nedsatt syn).

Fn-knapphändelser exponeras via en ny SystemButtonEventController-klass i namnområdet Windows.UI.Input . Objektet SystemButtonEventController stöder följande händelser:

Viktigt!

SystemButtonEventController kan inte ta emot dessa händelser om de redan har hanterats av en hanterare med högre prioritet.

Exempel

I följande exempel visar vi hur du skapar en SystemButtonEventController baserat på en DispatcherQueue och hanterar de fyra händelser som stöds av det här objektet.

Det är vanligt att fler än en av de händelser som stöds utlöses när knappen Fn trycks in. Om du till exempel trycker på knappen Fn på ett Surface-tangentbord utlöses SystemFunctionButtonPressed, SystemFunctionLockChanged och SystemFunctionLockIndicatorChanged samtidigt.

  1. I det här första kodfragmentet inkluderar vi bara de nödvändiga namnrymderna och anger vissa globala objekt, inklusive DispatcherQueue - och DispatcherQueueController-objekten för hantering av SystemButtonEventController-tråden .

    Sedan anger vi de händelsetoken som returneras när registrering av händelsehanteringsdelegater för SystemButtonEventController sker.

    namespace winrt
{
    using namespace Windows::System;
    using namespace Windows::UI::Input;
}

...

// Declare related members
winrt::DispatcherQueueController _queueController;
winrt::DispatcherQueue _queue;
winrt::SystemButtonEventController _controller;
winrt::event_token _fnKeyDownToken;
winrt::event_token _fnKeyUpToken;
winrt::event_token _fnLockToken;

  2. Vi anger också en händelsetoken för händelsen SystemFunctionLockIndicatorChanged tillsammans med en bool för att ange om programmet är i "inlärningsläge" (där användaren helt enkelt försöker utforska tangentbordet utan att utföra några funktioner).

    winrt::event_token _fnLockIndicatorToken;
bool _isLearningMode = false;

  3. Det tredje kodfragmentet innehåller motsvarande händelsehanterardelegater för varje händelse som stöds av Objektet SystemButtonEventController .

    Varje händelsehanterare meddelar händelsen som har inträffat. Dessutom styr FunctionLockIndicatorChanged-hanteraren även om appen är i "Learning"-läge (_isLearningMode = sant), vilket förhindrar att händelsen bubblar till andra hanterare och låter användaren utforska tangentbordsfunktioner utan att utföra åtgärden.

    void SetupSystemButtonEventController()
{
    // Create dispatcher queue controller and dispatcher queue
    _queueController = winrt::DispatcherQueueController::CreateOnDedicatedThread();
    _queue = _queueController.DispatcherQueue();

    // Create controller based on new created dispatcher queue
    _controller = winrt::SystemButtonEventController::CreateForDispatcherQueue(_queue);

    // Add Event Handler for each different event
    _fnKeyDownToken = _controller->FunctionButtonPressed(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionButtonEventArgs& args)
        {
            // Mock function to read the sentence "Fn button is pressed"
            PronounceFunctionButtonPressedMock();
            // Set Handled as true means this event is consumed by this controller
            // no more targets will receive this event
            args.Handled(true);
        });

        _fnKeyUpToken = _controller->FunctionButtonReleased(
            [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionButtonEventArgs& args)
            {
                // Mock function to read the sentence "Fn button is up"
                PronounceFunctionButtonReleasedMock();
                // Set Handled as true means this event is consumed by this controller
                // no more targets will receive this event
                args.Handled(true);
            });

    _fnLockToken = _controller->FunctionLockChanged(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionLockChangedEventArgs& args)
        {
            // Mock function to read the sentence "Fn shift is locked/unlocked"
            PronounceFunctionLockMock(args.IsLocked());
            // Set Handled as true means this event is consumed by this controller
            // no more targets will receive this event
            args.Handled(true);
        });

    _fnLockIndicatorToken = _controller->FunctionLockIndicatorChanged(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionLockIndicatorChangedEventArgs& args)
        {
            // Mock function to read the sentence "Fn lock indicator is on/off"
            PronounceFunctionLockIndicatorMock(args.IsIndicatorOn());
            // In learning mode, the user is exploring the keyboard. They expect the program
            // to announce what the key they just pressed WOULD HAVE DONE, without actually
            // doing it. Therefore, handle the event when in learning mode so the key is ignored
            // by the system.
            args.Handled(_isLearningMode);
        });
}

Se även

SystemButtonEventController-klass

  • Last updated on