vcl/qt5/QtInstanceWidget.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 <QtInstanceWidget.hxx>
  11 #include <QtInstanceWidget.moc>
  12
  13 #include <QtInstanceContainer.hxx>
  14
  15 #include <vcl/transfer.hxx>
  16 #include <vcl/qt/QtUtils.hxx>
  17
  18 /** Name of QObject property used for the help ID. */
  19 const char* const PROPERTY_HELP_ID = "help-id";
  20
  21 QtInstanceWidget::QtInstanceWidget(QWidget* pWidget)
  22     : m_pWidget(pWidget)
  23 {
  24     assert(pWidget);
  25
  26     connect(qApp, &QApplication::focusChanged, this, &QtInstanceWidget::applicationFocusChanged);
  27 }
  28
  29 void QtInstanceWidget::set_sensitive(bool bSensitive)
  30 {
  31     SolarMutexGuard g;
  32     QtInstance& rQtInstance = GetQtInstance();
  33     if (!rQtInstance.IsMainThread())
  34     {
  35         rQtInstance.RunInMainThread([&] { set_sensitive(bSensitive); });
  36         return;
  37     }
  38
  39     assert(m_pWidget);
  40     m_pWidget->setEnabled(bSensitive);
  41 }
  42
  43 bool QtInstanceWidget::get_sensitive() const
  44 {
  45     SolarMutexGuard g;
  46     QtInstance& rQtInstance = GetQtInstance();
  47     if (!rQtInstance.IsMainThread())
  48     {
  49         bool bSensitive = false;
  50         rQtInstance.RunInMainThread([&] { bSensitive = get_sensitive(); });
  51         return bSensitive;
  52     }
  53
  54     assert(m_pWidget);
  55     return m_pWidget->isEnabled();
  56 }
  57
  58 bool QtInstanceWidget::get_visible() const
  59 {
  60     SolarMutexGuard g;
  61     QtInstance& rQtInstance = GetQtInstance();
  62     if (!rQtInstance.IsMainThread())
  63     {
  64         bool bVisible = false;
  65         rQtInstance.RunInMainThread([&] { bVisible = get_visible(); });
  66         return bVisible;
  67     }
  68
  69     assert(m_pWidget);
  70     return m_pWidget->isVisible();
  71 }
  72
  73 bool QtInstanceWidget::is_visible() const
  74 {
  75     SolarMutexGuard g;
  76     QtInstance& rQtInstance = GetQtInstance();
  77     if (!rQtInstance.IsMainThread())
  78     {
  79         bool bVisible = false;
  80         rQtInstance.RunInMainThread([&] { bVisible = is_visible(); });
  81         return bVisible;
  82     }
  83
  84     assert(m_pWidget);
  85
  86     QWidget* pTopLevel = m_pWidget->topLevelWidget();
  87     assert(pTopLevel);
  88     return m_pWidget->isVisibleTo(pTopLevel) && pTopLevel->isVisible();
  89 }
  90
  91 void QtInstanceWidget::set_can_focus(bool bCanFocus)
  92 {
  93     SolarMutexGuard g;
  94     QtInstance& rQtInstance = GetQtInstance();
  95     if (!rQtInstance.IsMainThread())
  96     {
  97         rQtInstance.RunInMainThread([&] { set_can_focus(bCanFocus); });
  98         return;
  99     }
 100
 101     assert(m_pWidget);
 102     if (bCanFocus)
 103         m_pWidget->setFocusPolicy(Qt::FocusPolicy::StrongFocus);
 104     else
 105         m_pWidget->setFocusPolicy(Qt::FocusPolicy::NoFocus);
 106 }
 107
 108 void QtInstanceWidget::grab_focus()
 109 {
 110     SolarMutexGuard g;
 111     QtInstance& rQtInstance = GetQtInstance();
 112     if (!rQtInstance.IsMainThread())
 113     {
 114         rQtInstance.RunInMainThread([&] { grab_focus(); });
 115         return;
 116     }
 117
 118     assert(m_pWidget);
 119     m_pWidget->setFocus();
 120 }
 121
 122 bool QtInstanceWidget::has_focus() const
 123 {
 124     SolarMutexGuard g;
 125     QtInstance& rQtInstance = GetQtInstance();
 126     if (!rQtInstance.IsMainThread())
 127     {
 128         bool bFocus = false;
 129         rQtInstance.RunInMainThread([&] { bFocus = has_focus(); });
 130         return bFocus;
 131     }
 132
 133     assert(m_pWidget);
 134     return m_pWidget->hasFocus();
 135 }
 136
 137 bool QtInstanceWidget::is_active() const { return has_focus(); }
 138
 139 bool QtInstanceWidget::has_child_focus() const
 140 {
 141     SolarMutexGuard g;
 142     QtInstance& rQtInstance = GetQtInstance();
 143     if (!rQtInstance.IsMainThread())
 144     {
 145         bool bChildFocus = false;
 146         rQtInstance.RunInMainThread([&] { bChildFocus = has_child_focus(); });
 147         return bChildFocus;
 148     }
 149
 150     QWidget* pFocusWidget = QApplication::focusWidget();
 151     if (!pFocusWidget)
 152         return false;
 153
 154     QWidget* pParent = pFocusWidget->parentWidget();
 155     while (pParent)
 156     {
 157         if (pParent == m_pWidget)
 158             return true;
 159         pParent = pParent->parentWidget();
 160     }
 161     return false;
 162 }
 163
 164 void QtInstanceWidget::show()
 165 {
 166     SolarMutexGuard g;
 167     QtInstance& rQtInstance = GetQtInstance();
 168     if (!rQtInstance.IsMainThread())
 169     {
 170         rQtInstance.RunInMainThread([&] { show(); });
 171         return;
 172     }
 173
 174     assert(m_pWidget);
 175     m_pWidget->show();
 176 }
 177
 178 void QtInstanceWidget::hide()
 179 {
 180     SolarMutexGuard g;
 181     QtInstance& rQtInstance = GetQtInstance();
 182     if (!rQtInstance.IsMainThread())
 183     {
 184         rQtInstance.RunInMainThread([&] { hide(); });
 185         return;
 186     }
 187
 188     assert(m_pWidget);
 189     m_pWidget->hide();
 190 }
 191
 192 void QtInstanceWidget::set_size_request(int nWidth, int nHeight)
 193 {
 194     SolarMutexGuard g;
 195     GetQtInstance().RunInMainThread(
 196         [&] { m_pWidget->setMinimumSize(std::max(0, nWidth), std::max(0, nHeight)); });
 197 }
 198
 199 Size QtInstanceWidget::get_size_request() const
 200 {
 201     SolarMutexGuard g;
 202
 203     Size aSize;
 204     GetQtInstance().RunInMainThread([&] { aSize = toSize(m_pWidget->minimumSize()); });
 205     return aSize;
 206 }
 207
 208 Size QtInstanceWidget::get_preferred_size() const
 209 {
 210     SolarMutexGuard g;
 211
 212     Size aPreferredSize;
 213     GetQtInstance().RunInMainThread([&] { aPreferredSize = toSize(m_pWidget->sizeHint()); });
 214
 215     return aPreferredSize;
 216 }
 217
 218 float QtInstanceWidget::get_approximate_digit_width() const
 219 {
 220     SolarMutexGuard g;
 221
 222     float fWidth = 0;
 223     GetQtInstance().RunInMainThread(
 224         [&] { fWidth = m_pWidget->fontMetrics().horizontalAdvance("0123456789") / 10.0; });
 225     return fWidth;
 226 }
 227
 228 int QtInstanceWidget::get_text_height() const
 229 {
 230     SolarMutexGuard g;
 231
 232     int nHeight = 0;
 233     GetQtInstance().RunInMainThread([&] { nHeight = m_pWidget->fontMetrics().height(); });
 234     return nHeight;
 235 }
 236
 237 Size QtInstanceWidget::get_pixel_size(const OUString& rText) const
 238 {
 239     SolarMutexGuard g;
 240
 241     Size aSize;
 242     GetQtInstance().RunInMainThread(
 243         [&] { aSize = toSize(m_pWidget->fontMetrics().boundingRect(toQString(rText)).size()); });
 244
 245     return aSize;
 246 }
 247
 248 vcl::Font QtInstanceWidget::get_font()
 249 {
 250     assert(false && "Not implemented yet");
 251     return vcl::Font();
 252 }
 253
 254 OUString QtInstanceWidget::get_buildable_name() const { return OUString(); }
 255
 256 void QtInstanceWidget::set_buildable_name(const OUString&) {}
 257
 258 void QtInstanceWidget::setHelpId(QWidget& rWidget, const OUString& rHelpId)
 259 {
 260     SolarMutexGuard g;
 261     GetQtInstance().RunInMainThread(
 262         [&] { rWidget.setProperty(PROPERTY_HELP_ID, toQString(rHelpId)); });
 263 }
 264
 265 void QtInstanceWidget::set_help_id(const OUString& rHelpId) { setHelpId(*m_pWidget, rHelpId); }
 266
 267 OUString QtInstanceWidget::get_help_id() const
 268 {
 269     SolarMutexGuard g;
 270     QtInstance& rQtInstance = GetQtInstance();
 271     if (!rQtInstance.IsMainThread())
 272     {
 273         OUString sHelpId;
 274         rQtInstance.RunInMainThread([&] { sHelpId = get_help_id(); });
 275         return sHelpId;
 276     }
 277
 278     const QVariant aHelpIdVariant = m_pWidget->property(PROPERTY_HELP_ID);
 279     if (!aHelpIdVariant.isValid())
 280         return OUString();
 281
 282     assert(aHelpIdVariant.canConvert<QString>());
 283     return toOUString(aHelpIdVariant.toString());
 284 }
 285
 286 void QtInstanceWidget::set_hexpand(bool) { assert(false && "Not implemented yet"); }
 287
 288 bool QtInstanceWidget::get_hexpand() const
 289 {
 290     assert(false && "Not implemented yet");
 291     return true;
 292 }
 293
 294 void QtInstanceWidget::set_vexpand(bool) { assert(false && "Not implemented yet"); }
 295
 296 bool QtInstanceWidget::get_vexpand() const
 297 {
 298     assert(false && "Not implemented yet");
 299     return true;
 300 }
 301
 302 void QtInstanceWidget::set_margin_top(int) { assert(false && "Not implemented yet"); }
 303
 304 void QtInstanceWidget::set_margin_bottom(int) { assert(false && "Not implemented yet"); }
 305
 306 void QtInstanceWidget::set_margin_start(int) { assert(false && "Not implemented yet"); }
 307
 308 void QtInstanceWidget::set_margin_end(int) { assert(false && "Not implemented yet"); }
 309
 310 int QtInstanceWidget::get_margin_top() const
 311 {
 312     assert(false && "Not implemented yet");
 313     return 0;
 314 }
 315
 316 int QtInstanceWidget::get_margin_bottom() const
 317 {
 318     assert(false && "Not implemented yet");
 319     return 0;
 320 }
 321
 322 int QtInstanceWidget::get_margin_start() const
 323 {
 324     assert(false && "Not implemented yet");
 325     return 0;
 326 }
 327
 328 int QtInstanceWidget::get_margin_end() const
 329 {
 330     assert(false && "Not implemented yet");
 331     return 0;
 332 }
 333
 334 void QtInstanceWidget::set_accessible_name(const OUString& rName)
 335 {
 336     SolarMutexGuard g;
 337     QtInstance& rQtInstance = GetQtInstance();
 338     if (!rQtInstance.IsMainThread())
 339     {
 340         rQtInstance.RunInMainThread([&] { set_accessible_name(rName); });
 341         return;
 342     }
 343
 344     assert(m_pWidget);
 345     m_pWidget->setAccessibleName(toQString(rName));
 346 }
 347
 348 void QtInstanceWidget::set_accessible_description(const OUString& rDescription)
 349 {
 350     SolarMutexGuard g;
 351     QtInstance& rQtInstance = GetQtInstance();
 352     if (!rQtInstance.IsMainThread())
 353     {
 354         rQtInstance.RunInMainThread([&] { set_accessible_description(rDescription); });
 355         return;
 356     }
 357
 358     assert(m_pWidget);
 359     m_pWidget->setAccessibleDescription(toQString(rDescription));
 360 }
 361
 362 OUString QtInstanceWidget::get_accessible_name() const
 363 {
 364     SolarMutexGuard g;
 365     QtInstance& rQtInstance = GetQtInstance();
 366     if (!rQtInstance.IsMainThread())
 367     {
 368         OUString sName;
 369         rQtInstance.RunInMainThread([&] { sName = get_accessible_name(); });
 370         return sName;
 371     }
 372
 373     assert(m_pWidget);
 374     return toOUString(m_pWidget->accessibleName());
 375 }
 376
 377 OUString QtInstanceWidget::get_accessible_description() const
 378 {
 379     SolarMutexGuard g;
 380     QtInstance& rQtInstance = GetQtInstance();
 381     if (!rQtInstance.IsMainThread())
 382     {
 383         OUString sDescription;
 384         rQtInstance.RunInMainThread([&] { sDescription = get_accessible_description(); });
 385         return sDescription;
 386     }
 387
 388     assert(m_pWidget);
 389     return toOUString(m_pWidget->accessibleDescription());
 390 }
 391
 392 OUString QtInstanceWidget::get_accessible_id() const
 393 {
 394     SolarMutexGuard g;
 395     QtInstance& rQtInstance = GetQtInstance();
 396     if (!rQtInstance.IsMainThread())
 397     {
 398         OUString sId;
 399         rQtInstance.RunInMainThread([&] { sId = get_accessible_id(); });
 400         return sId;
 401     }
 402
 403     assert(m_pWidget);
 404 #if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
 405     return toOUString(m_pWidget->accessibleIdentifier());
 406 #else
 407     return OUString();
 408 #endif
 409 }
 410
 411 void QtInstanceWidget::set_accessible_relation_labeled_by(weld::Widget*)
 412 {
 413     assert(false && "Not implemented yet");
 414 }
 415
 416 void QtInstanceWidget::set_tooltip_text(const OUString& rTip)
 417 {
 418     SolarMutexGuard g;
 419     QtInstance& rQtInstance = GetQtInstance();
 420     if (!rQtInstance.IsMainThread())
 421     {
 422         rQtInstance.RunInMainThread([&] { set_tooltip_text(rTip); });
 423         return;
 424     }
 425
 426     assert(m_pWidget);
 427     m_pWidget->setToolTip(toQString(rTip));
 428 }
 429
 430 OUString QtInstanceWidget::get_tooltip_text() const
 431 {
 432     SolarMutexGuard g;
 433     QtInstance& rQtInstance = GetQtInstance();
 434     if (!rQtInstance.IsMainThread())
 435     {
 436         OUString sToolTipText;
 437         rQtInstance.RunInMainThread([&] { sToolTipText = get_tooltip_text(); });
 438         return sToolTipText;
 439     }
 440
 441     assert(m_pWidget);
 442     return toOUString(m_pWidget->toolTip());
 443 }
 444
 445 void QtInstanceWidget::set_cursor_data(void*) { assert(false && "Not implemented yet"); }
 446
 447 void QtInstanceWidget::grab_add() { assert(false && "Not implemented yet"); }
 448
 449 bool QtInstanceWidget::has_grab() const
 450 {
 451     assert(false && "Not implemented yet");
 452     return false;
 453 }
 454
 455 void QtInstanceWidget::grab_remove() { assert(false && "Not implemented yet"); }
 456
 457 bool QtInstanceWidget::get_extents_relative_to(const Widget& rRelative, int& rX, int& rY,
 458                                                int& rWidth, int& rHeight) const
 459 {
 460     SolarMutexGuard g;
 461
 462     bool bRet = false;
 463     GetQtInstance().RunInMainThread([&] {
 464         QRect aGeometry = m_pWidget->geometry();
 465         rWidth = aGeometry.width();
 466         rHeight = aGeometry.height();
 467         const QtInstanceWidget* pRelativeWidget = dynamic_cast<const QtInstanceWidget*>(&rRelative);
 468         if (!pRelativeWidget)
 469             return;
 470
 471         QPoint aRelativePos = m_pWidget->mapTo(pRelativeWidget->getQWidget(), QPoint(0, 0));
 472         rX = aRelativePos.x();
 473         rY = aRelativePos.y();
 474         bRet = true;
 475     });
 476
 477     return bRet;
 478 }
 479
 480 bool QtInstanceWidget::get_direction() const
 481 {
 482     SolarMutexGuard g;
 483
 484     bool bRTL = false;
 485     GetQtInstance().RunInMainThread(
 486         [&] { bRTL = m_pWidget->layoutDirection() == Qt::LayoutDirection::RightToLeft; });
 487     return bRTL;
 488 }
 489
 490 void QtInstanceWidget::set_direction(bool bRTL)
 491 {
 492     SolarMutexGuard g;
 493
 494     GetQtInstance().RunInMainThread([&] {
 495         m_pWidget->setLayoutDirection(bRTL ? Qt::LayoutDirection::RightToLeft
 496                                            : Qt::LayoutDirection::LeftToRight);
 497     });
 498 }
 499
 500 void QtInstanceWidget::freeze(){};
 501
 502 void QtInstanceWidget::thaw(){};
 503
 504 void QtInstanceWidget::set_busy_cursor(bool bBusy)
 505 {
 506     SolarMutexGuard g;
 507
 508     GetQtInstance().RunInMainThread([&] {
 509         if (bBusy)
 510             ++m_nBusyCount;
 511         else
 512             --m_nBusyCount;
 513         assert(m_nBusyCount >= 0);
 514
 515         if (m_nBusyCount == 1)
 516             m_pWidget->setCursor(Qt::BusyCursor);
 517         else if (m_nBusyCount == 0)
 518             m_pWidget->unsetCursor();
 519     });
 520 }
 521
 522 std::unique_ptr<weld::Container> QtInstanceWidget::weld_parent() const
 523 {
 524     QWidget* pParentWidget = m_pWidget->parentWidget();
 525     if (!pParentWidget)
 526         return nullptr;
 527
 528     return std::make_unique<QtInstanceContainer>(pParentWidget);
 529 }
 530
 531 void QtInstanceWidget::queue_resize()
 532 {
 533     SolarMutexGuard g;
 534
 535     GetQtInstance().RunInMainThread([&] { m_pWidget->adjustSize(); });
 536 }
 537
 538 void QtInstanceWidget::help_hierarchy_foreach(const std::function<bool(const OUString&)>&)
 539 {
 540     assert(false && "Not implemented yet");
 541 }
 542
 543 OUString QtInstanceWidget::strip_mnemonic(const OUString& rLabel) const
 544 {
 545     return rLabel.replaceFirst("&", "");
 546 }
 547
 548 OUString QtInstanceWidget::escape_ui_str(const OUString& rLabel) const
 549 {
 550     // preserve literal '&'
 551     return rLabel.replaceAll("&", "&&");
 552 }
 553
 554 VclPtr<VirtualDevice> QtInstanceWidget::create_virtual_device() const
 555 {
 556     VclPtr<VirtualDevice> xRet = VclPtr<VirtualDevice>::Create();
 557     xRet->SetBackground(COL_TRANSPARENT);
 558     return xRet;
 559 }
 560
 561 css::uno::Reference<css::datatransfer::dnd::XDropTarget> QtInstanceWidget::get_drop_target()
 562 {
 563     assert(false && "Not implemented yet");
 564     return nullptr;
 565 }
 566
 567 css::uno::Reference<css::datatransfer::clipboard::XClipboard>
 568 QtInstanceWidget::get_clipboard() const
 569 {
 570     return GetSystemClipboard();
 571 }
 572
 573 void QtInstanceWidget::connect_get_property_tree(const Link<tools::JsonWriter&, void>&)
 574 {
 575     // not implemented for the Qt variant
 576 }
 577
 578 void QtInstanceWidget::get_property_tree(tools::JsonWriter&)
 579 {
 580     // not implemented for the Qt variant
 581 }
 582
 583 void QtInstanceWidget::call_attention_to() { assert(false && "Not implemented yet"); }
 584
 585 void QtInstanceWidget::set_stack_background() { assert(false && "Not implemented yet"); }
 586
 587 void QtInstanceWidget::set_title_background() { assert(false && "Not implemented yet"); }
 588
 589 void QtInstanceWidget::set_toolbar_background() { assert(false && "Not implemented yet"); }
 590
 591 void QtInstanceWidget::set_highlight_background() { assert(false && "Not implemented yet"); }
 592
 593 void QtInstanceWidget::set_background(const Color& rBackColor)
 594 {
 595     QPalette aPalette = getQWidget()->palette();
 596     aPalette.setColor(QPalette::Base, toQColor(rBackColor));
 597     getQWidget()->setPalette(aPalette);
 598     getQWidget()->setBackgroundRole(QPalette::Base);
 599 }
 600
 601 void QtInstanceWidget::draw(OutputDevice&, const Point&, const Size&)
 602 {
 603     assert(false && "Not implemented yet");
 604 }
 605
 606 void QtInstanceWidget::applicationFocusChanged(QWidget* pOldFocus, QWidget* pNewFocus)
 607 {
 608     SolarMutexGuard g;
 609
 610     if (pOldFocus == m_pWidget)
 611         signal_focus_out();
 612     else if (pNewFocus == m_pWidget)
 613         signal_focus_in();
 614 }
 615
 616 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */