vcl/qt5/QtMenu.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <QtMenu.hxx>
  11 #include <QtMenu.moc>
  12
  13 #include <QtFrame.hxx>
  14 #include <QtInstance.hxx>
  15 #include <QtMainWindow.hxx>
  16
  17 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
  18 #include <QtWidgets/QActionGroup>
  19 #else
  20 #include <QtGui/QActionGroup>
  21 #endif
  22
  23 #include <QtWidgets/QButtonGroup>
  24 #include <QtWidgets/QHBoxLayout>
  25 #include <QtWidgets/QMenuBar>
  26 #include <QtWidgets/QPushButton>
  27 #include <QtWidgets/QStyle>
  28
  29 #include <o3tl/safeint.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <sal/log.hxx>
  32
  33 #include <strings.hrc>
  34 #include <bitmaps.hlst>
  35
  36 #include <vcl/toolkit/floatwin.hxx>
  37 #include <window.h>
  38
  39 // LO SalMenuButtonItem::mnId is sal_uInt16, so we go with -2, as -1 has a special meaning as automatic id
  40 constexpr int CLOSE_BUTTON_ID = -2;
  41 const QString gButtonGroupKey("QtMenu::ButtonGroup");
  42
  43 static inline void lcl_force_menubar_layout_update(QMenuBar& rMenuBar)
  44 {
  45     // just exists as a function to not comment it everywhere: forces reposition of the
  46     // corner widget after its layout changes, which will otherwise just happen on resize.
  47     // it unfortunatly has additional side effects; see QtMenu::GetMenuBarButtonRectPixel.
  48     rMenuBar.adjustSize();
  49 }
  50
  51 QtMenu::QtMenu(bool bMenuBar)
  52     : mpVCLMenu(nullptr)
  53     , mpParentSalMenu(nullptr)
  54     , mpFrame(nullptr)
  55     , mbMenuBar(bMenuBar)
  56     , mpQMenuBar(nullptr)
  57     , mpQMenu(nullptr)
  58     , m_pButtonGroup(nullptr)
  59 {
  60 }
  61
  62 bool QtMenu::VisibleMenuBar() { return true; }
  63
  64 void QtMenu::InsertMenuItem(QtMenuItem* pSalMenuItem, unsigned nPos)
  65 {
  66     sal_uInt16 nId = pSalMenuItem->mnId;
  67     OUString aText = mpVCLMenu->GetItemText(nId);
  68     NativeItemText(aText);
  69     vcl::KeyCode nAccelKey = mpVCLMenu->GetAccelKey(nId);
  70
  71     pSalMenuItem->mpAction.reset();
  72     pSalMenuItem->mpMenu.reset();
  73
  74     if (mbMenuBar)
  75     {
  76         // top-level menu
  77         if (validateQMenuBar())
  78         {
  79             QMenu* pQMenu = new QMenu(toQString(aText), nullptr);
  80             pSalMenuItem->mpMenu.reset(pQMenu);
  81
  82             if ((nPos != MENU_APPEND)
  83                 && (static_cast<size_t>(nPos) < o3tl::make_unsigned(mpQMenuBar->actions().size())))
  84             {
  85                 mpQMenuBar->insertMenu(mpQMenuBar->actions()[nPos], pQMenu);
  86             }
  87             else
  88             {
  89                 mpQMenuBar->addMenu(pQMenu);
  90             }
  91
  92             // correct parent menu for generated menu
  93             if (pSalMenuItem->mpSubMenu)
  94             {
  95                 pSalMenuItem->mpSubMenu->mpQMenu = pQMenu;
  96             }
  97
  98             connect(pQMenu, &QMenu::aboutToShow, this,
  99                     [pSalMenuItem] { slotMenuAboutToShow(pSalMenuItem); });
 100             connect(pQMenu, &QMenu::aboutToHide, this,
 101                     [pSalMenuItem] { slotMenuAboutToHide(pSalMenuItem); });
 102         }
 103     }
 104     else
 105     {
 106         if (!mpQMenu)
 107         {
 108             // no QMenu set, instantiate own one
 109             mpOwnedQMenu.reset(new QMenu);
 110             mpQMenu = mpOwnedQMenu.get();
 111         }
 112
 113         if (pSalMenuItem->mpSubMenu)
 114         {
 115             // submenu
 116             QMenu* pQMenu = new QMenu(toQString(aText), nullptr);
 117             pSalMenuItem->mpMenu.reset(pQMenu);
 118
 119             if ((nPos != MENU_APPEND)
 120                 && (static_cast<size_t>(nPos) < o3tl::make_unsigned(mpQMenu->actions().size())))
 121             {
 122                 mpQMenu->insertMenu(mpQMenu->actions()[nPos], pQMenu);
 123             }
 124             else
 125             {
 126                 mpQMenu->addMenu(pQMenu);
 127             }
 128
 129             // correct parent menu for generated menu
 130             pSalMenuItem->mpSubMenu->mpQMenu = pQMenu;
 131
 132             ReinitializeActionGroup(nPos);
 133
 134             // clear all action groups since menu is recreated
 135             pSalMenuItem->mpSubMenu->ResetAllActionGroups();
 136
 137             connect(pQMenu, &QMenu::aboutToShow, this,
 138                     [pSalMenuItem] { slotMenuAboutToShow(pSalMenuItem); });
 139             connect(pQMenu, &QMenu::aboutToHide, this,
 140                     [pSalMenuItem] { slotMenuAboutToHide(pSalMenuItem); });
 141         }
 142         else
 143         {
 144             if (pSalMenuItem->mnType == MenuItemType::SEPARATOR)
 145             {
 146                 QAction* pAction = new QAction(nullptr);
 147                 pSalMenuItem->mpAction.reset(pAction);
 148                 pAction->setSeparator(true);
 149
 150                 if ((nPos != MENU_APPEND)
 151                     && (static_cast<size_t>(nPos) < o3tl::make_unsigned(mpQMenu->actions().size())))
 152                 {
 153                     mpQMenu->insertAction(mpQMenu->actions()[nPos], pAction);
 154                 }
 155                 else
 156                 {
 157                     mpQMenu->addAction(pAction);
 158                 }
 159
 160                 ReinitializeActionGroup(nPos);
 161             }
 162             else
 163             {
 164                 // leaf menu
 165                 QAction* pAction = new QAction(toQString(aText), nullptr);
 166                 pSalMenuItem->mpAction.reset(pAction);
 167
 168                 if ((nPos != MENU_APPEND)
 169                     && (static_cast<size_t>(nPos) < o3tl::make_unsigned(mpQMenu->actions().size())))
 170                 {
 171                     mpQMenu->insertAction(mpQMenu->actions()[nPos], pAction);
 172                 }
 173                 else
 174                 {
 175                     mpQMenu->addAction(pAction);
 176                 }
 177
 178                 ReinitializeActionGroup(nPos);
 179
 180                 UpdateActionGroupItem(pSalMenuItem);
 181
 182                 pAction->setShortcut(toQString(nAccelKey.GetName()));
 183
 184                 connect(pAction, &QAction::triggered, this,
 185                         [pSalMenuItem] { slotMenuTriggered(pSalMenuItem); });
 186             }
 187         }
 188     }
 189
 190     QAction* pAction = pSalMenuItem->getAction();
 191     if (pAction)
 192     {
 193         pAction->setEnabled(pSalMenuItem->mbEnabled);
 194         pAction->setVisible(pSalMenuItem->mbVisible);
 195     }
 196 }
 197
 198 void QtMenu::ReinitializeActionGroup(unsigned nPos)
 199 {
 200     const unsigned nCount = GetItemCount();
 201
 202     if (nCount == 0)
 203     {
 204         return;
 205     }
 206
 207     if (nPos == MENU_APPEND)
 208     {
 209         nPos = nCount - 1;
 210     }
 211     else if (nPos >= nCount)
 212     {
 213         return;
 214     }
 215
 216     QtMenuItem* pPrevItem = (nPos > 0) ? GetItemAtPos(nPos - 1) : nullptr;
 217     QtMenuItem* pCurrentItem = GetItemAtPos(nPos);
 218     QtMenuItem* pNextItem = (nPos < nCount - 1) ? GetItemAtPos(nPos + 1) : nullptr;
 219
 220     if (pCurrentItem->mnType == MenuItemType::SEPARATOR)
 221     {
 222         pCurrentItem->mpActionGroup.reset();
 223
 224         // if it's inserted into middle of existing group, split it into two groups:
 225         // first goes original group, after separator goes new group
 226         if (pPrevItem && pPrevItem->mpActionGroup && pNextItem && pNextItem->mpActionGroup
 227             && (pPrevItem->mpActionGroup == pNextItem->mpActionGroup))
 228         {
 229             std::shared_ptr<QActionGroup> pFirstActionGroup = pPrevItem->mpActionGroup;
 230             auto pSecondActionGroup = std::make_shared<QActionGroup>(nullptr);
 231             pSecondActionGroup->setExclusive(true);
 232
 233             auto actions = pFirstActionGroup->actions();
 234
 235             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
 236             {
 237                 QtMenuItem* pModifiedItem = GetItemAtPos(idx);
 238
 239                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
 240                 {
 241                     break;
 242                 }
 243
 244                 pModifiedItem->mpActionGroup = pSecondActionGroup;
 245                 auto action = pModifiedItem->getAction();
 246
 247                 if (actions.contains(action))
 248                 {
 249                     pFirstActionGroup->removeAction(action);
 250                     pSecondActionGroup->addAction(action);
 251                 }
 252             }
 253         }
 254     }
 255     else
 256     {
 257         if (!pCurrentItem->mpActionGroup)
 258         {
 259             // unless element is inserted between two separators, or a separator and an end of vector, use neighbouring group since it's shared
 260             if (pPrevItem && pPrevItem->mpActionGroup)
 261             {
 262                 pCurrentItem->mpActionGroup = pPrevItem->mpActionGroup;
 263             }
 264             else if (pNextItem && pNextItem->mpActionGroup)
 265             {
 266                 pCurrentItem->mpActionGroup = pNextItem->mpActionGroup;
 267             }
 268             else
 269             {
 270                 pCurrentItem->mpActionGroup = std::make_shared<QActionGroup>(nullptr);
 271                 pCurrentItem->mpActionGroup->setExclusive(true);
 272             }
 273         }
 274
 275         // if there's also a different group after this element, merge it
 276         if (pNextItem && pNextItem->mpActionGroup
 277             && (pCurrentItem->mpActionGroup != pNextItem->mpActionGroup))
 278         {
 279             auto pFirstCheckedAction = pCurrentItem->mpActionGroup->checkedAction();
 280             auto pSecondCheckedAction = pNextItem->mpActionGroup->checkedAction();
 281             auto actions = pNextItem->mpActionGroup->actions();
 282
 283             // first move all actions from second group to first one, and if first group already has checked action,
 284             // and second group also has a checked action, uncheck action from second group
 285             for (auto action : actions)
 286             {
 287                 pNextItem->mpActionGroup->removeAction(action);
 288
 289                 if (pFirstCheckedAction && pSecondCheckedAction && (action == pSecondCheckedAction))
 290                 {
 291                     action->setChecked(false);
 292                 }
 293
 294                 pCurrentItem->mpActionGroup->addAction(action);
 295             }
 296
 297             // now replace all pointers to second group with pointers to first group
 298             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
 299             {
 300                 QtMenuItem* pModifiedItem = GetItemAtPos(idx);
 301
 302                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
 303                 {
 304                     break;
 305                 }
 306
 307                 pModifiedItem->mpActionGroup = pCurrentItem->mpActionGroup;
 308             }
 309         }
 310     }
 311 }
 312
 313 void QtMenu::ResetAllActionGroups()
 314 {
 315     for (unsigned nItem = 0; nItem < GetItemCount(); ++nItem)
 316     {
 317         QtMenuItem* pSalMenuItem = GetItemAtPos(nItem);
 318         pSalMenuItem->mpActionGroup.reset();
 319     }
 320 }
 321
 322 void QtMenu::UpdateActionGroupItem(const QtMenuItem* pSalMenuItem)
 323 {
 324     QAction* pAction = pSalMenuItem->getAction();
 325     if (!pAction)
 326         return;
 327
 328     bool bChecked = mpVCLMenu->IsItemChecked(pSalMenuItem->mnId);
 329     MenuItemBits itemBits = mpVCLMenu->GetItemBits(pSalMenuItem->mnId);
 330
 331     if (itemBits & MenuItemBits::RADIOCHECK)
 332     {
 333         pAction->setCheckable(true);
 334
 335         if (pSalMenuItem->mpActionGroup)
 336         {
 337             pSalMenuItem->mpActionGroup->addAction(pAction);
 338         }
 339
 340         pAction->setChecked(bChecked);
 341     }
 342     else
 343     {
 344         pAction->setActionGroup(nullptr);
 345
 346         if (itemBits & MenuItemBits::CHECKABLE)
 347         {
 348             pAction->setCheckable(true);
 349             pAction->setChecked(bChecked);
 350         }
 351         else
 352         {
 353             pAction->setChecked(false);
 354             pAction->setCheckable(false);
 355         }
 356     }
 357 }
 358
 359 void QtMenu::InsertItem(SalMenuItem* pSalMenuItem, unsigned nPos)
 360 {
 361     SolarMutexGuard aGuard;
 362     QtMenuItem* pItem = static_cast<QtMenuItem*>(pSalMenuItem);
 363
 364     if (nPos == MENU_APPEND)
 365         maItems.push_back(pItem);
 366     else
 367         maItems.insert(maItems.begin() + nPos, pItem);
 368
 369     pItem->mpParentMenu = this;
 370
 371     InsertMenuItem(pItem, nPos);
 372 }
 373
 374 void QtMenu::RemoveItem(unsigned nPos)
 375 {
 376     SolarMutexGuard aGuard;
 377
 378     if (nPos >= maItems.size())
 379         return;
 380
 381     QtMenuItem* pItem = maItems[nPos];
 382     pItem->mpAction.reset();
 383     pItem->mpMenu.reset();
 384
 385     maItems.erase(maItems.begin() + nPos);
 386
 387     // Recalculate action groups if necessary:
 388     // if separator between two QActionGroups was removed,
 389     // it may be needed to merge them
 390     if (nPos > 0)
 391     {
 392         ReinitializeActionGroup(nPos - 1);
 393     }
 394 }
 395
 396 void QtMenu::SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned nPos)
 397 {
 398     SolarMutexGuard aGuard;
 399     QtMenuItem* pItem = static_cast<QtMenuItem*>(pSalMenuItem);
 400     QtMenu* pQSubMenu = static_cast<QtMenu*>(pSubMenu);
 401
 402     pItem->mpSubMenu = pQSubMenu;
 403     // at this point the pointer to parent menu may be outdated, update it too
 404     pItem->mpParentMenu = this;
 405
 406     if (pQSubMenu != nullptr)
 407     {
 408         pQSubMenu->mpParentSalMenu = this;
 409         pQSubMenu->mpQMenu = pItem->mpMenu.get();
 410     }
 411
 412     // if it's not a menu bar item, then convert it to corresponding item if type if necessary.
 413     // If submenu is present and it's an action, convert it to menu.
 414     // If submenu is not present and it's a menu, convert it to action.
 415     // It may be fine to proceed in any case, but by skipping other cases
 416     // amount of unneeded actions taken should be reduced.
 417     if (pItem->mpParentMenu->mbMenuBar || (pQSubMenu && pItem->mpMenu)
 418         || ((!pQSubMenu) && pItem->mpAction))
 419     {
 420         return;
 421     }
 422
 423     InsertMenuItem(pItem, nPos);
 424 }
 425
 426 void QtMenu::SetFrame(const SalFrame* pFrame)
 427 {
 428     auto* pSalInst(GetQtInstance());
 429     assert(pSalInst);
 430     if (!pSalInst->IsMainThread())
 431     {
 432         pSalInst->RunInMainThread([this, pFrame]() { SetFrame(pFrame); });
 433         return;
 434     }
 435
 436     SolarMutexGuard aGuard;
 437     assert(mbMenuBar);
 438     mpFrame = const_cast<QtFrame*>(static_cast<const QtFrame*>(pFrame));
 439
 440     mpFrame->SetMenu(this);
 441
 442     QtMainWindow* pMainWindow = mpFrame->GetTopLevelWindow();
 443     if (!pMainWindow)
 444         return;
 445
 446     mpQMenuBar = new QMenuBar();
 447     pMainWindow->setMenuBar(mpQMenuBar);
 448
 449     QWidget* pWidget = mpQMenuBar->cornerWidget(Qt::TopRightCorner);
 450     if (pWidget)
 451     {
 452         m_pButtonGroup = pWidget->findChild<QButtonGroup*>(gButtonGroupKey);
 453         assert(m_pButtonGroup);
 454         connect(m_pButtonGroup, QOverload<QAbstractButton*>::of(&QButtonGroup::buttonClicked), this,
 455                 &QtMenu::slotMenuBarButtonClicked);
 456         QPushButton* pButton = static_cast<QPushButton*>(m_pButtonGroup->button(CLOSE_BUTTON_ID));
 457         if (pButton)
 458             connect(pButton, &QPushButton::clicked, this, &QtMenu::slotCloseDocument);
 459     }
 460     else
 461         m_pButtonGroup = nullptr;
 462     mpQMenu = nullptr;
 463
 464     DoFullMenuUpdate(mpVCLMenu);
 465 }
 466
 467 void QtMenu::DoFullMenuUpdate(Menu* pMenuBar)
 468 {
 469     // clear action groups since menu is rebuilt
 470     ResetAllActionGroups();
 471     ShowCloseButton(false);
 472
 473     for (sal_Int32 nItem = 0; nItem < static_cast<sal_Int32>(GetItemCount()); nItem++)
 474     {
 475         QtMenuItem* pSalMenuItem = GetItemAtPos(nItem);
 476         InsertMenuItem(pSalMenuItem, nItem);
 477         SetItemImage(nItem, pSalMenuItem, pSalMenuItem->maImage);
 478         const bool bShowDisabled
 479             = bool(pMenuBar->GetMenuFlags() & MenuFlags::AlwaysShowDisabledEntries)
 480               || !bool(pMenuBar->GetMenuFlags() & MenuFlags::HideDisabledEntries);
 481         const bool bVisible = pSalMenuItem->mbVisible
 482                               && (bShowDisabled || mpVCLMenu->IsItemEnabled(pSalMenuItem->mnId));
 483         pSalMenuItem->getAction()->setVisible(bVisible);
 484
 485         if (pSalMenuItem->mpSubMenu != nullptr)
 486         {
 487             pMenuBar->HandleMenuActivateEvent(pSalMenuItem->mpSubMenu->GetMenu());
 488             pSalMenuItem->mpSubMenu->DoFullMenuUpdate(pMenuBar);
 489             pMenuBar->HandleMenuDeActivateEvent(pSalMenuItem->mpSubMenu->GetMenu());
 490         }
 491     }
 492 }
 493
 494 void QtMenu::ShowItem(unsigned nPos, bool bShow)
 495 {
 496     if (nPos < maItems.size())
 497     {
 498         QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
 499         QAction* pAction = pSalMenuItem->getAction();
 500         if (pAction)
 501             pAction->setVisible(bShow);
 502         pSalMenuItem->mbVisible = bShow;
 503     }
 504 }
 505
 506 void QtMenu::SetItemBits(unsigned nPos, MenuItemBits)
 507 {
 508     if (nPos < maItems.size())
 509     {
 510         QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
 511         UpdateActionGroupItem(pSalMenuItem);
 512     }
 513 }
 514
 515 void QtMenu::CheckItem(unsigned nPos, bool bChecked)
 516 {
 517     if (nPos < maItems.size())
 518     {
 519         QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
 520         QAction* pAction = pSalMenuItem->getAction();
 521         if (pAction)
 522         {
 523             pAction->setCheckable(true);
 524             pAction->setChecked(bChecked);
 525         }
 526     }
 527 }
 528
 529 void QtMenu::EnableItem(unsigned nPos, bool bEnable)
 530 {
 531     if (nPos < maItems.size())
 532     {
 533         QtMenuItem* pSalMenuItem = GetItemAtPos(nPos);
 534         QAction* pAction = pSalMenuItem->getAction();
 535         if (pAction)
 536             pAction->setEnabled(bEnable);
 537         pSalMenuItem->mbEnabled = bEnable;
 538     }
 539 }
 540
 541 void QtMenu::SetItemText(unsigned, SalMenuItem* pItem, const OUString& rText)
 542 {
 543     QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
 544     QAction* pAction = pSalMenuItem->getAction();
 545     if (pAction)
 546     {
 547         OUString aText(rText);
 548         NativeItemText(aText);
 549         pAction->setText(toQString(aText));
 550     }
 551 }
 552
 553 void QtMenu::SetItemImage(unsigned, SalMenuItem* pItem, const Image& rImage)
 554 {
 555     QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
 556
 557     // Save new image to use it in DoFullMenuUpdate
 558     pSalMenuItem->maImage = rImage;
 559
 560     QAction* pAction = pSalMenuItem->getAction();
 561     if (!pAction)
 562         return;
 563
 564     pAction->setIcon(QPixmap::fromImage(toQImage(rImage)));
 565 }
 566
 567 void QtMenu::SetAccelerator(unsigned, SalMenuItem* pItem, const vcl::KeyCode&,
 568                             const OUString& rText)
 569 {
 570     QtMenuItem* pSalMenuItem = static_cast<QtMenuItem*>(pItem);
 571     QAction* pAction = pSalMenuItem->getAction();
 572     if (pAction)
 573         pAction->setShortcut(QKeySequence(toQString(rText), QKeySequence::PortableText));
 574 }
 575
 576 void QtMenu::GetSystemMenuData(SystemMenuData*) {}
 577
 578 QtMenu* QtMenu::GetTopLevel()
 579 {
 580     QtMenu* pMenu = this;
 581     while (pMenu->mpParentSalMenu)
 582         pMenu = pMenu->mpParentSalMenu;
 583     return pMenu;
 584 }
 585
 586 bool QtMenu::validateQMenuBar() const
 587 {
 588     if (!mpQMenuBar)
 589         return false;
 590     assert(mpFrame);
 591     QtMainWindow* pMainWindow = mpFrame->GetTopLevelWindow();
 592     assert(pMainWindow);
 593     const bool bValid = mpQMenuBar == pMainWindow->menuBar();
 594     if (!bValid)
 595     {
 596         QtMenu* thisPtr = const_cast<QtMenu*>(this);
 597         thisPtr->mpQMenuBar = nullptr;
 598     }
 599     return bValid;
 600 }
 601
 602 void QtMenu::ShowMenuBar(bool bVisible)
 603 {
 604     if (!validateQMenuBar())
 605         return;
 606
 607     mpQMenuBar->setVisible(bVisible);
 608     if (bVisible)
 609         lcl_force_menubar_layout_update(*mpQMenuBar);
 610 }
 611
 612 const QtFrame* QtMenu::GetFrame() const
 613 {
 614     SolarMutexGuard aGuard;
 615     const QtMenu* pMenu = this;
 616     while (pMenu && !pMenu->mpFrame)
 617         pMenu = pMenu->mpParentSalMenu;
 618     return pMenu ? pMenu->mpFrame : nullptr;
 619 }
 620
 621 void QtMenu::slotMenuTriggered(QtMenuItem* pQItem)
 622 {
 623     if (!pQItem)
 624         return;
 625
 626     QtMenu* pSalMenu = pQItem->mpParentMenu;
 627     QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 628
 629     Menu* pMenu = pSalMenu->GetMenu();
 630     auto mnId = pQItem->mnId;
 631
 632     // HACK to allow HandleMenuCommandEvent to "not-set" the checked button
 633     // LO expects a signal before an item state change, so reset the check item
 634     if (pQItem->mpAction->isCheckable()
 635         && (!pQItem->mpActionGroup || pQItem->mpActionGroup->actions().size() <= 1))
 636         pQItem->mpAction->setChecked(!pQItem->mpAction->isChecked());
 637     pTopLevel->GetMenu()->HandleMenuCommandEvent(pMenu, mnId);
 638 }
 639
 640 void QtMenu::slotMenuAboutToShow(QtMenuItem* pQItem)
 641 {
 642     if (pQItem)
 643     {
 644         QtMenu* pSalMenu = pQItem->mpSubMenu;
 645         QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 646
 647         Menu* pMenu = pSalMenu->GetMenu();
 648
 649         // following function may update the menu
 650         pTopLevel->GetMenu()->HandleMenuActivateEvent(pMenu);
 651     }
 652 }
 653
 654 void QtMenu::slotMenuAboutToHide(QtMenuItem* pQItem)
 655 {
 656     if (pQItem)
 657     {
 658         QtMenu* pSalMenu = pQItem->mpSubMenu;
 659         QtMenu* pTopLevel = pSalMenu->GetTopLevel();
 660
 661         Menu* pMenu = pSalMenu->GetMenu();
 662
 663         pTopLevel->GetMenu()->HandleMenuDeActivateEvent(pMenu);
 664     }
 665 }
 666
 667 void QtMenu::NativeItemText(OUString& rItemText)
 668 {
 669     // preserve literal '&'s in menu texts
 670     rItemText = rItemText.replaceAll("&", "&&");
 671
 672     rItemText = rItemText.replace('~', '&');
 673 }
 674
 675 void QtMenu::slotCloseDocument()
 676 {
 677     MenuBar* pVclMenuBar = static_cast<MenuBar*>(mpVCLMenu.get());
 678     if (pVclMenuBar)
 679         Application::PostUserEvent(pVclMenuBar->GetCloseButtonClickHdl());
 680 }
 681
 682 void QtMenu::slotMenuBarButtonClicked(QAbstractButton* pButton)
 683 {
 684     MenuBar* pVclMenuBar = static_cast<MenuBar*>(mpVCLMenu.get());
 685     if (pVclMenuBar)
 686     {
 687         SolarMutexGuard aGuard;
 688         pVclMenuBar->HandleMenuButtonEvent(m_pButtonGroup->id(pButton));
 689     }
 690 }
 691
 692 QPushButton* QtMenu::ImplAddMenuBarButton(const QIcon& rIcon, const QString& rToolTip, int nId)
 693 {
 694     if (!validateQMenuBar())
 695         return nullptr;
 696
 697     QWidget* pWidget = mpQMenuBar->cornerWidget(Qt::TopRightCorner);
 698     QHBoxLayout* pLayout;
 699     if (!pWidget)
 700     {
 701         assert(!m_pButtonGroup);
 702         pWidget = new QWidget(mpQMenuBar);
 703         assert(!pWidget->layout());
 704         pLayout = new QHBoxLayout();
 705         pLayout->setContentsMargins(QMargins());
 706         pLayout->setSpacing(0);
 707         pWidget->setLayout(pLayout);
 708         m_pButtonGroup = new QButtonGroup(pLayout);
 709         m_pButtonGroup->setObjectName(gButtonGroupKey);
 710         m_pButtonGroup->setExclusive(false);
 711         connect(m_pButtonGroup, QOverload<QAbstractButton*>::of(&QButtonGroup::buttonClicked), this,
 712                 &QtMenu::slotMenuBarButtonClicked);
 713         pWidget->show();
 714         mpQMenuBar->setCornerWidget(pWidget, Qt::TopRightCorner);
 715     }
 716     else
 717         pLayout = static_cast<QHBoxLayout*>(pWidget->layout());
 718     assert(m_pButtonGroup);
 719     assert(pLayout);
 720
 721     QPushButton* pButton = static_cast<QPushButton*>(m_pButtonGroup->button(nId));
 722     if (pButton)
 723         ImplRemoveMenuBarButton(nId);
 724
 725     pButton = new QPushButton();
 726     // we don't want the button to increase the QMenuBar height, so a fixed size square it is
 727     const int nFixedLength
 728         = mpQMenuBar->height() - 2 * mpQMenuBar->style()->pixelMetric(QStyle::PM_MenuBarVMargin);
 729     pButton->setFixedSize(nFixedLength, nFixedLength);
 730     pButton->setIcon(rIcon);
 731     pButton->setFlat(true);
 732     pButton->setFocusPolicy(Qt::NoFocus);
 733     pButton->setToolTip(rToolTip);
 734
 735     m_pButtonGroup->addButton(pButton, nId);
 736     int nPos = pLayout->count();
 737     if (m_pButtonGroup->button(CLOSE_BUTTON_ID))
 738         nPos--;
 739     pLayout->insertWidget(nPos, pButton, 0, Qt::AlignCenter);
 740     // show must happen after adding the button to the layout, otherwise the button is
 741     // shown, but not correct in the layout, if at all! Some times the layout ignores it.
 742     pButton->show();
 743
 744     lcl_force_menubar_layout_update(*mpQMenuBar);
 745
 746     return pButton;
 747 }
 748
 749 bool QtMenu::AddMenuBarButton(const SalMenuButtonItem& rItem)
 750 {
 751     if (!validateQMenuBar())
 752         return false;
 753     return !!ImplAddMenuBarButton(QIcon(QPixmap::fromImage(toQImage(rItem.maImage))),
 754                                   toQString(rItem.maToolTipText), rItem.mnId);
 755 }
 756
 757 void QtMenu::ImplRemoveMenuBarButton(int nId)
 758 {
 759     if (!validateQMenuBar())
 760         return;
 761
 762     assert(m_pButtonGroup);
 763     auto* pButton = m_pButtonGroup->button(nId);
 764     assert(pButton);
 765     QWidget* pWidget = mpQMenuBar->cornerWidget(Qt::TopRightCorner);
 766     assert(pWidget);
 767     QLayout* pLayout = pWidget->layout();
 768     m_pButtonGroup->removeButton(pButton);
 769     pLayout->removeWidget(pButton);
 770     delete pButton;
 771
 772     lcl_force_menubar_layout_update(*mpQMenuBar);
 773 }
 774
 775 void QtMenu::RemoveMenuBarButton(sal_uInt16 nId) { ImplRemoveMenuBarButton(nId); }
 776
 777 tools::Rectangle QtMenu::GetMenuBarButtonRectPixel(sal_uInt16 nId, SalFrame* pFrame)
 778 {
 779 #ifdef NDEBUG
 780     Q_UNUSED(pFrame);
 781 #endif
 782     if (!validateQMenuBar())
 783         return tools::Rectangle();
 784
 785     assert(mpFrame == static_cast<QtFrame*>(pFrame));
 786     assert(m_pButtonGroup);
 787     auto* pButton = static_cast<QPushButton*>(m_pButtonGroup->button(nId));
 788     assert(pButton);
 789
 790     // unfortunatly, calling lcl_force_menubar_layout_update results in a temporary wrong menubar size,
 791     // but it's the correct minimal size AFAIK and the layout seems correct, so just adjust the width.
 792     QPoint aPos = pButton->mapTo(mpFrame->asChild(), QPoint());
 793     aPos.rx() += (mpFrame->asChild()->width() - mpQMenuBar->width());
 794     return tools::Rectangle(toPoint(aPos), toSize(pButton->size()));
 795 }
 796
 797 void QtMenu::ShowCloseButton(bool bShow)
 798 {
 799     if (!validateQMenuBar())
 800         return;
 801
 802     if (!bShow && !m_pButtonGroup)
 803         return;
 804
 805     QPushButton* pButton = nullptr;
 806     if (m_pButtonGroup)
 807         pButton = static_cast<QPushButton*>(m_pButtonGroup->button(CLOSE_BUTTON_ID));
 808     if (!bShow && !pButton)
 809         return;
 810
 811     if (!pButton)
 812     {
 813         QIcon aIcon;
 814         if (QIcon::hasThemeIcon("window-close-symbolic"))
 815             aIcon = QIcon::fromTheme("window-close-symbolic");
 816         else
 817             aIcon = QIcon(
 818                 QPixmap::fromImage(toQImage(Image(StockImage::Yes, SV_RESID_BITMAP_CLOSEDOC))));
 819         pButton = ImplAddMenuBarButton(aIcon, toQString(VclResId(SV_HELPTEXT_CLOSEDOCUMENT)),
 820                                        CLOSE_BUTTON_ID);
 821         connect(pButton, &QPushButton::clicked, this, &QtMenu::slotCloseDocument);
 822     }
 823
 824     if (bShow)
 825         pButton->show();
 826     else
 827         pButton->hide();
 828
 829     lcl_force_menubar_layout_update(*mpQMenuBar);
 830 }
 831
 832 bool QtMenu::ShowNativePopupMenu(FloatingWindow* pWin, const tools::Rectangle& rRect,
 833                                  FloatWinPopupFlags nFlags)
 834 {
 835     assert(mpQMenu);
 836     DoFullMenuUpdate(mpVCLMenu);
 837     mpQMenu->setTearOffEnabled(bool(nFlags & FloatWinPopupFlags::AllowTearOff));
 838
 839     const VclPtr<vcl::Window> xParent = pWin->ImplGetWindowImpl()->mpRealParent;
 840     tools::Rectangle aFloatRect = FloatingWindow::ImplConvertToAbsPos(xParent, rRect);
 841
 842     // tdf#154447 Menu bar height has to be added
 843     QtFrame* pFrame = static_cast<QtFrame*>(pWin->ImplGetFrame());
 844     assert(pFrame);
 845     aFloatRect.SetPosY(aFloatRect.getY() + pFrame->menuBarOffset());
 846
 847     const QRect aRect = toQRect(aFloatRect, 1 / pFrame->devicePixelRatioF());
 848     mpQMenu->exec(aRect.bottomLeft());
 849
 850     return true;
 851 }
 852
 853 int QtMenu::GetMenuBarHeight() const
 854 {
 855     if (!validateQMenuBar() || mpQMenuBar->isHidden())
 856         return 0;
 857
 858     return mpQMenuBar->height();
 859 }
 860
 861 QtMenuItem::QtMenuItem(const SalItemParams* pItemData)
 862     : mpParentMenu(nullptr)
 863     , mpSubMenu(nullptr)
 864     , mnId(pItemData->nId)
 865     , mnType(pItemData->eType)
 866     , mbVisible(true)
 867     , mbEnabled(true)
 868     , maImage(pItemData->aImage)
 869 {
 870 }
 871
 872 QAction* QtMenuItem::getAction() const
 873 {
 874     if (mpMenu)
 875         return mpMenu->menuAction();
 876     if (mpAction)
 877         return mpAction.get();
 878     return nullptr;
 879 }
 880
 881 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */