vcl/qt5/Qt5Menu.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 <Qt5Menu.hxx>
  11 #include <Qt5Menu.moc>
  12
  13 #include <Qt5Frame.hxx>
  14 #include <Qt5Instance.hxx>
  15 #include <Qt5MainWindow.hxx>
  16
  17 #include <QtWidgets/QMenuBar>
  18 #include <QtWidgets/QPushButton>
  19
  20 #include <vcl/svapp.hxx>
  21 #include <sal/log.hxx>
  22
  23 #include <strings.hrc>
  24 #include <bitmaps.hlst>
  25
  26 Qt5Menu::Qt5Menu(bool bMenuBar)
  27     : mpVCLMenu(nullptr)
  28     , mpParentSalMenu(nullptr)
  29     , mpFrame(nullptr)
  30     , mbMenuBar(bMenuBar)
  31     , mpQMenuBar(nullptr)
  32     , mpQMenu(nullptr)
  33     , mpCloseButton(nullptr)
  34 {
  35 }
  36
  37 bool Qt5Menu::VisibleMenuBar() { return true; }
  38
  39 void Qt5Menu::InsertMenuItem(Qt5MenuItem* pSalMenuItem, unsigned nPos)
  40 {
  41     sal_uInt16 nId = pSalMenuItem->mnId;
  42     OUString aText = mpVCLMenu->GetItemText(nId);
  43     NativeItemText(aText);
  44     vcl::KeyCode nAccelKey = mpVCLMenu->GetAccelKey(nId);
  45
  46     pSalMenuItem->mpAction.reset();
  47     pSalMenuItem->mpMenu.reset();
  48
  49     if (mbMenuBar)
  50     {
  51         // top-level menu
  52         if (mpQMenuBar)
  53         {
  54             QMenu* pQMenu = new QMenu(toQString(aText), nullptr);
  55             pSalMenuItem->mpMenu.reset(pQMenu);
  56
  57             if ((nPos != MENU_APPEND)
  58                 && (static_cast<size_t>(nPos) < static_cast<size_t>(mpQMenuBar->actions().size())))
  59             {
  60                 mpQMenuBar->insertMenu(mpQMenuBar->actions()[nPos], pQMenu);
  61             }
  62             else
  63             {
  64                 mpQMenuBar->addMenu(pQMenu);
  65             }
  66
  67             // correct parent menu for generated menu
  68             if (pSalMenuItem->mpSubMenu)
  69             {
  70                 pSalMenuItem->mpSubMenu->mpQMenu = pQMenu;
  71             }
  72
  73             connect(pQMenu, &QMenu::aboutToShow, this,
  74                     [pSalMenuItem] { slotMenuAboutToShow(pSalMenuItem); });
  75             connect(pQMenu, &QMenu::aboutToHide, this,
  76                     [pSalMenuItem] { slotMenuAboutToHide(pSalMenuItem); });
  77         }
  78     }
  79     else if (mpQMenu)
  80     {
  81         if (pSalMenuItem->mpSubMenu)
  82         {
  83             // submenu
  84             QMenu* pQMenu = new QMenu(toQString(aText), nullptr);
  85             pSalMenuItem->mpMenu.reset(pQMenu);
  86
  87             if ((nPos != MENU_APPEND)
  88                 && (static_cast<size_t>(nPos) < static_cast<size_t>(mpQMenu->actions().size())))
  89             {
  90                 mpQMenu->insertMenu(mpQMenu->actions()[nPos], pQMenu);
  91             }
  92             else
  93             {
  94                 mpQMenu->addMenu(pQMenu);
  95             }
  96
  97             // correct parent menu for generated menu
  98             pSalMenuItem->mpSubMenu->mpQMenu = pQMenu;
  99
 100             ReinitializeActionGroup(nPos);
 101
 102             // clear all action groups since menu is recreated
 103             pSalMenuItem->mpSubMenu->ResetAllActionGroups();
 104
 105             connect(pQMenu, &QMenu::aboutToShow, this,
 106                     [pSalMenuItem] { slotMenuAboutToShow(pSalMenuItem); });
 107             connect(pQMenu, &QMenu::aboutToHide, this,
 108                     [pSalMenuItem] { slotMenuAboutToHide(pSalMenuItem); });
 109         }
 110         else
 111         {
 112             if (pSalMenuItem->mnType == MenuItemType::SEPARATOR)
 113             {
 114                 QAction* pAction = new QAction(nullptr);
 115                 pSalMenuItem->mpAction.reset(pAction);
 116                 pAction->setSeparator(true);
 117
 118                 if ((nPos != MENU_APPEND)
 119                     && (static_cast<size_t>(nPos) < static_cast<size_t>(mpQMenu->actions().size())))
 120                 {
 121                     mpQMenu->insertAction(mpQMenu->actions()[nPos], pAction);
 122                 }
 123                 else
 124                 {
 125                     mpQMenu->addAction(pAction);
 126                 }
 127
 128                 ReinitializeActionGroup(nPos);
 129             }
 130             else
 131             {
 132                 // leaf menu
 133                 QAction* pAction = new QAction(toQString(aText), nullptr);
 134                 pSalMenuItem->mpAction.reset(pAction);
 135
 136                 if ((nPos != MENU_APPEND)
 137                     && (static_cast<size_t>(nPos) < static_cast<size_t>(mpQMenu->actions().size())))
 138                 {
 139                     mpQMenu->insertAction(mpQMenu->actions()[nPos], pAction);
 140                 }
 141                 else
 142                 {
 143                     mpQMenu->addAction(pAction);
 144                 }
 145
 146                 ReinitializeActionGroup(nPos);
 147
 148                 UpdateActionGroupItem(pSalMenuItem);
 149
 150                 pAction->setShortcut(toQString(nAccelKey.GetName(GetFrame()->GetWindow())));
 151
 152                 connect(pAction, &QAction::triggered, this,
 153                         [pSalMenuItem] { slotMenuTriggered(pSalMenuItem); });
 154             }
 155         }
 156     }
 157
 158     QAction* pAction = pSalMenuItem->getAction();
 159     if (pAction)
 160     {
 161         pAction->setEnabled(pSalMenuItem->mbEnabled);
 162         pAction->setVisible(pSalMenuItem->mbVisible);
 163     }
 164 }
 165
 166 void Qt5Menu::ReinitializeActionGroup(unsigned nPos)
 167 {
 168     const unsigned nCount = GetItemCount();
 169
 170     if (nCount == 0)
 171     {
 172         return;
 173     }
 174
 175     if (nPos == MENU_APPEND)
 176     {
 177         nPos = nCount - 1;
 178     }
 179     else if (nPos >= nCount)
 180     {
 181         return;
 182     }
 183
 184     Qt5MenuItem* pPrevItem = (nPos > 0) ? GetItemAtPos(nPos - 1) : nullptr;
 185     Qt5MenuItem* pCurrentItem = GetItemAtPos(nPos);
 186     Qt5MenuItem* pNextItem = (nPos < nCount - 1) ? GetItemAtPos(nPos + 1) : nullptr;
 187
 188     if (pCurrentItem->mnType == MenuItemType::SEPARATOR)
 189     {
 190         pCurrentItem->mpActionGroup.reset();
 191
 192         // if it's inserted into middle of existing group, split it into two groups:
 193         // first goes original group, after separator goes new group
 194         if (pPrevItem && pPrevItem->mpActionGroup && pNextItem && pNextItem->mpActionGroup
 195             && (pPrevItem->mpActionGroup == pNextItem->mpActionGroup))
 196         {
 197             std::shared_ptr<QActionGroup> pFirstActionGroup = pPrevItem->mpActionGroup;
 198             std::shared_ptr<QActionGroup> pSecondActionGroup(new QActionGroup(nullptr));
 199             pSecondActionGroup->setExclusive(true);
 200
 201             auto actions = pFirstActionGroup->actions();
 202
 203             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
 204             {
 205                 Qt5MenuItem* pModifiedItem = GetItemAtPos(idx);
 206
 207                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
 208                 {
 209                     break;
 210                 }
 211
 212                 pModifiedItem->mpActionGroup = pSecondActionGroup;
 213                 auto action = pModifiedItem->getAction();
 214
 215                 if (actions.contains(action))
 216                 {
 217                     pFirstActionGroup->removeAction(action);
 218                     pSecondActionGroup->addAction(action);
 219                 }
 220             }
 221         }
 222     }
 223     else
 224     {
 225         if (!pCurrentItem->mpActionGroup)
 226         {
 227             // unless element is inserted between two separators, or a separator and an end of vector, use neighbouring group since it's shared
 228             if (pPrevItem && pPrevItem->mpActionGroup)
 229             {
 230                 pCurrentItem->mpActionGroup = pPrevItem->mpActionGroup;
 231             }
 232             else if (pNextItem && pNextItem->mpActionGroup)
 233             {
 234                 pCurrentItem->mpActionGroup = pNextItem->mpActionGroup;
 235             }
 236             else
 237             {
 238                 pCurrentItem->mpActionGroup.reset(new QActionGroup(nullptr));
 239                 pCurrentItem->mpActionGroup->setExclusive(true);
 240             }
 241         }
 242
 243         // if there's also a different group after this element, merge it
 244         if (pNextItem && pNextItem->mpActionGroup
 245             && (pCurrentItem->mpActionGroup != pNextItem->mpActionGroup))
 246         {
 247             auto pFirstCheckedAction = pCurrentItem->mpActionGroup->checkedAction();
 248             auto pSecondCheckedAction = pNextItem->mpActionGroup->checkedAction();
 249             auto actions = pNextItem->mpActionGroup->actions();
 250
 251             // first move all actions from second group to first one, and if first group already has checked action,
 252             // and second group also has a checked action, uncheck action from second group
 253             for (auto action : actions)
 254             {
 255                 pNextItem->mpActionGroup->removeAction(action);
 256
 257                 if (pFirstCheckedAction && pSecondCheckedAction && (action == pSecondCheckedAction))
 258                 {
 259                     action->setChecked(false);
 260                 }
 261
 262                 pCurrentItem->mpActionGroup->addAction(action);
 263             }
 264
 265             // now replace all pointers to second group with pointers to first group
 266             for (unsigned idx = nPos + 1; idx < nCount; ++idx)
 267             {
 268                 Qt5MenuItem* pModifiedItem = GetItemAtPos(idx);
 269
 270                 if ((!pModifiedItem) || (!pModifiedItem->mpActionGroup))
 271                 {
 272                     break;
 273                 }
 274
 275                 pModifiedItem->mpActionGroup = pCurrentItem->mpActionGroup;
 276             }
 277         }
 278     }
 279 }
 280
 281 void Qt5Menu::ResetAllActionGroups()
 282 {
 283     for (unsigned nItem = 0; nItem < GetItemCount(); ++nItem)
 284     {
 285         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nItem);
 286         pSalMenuItem->mpActionGroup.reset();
 287     }
 288 }
 289
 290 void Qt5Menu::UpdateActionGroupItem(const Qt5MenuItem* pSalMenuItem)
 291 {
 292     QAction* pAction = pSalMenuItem->getAction();
 293     if (!pAction)
 294         return;
 295
 296     bool bChecked = mpVCLMenu->IsItemChecked(pSalMenuItem->mnId);
 297     MenuItemBits itemBits = mpVCLMenu->GetItemBits(pSalMenuItem->mnId);
 298
 299     if (itemBits & MenuItemBits::RADIOCHECK)
 300     {
 301         pAction->setCheckable(true);
 302
 303         if (pSalMenuItem->mpActionGroup)
 304         {
 305             pSalMenuItem->mpActionGroup->addAction(pAction);
 306         }
 307
 308         pAction->setChecked(bChecked);
 309     }
 310     else
 311     {
 312         pAction->setActionGroup(nullptr);
 313
 314         if (itemBits & MenuItemBits::CHECKABLE)
 315         {
 316             pAction->setCheckable(true);
 317             pAction->setChecked(bChecked);
 318         }
 319         else
 320         {
 321             pAction->setChecked(false);
 322             pAction->setCheckable(false);
 323         }
 324     }
 325 }
 326
 327 void Qt5Menu::InsertItem(SalMenuItem* pSalMenuItem, unsigned nPos)
 328 {
 329     SolarMutexGuard aGuard;
 330     Qt5MenuItem* pItem = static_cast<Qt5MenuItem*>(pSalMenuItem);
 331
 332     if (nPos == MENU_APPEND)
 333         maItems.push_back(pItem);
 334     else
 335         maItems.insert(maItems.begin() + nPos, pItem);
 336
 337     pItem->mpParentMenu = this;
 338
 339     InsertMenuItem(pItem, nPos);
 340 }
 341
 342 void Qt5Menu::RemoveItem(unsigned nPos)
 343 {
 344     SolarMutexGuard aGuard;
 345
 346     if (nPos < maItems.size())
 347     {
 348         Qt5MenuItem* pItem = maItems[nPos];
 349         pItem->mpAction.reset();
 350         pItem->mpMenu.reset();
 351
 352         maItems.erase(maItems.begin() + nPos);
 353
 354         // Recalculate action groups if necessary:
 355         // if separator between two QActionGroups was removed,
 356         // it may be needed to merge them
 357         if (nPos > 0)
 358         {
 359             ReinitializeActionGroup(nPos - 1);
 360         }
 361     }
 362 }
 363
 364 void Qt5Menu::SetSubMenu(SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned nPos)
 365 {
 366     SolarMutexGuard aGuard;
 367     Qt5MenuItem* pItem = static_cast<Qt5MenuItem*>(pSalMenuItem);
 368     Qt5Menu* pQSubMenu = static_cast<Qt5Menu*>(pSubMenu);
 369
 370     pItem->mpSubMenu = pQSubMenu;
 371     // at this point the pointer to parent menu may be outdated, update it too
 372     pItem->mpParentMenu = this;
 373
 374     if (pQSubMenu != nullptr)
 375     {
 376         pQSubMenu->mpParentSalMenu = this;
 377         pQSubMenu->mpQMenu = pItem->mpMenu.get();
 378     }
 379
 380     // if it's not a menu bar item, then convert it to corresponding item if type if necessary.
 381     // If submenu is present and it's an action, convert it to menu.
 382     // If submenu is not present and it's a menu, convert it to action.
 383     // It may be fine to proceed in any case, but by skipping other cases
 384     // amount of unneeded actions taken should be reduced.
 385     if (pItem->mpParentMenu->mbMenuBar || (pQSubMenu && pItem->mpMenu)
 386         || ((!pQSubMenu) && pItem->mpAction))
 387     {
 388         return;
 389     }
 390
 391     InsertMenuItem(pItem, nPos);
 392 }
 393
 394 void Qt5Menu::SetFrame(const SalFrame* pFrame)
 395 {
 396     auto* pSalInst(static_cast<Qt5Instance*>(GetSalData()->m_pInstance));
 397     assert(pSalInst);
 398     if (!pSalInst->IsMainThread())
 399     {
 400         pSalInst->RunInMainThread([this, pFrame]() { SetFrame(pFrame); });
 401         return;
 402     }
 403
 404     SolarMutexGuard aGuard;
 405     assert(mbMenuBar);
 406     mpFrame = const_cast<Qt5Frame*>(static_cast<const Qt5Frame*>(pFrame));
 407
 408     mpFrame->SetMenu(this);
 409
 410     Qt5MainWindow* pMainWindow = mpFrame->GetTopLevelWindow();
 411     if (pMainWindow)
 412     {
 413         mpQMenuBar = pMainWindow->menuBar();
 414         if (mpQMenuBar)
 415         {
 416             mpQMenuBar->clear();
 417             QPushButton* pButton
 418                 = static_cast<QPushButton*>(mpQMenuBar->cornerWidget(Qt::TopRightCorner));
 419             if (pButton && ((mpCloseButton != pButton) || !maCloseButtonConnection))
 420             {
 421                 maCloseButtonConnection
 422                     = connect(pButton, &QPushButton::clicked, this, &Qt5Menu::slotCloseDocument);
 423                 mpCloseButton = pButton;
 424             }
 425         }
 426
 427         mpQMenu = nullptr;
 428
 429         DoFullMenuUpdate(mpVCLMenu);
 430     }
 431 }
 432
 433 void Qt5Menu::DoFullMenuUpdate(Menu* pMenuBar)
 434 {
 435     // clear action groups since menu is rebuilt
 436     ResetAllActionGroups();
 437     ShowCloseButton(false);
 438
 439     for (sal_Int32 nItem = 0; nItem < static_cast<sal_Int32>(GetItemCount()); nItem++)
 440     {
 441         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nItem);
 442         InsertMenuItem(pSalMenuItem, nItem);
 443         SetItemImage(nItem, pSalMenuItem, pSalMenuItem->maImage);
 444
 445         if (pSalMenuItem->mpSubMenu != nullptr)
 446         {
 447             pMenuBar->HandleMenuActivateEvent(pSalMenuItem->mpSubMenu->GetMenu());
 448             pSalMenuItem->mpSubMenu->DoFullMenuUpdate(pMenuBar);
 449             pMenuBar->HandleMenuDeActivateEvent(pSalMenuItem->mpSubMenu->GetMenu());
 450         }
 451     }
 452 }
 453
 454 void Qt5Menu::ShowItem(unsigned nPos, bool bShow)
 455 {
 456     if (nPos < maItems.size())
 457     {
 458         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
 459         QAction* pAction = pSalMenuItem->getAction();
 460         if (pAction)
 461             pAction->setVisible(bShow);
 462         pSalMenuItem->mbVisible = bShow;
 463     }
 464 }
 465
 466 void Qt5Menu::SetItemBits(unsigned nPos, MenuItemBits)
 467 {
 468     if (nPos < maItems.size())
 469     {
 470         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
 471         UpdateActionGroupItem(pSalMenuItem);
 472     }
 473 }
 474
 475 void Qt5Menu::CheckItem(unsigned nPos, bool bChecked)
 476 {
 477     if (nPos < maItems.size())
 478     {
 479         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
 480         QAction* pAction = pSalMenuItem->getAction();
 481         if (pAction)
 482         {
 483             pAction->setCheckable(true);
 484             pAction->setChecked(bChecked);
 485         }
 486     }
 487 }
 488
 489 void Qt5Menu::EnableItem(unsigned nPos, bool bEnable)
 490 {
 491     if (nPos < maItems.size())
 492     {
 493         Qt5MenuItem* pSalMenuItem = GetItemAtPos(nPos);
 494         QAction* pAction = pSalMenuItem->getAction();
 495         if (pAction)
 496             pAction->setEnabled(bEnable);
 497         pSalMenuItem->mbEnabled = bEnable;
 498     }
 499 }
 500
 501 void Qt5Menu::SetItemText(unsigned, SalMenuItem* pItem, const OUString& rText)
 502 {
 503     Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
 504     QAction* pAction = pSalMenuItem->getAction();
 505     if (pAction)
 506     {
 507         OUString aText(rText);
 508         NativeItemText(aText);
 509         pAction->setText(toQString(aText));
 510     }
 511 }
 512
 513 void Qt5Menu::SetItemImage(unsigned, SalMenuItem* pItem, const Image& rImage)
 514 {
 515     Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
 516
 517     // Save new image to use it in DoFullMenuUpdate
 518     pSalMenuItem->maImage = rImage;
 519
 520     QAction* pAction = pSalMenuItem->getAction();
 521     if (!pAction)
 522         return;
 523
 524     pAction->setIcon(QPixmap::fromImage(toQImage(rImage)));
 525 }
 526
 527 void Qt5Menu::SetAccelerator(unsigned, SalMenuItem* pItem, const vcl::KeyCode&,
 528                              const OUString& rText)
 529 {
 530     Qt5MenuItem* pSalMenuItem = static_cast<Qt5MenuItem*>(pItem);
 531     QAction* pAction = pSalMenuItem->getAction();
 532     if (pAction)
 533         pAction->setShortcut(QKeySequence(toQString(rText), QKeySequence::PortableText));
 534 }
 535
 536 void Qt5Menu::GetSystemMenuData(SystemMenuData*) {}
 537
 538 Qt5Menu* Qt5Menu::GetTopLevel()
 539 {
 540     Qt5Menu* pMenu = this;
 541     while (pMenu->mpParentSalMenu)
 542         pMenu = pMenu->mpParentSalMenu;
 543     return pMenu;
 544 }
 545
 546 void Qt5Menu::ShowMenuBar(bool bVisible)
 547 {
 548     if (mpQMenuBar)
 549         mpQMenuBar->setVisible(bVisible);
 550 }
 551
 552 const Qt5Frame* Qt5Menu::GetFrame() const
 553 {
 554     SolarMutexGuard aGuard;
 555     const Qt5Menu* pMenu = this;
 556     while (pMenu && !pMenu->mpFrame)
 557         pMenu = pMenu->mpParentSalMenu;
 558     return pMenu ? pMenu->mpFrame : nullptr;
 559 }
 560
 561 void Qt5Menu::slotMenuTriggered(Qt5MenuItem* pQItem)
 562 {
 563     if (pQItem)
 564     {
 565         Qt5Menu* pSalMenu = pQItem->mpParentMenu;
 566         Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
 567
 568         Menu* pMenu = pSalMenu->GetMenu();
 569         auto mnId = pQItem->mnId;
 570
 571         // HACK to allow HandleMenuCommandEvent to "not-set" the checked button
 572         // LO expects a signal before an item state change, so reset the check item
 573         if (pQItem->mpAction->isCheckable()
 574             && (!pQItem->mpActionGroup || pQItem->mpActionGroup->actions().size() <= 1))
 575             pQItem->mpAction->setChecked(!pQItem->mpAction->isChecked());
 576         pTopLevel->GetMenu()->HandleMenuCommandEvent(pMenu, mnId);
 577     }
 578 }
 579
 580 void Qt5Menu::slotMenuAboutToShow(Qt5MenuItem* pQItem)
 581 {
 582     if (pQItem)
 583     {
 584         Qt5Menu* pSalMenu = pQItem->mpSubMenu;
 585         Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
 586
 587         Menu* pMenu = pSalMenu->GetMenu();
 588
 589         // following function may update the menu
 590         pTopLevel->GetMenu()->HandleMenuActivateEvent(pMenu);
 591     }
 592 }
 593
 594 void Qt5Menu::slotMenuAboutToHide(Qt5MenuItem* pQItem)
 595 {
 596     if (pQItem)
 597     {
 598         Qt5Menu* pSalMenu = pQItem->mpSubMenu;
 599         Qt5Menu* pTopLevel = pSalMenu->GetTopLevel();
 600
 601         Menu* pMenu = pSalMenu->GetMenu();
 602
 603         pTopLevel->GetMenu()->HandleMenuDeActivateEvent(pMenu);
 604     }
 605 }
 606
 607 void Qt5Menu::NativeItemText(OUString& rItemText)
 608 {
 609     // preserve literal '&'s in menu texts
 610     rItemText = rItemText.replaceAll("&", "&&");
 611
 612     rItemText = rItemText.replace('~', '&');
 613 }
 614
 615 void Qt5Menu::slotCloseDocument()
 616 {
 617     MenuBar* pVclMenuBar = static_cast<MenuBar*>(mpVCLMenu.get());
 618     if (pVclMenuBar)
 619         Application::PostUserEvent(pVclMenuBar->GetCloseButtonClickHdl());
 620 }
 621
 622 void Qt5Menu::ShowCloseButton(bool bShow)
 623 {
 624     if (!mpQMenuBar)
 625         return;
 626
 627     QPushButton* pButton = static_cast<QPushButton*>(mpQMenuBar->cornerWidget(Qt::TopRightCorner));
 628     if (!pButton)
 629     {
 630         QIcon aIcon;
 631         if (QIcon::hasThemeIcon("window-close-symbolic"))
 632             aIcon = QIcon::fromTheme("window-close-symbolic");
 633         else
 634             aIcon = QIcon(
 635                 QPixmap::fromImage((toQImage(Image(StockImage::Yes, SV_RESID_BITMAP_CLOSEDOC)))));
 636         pButton = new QPushButton(mpQMenuBar);
 637         pButton->setIcon(aIcon);
 638         pButton->setFlat(true);
 639         pButton->setFocusPolicy(Qt::NoFocus);
 640         pButton->setToolTip(toQString(VclResId(SV_HELPTEXT_CLOSEDOCUMENT)));
 641         mpQMenuBar->setCornerWidget(pButton, Qt::TopRightCorner);
 642         maCloseButtonConnection
 643             = connect(pButton, &QPushButton::clicked, this, &Qt5Menu::slotCloseDocument);
 644         mpCloseButton = pButton;
 645     }
 646
 647     if (bShow)
 648         pButton->show();
 649     else
 650         pButton->hide();
 651 }
 652
 653 Qt5MenuItem::Qt5MenuItem(const SalItemParams* pItemData)
 654     : mpParentMenu(nullptr)
 655     , mpSubMenu(nullptr)
 656     , mnId(pItemData->nId)
 657     , mnType(pItemData->eType)
 658     , mbVisible(true)
 659     , mbEnabled(true)
 660     , maImage(pItemData->aImage)
 661 {
 662 }
 663
 664 QAction* Qt5MenuItem::getAction() const
 665 {
 666     if (mpMenu)
 667         return mpMenu->menuAction();
 668     if (mpAction)
 669         return mpAction.get();
 670     return nullptr;
 671 }
 672
 673 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */