vcl/jsdialog/jsdialogbuilder.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 <jsdialog/jsdialogbuilder.hxx>
  11 #include <sal/log.hxx>
  12 #include <comphelper/base64.hxx>
  13 #include <iconview.hxx>
  14 #include <utility>
  15 #include <vcl/menu.hxx>
  16 #include <vcl/svapp.hxx>
  17 #include <vcl/toolbox.hxx>
  18 #include <vcl/toolkit/button.hxx>
  19 #include <vcl/toolkit/combobox.hxx>
  20 #include <vcl/toolkit/dialog.hxx>
  21 #include <vcl/toolkit/treelistentry.hxx>
  22 #include <vcl/toolkit/vclmedit.hxx>
  23 #include <verticaltabctrl.hxx>
  24 #include <messagedialog.hxx>
  25 #include <tools/json_writer.hxx>
  26 #include <memory>
  27 #include <vcl/jsdialog/executor.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <tools/stream.hxx>
  30 #include <vcl/cvtgrf.hxx>
  31 #include <wizdlg.hxx>
  32
  33 namespace
  34 {
  35 void response_help(vcl::Window* pWindow)
  36 {
  37     ::Dialog* pDialog = dynamic_cast<::Dialog*>(pWindow);
  38     if (!pDialog)
  39         return;
  40
  41     vcl::Window* pButtonWindow = pDialog->get_widget_for_response(RET_HELP);
  42     ::Button* pButton = dynamic_cast<::Button*>(pButtonWindow);
  43     if (!pButton)
  44     {
  45         // Is it a wizard dialog?
  46         vcl::RoadmapWizard* pWizard = dynamic_cast<vcl::RoadmapWizard*>(pWindow);
  47         if (!pWizard || !pWizard->m_pHelp)
  48             return;
  49         pWizard->m_pHelp->Click();
  50         return;
  51     }
  52
  53     pButton->Click();
  54 }
  55 }
  56
  57 namespace
  58 {
  59 vcl::Window* extract_sal_widget(weld::Widget* pParent)
  60 {
  61     SalInstanceWidget* pInstanceWidget = dynamic_cast<SalInstanceWidget*>(pParent);
  62     return pInstanceWidget ? pInstanceWidget->getWidget() : nullptr;
  63 }
  64 }
  65
  66 // Drag and drop
  67
  68 namespace
  69 {
  70 class JSDropTargetDropContext
  71     : public cppu::WeakImplHelper<css::datatransfer::dnd::XDropTargetDropContext>
  72 {
  73 public:
  74     JSDropTargetDropContext() {}
  75
  76     // XDropTargetDropContext
  77     virtual void SAL_CALL acceptDrop(sal_Int8 /*dragOperation*/) override {}
  78
  79     virtual void SAL_CALL rejectDrop() override {}
  80
  81     virtual void SAL_CALL dropComplete(sal_Bool /*bSuccess*/) override {}
  82 };
  83 }
  84
  85 static JSTreeView* g_DragSource;
  86
  87 JSDropTarget::JSDropTarget() {}
  88
  89 void JSDropTarget::initialize(const css::uno::Sequence<css::uno::Any>& /*rArgs*/) {}
  90
  91 void JSDropTarget::addDropTargetListener(
  92     const css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>& xListener)
  93 {
  94     std::unique_lock aGuard(m_aMutex);
  95
  96     m_aListeners.push_back(xListener);
  97 }
  98
  99 void JSDropTarget::removeDropTargetListener(
 100     const css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>& xListener)
 101 {
 102     std::unique_lock aGuard(m_aMutex);
 103
 104     std::erase(m_aListeners, xListener);
 105 }
 106
 107 sal_Bool JSDropTarget::isActive() { return false; }
 108
 109 void JSDropTarget::setActive(sal_Bool /*active*/) {}
 110
 111 sal_Int8 JSDropTarget::getDefaultActions() { return 0; }
 112
 113 void JSDropTarget::setDefaultActions(sal_Int8 /*actions*/) {}
 114
 115 OUString JSDropTarget::getImplementationName()
 116 {
 117     return u"com.sun.star.datatransfer.dnd.JSDropTarget"_ustr;
 118 }
 119
 120 sal_Bool JSDropTarget::supportsService(OUString const& ServiceName)
 121 {
 122     return cppu::supportsService(this, ServiceName);
 123 }
 124
 125 css::uno::Sequence<OUString> JSDropTarget::getSupportedServiceNames()
 126 {
 127     css::uno::Sequence<OUString> aRet{ u"com.sun.star.datatransfer.dnd.JSDropTarget"_ustr };
 128     return aRet;
 129 }
 130
 131 void JSDropTarget::fire_drop(const css::datatransfer::dnd::DropTargetDropEvent& dtde)
 132 {
 133     std::unique_lock aGuard(m_aMutex);
 134     std::vector<css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>> aListeners(
 135         m_aListeners);
 136     aGuard.unlock();
 137
 138     for (auto const& listener : aListeners)
 139     {
 140         listener->drop(dtde);
 141     }
 142 }
 143
 144 void JSDropTarget::fire_dragEnter(const css::datatransfer::dnd::DropTargetDragEnterEvent& dtde)
 145 {
 146     std::unique_lock aGuard(m_aMutex);
 147     std::vector<css::uno::Reference<css::datatransfer::dnd::XDropTargetListener>> aListeners(
 148         m_aListeners);
 149     aGuard.unlock();
 150
 151     for (auto const& listener : aListeners)
 152     {
 153         listener->dragEnter(dtde);
 154     }
 155 }
 156
 157 void JSInstanceBuilder::initializeDialogSender()
 158 {
 159     m_sTypeOfJSON = "dialog";
 160
 161     vcl::Window* pRoot = m_xBuilder->get_widget_root();
 162
 163     if (pRoot && pRoot->GetParent())
 164     {
 165         m_aParentDialog = pRoot->GetParent()->GetParentWithLOKNotifier();
 166         if (m_aParentDialog)
 167             m_nWindowId = m_aParentDialog->GetLOKWindowId();
 168         InsertWindowToMap(getMapIdFromWindowId());
 169     }
 170
 171     initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 172 }
 173
 174 void JSInstanceBuilder::initializePopupSender()
 175 {
 176     // when it is a popup we initialize sender in weld_popover
 177     m_sTypeOfJSON = "popup";
 178 }
 179
 180 void JSInstanceBuilder::initializeSidebarSender(sal_uInt64 nLOKWindowId,
 181                                                 const std::u16string_view& rUIFile)
 182 {
 183     m_sTypeOfJSON = "sidebar";
 184     m_nWindowId = nLOKWindowId;
 185
 186     vcl::Window* pRoot = m_xBuilder->get_widget_root();
 187
 188     m_aParentDialog = pRoot->GetParentWithLOKNotifier();
 189
 190     if (rUIFile == u"sfx/ui/panel.ui")
 191     {
 192         // builder for Panel, get SidebarDockingWindow as m_aContentWindow
 193         m_aContentWindow = pRoot;
 194         for (int i = 0; i < 7 && m_aContentWindow; i++)
 195             m_aContentWindow = m_aContentWindow->GetParent();
 196     }
 197     else
 198     {
 199         // embedded fragments cannot send close message for whole sidebar
 200         if (rUIFile == u"modules/simpress/ui/customanimationfragment.ui")
 201             m_bCanClose = false;
 202
 203         // builder for PanelLayout, get SidebarDockingWindow as m_aContentWindow
 204         m_aContentWindow = pRoot;
 205         for (int i = 0; i < 9 && m_aContentWindow; i++)
 206             m_aContentWindow = m_aContentWindow->GetParent();
 207     }
 208
 209     InsertWindowToMap(getMapIdFromWindowId());
 210
 211     initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 212 }
 213
 214 void JSInstanceBuilder::initializeNotebookbarSender(sal_uInt64 nLOKWindowId)
 215 {
 216     m_sTypeOfJSON = "notebookbar";
 217
 218     vcl::Window* pRoot = m_xBuilder->get_widget_root();
 219     if (pRoot && pRoot->GetParent())
 220     {
 221         m_aParentDialog = pRoot->GetParent()->GetParentWithLOKNotifier();
 222         if (m_aParentDialog)
 223             m_nWindowId = m_aParentDialog->GetLOKWindowId();
 224         if (!m_nWindowId && nLOKWindowId)
 225         {
 226             m_nWindowId = nLOKWindowId;
 227             m_bIsNotebookbar = true;
 228         }
 229         InsertWindowToMap(getMapIdFromWindowId());
 230     }
 231
 232     initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 233 }
 234
 235 void JSInstanceBuilder::initializeFormulabarSender(sal_uInt64 nLOKWindowId,
 236                                                    const std::u16string_view& sTypeOfJSON,
 237                                                    vcl::Window* pVclParent)
 238 {
 239     m_sTypeOfJSON = sTypeOfJSON;
 240     m_nWindowId = nLOKWindowId;
 241
 242     vcl::Window* pRoot = m_xBuilder->get_widget_root();
 243     m_aContentWindow = pVclParent;
 244     if (pRoot && pRoot->GetParent())
 245     {
 246         m_aParentDialog = pRoot->GetParent()->GetParentWithLOKNotifier();
 247         InsertWindowToMap(getMapIdFromWindowId());
 248     }
 249
 250     initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 251 }
 252
 253 void JSInstanceBuilder::initializeMenuSender(weld::Widget* pParent)
 254 {
 255     m_sTypeOfJSON = "menu";
 256     m_aParentDialog = extract_sal_widget(pParent)->GetParentWithLOKNotifier();
 257     initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 258 }
 259
 260 JSInstanceBuilder::JSInstanceBuilder(weld::Widget* pParent, vcl::Window* pVclParent,
 261                                      std::u16string_view rUIRoot, const OUString& rUIFile,
 262                                      JSInstanceBuilder::Type eBuilderType, sal_uInt64 nLOKWindowId,
 263                                      const std::u16string_view& sTypeOfJSON,
 264                                      const css::uno::Reference<css::frame::XFrame>& rFrame)
 265     : SalInstanceBuilder(pVclParent ? pVclParent : extract_sal_widget(pParent), rUIRoot, rUIFile,
 266                          rFrame)
 267     , m_nWindowId(0)
 268     , m_aParentDialog(nullptr)
 269     , m_aContentWindow(nullptr)
 270     , m_sTypeOfJSON("unknown")
 271     , m_bHasTopLevelDialog(false)
 272     , m_bIsNotebookbar(false)
 273     , m_bSentInitialUpdate(false)
 274     , m_bIsNestedBuilder(false)
 275     , m_aWindowToRelease(nullptr)
 276 {
 277     switch (eBuilderType)
 278     {
 279         case JSInstanceBuilder::Type::Dialog:
 280             initializeDialogSender();
 281             break;
 282
 283         case JSInstanceBuilder::Type::Popup:
 284             initializePopupSender();
 285             break;
 286
 287         case JSInstanceBuilder::Type::Sidebar:
 288             initializeSidebarSender(nLOKWindowId, rUIFile);
 289             break;
 290
 291         case JSInstanceBuilder::Type::Notebookbar:
 292             initializeNotebookbarSender(nLOKWindowId);
 293             break;
 294
 295         case JSInstanceBuilder::Type::Formulabar:
 296             initializeFormulabarSender(nLOKWindowId, sTypeOfJSON, pVclParent);
 297             break;
 298
 299         case JSInstanceBuilder::Type::Menu:
 300             initializeMenuSender(pParent);
 301             break;
 302
 303         default:
 304             assert(false);
 305     };
 306 }
 307
 308 std::unique_ptr<JSInstanceBuilder> JSInstanceBuilder::CreateDialogBuilder(weld::Widget* pParent,
 309                                                                           const OUString& rUIRoot,
 310                                                                           const OUString& rUIFile)
 311 {
 312     return std::make_unique<JSInstanceBuilder>(pParent, nullptr, rUIRoot, rUIFile,
 313                                                JSInstanceBuilder::Type::Dialog);
 314 }
 315
 316 std::unique_ptr<JSInstanceBuilder> JSInstanceBuilder::CreateNotebookbarBuilder(
 317     vcl::Window* pParent, const OUString& rUIRoot, const OUString& rUIFile,
 318     const css::uno::Reference<css::frame::XFrame>& rFrame, sal_uInt64 nWindowId)
 319 {
 320     return std::make_unique<JSInstanceBuilder>(nullptr, pParent, rUIRoot, rUIFile,
 321                                                JSInstanceBuilder::Type::Notebookbar, nWindowId, u"",
 322                                                rFrame);
 323 }
 324
 325 std::unique_ptr<JSInstanceBuilder> JSInstanceBuilder::CreateSidebarBuilder(weld::Widget* pParent,
 326                                                                            const OUString& rUIRoot,
 327                                                                            const OUString& rUIFile,
 328                                                                            sal_uInt64 nLOKWindowId)
 329 {
 330     return std::make_unique<JSInstanceBuilder>(pParent, nullptr, rUIRoot, rUIFile,
 331                                                JSInstanceBuilder::Type::Sidebar, nLOKWindowId);
 332 }
 333
 334 std::unique_ptr<JSInstanceBuilder> JSInstanceBuilder::CreatePopupBuilder(weld::Widget* pParent,
 335                                                                          const OUString& rUIRoot,
 336                                                                          const OUString& rUIFile)
 337 {
 338     return std::make_unique<JSInstanceBuilder>(pParent, nullptr, rUIRoot, rUIFile,
 339                                                JSInstanceBuilder::Type::Popup);
 340 }
 341
 342 std::unique_ptr<JSInstanceBuilder> JSInstanceBuilder::CreateMenuBuilder(weld::Widget* pParent,
 343                                                                         const OUString& rUIRoot,
 344                                                                         const OUString& rUIFile)
 345 {
 346     return std::make_unique<JSInstanceBuilder>(pParent, nullptr, rUIRoot, rUIFile,
 347                                                JSInstanceBuilder::Type::Menu);
 348 }
 349
 350 std::unique_ptr<JSInstanceBuilder>
 351 JSInstanceBuilder::CreateFormulabarBuilder(vcl::Window* pParent, const OUString& rUIRoot,
 352                                            const OUString& rUIFile, sal_uInt64 nLOKWindowId)
 353 {
 354     return std::make_unique<JSInstanceBuilder>(nullptr, pParent, rUIRoot, rUIFile,
 355                                                JSInstanceBuilder::Type::Formulabar, nLOKWindowId,
 356                                                u"formulabar");
 357 }
 358
 359 std::unique_ptr<JSInstanceBuilder>
 360 JSInstanceBuilder::CreateAddressInputBuilder(vcl::Window* pParent, const OUString& rUIRoot,
 361                                              const OUString& rUIFile, sal_uInt64 nLOKWindowId)
 362 {
 363     return std::make_unique<JSInstanceBuilder>(nullptr, pParent, rUIRoot, rUIFile,
 364                                                JSInstanceBuilder::Type::Formulabar, nLOKWindowId,
 365                                                u"addressinputfield");
 366 }
 367
 368 JSInstanceBuilder::~JSInstanceBuilder()
 369 {
 370     // tab page closed -> refresh parent window
 371     if (m_bIsNestedBuilder && m_sTypeOfJSON == "dialog")
 372     {
 373         jsdialog::SendFullUpdate(OUString::number(m_nWindowId), u"__DIALOG__"_ustr);
 374     }
 375
 376     if (m_sTypeOfJSON == "popup" || m_sTypeOfJSON == "menu")
 377         sendClosePopup(m_nWindowId);
 378
 379     if (m_aWindowToRelease)
 380     {
 381         m_aWindowToRelease->ReleaseLOKNotifier();
 382         m_aWindowToRelease.clear();
 383     }
 384
 385     if (m_nWindowId && (m_bHasTopLevelDialog || m_bIsNotebookbar))
 386     {
 387         JSInstanceBuilder::Widgets().Forget(getMapIdFromWindowId());
 388     }
 389     else
 390     {
 391         auto aWindowMap = JSInstanceBuilder::Widgets().Find(getMapIdFromWindowId());
 392         if (aWindowMap)
 393         {
 394             std::for_each(m_aRememberedWidgets.begin(), m_aRememberedWidgets.end(),
 395                           [&aWindowMap](const OUString& sId) { aWindowMap->Forget(sId); });
 396         }
 397     }
 398
 399     JSInstanceBuilder::Popups().Forget(OUString::number(m_nWindowId));
 400     JSInstanceBuilder::Menus().Forget(OUString::number(m_nWindowId));
 401 }
 402
 403 const OUString& JSInstanceBuilder::GetTypeOfJSON() const { return m_sTypeOfJSON; }
 404
 405 VclPtr<vcl::Window>& JSInstanceBuilder::GetContentWindow()
 406 {
 407     if (m_aContentWindow)
 408         return m_aContentWindow;
 409     else
 410         return m_bHasTopLevelDialog ? m_aOwnedToplevel : m_aParentDialog;
 411 }
 412
 413 VclPtr<vcl::Window>& JSInstanceBuilder::GetNotifierWindow()
 414 {
 415     return m_bHasTopLevelDialog ? m_aOwnedToplevel : m_aParentDialog;
 416 }
 417
 418 std::unique_ptr<weld::Dialog> JSInstanceBuilder::weld_dialog(const OUString& id)
 419 {
 420     std::unique_ptr<weld::Dialog> pRet;
 421     ::Dialog* pDialog = m_xBuilder->get<::Dialog>(id);
 422
 423     if (pDialog)
 424     {
 425         if (!pDialog->GetLOKNotifier())
 426             pDialog->SetLOKNotifier(GetpApp());
 427
 428         m_nWindowId = pDialog->GetLOKWindowId();
 429         pDialog->SetLOKTunnelingState(false);
 430
 431         InsertWindowToMap(getMapIdFromWindowId());
 432
 433         assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
 434         m_aOwnedToplevel.set(pDialog);
 435         m_xBuilder->drop_ownership(pDialog);
 436         m_bHasTopLevelDialog = true;
 437
 438         pRet.reset(new JSDialog(this, pDialog, this, false));
 439
 440         RememberWidget(u"__DIALOG__"_ustr, pRet.get());
 441
 442         initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 443         m_bSentInitialUpdate = true;
 444     }
 445
 446     return pRet;
 447 }
 448
 449 std::unique_ptr<weld::Assistant> JSInstanceBuilder::weld_assistant(const OUString& id)
 450 {
 451     vcl::RoadmapWizard* pDialog = m_xBuilder->get<vcl::RoadmapWizard>(id);
 452     std::unique_ptr<JSAssistant> pRet(pDialog ? new JSAssistant(this, pDialog, this, false)
 453                                               : nullptr);
 454     if (pDialog)
 455     {
 456         m_nWindowId = pDialog->GetLOKWindowId();
 457         pDialog->SetLOKTunnelingState(false);
 458
 459         InsertWindowToMap(getMapIdFromWindowId());
 460
 461         assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
 462         m_aOwnedToplevel.set(pDialog);
 463         m_xBuilder->drop_ownership(pDialog);
 464         m_bHasTopLevelDialog = true;
 465
 466         pRet.reset(new JSAssistant(this, pDialog, this, false));
 467
 468         RememberWidget(u"__DIALOG__"_ustr, pRet.get());
 469
 470         initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 471         m_bSentInitialUpdate = true;
 472     }
 473
 474     return pRet;
 475 }
 476
 477 std::unique_ptr<weld::MessageDialog> JSInstanceBuilder::weld_message_dialog(const OUString& id)
 478 {
 479     std::unique_ptr<weld::MessageDialog> pRet;
 480     ::MessageDialog* pMessageDialog = m_xBuilder->get<::MessageDialog>(id);
 481
 482     if (pMessageDialog)
 483     {
 484         m_nWindowId = pMessageDialog->GetLOKWindowId();
 485         pMessageDialog->SetLOKTunnelingState(false);
 486
 487         InsertWindowToMap(getMapIdFromWindowId());
 488
 489         assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
 490         m_aOwnedToplevel.set(pMessageDialog);
 491         m_xBuilder->drop_ownership(pMessageDialog);
 492         m_bHasTopLevelDialog = true;
 493
 494         initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 495         m_bSentInitialUpdate = true;
 496     }
 497
 498     pRet.reset(pMessageDialog ? new JSMessageDialog(this, pMessageDialog, this, false) : nullptr);
 499
 500     if (pRet)
 501         RememberWidget(u"__DIALOG__"_ustr, pRet.get());
 502
 503     return pRet;
 504 }
 505
 506 std::unique_ptr<weld::Container> JSInstanceBuilder::weld_container(const OUString& id)
 507 {
 508     vcl::Window* pContainer = m_xBuilder->get<vcl::Window>(id);
 509     auto pWeldWidget
 510         = pContainer ? std::make_unique<JSContainer>(this, pContainer, this, false) : nullptr;
 511
 512     if (pWeldWidget)
 513         RememberWidget(id, pWeldWidget.get());
 514
 515     if (!m_bSentInitialUpdate && pContainer)
 516     {
 517         m_bSentInitialUpdate = true;
 518
 519         // use parent builder to send update - avoid multiple calls from many builders
 520         vcl::Window* pParent = pContainer->GetParent();
 521         OUString sId = OUString::number(m_nWindowId);
 522         while (pParent)
 523         {
 524             auto aWidgetMap = Widgets().Find(sId);
 525             if (!aWidgetMap || !aWidgetMap->Find(pParent->get_id()))
 526                 break;
 527             pParent = pParent->GetParent();
 528         }
 529
 530         if (pParent)
 531             jsdialog::SendFullUpdate(sId, pParent->get_id());
 532
 533         // this is nested builder, don't close parent dialog on destroy (eg. single tab page is closed)
 534         m_bCanClose = false;
 535         m_bIsNestedBuilder = true;
 536     }
 537
 538     return pWeldWidget;
 539 }
 540
 541 std::unique_ptr<weld::ScrolledWindow>
 542 JSInstanceBuilder::weld_scrolled_window(const OUString& id, bool bUserManagedScrolling)
 543 {
 544     VclScrolledWindow* pScrolledWindow = m_xBuilder->get<VclScrolledWindow>(id);
 545     auto pWeldWidget = pScrolledWindow
 546                            ? std::make_unique<JSScrolledWindow>(this, pScrolledWindow, this, false,
 547                                                                 bUserManagedScrolling)
 548                            : nullptr;
 549
 550     if (pWeldWidget)
 551         RememberWidget(id, pWeldWidget.get());
 552
 553     return pWeldWidget;
 554 }
 555
 556 std::unique_ptr<weld::Label> JSInstanceBuilder::weld_label(const OUString& id)
 557 {
 558     Control* pLabel = m_xBuilder->get<Control>(id);
 559     auto pWeldWidget = std::make_unique<JSLabel>(this, pLabel, this, false);
 560
 561     if (pWeldWidget)
 562         RememberWidget(id, pWeldWidget.get());
 563
 564     return pWeldWidget;
 565 }
 566
 567 std::unique_ptr<weld::Button> JSInstanceBuilder::weld_button(const OUString& id)
 568 {
 569     ::Button* pButton = m_xBuilder->get<::Button>(id);
 570     auto pWeldWidget = pButton ? std::make_unique<JSButton>(this, pButton, this, false) : nullptr;
 571
 572     if (pWeldWidget)
 573         RememberWidget(id, pWeldWidget.get());
 574
 575     return pWeldWidget;
 576 }
 577
 578 std::unique_ptr<weld::LinkButton> JSInstanceBuilder::weld_link_button(const OUString& id)
 579 {
 580     ::FixedHyperlink* pButton = m_xBuilder->get<::FixedHyperlink>(id);
 581     auto pWeldWidget
 582         = pButton ? std::make_unique<JSLinkButton>(this, pButton, this, false) : nullptr;
 583
 584     if (pWeldWidget)
 585         RememberWidget(id, pWeldWidget.get());
 586
 587     return pWeldWidget;
 588 }
 589
 590 std::unique_ptr<weld::ToggleButton> JSInstanceBuilder::weld_toggle_button(const OUString& id)
 591 {
 592     ::PushButton* pButton = m_xBuilder->get<::PushButton>(id);
 593     auto pWeldWidget
 594         = pButton ? std::make_unique<JSToggleButton>(this, pButton, this, false) : nullptr;
 595
 596     if (pWeldWidget)
 597         RememberWidget(id, pWeldWidget.get());
 598
 599     return pWeldWidget;
 600 }
 601
 602 std::unique_ptr<weld::Entry> JSInstanceBuilder::weld_entry(const OUString& id)
 603 {
 604     Edit* pEntry = m_xBuilder->get<Edit>(id);
 605     auto pWeldWidget = pEntry ? std::make_unique<JSEntry>(this, pEntry, this, false) : nullptr;
 606
 607     if (pWeldWidget)
 608         RememberWidget(id, pWeldWidget.get());
 609
 610     return pWeldWidget;
 611 }
 612
 613 std::unique_ptr<weld::ComboBox> JSInstanceBuilder::weld_combo_box(const OUString& id)
 614 {
 615     vcl::Window* pWidget = m_xBuilder->get<vcl::Window>(id);
 616     ::ComboBox* pComboBox = dynamic_cast<::ComboBox*>(pWidget);
 617     std::unique_ptr<weld::ComboBox> pWeldWidget;
 618
 619     if (pComboBox)
 620     {
 621         pWeldWidget = std::make_unique<JSComboBox>(this, pComboBox, this, false);
 622     }
 623     else
 624     {
 625         ListBox* pListBox = dynamic_cast<ListBox*>(pWidget);
 626         pWeldWidget = pListBox ? std::make_unique<JSListBox>(this, pListBox, this, false) : nullptr;
 627     }
 628
 629     if (pWeldWidget)
 630         RememberWidget(id, pWeldWidget.get());
 631
 632     return pWeldWidget;
 633 }
 634
 635 std::unique_ptr<weld::Notebook> JSInstanceBuilder::weld_notebook(const OUString& id)
 636 {
 637     std::unique_ptr<weld::Notebook> pWeldWidget;
 638     vcl::Window* pNotebook = m_xBuilder->get(id);
 639
 640     if (pNotebook && pNotebook->GetType() == WindowType::TABCONTROL)
 641         pWeldWidget
 642             = std::make_unique<JSNotebook>(this, static_cast<TabControl*>(pNotebook), this, false);
 643     else if (pNotebook && pNotebook->GetType() == WindowType::VERTICALTABCONTROL)
 644         pWeldWidget = std::make_unique<JSVerticalNotebook>(
 645             this, static_cast<VerticalTabControl*>(pNotebook), this, false);
 646
 647     if (pWeldWidget)
 648         RememberWidget(id, pWeldWidget.get());
 649
 650     return pWeldWidget;
 651 }
 652
 653 std::unique_ptr<weld::SpinButton> JSInstanceBuilder::weld_spin_button(const OUString& id)
 654 {
 655     FormattedField* pSpinButton = m_xBuilder->get<FormattedField>(id);
 656     auto pWeldWidget
 657         = pSpinButton ? std::make_unique<JSSpinButton>(this, pSpinButton, this, false) : nullptr;
 658
 659     if (pWeldWidget)
 660         RememberWidget(id, pWeldWidget.get());
 661
 662     return pWeldWidget;
 663 }
 664
 665 std::unique_ptr<weld::FormattedSpinButton>
 666 JSInstanceBuilder::weld_formatted_spin_button(const OUString& id)
 667 {
 668     FormattedField* pSpinButton = m_xBuilder->get<FormattedField>(id);
 669     auto pWeldWidget = pSpinButton
 670                            ? std::make_unique<JSFormattedSpinButton>(this, pSpinButton, this, false)
 671                            : nullptr;
 672
 673     if (pWeldWidget)
 674         RememberWidget(id, pWeldWidget.get());
 675
 676     return pWeldWidget;
 677 }
 678
 679 std::unique_ptr<weld::CheckButton> JSInstanceBuilder::weld_check_button(const OUString& id)
 680 {
 681     CheckBox* pCheckButton = m_xBuilder->get<CheckBox>(id);
 682     auto pWeldWidget
 683         = pCheckButton ? std::make_unique<JSCheckButton>(this, pCheckButton, this, false) : nullptr;
 684
 685     if (pWeldWidget)
 686         RememberWidget(id, pWeldWidget.get());
 687
 688     return pWeldWidget;
 689 }
 690
 691 std::unique_ptr<weld::DrawingArea>
 692 JSInstanceBuilder::weld_drawing_area(const OUString& id, const a11yref& rA11yImpl,
 693                                      FactoryFunction pUITestFactoryFunction, void* pUserData)
 694 {
 695     VclDrawingArea* pArea = m_xBuilder->get<VclDrawingArea>(id);
 696     auto pWeldWidget = pArea ? std::make_unique<JSDrawingArea>(this, pArea, this, rA11yImpl,
 697                                                                pUITestFactoryFunction, pUserData)
 698                              : nullptr;
 699
 700     if (pWeldWidget)
 701         RememberWidget(id, pWeldWidget.get());
 702
 703     return pWeldWidget;
 704 }
 705
 706 std::unique_ptr<weld::Toolbar> JSInstanceBuilder::weld_toolbar(const OUString& id)
 707 {
 708     ToolBox* pToolBox = m_xBuilder->get<ToolBox>(id);
 709     auto pWeldWidget
 710         = pToolBox ? std::make_unique<JSToolbar>(this, pToolBox, this, false) : nullptr;
 711
 712     if (pWeldWidget)
 713         RememberWidget(id, pWeldWidget.get());
 714
 715     return pWeldWidget;
 716 }
 717
 718 std::unique_ptr<weld::TextView> JSInstanceBuilder::weld_text_view(const OUString& id)
 719 {
 720     VclMultiLineEdit* pTextView = m_xBuilder->get<VclMultiLineEdit>(id);
 721     auto pWeldWidget
 722         = pTextView ? std::make_unique<JSTextView>(this, pTextView, this, false) : nullptr;
 723
 724     if (pWeldWidget)
 725         RememberWidget(id, pWeldWidget.get());
 726
 727     return pWeldWidget;
 728 }
 729
 730 std::unique_ptr<weld::TreeView> JSInstanceBuilder::weld_tree_view(const OUString& id)
 731 {
 732     SvTabListBox* pTreeView = m_xBuilder->get<SvTabListBox>(id);
 733     auto pWeldWidget
 734         = pTreeView ? std::make_unique<JSTreeView>(this, pTreeView, this, false) : nullptr;
 735
 736     if (pWeldWidget)
 737         RememberWidget(id, pWeldWidget.get());
 738
 739     return pWeldWidget;
 740 }
 741
 742 std::unique_ptr<weld::Expander> JSInstanceBuilder::weld_expander(const OUString& id)
 743 {
 744     VclExpander* pExpander = m_xBuilder->get<VclExpander>(id);
 745     auto pWeldWidget
 746         = pExpander ? std::make_unique<JSExpander>(this, pExpander, this, false) : nullptr;
 747
 748     if (pWeldWidget)
 749         RememberWidget(id, pWeldWidget.get());
 750
 751     return pWeldWidget;
 752 }
 753
 754 std::unique_ptr<weld::IconView> JSInstanceBuilder::weld_icon_view(const OUString& id)
 755 {
 756     ::IconView* pIconView = m_xBuilder->get<::IconView>(id);
 757     auto pWeldWidget
 758         = pIconView ? std::make_unique<JSIconView>(this, pIconView, this, false) : nullptr;
 759
 760     if (pWeldWidget)
 761         RememberWidget(id, pWeldWidget.get());
 762
 763     return pWeldWidget;
 764 }
 765
 766 std::unique_ptr<weld::RadioButton> JSInstanceBuilder::weld_radio_button(const OUString& id)
 767 {
 768     ::RadioButton* pRadioButton = m_xBuilder->get<::RadioButton>(id);
 769     auto pWeldWidget
 770         = pRadioButton ? std::make_unique<JSRadioButton>(this, pRadioButton, this, false) : nullptr;
 771
 772     if (pWeldWidget)
 773         RememberWidget(id, pWeldWidget.get());
 774
 775     return pWeldWidget;
 776 }
 777
 778 std::unique_ptr<weld::Frame> JSInstanceBuilder::weld_frame(const OUString& id)
 779 {
 780     ::VclFrame* pFrame = m_xBuilder->get<::VclFrame>(id);
 781     auto pWeldWidget = pFrame ? std::make_unique<JSFrame>(this, pFrame, this, false) : nullptr;
 782
 783     if (pWeldWidget)
 784         RememberWidget(id, pWeldWidget.get());
 785
 786     return pWeldWidget;
 787 }
 788
 789 std::unique_ptr<weld::MenuButton> JSInstanceBuilder::weld_menu_button(const OUString& id)
 790 {
 791     ::MenuButton* pMenuButton = m_xBuilder->get<::MenuButton>(id);
 792     auto pWeldWidget
 793         = pMenuButton ? std::make_unique<JSMenuButton>(this, pMenuButton, this, false) : nullptr;
 794
 795     if (pWeldWidget)
 796         RememberWidget(id, pWeldWidget.get());
 797
 798     return pWeldWidget;
 799 }
 800
 801 std::unique_ptr<weld::Menu> JSInstanceBuilder::weld_menu(const OUString& id)
 802 {
 803     PopupMenu* pPopupMenu = m_xBuilder->get_menu(id);
 804
 805     JSMenu* pMenu = pPopupMenu ? new JSMenu(this, pPopupMenu, this, false) : nullptr;
 806
 807     std::unique_ptr<weld::Menu> pWeldWidget(pMenu);
 808
 809     if (pWeldWidget)
 810         JSInstanceBuilder::Menus().Remember(getMapIdFromWindowId(), pWeldWidget.get());
 811
 812     return pWeldWidget;
 813 }
 814
 815 std::unique_ptr<weld::Popover> JSInstanceBuilder::weld_popover(const OUString& id)
 816 {
 817     DockingWindow* pDockingWindow = m_xBuilder->get<DockingWindow>(id);
 818     JSPopover* pPopover
 819         = pDockingWindow ? new JSPopover(this, pDockingWindow, this, false) : nullptr;
 820     std::unique_ptr<weld::Popover> pWeldWidget(pPopover);
 821     if (pDockingWindow)
 822     {
 823         assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
 824         m_aOwnedToplevel.set(pDockingWindow);
 825         m_xBuilder->drop_ownership(pDockingWindow);
 826
 827         if (VclPtr<vcl::Window> pWin = pDockingWindow->GetParentWithLOKNotifier())
 828         {
 829             vcl::Window* pPopupRoot = pDockingWindow->GetChild(0);
 830             pPopupRoot->SetLOKNotifier(pWin->GetLOKNotifier());
 831             m_aParentDialog = pPopupRoot;
 832             m_aWindowToRelease = pPopupRoot;
 833             m_nWindowId = m_aParentDialog->GetLOKWindowId();
 834
 835             pPopover->set_window_id(m_nWindowId);
 836             JSInstanceBuilder::Popups().Remember(OUString::number(m_nWindowId), pDockingWindow);
 837
 838             InsertWindowToMap(getMapIdFromWindowId());
 839             initializeSender(GetNotifierWindow(), GetContentWindow(), GetTypeOfJSON());
 840         }
 841     }
 842
 843     if (pWeldWidget)
 844         RememberWidget(u"__POPOVER__"_ustr, pWeldWidget.get());
 845
 846     return pWeldWidget;
 847 }
 848
 849 std::unique_ptr<weld::Box> JSInstanceBuilder::weld_box(const OUString& id)
 850 {
 851     VclBox* pContainer = m_xBuilder->get<VclBox>(id);
 852     auto pWeldWidget
 853         = pContainer ? std::make_unique<JSBox>(this, pContainer, this, false) : nullptr;
 854
 855     if (pWeldWidget)
 856         RememberWidget(id, pWeldWidget.get());
 857
 858     return pWeldWidget;
 859 }
 860
 861 std::unique_ptr<weld::Widget> JSInstanceBuilder::weld_widget(const OUString& id)
 862 {
 863     vcl::Window* pWidget = m_xBuilder->get(id);
 864     auto pWeldWidget
 865         = pWidget ? std::make_unique<JSWidgetInstance>(this, pWidget, this, false) : nullptr;
 866
 867     if (pWeldWidget)
 868         RememberWidget(id, pWeldWidget.get());
 869
 870     return pWeldWidget;
 871 }
 872
 873 std::unique_ptr<weld::Image> JSInstanceBuilder::weld_image(const OUString& id)
 874 {
 875     FixedImage* pImage = m_xBuilder->get<FixedImage>(id);
 876
 877     auto pWeldWidget = pImage ? std::make_unique<JSImage>(this, pImage, this, false) : nullptr;
 878
 879     if (pWeldWidget)
 880         RememberWidget(id, pWeldWidget.get());
 881
 882     return pWeldWidget;
 883 }
 884
 885 std::unique_ptr<weld::LevelBar> JSInstanceBuilder::weld_level_bar(const OUString& id)
 886 {
 887     ::ProgressBar* pLevelBar = m_xBuilder->get<::ProgressBar>(id);
 888
 889     auto pWeldWidget
 890         = pLevelBar ? std::make_unique<JSLevelBar>(this, pLevelBar, this, false) : nullptr;
 891
 892     if (pWeldWidget)
 893         RememberWidget(id, pWeldWidget.get());
 894
 895     return pWeldWidget;
 896 }
 897
 898 std::unique_ptr<weld::Calendar> JSInstanceBuilder::weld_calendar(const OUString& id)
 899 {
 900     ::Calendar* pCalendar = m_xBuilder->get<::Calendar>(id);
 901
 902     auto pWeldWidget
 903         = pCalendar ? std::make_unique<JSCalendar>(this, pCalendar, this, false) : nullptr;
 904
 905     if (pWeldWidget)
 906         RememberWidget(id, pWeldWidget.get());
 907
 908     return pWeldWidget;
 909 }
 910
 911 weld::MessageDialog*
 912 JSInstanceBuilder::CreateMessageDialog(weld::Widget* pParent, VclMessageType eMessageType,
 913                                        VclButtonsType eButtonType, const OUString& rPrimaryMessage,
 914                                        const vcl::ILibreOfficeKitNotifier* pNotifier)
 915 {
 916     SalInstanceWidget* pParentInstance = dynamic_cast<SalInstanceWidget*>(pParent);
 917     SystemWindow* pParentWidget = pParentInstance ? pParentInstance->getSystemWindow() : nullptr;
 918     VclPtrInstance<::MessageDialog> xMessageDialog(pParentWidget, rPrimaryMessage, eMessageType,
 919                                                    eButtonType);
 920
 921     if (pNotifier)
 922         xMessageDialog->SetLOKNotifier(pNotifier);
 923
 924     pNotifier = xMessageDialog->GetLOKNotifier();
 925     if (pNotifier)
 926     {
 927         OUString sWindowId = OUString::number(xMessageDialog->GetLOKWindowId());
 928         InsertWindowToMap(sWindowId);
 929         xMessageDialog->SetLOKTunnelingState(false);
 930
 931         return new JSMessageDialog(xMessageDialog, nullptr, true);
 932     }
 933     else
 934         SAL_WARN("vcl", "No notifier in JSInstanceBuilder::CreateMessageDialog");
 935
 936     return new JSMessageDialog(xMessageDialog, nullptr, true);
 937 }
 938
 939 JSDialog::JSDialog(JSDialogSender* pSender, ::Dialog* pDialog, SalInstanceBuilder* pBuilder,
 940                    bool bTakeOwnership)
 941     : JSWidget<SalInstanceDialog, ::Dialog>(pSender, pDialog, pBuilder, bTakeOwnership)
 942 {
 943 }
 944
 945 void JSDialog::collapse(weld::Widget* pEdit, weld::Widget* pButton)
 946 {
 947     SalInstanceDialog::collapse(pEdit, pButton);
 948     sendFullUpdate();
 949 }
 950
 951 void JSDialog::undo_collapse()
 952 {
 953     SalInstanceDialog::undo_collapse();
 954     sendFullUpdate();
 955 }
 956
 957 void JSDialog::response(int response)
 958 {
 959     if (response == RET_HELP)
 960     {
 961         response_help(m_xWidget.get());
 962         return;
 963     }
 964
 965     sendClose();
 966     SalInstanceDialog::response(response);
 967 }
 968
 969 void JSAssistant::response(int response)
 970 {
 971     if (response == RET_HELP)
 972     {
 973         response_help(m_xWidget.get());
 974         return;
 975     }
 976
 977     sendClose();
 978     SalInstanceAssistant::response(response);
 979 }
 980
 981 int JSDialog::run()
 982 {
 983     sendFullUpdate(true);
 984     int ret = SalInstanceDialog::run();
 985     return ret;
 986 }
 987
 988 bool JSDialog::runAsync(std::shared_ptr<weld::DialogController> const& rxOwner,
 989                         const std::function<void(sal_Int32)>& rEndDialogFn)
 990 {
 991     bool ret = SalInstanceDialog::runAsync(rxOwner, rEndDialogFn);
 992     sendFullUpdate();
 993     return ret;
 994 }
 995
 996 bool JSDialog::runAsync(std::shared_ptr<Dialog> const& rxSelf,
 997                         const std::function<void(sal_Int32)>& func)
 998 {
 999     bool ret = SalInstanceDialog::runAsync(rxSelf, func);
1000     sendFullUpdate();
1001     return ret;
1002 }
1003
1004 int JSAssistant::run()
1005 {
1006     sendFullUpdate(true);
1007     int ret = SalInstanceDialog::run();
1008     return ret;
1009 }
1010
1011 bool JSAssistant::runAsync(std::shared_ptr<weld::DialogController> const& rxOwner,
1012                            const std::function<void(sal_Int32)>& rEndDialogFn)
1013 {
1014     bool ret = SalInstanceDialog::runAsync(rxOwner, rEndDialogFn);
1015     sendFullUpdate();
1016     return ret;
1017 }
1018
1019 bool JSAssistant::runAsync(std::shared_ptr<Dialog> const& rxSelf,
1020                            const std::function<void(sal_Int32)>& func)
1021 {
1022     bool ret = SalInstanceDialog::runAsync(rxSelf, func);
1023     sendFullUpdate();
1024     return ret;
1025 }
1026
1027 std::unique_ptr<weld::Button> JSDialog::weld_button_for_response(int nResponse)
1028 {
1029     std::unique_ptr<weld::Button> xWeldWidget;
1030     if (PushButton* pButton
1031         = dynamic_cast<::PushButton*>(m_xDialog->get_widget_for_response(nResponse)))
1032     {
1033         xWeldWidget = std::make_unique<JSButton>(m_pSender, pButton, nullptr, false);
1034
1035         auto pParentDialog = m_xDialog->GetParentWithLOKNotifier();
1036         if (pParentDialog)
1037             JSInstanceBuilder::RememberWidget(OUString::number(pParentDialog->GetLOKWindowId()),
1038                                               pButton->get_id(), xWeldWidget.get());
1039     }
1040
1041     return xWeldWidget;
1042 }
1043
1044 std::unique_ptr<weld::Button> JSAssistant::weld_button_for_response(int nResponse)
1045 {
1046     ::PushButton* pButton = nullptr;
1047     std::unique_ptr<JSButton> xWeldWidget;
1048     if (nResponse == RET_YES)
1049         pButton = m_xWizard->m_pNextPage;
1050     else if (nResponse == RET_NO)
1051         pButton = m_xWizard->m_pPrevPage;
1052     else if (nResponse == RET_OK)
1053         pButton = m_xWizard->m_pFinish;
1054     else if (nResponse == RET_CANCEL)
1055         pButton = m_xWizard->m_pCancel;
1056     else if (nResponse == RET_HELP)
1057         pButton = m_xWizard->m_pHelp;
1058
1059     if (pButton)
1060     {
1061         xWeldWidget = std::make_unique<JSButton>(m_pSender, pButton, nullptr, false);
1062
1063         auto pParentDialog = m_xWizard->GetParentWithLOKNotifier();
1064         if (pParentDialog)
1065             JSInstanceBuilder::RememberWidget(OUString::number(pParentDialog->GetLOKWindowId()),
1066                                               pButton->get_id(), xWeldWidget.get());
1067     }
1068
1069     return xWeldWidget;
1070 }
1071
1072 JSAssistant::JSAssistant(JSDialogSender* pSender, vcl::RoadmapWizard* pDialog,
1073                          SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1074     : JSWidget<SalInstanceAssistant, vcl::RoadmapWizard>(pSender, pDialog, pBuilder, bTakeOwnership)
1075 {
1076 }
1077
1078 void JSAssistant::set_current_page(int nPage)
1079 {
1080     SalInstanceAssistant::set_current_page(nPage);
1081     sendFullUpdate();
1082 }
1083
1084 void JSAssistant::set_current_page(const OUString& rIdent)
1085 {
1086     SalInstanceAssistant::set_current_page(rIdent);
1087     sendFullUpdate();
1088 }
1089
1090 JSContainer::JSContainer(JSDialogSender* pSender, vcl::Window* pContainer,
1091                          SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1092     : JSWidget<SalInstanceContainer, vcl::Window>(pSender, pContainer, pBuilder, bTakeOwnership)
1093 {
1094 }
1095
1096 void JSContainer::move(weld::Widget* pWidget, weld::Container* pNewParent)
1097 {
1098     SalInstanceContainer::move(pWidget, pNewParent);
1099     sendFullUpdate();
1100 }
1101
1102 JSScrolledWindow::JSScrolledWindow(JSDialogSender* pSender, ::VclScrolledWindow* pContainer,
1103                                    SalInstanceBuilder* pBuilder, bool bTakeOwnership,
1104                                    bool bUserManagedScrolling)
1105     : JSWidget<SalInstanceScrolledWindow, ::VclScrolledWindow>(
1106           pSender, pContainer, pBuilder, bTakeOwnership, bUserManagedScrolling)
1107 {
1108 }
1109
1110 void JSScrolledWindow::vadjustment_configure(int value, int lower, int upper, int step_increment,
1111                                              int page_increment, int page_size)
1112 {
1113     SalInstanceScrolledWindow::vadjustment_configure(value, lower, upper, step_increment,
1114                                                      page_increment, page_size);
1115     sendUpdate();
1116 }
1117
1118 void JSScrolledWindow::vadjustment_set_value(int value)
1119 {
1120     SalInstanceScrolledWindow::vadjustment_set_value(value);
1121     sendUpdate();
1122 }
1123
1124 void JSScrolledWindow::vadjustment_set_value_no_notification(int value)
1125 {
1126     SalInstanceScrolledWindow::vadjustment_set_value(value);
1127 }
1128
1129 void JSScrolledWindow::vadjustment_set_page_size(int size)
1130 {
1131     SalInstanceScrolledWindow::vadjustment_set_page_size(size);
1132     sendUpdate();
1133 }
1134
1135 void JSScrolledWindow::set_vpolicy(VclPolicyType eVPolicy)
1136 {
1137     SalInstanceScrolledWindow::set_vpolicy(eVPolicy);
1138     sendUpdate();
1139 }
1140
1141 void JSScrolledWindow::hadjustment_configure(int value, int lower, int upper, int step_increment,
1142                                              int page_increment, int page_size)
1143 {
1144     SalInstanceScrolledWindow::hadjustment_configure(value, lower, upper, step_increment,
1145                                                      page_increment, page_size);
1146     sendUpdate();
1147 }
1148
1149 void JSScrolledWindow::hadjustment_set_value(int value)
1150 {
1151     SalInstanceScrolledWindow::hadjustment_set_value(value);
1152     sendUpdate();
1153 }
1154
1155 void JSScrolledWindow::hadjustment_set_value_no_notification(int value)
1156 {
1157     SalInstanceScrolledWindow::hadjustment_set_value(value);
1158 }
1159
1160 void JSScrolledWindow::hadjustment_set_page_size(int size)
1161 {
1162     SalInstanceScrolledWindow::hadjustment_set_page_size(size);
1163     sendUpdate();
1164 }
1165
1166 void JSScrolledWindow::set_hpolicy(VclPolicyType eVPolicy)
1167 {
1168     SalInstanceScrolledWindow::set_hpolicy(eVPolicy);
1169     sendUpdate();
1170 }
1171
1172 JSLabel::JSLabel(JSDialogSender* pSender, Control* pLabel, SalInstanceBuilder* pBuilder,
1173                  bool bTakeOwnership)
1174     : JSWidget<SalInstanceLabel, Control>(pSender, pLabel, pBuilder, bTakeOwnership)
1175 {
1176 }
1177
1178 void JSLabel::set_label(const OUString& rText)
1179 {
1180     SalInstanceLabel::set_label(rText);
1181     sendUpdate();
1182 };
1183
1184 JSButton::JSButton(JSDialogSender* pSender, ::Button* pButton, SalInstanceBuilder* pBuilder,
1185                    bool bTakeOwnership)
1186     : JSWidget<SalInstanceButton, ::Button>(pSender, pButton, pBuilder, bTakeOwnership)
1187 {
1188 }
1189
1190 JSLinkButton::JSLinkButton(JSDialogSender* pSender, ::FixedHyperlink* pButton,
1191                            SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1192     : JSWidget<SalInstanceLinkButton, ::FixedHyperlink>(pSender, pButton, pBuilder, bTakeOwnership)
1193 {
1194 }
1195
1196 JSToggleButton::JSToggleButton(JSDialogSender* pSender, ::PushButton* pButton,
1197                                SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1198     : JSWidget<SalInstanceToggleButton, ::PushButton>(pSender, pButton, pBuilder, bTakeOwnership)
1199 {
1200 }
1201
1202 JSEntry::JSEntry(JSDialogSender* pSender, ::Edit* pEntry, SalInstanceBuilder* pBuilder,
1203                  bool bTakeOwnership)
1204     : JSWidget<SalInstanceEntry, ::Edit>(pSender, pEntry, pBuilder, bTakeOwnership)
1205 {
1206 }
1207
1208 void JSEntry::set_text(const OUString& rText)
1209 {
1210     SalInstanceEntry::set_text(rText);
1211     sendUpdate();
1212 }
1213
1214 void JSEntry::set_text_without_notify(const OUString& rText) { SalInstanceEntry::set_text(rText); }
1215
1216 void JSEntry::replace_selection(const OUString& rText)
1217 {
1218     SalInstanceEntry::replace_selection(rText);
1219     sendUpdate();
1220 }
1221
1222 JSListBox::JSListBox(JSDialogSender* pSender, ::ListBox* pListBox, SalInstanceBuilder* pBuilder,
1223                      bool bTakeOwnership)
1224     : JSWidget<SalInstanceComboBoxWithoutEdit, ::ListBox>(pSender, pListBox, pBuilder,
1225                                                           bTakeOwnership)
1226 {
1227 }
1228
1229 void JSListBox::insert(int pos, const OUString& rStr, const OUString* pId,
1230                        const OUString* pIconName, VirtualDevice* pImageSurface)
1231 {
1232     SalInstanceComboBoxWithoutEdit::insert(pos, rStr, pId, pIconName, pImageSurface);
1233     sendUpdate();
1234 }
1235
1236 void JSListBox::remove(int pos)
1237 {
1238     SalInstanceComboBoxWithoutEdit::remove(pos);
1239     sendUpdate();
1240 }
1241
1242 void JSListBox::set_active(int pos)
1243 {
1244     SalInstanceComboBoxWithoutEdit::set_active(pos);
1245     sendUpdate();
1246 }
1247
1248 JSComboBox::JSComboBox(JSDialogSender* pSender, ::ComboBox* pComboBox, SalInstanceBuilder* pBuilder,
1249                        bool bTakeOwnership)
1250     : JSWidget<SalInstanceComboBoxWithEdit, ::ComboBox>(pSender, pComboBox, pBuilder,
1251                                                         bTakeOwnership)
1252 {
1253 }
1254
1255 void JSComboBox::insert(int pos, const OUString& rStr, const OUString* pId,
1256                         const OUString* pIconName, VirtualDevice* pImageSurface)
1257 {
1258     SalInstanceComboBoxWithEdit::insert(pos, rStr, pId, pIconName, pImageSurface);
1259     sendUpdate();
1260 }
1261
1262 void JSComboBox::remove(int pos)
1263 {
1264     SalInstanceComboBoxWithEdit::remove(pos);
1265     sendUpdate();
1266 }
1267
1268 void JSComboBox::set_entry_text_without_notify(const OUString& rText)
1269 {
1270     SalInstanceComboBoxWithEdit::set_entry_text(rText);
1271 }
1272
1273 void JSComboBox::set_entry_text(const OUString& rText)
1274 {
1275     SalInstanceComboBoxWithEdit::set_entry_text(rText);
1276
1277     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1278     (*pMap)[ACTION_TYPE ""_ostr] = "setText";
1279     (*pMap)["text"_ostr] = rText;
1280     sendAction(std::move(pMap));
1281 }
1282
1283 void JSComboBox::set_active(int pos)
1284 {
1285     if (pos == get_active())
1286         return;
1287
1288     SalInstanceComboBoxWithEdit::set_active(pos);
1289
1290     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1291     (*pMap)[ACTION_TYPE ""_ostr] = "select";
1292     (*pMap)["position"_ostr] = OUString::number(pos);
1293     sendAction(std::move(pMap));
1294 }
1295
1296 void JSComboBox::set_active_id(const OUString& rStr)
1297 {
1298     sal_uInt16 nPos = find_id(rStr);
1299     set_active(nPos);
1300 }
1301
1302 bool JSComboBox::changed_by_direct_pick() const { return true; }
1303
1304 void JSComboBox::render_entry(int pos, int dpix, int dpiy)
1305 {
1306     ScopedVclPtrInstance<VirtualDevice> pDevice(DeviceFormat::WITH_ALPHA);
1307     pDevice->SetDPIX(96.0 * dpix / 100);
1308     pDevice->SetDPIY(96.0 * dpiy / 100);
1309
1310     Size aRenderSize = signal_custom_get_size(*pDevice);
1311     pDevice->SetOutputSize(aRenderSize);
1312
1313     signal_custom_render(*pDevice, tools::Rectangle(Point(0, 0), aRenderSize), false, get_id(pos));
1314
1315     BitmapEx aImage = pDevice->GetBitmapEx(Point(0, 0), aRenderSize);
1316
1317     SvMemoryStream aOStm(65535, 65535);
1318     if (GraphicConverter::Export(aOStm, aImage, ConvertDataFormat::PNG) == ERRCODE_NONE)
1319     {
1320         css::uno::Sequence<sal_Int8> aSeq(static_cast<sal_Int8 const*>(aOStm.GetData()),
1321                                           aOStm.Tell());
1322         OUStringBuffer aBuffer("data:image/png;base64,");
1323         ::comphelper::Base64::encode(aBuffer, aSeq);
1324
1325         std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1326         (*pMap)[ACTION_TYPE ""_ostr] = "rendered_entry";
1327         (*pMap)["pos"_ostr] = OUString::number(pos);
1328         (*pMap)["image"_ostr] = aBuffer;
1329         sendAction(std::move(pMap));
1330     }
1331 }
1332
1333 JSNotebook::JSNotebook(JSDialogSender* pSender, ::TabControl* pControl,
1334                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1335     : JSWidget<SalInstanceNotebook, ::TabControl>(pSender, pControl, pBuilder, bTakeOwnership)
1336 {
1337 }
1338
1339 void JSNotebook::remove_page(const OUString& rIdent)
1340 {
1341     SalInstanceNotebook::remove_page(rIdent);
1342     sendFullUpdate();
1343 }
1344
1345 void JSNotebook::insert_page(const OUString& rIdent, const OUString& rLabel, int nPos)
1346 {
1347     SalInstanceNotebook::insert_page(rIdent, rLabel, nPos);
1348     sendFullUpdate();
1349 }
1350
1351 JSVerticalNotebook::JSVerticalNotebook(JSDialogSender* pSender, ::VerticalTabControl* pControl,
1352                                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1353     : JSWidget<SalInstanceVerticalNotebook, ::VerticalTabControl>(pSender, pControl, pBuilder,
1354                                                                   bTakeOwnership)
1355 {
1356 }
1357
1358 void JSVerticalNotebook::remove_page(const OUString& rIdent)
1359 {
1360     SalInstanceVerticalNotebook::remove_page(rIdent);
1361     sendFullUpdate();
1362 }
1363
1364 void JSVerticalNotebook::insert_page(const OUString& rIdent, const OUString& rLabel, int nPos)
1365 {
1366     SalInstanceVerticalNotebook::insert_page(rIdent, rLabel, nPos);
1367     sendFullUpdate();
1368 }
1369
1370 JSSpinButton::JSSpinButton(JSDialogSender* pSender, ::FormattedField* pSpin,
1371                            SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1372     : JSWidget<SalInstanceSpinButton, ::FormattedField>(pSender, pSpin, pBuilder, bTakeOwnership)
1373 {
1374 }
1375
1376 void JSSpinButton::set_value(sal_Int64 value)
1377 {
1378     SalInstanceSpinButton::set_value(value);
1379
1380     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1381     (*pMap)[ACTION_TYPE ""_ostr] = "setText";
1382     (*pMap)["text"_ostr] = OUString::number(m_rFormatter.GetValue());
1383     sendAction(std::move(pMap));
1384 }
1385
1386 void JSSpinButton::set_range(sal_Int64 min, sal_Int64 max)
1387 {
1388     SalInstanceSpinButton::set_range(min, max);
1389     sendUpdate();
1390 }
1391
1392 JSFormattedSpinButton::JSFormattedSpinButton(JSDialogSender* pSender, ::FormattedField* pSpin,
1393                                              SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1394     : JSWidget<SalInstanceFormattedSpinButton, ::FormattedField>(pSender, pSpin, pBuilder,
1395                                                                  bTakeOwnership)
1396 {
1397 }
1398
1399 void JSFormattedSpinButton::set_text(const OUString& rText)
1400 {
1401     SalInstanceFormattedSpinButton::set_text(rText);
1402     sendUpdate();
1403 }
1404
1405 void JSFormattedSpinButton::set_text_without_notify(const OUString& rText)
1406 {
1407     SalInstanceFormattedSpinButton::set_text(rText);
1408 }
1409
1410 JSMessageDialog::JSMessageDialog(JSDialogSender* pSender, ::MessageDialog* pDialog,
1411                                  SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1412     : JSWidget<SalInstanceMessageDialog, ::MessageDialog>(pSender, pDialog, pBuilder,
1413                                                           bTakeOwnership)
1414 {
1415 }
1416
1417 JSMessageDialog::JSMessageDialog(::MessageDialog* pDialog, SalInstanceBuilder* pBuilder,
1418                                  bool bTakeOwnership)
1419     : JSWidget<SalInstanceMessageDialog, ::MessageDialog>(nullptr, pDialog, pBuilder,
1420                                                           bTakeOwnership)
1421     , m_pOwnedSender(new JSDialogSender(pDialog, pDialog, u"dialog"_ustr))
1422 {
1423     m_pSender = m_pOwnedSender.get();
1424
1425     if (pBuilder)
1426         return;
1427
1428     m_sWindowId = OUString::number(m_xMessageDialog->GetLOKWindowId());
1429
1430     if (::OKButton* pOKBtn
1431         = dynamic_cast<::OKButton*>(m_xMessageDialog->get_widget_for_response(RET_OK)))
1432     {
1433         m_pOK.reset(new JSButton(m_pSender, pOKBtn, nullptr, false));
1434         JSInstanceBuilder::RememberWidget(m_sWindowId, pOKBtn->get_id(), m_pOK.get());
1435         m_pOK->connect_clicked(LINK(this, JSMessageDialog, OKHdl));
1436     }
1437
1438     if (::CancelButton* pCancelBtn
1439         = dynamic_cast<::CancelButton*>(m_xMessageDialog->get_widget_for_response(RET_CANCEL)))
1440     {
1441         m_pCancel.reset(new JSButton(m_pSender, pCancelBtn, nullptr, false));
1442         JSInstanceBuilder::RememberWidget(m_sWindowId, pCancelBtn->get_id(), m_pCancel.get());
1443         m_pCancel->connect_clicked(LINK(this, JSMessageDialog, CancelHdl));
1444     }
1445 }
1446
1447 JSMessageDialog::~JSMessageDialog()
1448 {
1449     if (!m_pBuilder)
1450     {
1451         // For Message Dialogs created from Application::CreateMessageDialog
1452         // (where there is no builder to take care of this for us) explicitly
1453         // remove this window id on tear down
1454         JSInstanceBuilder::Widgets().Forget(m_sWindowId);
1455     }
1456 }
1457
1458 void JSMessageDialog::RememberMessageDialog()
1459 {
1460     static constexpr OUString sWidgetName = u"__DIALOG__"_ustr;
1461     OUString sWindowId = OUString::number(m_xMessageDialog->GetLOKWindowId());
1462     auto aWidgetMap = JSInstanceBuilder::Widgets().Find(sWindowId);
1463     if (aWidgetMap && aWidgetMap->Find(sWidgetName))
1464         return;
1465
1466     JSInstanceBuilder::InsertWindowToMap(sWindowId);
1467     JSInstanceBuilder::RememberWidget(sWindowId, sWidgetName, this);
1468 }
1469
1470 int JSMessageDialog::run()
1471 {
1472     if (GetLOKNotifier())
1473     {
1474         RememberMessageDialog();
1475         sendFullUpdate();
1476     }
1477
1478     int bRet = SalInstanceMessageDialog::run();
1479     return bRet;
1480 }
1481
1482 bool JSMessageDialog::runAsync(std::shared_ptr<weld::DialogController> const& rxOwner,
1483                                const std::function<void(sal_Int32)>& rEndDialogFn)
1484 {
1485     bool bRet = SalInstanceMessageDialog::runAsync(rxOwner, rEndDialogFn);
1486
1487     RememberMessageDialog();
1488     sendFullUpdate();
1489
1490     return bRet;
1491 }
1492
1493 bool JSMessageDialog::runAsync(std::shared_ptr<Dialog> const& rxSelf,
1494                                const std::function<void(sal_Int32)>& rEndDialogFn)
1495 {
1496     bool bRet = SalInstanceMessageDialog::runAsync(rxSelf, rEndDialogFn);
1497
1498     RememberMessageDialog();
1499     sendFullUpdate();
1500
1501     return bRet;
1502 }
1503
1504 IMPL_LINK_NOARG(JSMessageDialog, OKHdl, weld::Button&, void) { response(RET_OK); }
1505
1506 IMPL_LINK_NOARG(JSMessageDialog, CancelHdl, weld::Button&, void) { response(RET_CANCEL); }
1507
1508 void JSMessageDialog::set_primary_text(const OUString& rText)
1509 {
1510     SalInstanceMessageDialog::set_primary_text(rText);
1511     sendFullUpdate();
1512 }
1513
1514 void JSMessageDialog::set_secondary_text(const OUString& rText)
1515 {
1516     SalInstanceMessageDialog::set_secondary_text(rText);
1517     sendFullUpdate();
1518 }
1519
1520 void JSMessageDialog::response(int response)
1521 {
1522     if (response == RET_HELP)
1523     {
1524         response_help(m_xWidget.get());
1525         return;
1526     }
1527
1528     sendClose();
1529     SalInstanceMessageDialog::response(response);
1530 }
1531
1532 JSCheckButton::JSCheckButton(JSDialogSender* pSender, ::CheckBox* pCheckBox,
1533                              SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1534     : JSWidget<SalInstanceCheckButton, ::CheckBox>(pSender, pCheckBox, pBuilder, bTakeOwnership)
1535 {
1536 }
1537
1538 void JSCheckButton::set_active(bool active)
1539 {
1540     bool bWasActive = get_active();
1541     SalInstanceCheckButton::set_active(active);
1542     if (bWasActive != active)
1543         sendUpdate();
1544 }
1545
1546 JSDrawingArea::JSDrawingArea(JSDialogSender* pSender, VclDrawingArea* pDrawingArea,
1547                              SalInstanceBuilder* pBuilder, const a11yref& rAlly,
1548                              FactoryFunction pUITestFactoryFunction, void* pUserData)
1549     : JSWidget<SalInstanceDrawingArea, VclDrawingArea>(pSender, pDrawingArea, pBuilder, rAlly,
1550                                                        std::move(pUITestFactoryFunction), pUserData,
1551                                                        false)
1552 {
1553 }
1554
1555 void JSDrawingArea::queue_draw()
1556 {
1557     SalInstanceDrawingArea::queue_draw();
1558     sendUpdate();
1559 }
1560
1561 void JSDrawingArea::queue_draw_area(int x, int y, int width, int height)
1562 {
1563     SalInstanceDrawingArea::queue_draw_area(x, y, width, height);
1564     sendUpdate();
1565 }
1566
1567 JSToolbar::JSToolbar(JSDialogSender* pSender, ::ToolBox* pToolbox, SalInstanceBuilder* pBuilder,
1568                      bool bTakeOwnership)
1569     : JSWidget<SalInstanceToolbar, ::ToolBox>(pSender, pToolbox, pBuilder, bTakeOwnership)
1570 {
1571 }
1572
1573 void JSToolbar::set_menu_item_active(const OUString& rIdent, bool bActive)
1574 {
1575     bool bWasActive = get_menu_item_active(rIdent);
1576     SalInstanceToolbar::set_menu_item_active(rIdent, bActive);
1577
1578     ToolBoxItemId nItemId = m_xToolBox->GetItemId(rIdent);
1579     VclPtr<vcl::Window> pFloat = m_aFloats[nItemId];
1580
1581     if (!pFloat)
1582         return;
1583
1584     // See WeldToolbarPopup : include/svtools/toolbarmenu.hxx
1585     // TopLevel (Popover) -> Container -> main container of the popup
1586     vcl::Window* pPopupRoot = pFloat->GetChild(0);
1587     if (pPopupRoot)
1588         pPopupRoot = pPopupRoot->GetChild(0);
1589
1590     if (pPopupRoot)
1591     {
1592         if (bActive)
1593         {
1594             JSInstanceBuilder::Popups().Remember(OUString::number(pPopupRoot->GetLOKWindowId()),
1595                                                  pFloat);
1596             sendPopup(pPopupRoot, m_xToolBox->get_id(), rIdent);
1597         }
1598         else if (bWasActive)
1599         {
1600             JSInstanceBuilder::Popups().Forget(OUString::number(pPopupRoot->GetLOKWindowId()));
1601             sendClosePopup(pPopupRoot->GetLOKWindowId());
1602         }
1603     }
1604 }
1605
1606 void JSToolbar::set_item_sensitive(const OUString& rIdent, bool bSensitive)
1607 {
1608     bool bWasSensitive = get_item_sensitive(rIdent);
1609     SalInstanceToolbar::set_item_sensitive(rIdent, bSensitive);
1610     if (bWasSensitive != bSensitive)
1611         sendUpdate();
1612 }
1613
1614 void JSToolbar::set_item_icon_name(const OUString& rIdent, const OUString& rIconName)
1615 {
1616     SalInstanceToolbar::set_item_icon_name(rIdent, rIconName);
1617     sendUpdate();
1618 }
1619
1620 JSTextView::JSTextView(JSDialogSender* pSender, ::VclMultiLineEdit* pTextView,
1621                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1622     : JSWidget<SalInstanceTextView, ::VclMultiLineEdit>(pSender, pTextView, pBuilder,
1623                                                         bTakeOwnership)
1624 {
1625 }
1626
1627 void JSTextView::set_text(const OUString& rText)
1628 {
1629     SalInstanceTextView::set_text(rText);
1630     sendUpdate();
1631 }
1632
1633 void JSTextView::set_text_without_notify(const OUString& rText)
1634 {
1635     SalInstanceTextView::set_text(rText);
1636 }
1637
1638 void JSTextView::replace_selection(const OUString& rText)
1639 {
1640     SalInstanceTextView::replace_selection(rText);
1641     sendUpdate();
1642 }
1643
1644 JSTreeView::JSTreeView(JSDialogSender* pSender, ::SvTabListBox* pTreeView,
1645                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1646     : JSWidget<SalInstanceTreeView, ::SvTabListBox>(pSender, pTreeView, pBuilder, bTakeOwnership)
1647 {
1648 }
1649
1650 void JSTreeView::set_toggle(int pos, TriState eState, int col)
1651 {
1652     SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, 0);
1653
1654     while (pEntry && pos--)
1655         pEntry = m_xTreeView->Next(pEntry);
1656
1657     if (pEntry)
1658     {
1659         SalInstanceTreeView::set_toggle(pEntry, eState, col);
1660         signal_toggled(iter_col(SalInstanceTreeIter(pEntry), col));
1661
1662         sendUpdate();
1663     }
1664 }
1665
1666 void JSTreeView::set_toggle(const weld::TreeIter& rIter, TriState bOn, int col)
1667 {
1668     SalInstanceTreeView::set_toggle(rIter, bOn, col);
1669     sendUpdate();
1670 }
1671
1672 void JSTreeView::set_sensitive(int pos, bool bSensitive, int col)
1673 {
1674     SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, 0);
1675
1676     while (pEntry && pos--)
1677         pEntry = m_xTreeView->Next(pEntry);
1678
1679     if (pEntry)
1680     {
1681         SalInstanceTreeView::set_sensitive(pEntry, bSensitive, col);
1682         sendUpdate();
1683     }
1684 }
1685
1686 void JSTreeView::set_sensitive(const weld::TreeIter& rIter, bool bSensitive, int col)
1687 {
1688     SalInstanceTreeView::set_sensitive(rIter, bSensitive, col);
1689     sendUpdate();
1690 }
1691
1692 void JSTreeView::select(int pos)
1693 {
1694     assert(m_xTreeView->IsUpdateMode() && "don't select when frozen");
1695     disable_notify_events();
1696     if (pos == -1 || (pos == 0 && n_children() == 0))
1697         m_xTreeView->SelectAll(false);
1698     else
1699     {
1700         SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, 0);
1701
1702         while (pEntry && pos--)
1703             pEntry = m_xTreeView->Next(pEntry);
1704
1705         if (pEntry)
1706         {
1707             m_xTreeView->Select(pEntry, true);
1708             m_xTreeView->MakeVisible(pEntry);
1709         }
1710     }
1711     enable_notify_events();
1712
1713     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1714     (*pMap)[ACTION_TYPE ""_ostr] = "select";
1715     (*pMap)["position"_ostr] = OUString::number(pos);
1716     sendAction(std::move(pMap));
1717 }
1718
1719 weld::TreeView* JSTreeView::get_drag_source() const { return g_DragSource; }
1720
1721 void JSTreeView::drag_start() { g_DragSource = this; }
1722
1723 void JSTreeView::drag_end()
1724 {
1725     css::datatransfer::dnd::XDropTarget* xDropTarget = m_xDropTarget.get();
1726     if (xDropTarget)
1727     {
1728         css::datatransfer::dnd::DropTargetDropEvent aEvent;
1729         aEvent.Source = xDropTarget;
1730         aEvent.Context = new JSDropTargetDropContext();
1731         // dummy values
1732         aEvent.LocationX = 50;
1733         aEvent.LocationY = 50;
1734         aEvent.DropAction = css::datatransfer::dnd::DNDConstants::ACTION_DEFAULT;
1735         aEvent.SourceActions = css::datatransfer::dnd::DNDConstants::ACTION_DEFAULT;
1736
1737         m_xDropTarget->fire_drop(aEvent);
1738
1739         sendUpdate();
1740         if (g_DragSource)
1741             g_DragSource->sendUpdate();
1742     }
1743
1744     g_DragSource = nullptr;
1745 }
1746
1747 void JSTreeView::insert(const weld::TreeIter* pParent, int pos, const OUString* pStr,
1748                         const OUString* pId, const OUString* pIconName,
1749                         VirtualDevice* pImageSurface, bool bChildrenOnDemand, weld::TreeIter* pRet)
1750 {
1751     SalInstanceTreeView::insert(pParent, pos, pStr, pId, pIconName, pImageSurface,
1752                                 bChildrenOnDemand, pRet);
1753
1754     sendUpdate();
1755 }
1756
1757 void JSTreeView::set_text(int row, const OUString& rText, int col)
1758 {
1759     SalInstanceTreeView::set_text(row, rText, col);
1760     sendUpdate();
1761 }
1762
1763 void JSTreeView::set_text(const weld::TreeIter& rIter, const OUString& rStr, int col)
1764 {
1765     SalInstanceTreeView::set_text(rIter, rStr, col);
1766     sendUpdate();
1767 }
1768
1769 void JSTreeView::remove(int pos)
1770 {
1771     SalInstanceTreeView::remove(pos);
1772     sendUpdate();
1773 }
1774
1775 void JSTreeView::remove(const weld::TreeIter& rIter)
1776 {
1777     SalInstanceTreeView::remove(rIter);
1778     sendUpdate();
1779 }
1780
1781 void JSTreeView::clear()
1782 {
1783     SalInstanceTreeView::clear();
1784     sendUpdate();
1785 }
1786
1787 void JSTreeView::set_cursor_without_notify(const weld::TreeIter& rIter)
1788 {
1789     SalInstanceTreeView::set_cursor(rIter);
1790 }
1791
1792 void JSTreeView::set_cursor(const weld::TreeIter& rIter)
1793 {
1794     SalInstanceTreeView::set_cursor(rIter);
1795     sendUpdate();
1796 }
1797
1798 void JSTreeView::set_cursor(int pos)
1799 {
1800     SalInstanceTreeView::set_cursor(pos);
1801     sendUpdate();
1802 }
1803
1804 void JSTreeView::expand_row(const weld::TreeIter& rIter)
1805 {
1806     bool bNotify = false;
1807     const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
1808     if (!m_xTreeView->IsExpanded(rVclIter.iter))
1809         bNotify = true;
1810
1811     SalInstanceTreeView::expand_row(rIter);
1812
1813     if (bNotify)
1814         sendUpdate();
1815 }
1816
1817 void JSTreeView::collapse_row(const weld::TreeIter& rIter)
1818 {
1819     bool bNotify = false;
1820     const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
1821     if (m_xTreeView->IsExpanded(rVclIter.iter))
1822         bNotify = true;
1823
1824     SalInstanceTreeView::collapse_row(rIter);
1825
1826     if (bNotify)
1827         sendUpdate();
1828 }
1829
1830 JSExpander::JSExpander(JSDialogSender* pSender, ::VclExpander* pExpander,
1831                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1832     : JSWidget<SalInstanceExpander, ::VclExpander>(pSender, pExpander, pBuilder, bTakeOwnership)
1833 {
1834 }
1835
1836 void JSExpander::set_expanded(bool bExpand)
1837 {
1838     SalInstanceExpander::set_expanded(bExpand);
1839     sendUpdate();
1840 }
1841
1842 JSIconView::JSIconView(JSDialogSender* pSender, ::IconView* pIconView, SalInstanceBuilder* pBuilder,
1843                        bool bTakeOwnership)
1844     : JSWidget<SalInstanceIconView, ::IconView>(pSender, pIconView, pBuilder, bTakeOwnership)
1845 {
1846 }
1847
1848 void JSIconView::insert(int pos, const OUString* pStr, const OUString* pId,
1849                         const OUString* pIconName, weld::TreeIter* pRet)
1850 {
1851     SalInstanceIconView::insert(pos, pStr, pId, pIconName, pRet);
1852     sendUpdate();
1853 }
1854
1855 void JSIconView::insert(int pos, const OUString* pStr, const OUString* pId,
1856                         const VirtualDevice* pIcon, weld::TreeIter* pRet)
1857 {
1858     SalInstanceIconView::insert(pos, pStr, pId, pIcon, pRet);
1859     sendUpdate();
1860 }
1861
1862 void JSIconView::insert_separator(int pos, const OUString* pId)
1863 {
1864     SalInstanceIconView::insert_separator(pos, pId);
1865     sendUpdate();
1866 }
1867
1868 void JSIconView::clear()
1869 {
1870     SalInstanceIconView::clear();
1871     sendUpdate();
1872 }
1873
1874 void JSIconView::select(int pos)
1875 {
1876     SalInstanceIconView::select(pos);
1877
1878     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1879     (*pMap)[ACTION_TYPE ""_ostr] = "select";
1880     (*pMap)["position"_ostr] = OUString::number(pos);
1881     sendAction(std::move(pMap));
1882 }
1883
1884 void JSIconView::unselect(int pos)
1885 {
1886     SalInstanceIconView::unselect(pos);
1887     sendUpdate();
1888 }
1889
1890 void JSIconView::render_entry(int pos, int dpix, int dpiy)
1891 {
1892     OUString sImage = m_xIconView->renderEntry(pos, dpix, dpiy);
1893     if (sImage.isEmpty())
1894         return;
1895
1896     std::unique_ptr<jsdialog::ActionDataMap> pMap = std::make_unique<jsdialog::ActionDataMap>();
1897     (*pMap)[ACTION_TYPE ""_ostr] = "rendered_entry";
1898     (*pMap)["pos"_ostr] = OUString::number(pos);
1899     (*pMap)["image"_ostr] = sImage;
1900     sendAction(std::move(pMap));
1901 }
1902
1903 JSRadioButton::JSRadioButton(JSDialogSender* pSender, ::RadioButton* pRadioButton,
1904                              SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1905     : JSWidget<SalInstanceRadioButton, ::RadioButton>(pSender, pRadioButton, pBuilder,
1906                                                       bTakeOwnership)
1907 {
1908 }
1909
1910 void JSRadioButton::set_active(bool active)
1911 {
1912     SalInstanceRadioButton::set_active(active);
1913     sendUpdate();
1914 }
1915
1916 JSFrame::JSFrame(JSDialogSender* pSender, ::VclFrame* pFrame, SalInstanceBuilder* pBuilder,
1917                  bool bTakeOwnership)
1918     : JSWidget<SalInstanceFrame, ::VclFrame>(pSender, pFrame, pBuilder, bTakeOwnership)
1919 {
1920 }
1921
1922 JSMenuButton::JSMenuButton(JSDialogSender* pSender, ::MenuButton* pMenuButton,
1923                            SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1924     : JSWidget<SalInstanceMenuButton, ::MenuButton>(pSender, pMenuButton, pBuilder, bTakeOwnership)
1925 {
1926 }
1927
1928 void JSMenuButton::set_label(const OUString& rText)
1929 {
1930     OUString aPreviousLabel = get_label();
1931     SalInstanceMenuButton::set_label(rText);
1932     if (aPreviousLabel != rText)
1933         sendUpdate();
1934 }
1935
1936 void JSMenuButton::set_image(VirtualDevice* pDevice)
1937 {
1938     SalInstanceMenuButton::set_image(pDevice);
1939     sendUpdate();
1940 }
1941
1942 void JSMenuButton::set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage)
1943 {
1944     SalInstanceMenuButton::set_image(rImage);
1945     sendUpdate();
1946 }
1947
1948 void JSMenuButton::set_active(bool bActive)
1949 {
1950     SalInstanceMenuButton::set_active(bActive);
1951
1952     VclPtr<vcl::Window> pPopup = m_xMenuButton->GetPopover();
1953     if (pPopup)
1954     {
1955         if (bActive)
1956             sendPopup(pPopup->GetChild(0), m_xMenuButton->get_id(), m_xMenuButton->get_id());
1957         else
1958             sendClosePopup(pPopup->GetChild(0)->GetLOKWindowId());
1959     }
1960 }
1961
1962 JSMenu::JSMenu(JSDialogSender* pSender, PopupMenu* pPopupMenu, SalInstanceBuilder* /*pBuilder*/,
1963                bool bTakeOwnership)
1964     : SalInstanceMenu(pPopupMenu, bTakeOwnership)
1965     , m_pPopupMenu(pPopupMenu)
1966     , m_pSender(pSender)
1967 {
1968 }
1969
1970 OUString JSMenu::popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect,
1971                                weld::Placement /*ePlace*/)
1972 {
1973     // Do not block with SalInstanceMenu::popup_at_rect(pParent, rRect, ePlace);
1974
1975     // we find position based on parent widget id and row text inside TreeView for context menu
1976     OUString sCancelId;
1977     weld::TreeView* pTree = dynamic_cast<weld::TreeView*>(pParent);
1978     if (pTree)
1979     {
1980         std::unique_ptr<weld::TreeIter> itEntry(pTree->make_iterator());
1981         if (pTree->get_dest_row_at_pos(rRect.Center(), itEntry.get(), false, false))
1982             sCancelId = pTree->get_text(*itEntry);
1983     }
1984
1985     m_pSender->sendMenu(m_pPopupMenu, pParent ? pParent->get_buildable_name() : "", sCancelId);
1986
1987     // Don't return any action - simulate canceled menu
1988     return "";
1989 }
1990
1991 JSPopover::JSPopover(JSDialogSender* pSender, DockingWindow* pDockingWindow,
1992                      SalInstanceBuilder* pBuilder, bool bTakeOwnership)
1993     : JSWidget<SalInstancePopover, DockingWindow>(pSender, pDockingWindow, pBuilder, bTakeOwnership)
1994     , mnWindowId(0)
1995 {
1996 }
1997
1998 void JSPopover::popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect,
1999                               weld::Placement ePlace)
2000 {
2001     SalInstancePopover::popup_at_rect(pParent, rRect, ePlace);
2002     sendPopup(getWidget()->GetChild(0), u"_POPOVER_"_ustr, u"_POPOVER_"_ustr);
2003 }
2004
2005 void JSPopover::popdown()
2006 {
2007     VclPtr<vcl::Window> pPopup = JSInstanceBuilder::Popups().Find(OUString::number(mnWindowId));
2008
2009     if (pPopup)
2010     {
2011         sendClosePopup(mnWindowId);
2012         vcl::Window::GetDockingManager()->EndPopupMode(pPopup);
2013     }
2014
2015     if (getWidget() && getWidget()->GetChild(0))
2016         sendClosePopup(getWidget()->GetChild(0)->GetLOKWindowId());
2017
2018     SalInstancePopover::popdown();
2019 }
2020
2021 JSBox::JSBox(JSDialogSender* pSender, VclBox* pBox, SalInstanceBuilder* pBuilder,
2022              bool bTakeOwnership)
2023     : JSWidget<SalInstanceBox, VclBox>(pSender, pBox, pBuilder, bTakeOwnership)
2024 {
2025 }
2026
2027 void JSBox::reorder_child(weld::Widget* pWidget, int nNewPosition)
2028 {
2029     SalInstanceBox::reorder_child(pWidget, nNewPosition);
2030     sendFullUpdate();
2031 }
2032
2033 JSImage::JSImage(JSDialogSender* pSender, FixedImage* pImage, SalInstanceBuilder* pBuilder,
2034                  bool bTakeOwnership)
2035     : JSWidget<SalInstanceImage, FixedImage>(pSender, pImage, pBuilder, bTakeOwnership)
2036 {
2037 }
2038
2039 void JSImage::set_image(VirtualDevice* pDevice)
2040 {
2041     SalInstanceImage::set_image(pDevice);
2042     sendUpdate();
2043 }
2044
2045 void JSImage::set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage)
2046 {
2047     SalInstanceImage::set_image(rImage);
2048     sendUpdate();
2049 }
2050
2051 JSLevelBar::JSLevelBar(JSDialogSender* pSender, ::ProgressBar* pProgressBar,
2052                        SalInstanceBuilder* pBuilder, bool bTakeOwnership)
2053     : JSWidget<SalInstanceLevelBar, ::ProgressBar>(pSender, pProgressBar, pBuilder, bTakeOwnership)
2054 {
2055 }
2056
2057 void JSLevelBar::set_percentage(double fPercentage)
2058 {
2059     SalInstanceLevelBar::set_percentage(fPercentage);
2060     sendUpdate();
2061 }
2062
2063 JSCalendar::JSCalendar(JSDialogSender* pSender, ::Calendar* pCalendar, SalInstanceBuilder* pBuilder,
2064                        bool bTakeOwnership)
2065     : JSWidget<SalInstanceCalendar, ::Calendar>(pSender, pCalendar, pBuilder, bTakeOwnership)
2066 {
2067 }
2068
2069 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */