sc/source/ui/unoobj/linkuno.cxx

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