Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1334 insertions, 0 deletions

diff --git a/vcl/source/window/menufloatingwindow.cxx b/vcl/source/window/menufloatingwindow.cxx
new file mode 100644
index 000000000..84e19a63e
--- /dev/null
+++ b/vcl/source/window/menufloatingwindow.cxx
@@ -0,0 +1,1334 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "menufloatingwindow.hxx"
+#include "menuitemlist.hxx"
+#include "menubarwindow.hxx"
+#include "bufferdevice.hxx"
+
+#include <sal/log.hxx>
+#include <salframe.hxx>
+#include <svdata.hxx>
+#include <vcl/decoview.hxx>
+#include <vcl/settings.hxx>
+#include <window.h>
+
+MenuFloatingWindow::MenuFloatingWindow( Menu* pMen, vcl::Window* pParent, WinBits nStyle ) :
+    FloatingWindow( pParent, nStyle ),
+    pMenu(pMen),
+    nHighlightedItem(ITEMPOS_INVALID),
+    nMBDownPos(ITEMPOS_INVALID),
+    nScrollerHeight(0),
+    nFirstEntry(0),
+    nPosInParent(ITEMPOS_INVALID),
+    bInExecute(false),
+    bScrollMenu(false),
+    bScrollUp(false),
+    bScrollDown(false),
+    bIgnoreFirstMove(true),
+    bKeyInput(false)
+{
+    mpWindowImpl->mbMenuFloatingWindow= true;
+
+    ApplySettings(*this);
+
+    SetPopupModeEndHdl( LINK( this, MenuFloatingWindow, PopupEnd ) );
+
+    aHighlightChangedTimer.SetInvokeHandler( LINK( this, MenuFloatingWindow, HighlightChanged ) );
+    aHighlightChangedTimer.SetTimeout( GetSettings().GetMouseSettings().GetMenuDelay() );
+    aHighlightChangedTimer.SetDebugName( "vcl::MenuFloatingWindow aHighlightChangedTimer" );
+
+    aSubmenuCloseTimer.SetTimeout( GetSettings().GetMouseSettings().GetMenuDelay() );
+    aSubmenuCloseTimer.SetInvokeHandler( LINK( this, MenuFloatingWindow, SubmenuClose ) );
+    aSubmenuCloseTimer.SetDebugName( "vcl::MenuFloatingWindow aSubmenuCloseTimer" );
+
+    aScrollTimer.SetInvokeHandler( LINK( this, MenuFloatingWindow, AutoScroll ) );
+    aScrollTimer.SetDebugName( "vcl::MenuFloatingWindow aScrollTimer" );
+
+    AddEventListener( LINK( this, MenuFloatingWindow, ShowHideListener ) );
+}
+
+void MenuFloatingWindow::doShutdown()
+{
+    if( !pMenu )
+        return;
+
+    // #105373# notify toolkit that highlight was removed
+    // otherwise the entry will not be read when the menu is opened again
+    if( nHighlightedItem != ITEMPOS_INVALID )
+        pMenu->ImplCallEventListeners( VclEventId::MenuDehighlight, nHighlightedItem );
+    if (!bKeyInput && pMenu && pMenu->pStartedFrom && !pMenu->pStartedFrom->IsMenuBar())
+    {
+        // #102461# remove highlight in parent
+        size_t i, nCount = pMenu->pStartedFrom->pItemList->size();
+        for(i = 0; i < nCount; i++)
+        {
+            MenuItemData* pData = pMenu->pStartedFrom->pItemList->GetDataFromPos( i );
+            if( pData && ( pData->pSubMenu == pMenu ) )
+                break;
+        }
+        if( i < nCount )
+        {
+            MenuFloatingWindow* pPWin = static_cast<MenuFloatingWindow*>(pMenu->pStartedFrom->ImplGetWindow());
+            if (pPWin)
+                pPWin->InvalidateItem(i);
+        }
+    }
+
+    // free the reference to the accessible component
+    SetAccessible( css::uno::Reference< css::accessibility::XAccessible >() );
+
+    aHighlightChangedTimer.Stop();
+
+    // #95056# invalidate screen area covered by system window
+    // so this can be taken into account if the commandhandler performs a scroll operation
+    if( GetParent() )
+    {
+        tools::Rectangle aInvRect( GetWindowExtentsRelative( GetParent() ) );
+        GetParent()->Invalidate( aInvRect );
+    }
+    pMenu = nullptr;
+    RemoveEventListener( LINK( this, MenuFloatingWindow, ShowHideListener ) );
+
+    aScrollTimer.Stop();
+    aSubmenuCloseTimer.Stop();
+    aSubmenuCloseTimer.Stop();
+    aHighlightChangedTimer.Stop();
+    aHighlightChangedTimer.Stop();
+
+}
+
+MenuFloatingWindow::~MenuFloatingWindow()
+{
+    disposeOnce();
+}
+
+void MenuFloatingWindow::dispose()
+{
+    doShutdown();
+    pMenu.clear();
+    pActivePopup.clear();
+    xSaveFocusId.clear();
+    FloatingWindow::dispose();
+}
+
+void MenuFloatingWindow::Resize()
+{
+    InitMenuClipRegion(*this); // FIXME
+}
+
+void MenuFloatingWindow::ApplySettings(vcl::RenderContext& rRenderContext)
+{
+    FloatingWindow::ApplySettings(rRenderContext);
+
+    if (IsNativeControlSupported(ControlType::MenuPopup, ControlPart::MenuItem) &&
+        IsNativeControlSupported(ControlType::MenuPopup, ControlPart::Entire))
+    {
+        AllSettings aSettings(GetSettings());
+        ImplGetFrame()->UpdateSettings(aSettings); // Update theme colors.
+        StyleSettings aStyle(aSettings.GetStyleSettings());
+        Color aHighlightTextColor = ImplGetSVData()->maNWFData.maMenuBarHighlightTextColor;
+        if (aHighlightTextColor != COL_TRANSPARENT)
+        {
+            aStyle.SetMenuHighlightTextColor(aHighlightTextColor);
+        }
+        aSettings.SetStyleSettings(aStyle);
+        OutputDevice::SetSettings(aSettings);
+    }
+
+    const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
+    SetPointFont(rRenderContext, rStyleSettings.GetMenuFont());
+
+    if (rRenderContext.IsNativeControlSupported(ControlType::MenuPopup, ControlPart::Entire))
+    {
+        rRenderContext.SetBackground(); // background will be drawn by NWF
+    }
+    else
+        rRenderContext.SetBackground(Wallpaper(rStyleSettings.GetMenuColor()));
+
+    rRenderContext.SetTextColor(rStyleSettings.GetMenuTextColor());
+    rRenderContext.SetTextFillColor();
+    rRenderContext.SetLineColor();
+}
+
+/// Get a negative pixel offset for an offset menu
+long MenuFloatingWindow::ImplGetStartY() const
+{
+    long nY = 0;
+    if( pMenu )
+    {
+        // avoid crash if somehow menu got disposed, and MenuItemList is empty (workaround for tdf#104686)
+        if ( nFirstEntry > 0 && !pMenu->GetItemList()->GetDataFromPos(nFirstEntry - 1) )
+        {
+            return 0;
+        }
+
+        for ( sal_uInt16 n = 0; n < nFirstEntry; n++ )
+            nY += pMenu->GetItemList()->GetDataFromPos( n )->aSz.Height();
+        nY -= pMenu->GetTitleHeight();
+    }
+    return -nY;
+}
+
+vcl::Region MenuFloatingWindow::ImplCalcClipRegion() const
+{
+    Size aOutSz = GetOutputSizePixel();
+    tools::Rectangle aRect( Point(), aOutSz );
+    aRect.AdjustTop(nScrollerHeight );
+    aRect.AdjustBottom( -nScrollerHeight );
+
+    vcl::Region aRegion(aRect);
+
+    return aRegion;
+}
+
+void MenuFloatingWindow::InitMenuClipRegion(vcl::RenderContext& rRenderContext)
+{
+    if (IsScrollMenu())
+    {
+        rRenderContext.SetClipRegion(ImplCalcClipRegion());
+    }
+    else
+    {
+        rRenderContext.SetClipRegion();
+    }
+}
+
+void MenuFloatingWindow::ImplHighlightItem( const MouseEvent& rMEvt, bool bMBDown )
+{
+    if( ! pMenu )
+        return;
+
+    long nY = GetInitialItemY();
+    long nMouseY = rMEvt.GetPosPixel().Y();
+    Size aOutSz = GetOutputSizePixel();
+    if ( ( nMouseY >= nY ) && ( nMouseY < aOutSz.Height() ) )
+    {
+        bool bHighlighted = false;
+        size_t nCount = pMenu->pItemList->size();
+        for ( size_t n = 0; !bHighlighted && ( n < nCount ); n++ )
+        {
+            if ( pMenu->ImplIsVisible( n ) )
+            {
+                MenuItemData* pItemData = pMenu->pItemList->GetDataFromPos( n );
+                long nOldY = nY;
+                nY += pItemData->aSz.Height();
+                if ( ( nOldY <= nMouseY ) && ( nY > nMouseY ) && pMenu->ImplIsSelectable( n ) )
+                {
+                    bool bPopupArea = true;
+                    if ( pItemData->nBits & MenuItemBits::POPUPSELECT )
+                    {
+                        // only when clicked over the arrow...
+                        Size aSz = GetOutputSizePixel();
+                        long nFontHeight = GetTextHeight();
+                        bPopupArea = ( rMEvt.GetPosPixel().X() >= ( aSz.Width() - nFontHeight - nFontHeight/4 ) );
+                    }
+
+                    if ( bMBDown )
+                    {
+                        if ( n != nHighlightedItem )
+                        {
+                            ChangeHighlightItem( static_cast<sal_uInt16>(n), false );
+                        }
+
+                        bool bAllowNewPopup = true;
+                        if ( pActivePopup )
+                        {
+                            MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
+                            bAllowNewPopup = pData && ( pData->pSubMenu != pActivePopup );
+                            if ( bAllowNewPopup )
+                                KillActivePopup();
+                        }
+
+                        if ( bPopupArea && bAllowNewPopup )
+                        {
+                            HighlightChanged( nullptr );
+                        }
+                    }
+                    else
+                    {
+                        if ( n != nHighlightedItem )
+                        {
+                            ChangeHighlightItem( static_cast<sal_uInt16>(n), true );
+                        }
+                        else if ( pItemData->nBits & MenuItemBits::POPUPSELECT )
+                        {
+                            if ( bPopupArea && ( pActivePopup != pItemData->pSubMenu ) )
+                                HighlightChanged( nullptr );
+                        }
+                    }
+                    bHighlighted = true;
+                }
+            }
+        }
+        if ( !bHighlighted )
+            ChangeHighlightItem( ITEMPOS_INVALID, true );
+    }
+    else
+    {
+        ImplScroll( rMEvt.GetPosPixel() );
+        ChangeHighlightItem( ITEMPOS_INVALID, true );
+    }
+}
+
+IMPL_LINK_NOARG(MenuFloatingWindow, PopupEnd, FloatingWindow*, void)
+{
+    // "this" will be deleted before the end of this method!
+    Menu* pM = pMenu;
+    if ( bInExecute )
+    {
+        End();
+        if ( pActivePopup )
+        {
+            KillActivePopup(); // should be ok to just remove it
+            //pActivePopup->bCanceled = true;
+        }
+        pMenu->bInCallback = true;
+        pMenu->Deactivate();
+        pMenu->bInCallback = false;
+    }
+    else
+    {
+        if (pMenu && pMenu->pStartedFrom)
+            pMenu->pStartedFrom->ClosePopup(pMenu);
+    }
+
+    if ( pM )
+        pM->pStartedFrom = nullptr;
+}
+
+IMPL_LINK_NOARG(MenuFloatingWindow, AutoScroll, Timer *, void)
+{
+    ImplScroll( GetPointerPosPixel() );
+}
+
+IMPL_LINK( MenuFloatingWindow, HighlightChanged, Timer*, pTimer, void )
+{
+    if( ! pMenu )
+        return;
+
+    MenuItemData* pItemData = pMenu->pItemList->GetDataFromPos( nHighlightedItem );
+    if ( pItemData )
+    {
+        if ( pActivePopup && ( pActivePopup != pItemData->pSubMenu ) )
+        {
+            FloatWinPopupFlags nOldFlags = GetPopupModeFlags();
+            SetPopupModeFlags( GetPopupModeFlags() | FloatWinPopupFlags::NoAppFocusClose );
+            KillActivePopup();
+            SetPopupModeFlags( nOldFlags );
+        }
+        if ( pItemData->bEnabled && pItemData->pSubMenu && pItemData->pSubMenu->GetItemCount() && ( pItemData->pSubMenu != pActivePopup ) )
+        {
+            pActivePopup = static_cast<PopupMenu*>(pItemData->pSubMenu.get());
+            long nY = nScrollerHeight+ImplGetStartY();
+            MenuItemData* pData = nullptr;
+            for ( sal_uLong n = 0; n < nHighlightedItem; n++ )
+            {
+                pData = pMenu->pItemList->GetDataFromPos( n );
+                nY += pData->aSz.Height();
+            }
+            pData = pMenu->pItemList->GetDataFromPos( nHighlightedItem );
+            Size MySize = GetOutputSizePixel();
+            Point aItemTopLeft( 0, nY );
+            Point aItemBottomRight( aItemTopLeft );
+            aItemBottomRight.AdjustX(MySize.Width() );
+            aItemBottomRight.AdjustY(pData->aSz.Height() );
+
+            // shift the popups a little
+            aItemTopLeft.AdjustX(2 );
+            aItemBottomRight.AdjustX( -2 );
+            if ( nHighlightedItem )
+                aItemTopLeft.AdjustY( -2 );
+            else
+            {
+                sal_Int32 nL, nT, nR, nB;
+                GetBorder( nL, nT, nR, nB );
+                aItemTopLeft.AdjustY( -nT );
+            }
+
+            // pTest: crash due to Reschedule() in call of Activate()
+            // Also it is prevented that submenus are displayed which
+            // were for long in Activate Rescheduled and which should not be
+            // displayed now.
+            Menu* pTest = pActivePopup;
+            FloatWinPopupFlags nOldFlags = GetPopupModeFlags();
+            SetPopupModeFlags( GetPopupModeFlags() | FloatWinPopupFlags::NoAppFocusClose );
+            sal_uInt16 nRet = pActivePopup->ImplExecute( this, tools::Rectangle( aItemTopLeft, aItemBottomRight ), FloatWinPopupFlags::Right, pMenu, pTimer == nullptr );
+            SetPopupModeFlags( nOldFlags );
+
+            // nRet != 0, if it was stopped during Activate()...
+            if ( !nRet && ( pActivePopup == pTest ) && pActivePopup->ImplGetWindow() )
+                pActivePopup->ImplGetFloatingWindow()->AddPopupModeWindow( this );
+        }
+    }
+}
+
+IMPL_LINK_NOARG(MenuFloatingWindow, SubmenuClose, Timer *, void)
+{
+    if( pMenu && pMenu->pStartedFrom )
+    {
+        MenuFloatingWindow* pWin = static_cast<MenuFloatingWindow*>(pMenu->pStartedFrom->GetWindow());
+        if( pWin )
+            pWin->KillActivePopup();
+    }
+}
+
+IMPL_LINK( MenuFloatingWindow, ShowHideListener, VclWindowEvent&, rEvent, void )
+{
+    if( ! pMenu )
+        return;
+
+    if( rEvent.GetId() == VclEventId::WindowShow )
+        pMenu->ImplCallEventListeners( VclEventId::MenuShow, ITEMPOS_INVALID );
+    else if( rEvent.GetId() == VclEventId::WindowHide )
+        pMenu->ImplCallEventListeners( VclEventId::MenuHide, ITEMPOS_INVALID );
+}
+
+void MenuFloatingWindow::EnableScrollMenu( bool b )
+{
+    bScrollMenu = b;
+    nScrollerHeight = b ? static_cast<sal_uInt16>(GetSettings().GetStyleSettings().GetScrollBarSize()) /2 : 0;
+    bScrollDown = true;
+    InitMenuClipRegion(*this);
+}
+
+void MenuFloatingWindow::Start()
+{
+    if (bInExecute)
+        return;
+    bInExecute = true;
+    if (GetParent())
+        GetParent()->IncModalCount();
+}
+
+bool MenuFloatingWindow::MenuInHierarchyHasFocus() const
+{
+    if (HasChildPathFocus())
+        return true;
+    PopupMenu* pSub = GetActivePopup();
+    if (!pSub)
+        return false;
+    return pSub->ImplGetFloatingWindow()->HasChildPathFocus();
+}
+
+void MenuFloatingWindow::End()
+{
+    if (!bInExecute)
+        return;
+
+    if (GetParent() && !GetParent()->IsDisposed())
+        GetParent()->DecModalCount();
+
+    // restore focus to previous window if we still have the focus
+    VclPtr<vcl::Window> xFocusId(xSaveFocusId);
+    xSaveFocusId = nullptr;
+    if (xFocusId != nullptr && MenuInHierarchyHasFocus())
+    {
+        ImplGetSVData()->mpWinData->mbNoDeactivate = false;
+        Window::EndSaveFocus(xFocusId);
+    }
+
+    bInExecute = false;
+}
+
+void MenuFloatingWindow::Execute()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+
+    pSVData->maAppData.mpActivePopupMenu = static_cast<PopupMenu*>(pMenu.get());
+
+    Start();
+
+    while (bInExecute)
+        Application::Yield();
+
+    pSVData->maAppData.mpActivePopupMenu = nullptr;
+}
+
+void MenuFloatingWindow::StopExecute()
+{
+    End();
+
+    ImplEndPopupMode(FloatWinPopupEndFlags::NONE, xSaveFocusId);
+
+    aHighlightChangedTimer.Stop();
+    if (pActivePopup)
+    {
+        KillActivePopup();
+    }
+    // notify parent, needed for accessibility
+    if( pMenu && pMenu->pStartedFrom )
+        pMenu->pStartedFrom->ImplCallEventListeners( VclEventId::MenuSubmenuDeactivate, nPosInParent );
+}
+
+void MenuFloatingWindow::KillActivePopup( PopupMenu* pThisOnly )
+{
+    if ( pActivePopup && ( !pThisOnly || ( pThisOnly == pActivePopup ) ) )
+    {
+        if( pActivePopup->pWindow )
+            if( static_cast<FloatingWindow *>(pActivePopup->pWindow.get())->IsInCleanUp() )
+                return; // kill it later
+        if ( pActivePopup->bInCallback )
+            pActivePopup->bCanceled = true;
+
+        // For all actions pActivePopup = 0, if e.g.
+        // PopupModeEndHdl the popups to destroy were called synchronous
+        PopupMenu* pPopup = pActivePopup;
+        pActivePopup = nullptr;
+        pPopup->bInCallback = true;
+        pPopup->Deactivate();
+        pPopup->bInCallback = false;
+        if ( pPopup->ImplGetWindow() )
+        {
+            pPopup->ImplGetFloatingWindow()->StopExecute();
+            pPopup->ImplGetFloatingWindow()->doShutdown();
+            pPopup->pWindow->SetParentToDefaultWindow();
+            pPopup->pWindow.disposeAndClear();
+
+            PaintImmediately();
+        }
+    }
+}
+
+void MenuFloatingWindow::EndExecute()
+{
+    Menu* pStart = pMenu ? pMenu->ImplGetStartMenu() : nullptr;
+
+    // if started elsewhere, cleanup there as well
+    MenuFloatingWindow* pCleanUpFrom = this;
+    MenuFloatingWindow* pWin = this;
+    while (pWin && !pWin->bInExecute &&
+        pWin->pMenu->pStartedFrom && !pWin->pMenu->pStartedFrom->IsMenuBar())
+    {
+        pWin = static_cast<PopupMenu*>(pWin->pMenu->pStartedFrom.get())->ImplGetFloatingWindow();
+    }
+    if ( pWin )
+        pCleanUpFrom = pWin;
+
+    // this window will be destroyed => store date locally...
+    Menu* pM = pMenu;
+    sal_uInt16 nItem = nHighlightedItem;
+
+    pCleanUpFrom->StopExecute();
+
+    if ( nItem != ITEMPOS_INVALID && pM )
+    {
+        MenuItemData* pItemData = pM->GetItemList()->GetDataFromPos( nItem );
+        if ( pItemData && !pItemData->bIsTemporary )
+        {
+            pM->nSelectedId = pItemData->nId;
+            pM->sSelectedIdent = pItemData->sIdent;
+            if (pStart)
+            {
+                pStart->nSelectedId = pItemData->nId;
+                pStart->sSelectedIdent = pItemData->sIdent;
+            }
+
+            pM->ImplSelect();
+        }
+    }
+}
+
+void MenuFloatingWindow::EndExecute( sal_uInt16 nId )
+{
+    size_t nPos;
+    if ( pMenu && pMenu->GetItemList()->GetData( nId, nPos ) )
+        nHighlightedItem = nPos;
+    else
+        nHighlightedItem = ITEMPOS_INVALID;
+
+    EndExecute();
+}
+
+void MenuFloatingWindow::MouseButtonDown( const MouseEvent& rMEvt )
+{
+    // TH creates a ToTop on this window, but the active popup
+    // should stay on top...
+    // due to focus change this would close all menus -> don't do it (#94123)
+    //if ( pActivePopup && pActivePopup->ImplGetWindow() && !pActivePopup->ImplGetFloatingWindow()->pActivePopup )
+    //    pActivePopup->ImplGetFloatingWindow()->ToTop( ToTopFlags::NoGrabFocus );
+
+    ImplHighlightItem( rMEvt, true );
+
+    nMBDownPos = nHighlightedItem;
+}
+
+void MenuFloatingWindow::MouseButtonUp( const MouseEvent& rMEvt )
+{
+    MenuItemData* pData = pMenu ? pMenu->GetItemList()->GetDataFromPos( nHighlightedItem ) : nullptr;
+    // nMBDownPos store in local variable and reset immediately,
+    // as it will be too late after EndExecute
+    sal_uInt16 _nMBDownPos = nMBDownPos;
+    nMBDownPos = ITEMPOS_INVALID;
+    if ( pData && pData->bEnabled && ( pData->eType != MenuItemType::SEPARATOR ) )
+    {
+        if ( !pData->pSubMenu )
+        {
+            EndExecute();
+        }
+        else if ( ( pData->nBits & MenuItemBits::POPUPSELECT ) && ( nHighlightedItem == _nMBDownPos ) && ( rMEvt.GetClicks() == 2 ) )
+        {
+            // not when clicked over the arrow...
+            Size aSz = GetOutputSizePixel();
+            long nFontHeight = GetTextHeight();
+            if ( rMEvt.GetPosPixel().X() < ( aSz.Width() - nFontHeight - nFontHeight/4 ) )
+                EndExecute();
+        }
+    }
+
+}
+
+void MenuFloatingWindow::MouseMove( const MouseEvent& rMEvt )
+{
+    if ( !IsVisible() || rMEvt.IsSynthetic() || rMEvt.IsEnterWindow() )
+        return;
+
+    if ( rMEvt.IsLeaveWindow() )
+    {
+        // #102461# do not remove highlight if a popup menu is open at this position
+        MenuItemData* pData = pMenu ? pMenu->pItemList->GetDataFromPos( nHighlightedItem ) : nullptr;
+        // close popup with some delayed if we leave somewhere else
+        if( pActivePopup && pData && pData->pSubMenu != pActivePopup )
+            pActivePopup->ImplGetFloatingWindow()->aSubmenuCloseTimer.Start();
+
+        if( !pActivePopup || (pData && pData->pSubMenu != pActivePopup ) )
+            ChangeHighlightItem( ITEMPOS_INVALID, false );
+
+        if ( IsScrollMenu() )
+            ImplScroll( rMEvt.GetPosPixel() );
+    }
+    else
+    {
+        aSubmenuCloseTimer.Stop();
+        if( bIgnoreFirstMove )
+            bIgnoreFirstMove = false;
+        else
+            ImplHighlightItem( rMEvt, false );
+    }
+}
+
+void MenuFloatingWindow::ImplScroll( bool bUp )
+{
+    KillActivePopup();
+    PaintImmediately();
+
+    if (!pMenu)
+        return;
+
+    Invalidate();
+
+    pMenu->ImplKillLayoutData();
+
+    if ( bScrollUp && bUp )
+    {
+        nFirstEntry = pMenu->ImplGetPrevVisible( nFirstEntry );
+        SAL_WARN_IF( nFirstEntry == ITEMPOS_INVALID, "vcl", "Scroll?!" );
+
+        // avoid crash if somehow menu got disposed, and MenuItemList is empty (workaround for tdf#104686)
+        const auto pItemData = pMenu->GetItemList()->GetDataFromPos( nFirstEntry );
+        if ( pItemData )
+        {
+            long nScrollEntryHeight = pItemData->aSz.Height();
+
+            if ( !bScrollDown )
+            {
+                bScrollDown = true;
+                Invalidate();
+            }
+
+            if ( pMenu->ImplGetPrevVisible( nFirstEntry ) == ITEMPOS_INVALID )
+            {
+                bScrollUp = false;
+                Invalidate();
+            }
+
+            Scroll( 0, nScrollEntryHeight, ImplCalcClipRegion().GetBoundRect(), ScrollFlags::Clip );
+        }
+    }
+    else if ( bScrollDown && !bUp )
+    {
+        // avoid crash if somehow menu got disposed, and MenuItemList is empty (workaround for tdf#104686)
+        const auto pItemData = pMenu->GetItemList()->GetDataFromPos( nFirstEntry );
+        if ( pItemData )
+        {
+            long nScrollEntryHeight = pItemData->aSz.Height();
+
+            nFirstEntry = pMenu->ImplGetNextVisible( nFirstEntry );
+            SAL_WARN_IF( nFirstEntry == ITEMPOS_INVALID, "vcl", "Scroll?!" );
+
+            if ( !bScrollUp )
+            {
+                bScrollUp = true;
+                Invalidate();
+            }
+
+            long nHeight = GetOutputSizePixel().Height();
+            sal_uInt16 nLastVisible;
+            static_cast<PopupMenu*>(pMenu.get())->ImplCalcVisEntries( nHeight, nFirstEntry, &nLastVisible );
+            if ( pMenu->ImplGetNextVisible( nLastVisible ) == ITEMPOS_INVALID )
+            {
+                bScrollDown = false;
+                Invalidate();
+            }
+
+            Scroll( 0, -nScrollEntryHeight, ImplCalcClipRegion().GetBoundRect(), ScrollFlags::Clip );
+        }
+    }
+
+    Invalidate();
+}
+
+void MenuFloatingWindow::ImplScroll( const Point& rMousePos )
+{
+    Size aOutSz = GetOutputSizePixel();
+
+    long nY = nScrollerHeight;
+    long nMouseY = rMousePos.Y();
+    long nDelta = 0;
+
+    if ( bScrollUp && ( nMouseY < nY ) )
+    {
+        ImplScroll( true );
+        nDelta = nY - nMouseY;
+    }
+    else if ( bScrollDown && ( nMouseY > ( aOutSz.Height() - nY ) ) )
+    {
+        ImplScroll( false );
+        nDelta = nMouseY - ( aOutSz.Height() - nY );
+    }
+
+    if ( nDelta )
+    {
+        aScrollTimer.Stop();    // if scrolled through MouseMove.
+        long nTimeout;
+        if ( nDelta < 3 )
+            nTimeout = 200;
+        else if ( nDelta < 5 )
+            nTimeout = 100;
+        else if ( nDelta < 8 )
+            nTimeout = 70;
+        else if ( nDelta < 12 )
+            nTimeout = 40;
+        else
+            nTimeout = 20;
+        aScrollTimer.SetTimeout( nTimeout );
+        aScrollTimer.Start();
+    }
+}
+void MenuFloatingWindow::ChangeHighlightItem( sal_uInt16 n, bool bStartPopupTimer )
+{
+    // #57934# if necessary, immediately close the active, as TH's backgroundstorage works.
+    // #65750# we prefer to refrain from the background storage of small lines.
+    //         otherwise the menus are difficult to operate.
+    //  MenuItemData* pNextData = pMenu->pItemList->GetDataFromPos( n );
+    //  if ( pActivePopup && pNextData && ( pActivePopup != pNextData->pSubMenu ) )
+    //      KillActivePopup();
+
+    aSubmenuCloseTimer.Stop();
+    if( ! pMenu )
+        return;
+
+    if ( nHighlightedItem != ITEMPOS_INVALID )
+    {
+        InvalidateItem(nHighlightedItem);
+        pMenu->ImplCallEventListeners( VclEventId::MenuDehighlight, nHighlightedItem );
+    }
+
+    nHighlightedItem = n;
+    SAL_WARN_IF( !pMenu->ImplIsVisible( nHighlightedItem ) && nHighlightedItem != ITEMPOS_INVALID, "vcl", "ChangeHighlightItem: Not visible!" );
+    if( nHighlightedItem != ITEMPOS_INVALID )
+    {
+        if (pMenu->pStartedFrom && !pMenu->pStartedFrom->IsMenuBar())
+        {
+            // #102461# make sure parent entry is highlighted as well
+            size_t i, nCount = pMenu->pStartedFrom->pItemList->size();
+            for(i = 0; i < nCount; i++)
+            {
+                MenuItemData* pData = pMenu->pStartedFrom->pItemList->GetDataFromPos( i );
+                if( pData && ( pData->pSubMenu == pMenu ) )
+                    break;
+            }
+            if( i < nCount )
+            {
+                MenuFloatingWindow* pPWin = static_cast<MenuFloatingWindow*>(pMenu->pStartedFrom->ImplGetWindow());
+                if( pPWin && pPWin->nHighlightedItem != i )
+                {
+                    pPWin->InvalidateItem(i);
+                    pPWin->nHighlightedItem = i;
+                }
+            }
+        }
+        InvalidateItem(nHighlightedItem);
+        pMenu->ImplCallHighlight( nHighlightedItem );
+    }
+    else
+    {
+        pMenu->nSelectedId = 0;
+        pMenu->sSelectedIdent.clear();
+    }
+
+    if ( bStartPopupTimer )
+    {
+        // #102438# Menu items are not selectable
+        // If a menu item is selected by an AT-tool via the XAccessibleAction, XAccessibleValue
+        // or XAccessibleSelection interface, and the parent popup menus are not executed yet,
+        // the parent popup menus must be executed SYNCHRONOUSLY, before the menu item is selected.
+        if ( GetSettings().GetMouseSettings().GetMenuDelay() )
+            aHighlightChangedTimer.Start();
+        else
+            HighlightChanged( &aHighlightChangedTimer );
+    }
+}
+
+/// Calculate the initial vertical pixel offset of the first item.
+/// May be negative for scrolled windows.
+long MenuFloatingWindow::GetInitialItemY(long *pStartY) const
+{
+    long nStartY = ImplGetStartY();
+    if (pStartY)
+        *pStartY = nStartY;
+    return nScrollerHeight + nStartY +
+        ImplGetSVData()->maNWFData.mnMenuFormatBorderY;
+}
+
+/// Emit an Invalidate just for this item's area
+void MenuFloatingWindow::InvalidateItem(sal_uInt16 nPos)
+{
+    if (!pMenu)
+        return;
+
+    long nY = GetInitialItemY();
+    size_t nCount = pMenu->pItemList->size();
+    for (size_t n = 0; n < nCount; n++)
+    {
+        MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
+        long nHeight = pData->aSz.Height();
+        if (n == nPos)
+        {
+            Size aWidth( GetSizePixel() );
+            tools::Rectangle aRect(Point(0, nY), Size(aWidth.Width(), nHeight));
+            Invalidate( aRect );
+        }
+        nY += nHeight;
+    }
+}
+
+void MenuFloatingWindow::RenderHighlightItem(vcl::RenderContext& rRenderContext, sal_uInt16 nPos)
+{
+    if (!pMenu)
+        return;
+
+    Size aSz(GetOutputSizePixel());
+
+    long nX = 0;
+    long nStartY;
+    long nY = GetInitialItemY(&nStartY);
+
+    int nOuterSpaceX = ImplGetSVData()->maNWFData.mnMenuFormatBorderX;
+
+    size_t nCount = pMenu->pItemList->size();
+    for (size_t n = 0; n < nCount; n++)
+    {
+        MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
+        if (n == nPos)
+        {
+            SAL_WARN_IF(!pMenu->ImplIsVisible(n), "vcl", "Highlight: Item not visible!");
+            if (pData->eType != MenuItemType::SEPARATOR)
+            {
+                bool bRestoreLineColor = false;
+                Color oldLineColor;
+                bool bDrawItemRect = true;
+
+                tools::Rectangle aItemRect(Point(nX + nOuterSpaceX, nY), Size(aSz.Width() - 2 * nOuterSpaceX, pData->aSz.Height()));
+                if (pData->nBits & MenuItemBits::POPUPSELECT)
+                {
+                    long nFontHeight = GetTextHeight();
+                    aItemRect.AdjustRight( -(nFontHeight + nFontHeight / 4) );
+                }
+
+                if (rRenderContext.IsNativeControlSupported(ControlType::MenuPopup, ControlPart::Entire))
+                {
+                    Size aPxSize(GetOutputSizePixel());
+                    rRenderContext.Push(PushFlags::CLIPREGION);
+                    rRenderContext.IntersectClipRegion(tools::Rectangle(Point(nX, nY), Size(aSz.Width(), pData->aSz.Height())));
+                    tools::Rectangle aCtrlRect(Point(nX, 0), Size(aPxSize.Width()-nX, aPxSize.Height()));
+                    MenupopupValue aVal(pMenu->nTextPos-GUTTERBORDER, aItemRect);
+                    rRenderContext.DrawNativeControl(ControlType::MenuPopup, ControlPart::Entire,
+                                                     aCtrlRect, ControlState::ENABLED, aVal, OUString());
+                    if (rRenderContext.IsNativeControlSupported(ControlType::MenuPopup, ControlPart::MenuItem))
+                    {
+                        bDrawItemRect = false;
+                        if (!rRenderContext.DrawNativeControl(ControlType::MenuPopup, ControlPart::MenuItem, aItemRect,
+                                                              ControlState::SELECTED | (pData->bEnabled
+                                                                                            ? ControlState::ENABLED
+                                                                                            : ControlState::NONE),
+                                                              aVal, OUString()))
+                        {
+                            bDrawItemRect = true;
+                        }
+                    }
+                    else
+                        bDrawItemRect = true;
+                    rRenderContext.Pop();
+                }
+                if (bDrawItemRect)
+                {
+                    if (pData->bEnabled)
+                        rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetMenuHighlightColor());
+                    else
+                    {
+                        rRenderContext.SetFillColor();
+                        oldLineColor = rRenderContext.GetLineColor();
+                        rRenderContext.SetLineColor(rRenderContext.GetSettings().GetStyleSettings().GetMenuHighlightColor());
+                        bRestoreLineColor = true;
+                    }
+
+                    rRenderContext.DrawRect(aItemRect);
+                }
+                pMenu->ImplPaint(rRenderContext, GetOutputSizePixel(), nScrollerHeight, nStartY, pData, true/*bHighlight*/);
+                if (bRestoreLineColor)
+                    rRenderContext.SetLineColor(oldLineColor);
+            }
+            return;
+        }
+
+        nY += pData->aSz.Height();
+    }
+}
+
+tools::Rectangle MenuFloatingWindow::ImplGetItemRect( sal_uInt16 nPos )
+{
+    if( ! pMenu )
+        return tools::Rectangle();
+
+    tools::Rectangle aRect;
+    Size    aSz = GetOutputSizePixel();
+    long    nStartY = ImplGetStartY();
+    long    nY = nScrollerHeight+nStartY;
+
+    size_t nCount = pMenu->pItemList->size();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        MenuItemData* pData = pMenu->pItemList->GetDataFromPos( n );
+        if ( n == nPos )
+        {
+            SAL_WARN_IF( !pMenu->ImplIsVisible( n ), "vcl", "ImplGetItemRect: Item not visible!" );
+            if ( pData->eType != MenuItemType::SEPARATOR )
+            {
+                aRect = tools::Rectangle( Point( 0, nY ), Size( aSz.Width(), pData->aSz.Height() ) );
+                if ( pData->nBits & MenuItemBits::POPUPSELECT )
+                {
+                    long nFontHeight = GetTextHeight();
+                    aRect.AdjustRight( -(nFontHeight + nFontHeight/4) );
+                }
+            }
+            break;
+        }
+        nY += pData->aSz.Height();
+    }
+    return aRect;
+}
+
+void MenuFloatingWindow::ImplCursorUpDown( bool bUp, bool bHomeEnd )
+{
+    if( ! pMenu )
+        return;
+
+    const StyleSettings& rSettings = GetSettings().GetStyleSettings();
+
+    sal_uInt16 n = nHighlightedItem;
+    if ( n == ITEMPOS_INVALID )
+    {
+        if ( bUp )
+            n = 0;
+        else
+            n = pMenu->GetItemCount()-1;
+    }
+
+    sal_uInt16 nLoop = n;
+
+    if( bHomeEnd )
+    {
+        // absolute positioning
+        if( bUp )
+        {
+            n = pMenu->GetItemCount();
+            nLoop = n-1;
+        }
+        else
+        {
+            n = sal_uInt16(-1);
+            nLoop = n+1;
+        }
+    }
+
+    do
+    {
+        if ( bUp )
+        {
+            if ( n )
+                n--;
+            else
+                if ( !IsScrollMenu() || ( nHighlightedItem == ITEMPOS_INVALID ) )
+                    n = pMenu->GetItemCount()-1;
+                else
+                    break;
+        }
+        else
+        {
+            n++;
+            if ( n >= pMenu->GetItemCount() )
+            {
+                if ( !IsScrollMenu() || ( nHighlightedItem == ITEMPOS_INVALID ) )
+                    n = 0;
+                else
+                    break;
+            }
+        }
+
+        MenuItemData* pData = pMenu->GetItemList()->GetDataFromPos( n );
+        if ( ( pData->bEnabled || !rSettings.GetSkipDisabledInMenus() )
+              && ( pData->eType != MenuItemType::SEPARATOR ) && pMenu->ImplIsVisible( n ) && pMenu->ImplIsSelectable( n ) )
+        {
+            // Is selection in visible area?
+            if ( IsScrollMenu() )
+            {
+                ChangeHighlightItem( ITEMPOS_INVALID, false );
+
+                while ( n < nFirstEntry )
+                    ImplScroll( true );
+
+                Size aOutSz = GetOutputSizePixel();
+                sal_uInt16 nLastVisible;
+                static_cast<PopupMenu*>(pMenu.get())->ImplCalcVisEntries( aOutSz.Height(), nFirstEntry, &nLastVisible );
+                while ( n > nLastVisible )
+                {
+                    ImplScroll( false );
+                    static_cast<PopupMenu*>(pMenu.get())->ImplCalcVisEntries( aOutSz.Height(), nFirstEntry, &nLastVisible );
+                }
+            }
+            ChangeHighlightItem( n, false );
+            break;
+        }
+    } while ( n != nLoop );
+}
+
+void MenuFloatingWindow::KeyInput( const KeyEvent& rKEvent )
+{
+    VclPtr<vcl::Window> xWindow = this;
+
+    bool autoacc = ImplGetSVData()->maNWFData.mbAutoAccel;
+    sal_uInt16 nCode = rKEvent.GetKeyCode().GetCode();
+    bKeyInput = true;
+    switch ( nCode )
+    {
+        case KEY_UP:
+        case KEY_DOWN:
+        {
+            ImplCursorUpDown( nCode == KEY_UP );
+        }
+        break;
+        case KEY_END:
+        case KEY_HOME:
+        {
+            ImplCursorUpDown( nCode == KEY_END, true );
+        }
+        break;
+        case KEY_F6:
+        case KEY_ESCAPE:
+        {
+            // Ctrl-F6 acts like ESC here, the menu bar however will then put the focus in the document
+            if( nCode == KEY_F6 && !rKEvent.GetKeyCode().IsMod1() )
+                break;
+            if( pMenu )
+            {
+                if ( !pMenu->pStartedFrom )
+                {
+                    StopExecute();
+                    KillActivePopup();
+                }
+                else if (pMenu->pStartedFrom->IsMenuBar())
+                {
+                    pMenu->pStartedFrom->MenuBarKeyInput(rKEvent);
+                }
+                else
+                {
+                    StopExecute();
+                    PopupMenu* pPopupMenu = static_cast<PopupMenu*>(pMenu->pStartedFrom.get());
+                    MenuFloatingWindow* pFloat = pPopupMenu->ImplGetFloatingWindow();
+                    pFloat->GrabFocus();
+                    pFloat->KillActivePopup();
+                    pPopupMenu->ImplCallHighlight(pFloat->nHighlightedItem);
+                }
+            }
+        }
+        break;
+        case KEY_LEFT:
+        {
+            if ( pMenu && pMenu->pStartedFrom )
+            {
+                StopExecute();
+                if (pMenu->pStartedFrom->IsMenuBar())
+                {
+                    pMenu->pStartedFrom->MenuBarKeyInput(rKEvent);
+                }
+                else
+                {
+                    MenuFloatingWindow* pFloat = static_cast<PopupMenu*>(pMenu->pStartedFrom.get())->ImplGetFloatingWindow();
+                    pFloat->GrabFocus();
+                    pFloat->KillActivePopup();
+                    sal_uInt16 highlightItem = pFloat->GetHighlightedItem();
+                    pFloat->ChangeHighlightItem(highlightItem, false);
+                }
+            }
+        }
+        break;
+        case KEY_RIGHT:
+        {
+            if( pMenu )
+            {
+                bool bDone = false;
+                if ( nHighlightedItem != ITEMPOS_INVALID )
+                {
+                    MenuItemData* pData = pMenu->GetItemList()->GetDataFromPos( nHighlightedItem );
+                    if ( pData && pData->pSubMenu )
+                    {
+                        HighlightChanged( nullptr );
+                        bDone = true;
+                    }
+                }
+                if ( !bDone )
+                {
+                    Menu* pStart = pMenu->ImplGetStartMenu();
+                    if (pStart && pStart->IsMenuBar())
+                    {
+                        // Forward...
+                        pStart->ImplGetWindow()->KeyInput( rKEvent );
+                    }
+                }
+            }
+        }
+        break;
+        case KEY_RETURN:
+        {
+            if( pMenu )
+            {
+                MenuItemData* pData = pMenu->GetItemList()->GetDataFromPos( nHighlightedItem );
+                if ( pData && pData->bEnabled )
+                {
+                    if ( pData->pSubMenu )
+                        HighlightChanged( nullptr );
+                    else
+                        EndExecute();
+                }
+                else
+                    StopExecute();
+            }
+        }
+        break;
+        case KEY_MENU:
+        {
+            if( pMenu )
+            {
+                Menu* pStart = pMenu->ImplGetStartMenu();
+                if (pStart && pStart->IsMenuBar())
+                {
+                    // Forward...
+                    pStart->ImplGetWindow()->KeyInput( rKEvent );
+                }
+            }
+        }
+        break;
+        default:
+        {
+            sal_Unicode nCharCode = rKEvent.GetCharCode();
+            size_t nPos = 0;
+            size_t nDuplicates = 0;
+            MenuItemData* pData = (nCharCode && pMenu) ?
+                pMenu->GetItemList()->SearchItem(nCharCode, rKEvent.GetKeyCode(), nPos, nDuplicates, nHighlightedItem) : nullptr;
+            if (pData)
+            {
+                if ( pData->pSubMenu || nDuplicates > 1 )
+                {
+                    ChangeHighlightItem( nPos, false );
+                    HighlightChanged( nullptr );
+                }
+                else
+                {
+                    nHighlightedItem = nPos;
+                    EndExecute();
+                }
+            }
+            else
+                FloatingWindow::KeyInput( rKEvent );
+        }
+    }
+
+    if (pMenu && pMenu->pStartedFrom && pMenu->pStartedFrom->IsMenuBar())
+    {
+        MenuBar *pMenuBar = static_cast<MenuBar*>(pMenu->pStartedFrom.get());
+        const bool bShowAccels = nCode != KEY_ESCAPE;
+        if (pMenuBar->getMenuBarWindow()->GetMBWMenuKey() != bShowAccels)
+        {
+            pMenuBar->getMenuBarWindow()->SetMBWMenuKey(bShowAccels);
+            pMenuBar->getMenuBarWindow()->SetMBWHideAccel(!bShowAccels);
+            if (autoacc)
+                Invalidate(InvalidateFlags::Update);
+        }
+    }
+
+    // #105474# check if menu window was not destroyed
+    if ( !xWindow->IsDisposed() )
+    {
+        bKeyInput = false;
+    }
+}
+
+void MenuFloatingWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle &rPaintRect)
+{
+    if (!pMenu)
+        return;
+
+    // Set the clip before the buffering starts: rPaintRect may be larger than the current clip,
+    // this way the buffer -> render context copy happens with this clip.
+    rRenderContext.Push(PushFlags::CLIPREGION);
+    rRenderContext.SetClipRegion(vcl::Region(rPaintRect));
+
+    // Make sure that all actual rendering happens in one go to avoid flicker.
+    vcl::BufferDevice pBuffer(this, rRenderContext);
+
+    if (rRenderContext.IsNativeControlSupported(ControlType::MenuPopup, ControlPart::Entire))
+    {
+        pBuffer->SetClipRegion();
+        long nX = 0;
+        Size aPxSize(GetOutputSizePixel());
+        aPxSize.AdjustWidth( -nX );
+        ImplControlValue aVal(pMenu->nTextPos - GUTTERBORDER);
+        pBuffer->DrawNativeControl(ControlType::MenuPopup, ControlPart::Entire,
+                                   tools::Rectangle(Point(nX, 0), aPxSize), ControlState::ENABLED,
+                                   aVal, OUString());
+        InitMenuClipRegion(*pBuffer);
+    }
+    if (IsScrollMenu())
+    {
+        ImplDrawScroller(*pBuffer, true);
+        ImplDrawScroller(*pBuffer, false);
+    }
+    pBuffer->SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetMenuColor());
+    pMenu->ImplPaint(*pBuffer, GetOutputSizePixel(), nScrollerHeight, ImplGetStartY());
+    if (nHighlightedItem != ITEMPOS_INVALID)
+        RenderHighlightItem(*pBuffer, nHighlightedItem);
+
+    pBuffer.Dispose();
+    rRenderContext.Pop();
+}
+
+void MenuFloatingWindow::ImplDrawScroller(vcl::RenderContext& rRenderContext, bool bUp)
+{
+    if (!pMenu)
+        return;
+
+    rRenderContext.SetClipRegion();
+
+    Size aOutSz(GetOutputSizePixel());
+    long nY = bUp ? 0 : (aOutSz.Height() - nScrollerHeight);
+    long nX = 0;
+    tools::Rectangle aRect(Point(nX, nY), Size(aOutSz.Width() - nX, nScrollerHeight));
+
+    DecorationView aDecoView(&rRenderContext);
+    SymbolType eSymbol = bUp ? SymbolType::SPIN_UP : SymbolType::SPIN_DOWN;
+
+    DrawSymbolFlags nStyle = DrawSymbolFlags::NONE;
+    if ((bUp && !bScrollUp) || (!bUp && !bScrollDown))
+        nStyle |= DrawSymbolFlags::Disable;
+
+    aDecoView.DrawSymbol(aRect, eSymbol, rRenderContext.GetSettings().GetStyleSettings().GetButtonTextColor(), nStyle);
+
+    InitMenuClipRegion(rRenderContext);
+}
+
+void MenuFloatingWindow::RequestHelp( const HelpEvent& rHEvt )
+{
+    sal_uInt16 nId = nHighlightedItem;
+    Menu* pM = pMenu;
+    vcl::Window* pW = this;
+
+    // #102618# Get item rect before destroying the window in EndExecute() call
+    tools::Rectangle aHighlightRect( ImplGetItemRect( nHighlightedItem ) );
+
+    if ( rHEvt.GetMode() & HelpEventMode::CONTEXT )
+    {
+        nHighlightedItem = ITEMPOS_INVALID;
+        EndExecute();
+        pW = nullptr;
+    }
+
+    if( !ImplHandleHelpEvent( pW, pM, nId, rHEvt, aHighlightRect ) )
+        Window::RequestHelp( rHEvt );
+}
+
+void MenuFloatingWindow::StateChanged( StateChangedType nType )
+{
+    FloatingWindow::StateChanged( nType );
+
+    if ( ( nType == StateChangedType::ControlForeground ) || ( nType == StateChangedType::ControlBackground ) )
+    {
+        ApplySettings(*this);
+        Invalidate();
+    }
+}
+
+void MenuFloatingWindow::DataChanged( const DataChangedEvent& rDCEvt )
+{
+    FloatingWindow::DataChanged( rDCEvt );
+
+    if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
+         (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
+         ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
+          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
+    {
+        ApplySettings(*this);
+        Invalidate();
+    }
+}
+
+void MenuFloatingWindow::Command( const CommandEvent& rCEvt )
+{
+    if ( rCEvt.GetCommand() == CommandEventId::Wheel )
+    {
+        const CommandWheelData* pData = rCEvt.GetWheelData();
+        if( !pData->GetModifier() && ( pData->GetMode() == CommandWheelMode::SCROLL ) )
+        {
+            ImplScroll( pData->GetDelta() > 0 );
+            MouseMove( MouseEvent( GetPointerPosPixel(), 0 ) );
+        }
+    }
+}
+
+css::uno::Reference<css::accessibility::XAccessible> MenuFloatingWindow::CreateAccessible()
+{
+    css::uno::Reference<css::accessibility::XAccessible> xAcc;
+
+    if (pMenu && !pMenu->pStartedFrom)
+        xAcc = pMenu->GetAccessible();
+
+    return xAcc;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */