sc/source/ui/xmlsource/xmlsourcedlg.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <xmlsourcedlg.hxx>
  11 #include <bitmaps.hlst>
  12 #include <document.hxx>
  13 #include <orcusfilters.hxx>
  14 #include <filter.hxx>
  15 #include <reffact.hxx>
  16 #include <tabvwsh.hxx>
  17
  18 #include <tools/urlobj.hxx>
  19 #include <sfx2/filedlghelper.hxx>
  20
  21 #include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
  22 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  23 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  24
  25 using namespace com::sun::star;
  26
  27 namespace {
  28
  29 bool isAttribute(const weld::TreeView& rControl, const weld::TreeIter& rEntry)
  30 {
  31     const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rControl, rEntry);
  32     if (!pUserData)
  33         return false;
  34
  35     return pUserData->meType == ScOrcusXMLTreeParam::Attribute;
  36 }
  37
  38 OUString getXPath(
  39     const weld::TreeView& rTree, const weld::TreeIter& rEntry, std::vector<size_t>& rNamespaces)
  40 {
  41     OUStringBuffer aBuf;
  42     std::unique_ptr<weld::TreeIter> xEntry(rTree.make_iterator(&rEntry));
  43     do
  44     {
  45         // Collect used namespace.
  46         const ScOrcusXMLTreeParam::EntryData* pData = ScOrcusXMLTreeParam::getUserData(rTree, *xEntry);
  47         if (pData)
  48             rNamespaces.push_back(pData->mnNamespaceID);
  49
  50         // element separator is '/' whereas attribute separator is '/@' in xpath.
  51         std::u16string_view sSeparator;
  52         if (isAttribute(rTree, *xEntry))
  53             sSeparator = u"/@";
  54         else
  55             sSeparator = u"/";
  56         aBuf.insert(0, sSeparator + rTree.get_text(*xEntry, 0));
  57     }
  58     while (rTree.iter_parent(*xEntry));
  59
  60     return aBuf.makeStringAndClear();
  61 }
  62
  63 }
  64
  65 ScXMLSourceDlg::ScXMLSourceDlg(
  66     SfxBindings* pB, SfxChildWindow* pCW, weld::Window* pParent, ScDocument* pDoc)
  67     : ScAnyRefDlgController(pB, pCW, pParent, u"modules/scalc/ui/xmlsourcedialog.ui"_ustr, u"XMLSourceDialog"_ustr)
  68     , mpDoc(pDoc)
  69     , mbDlgLostFocus(false)
  70     , mxBtnSelectSource(m_xBuilder->weld_button(u"selectsource"_ustr))
  71     , mxFtSourceFile(m_xBuilder->weld_label(u"sourcefile"_ustr))
  72     , mxMapGrid(m_xBuilder->weld_container(u"mapgrid"_ustr))
  73     , mxLbTree(m_xBuilder->weld_tree_view(u"tree"_ustr))
  74     , mxRefEdit(new formula::RefEdit(m_xBuilder->weld_entry(u"edit"_ustr)))
  75     , mxRefBtn(new formula::RefButton(m_xBuilder->weld_button(u"ref"_ustr)))
  76     , mxBtnOk(m_xBuilder->weld_button(u"ok"_ustr))
  77     , mxBtnCancel(m_xBuilder->weld_button(u"cancel"_ustr))
  78     , maCustomCompare(*mxLbTree)
  79     , maCellLinks(maCustomCompare)
  80     , maRangeLinks(maCustomCompare)
  81 {
  82     mxLbTree->set_size_request(mxLbTree->get_approximate_digit_width() * 40,
  83                                mxLbTree->get_height_rows(15));
  84     mxLbTree->set_selection_mode(SelectionMode::Multiple);
  85     mxRefEdit->SetReferences(this, nullptr);
  86     mxRefBtn->SetReferences(this, mxRefEdit.get());
  87
  88     mpActiveEdit = mxRefEdit.get();
  89
  90     maXMLParam.maImgElementDefault = RID_BMP_ELEMENT_DEFAULT;
  91     maXMLParam.maImgElementRepeat = RID_BMP_ELEMENT_REPEAT;
  92     maXMLParam.maImgAttribute = RID_BMP_ELEMENT_ATTRIBUTE;
  93
  94     Link<weld::Button&,void> aBtnHdl = LINK(this, ScXMLSourceDlg, BtnPressedHdl);
  95     mxBtnSelectSource->connect_clicked(aBtnHdl);
  96     mxBtnOk->connect_clicked(aBtnHdl);
  97     mxBtnCancel->connect_clicked(aBtnHdl);
  98
  99     mxLbTree->connect_selection_changed(LINK(this, ScXMLSourceDlg, TreeItemSelectHdl));
 100
 101     Link<formula::RefEdit&,void> aLink = LINK(this, ScXMLSourceDlg, RefModifiedHdl);
 102     mxRefEdit->SetModifyHdl(aLink);
 103
 104     mxBtnOk->set_sensitive(false);
 105
 106     SetNonLinkable();
 107     mxBtnSelectSource->grab_focus(); // Initial focus is on the select source button.
 108 }
 109
 110 ScXMLSourceDlg::~ScXMLSourceDlg()
 111 {
 112 }
 113
 114 bool ScXMLSourceDlg::IsRefInputMode() const
 115 {
 116     return mpActiveEdit != nullptr && mpActiveEdit->GetWidget()->get_sensitive();
 117 }
 118
 119 void ScXMLSourceDlg::SetReference(const ScRange& rRange, ScDocument& rDoc)
 120 {
 121     if (!mpActiveEdit)
 122         return;
 123
 124     if (rRange.aStart != rRange.aEnd)
 125         RefInputStart(mpActiveEdit);
 126
 127     OUString aStr(rRange.aStart.Format(ScRefFlags::ADDR_ABS_3D, &rDoc, rDoc.GetAddressConvention()));
 128     mpActiveEdit->SetRefString(aStr);
 129
 130     RefEditModified();
 131 }
 132
 133 void ScXMLSourceDlg::Deactivate()
 134 {
 135     mbDlgLostFocus = true;
 136 }
 137
 138 void ScXMLSourceDlg::SetActive()
 139 {
 140     if (mbDlgLostFocus)
 141     {
 142         mbDlgLostFocus = false;
 143         if (mpActiveEdit)
 144         {
 145             mpActiveEdit->GrabFocus();
 146         }
 147     }
 148     else
 149     {
 150         m_xDialog->grab_focus();
 151     }
 152
 153     RefInputDone();
 154 }
 155
 156 void ScXMLSourceDlg::Close()
 157 {
 158     DoClose(ScXMLSourceDlgWrapper::GetChildWindowId());
 159 }
 160
 161 void ScXMLSourceDlg::SelectSourceFile()
 162 {
 163     sfx2::FileDialogHelper aDlgHelper(ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
 164                                       FileDialogFlags::NONE, m_xDialog.get());
 165     aDlgHelper.SetContext(sfx2::FileDialogHelper::CalcXMLSource);
 166
 167     uno::Reference<ui::dialogs::XFilePicker3> xFilePicker = aDlgHelper.GetFilePicker();
 168
 169     // Use the directory of current source file.
 170     INetURLObject aURL(maSrcPath);
 171     aURL.removeSegment();
 172     aURL.removeFinalSlash();
 173     OUString aPath = aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE);
 174     xFilePicker->setDisplayDirectory(aPath);
 175
 176     if (xFilePicker->execute() != ui::dialogs::ExecutableDialogResults::OK)
 177         // File picker dialog cancelled.
 178         return;
 179
 180     uno::Sequence<OUString> aFiles = xFilePicker->getSelectedFiles();
 181     if (!aFiles.hasElements())
 182         return;
 183
 184     // There should only be one file returned from the file picker.
 185     maSrcPath = aFiles[0];
 186     mxFtSourceFile->set_label(maSrcPath);
 187     LoadSourceFileStructure(maSrcPath);
 188 }
 189
 190 void ScXMLSourceDlg::LoadSourceFileStructure(const OUString& rPath)
 191 {
 192     ScOrcusFilters* pOrcus = ScFormatFilter::Get().GetOrcusFilters();
 193     if (!pOrcus)
 194         return;
 195
 196     mpXMLContext = pOrcus->createXMLContext(*mpDoc, rPath);
 197     if (!mpXMLContext)
 198         return;
 199
 200     mpXMLContext->loadXMLStructure(*mxLbTree, maXMLParam);
 201 }
 202
 203 namespace {
 204
 205 /**
 206  * The current entry is the reference entry for a cell link.  For a range
 207  * link, the reference entry is the shallowest repeat element entry up from
 208  * the current entry position.  The mapped cell position for a range link is
 209  * stored with the reference entry.
 210  */
 211 std::unique_ptr<weld::TreeIter> getReferenceEntry(const weld::TreeView& rTree, const weld::TreeIter& rCurEntry)
 212 {
 213     std::unique_ptr<weld::TreeIter> xParent(rTree.make_iterator(&rCurEntry));
 214     bool bParent = rTree.iter_parent(*xParent);
 215     std::unique_ptr<weld::TreeIter> xRefEntry;
 216     while (bParent)
 217     {
 218         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rTree, *xParent);
 219         assert(pUserData);
 220         if (pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat)
 221         {
 222             // This is a repeat element - a potential reference entry.
 223             xRefEntry = rTree.make_iterator(xParent.get());
 224         }
 225         bParent = rTree.iter_parent(*xParent);
 226     }
 227
 228     if (xRefEntry)
 229         return xRefEntry;
 230
 231     std::unique_ptr<weld::TreeIter> xCurEntry(rTree.make_iterator(&rCurEntry));
 232     return xCurEntry;
 233 }
 234
 235 }
 236
 237 void ScXMLSourceDlg::TreeItemSelected()
 238 {
 239     std::unique_ptr<weld::TreeIter> xEntry(mxLbTree->make_iterator());
 240     if (!mxLbTree->get_cursor(xEntry.get()))
 241         return;
 242
 243     mxLbTree->unselect_all();
 244     mxLbTree->select(*xEntry);
 245
 246     mxCurRefEntry = getReferenceEntry(*mxLbTree, *xEntry);
 247
 248     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *mxCurRefEntry);
 249     assert(pUserData);
 250
 251     const ScAddress& rPos = pUserData->maLinkedPos;
 252     if (rPos.IsValid())
 253     {
 254         OUString aStr(rPos.Format(ScRefFlags::ADDR_ABS_3D, mpDoc, mpDoc->GetAddressConvention()));
 255         mxRefEdit->SetRefString(aStr);
 256     }
 257     else
 258         mxRefEdit->SetRefString(OUString());
 259
 260     switch (pUserData->meType)
 261     {
 262         case ScOrcusXMLTreeParam::Attribute:
 263             AttributeSelected(*mxCurRefEntry);
 264         break;
 265         case ScOrcusXMLTreeParam::ElementDefault:
 266             DefaultElementSelected(*mxCurRefEntry);
 267         break;
 268         case ScOrcusXMLTreeParam::ElementRepeat:
 269             RepeatElementSelected(*mxCurRefEntry);
 270         break;
 271         default:
 272             ;
 273     }
 274 }
 275
 276 void ScXMLSourceDlg::DefaultElementSelected(const weld::TreeIter& rEntry)
 277 {
 278     if (mxLbTree->iter_has_child(rEntry))
 279     {
 280         // Only an element with no child elements (leaf element) can be linked.
 281         bool bHasChild = false;
 282         std::unique_ptr<weld::TreeIter> xChild(mxLbTree->make_iterator(&rEntry));
 283         (void)mxLbTree->iter_children(*xChild);
 284         do
 285         {
 286             ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *xChild);
 287             assert(pUserData);
 288             if (pUserData->meType != ScOrcusXMLTreeParam::Attribute)
 289             {
 290                 // This child is not an attribute. Bail out.
 291                 bHasChild = true;
 292                 break;
 293             }
 294         }
 295         while (mxLbTree->iter_next_sibling(*xChild));
 296
 297         if (bHasChild)
 298         {
 299             SetNonLinkable();
 300             return;
 301         }
 302     }
 303
 304     // Check all its parents and make sure non of them are range-linked nor
 305     // repeat elements.
 306     if (IsParentDirty(&rEntry))
 307     {
 308         SetNonLinkable();
 309         return;
 310     }
 311
 312     SetSingleLinkable();
 313 }
 314
 315 void ScXMLSourceDlg::RepeatElementSelected(const weld::TreeIter& rEntry)
 316 {
 317     // Check all its parents first.
 318
 319     if (IsParentDirty(&rEntry))
 320     {
 321         SetNonLinkable();
 322         return;
 323     }
 324
 325     // Check all its child elements / attributes and make sure non of them are
 326     // linked.
 327
 328     if (IsChildrenDirty(&rEntry))
 329     {
 330         SetNonLinkable();
 331         return;
 332     }
 333
 334     if (!mxLbTree->is_selected(rEntry))
 335     {
 336         // Highlight the entry if not highlighted already.  This can happen
 337         // when the current entry is a child entry of a repeat element entry.
 338         mxLbTree->select(rEntry);
 339     }
 340
 341     SelectAllChildEntries(rEntry);
 342     SetRangeLinkable();
 343 }
 344
 345 void ScXMLSourceDlg::AttributeSelected(const weld::TreeIter& rEntry)
 346 {
 347     // Check all its parent elements and make sure non of them are linked nor
 348     // repeat elements.  In attribute's case, it's okay to have the immediate
 349     // parent element linked (but not range-linked).
 350     std::unique_ptr<weld::TreeIter> xParent(mxLbTree->make_iterator(&rEntry));
 351     mxLbTree->iter_parent(*xParent);
 352
 353     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *xParent);
 354     assert(pUserData);
 355     if (pUserData->maLinkedPos.IsValid() && pUserData->mbRangeParent)
 356     {
 357         // Parent element is range-linked.  Bail out.
 358         SetNonLinkable();
 359         return;
 360     }
 361
 362     if (IsParentDirty(&rEntry))
 363     {
 364         SetNonLinkable();
 365         return;
 366     }
 367
 368     SetSingleLinkable();
 369 }
 370
 371 void ScXMLSourceDlg::SetNonLinkable()
 372 {
 373     mxMapGrid->set_sensitive(false);
 374 }
 375
 376 void ScXMLSourceDlg::SetSingleLinkable()
 377 {
 378     mxMapGrid->set_sensitive(true);
 379 }
 380
 381 void ScXMLSourceDlg::SetRangeLinkable()
 382 {
 383     mxMapGrid->set_sensitive(true);
 384 }
 385
 386 void ScXMLSourceDlg::SelectAllChildEntries(const weld::TreeIter& rEntry)
 387 {
 388     std::unique_ptr<weld::TreeIter> xChild(mxLbTree->make_iterator(&rEntry));
 389     if (!mxLbTree->iter_children(*xChild))
 390         return;
 391     do
 392     {
 393         SelectAllChildEntries(*xChild); // select recursively.
 394         mxLbTree->select(*xChild);
 395     } while (mxLbTree->iter_next_sibling(*xChild));
 396 }
 397
 398 bool ScXMLSourceDlg::IsParentDirty(const weld::TreeIter* pEntry) const
 399 {
 400     std::unique_ptr<weld::TreeIter> xParent(mxLbTree->make_iterator(pEntry));
 401     if (!mxLbTree->iter_parent(*xParent))
 402         return false;
 403     do
 404     {
 405         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *xParent);
 406         assert(pUserData);
 407         if (pUserData->maLinkedPos.IsValid())
 408         {
 409             // This parent is already linked.
 410             return true;
 411         }
 412     }
 413     while (mxLbTree->iter_parent(*xParent));
 414     return false;
 415 }
 416
 417 bool ScXMLSourceDlg::IsChildrenDirty(const weld::TreeIter* pEntry) const
 418 {
 419     std::unique_ptr<weld::TreeIter> xChild(mxLbTree->make_iterator(pEntry));
 420     if (!mxLbTree->iter_children(*xChild))
 421         return false;
 422
 423     do
 424     {
 425         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *xChild);
 426         assert(pUserData);
 427         if (pUserData->maLinkedPos.IsValid())
 428             // Already linked.
 429             return true;
 430
 431         if (pUserData->meType == ScOrcusXMLTreeParam::ElementDefault)
 432         {
 433             // Check recursively.
 434             if (IsChildrenDirty(xChild.get()))
 435                 return true;
 436         }
 437     } while (mxLbTree->iter_next_sibling(*xChild));
 438
 439     return false;
 440 }
 441
 442 namespace {
 443
 444 /**
 445  * Pick only the leaf elements.
 446  */
 447 void getFieldLinks(
 448     ScOrcusImportXMLParam::RangeLink& rRangeLink, std::vector<size_t>& rNamespaces,
 449     const weld::TreeView& rTree, const weld::TreeIter& rEntry)
 450 {
 451     OUString aPath = getXPath(rTree, rEntry, rNamespaces);
 452     const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rTree, rEntry);
 453
 454     if (pUserData)
 455     {
 456         if (pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat)
 457             // nested repeat element automatically becomes a row-group node.
 458             rRangeLink.maRowGroups.push_back(
 459                 OUStringToOString(aPath, RTL_TEXTENCODING_UTF8));
 460
 461         if (pUserData->mbLeafNode && !aPath.isEmpty())
 462             // XPath should never be empty anyway, but it won't hurt to check...
 463             rRangeLink.maFieldPaths.push_back(OUStringToOString(aPath, RTL_TEXTENCODING_UTF8));
 464     }
 465
 466     std::unique_ptr<weld::TreeIter> xChild(rTree.make_iterator(&rEntry));
 467
 468     if (!rTree.iter_children(*xChild))
 469         // No more children.  We're done.
 470         return;
 471
 472     do
 473     {
 474         // Walk recursively.
 475         getFieldLinks(rRangeLink, rNamespaces, rTree, *xChild);
 476     }
 477     while (rTree.iter_next_sibling(*xChild));
 478 }
 479
 480 void removeDuplicates(std::vector<size_t>& rArray)
 481 {
 482     std::sort(rArray.begin(), rArray.end());
 483     std::vector<size_t>::iterator it = std::unique(rArray.begin(), rArray.end());
 484     rArray.erase(it, rArray.end());
 485 }
 486
 487 }
 488
 489 void ScXMLSourceDlg::OkPressed()
 490 {
 491     if (!mpXMLContext)
 492         return;
 493
 494     // Begin import.
 495
 496     ScOrcusImportXMLParam aParam;
 497
 498     // Convert single cell links.
 499     for (const auto& rEntry : maCellLinks)
 500     {
 501         OUString aPath = getXPath(*mxLbTree, *rEntry, aParam.maNamespaces);
 502         const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *rEntry);
 503
 504         aParam.maCellLinks.emplace_back(
 505                 pUserData->maLinkedPos, OUStringToOString(aPath, RTL_TEXTENCODING_UTF8));
 506     }
 507
 508     // Convert range links. For now, an element with range link takes all its
 509     // child elements as its fields.
 510     for (const auto& rEntry: maRangeLinks)
 511     {
 512         const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *rEntry);
 513
 514         ScOrcusImportXMLParam::RangeLink aRangeLink;
 515         aRangeLink.maPos = pUserData->maLinkedPos;
 516
 517         // Go through all its child elements.
 518         getFieldLinks(aRangeLink, aParam.maNamespaces, *mxLbTree, *rEntry);
 519
 520         // Add the reference entry as a row-group node, which will be used
 521         // as a row position increment point.
 522         OUString aThisEntry = getXPath(*mxLbTree, *rEntry, aParam.maNamespaces);
 523         aRangeLink.maRowGroups.push_back(
 524             OUStringToOString(aThisEntry, RTL_TEXTENCODING_UTF8));
 525
 526         aParam.maRangeLinks.push_back(aRangeLink);
 527     }
 528
 529     // Remove duplicate namespace IDs.
 530     removeDuplicates(aParam.maNamespaces);
 531
 532     // Now do the import.
 533     mpXMLContext->importXML(aParam);
 534
 535     // Don't forget to broadcast the change.
 536     ScDocShell* pShell = mpDoc->GetDocumentShell();
 537     pShell->Broadcast(SfxHint(SfxHintId::ScDataChanged));
 538
 539     // Repaint the grid to force repaint the cell values.
 540     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 541     if (pViewShell)
 542         pViewShell->PaintGrid();
 543
 544     m_xDialog->response(RET_OK);
 545 }
 546
 547 void ScXMLSourceDlg::CancelPressed()
 548 {
 549     m_xDialog->response(RET_CANCEL);
 550 }
 551
 552 void ScXMLSourceDlg::RefEditModified()
 553 {
 554     OUString aRefStr = mxRefEdit->GetText();
 555
 556     // Check if the address is valid.
 557     // Preset current sheet in case only address was entered.
 558     ScAddress aLinkedPos;
 559     aLinkedPos.SetTab( ScDocShell::GetCurTab());
 560     ScRefFlags nRes = aLinkedPos.Parse(aRefStr, *mpDoc, mpDoc->GetAddressConvention());
 561     bool bValid = ( (nRes & ScRefFlags::VALID) == ScRefFlags::VALID );
 562
 563     // TODO: For some unknown reason, setting the ref invalid will hide the text altogether.
 564     // Find out how to make this work.
 565 //  mxRefEdit->SetRefValid(bValid);
 566
 567     if (!bValid)
 568         aLinkedPos.SetInvalid();
 569
 570     // Set this address to the current reference entry.
 571     if (!mxCurRefEntry)
 572         // This should never happen.
 573         return;
 574
 575     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mxLbTree, *mxCurRefEntry);
 576     if (!pUserData)
 577         // This should never happen either.
 578         return;
 579
 580     bool bRepeatElem = pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat;
 581     pUserData->maLinkedPos = aLinkedPos;
 582     pUserData->mbRangeParent = aLinkedPos.IsValid() && bRepeatElem;
 583
 584     if (bRepeatElem)
 585     {
 586         if (bValid)
 587             maRangeLinks.insert(mxLbTree->make_iterator(mxCurRefEntry.get()));
 588         else
 589             maRangeLinks.erase(mxCurRefEntry);
 590     }
 591     else
 592     {
 593         if (bValid)
 594             maCellLinks.insert(mxLbTree->make_iterator(mxCurRefEntry.get()));
 595         else
 596             maCellLinks.erase(mxCurRefEntry);
 597     }
 598
 599     // Enable the import button only when at least one link exists.
 600     bool bHasLink = !maCellLinks.empty() || !maRangeLinks.empty();
 601     mxBtnOk->set_sensitive(bHasLink);
 602 }
 603
 604 IMPL_LINK(ScXMLSourceDlg, BtnPressedHdl, weld::Button&, rBtn, void)
 605 {
 606     if (&rBtn == mxBtnSelectSource.get())
 607         SelectSourceFile();
 608     else if (&rBtn == mxBtnOk.get())
 609         OkPressed();
 610     else if (&rBtn == mxBtnCancel.get())
 611         CancelPressed();
 612 }
 613
 614 IMPL_LINK_NOARG(ScXMLSourceDlg, TreeItemSelectHdl, weld::TreeView&, void)
 615 {
 616     TreeItemSelected();
 617 }
 618
 619 IMPL_LINK_NOARG(ScXMLSourceDlg, RefModifiedHdl, formula::RefEdit&, void)
 620 {
 621     RefEditModified();
 622 }
 623
 624 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */