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