vcl/qt5/QtBuilder.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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 <QtBuilder.hxx>
  11
  12 #include <QtDoubleSpinBox.hxx>
  13 #include <QtExpander.hxx>
  14 #include <QtInstanceLinkButton.hxx>
  15 #include <QtInstanceMenu.hxx>
  16 #include <QtInstanceMessageDialog.hxx>
  17 #include <QtInstanceNotebook.hxx>
  18 #include <QtTools.hxx>
  19
  20 #include <rtl/ustrbuf.hxx>
  21 #include <vcl/qt/QtUtils.hxx>
  22
  23 #include <QtGui/QStandardItemModel>
  24 #include <QtWidgets/QButtonGroup>
  25 #include <QtWidgets/QCheckBox>
  26 #include <QtWidgets/QComboBox>
  27 #include <QtWidgets/QDialog>
  28 #include <QtWidgets/QDialogButtonBox>
  29 #include <QtWidgets/QGroupBox>
  30 #include <QtWidgets/QLabel>
  31 #include <QtWidgets/QLineEdit>
  32 #include <QtWidgets/QListView>
  33 #include <QtWidgets/QLayout>
  34 #include <QtWidgets/QPlainTextEdit>
  35 #include <QtWidgets/QProgressBar>
  36 #include <QtWidgets/QPushButton>
  37 #include <QtWidgets/QRadioButton>
  38 #include <QtWidgets/QScrollArea>
  39 #include <QtWidgets/QSlider>
  40 #include <QtWidgets/QSplitter>
  41 #include <QtWidgets/QTabWidget>
  42 #include <QtWidgets/QToolButton>
  43 #include <QtWidgets/QTreeView>
  44
  45 namespace
  46 {
  47 QString convertAccelerator(const OUString& rText)
  48 {
  49     // preserve literal '&'s and use '&' instead of '_' for the accelerator
  50     return toQString(rText.replaceAll("&", "&&").replace('_', '&'));
  51 }
  52 }
  53
  54 QtBuilder::QtBuilder(QObject* pParent, std::u16string_view sUIRoot, const OUString& rUIFile)
  55     : WidgetBuilder(sUIRoot, rUIFile, false)
  56 {
  57     processUIFile(pParent);
  58
  59     // tweak widget hierarchy (remove unnecessary parent widgets)
  60     for (const std::pair<QWidget*, QWidget*>& rPair : m_aWidgetReplacements)
  61         replaceWidget(rPair.first, rPair.second);
  62 }
  63
  64 QtBuilder::~QtBuilder() {}
  65
  66 QWidget* QtBuilder::get_by_name(std::u16string_view sID)
  67 {
  68     for (auto const& child : m_aChildren)
  69     {
  70         if (child.m_sID == sID)
  71             return child.m_pWidget;
  72     }
  73
  74     return nullptr;
  75 }
  76
  77 void QtBuilder::insertComboBoxOrListBoxItems(QObject* pObject, stringmap& rMap,
  78                                              const std::vector<ComboBoxTextItem>& rItems)
  79 {
  80     if (QComboBox* pComboBox = qobject_cast<QComboBox*>(pObject))
  81     {
  82         for (const ComboBoxTextItem& rItem : rItems)
  83         {
  84             QVariant aUserData;
  85             if (!rItem.m_sId.isEmpty())
  86                 aUserData = QVariant::fromValue(toQString(rItem.m_sId));
  87
  88             pComboBox->addItem(toQString(rItem.m_sItem), aUserData);
  89         }
  90
  91         const int nActiveId = BuilderBase::extractActive(rMap);
  92         pComboBox->setCurrentIndex(nActiveId);
  93         return;
  94     }
  95
  96     assert(false && "list boxes are not supported yet");
  97 }
  98
  99 QObject* QtBuilder::insertObject(QObject* pParent, const OUString& rClass, std::string_view sType,
 100                                  const OUString& rID, stringmap& rProps, stringmap&, stringmap&)
 101 {
 102     QObject* pCurrentChild = nullptr;
 103
 104     pCurrentChild = makeObject(pParent, rClass, sType, rID, rProps);
 105
 106     setProperties(pCurrentChild, rProps);
 107
 108     rProps.clear();
 109
 110     return pCurrentChild;
 111 }
 112
 113 QObject* QtBuilder::makeObject(QObject* pParent, std::u16string_view sName, std::string_view sType,
 114                                const OUString& sID, stringmap& rMap)
 115 {
 116     // ignore placeholders
 117     if (sName.empty())
 118         return nullptr;
 119
 120     // nothing to do for these
 121     if (sName == u"GtkCellRendererPixbuf" || sName == u"GtkCellRendererText"
 122         || sName == u"GtkTreeSelection")
 123         return nullptr;
 124
 125     QWidget* pParentWidget = qobject_cast<QWidget*>(pParent);
 126     QLayout* pParentLayout = qobject_cast<QLayout*>(pParent);
 127
 128     QObject* pObject = nullptr;
 129     // in case a QLayout is created, an additional QWidget parent
 130     // will also be created because that is needed for QtInstanceContainer
 131     QWidget* pLayoutParentWidget = nullptr;
 132
 133     if (sName == u"GtkMessageDialog")
 134     {
 135         pObject = new QMessageBox(pParentWidget);
 136     }
 137     else if (sName == u"GtkBox")
 138     {
 139         // for a QMessageBox, return the existing layout instead of creating a new one
 140         if (QMessageBox* pMessageBox = qobject_cast<QMessageBox*>(pParent))
 141         {
 142             pObject = pMessageBox->layout();
 143             assert(pObject && "QMessageBox has no layout");
 144         }
 145         else
 146         {
 147             QWidget* pBoxParentWidget = pParentWidget;
 148             // Unless this is the direct GtkBox child of a GtkDialog, create a parent widget
 149             // that can be used to create a QtInstanceContainer for this box
 150             if (!qobject_cast<QDialog*>(pParentWidget))
 151             {
 152                 pLayoutParentWidget = new QWidget(pParentWidget);
 153                 pBoxParentWidget = pLayoutParentWidget;
 154             }
 155
 156             const bool bVertical = hasOrientationVertical(rMap);
 157             if (bVertical)
 158                 pObject = new QVBoxLayout(pBoxParentWidget);
 159             else
 160                 pObject = new QHBoxLayout(pBoxParentWidget);
 161         }
 162     }
 163     else if (sName == u"GtkButtonBox")
 164     {
 165         QWidget* pTopLevel = windowForObject(pParent);
 166         if (QMessageBox* pMessageBox = qobject_cast<QMessageBox*>(pTopLevel))
 167         {
 168             // for a QMessageBox, return the existing button box instead of creating a new one
 169             QDialogButtonBox* pButtonBox = findButtonBox(pMessageBox);
 170             assert(pButtonBox && "Could not find QMessageBox's button box");
 171             pObject = pButtonBox;
 172
 173             // skip adding to layout below, button box is already contained in dialog
 174             pParentLayout = nullptr;
 175         }
 176         else
 177         {
 178             QDialogButtonBox* pButtonBox = new QDialogButtonBox(pParentWidget);
 179             if (hasOrientationVertical(rMap))
 180                 pButtonBox->setOrientation(Qt::Vertical);
 181             pObject = pButtonBox;
 182         }
 183     }
 184     else if (sName == u"GtkButton")
 185     {
 186         if (QDialogButtonBox* pButtonBox = qobject_cast<QDialogButtonBox*>(pParentWidget))
 187         {
 188             pObject = pButtonBox->addButton("", QDialogButtonBox::NoRole);
 189
 190             // for message boxes, avoid implicit standard buttons in addition to those explicitly added
 191             if (QMessageBox* pMessageBox = qobject_cast<QMessageBox*>(pParentWidget->window()))
 192                 pMessageBox->setStandardButtons(QMessageBox::NoButton);
 193         }
 194         else
 195         {
 196             pObject = new QPushButton(pParentWidget);
 197         }
 198     }
 199     else if (sName == u"GtkCheckButton")
 200     {
 201         pObject = new QCheckBox(pParentWidget);
 202     }
 203     else if (sName == u"GtkComboBoxText")
 204     {
 205         QComboBox* pComboBox = new QComboBox(pParentWidget);
 206         pComboBox->setEditable(extractEntry(rMap));
 207         pObject = pComboBox;
 208     }
 209     else if (sName == u"GtkDialog")
 210     {
 211         pObject = new QDialog(pParentWidget);
 212     }
 213     else if (sName == u"GtkDrawingArea")
 214     {
 215         pObject = new QLabel(pParentWidget);
 216     }
 217     else if (sName == u"GtkEntry")
 218     {
 219         QLineEdit* pLineEdit = new QLineEdit(pParentWidget);
 220         auto aIt = rMap.find(u"visibility"_ustr);
 221         if (aIt != rMap.end() && !toBool(aIt->second))
 222             pLineEdit->setEchoMode(QLineEdit::Password);
 223
 224         pObject = pLineEdit;
 225     }
 226     else if (sName == u"GtkExpander")
 227     {
 228         pObject = new QtExpander(pParentWidget);
 229     }
 230     else if (sName == u"GtkFrame")
 231     {
 232         pObject = new QGroupBox(pParentWidget);
 233     }
 234     else if (sName == u"GtkGrid")
 235     {
 236         pLayoutParentWidget = new QWidget(pParentWidget);
 237         pObject = new QGridLayout(pLayoutParentWidget);
 238     }
 239     else if (sName == u"GtkIconView")
 240     {
 241         QListView* pListView = new QListView(pParentWidget);
 242         pListView->setModel(new QStandardItemModel(pListView));
 243         pListView->setViewMode(QListView::IconMode);
 244         pObject = pListView;
 245     }
 246     else if (sName == u"GtkImage")
 247     {
 248         QLabel* pLabel = new QLabel(pParentWidget);
 249         const OUString sIconName = extractIconName(rMap);
 250         if (!sIconName.isEmpty())
 251         {
 252             const Image aImage = loadThemeImage(sIconName);
 253             pLabel->setPixmap(toQPixmap(aImage));
 254         }
 255         pObject = pLabel;
 256     }
 257     else if (sName == u"GtkLabel")
 258     {
 259         QLabel* pLabel = new QLabel(pParentWidget);
 260         setLabelProperties(*pLabel, rMap);
 261         extractMnemonicWidget(sID, rMap);
 262         pObject = pLabel;
 263     }
 264     else if (sName == u"GtkLevelBar" || sName == u"GtkProgressBar")
 265     {
 266         QProgressBar* pProgressBar = new QProgressBar(pParentWidget);
 267         // don't show text (progress in percent) by default
 268         pProgressBar->setTextVisible(false);
 269         pObject = pProgressBar;
 270     }
 271     else if (sName == u"GtkLinkButton")
 272     {
 273         QtHyperlinkLabel* pLabel = new QtHyperlinkLabel(pParentWidget);
 274         if (rMap.contains(u"label"_ustr))
 275             pLabel->setDisplayText(toQString(rMap[u"label"_ustr]));
 276         if (rMap.contains(u"uri"_ustr))
 277             pLabel->setUri(toQString(rMap[u"uri"_ustr]));
 278
 279         pObject = pLabel;
 280     }
 281     else if (sName == u"GtkMenuButton")
 282     {
 283         QToolButton* pMenuButton = new QToolButton(pParentWidget);
 284         const OUString sMenu = extractPopupMenu(rMap);
 285         if (!sMenu.isEmpty())
 286         {
 287             QMenu* pMenu = get_menu(sMenu);
 288             assert(pMenu && "menu button references non-existing menu");
 289             pMenuButton->setMenu(pMenu);
 290         }
 291         pObject = pMenuButton;
 292     }
 293     else if (sName == u"GtkNotebook")
 294     {
 295         pObject = new QTabWidget(pParentWidget);
 296     }
 297     else if (sName == u"GtkPaned")
 298     {
 299         pObject = new QSplitter(pParentWidget);
 300     }
 301     else if (sName == u"GtkPopover")
 302     {
 303         QWidget* pWidget = new QWidget(pParentWidget, Qt::Popup);
 304         pWidget->setLayout(new QVBoxLayout);
 305         pObject = pWidget;
 306     }
 307     else if (sName == u"GtkRadioButton")
 308     {
 309         pObject = new QRadioButton(pParentWidget);
 310         extractRadioButtonGroup(sID, rMap);
 311     }
 312     else if (sName == u"GtkScrolledWindow")
 313     {
 314         pObject = new QScrollArea(pParentWidget);
 315     }
 316     else if (sName == u"GtkSeparator")
 317     {
 318         const bool bVertical = hasOrientationVertical(rMap);
 319         QFrame* pFrame = new QFrame(pParentWidget);
 320         pFrame->setFrameShape(bVertical ? QFrame::VLine : QFrame::HLine);
 321         pObject = pFrame;
 322     }
 323     else if (sName == u"GtkScale")
 324     {
 325         QSlider* pSlider = new QSlider(pParentWidget);
 326         setScaleProperties(*pSlider, rMap);
 327         pObject = pSlider;
 328     }
 329     else if (sName == u"GtkSpinButton")
 330     {
 331         QtDoubleSpinBox* pSpinBox = new QtDoubleSpinBox(pParentWidget);
 332         setSpinButtonProperties(*pSpinBox, rMap);
 333         pObject = pSpinBox;
 334     }
 335     else if (sName == u"GtkTextView")
 336     {
 337         pObject = new QPlainTextEdit(pParentWidget);
 338     }
 339     else if (sName == u"GtkToggleButton")
 340     {
 341         pObject = new QToolButton(pParentWidget);
 342     }
 343     else if (sName == u"GtkTreeView")
 344     {
 345         QTreeView* pTreeView = new QTreeView(pParentWidget);
 346         pTreeView->setModel(new QStandardItemModel(pTreeView));
 347         pTreeView->setHeaderHidden(!extractHeadersVisible(rMap));
 348         pTreeView->setRootIsDecorated(extractShowExpanders(rMap));
 349         pObject = pTreeView;
 350     }
 351     else if (sName == u"GtkTreeViewColumn")
 352     {
 353         QTreeView* pTreeView = qobject_cast<QTreeView*>(pParentWidget);
 354         assert(pTreeView && "Tree view column doesn't have a tree view parent");
 355         QStandardItemModel* pModel = qobject_cast<QStandardItemModel*>(pTreeView->model());
 356         assert(pModel && "Tree view doesn't have QStandardItemModel set");
 357         const int nCol = pModel->columnCount();
 358         pModel->insertColumn(nCol);
 359         pModel->setHeaderData(nCol, Qt::Horizontal, toQString(extractTitle(rMap)));
 360
 361         // nothing else to do, return tree view parent for the widget
 362         return pTreeView;
 363     }
 364     else if (sName == u"GtkViewport")
 365     {
 366         // GtkViewport is an adaptor to make GtkWidgets scrollable
 367         // inside a GtkScrolledWindow; no equivalent needed for widgets
 368         // inside QScrollArea - just create a simple QWidget
 369         pObject = new QWidget(pParentWidget);
 370     }
 371     else
 372     {
 373         SAL_WARN("vcl.qt", "Widget type not supported yet: "
 374                                << OUStringToOString(sName, RTL_TEXTENCODING_UTF8));
 375         assert(false && "Widget type not supported yet");
 376     }
 377
 378     QWidget* pWidget = qobject_cast<QWidget*>(pObject);
 379     if (!pWidget)
 380         pWidget = pLayoutParentWidget;
 381
 382     if (QSplitter* pSplitterParent = qobject_cast<QSplitter*>(pParentWidget))
 383     {
 384         assert(pWidget);
 385         pSplitterParent->addWidget(pWidget);
 386         // unset to not create a layout below
 387         pParentWidget = nullptr;
 388     }
 389     else if (QTabWidget* pParentTabWidget = qobject_cast<QTabWidget*>(pParentWidget))
 390     {
 391         // remove QTabWidget child widget, set via QTabWidget::addTab instead
 392         assert(pWidget);
 393         pWidget->setParent(nullptr);
 394         // initially, add tab with empty label, QtBuilder::applyTabChildProperties will evaluate actual one
 395         pParentTabWidget->addTab(pWidget, QStringLiteral());
 396         // unset pParentWidget to not create a layout below
 397         pParentWidget = nullptr;
 398     }
 399     else if (QtExpander* pExpander = qobject_cast<QtExpander*>(pParentWidget))
 400     {
 401         // set the content (not the label) child as the expander's widget
 402         if (sType != "label")
 403         {
 404             pExpander->setContentWidget(pWidget);
 405             // erase "visible" property, QtExpander shows/hides the widget as needed
 406             rMap.erase("visible");
 407         }
 408     }
 409
 410     if (pWidget)
 411     {
 412         if (!pParentLayout && pParentWidget)
 413         {
 414             // if the parent is a widget, use the widget's layout, and ensure it has one set
 415             pParentLayout = pParentWidget->layout();
 416             if (!pParentLayout)
 417                 pParentLayout = new QVBoxLayout(pParentWidget);
 418         }
 419
 420         // add widget to parent layout
 421         if (pParentLayout)
 422             pParentLayout->addWidget(pWidget);
 423
 424         QtInstanceWidget::setHelpId(*pWidget, getHelpRoot() + sID);
 425
 426         pWidget->setToolTip(toQString(extractTooltipText(rMap)));
 427         pWidget->setVisible(extractVisible(rMap));
 428
 429 #if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
 430         // Set GtkBuilder ID as accessible ID
 431         pWidget->setAccessibleIdentifier(toQString(sID));
 432 #endif
 433     }
 434     else if (QLayout* pLayout = qobject_cast<QLayout*>(pObject))
 435     {
 436         // add layout to parent layout
 437         if (QBoxLayout* pParentBoxLayout = qobject_cast<QBoxLayout*>(pParentLayout))
 438             pParentBoxLayout->addLayout(pLayout);
 439         else if (QGridLayout* pParentGridLayout = qobject_cast<QGridLayout*>(pParentLayout))
 440             pParentGridLayout->addLayout(pLayout, pParentGridLayout->rowCount(), 0);
 441     }
 442
 443     if (pWidget)
 444         m_aChildren.emplace_back(sID, pWidget);
 445
 446     return pObject;
 447 }
 448
 449 void QtBuilder::tweakInsertedChild(QObject* pParent, QObject* pCurrentChild, std::string_view sType,
 450                                    std::string_view sInternalChild)
 451 {
 452     if (sInternalChild == "entry" && qobject_cast<QComboBox*>(pParent))
 453     {
 454         // an editable GtkComboBox has an internal GtkEntry child,
 455         // but QComboBox doesn't need a separate widget for it, so
 456         // delete it
 457         deleteObject(pCurrentChild);
 458     }
 459
 460     if (sType == "label")
 461     {
 462         if (QLabel* pLabel = qobject_cast<QLabel*>(pCurrentChild))
 463         {
 464             if (QGroupBox* pGroupBox = qobject_cast<QGroupBox*>(pParent))
 465             {
 466                 // GtkFrame has a `child-type="label"` child for the GtkFrame label
 467                 // in the GtkBuilder .ui file, s. https://docs.gtk.org/gtk3/class.Frame.html
 468                 // For QGroupBox, the title can be set directly. Therefore, take over the
 469                 // title from the label and delete the separate label widget again
 470                 pGroupBox->setTitle(pLabel->text());
 471                 deleteObject(pLabel);
 472             }
 473             else if (QtExpander* pExpander = qobject_cast<QtExpander*>(pParent))
 474             {
 475                 // GtkExpander has a `child-type="label"` child for the expander label
 476                 // in the GtkBuilder .ui file, s. https://docs.gtk.org/gtk3/class.Expander.html
 477                 // For QtExpander, the (button) text can be set directly. Therefore, take over
 478                 // text from the label and delete the separate label widget again
 479                 pExpander->setText(pLabel->text());
 480                 deleteObject(pLabel);
 481             }
 482         }
 483     }
 484
 485     if (QScrollArea* pScrollAreaParent = qobject_cast<QScrollArea*>(pParent))
 486     {
 487         if (QAbstractScrollArea* pScrollArea = qobject_cast<QAbstractScrollArea*>(pCurrentChild))
 488         {
 489             // if the child provides scrolling capabilities itself, it doesn't need
 490             // another scroll area parent -> mark parent scroll area for removal
 491             m_aWidgetReplacements.emplace_back(pScrollAreaParent, pScrollArea);
 492         }
 493         else
 494         {
 495             // set as the scroll area's widget
 496             QWidget* pCurrentWidget = nullptr;
 497             if (pCurrentChild->isWidgetType())
 498                 pCurrentWidget = static_cast<QWidget*>(pCurrentChild);
 499             else
 500                 pCurrentWidget = static_cast<QLayout*>(pCurrentChild)->parentWidget();
 501             assert(pCurrentWidget);
 502             pScrollAreaParent->setWidget(pCurrentWidget);
 503         }
 504     }
 505
 506     if (QDialog* pDialog = qobject_cast<QDialog*>(pCurrentChild))
 507     {
 508         // no action needed for QMessageBox, where the default button box is used
 509         // and button click is handled in QtInstanceMessageDialog
 510         if (!qobject_cast<QMessageBox*>(pDialog))
 511         {
 512             if (QDialogButtonBox* pButtonBox = findButtonBox(pDialog))
 513             {
 514                 // ensure that button box is the last item in QDialog's layout
 515                 // (that seems to be implicitly the case for GtkDialog in GTK)
 516                 QLayout* pLayout = pDialog->layout();
 517                 assert(pLayout && "dialog has no layout");
 518                 pLayout->removeWidget(pButtonBox);
 519                 pLayout->addWidget(pButtonBox);
 520
 521                 // connect button click handler
 522                 const QList<QAbstractButton*> aButtons = pButtonBox->buttons();
 523                 for (QAbstractButton* pButton : aButtons)
 524                 {
 525                     assert(pButton);
 526                     QObject::connect(pButton, &QAbstractButton::clicked, pDialog,
 527                                      [pDialog, pButton] {
 528                                          QtInstanceDialog::handleButtonClick(*pDialog, *pButton);
 529                                      });
 530                 }
 531             }
 532         }
 533     }
 534 }
 535
 536 void QtBuilder::setMnemonicWidget(const OUString& rLabelId, const OUString& rMnemonicWidgetId)
 537 {
 538     QLabel* pLabel = get<QLabel>(rLabelId);
 539     QWidget* pBuddy = get_by_name(rMnemonicWidgetId);
 540
 541     if (!pLabel || !pBuddy)
 542         return;
 543
 544     pLabel->setBuddy(pBuddy);
 545 }
 546
 547 void QtBuilder::setRadioButtonGroup(const OUString& rRadioButtonId, const OUString& rRadioGroupId)
 548 {
 549     // insert all buttons into a button group owned by button whose matches the group's
 550     QRadioButton* pGroupOwner = get<QRadioButton>(rRadioGroupId);
 551     assert(pGroupOwner && "No radio button with the given group name");
 552
 553     QButtonGroup* pButtonGroup = nullptr;
 554     static const char* const pPropertyKey = "PROPERTY_BUTTONGROUP";
 555     QVariant aVariant = pGroupOwner->property(pPropertyKey);
 556     if (aVariant.canConvert<QButtonGroup*>())
 557     {
 558         pButtonGroup = aVariant.value<QButtonGroup*>();
 559     }
 560     else
 561     {
 562         pButtonGroup = new QButtonGroup(pGroupOwner);
 563         pButtonGroup->addButton(pGroupOwner);
 564     }
 565
 566     QRadioButton* pRadioButton = get<QRadioButton>(rRadioButtonId);
 567     assert(pRadioButton && "No radio button with given ID");
 568     pButtonGroup->addButton(pRadioButton);
 569
 570     pGroupOwner->setProperty(pPropertyKey, QVariant::fromValue(pButtonGroup));
 571 }
 572
 573 void QtBuilder::setPriority(QObject*, int) { SAL_WARN("vcl.qt", "Ignoring priority"); }
 574
 575 void QtBuilder::setContext(QObject*, std::vector<vcl::EnumContext::Context>&&)
 576 {
 577     SAL_WARN("vcl.qt", "Ignoring context");
 578 }
 579
 580 bool QtBuilder::isHorizontalTabControl(QObject* pObject)
 581 {
 582     QTabWidget* pTabWidget = qobject_cast<QTabWidget*>(pObject);
 583     if (!pTabWidget)
 584         return false;
 585
 586     const QTabWidget::TabPosition ePosition = pTabWidget->tabPosition();
 587     return ePosition == QTabWidget::TabPosition::North
 588            || ePosition == QTabWidget::TabPosition::South;
 589 }
 590
 591 QMenu* QtBuilder::createMenu(const OUString& rId)
 592 {
 593     QMenu* pMenu = new QMenu;
 594     pMenu->setObjectName(toQString(rId));
 595     return pMenu;
 596 }
 597
 598 void QtBuilder::insertMenuObject(QMenu* pParent, QMenu* pSubMenu, const OUString& rClass,
 599                                  const OUString& rID, stringmap& rProps, stringmap&, accelmap&)
 600 {
 601     assert(!pSubMenu && "Handling not implemented yet");
 602     (void)pSubMenu;
 603
 604     if (rClass == "GtkMenuItem")
 605     {
 606         const OUString sLabel = extractLabel(rProps);
 607         QAction* pAction = pParent->addAction(toQString(sLabel));
 608         pAction->setObjectName(toQString(rID));
 609
 610         const OUString sActionName(extractActionName(rProps));
 611         QtInstanceMenu::setActionName(*pAction, sActionName);
 612     }
 613     else
 614     {
 615         assert(false && "Not implemented yet");
 616     }
 617 }
 618
 619 void QtBuilder::applyAtkProperties(QObject* pObject, const stringmap& rProperties, bool)
 620 {
 621     if (!pObject || !pObject->isWidgetType())
 622         return;
 623
 624     QWidget* pWidget = static_cast<QWidget*>(pObject);
 625
 626     for (auto const & [ rKey, rValue ] : rProperties)
 627     {
 628         if (rKey == "AtkObject::accessible-description")
 629             pWidget->setAccessibleDescription(toQString(rValue));
 630         else if (rKey == "AtkObject::accessible-name")
 631             pWidget->setAccessibleName(toQString(rValue));
 632     }
 633 }
 634
 635 void QtBuilder::applyGridPackingProperties(QWidget* pCurrentChild, QGridLayout& rGrid,
 636                                            const stringmap& rPackingProperties)
 637 {
 638     assert(pCurrentChild);
 639
 640     // properties not set when there's no explicit GtkGrid in the .ui file,
 641     // like for the QGridLayout that's the (implicit) layout of a QMessageBox
 642     if (!rPackingProperties.contains(u"left-attach"_ustr)
 643         || !rPackingProperties.contains(u"top-attach"_ustr))
 644         return;
 645
 646     const sal_Int32 nColumn = rPackingProperties.at(u"left-attach"_ustr).toInt32();
 647     const sal_Int32 nRow = rPackingProperties.at(u"top-attach"_ustr).toInt32();
 648
 649     auto aWidthIt = rPackingProperties.find(u"width"_ustr);
 650     sal_Int32 nColumnSpan = (aWidthIt == rPackingProperties.end()) ? 1 : aWidthIt->second.toInt32();
 651
 652     auto aHeightIt = rPackingProperties.find(u"height"_ustr);
 653     sal_Int32 nRowSpan = (aHeightIt == rPackingProperties.end()) ? 1 : aHeightIt->second.toInt32();
 654
 655     rGrid.removeWidget(pCurrentChild);
 656     rGrid.addWidget(pCurrentChild, nRow, nColumn, nRowSpan, nColumnSpan);
 657 }
 658
 659 void QtBuilder::applyPackingProperties(QObject* pCurrentChild, QObject* pParent,
 660                                        const stringmap& rPackingProperties)
 661 {
 662     if (!pCurrentChild)
 663         return;
 664
 665     QWidget* pWidget = nullptr;
 666     if (pCurrentChild->isWidgetType())
 667         pWidget = static_cast<QWidget*>(pCurrentChild);
 668     else
 669     {
 670         QObject* pParentObject = pCurrentChild->parent();
 671         assert(pParent && "Non-widget (i.e. layout) has no parent");
 672         if (pParentObject->isWidgetType())
 673             pWidget = static_cast<QWidget*>(pParentObject);
 674     }
 675
 676     if (!pWidget)
 677         return;
 678
 679     // check parent's parent, due to extra QWidget parents for layouts
 680     if (QGridLayout* pGrid = qobject_cast<QGridLayout*>(pParent))
 681         applyGridPackingProperties(pWidget, *pGrid, rPackingProperties);
 682     else
 683         SAL_WARN("vcl.qt", "QtBuilder::applyPackingProperties not yet implemented for this case");
 684 }
 685
 686 void QtBuilder::applyTabChildProperties(QObject* pParent, const std::vector<OUString>& rIDs,
 687                                         std::vector<vcl::EnumContext::Context>&,
 688                                         stringmap& rProperties, stringmap&)
 689 {
 690     QTabWidget* pTabWidget = qobject_cast<QTabWidget*>(pParent);
 691     assert(pTabWidget && "parent must be a QTabWidget");
 692
 693     // set ID and label for the last inserted tab
 694     assert(rProperties.contains(u"label"_ustr) && "Tab has no label");
 695     QtInstanceNotebook::setTabIdAndLabel(*pTabWidget, pTabWidget->count() - 1, rIDs.front(),
 696                                          rProperties.at(u"label"_ustr));
 697 }
 698
 699 void QtBuilder::set_response(std::u16string_view sID, short nResponse)
 700 {
 701     QPushButton* pPushButton = get<QPushButton>(sID);
 702     assert(pPushButton);
 703     pPushButton->setProperty(QtInstanceMessageDialog::PROPERTY_VCL_RESPONSE_CODE, int(nResponse));
 704 }
 705
 706 void QtBuilder::deleteObject(QObject* pObject)
 707 {
 708     if (pObject->isWidgetType())
 709         static_cast<QWidget*>(pObject)->hide();
 710     pObject->deleteLater();
 711 }
 712
 713 void QtBuilder::replaceWidget(QWidget* pOldWidget, QWidget* pNewWidget)
 714 {
 715     QWidget* pParent = pOldWidget->parentWidget();
 716     assert(pParent);
 717
 718     // replace old with new widget and mark old widget for deletion
 719     if (QLayout* pParentLayout = pParent->layout())
 720     {
 721         std::unique_ptr<QLayoutItem> pOldItem(pParentLayout->replaceWidget(pOldWidget, pNewWidget));
 722     }
 723     else if (QSplitter* pSplitter = qobject_cast<QSplitter*>(pParent))
 724     {
 725         const int nIndex = pSplitter->indexOf(pOldWidget);
 726         assert(nIndex >= 0 && "old widget not a child of the splitter");
 727         pSplitter->replaceWidget(nIndex, pNewWidget);
 728     }
 729     else
 730     {
 731         assert(false && "Unhandled case in replaceWidget - not implemented (yet)");
 732     }
 733
 734     deleteObject(pOldWidget);
 735 }
 736
 737 void QtBuilder::setProperties(QObject* pObject, stringmap& rProps)
 738 {
 739     if (QMessageBox* pMessageBox = qobject_cast<QMessageBox*>(pObject))
 740     {
 741         for (auto const & [ rKey, rValue ] : rProps)
 742         {
 743             if (rKey == u"text")
 744             {
 745                 pMessageBox->setText(toQString(rValue));
 746             }
 747             else if (rKey == u"title")
 748             {
 749                 pMessageBox->setWindowTitle(toQString(rValue));
 750             }
 751             else if (rKey == u"secondary-text")
 752             {
 753                 pMessageBox->setInformativeText(toQString(rValue));
 754             }
 755             else if (rKey == u"message-type")
 756             {
 757                 if (rValue == u"error")
 758                     pMessageBox->setIcon(QMessageBox::Critical);
 759                 else if (rValue == u"info")
 760                     pMessageBox->setIcon(QMessageBox::Information);
 761                 else if (rValue == u"question")
 762                     pMessageBox->setIcon(QMessageBox::Question);
 763                 else if (rValue == u"warning")
 764                     pMessageBox->setIcon(QMessageBox::Warning);
 765                 else
 766                     assert(false && "Unhandled message-type");
 767             }
 768         }
 769     }
 770     else if (qobject_cast<QCheckBox*>(pObject) || qobject_cast<QRadioButton*>(pObject))
 771     {
 772         QAbstractButton* pButton = static_cast<QAbstractButton*>(pObject);
 773         for (auto const & [ rKey, rValue ] : rProps)
 774         {
 775             if (rKey == u"active")
 776                 pButton->setChecked(toBool(rValue));
 777             else if (rKey == u"label")
 778                 pButton->setText(convertAccelerator(rValue));
 779         }
 780     }
 781     else if (QDialog* pDialog = qobject_cast<QDialog*>(pObject))
 782     {
 783         for (auto const & [ rKey, rValue ] : rProps)
 784         {
 785             if (rKey == u"modal")
 786                 pDialog->setModal(toBool(rValue));
 787             else if (rKey == u"title")
 788                 pDialog->setWindowTitle(toQString(rValue));
 789         }
 790     }
 791     else if (QPlainTextEdit* pTextEdit = qobject_cast<QPlainTextEdit*>(pObject))
 792     {
 793         for (auto const & [ rKey, rValue ] : rProps)
 794         {
 795             if (rKey == u"accepts-tab")
 796                 pTextEdit->setTabChangesFocus(!toBool(rValue));
 797         }
 798     }
 799     else if (QPushButton* pButton = qobject_cast<QPushButton*>(pObject))
 800     {
 801         for (auto const & [ rKey, rValue ] : rProps)
 802         {
 803             if (rKey == u"image")
 804             {
 805                 QLabel* pImageLabel = get<QLabel>(rValue);
 806                 assert(pImageLabel && "Button has non-existent image set");
 807 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 808                 pButton->setIcon(QIcon(pImageLabel->pixmap()));
 809 #else
 810                 pButton->setIcon(QIcon(pImageLabel->pixmap(Qt::ReturnByValue)));
 811 #endif
 812                 // parentless GtkImage in .ui file is only used for setting button
 813                 // image, so the object is no longer needed after doing so
 814                 if (!pImageLabel->parent())
 815                     deleteObject(pImageLabel);
 816             }
 817             else if (rKey == u"label")
 818             {
 819                 pButton->setText(convertAccelerator(rValue));
 820             }
 821         }
 822     }
 823 }
 824
 825 void QtBuilder::setLabelProperties(QLabel& rLabel, stringmap& rProps)
 826 {
 827     for (auto const & [ rKey, rValue ] : rProps)
 828     {
 829         if (rKey == u"label")
 830             rLabel.setText(convertAccelerator(rValue));
 831         else if (rKey == u"wrap")
 832             rLabel.setWordWrap(toBool(rValue));
 833     }
 834 }
 835
 836 void QtBuilder::setScaleProperties(QSlider& rSlider, stringmap& rProps)
 837 {
 838     if (!hasOrientationVertical(rProps))
 839         rSlider.setOrientation(Qt::Horizontal);
 840
 841     auto aAdjustmentIt = rProps.find("adjustment");
 842     if (aAdjustmentIt != rProps.end())
 843     {
 844         const Adjustment* pAdjustment = get_adjustment_by_name(aAdjustmentIt->second);
 845         assert(pAdjustment && "referenced adjustment doesn't exist");
 846         for (auto const & [ rKey, rValue ] : *pAdjustment)
 847         {
 848             if (rKey == u"upper")
 849                 rSlider.setMaximum(rValue.toInt32());
 850             else if (rKey == u"lower")
 851                 rSlider.setMinimum(rValue.toInt32());
 852             else if (rKey == "value")
 853                 rSlider.setValue(rValue.toInt32());
 854             else if (rKey == "page-increment")
 855                 rSlider.setPageStep(rValue.toInt32());
 856             else if (rKey == "step-increment")
 857                 rSlider.setSingleStep(rValue.toInt32());
 858         }
 859     }
 860 }
 861
 862 void QtBuilder::setSpinButtonProperties(QDoubleSpinBox& rSpinBox, stringmap& rProps)
 863 {
 864     auto aDigitsIt = rProps.find(u"digits"_ustr);
 865     sal_Int32 nDigits = (aDigitsIt != rProps.end()) ? aDigitsIt->second.toInt32() : 0;
 866     rSpinBox.setDecimals(nDigits);
 867
 868     auto aAdjustmentIt = rProps.find("adjustment");
 869     if (aAdjustmentIt != rProps.end())
 870     {
 871         const Adjustment* pAdjustment = get_adjustment_by_name(aAdjustmentIt->second);
 872         assert(pAdjustment && "referenced adjustment doesn't exist");
 873         for (auto const & [ rKey, rValue ] : *pAdjustment)
 874         {
 875             if (rKey == u"upper")
 876                 rSpinBox.setMaximum(rValue.toDouble());
 877             else if (rKey == u"lower")
 878                 rSpinBox.setMinimum(rValue.toDouble());
 879             else if (rKey == "value")
 880                 rSpinBox.setValue(rValue.toDouble());
 881             else if (rKey == "step-increment")
 882                 rSpinBox.setSingleStep(rValue.toDouble());
 883         }
 884     }
 885 }
 886
 887 QWidget* QtBuilder::windowForObject(QObject* pObject)
 888 {
 889     if (QWidget* pWidget = qobject_cast<QWidget*>(pObject))
 890         return pWidget->window();
 891
 892     if (QLayout* pLayout = qobject_cast<QLayout*>(pObject))
 893     {
 894         if (QWidget* pParentWidget = pLayout->parentWidget())
 895             return pParentWidget->window();
 896     }
 897
 898     return nullptr;
 899 }
 900
 901 QDialogButtonBox* QtBuilder::findButtonBox(QDialog* pDialog)
 902 {
 903     assert(pDialog);
 904     QLayout* pLayout = pDialog->layout();
 905     if (!pLayout)
 906         return nullptr;
 907
 908     for (int i = 0; i < pLayout->count(); i++)
 909     {
 910         QLayoutItem* pItem = pLayout->itemAt(i);
 911         if (QWidget* pItemWidget = pItem->widget())
 912         {
 913             if (QDialogButtonBox* pButtonBox = qobject_cast<QDialogButtonBox*>(pItemWidget))
 914                 return pButtonBox;
 915         }
 916     }
 917     return nullptr;
 918 }
 919
 920 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */