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 "sc.hrc"
  12 #include "scresid.hxx"
  13 #include "document.hxx"
  14 #include "orcusfilters.hxx"
  15 #include "filter.hxx"
  16 #include "reffact.hxx"
  17 #include "tabvwsh.hxx"
  18
  19 #include <unotools/pathoptions.hxx>
  20 #include <tools/urlobj.hxx>
  21 #include <svtools/svlbitm.hxx>
  22 #include <svtools/treelistentry.hxx>
  23 #include <svtools/viewdataentry.hxx>
  24 #include <sfx2/objsh.hxx>
  25
  26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  27 #include <com/sun/star/ui/dialogs/FilePicker.hpp>
  28 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  29 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  30
  31 using namespace com::sun::star;
  32
  33 namespace {
  34
  35 bool isAttribute(const SvTreeListEntry& rEntry)
  36 {
  37     const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rEntry);
  38     if (!pUserData)
  39         return false;
  40
  41     return pUserData->meType == ScOrcusXMLTreeParam::Attribute;
  42 }
  43
  44 OUString getXPath(
  45     const SvTreeListBox& rTree, const SvTreeListEntry& rEntry, std::vector<size_t>& rNamespaces)
  46 {
  47     OUStringBuffer aBuf;
  48     for (const SvTreeListEntry* p = &rEntry; p; p = rTree.GetParent(p))
  49     {
  50         const SvLBoxItem* pItem = p->GetFirstItem(SV_ITEM_ID_LBOXSTRING);
  51         if (!pItem)
  52             continue;
  53
  54         // Collect used namespace.
  55         const ScOrcusXMLTreeParam::EntryData* pData = ScOrcusXMLTreeParam::getUserData(*p);
  56         if (pData)
  57             rNamespaces.push_back(pData->mnNamespaceID);
  58
  59         const SvLBoxString* pStr = static_cast<const SvLBoxString*>(pItem);
  60         aBuf.insert(0, pStr->GetText());
  61         aBuf.insert(0, isAttribute(*p) ? '@' : '/');
  62     }
  63
  64     return aBuf.makeStringAndClear();
  65 }
  66
  67 }
  68
  69 ScXMLSourceDlg::ScXMLSourceDlg(
  70     SfxBindings* pB, SfxChildWindow* pCW, vcl::Window* pParent, ScDocument* pDoc)
  71     : ScAnyRefDlg(pB, pCW, pParent, "XMLSourceDialog",
  72         "modules/scalc/ui/xmlsourcedialog.ui")
  73     , mpCurRefEntry(nullptr)
  74     , mpDoc(pDoc)
  75     , mbDlgLostFocus(false)
  76 {
  77     get(mpBtnSelectSource, "selectsource");
  78     get(mpFtSourceFile, "sourcefile");
  79     get(mpMapGrid, "mapgrid");
  80     get(mpLbTree, "tree");
  81     Size aTreeSize(mpLbTree->LogicToPixel(Size(130, 120), MAP_APPFONT));
  82     mpLbTree->set_width_request(aTreeSize.Width());
  83     mpLbTree->set_height_request(aTreeSize.Height());
  84     get(mpRefEdit, "edit");
  85     mpRefEdit->SetReferences(this, nullptr);
  86     get(mpRefBtn, "ref");
  87     mpRefBtn->SetReferences(this, mpRefEdit);
  88     get(mpBtnCancel, "cancel");
  89     get(mpBtnOk, "ok");
  90
  91     mpActiveEdit = mpRefEdit;
  92
  93     maXMLParam.maImgElementDefault = Image(ScResId(IMG_ELEMENT_DEFAULT));
  94     maXMLParam.maImgElementRepeat = Image(ScResId(IMG_ELEMENT_REPEAT));
  95     maXMLParam.maImgAttribute = Image(ScResId(IMG_ELEMENT_ATTRIBUTE));
  96
  97     Link<Button*,void> aBtnHdl = LINK(this, ScXMLSourceDlg, BtnPressedHdl);
  98     mpBtnSelectSource->SetClickHdl(aBtnHdl);
  99     mpBtnOk->SetClickHdl(aBtnHdl);
 100     mpBtnCancel->SetClickHdl(aBtnHdl);
 101
 102     Link<Control&,void> aLink2 = LINK(this, ScXMLSourceDlg, GetFocusHdl);
 103     mpRefEdit->SetGetFocusHdl(aLink2);
 104     mpRefBtn->SetGetFocusHdl(aLink2);
 105
 106     mpLbTree->SetSelectHdl(LINK(this, ScXMLSourceDlg, TreeItemSelectHdl));
 107
 108     Link<Edit&,void> aLink = LINK(this, ScXMLSourceDlg, RefModifiedHdl);
 109     mpRefEdit->SetModifyHdl(aLink);
 110
 111     mpBtnOk->Disable();
 112
 113     SetNonLinkable();
 114     mpBtnSelectSource->GrabFocus(); // Initial focus is on the select source button.
 115 }
 116
 117 ScXMLSourceDlg::~ScXMLSourceDlg()
 118 {
 119     disposeOnce();
 120 }
 121
 122 void ScXMLSourceDlg::dispose()
 123 {
 124     mpBtnSelectSource.clear();
 125     mpFtSourceFile.clear();
 126     mpMapGrid.clear();
 127     mpLbTree.clear();
 128     mpRefEdit.clear();
 129     mpRefBtn.clear();
 130     mpBtnOk.clear();
 131     mpBtnCancel.clear();
 132     mpActiveEdit.clear();
 133     ScAnyRefDlg::dispose();
 134 }
 135
 136 bool ScXMLSourceDlg::IsRefInputMode() const
 137 {
 138     return mpActiveEdit != nullptr && mpActiveEdit->IsEnabled();
 139 }
 140
 141 void ScXMLSourceDlg::SetReference(const ScRange& rRange, ScDocument* pDoc)
 142 {
 143     if (!mpActiveEdit)
 144         return;
 145
 146     if (rRange.aStart != rRange.aEnd)
 147         RefInputStart(mpActiveEdit);
 148
 149     OUString aStr(rRange.aStart.Format(ScRefFlags::ADDR_ABS_3D, pDoc, pDoc->GetAddressConvention()));
 150     mpActiveEdit->SetRefString(aStr);
 151
 152     RefEditModified();
 153 }
 154
 155 void ScXMLSourceDlg::Deactivate()
 156 {
 157     mbDlgLostFocus = true;
 158 }
 159
 160 void ScXMLSourceDlg::SetActive()
 161 {
 162     if (mbDlgLostFocus)
 163     {
 164         mbDlgLostFocus = false;
 165         if (mpActiveEdit)
 166         {
 167             mpActiveEdit->GrabFocus();
 168         }
 169     }
 170     else
 171     {
 172         GrabFocus();
 173     }
 174
 175     RefInputDone();
 176 }
 177
 178 bool ScXMLSourceDlg::Close()
 179 {
 180     return DoClose(ScXMLSourceDlgWrapper::GetChildWindowId());
 181 }
 182
 183 void ScXMLSourceDlg::SelectSourceFile()
 184 {
 185     uno::Reference<ui::dialogs::XFilePicker3> xFilePicker = ui::dialogs::FilePicker::createWithMode( comphelper::getProcessComponentContext(), ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE );
 186
 187     if (maSrcPath.isEmpty())
 188         // Use default path.
 189         xFilePicker->setDisplayDirectory(SvtPathOptions().GetWorkPath());
 190     else
 191     {
 192         // Use the directory of current source file.
 193         INetURLObject aURL(maSrcPath);
 194         aURL.removeSegment();
 195         aURL.removeFinalSlash();
 196         OUString aPath = aURL.GetMainURL(INetURLObject::NO_DECODE);
 197         xFilePicker->setDisplayDirectory(aPath);
 198     }
 199
 200     if (xFilePicker->execute() != ui::dialogs::ExecutableDialogResults::OK)
 201         // File picker dialog cancelled.
 202         return;
 203
 204     uno::Sequence<OUString> aFiles = xFilePicker->getSelectedFiles();
 205     if (!aFiles.getLength())
 206         return;
 207
 208     // There should only be one file returned from the file picker.
 209     maSrcPath = aFiles[0];
 210     mpFtSourceFile->SetText(maSrcPath);
 211     maHighlightedEntries.clear();
 212     LoadSourceFileStructure(maSrcPath);
 213 }
 214
 215 void ScXMLSourceDlg::LoadSourceFileStructure(const OUString& rPath)
 216 {
 217     ScOrcusFilters* pOrcus = ScFormatFilter::Get().GetOrcusFilters();
 218     if (!pOrcus)
 219         return;
 220
 221     mpXMLContext.reset(pOrcus->createXMLContext(*mpDoc, rPath));
 222     if (!mpXMLContext)
 223         return;
 224
 225     mpXMLContext->loadXMLStructure(*mpLbTree, maXMLParam);
 226 }
 227
 228 void ScXMLSourceDlg::HandleGetFocus(Control* pCtrl)
 229 {
 230     mpActiveEdit = nullptr;
 231     if (pCtrl == mpRefEdit || pCtrl == mpRefBtn)
 232         mpActiveEdit = mpRefEdit;
 233
 234     if (mpActiveEdit)
 235         mpActiveEdit->SetSelection(Selection(0, SELECTION_MAX));
 236 }
 237
 238 namespace {
 239
 240 class UnhighlightEntry : public std::unary_function<SvTreeListEntry*, void>
 241 {
 242     SvTreeListBox& mrTree;
 243 public:
 244     explicit UnhighlightEntry(SvTreeListBox& rTree) : mrTree(rTree) {}
 245
 246     void operator() (SvTreeListEntry* p)
 247     {
 248         SvViewDataEntry* pView = mrTree.GetViewDataEntry(p);
 249         if (!pView)
 250             return;
 251
 252         pView->SetHighlighted(false);
 253         mrTree.Invalidate();
 254     }
 255 };
 256
 257 /**
 258  * When the current entry is a direct or indirect child of a mappable
 259  * repeat element entry, that entry becomes the reference entry.
 260  * Otherwise the reference entry equals the current entry.  A reference
 261  * entry is the entry that stores mapped cell position.
 262  */
 263 SvTreeListEntry* getReferenceEntry(SvTreeListBox& rTree, SvTreeListEntry* pCurEntry)
 264 {
 265     SvTreeListEntry* pParent = rTree.GetParent(pCurEntry);
 266     SvTreeListEntry* pRefEntry = nullptr;
 267     while (pParent)
 268     {
 269         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*pParent);
 270         OSL_ASSERT(pUserData);
 271         if (pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat)
 272         {
 273             // This is a repeat element.
 274             if (pRefEntry)
 275             {
 276                 // Second repeat element encountered. Not good.
 277                 return pCurEntry;
 278             }
 279
 280             pRefEntry = pParent;
 281         }
 282         pParent = rTree.GetParent(pParent);
 283     }
 284
 285     return pRefEntry ? pRefEntry : pCurEntry;
 286 }
 287
 288 }
 289
 290 void ScXMLSourceDlg::TreeItemSelected()
 291 {
 292     SvTreeListEntry* pEntry = mpLbTree->GetCurEntry();
 293     if (!pEntry)
 294         return;
 295
 296     if (!maHighlightedEntries.empty())
 297     {
 298         // Remove highlights from all previously highlighted entries (if any).
 299         std::for_each(maHighlightedEntries.begin(), maHighlightedEntries.end(), UnhighlightEntry(*mpLbTree));
 300         maHighlightedEntries.clear();
 301     }
 302
 303     mpCurRefEntry = getReferenceEntry(*mpLbTree, pEntry);
 304
 305     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mpCurRefEntry);
 306     OSL_ASSERT(pUserData);
 307
 308     const ScAddress& rPos = pUserData->maLinkedPos;
 309     if (rPos.IsValid())
 310     {
 311         OUString aStr(rPos.Format(ScRefFlags::ADDR_ABS_3D, mpDoc, mpDoc->GetAddressConvention()));
 312         mpRefEdit->SetRefString(aStr);
 313     }
 314     else
 315         mpRefEdit->SetRefString(OUString());
 316
 317     switch (pUserData->meType)
 318     {
 319         case ScOrcusXMLTreeParam::Attribute:
 320             AttributeSelected(*mpCurRefEntry);
 321         break;
 322         case ScOrcusXMLTreeParam::ElementDefault:
 323             DefaultElementSelected(*mpCurRefEntry);
 324         break;
 325         case ScOrcusXMLTreeParam::ElementRepeat:
 326             RepeatElementSelected(*mpCurRefEntry);
 327         break;
 328         default:
 329             ;
 330     }
 331 }
 332
 333 void ScXMLSourceDlg::DefaultElementSelected(SvTreeListEntry& rEntry)
 334 {
 335
 336     if (mpLbTree->GetChildCount(&rEntry) > 0)
 337     {
 338         // Only an element with no child elements (leaf element) can be linked.
 339         bool bHasChild = false;
 340         for (SvTreeListEntry* pChild = mpLbTree->FirstChild(&rEntry); pChild; pChild = SvTreeListBox::NextSibling(pChild))
 341         {
 342             ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*pChild);
 343             OSL_ASSERT(pUserData);
 344             if (pUserData->meType != ScOrcusXMLTreeParam::Attribute)
 345             {
 346                 // This child is not an attribute. Bail out.
 347                 bHasChild = true;
 348                 break;
 349             }
 350         }
 351
 352         if (bHasChild)
 353         {
 354             SetNonLinkable();
 355             return;
 356         }
 357     }
 358
 359     // Check all its parents and make sure non of them are range-linked nor
 360     // repeat elements.
 361     if (IsParentDirty(&rEntry))
 362     {
 363         SetNonLinkable();
 364         return;
 365     }
 366
 367     SetSingleLinkable();
 368 }
 369
 370 void ScXMLSourceDlg::RepeatElementSelected(SvTreeListEntry& rEntry)
 371 {
 372     // Check all its parents first.
 373
 374     if (IsParentDirty(&rEntry))
 375     {
 376         SetNonLinkable();
 377         return;
 378     }
 379
 380     // Check all its child elements / attributes and make sure non of them are
 381     // linked or repeat elements.  In the future we will support range linking
 382     // of repeat element who has another repeat elements. But first I need to
 383     // support that scenario in orcus.
 384
 385     if (IsChildrenDirty(&rEntry))
 386     {
 387         SetNonLinkable();
 388         return;
 389     }
 390
 391     SvViewDataEntry* p = mpLbTree->GetViewDataEntry(&rEntry);
 392     if (!p->IsHighlighted())
 393     {
 394         // Highlight the entry if not highlighted already.  This can happen
 395         // when the current entry is a child entry of a repeat element entry.
 396         p->SetHighlighted(true);
 397         mpLbTree->Invalidate();
 398         maHighlightedEntries.push_back(&rEntry);
 399     }
 400
 401     SelectAllChildEntries(rEntry);
 402     SetRangeLinkable();
 403 }
 404
 405 void ScXMLSourceDlg::AttributeSelected(SvTreeListEntry& rEntry)
 406 {
 407     // Check all its parent elements and make sure non of them are linked nor
 408     // repeat elements.  In attribute's case, it's okay to have the immediate
 409     // parent element linked (but not range-linked).
 410
 411     SvTreeListEntry* pParent = mpLbTree->GetParent(&rEntry);
 412     OSL_ASSERT(pParent); // attribute should have a parent element.
 413
 414     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*pParent);
 415     OSL_ASSERT(pUserData);
 416     if (pUserData->maLinkedPos.IsValid() && pUserData->mbRangeParent)
 417     {
 418         // Parent element is range-linked.  Bail out.
 419         SetNonLinkable();
 420         return;
 421     }
 422
 423     if (IsParentDirty(&rEntry))
 424     {
 425         SetNonLinkable();
 426         return;
 427     }
 428
 429     SetSingleLinkable();
 430 }
 431
 432 void ScXMLSourceDlg::SetNonLinkable()
 433 {
 434     mpMapGrid->Disable();
 435 }
 436
 437 void ScXMLSourceDlg::SetSingleLinkable()
 438 {
 439     mpMapGrid->Enable();
 440 }
 441
 442 void ScXMLSourceDlg::SetRangeLinkable()
 443 {
 444     mpMapGrid->Enable();
 445 }
 446
 447 void ScXMLSourceDlg::SelectAllChildEntries(SvTreeListEntry& rEntry)
 448 {
 449     SvTreeListEntries& rChildren = rEntry.GetChildEntries();
 450     for (auto const& it : rChildren)
 451     {
 452         SvTreeListEntry& r = *it;
 453         SelectAllChildEntries(r); // select recursively.
 454         SvViewDataEntry* p = mpLbTree->GetViewDataEntry(&r);
 455         p->SetHighlighted(true);
 456         mpLbTree->Invalidate();
 457         maHighlightedEntries.push_back(&r);
 458     }
 459 }
 460
 461 bool ScXMLSourceDlg::IsParentDirty(SvTreeListEntry* pEntry) const
 462 {
 463     SvTreeListEntry* pParent = mpLbTree->GetParent(pEntry);
 464     while (pParent)
 465     {
 466         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*pParent);
 467         assert(pUserData);
 468         if (pUserData->maLinkedPos.IsValid())
 469         {
 470             // This parent is already linked.
 471             return true;
 472         }
 473         if (pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat)
 474         {
 475             // This is a repeat element.
 476             return true;
 477         }
 478         pParent = mpLbTree->GetParent(pParent);
 479     }
 480     return false;
 481 }
 482
 483 bool ScXMLSourceDlg::IsChildrenDirty(SvTreeListEntry* pEntry) const
 484 {
 485     for (SvTreeListEntry* pChild = mpLbTree->FirstChild(pEntry); pChild; pChild = SvTreeListBox::NextSibling(pChild))
 486     {
 487         ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*pChild);
 488         OSL_ASSERT(pUserData);
 489         if (pUserData->maLinkedPos.IsValid())
 490             // Already linked.
 491             return true;
 492
 493         if (pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat)
 494             // We don't support linking of nested repeat elements (yet).
 495             return true;
 496
 497         if (pUserData->meType == ScOrcusXMLTreeParam::ElementDefault)
 498         {
 499             // Check recursively.
 500             if (IsChildrenDirty(pChild))
 501                 return true;
 502         }
 503     }
 504
 505     return false;
 506 }
 507
 508 namespace {
 509
 510 /**
 511  * Pick only the leaf elements.
 512  */
 513 void getFieldLinks(
 514     ScOrcusImportXMLParam::RangeLink& rRangeLink, std::vector<size_t>& rNamespaces,
 515     const SvTreeListBox& rTree, const SvTreeListEntry& rEntry)
 516 {
 517     const SvTreeListEntries& rChildren = rEntry.GetChildEntries();
 518     if (rChildren.empty())
 519         // No more children.  We're done.
 520         return;
 521
 522     for (auto const& it : rChildren)
 523     {
 524         const SvTreeListEntry& rChild = *it;
 525         OUString aPath = getXPath(rTree, rChild, rNamespaces);
 526         const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rChild);
 527
 528         if (pUserData && pUserData->mbLeafNode)
 529         {
 530             if (!aPath.isEmpty())
 531                 // XPath should never be empty anyway, but it won't hurt to check...
 532                 rRangeLink.maFieldPaths.push_back(OUStringToOString(aPath, RTL_TEXTENCODING_UTF8));
 533         }
 534
 535         // Walk recursively.
 536         getFieldLinks(rRangeLink, rNamespaces, rTree, rChild);
 537     }
 538 }
 539
 540 void removeDuplicates(std::vector<size_t>& rArray)
 541 {
 542     std::sort(rArray.begin(), rArray.end());
 543     std::vector<size_t>::iterator it = std::unique(rArray.begin(), rArray.end());
 544     rArray.erase(it, rArray.end());
 545 }
 546
 547 }
 548
 549 void ScXMLSourceDlg::OkPressed()
 550 {
 551     if (!mpXMLContext)
 552         return;
 553
 554     // Begin import.
 555
 556     ScOrcusImportXMLParam aParam;
 557
 558     // Convert single cell links.
 559     {
 560         std::set<const SvTreeListEntry*>::const_iterator it = maCellLinks.begin(), itEnd = maCellLinks.end();
 561         for (; it != itEnd; ++it)
 562         {
 563             const SvTreeListEntry& rEntry = **it;
 564             OUString aPath = getXPath(*mpLbTree, rEntry, aParam.maNamespaces);
 565             const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rEntry);
 566
 567             aParam.maCellLinks.push_back(
 568                 ScOrcusImportXMLParam::CellLink(
 569                     pUserData->maLinkedPos, OUStringToOString(aPath, RTL_TEXTENCODING_UTF8)));
 570         }
 571     }
 572
 573     // Convert range links. For now, an element with range link takes all its
 574     // child elements as its fields.
 575     {
 576         std::set<const SvTreeListEntry*>::const_iterator it = maRangeLinks.begin(), itEnd = maRangeLinks.end();
 577         for (; it != itEnd; ++it)
 578         {
 579             const SvTreeListEntry& rEntry = **it;
 580             const ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(rEntry);
 581
 582             ScOrcusImportXMLParam::RangeLink aRangeLink;
 583             aRangeLink.maPos = pUserData->maLinkedPos;
 584
 585             // Go through all its child elements.
 586             getFieldLinks(aRangeLink, aParam.maNamespaces, *mpLbTree, rEntry);
 587
 588             aParam.maRangeLinks.push_back(aRangeLink);
 589         }
 590     }
 591
 592     // Remove duplicate namespace IDs.
 593     removeDuplicates(aParam.maNamespaces);
 594
 595     // Now do the import.
 596     mpXMLContext->importXML(aParam);
 597
 598     // Don't forget to broadcast the change.
 599     SfxObjectShell* pShell = mpDoc->GetDocumentShell();
 600     pShell->Broadcast(SfxSimpleHint(FID_DATACHANGED));
 601
 602     // Repaint the grid to force repaint the cell values.
 603     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 604     if (pViewShell)
 605         pViewShell->PaintGrid();
 606
 607     Close();
 608 }
 609
 610 void ScXMLSourceDlg::CancelPressed()
 611 {
 612     Close();
 613 }
 614
 615 void ScXMLSourceDlg::RefEditModified()
 616 {
 617     OUString aRefStr = mpRefEdit->GetText();
 618
 619     // Check if the address is valid.
 620     ScAddress aLinkedPos;
 621     ScRefFlags nRes = aLinkedPos.Parse(aRefStr, mpDoc, mpDoc->GetAddressConvention());
 622     bool bValid = ( (nRes & ScRefFlags::VALID) == ScRefFlags::VALID );
 623
 624     // TODO: For some unknown reason, setting the ref invalid will hide the text altogether.
 625     // Find out how to make this work.
 626 //  mpRefEdit->SetRefValid(bValid);
 627
 628     if (!bValid)
 629         aLinkedPos.SetInvalid();
 630
 631     // Set this address to the current reference entry.
 632     if (!mpCurRefEntry)
 633         // This should never happen.
 634         return;
 635
 636     ScOrcusXMLTreeParam::EntryData* pUserData = ScOrcusXMLTreeParam::getUserData(*mpCurRefEntry);
 637     if (!pUserData)
 638         // This should never happen either.
 639         return;
 640
 641     bool bRepeatElem = pUserData->meType == ScOrcusXMLTreeParam::ElementRepeat;
 642     pUserData->maLinkedPos = aLinkedPos;
 643     pUserData->mbRangeParent = aLinkedPos.IsValid() && bRepeatElem;
 644
 645     if (bRepeatElem)
 646     {
 647         if (bValid)
 648             maRangeLinks.insert(mpCurRefEntry);
 649         else
 650             maRangeLinks.erase(mpCurRefEntry);
 651     }
 652     else
 653     {
 654         if (bValid)
 655             maCellLinks.insert(mpCurRefEntry);
 656         else
 657             maCellLinks.erase(mpCurRefEntry);
 658     }
 659
 660     // Enable the import button only when at least one link exists.
 661     bool bHasLink = !maCellLinks.empty() || !maRangeLinks.empty();
 662     mpBtnOk->Enable(bHasLink);
 663 }
 664
 665 IMPL_LINK_TYPED(ScXMLSourceDlg, GetFocusHdl, Control&, rCtrl, void)
 666 {
 667     HandleGetFocus(&rCtrl);
 668 }
 669
 670 IMPL_LINK_TYPED(ScXMLSourceDlg, BtnPressedHdl, Button*, pBtn, void)
 671 {
 672     if (pBtn == mpBtnSelectSource)
 673         SelectSourceFile();
 674     else if (pBtn == mpBtnOk)
 675         OkPressed();
 676     else if (pBtn == mpBtnCancel)
 677         CancelPressed();
 678 }
 679
 680 IMPL_LINK_NOARG_TYPED(ScXMLSourceDlg, TreeItemSelectHdl, SvTreeListBox*, void)
 681 {
 682     TreeItemSelected();
 683 }
 684
 685 IMPL_LINK_NOARG_TYPED(ScXMLSourceDlg, RefModifiedHdl, Edit&, void)
 686 {
 687     RefEditModified();
 688 }
 689
 690 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */