sc/source/ui/unoobj/linkuno.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svl/smplhint.hxx>
  21 #include <sfx2/linkmgr.hxx>
  22 #include <vcl/svapp.hxx>
  23
  24 #include "linkuno.hxx"
  25 #include "miscuno.hxx"
  26 #include "convuno.hxx"
  27 #include "docsh.hxx"
  28 #include "docfunc.hxx"
  29 #include "tablink.hxx"
  30 #include "arealink.hxx"
  31 #include "hints.hxx"
  32 #include "unonames.hxx"
  33 #include "rangeseq.hxx"
  34 #include "token.hxx"
  35 #include "scmatrix.hxx"
  36
  37 #include <vector>
  38 #include <climits>
  39
  40 using namespace com::sun::star;
  41 using namespace formula;
  42 using ::com::sun::star::uno::Any;
  43 using ::com::sun::star::uno::Reference;
  44 using ::com::sun::star::uno::Sequence;
  45 using ::com::sun::star::uno::UNO_QUERY;
  46 using ::com::sun::star::uno::UNO_QUERY_THROW;
  47 using ::com::sun::star::lang::IllegalArgumentException;
  48 using ::com::sun::star::uno::RuntimeException;
  49 using ::std::vector;
  50
  51 //------------------------------------------------------------------------
  52
  53 //  fuer Sheet- und Area-Links benutzt:
  54 static const SfxItemPropertyMapEntry* lcl_GetSheetLinkMap()
  55 {
  56     static const SfxItemPropertyMapEntry aSheetLinkMap_Impl[] =
  57     {
  58         {MAP_CHAR_LEN(SC_UNONAME_FILTER),   0,  &getCppuType((OUString*)0),    0, 0 },
  59         {MAP_CHAR_LEN(SC_UNONAME_FILTOPT),  0,  &getCppuType((OUString*)0),    0, 0 },
  60         {MAP_CHAR_LEN(SC_UNONAME_LINKURL),  0,  &getCppuType((OUString*)0),    0, 0 },
  61         {MAP_CHAR_LEN(SC_UNONAME_REFDELAY), 0,  &getCppuType((sal_Int32*)0),        0, 0 },
  62         {MAP_CHAR_LEN(SC_UNONAME_REFPERIOD),    0,  &getCppuType((sal_Int32*)0),        0, 0 },
  63         {0,0,0,0,0,0}
  64     };
  65     return aSheetLinkMap_Impl;
  66 }
  67
  68 //------------------------------------------------------------------------
  69
  70 SC_SIMPLE_SERVICE_INFO( ScAreaLinkObj, "ScAreaLinkObj", "com.sun.star.sheet.CellAreaLink" )
  71 SC_SIMPLE_SERVICE_INFO( ScAreaLinksObj, "ScAreaLinksObj", "com.sun.star.sheet.CellAreaLinks" )
  72 SC_SIMPLE_SERVICE_INFO( ScDDELinkObj, "ScDDELinkObj", "com.sun.star.sheet.DDELink" )
  73 SC_SIMPLE_SERVICE_INFO( ScDDELinksObj, "ScDDELinksObj", "com.sun.star.sheet.DDELinks" )
  74 SC_SIMPLE_SERVICE_INFO( ScSheetLinkObj, "ScSheetLinkObj", "com.sun.star.sheet.SheetLink" )
  75 SC_SIMPLE_SERVICE_INFO( ScSheetLinksObj, "ScSheetLinksObj", "com.sun.star.sheet.SheetLinks" )
  76
  77 //------------------------------------------------------------------------
  78
  79 ScSheetLinkObj::ScSheetLinkObj(ScDocShell* pDocSh, const OUString& rName) :
  80     aPropSet( lcl_GetSheetLinkMap() ),
  81     pDocShell( pDocSh ),
  82     aFileName( rName )
  83 {
  84     pDocShell->GetDocument()->AddUnoObject(*this);
  85 }
  86
  87 ScSheetLinkObj::~ScSheetLinkObj()
  88 {
  89     if (pDocShell)
  90         pDocShell->GetDocument()->RemoveUnoObject(*this);
  91 }
  92
  93 void ScSheetLinkObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
  94 {
  95     //! notify if links in document are changed
  96     //  UpdateRef is not needed here
  97
  98     if ( rHint.ISA( SfxSimpleHint ) )
  99     {
 100         if ( ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 101             pDocShell = NULL;       // pointer is invalid
 102     }
 103     else if ( rHint.ISA( ScLinkRefreshedHint ) )
 104     {
 105         const ScLinkRefreshedHint& rLH = (const ScLinkRefreshedHint&) rHint;
 106         if ( rLH.GetLinkType() == SC_LINKREFTYPE_SHEET && rLH.GetUrl() == aFileName )
 107             Refreshed_Impl();
 108     }
 109 }
 110
 111 ScTableLink* ScSheetLinkObj::GetLink_Impl() const
 112 {
 113     if (pDocShell)
 114     {
 115         sfx2::LinkManager* pLinkManager = pDocShell->GetDocument()->GetLinkManager();
 116         size_t nCount = pLinkManager->GetLinks().size();
 117         for (size_t i=0; i<nCount; i++)
 118         {
 119             ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[i];
 120             if (pBase->ISA(ScTableLink))
 121             {
 122                 ScTableLink* pTabLink = (ScTableLink*)pBase;
 123                 if ( pTabLink->GetFileName().equals(aFileName) )
 124                     return pTabLink;
 125             }
 126         }
 127     }
 128     return NULL;    // nicht gefunden
 129 }
 130
 131 // XNamed
 132
 133 OUString SAL_CALL ScSheetLinkObj::getName() throw(uno::RuntimeException)
 134 {
 135     SolarMutexGuard aGuard;
 136     return getFileName();   // Name ist der Dateiname (URL)
 137 }
 138
 139 void SAL_CALL ScSheetLinkObj::setName( const OUString& aName ) throw(uno::RuntimeException)
 140 {
 141     SolarMutexGuard aGuard;
 142     setFileName(aName);     // Name ist der Dateiname (URL)
 143 }
 144
 145 // XRefreshable
 146
 147 void SAL_CALL ScSheetLinkObj::refresh() throw(uno::RuntimeException)
 148 {
 149     SolarMutexGuard aGuard;
 150     ScTableLink* pLink = GetLink_Impl();
 151     if (pLink)
 152         pLink->Refresh( pLink->GetFileName(), pLink->GetFilterName(), NULL, pLink->GetRefreshDelay() );
 153 }
 154
 155 void SAL_CALL ScSheetLinkObj::addRefreshListener(
 156                                 const uno::Reference<util::XRefreshListener >& xListener )
 157                                                 throw(uno::RuntimeException)
 158 {
 159     SolarMutexGuard aGuard;
 160     uno::Reference<util::XRefreshListener>* pObj =
 161             new uno::Reference<util::XRefreshListener>( xListener );
 162     aRefreshListeners.push_back( pObj );
 163
 164     //  hold one additional ref to keep this object alive as long as there are listeners
 165     if ( aRefreshListeners.size() == 1 )
 166         acquire();
 167 }
 168
 169 void SAL_CALL ScSheetLinkObj::removeRefreshListener(
 170                                 const uno::Reference<util::XRefreshListener >& xListener )
 171                                                 throw(uno::RuntimeException)
 172 {
 173     SolarMutexGuard aGuard;
 174     size_t nCount = aRefreshListeners.size();
 175     for ( size_t n=nCount; n--; )
 176     {
 177         uno::Reference<util::XRefreshListener>& rObj = aRefreshListeners[n];
 178         if ( rObj == xListener )
 179         {
 180             aRefreshListeners.erase( aRefreshListeners.begin() + n );
 181             if ( aRefreshListeners.empty() )
 182                 release();                          // release ref for listeners
 183             break;
 184         }
 185     }
 186 }
 187
 188 void ScSheetLinkObj::Refreshed_Impl()
 189 {
 190     lang::EventObject aEvent;
 191     aEvent.Source.set((cppu::OWeakObject*)this);
 192     for ( size_t n=0; n<aRefreshListeners.size(); n++ )
 193         aRefreshListeners[n]->refreshed( aEvent );
 194 }
 195
 196 void ScSheetLinkObj::ModifyRefreshDelay_Impl( sal_Int32 nRefresh )
 197 {
 198     ScTableLink* pLink = GetLink_Impl();
 199     if( pLink )
 200         pLink->SetRefreshDelay( (sal_uLong) nRefresh );
 201 }
 202
 203 // XPropertySet
 204
 205 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScSheetLinkObj::getPropertySetInfo()
 206                                                         throw(uno::RuntimeException)
 207 {
 208     SolarMutexGuard aGuard;
 209     static uno::Reference<beans::XPropertySetInfo> aRef(
 210         new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
 211     return aRef;
 212 }
 213
 214 void SAL_CALL ScSheetLinkObj::setPropertyValue(
 215                         const OUString& aPropertyName, const uno::Any& aValue )
 216                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 217                         lang::IllegalArgumentException, lang::WrappedTargetException,
 218                         uno::RuntimeException)
 219 {
 220     SolarMutexGuard aGuard;
 221     OUString aNameString(aPropertyName);
 222     OUString aValStr;
 223     if ( aNameString.equalsAscii( SC_UNONAME_LINKURL ) )
 224     {
 225         if ( aValue >>= aValStr )
 226             setFileName( aValStr );
 227     }
 228     else if ( aNameString.equalsAscii( SC_UNONAME_FILTER ) )
 229     {
 230         if ( aValue >>= aValStr )
 231             setFilter( aValStr );
 232     }
 233     else if ( aNameString.equalsAscii( SC_UNONAME_FILTOPT ) )
 234     {
 235         if ( aValue >>= aValStr )
 236             setFilterOptions( aValStr );
 237     }
 238     else if ( aNameString.equalsAscii( SC_UNONAME_REFPERIOD ) )
 239     {
 240         sal_Int32 nRefresh = 0;
 241         if ( aValue >>= nRefresh )
 242             setRefreshDelay( nRefresh );
 243     }
 244     else if ( aNameString.equalsAscii( SC_UNONAME_REFDELAY ) )
 245     {
 246         sal_Int32 nRefresh = 0;
 247         if ( aValue >>= nRefresh )
 248             setRefreshDelay( nRefresh );
 249     }
 250 }
 251
 252 uno::Any SAL_CALL ScSheetLinkObj::getPropertyValue( const OUString& aPropertyName )
 253                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 254                         uno::RuntimeException)
 255 {
 256     SolarMutexGuard aGuard;
 257     OUString aNameString(aPropertyName);
 258     uno::Any aRet;
 259     if ( aNameString.equalsAscii( SC_UNONAME_LINKURL ) )
 260         aRet <<= getFileName();
 261     else if ( aNameString.equalsAscii( SC_UNONAME_FILTER ) )
 262         aRet <<= getFilter();
 263     else if ( aNameString.equalsAscii( SC_UNONAME_FILTOPT ) )
 264         aRet <<= getFilterOptions();
 265     else if ( aNameString.equalsAscii( SC_UNONAME_REFPERIOD ) )
 266         aRet <<= getRefreshDelay();
 267     else if ( aNameString.equalsAscii( SC_UNONAME_REFDELAY ) )
 268         aRet <<= getRefreshDelay();
 269     return aRet;
 270 }
 271
 272 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScSheetLinkObj )
 273
 274 // internal:
 275
 276 OUString ScSheetLinkObj::getFileName(void) const
 277 {
 278     SolarMutexGuard aGuard;
 279     return aFileName;
 280 }
 281
 282 void ScSheetLinkObj::setFileName(const OUString& rNewName)
 283 {
 284     SolarMutexGuard aGuard;
 285     ScTableLink* pLink = GetLink_Impl();
 286     if (pLink)
 287     {
 288         //  pLink->Refresh mit neuem Dateinamen bringt sfx2::LinkManager durcheinander
 289         //  darum per Hand die Tabellen umsetzen und Link per UpdateLinks neu erzeugen
 290
 291         OUString aNewStr(ScGlobal::GetAbsDocName( rNewName, pDocShell ));
 292
 293         //  zuerst Tabellen umsetzen
 294
 295         ScDocument* pDoc = pDocShell->GetDocument();
 296         SCTAB nTabCount = pDoc->GetTableCount();
 297         for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 298             if ( pDoc->IsLinked(nTab) && pDoc->GetLinkDoc(nTab) == aFileName )  // alte Datei
 299                 pDoc->SetLink( nTab, pDoc->GetLinkMode(nTab), aNewStr,
 300                                 pDoc->GetLinkFlt(nTab), pDoc->GetLinkOpt(nTab),
 301                                 pDoc->GetLinkTab(nTab),
 302                                 pDoc->GetLinkRefreshDelay(nTab) );  // nur Datei aendern
 303
 304         //  Links updaten
 305         //! Undo !!!
 306
 307         pLink = NULL;               // wird bei UpdateLinks ungueltig
 308         pDocShell->UpdateLinks();   // alter Link raus, evtl. neuen Link anlegen
 309
 310         //  Daten kopieren
 311
 312         aFileName = aNewStr;
 313         pLink = GetLink_Impl();     // neuer Link mit neuem Namen
 314         if (pLink)
 315             pLink->Update();        // inkl. Paint & Undo fuer Daten
 316     }
 317 }
 318
 319 OUString ScSheetLinkObj::getFilter(void) const
 320 {
 321     SolarMutexGuard aGuard;
 322     OUString aRet;
 323     ScTableLink* pLink = GetLink_Impl();
 324     if (pLink)
 325         aRet = pLink->GetFilterName();
 326     return aRet;
 327 }
 328
 329 void ScSheetLinkObj::setFilter(const OUString& Filter)
 330 {
 331     SolarMutexGuard aGuard;
 332     ScTableLink* pLink = GetLink_Impl();
 333     if (pLink)
 334     {
 335         OUString aFilterStr(Filter);
 336         pLink->Refresh( aFileName, aFilterStr, NULL, pLink->GetRefreshDelay() );
 337     }
 338 }
 339
 340 OUString ScSheetLinkObj::getFilterOptions(void) const
 341 {
 342     SolarMutexGuard aGuard;
 343     OUString aRet;
 344     ScTableLink* pLink = GetLink_Impl();
 345     if (pLink)
 346         aRet = pLink->GetOptions();
 347     return aRet;
 348 }
 349
 350 void ScSheetLinkObj::setFilterOptions(const OUString& FilterOptions)
 351 {
 352     SolarMutexGuard aGuard;
 353     ScTableLink* pLink = GetLink_Impl();
 354     if (pLink)
 355     {
 356         OUString aOptStr(FilterOptions);
 357         pLink->Refresh( aFileName, pLink->GetFilterName(), &aOptStr, pLink->GetRefreshDelay() );
 358     }
 359 }
 360
 361 sal_Int32 ScSheetLinkObj::getRefreshDelay(void) const
 362 {
 363     SolarMutexGuard aGuard;
 364     sal_Int32 nRet = 0;
 365     ScTableLink* pLink = GetLink_Impl();
 366     if (pLink)
 367         nRet = (sal_Int32) pLink->GetRefreshDelay();
 368     return nRet;
 369 }
 370
 371 void ScSheetLinkObj::setRefreshDelay(sal_Int32 nRefreshDelay)
 372 {
 373     SolarMutexGuard aGuard;
 374     ModifyRefreshDelay_Impl( nRefreshDelay );
 375 }
 376
 377 //------------------------------------------------------------------------
 378
 379 ScSheetLinksObj::ScSheetLinksObj(ScDocShell* pDocSh) :
 380     pDocShell( pDocSh )
 381 {
 382     pDocShell->GetDocument()->AddUnoObject(*this);
 383 }
 384
 385 ScSheetLinksObj::~ScSheetLinksObj()
 386 {
 387     if (pDocShell)
 388         pDocShell->GetDocument()->RemoveUnoObject(*this);
 389 }
 390
 391 void ScSheetLinksObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 392 {
 393     //  Referenz-Update interessiert hier nicht
 394
 395     if ( rHint.ISA( SfxSimpleHint ) &&
 396             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 397     {
 398         pDocShell = NULL;       // ungueltig geworden
 399     }
 400 }
 401
 402 // XSheetLinks
 403
 404 ScSheetLinkObj* ScSheetLinksObj::GetObjectByIndex_Impl(sal_Int32 nIndex)
 405 {
 406     if (!pDocShell)
 407         return NULL;
 408
 409     typedef boost::unordered_set<OUString, OUStringHash> StrSetType;
 410     StrSetType aNames;
 411     ScDocument* pDoc = pDocShell->GetDocument();
 412     SCTAB nTabCount = pDoc->GetTableCount();
 413     sal_Int32 nCount = 0;
 414     for (SCTAB nTab = 0; nTab < nTabCount; ++nTab)
 415     {
 416         if (!pDoc->IsLinked(nTab))
 417             continue;
 418
 419         OUString aLinkDoc = pDoc->GetLinkDoc(nTab);
 420         if (aNames.insert(aLinkDoc).second)
 421         {
 422             // unique document name.
 423             if (nCount == nIndex)
 424                 return new ScSheetLinkObj( pDocShell, aLinkDoc );
 425             ++nCount;
 426         }
 427     }
 428
 429     return NULL;    // kein Dokument oder Index zu gross
 430 }
 431
 432 ScSheetLinkObj* ScSheetLinksObj::GetObjectByName_Impl(const OUString& aName)
 433 {
 434     //  Name ist der Dateiname
 435
 436     if (pDocShell)
 437     {
 438         OUString aNameStr(aName);
 439
 440         ScDocument* pDoc = pDocShell->GetDocument();
 441         SCTAB nTabCount = pDoc->GetTableCount();
 442         for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 443             if (pDoc->IsLinked(nTab))
 444             {
 445                 //! case-insensitiv ???
 446                 OUString aLinkDoc = pDoc->GetLinkDoc( nTab );
 447                 if ( aLinkDoc == aNameStr )
 448                     return new ScSheetLinkObj( pDocShell, aNameStr );
 449             }
 450     }
 451
 452     return NULL;
 453 }
 454
 455 // XEnumerationAccess
 456
 457 uno::Reference<container::XEnumeration> SAL_CALL ScSheetLinksObj::createEnumeration()
 458                                                     throw(uno::RuntimeException)
 459 {
 460     SolarMutexGuard aGuard;
 461     return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.SheetLinksEnumeration"));
 462 }
 463
 464 // XIndexAccess
 465
 466 sal_Int32 SAL_CALL ScSheetLinksObj::getCount() throw(uno::RuntimeException)
 467 {
 468     typedef boost::unordered_set<OUString, OUStringHash> StrSetType;
 469
 470     SolarMutexGuard aGuard;
 471     if (!pDocShell)
 472         return 0;
 473
 474     sal_Int32 nCount = 0;
 475
 476     StrSetType aNames;
 477     ScDocument* pDoc = pDocShell->GetDocument();
 478     SCTAB nTabCount = pDoc->GetTableCount();
 479     for (SCTAB nTab = 0; nTab < nTabCount; ++nTab)
 480     {
 481         if (!pDoc->IsLinked(nTab))
 482             continue;
 483
 484         OUString aLinkDoc = pDoc->GetLinkDoc(nTab);
 485         if (aNames.insert(aLinkDoc).second)
 486             ++nCount;
 487     }
 488     return nCount;
 489 }
 490
 491 uno::Any SAL_CALL ScSheetLinksObj::getByIndex( sal_Int32 nIndex )
 492                             throw(lang::IndexOutOfBoundsException,
 493                                     lang::WrappedTargetException, uno::RuntimeException)
 494 {
 495     SolarMutexGuard aGuard;
 496     uno::Reference<beans::XPropertySet> xLink(GetObjectByIndex_Impl(nIndex));
 497     if (xLink.is())
 498         return uno::makeAny(xLink);
 499     else
 500         throw lang::IndexOutOfBoundsException();
 501 }
 502
 503 uno::Type SAL_CALL ScSheetLinksObj::getElementType() throw(uno::RuntimeException)
 504 {
 505     SolarMutexGuard aGuard;
 506     return getCppuType((uno::Reference<beans::XPropertySet>*)0);
 507 }
 508
 509 sal_Bool SAL_CALL ScSheetLinksObj::hasElements() throw(uno::RuntimeException)
 510 {
 511     SolarMutexGuard aGuard;
 512     return ( getCount() != 0 );
 513 }
 514
 515 uno::Any SAL_CALL ScSheetLinksObj::getByName( const OUString& aName )
 516             throw(container::NoSuchElementException,
 517                     lang::WrappedTargetException, uno::RuntimeException)
 518 {
 519     SolarMutexGuard aGuard;
 520     uno::Reference<beans::XPropertySet> xLink(GetObjectByName_Impl(aName));
 521     if (xLink.is())
 522         return uno::makeAny(xLink);
 523     else
 524         throw container::NoSuchElementException();
 525 //    return uno::Any();
 526 }
 527
 528 sal_Bool SAL_CALL ScSheetLinksObj::hasByName( const OUString& aName )
 529                                         throw(uno::RuntimeException)
 530 {
 531     SolarMutexGuard aGuard;
 532     //  Name ist der Dateiname
 533
 534     if (pDocShell)
 535     {
 536         OUString aNameStr(aName);
 537
 538         ScDocument* pDoc = pDocShell->GetDocument();
 539         SCTAB nTabCount = pDoc->GetTableCount();
 540         for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 541             if (pDoc->IsLinked(nTab))
 542             {
 543                 //! case-insensitiv ???
 544                 OUString aLinkDoc(pDoc->GetLinkDoc( nTab ));
 545                 if ( aLinkDoc == aNameStr )
 546                     return sal_True;
 547             }
 548     }
 549     return false;
 550 }
 551
 552 uno::Sequence<OUString> SAL_CALL ScSheetLinksObj::getElementNames() throw(uno::RuntimeException)
 553 {
 554     typedef boost::unordered_set<OUString, OUStringHash> StrSetType;
 555
 556     SolarMutexGuard aGuard;
 557     //  Name ist der Dateiname
 558
 559     if (!pDocShell)
 560         return uno::Sequence<OUString>();
 561
 562     StrSetType aNames;
 563     ScDocument* pDoc = pDocShell->GetDocument();
 564     SCTAB nTabCount = pDoc->GetTableCount();
 565
 566     sal_Int32 nLinkCount = getCount();
 567     uno::Sequence<OUString> aSeq(nLinkCount);
 568     OUString* pAry = aSeq.getArray();
 569     size_t nPos = 0;
 570     for (SCTAB nTab = 0; nTab < nTabCount; ++nTab)
 571     {
 572         if (!pDoc->IsLinked(nTab))
 573             continue;
 574
 575         OUString aLinkDoc = pDoc->GetLinkDoc(nTab);
 576         if (aNames.insert(aLinkDoc).second)
 577             pAry[nPos++] = aLinkDoc;
 578     }
 579     OSL_ENSURE( nPos==static_cast<size_t>(nLinkCount), "verzaehlt" );
 580     return aSeq;
 581 }
 582
 583 //------------------------------------------------------------------------
 584
 585 static ScAreaLink* lcl_GetAreaLink( ScDocShell* pDocShell, size_t nPos )
 586 {
 587     if (pDocShell)
 588     {
 589         sfx2::LinkManager* pLinkManager = pDocShell->GetDocument()->GetLinkManager();
 590         size_t nTotalCount = pLinkManager->GetLinks().size();
 591         size_t nAreaCount = 0;
 592         for (size_t i=0; i<nTotalCount; i++)
 593         {
 594             ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[i];
 595             if (pBase->ISA(ScAreaLink))
 596             {
 597                 if ( nAreaCount == nPos )
 598                     return static_cast<ScAreaLink*>(pBase);
 599                 ++nAreaCount;
 600             }
 601         }
 602     }
 603     return NULL;    // nicht gefunden
 604 }
 605
 606 ScAreaLinkObj::ScAreaLinkObj(ScDocShell* pDocSh, size_t nP) :
 607     aPropSet( lcl_GetSheetLinkMap() ),
 608     pDocShell( pDocSh ),
 609     nPos( nP )
 610 {
 611     pDocShell->GetDocument()->AddUnoObject(*this);
 612 }
 613
 614 ScAreaLinkObj::~ScAreaLinkObj()
 615 {
 616     if (pDocShell)
 617         pDocShell->GetDocument()->RemoveUnoObject(*this);
 618 }
 619
 620 void ScAreaLinkObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 621 {
 622     //! notify if links in document are changed
 623     //  UpdateRef is not needed here
 624
 625     if ( rHint.ISA( SfxSimpleHint ) )
 626     {
 627         if ( ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 628             pDocShell = NULL;       // pointer is invalid
 629     }
 630     else if ( rHint.ISA( ScLinkRefreshedHint ) )
 631     {
 632         const ScLinkRefreshedHint& rLH = (const ScLinkRefreshedHint&) rHint;
 633         if ( rLH.GetLinkType() == SC_LINKREFTYPE_AREA )
 634         {
 635             //  get this link to compare dest position
 636             ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 637             if ( pLink && pLink->GetDestArea().aStart == rLH.GetDestPos() )
 638                 Refreshed_Impl();
 639         }
 640     }
 641 }
 642
 643 // XFileLink
 644
 645 void ScAreaLinkObj::Modify_Impl( const OUString* pNewFile, const OUString* pNewFilter,
 646                                  const OUString* pNewOptions, const OUString* pNewSource,
 647                                  const table::CellRangeAddress* pNewDest )
 648 {
 649     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 650     if (pLink)
 651     {
 652         OUString aFile    (pLink->GetFile());
 653         OUString aFilter  (pLink->GetFilter());
 654         OUString aOptions (pLink->GetOptions());
 655         OUString aSource  (pLink->GetSource());
 656         ScRange aDest   (pLink->GetDestArea());
 657         sal_uLong nRefresh  = pLink->GetRefreshDelay();
 658
 659         //! Undo fuer Loeschen
 660         //! Undo zusammenfassen
 661
 662         sfx2::LinkManager* pLinkManager = pDocShell->GetDocument()->GetLinkManager();
 663         pLinkManager->Remove( pLink );
 664         pLink = NULL;   // bei Remove geloescht
 665
 666         sal_Bool bFitBlock = sal_True;          // verschieben, wenn durch Update Groesse geaendert
 667         if (pNewFile)
 668         {
 669             aFile = *pNewFile;
 670             aFile = ScGlobal::GetAbsDocName( aFile, pDocShell );    //! in InsertAreaLink?
 671         }
 672         if (pNewFilter)
 673             aFilter = *pNewFilter;
 674         if (pNewOptions)
 675             aOptions = *pNewOptions;
 676         if (pNewSource)
 677             aSource = *pNewSource;
 678         if (pNewDest)
 679         {
 680             ScUnoConversion::FillScRange( aDest, *pNewDest );
 681             bFitBlock = false;  // neuer Bereich angegeben -> keine Inhalte verschieben
 682         }
 683         pDocShell->GetDocFunc().InsertAreaLink( aFile, aFilter, aOptions, aSource,
 684                                                 aDest, nRefresh, bFitBlock, sal_True );
 685     }
 686 }
 687
 688 void ScAreaLinkObj::ModifyRefreshDelay_Impl( sal_Int32 nRefresh )
 689 {
 690     ScAreaLink* pLink = lcl_GetAreaLink( pDocShell, nPos );
 691     if( pLink )
 692         pLink->SetRefreshDelay( (sal_uLong) nRefresh );
 693 }
 694
 695 // XRefreshable
 696
 697 void SAL_CALL ScAreaLinkObj::refresh() throw(uno::RuntimeException)
 698 {
 699     SolarMutexGuard aGuard;
 700     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 701     if (pLink)
 702         pLink->Refresh( pLink->GetFile(), pLink->GetFilter(), pLink->GetSource(), pLink->GetRefreshDelay() );
 703 }
 704
 705 void SAL_CALL ScAreaLinkObj::addRefreshListener(
 706                                 const uno::Reference<util::XRefreshListener >& xListener )
 707                                                 throw(uno::RuntimeException)
 708 {
 709     SolarMutexGuard aGuard;
 710     uno::Reference<util::XRefreshListener>* pObj =
 711             new uno::Reference<util::XRefreshListener>( xListener );
 712     aRefreshListeners.push_back( pObj );
 713
 714     //  hold one additional ref to keep this object alive as long as there are listeners
 715     if ( aRefreshListeners.size() == 1 )
 716         acquire();
 717 }
 718
 719 void SAL_CALL ScAreaLinkObj::removeRefreshListener(
 720                                 const uno::Reference<util::XRefreshListener >& xListener )
 721                                                 throw(uno::RuntimeException)
 722 {
 723     SolarMutexGuard aGuard;
 724     size_t nCount = aRefreshListeners.size();
 725     for ( size_t n=nCount; n--; )
 726     {
 727         uno::Reference<util::XRefreshListener>& rObj = aRefreshListeners[n];
 728         if ( rObj == xListener )
 729         {
 730             aRefreshListeners.erase( aRefreshListeners.begin() + n );
 731             if ( aRefreshListeners.empty() )
 732                 release();                          // release ref for listeners
 733             break;
 734         }
 735
 736         if(n == 0)
 737             break;
 738     }
 739 }
 740
 741 void ScAreaLinkObj::Refreshed_Impl()
 742 {
 743     lang::EventObject aEvent;
 744     aEvent.Source.set((cppu::OWeakObject*)this);
 745     for ( size_t n=0; n<aRefreshListeners.size(); n++ )
 746         aRefreshListeners[n]->refreshed( aEvent );
 747 }
 748
 749 // XPropertySet
 750
 751 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAreaLinkObj::getPropertySetInfo()
 752                                                         throw(uno::RuntimeException)
 753 {
 754     SolarMutexGuard aGuard;
 755     static uno::Reference<beans::XPropertySetInfo> aRef(
 756         new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
 757     return aRef;
 758 }
 759
 760 void SAL_CALL ScAreaLinkObj::setPropertyValue(
 761                         const OUString& aPropertyName, const uno::Any& aValue )
 762                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 763                         lang::IllegalArgumentException, lang::WrappedTargetException,
 764                         uno::RuntimeException)
 765 {
 766     SolarMutexGuard aGuard;
 767     OUString aNameString(aPropertyName);
 768     OUString aValStr;
 769     if ( aNameString.equalsAscii( SC_UNONAME_LINKURL ) )
 770     {
 771         if ( aValue >>= aValStr )
 772             setFileName( aValStr );
 773     }
 774     else if ( aNameString.equalsAscii( SC_UNONAME_FILTER ) )
 775     {
 776         if ( aValue >>= aValStr )
 777             setFilter( aValStr );
 778     }
 779     else if ( aNameString.equalsAscii( SC_UNONAME_FILTOPT ) )
 780     {
 781         if ( aValue >>= aValStr )
 782             setFilterOptions( aValStr );
 783     }
 784     else if ( aNameString.equalsAscii( SC_UNONAME_REFPERIOD ) )
 785     {
 786         sal_Int32 nRefresh = 0;
 787         if ( aValue >>= nRefresh )
 788             setRefreshDelay( nRefresh );
 789     }
 790     else if ( aNameString.equalsAscii( SC_UNONAME_REFDELAY ) )
 791     {
 792         sal_Int32 nRefresh = 0;
 793         if ( aValue >>= nRefresh )
 794             setRefreshDelay( nRefresh );
 795     }
 796 }
 797
 798 uno::Any SAL_CALL ScAreaLinkObj::getPropertyValue( const OUString& aPropertyName )
 799                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 800                         uno::RuntimeException)
 801 {
 802     SolarMutexGuard aGuard;
 803     OUString aNameString(aPropertyName);
 804     uno::Any aRet;
 805     if ( aNameString.equalsAscii( SC_UNONAME_LINKURL ) )
 806         aRet <<= getFileName();
 807     else if ( aNameString.equalsAscii( SC_UNONAME_FILTER ) )
 808         aRet <<= getFilter();
 809     else if ( aNameString.equalsAscii( SC_UNONAME_FILTOPT ) )
 810         aRet <<= getFilterOptions();
 811     else if ( aNameString.equalsAscii( SC_UNONAME_REFPERIOD ) )
 812         aRet <<= getRefreshDelay();
 813     else if ( aNameString.equalsAscii( SC_UNONAME_REFDELAY ) )
 814         aRet <<= getRefreshDelay();
 815     return aRet;
 816 }
 817
 818 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAreaLinkObj )
 819
 820 //  internal:
 821
 822 OUString ScAreaLinkObj::getFileName(void) const
 823 {
 824     SolarMutexGuard aGuard;
 825     OUString aRet;
 826     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 827     if (pLink)
 828         aRet = pLink->GetFile();
 829     return aRet;
 830 }
 831
 832 void ScAreaLinkObj::setFileName(const OUString& rNewName)
 833 {
 834     SolarMutexGuard aGuard;
 835     Modify_Impl( &rNewName, NULL, NULL, NULL, NULL );
 836 }
 837
 838 OUString ScAreaLinkObj::getFilter(void) const
 839 {
 840     SolarMutexGuard aGuard;
 841     OUString aRet;
 842     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 843     if (pLink)
 844         aRet = pLink->GetFilter();
 845     return aRet;
 846 }
 847
 848 void ScAreaLinkObj::setFilter(const OUString& Filter)
 849 {
 850     SolarMutexGuard aGuard;
 851     Modify_Impl( NULL, &Filter, NULL, NULL, NULL );
 852 }
 853
 854 OUString ScAreaLinkObj::getFilterOptions(void) const
 855 {
 856     SolarMutexGuard aGuard;
 857     OUString aRet;
 858     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 859     if (pLink)
 860         aRet = pLink->GetOptions();
 861     return aRet;
 862 }
 863
 864 void ScAreaLinkObj::setFilterOptions(const OUString& FilterOptions)
 865 {
 866     SolarMutexGuard aGuard;
 867     Modify_Impl( NULL, NULL, &FilterOptions, NULL, NULL );
 868 }
 869
 870 sal_Int32 ScAreaLinkObj::getRefreshDelay(void) const
 871 {
 872     SolarMutexGuard aGuard;
 873     sal_Int32 nRet = 0;
 874     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 875     if (pLink)
 876         nRet = (sal_Int32) pLink->GetRefreshDelay();
 877     return nRet;
 878 }
 879
 880 void ScAreaLinkObj::setRefreshDelay(sal_Int32 nRefreshDelay)
 881 {
 882     SolarMutexGuard aGuard;
 883     ModifyRefreshDelay_Impl( nRefreshDelay );
 884 }
 885
 886 // XAreaLink
 887
 888 OUString SAL_CALL ScAreaLinkObj::getSourceArea() throw(uno::RuntimeException)
 889 {
 890     SolarMutexGuard aGuard;
 891     OUString aRet;
 892     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 893     if (pLink)
 894         aRet = pLink->GetSource();
 895     return aRet;
 896 }
 897
 898 void SAL_CALL ScAreaLinkObj::setSourceArea( const OUString& aSourceArea )
 899                                             throw(uno::RuntimeException)
 900 {
 901     SolarMutexGuard aGuard;
 902     Modify_Impl( NULL, NULL, NULL, &aSourceArea, NULL );
 903 }
 904
 905 table::CellRangeAddress SAL_CALL ScAreaLinkObj::getDestArea() throw(uno::RuntimeException)
 906 {
 907     SolarMutexGuard aGuard;
 908     table::CellRangeAddress aRet;
 909     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, nPos);
 910     if (pLink)
 911         ScUnoConversion::FillApiRange( aRet, pLink->GetDestArea() );
 912     return aRet;
 913 }
 914
 915 void SAL_CALL ScAreaLinkObj::setDestArea( const table::CellRangeAddress& aDestArea )
 916                                             throw(uno::RuntimeException)
 917 {
 918     SolarMutexGuard aGuard;
 919     Modify_Impl( NULL, NULL, NULL, NULL, &aDestArea );
 920 }
 921
 922 //------------------------------------------------------------------------
 923
 924 ScAreaLinksObj::ScAreaLinksObj(ScDocShell* pDocSh) :
 925     pDocShell( pDocSh )
 926 {
 927     pDocShell->GetDocument()->AddUnoObject(*this);
 928 }
 929
 930 ScAreaLinksObj::~ScAreaLinksObj()
 931 {
 932     if (pDocShell)
 933         pDocShell->GetDocument()->RemoveUnoObject(*this);
 934 }
 935
 936 void ScAreaLinksObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
 937 {
 938     //  Referenz-Update interessiert hier nicht
 939
 940     if ( rHint.ISA( SfxSimpleHint ) &&
 941             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
 942     {
 943         pDocShell = NULL;       // ungueltig geworden
 944     }
 945 }
 946
 947 // XAreaLinks
 948
 949 ScAreaLinkObj* ScAreaLinksObj::GetObjectByIndex_Impl(sal_Int32 nIndex)
 950 {
 951     if ( pDocShell && nIndex >= 0 && nIndex < getCount() )
 952         return new ScAreaLinkObj( pDocShell, (size_t)nIndex );
 953
 954     return NULL;    // nicht gefunden
 955 }
 956
 957 void SAL_CALL ScAreaLinksObj::insertAtPosition( const table::CellAddress& aDestPos,
 958                                                 const OUString& aFileName,
 959                                                 const OUString& aSourceArea,
 960                                                 const OUString& aFilter,
 961                                                 const OUString& aFilterOptions )
 962                                             throw(uno::RuntimeException)
 963 {
 964     SolarMutexGuard aGuard;
 965     if (pDocShell)
 966     {
 967         OUString aFileStr   (aFileName);
 968         OUString aFilterStr (aFilter);
 969         OUString aOptionStr (aFilterOptions);
 970         OUString aSourceStr (aSourceArea);
 971         ScAddress aDestAddr( (SCCOL)aDestPos.Column, (SCROW)aDestPos.Row, aDestPos.Sheet );
 972
 973         aFileStr = ScGlobal::GetAbsDocName( aFileStr, pDocShell );  //! in InsertAreaLink ???
 974         pDocShell->GetDocFunc().InsertAreaLink( aFileStr, aFilterStr, aOptionStr,
 975                                                 aSourceStr, ScRange(aDestAddr),
 976                                                 0, false, sal_True ); // don't move contents
 977     }
 978 }
 979
 980 void SAL_CALL ScAreaLinksObj::removeByIndex( sal_Int32 nIndex ) throw(uno::RuntimeException)
 981 {
 982     SolarMutexGuard aGuard;
 983     ScAreaLink* pLink = lcl_GetAreaLink(pDocShell, (size_t)nIndex);
 984     if (pLink)
 985     {
 986         //! SetAddUndo oder so
 987
 988         sfx2::LinkManager* pLinkManager = pDocShell->GetDocument()->GetLinkManager();
 989         pLinkManager->Remove( pLink );
 990     }
 991 }
 992
 993 // XEnumerationAccess
 994
 995 uno::Reference<container::XEnumeration> SAL_CALL ScAreaLinksObj::createEnumeration()
 996                                                     throw(uno::RuntimeException)
 997 {
 998     SolarMutexGuard aGuard;
 999     return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.CellAreaLinksEnumeration"));
1000 }
1001
1002 // XIndexAccess
1003
1004 sal_Int32 SAL_CALL ScAreaLinksObj::getCount() throw(uno::RuntimeException)
1005 {
1006     SolarMutexGuard aGuard;
1007     sal_Int32 nAreaCount = 0;
1008     if (pDocShell)
1009     {
1010         sfx2::LinkManager* pLinkManager = pDocShell->GetDocument()->GetLinkManager();
1011         size_t nTotalCount = pLinkManager->GetLinks().size();
1012         for (size_t i=0; i<nTotalCount; i++)
1013         {
1014             ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[i];
1015             if (pBase->ISA(ScAreaLink))
1016                 ++nAreaCount;
1017         }
1018     }
1019     return nAreaCount;
1020 }
1021
1022 uno::Any SAL_CALL ScAreaLinksObj::getByIndex( sal_Int32 nIndex )
1023                             throw(lang::IndexOutOfBoundsException,
1024                                     lang::WrappedTargetException, uno::RuntimeException)
1025 {
1026     SolarMutexGuard aGuard;
1027     uno::Reference<sheet::XAreaLink> xLink(GetObjectByIndex_Impl(nIndex));
1028     if (xLink.is())
1029         return uno::makeAny(xLink);
1030     else
1031         throw lang::IndexOutOfBoundsException();
1032 }
1033
1034 uno::Type SAL_CALL ScAreaLinksObj::getElementType() throw(uno::RuntimeException)
1035 {
1036     SolarMutexGuard aGuard;
1037     return getCppuType((uno::Reference<sheet::XAreaLink>*)0);
1038 }
1039
1040 sal_Bool SAL_CALL ScAreaLinksObj::hasElements() throw(uno::RuntimeException)
1041 {
1042     SolarMutexGuard aGuard;
1043     return ( getCount() != 0 );
1044 }
1045
1046 //------------------------------------------------------------------------
1047
1048 ScDDELinkObj::ScDDELinkObj(ScDocShell* pDocSh, const OUString& rA,
1049                             const OUString& rT, const OUString& rI) :
1050     pDocShell( pDocSh ),
1051     aAppl( rA ),
1052     aTopic( rT ),
1053     aItem( rI )
1054 {
1055     pDocShell->GetDocument()->AddUnoObject(*this);
1056 }
1057
1058 ScDDELinkObj::~ScDDELinkObj()
1059 {
1060     if (pDocShell)
1061         pDocShell->GetDocument()->RemoveUnoObject(*this);
1062 }
1063
1064 void ScDDELinkObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
1065 {
1066     //! notify if links in document are changed
1067     //  UpdateRef is not needed here
1068
1069     if ( rHint.ISA( SfxSimpleHint ) )
1070     {
1071         if ( ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
1072             pDocShell = NULL;       // pointer is invalid
1073     }
1074     else if ( rHint.ISA( ScLinkRefreshedHint ) )
1075     {
1076         const ScLinkRefreshedHint& rLH = (const ScLinkRefreshedHint&) rHint;
1077         if ( rLH.GetLinkType() == SC_LINKREFTYPE_DDE &&
1078              rLH.GetDdeAppl()  == aAppl &&
1079              rLH.GetDdeTopic() == aTopic &&
1080              rLH.GetDdeItem()  == aItem )       //! mode is ignored
1081             Refreshed_Impl();
1082     }
1083 }
1084
1085 // XNamed
1086
1087 static OUString lcl_BuildDDEName( const OUString& rAppl, const OUString& rTopic, const OUString& rItem )
1088 {
1089     //  Appl|Topic!Item (wie Excel)
1090     OUString aRet = rAppl + "|" + rTopic + "!" + rItem;
1091     return aRet;
1092 }
1093
1094 OUString SAL_CALL ScDDELinkObj::getName() throw(uno::RuntimeException)
1095 {
1096     SolarMutexGuard aGuard;
1097     return lcl_BuildDDEName( aAppl, aTopic, aItem );
1098 }
1099
1100 void SAL_CALL ScDDELinkObj::setName( const OUString& /* aName */ ) throw(uno::RuntimeException)
1101 {
1102     //  name can't be changed (formulas wouldn't find the link)
1103     throw uno::RuntimeException();
1104 }
1105
1106 // XDDELink
1107
1108 OUString SAL_CALL ScDDELinkObj::getApplication() throw(uno::RuntimeException)
1109 {
1110     SolarMutexGuard aGuard;
1111     //! Test, ob Link noch im Dokument enthalten?
1112
1113     return aAppl;
1114 }
1115
1116 OUString SAL_CALL ScDDELinkObj::getTopic() throw(uno::RuntimeException)
1117 {
1118     SolarMutexGuard aGuard;
1119     //! Test, ob Link noch im Dokument enthalten?
1120
1121     return aTopic;
1122 }
1123
1124 OUString SAL_CALL ScDDELinkObj::getItem() throw(uno::RuntimeException)
1125 {
1126     SolarMutexGuard aGuard;
1127     //! Test, ob Link noch im Dokument enthalten?
1128
1129     return aItem;
1130 }
1131
1132 // XRefreshable
1133
1134 void SAL_CALL ScDDELinkObj::refresh() throw(uno::RuntimeException)
1135 {
1136     SolarMutexGuard aGuard;
1137     if (pDocShell)
1138     {
1139         ScDocument* pDoc = pDocShell->GetDocument();
1140         (void)pDoc->UpdateDdeLink( aAppl, aTopic, aItem );
1141         //! Fehler abfragen
1142     }
1143 }
1144
1145 void SAL_CALL ScDDELinkObj::addRefreshListener(
1146                                 const uno::Reference<util::XRefreshListener >& xListener )
1147                                                 throw(uno::RuntimeException)
1148 {
1149     SolarMutexGuard aGuard;
1150     uno::Reference<util::XRefreshListener>* pObj =
1151             new uno::Reference<util::XRefreshListener>( xListener );
1152     aRefreshListeners.push_back( pObj );
1153
1154     //  hold one additional ref to keep this object alive as long as there are listeners
1155     if ( aRefreshListeners.size() == 1 )
1156         acquire();
1157 }
1158
1159 void SAL_CALL ScDDELinkObj::removeRefreshListener(
1160                                 const uno::Reference<util::XRefreshListener >& xListener )
1161                                                 throw(uno::RuntimeException)
1162 {
1163     SolarMutexGuard aGuard;
1164     size_t nCount = aRefreshListeners.size();
1165     for ( size_t n=nCount; n--; )
1166     {
1167         uno::Reference<util::XRefreshListener>& rObj = aRefreshListeners[n];
1168         if ( rObj == xListener )
1169         {
1170             aRefreshListeners.erase( aRefreshListeners.begin() + n );
1171             if ( aRefreshListeners.empty() )
1172                 release();                          // release ref for listeners
1173             break;
1174         }
1175     }
1176 }
1177
1178 // XDDELinkResults
1179
1180 uno::Sequence< uno::Sequence< uno::Any > > ScDDELinkObj::getResults(  )
1181     throw (uno::RuntimeException)
1182 {
1183     SolarMutexGuard aGuard;
1184     uno::Sequence< uno::Sequence< uno::Any > > aReturn;
1185     bool bSuccess = false;
1186
1187     if ( pDocShell )
1188     {
1189         ScDocument* pDoc = pDocShell->GetDocument();
1190         if ( pDoc )
1191         {
1192             size_t nPos = 0;
1193             if ( pDoc->FindDdeLink( aAppl, aTopic, aItem, SC_DDE_IGNOREMODE, nPos ) )
1194             {
1195                 const ScMatrix* pMatrix = pDoc->GetDdeLinkResultMatrix( nPos );
1196                 if ( pMatrix )
1197                 {
1198                     uno::Any aAny;
1199                     if ( ScRangeToSequence::FillMixedArray( aAny, pMatrix, true ) )
1200                     {
1201                         aAny >>= aReturn;
1202                     }
1203                 }
1204                 bSuccess = true;
1205             }
1206         }
1207     }
1208
1209     if ( !bSuccess )
1210     {
1211         throw uno::RuntimeException( OUString(
1212             "ScDDELinkObj::getResults: failed to get results!" ),
1213             uno::Reference< uno::XInterface >() );
1214     }
1215
1216     return aReturn;
1217 }
1218
1219 void ScDDELinkObj::setResults( const uno::Sequence< uno::Sequence< uno::Any > >& aResults )
1220     throw (uno::RuntimeException)
1221 {
1222     SolarMutexGuard aGuard;
1223     bool bSuccess = false;
1224
1225     if ( pDocShell )
1226     {
1227         ScDocument* pDoc = pDocShell->GetDocument();
1228         if ( pDoc )
1229         {
1230             size_t nPos = 0;
1231             if ( pDoc->FindDdeLink( aAppl, aTopic, aItem, SC_DDE_IGNOREMODE, nPos ) )
1232             {
1233                 uno::Any aAny;
1234                 aAny <<= aResults;
1235                 ScMatrixRef xMatrix = ScSequenceToMatrix::CreateMixedMatrix( aAny );
1236                 bSuccess = pDoc->SetDdeLinkResultMatrix( nPos, xMatrix );
1237             }
1238         }
1239     }
1240
1241     if ( !bSuccess )
1242     {
1243         throw uno::RuntimeException( OUString(
1244             "ScDDELinkObj::setResults: failed to set results!" ),
1245             uno::Reference< uno::XInterface >() );
1246     }
1247 }
1248
1249 void ScDDELinkObj::Refreshed_Impl()
1250 {
1251     lang::EventObject aEvent;
1252     aEvent.Source.set((cppu::OWeakObject*)this);
1253     for ( size_t n=0; n<aRefreshListeners.size(); n++ )
1254         aRefreshListeners[n]->refreshed( aEvent );
1255 }
1256
1257 //------------------------------------------------------------------------
1258
1259 ScDDELinksObj::ScDDELinksObj(ScDocShell* pDocSh) :
1260     pDocShell( pDocSh )
1261 {
1262     pDocShell->GetDocument()->AddUnoObject(*this);
1263 }
1264
1265 ScDDELinksObj::~ScDDELinksObj()
1266 {
1267     if (pDocShell)
1268         pDocShell->GetDocument()->RemoveUnoObject(*this);
1269 }
1270
1271 void ScDDELinksObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
1272 {
1273     //  Referenz-Update interessiert hier nicht
1274
1275     if ( rHint.ISA( SfxSimpleHint ) &&
1276             ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
1277     {
1278         pDocShell = NULL;       // ungueltig geworden
1279     }
1280 }
1281
1282 // XDDELinks
1283
1284 ScDDELinkObj* ScDDELinksObj::GetObjectByIndex_Impl(sal_Int32 nIndex)
1285 {
1286     if (pDocShell)
1287     {
1288         OUString aAppl, aTopic, aItem;
1289         if ( pDocShell->GetDocument()->GetDdeLinkData( (size_t)nIndex, aAppl, aTopic, aItem ) )
1290             return new ScDDELinkObj( pDocShell, aAppl, aTopic, aItem );
1291     }
1292     return NULL;
1293 }
1294
1295 ScDDELinkObj* ScDDELinksObj::GetObjectByName_Impl(const OUString& aName)
1296 {
1297     if (pDocShell)
1298     {
1299         OUString aNamStr(aName);
1300         OUString aAppl, aTopic, aItem;
1301
1302         ScDocument* pDoc = pDocShell->GetDocument();
1303         size_t nCount = pDoc->GetDdeLinkCount();
1304         for (size_t i=0; i<nCount; i++)
1305         {
1306             pDoc->GetDdeLinkData( i, aAppl, aTopic, aItem );
1307             if ( lcl_BuildDDEName(aAppl, aTopic, aItem) == aNamStr )
1308                 return new ScDDELinkObj( pDocShell, aAppl, aTopic, aItem );
1309         }
1310     }
1311     return NULL;
1312 }
1313
1314 // XEnumerationAccess
1315
1316 uno::Reference<container::XEnumeration> SAL_CALL ScDDELinksObj::createEnumeration()
1317                                                     throw(uno::RuntimeException)
1318 {
1319     SolarMutexGuard aGuard;
1320     return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.DDELinksEnumeration"));
1321 }
1322
1323 // XIndexAccess
1324
1325 sal_Int32 SAL_CALL ScDDELinksObj::getCount() throw(uno::RuntimeException)
1326 {
1327     SolarMutexGuard aGuard;
1328     sal_Int32 nAreaCount = 0;
1329     if (pDocShell)
1330         nAreaCount = pDocShell->GetDocument()->GetDdeLinkCount();
1331     return nAreaCount;
1332 }
1333
1334 uno::Any SAL_CALL ScDDELinksObj::getByIndex( sal_Int32 nIndex )
1335                             throw(lang::IndexOutOfBoundsException,
1336                                     lang::WrappedTargetException, uno::RuntimeException)
1337 {
1338     SolarMutexGuard aGuard;
1339     uno::Reference<sheet::XDDELink> xLink(GetObjectByIndex_Impl(nIndex));
1340     if (xLink.is())
1341         return uno::makeAny(xLink);
1342     else
1343         throw lang::IndexOutOfBoundsException();
1344 }
1345
1346 uno::Type SAL_CALL ScDDELinksObj::getElementType() throw(uno::RuntimeException)
1347 {
1348     SolarMutexGuard aGuard;
1349     return getCppuType((uno::Reference<sheet::XDDELink>*)0);
1350 }
1351
1352 sal_Bool SAL_CALL ScDDELinksObj::hasElements() throw(uno::RuntimeException)
1353 {
1354     SolarMutexGuard aGuard;
1355     return ( getCount() != 0 );
1356 }
1357
1358 uno::Any SAL_CALL ScDDELinksObj::getByName( const OUString& aName )
1359             throw(container::NoSuchElementException,
1360                     lang::WrappedTargetException, uno::RuntimeException)
1361 {
1362     SolarMutexGuard aGuard;
1363     uno::Reference<sheet::XDDELink> xLink(GetObjectByName_Impl(aName));
1364     if (xLink.is())
1365         return uno::makeAny(xLink);
1366     else
1367         throw container::NoSuchElementException();
1368 }
1369
1370 uno::Sequence<OUString> SAL_CALL ScDDELinksObj::getElementNames() throw(uno::RuntimeException)
1371 {
1372     SolarMutexGuard aGuard;
1373     if (pDocShell)
1374     {
1375         OUString aAppl, aTopic, aItem;
1376
1377         ScDocument* pDoc = pDocShell->GetDocument();
1378         size_t nCount = pDoc->GetDdeLinkCount();
1379         uno::Sequence<OUString> aSeq(nCount);
1380         OUString* pAry = aSeq.getArray();
1381
1382         for (size_t i=0; i<nCount; i++)
1383         {
1384             pDoc->GetDdeLinkData( i, aAppl, aTopic, aItem );
1385             pAry[i] = lcl_BuildDDEName(aAppl, aTopic, aItem);
1386         }
1387         return aSeq;
1388     }
1389     return uno::Sequence<OUString>();
1390 }
1391
1392 sal_Bool SAL_CALL ScDDELinksObj::hasByName( const OUString& aName )
1393                                         throw(uno::RuntimeException)
1394 {
1395     SolarMutexGuard aGuard;
1396     if (pDocShell)
1397     {
1398         OUString aNamStr(aName);
1399         OUString aAppl, aTopic, aItem;
1400
1401         ScDocument* pDoc = pDocShell->GetDocument();
1402         size_t nCount = pDoc->GetDdeLinkCount();
1403         for (size_t i=0; i<nCount; i++)
1404         {
1405             pDoc->GetDdeLinkData( i, aAppl, aTopic, aItem );
1406             if ( lcl_BuildDDEName(aAppl, aTopic, aItem) == aNamStr )
1407                 return sal_True;
1408         }
1409     }
1410     return false;
1411 }
1412
1413 // XDDELinks
1414
1415 uno::Reference< sheet::XDDELink > ScDDELinksObj::addDDELink(
1416     const OUString& aApplication, const OUString& aTopic,
1417     const OUString& aItem, ::com::sun::star::sheet::DDELinkMode nMode )
1418     throw (uno::RuntimeException)
1419 {
1420     SolarMutexGuard aGuard;
1421     uno::Reference< sheet::XDDELink > xLink;
1422
1423     if ( pDocShell )
1424     {
1425         ScDocument* pDoc = pDocShell->GetDocument();
1426         if ( pDoc )
1427         {
1428             sal_uInt8 nMod = SC_DDE_DEFAULT;
1429             switch ( nMode )
1430             {
1431                 case sheet::DDELinkMode_DEFAULT:
1432                     {
1433                         nMod = SC_DDE_DEFAULT;
1434                     }
1435                     break;
1436                 case sheet::DDELinkMode_ENGLISH:
1437                     {
1438                         nMod = SC_DDE_ENGLISH;
1439                     }
1440                     break;
1441                 case sheet::DDELinkMode_TEXT:
1442                     {
1443                         nMod = SC_DDE_TEXT;
1444                     }
1445                     break;
1446                 default:
1447                     {
1448                     }
1449                     break;
1450             }
1451
1452             if ( pDoc->CreateDdeLink( aApplication, aTopic, aItem, nMod, ScMatrixRef() ) )
1453             {
1454                 const OUString aName( lcl_BuildDDEName( aApplication, aTopic, aItem ) );
1455                 xLink.set( GetObjectByName_Impl( aName ) );
1456             }
1457         }
1458     }
1459
1460     if ( !xLink.is() )
1461     {
1462         throw uno::RuntimeException( OUString(
1463             "ScDDELinksObj::addDDELink: cannot add DDE link!" ),
1464             uno::Reference< uno::XInterface >() );
1465     }
1466
1467     return xLink;
1468 }
1469
1470 // ============================================================================
1471
1472 ScExternalSheetCacheObj::ScExternalSheetCacheObj(ScExternalRefCache::TableTypeRef pTable, size_t nIndex) :
1473     mpTable(pTable),
1474     mnIndex(nIndex)
1475 {
1476 }
1477
1478 ScExternalSheetCacheObj::~ScExternalSheetCacheObj()
1479 {
1480 }
1481
1482 void SAL_CALL ScExternalSheetCacheObj::setCellValue(sal_Int32 nCol, sal_Int32 nRow, const Any& rValue)
1483     throw (IllegalArgumentException, RuntimeException)
1484 {
1485     SolarMutexGuard aGuard;
1486     if (nRow < 0 || nCol < 0)
1487         throw IllegalArgumentException();
1488
1489     ScExternalRefCache::TokenRef pToken;
1490     double fVal = 0.0;
1491     OUString aVal;
1492     if (rValue >>= fVal)
1493         pToken.reset(new FormulaDoubleToken(fVal));
1494     else if (rValue >>= aVal)
1495         pToken.reset(new FormulaStringToken(aVal));
1496     else
1497         // unidentified value type.
1498         return;
1499
1500     mpTable->setCell(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), pToken);
1501 }
1502
1503 Any SAL_CALL ScExternalSheetCacheObj::getCellValue(sal_Int32 nCol, sal_Int32 nRow)
1504     throw (IllegalArgumentException, RuntimeException)
1505 {
1506     SolarMutexGuard aGuard;
1507     if (nRow < 0 || nCol < 0)
1508         throw IllegalArgumentException();
1509
1510     FormulaToken* pToken = mpTable->getCell(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow)).get();
1511     if (!pToken)
1512         throw IllegalArgumentException();
1513
1514     Any aValue;
1515     switch (pToken->GetType())
1516     {
1517         case svDouble:
1518         {
1519             double fVal = pToken->GetDouble();
1520             aValue <<= fVal;
1521         }
1522         break;
1523         case svString:
1524         {
1525             OUString aVal = pToken->GetString().getString();
1526             aValue <<= aVal;
1527         }
1528         break;
1529         default:
1530             throw IllegalArgumentException();
1531     }
1532     return aValue;
1533 }
1534
1535 Sequence< sal_Int32 > SAL_CALL ScExternalSheetCacheObj::getAllRows()
1536     throw (RuntimeException)
1537 {
1538     SolarMutexGuard aGuard;
1539     vector<SCROW> aRows;
1540     mpTable->getAllRows(aRows);
1541     size_t nSize = aRows.size();
1542     Sequence<sal_Int32> aRowsSeq(nSize);
1543     for (size_t i = 0; i < nSize; ++i)
1544         aRowsSeq[i] = aRows[i];
1545
1546     return aRowsSeq;
1547 }
1548
1549 Sequence< sal_Int32 > SAL_CALL ScExternalSheetCacheObj::getAllColumns(sal_Int32 nRow)
1550     throw (IllegalArgumentException, RuntimeException)
1551 {
1552     SolarMutexGuard aGuard;
1553     if (nRow < 0)
1554         throw IllegalArgumentException();
1555
1556     vector<SCCOL> aCols;
1557     mpTable->getAllCols(static_cast<SCROW>(nRow), aCols);
1558     size_t nSize = aCols.size();
1559     Sequence<sal_Int32> aColsSeq(nSize);
1560     for (size_t i = 0; i < nSize; ++i)
1561         aColsSeq[i] = aCols[i];
1562
1563     return aColsSeq;
1564 }
1565
1566 sal_Int32 SAL_CALL ScExternalSheetCacheObj::getTokenIndex()
1567         throw (RuntimeException)
1568 {
1569     return static_cast< sal_Int32 >( mnIndex );
1570 }
1571
1572 // ============================================================================
1573
1574 ScExternalDocLinkObj::ScExternalDocLinkObj(ScExternalRefManager* pRefMgr, sal_uInt16 nFileId) :
1575     mpRefMgr(pRefMgr), mnFileId(nFileId)
1576 {
1577 }
1578
1579 ScExternalDocLinkObj::~ScExternalDocLinkObj()
1580 {
1581 }
1582
1583 Reference< sheet::XExternalSheetCache > SAL_CALL ScExternalDocLinkObj::addSheetCache(
1584     const OUString& aSheetName, sal_Bool bDynamicCache )
1585         throw (RuntimeException)
1586 {
1587     SolarMutexGuard aGuard;
1588     size_t nIndex = 0;
1589     ScExternalRefCache::TableTypeRef pTable = mpRefMgr->getCacheTable(mnFileId, aSheetName, true, &nIndex);
1590     if (!bDynamicCache)
1591         // Set the whole table cached to prevent access to the source document.
1592         pTable->setWholeTableCached();
1593
1594     Reference< sheet::XExternalSheetCache > aSheetCache(new ScExternalSheetCacheObj(pTable, nIndex));
1595     return aSheetCache;
1596 }
1597
1598 Any SAL_CALL ScExternalDocLinkObj::getByName(const OUString &aName)
1599         throw (container::NoSuchElementException, lang::WrappedTargetException, RuntimeException)
1600 {
1601     SolarMutexGuard aGuard;
1602     size_t nIndex = 0;
1603     ScExternalRefCache::TableTypeRef pTable = mpRefMgr->getCacheTable(mnFileId, aName, false, &nIndex);
1604     if (!pTable)
1605         throw container::NoSuchElementException();
1606
1607     Reference< sheet::XExternalSheetCache > aSheetCache(new ScExternalSheetCacheObj(pTable, nIndex));
1608
1609     Any aAny;
1610     aAny <<= aSheetCache;
1611     return aAny;
1612 }
1613
1614 Sequence< OUString > SAL_CALL ScExternalDocLinkObj::getElementNames()
1615         throw (RuntimeException)
1616 {
1617     SolarMutexGuard aGuard;
1618     vector<OUString> aTabNames;
1619     mpRefMgr->getAllCachedTableNames(mnFileId, aTabNames);
1620
1621     // #i116940# be consistent with getByName: include only table names which have a cache already
1622     vector<OUString> aValidNames;
1623     for (vector<OUString>::iterator aIter = aTabNames.begin(); aIter != aTabNames.end(); ++aIter)
1624         if (mpRefMgr->getCacheTable(mnFileId, *aIter, false))
1625             aValidNames.push_back(*aIter);
1626
1627     size_t n = aValidNames.size();
1628     Sequence<OUString> aSeq(n);
1629     for (size_t i = 0; i < n; ++i)
1630         aSeq[i] = aValidNames[i];
1631     return aSeq;
1632 }
1633
1634 sal_Bool SAL_CALL ScExternalDocLinkObj::hasByName(const OUString &aName)
1635         throw (RuntimeException)
1636 {
1637     SolarMutexGuard aGuard;
1638
1639     // #i116940# be consistent with getByName: allow only table names which have a cache already
1640     ScExternalRefCache::TableTypeRef pTable = mpRefMgr->getCacheTable(mnFileId, aName, false);
1641     return (pTable.get() != NULL);
1642 }
1643
1644 sal_Int32 SAL_CALL ScExternalDocLinkObj::getCount()
1645         throw (RuntimeException)
1646 {
1647     SolarMutexGuard aGuard;
1648
1649     // #i116940# be consistent with getByName: count only table names which have a cache already
1650     return getElementNames().getLength();
1651 }
1652
1653 Any SAL_CALL ScExternalDocLinkObj::getByIndex(sal_Int32 nApiIndex)
1654         throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, RuntimeException)
1655 {
1656     SolarMutexGuard aGuard;
1657
1658     // #i116940# Can't use nApiIndex as index for the ref manager, because the API counts only
1659     // the entries which have a cache already. Quick solution: Use getElementNames.
1660     Sequence< OUString > aNames( getElementNames() );
1661     if (nApiIndex < 0 || nApiIndex >= aNames.getLength())
1662         throw lang::IndexOutOfBoundsException();
1663
1664     size_t nIndex = 0;
1665     ScExternalRefCache::TableTypeRef pTable = mpRefMgr->getCacheTable(mnFileId, aNames[nApiIndex], false, &nIndex);
1666     if (!pTable)
1667         throw lang::IndexOutOfBoundsException();
1668
1669     Reference< sheet::XExternalSheetCache > aSheetCache(new ScExternalSheetCacheObj(pTable, nIndex));
1670
1671     Any aAny;
1672     aAny <<= aSheetCache;
1673     return aAny;
1674 }
1675
1676 Reference< container::XEnumeration > SAL_CALL ScExternalDocLinkObj::createEnumeration()
1677         throw (RuntimeException)
1678 {
1679     SolarMutexGuard aGuard;
1680     Reference< container::XEnumeration > aRef(
1681         new ScIndexEnumeration(this, OUString(
1682             "com.sun.star.sheet.ExternalDocLink")));
1683     return aRef;
1684 }
1685
1686 uno::Type SAL_CALL ScExternalDocLinkObj::getElementType()
1687         throw (RuntimeException)
1688 {
1689     SolarMutexGuard aGuard;
1690     return getCppuType(static_cast<Reference<sheet::XExternalDocLink>*>(0));
1691 }
1692
1693 sal_Bool SAL_CALL ScExternalDocLinkObj::hasElements()
1694         throw (RuntimeException)
1695 {
1696     SolarMutexGuard aGuard;
1697
1698     // #i116940# be consistent with getByName: count only table names which have a cache already
1699     return ( getElementNames().getLength() > 0 );
1700 }
1701
1702 sal_Int32 SAL_CALL ScExternalDocLinkObj::getTokenIndex()
1703         throw (RuntimeException)
1704 {
1705     return static_cast<sal_Int32>(mnFileId);
1706 }
1707
1708 // ============================================================================
1709
1710 ScExternalDocLinksObj::ScExternalDocLinksObj(ScDocShell* pDocShell) :
1711     mpDocShell(pDocShell),
1712     mpRefMgr(pDocShell->GetDocument()->GetExternalRefManager())
1713 {
1714 }
1715
1716 ScExternalDocLinksObj::~ScExternalDocLinksObj()
1717 {
1718 }
1719
1720 Reference< sheet::XExternalDocLink > SAL_CALL ScExternalDocLinksObj::addDocLink(
1721     const OUString& aDocName )
1722         throw (RuntimeException)
1723 {
1724     SolarMutexGuard aGuard;
1725     sal_uInt16 nFileId = mpRefMgr->getExternalFileId(aDocName);
1726     Reference< sheet::XExternalDocLink > aDocLink(new ScExternalDocLinkObj(mpRefMgr, nFileId));
1727     return aDocLink;
1728 }
1729
1730 Any SAL_CALL ScExternalDocLinksObj::getByName(const OUString &aName)
1731         throw (container::NoSuchElementException, lang::WrappedTargetException, RuntimeException)
1732 {
1733     SolarMutexGuard aGuard;
1734     if (!mpRefMgr->hasExternalFile(aName))
1735         throw container::NoSuchElementException();
1736
1737     sal_uInt16 nFileId = mpRefMgr->getExternalFileId(aName);
1738     Reference< sheet::XExternalDocLink > aDocLink(new ScExternalDocLinkObj(mpRefMgr, nFileId));
1739
1740     Any aAny;
1741     aAny <<= aDocLink;
1742     return aAny;
1743 }
1744
1745 Sequence< OUString > SAL_CALL ScExternalDocLinksObj::getElementNames()
1746         throw (RuntimeException)
1747 {
1748     SolarMutexGuard aGuard;
1749     sal_uInt16 n = mpRefMgr->getExternalFileCount();
1750     Sequence<OUString> aSeq(n);
1751     for (sal_uInt16 i = 0; i < n; ++i)
1752     {
1753         const OUString* pName = mpRefMgr->getExternalFileName(i);
1754         aSeq[i] = pName ? *pName : OUString();
1755     }
1756
1757     return aSeq;
1758 }
1759
1760 sal_Bool SAL_CALL ScExternalDocLinksObj::hasByName(const OUString &aName)
1761         throw (RuntimeException)
1762 {
1763     SolarMutexGuard aGuard;
1764     return mpRefMgr->hasExternalFile(aName);
1765 }
1766
1767 sal_Int32 SAL_CALL ScExternalDocLinksObj::getCount()
1768         throw (RuntimeException)
1769 {
1770     SolarMutexGuard aGuard;
1771     return mpRefMgr->getExternalFileCount();
1772 }
1773
1774 Any SAL_CALL ScExternalDocLinksObj::getByIndex(sal_Int32 nIndex)
1775         throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, RuntimeException)
1776 {
1777     SolarMutexGuard aGuard;
1778     if (nIndex > ::std::numeric_limits<sal_uInt16>::max() || nIndex < ::std::numeric_limits<sal_uInt16>::min())
1779         throw lang::IndexOutOfBoundsException();
1780
1781     sal_uInt16 nFileId = static_cast<sal_uInt16>(nIndex);
1782
1783     if (!mpRefMgr->hasExternalFile(nFileId))
1784         throw lang::IndexOutOfBoundsException();
1785
1786     Reference< sheet::XExternalDocLink > aDocLink(new ScExternalDocLinkObj(mpRefMgr, nFileId));
1787     Any aAny;
1788     aAny <<= aDocLink;
1789     return aAny;
1790 }
1791
1792 Reference< container::XEnumeration > SAL_CALL ScExternalDocLinksObj::createEnumeration()
1793         throw (RuntimeException)
1794 {
1795     SolarMutexGuard aGuard;
1796     Reference< container::XEnumeration > aRef(
1797         new ScIndexEnumeration(this, OUString(
1798             "com.sun.star.sheet.ExternalDocLinks")));
1799     return aRef;
1800 }
1801
1802 uno::Type SAL_CALL ScExternalDocLinksObj::getElementType()
1803         throw (RuntimeException)
1804 {
1805     SolarMutexGuard aGuard;
1806     return getCppuType(static_cast<Reference<sheet::XExternalDocLinks>*>(0));
1807 }
1808
1809 sal_Bool SAL_CALL ScExternalDocLinksObj::hasElements()
1810         throw (RuntimeException)
1811 {
1812     SolarMutexGuard aGuard;
1813     return mpRefMgr->getExternalFileCount() > 0;
1814 }
1815
1816 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */