sfx2/source/appl/linksrc.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
  21 #include <sfx2/linksrc.hxx>
  22 #include <sfx2/lnkbase.hxx>
  23 #include <com/sun/star/uno/Any.hxx>
  24 #include <com/sun/star/uno/Sequence.hxx>
  25
  26 #include <vcl/timer.hxx>
  27 #include <vector>
  28 #include <algorithm>
  29
  30
  31 using namespace ::com::sun::star::uno;
  32
  33 namespace sfx2
  34 {
  35
  36 TYPEINIT0( SvLinkSource )
  37
  38 class SvLinkSourceTimer : public Timer
  39 {
  40     SvLinkSource *  pOwner;
  41     virtual void    Timeout();
  42 public:
  43             SvLinkSourceTimer( SvLinkSource * pOwn );
  44 };
  45
  46 SvLinkSourceTimer::SvLinkSourceTimer( SvLinkSource * pOwn )
  47     : pOwner( pOwn )
  48 {
  49 }
  50
  51 void SvLinkSourceTimer::Timeout()
  52 {
  53     // Secure against beeing destroyed in Handler
  54     SvLinkSourceRef aAdv( pOwner );
  55     pOwner->SendDataChanged();
  56 }
  57
  58 static void StartTimer( SvLinkSourceTimer ** ppTimer, SvLinkSource * pOwner,
  59                         sal_uIntPtr nTimeout )
  60 {
  61     if( !*ppTimer )
  62     {
  63         *ppTimer = new SvLinkSourceTimer( pOwner );
  64         (*ppTimer)->SetTimeout( nTimeout );
  65         (*ppTimer)->Start();
  66     }
  67 }
  68
  69
  70 struct SvLinkSource_Entry_Impl
  71 {
  72     SvBaseLinkRef       xSink;
  73     OUString            aDataMimeType;
  74     sal_uInt16          nAdviseModes;
  75     sal_Bool            bIsDataSink;
  76
  77     SvLinkSource_Entry_Impl( SvBaseLink* pLink, const OUString& rMimeType,
  78                                 sal_uInt16 nAdvMode )
  79         : xSink( pLink ), aDataMimeType( rMimeType ),
  80             nAdviseModes( nAdvMode ), bIsDataSink( sal_True )
  81     {}
  82
  83     SvLinkSource_Entry_Impl( SvBaseLink* pLink )
  84         : xSink( pLink ), nAdviseModes( 0 ), bIsDataSink( sal_False )
  85     {}
  86
  87     ~SvLinkSource_Entry_Impl();
  88 };
  89
  90 SvLinkSource_Entry_Impl::~SvLinkSource_Entry_Impl()
  91 {
  92 }
  93
  94 class SvLinkSource_Array_Impl : public std::vector<SvLinkSource_Entry_Impl*>
  95 {
  96 public:
  97     void DeleteAndDestroy(SvLinkSource_Entry_Impl* p)
  98     {
  99         iterator it = std::find(begin(), end(), p);
 100         if (it != end())
 101         {
 102             erase(it);
 103             delete p;
 104         }
 105     }
 106
 107     ~SvLinkSource_Array_Impl()
 108     {
 109         for(const_iterator it = begin(); it != end(); ++it)
 110             delete *it;
 111     }
 112 };
 113
 114 class SvLinkSource_EntryIter_Impl
 115 {
 116     SvLinkSource_Array_Impl aArr;
 117     const SvLinkSource_Array_Impl& rOrigArr;
 118     sal_uInt16 nPos;
 119 public:
 120     SvLinkSource_EntryIter_Impl( const SvLinkSource_Array_Impl& rArr );
 121     ~SvLinkSource_EntryIter_Impl();
 122     SvLinkSource_Entry_Impl* Curr()
 123                             { return nPos < aArr.size() ? aArr[ nPos ] : 0; }
 124     SvLinkSource_Entry_Impl* Next();
 125     sal_Bool IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry );
 126 };
 127
 128 SvLinkSource_EntryIter_Impl::SvLinkSource_EntryIter_Impl(
 129         const SvLinkSource_Array_Impl& rArr )
 130     : aArr( rArr ), rOrigArr( rArr ), nPos( 0 )
 131 {
 132 }
 133 SvLinkSource_EntryIter_Impl::~SvLinkSource_EntryIter_Impl()
 134 {
 135     aArr.clear();
 136 }
 137
 138 sal_Bool SvLinkSource_EntryIter_Impl::IsValidCurrValue( SvLinkSource_Entry_Impl* pEntry )
 139 {
 140     return ( nPos < aArr.size() && aArr[nPos] == pEntry
 141        && std::find( rOrigArr.begin(), rOrigArr.end(), pEntry ) != rOrigArr.end() );
 142 }
 143
 144 SvLinkSource_Entry_Impl* SvLinkSource_EntryIter_Impl::Next()
 145 {
 146     SvLinkSource_Entry_Impl* pRet = 0;
 147     if( nPos + 1 < (sal_uInt16)aArr.size() )
 148     {
 149         ++nPos;
 150         if( rOrigArr.size() == aArr.size() &&
 151             rOrigArr[ nPos ] == aArr[ nPos ] )
 152             pRet = aArr[ nPos ];
 153         else
 154         {
 155             // then we must search the current (or the next) in the orig
 156             do {
 157                 pRet = aArr[ nPos ];
 158                 if( std::find(rOrigArr.begin(), rOrigArr.end(), pRet ) != rOrigArr.end() )
 159                     break;
 160                 pRet = 0;
 161                 ++nPos;
 162             } while( nPos < aArr.size() );
 163
 164             if( nPos >= aArr.size() )
 165                 pRet = 0;
 166         }
 167     }
 168     return pRet;
 169 }
 170
 171 struct SvLinkSource_Impl
 172 {
 173     SvLinkSource_Array_Impl aArr;
 174     OUString                aDataMimeType;
 175     SvLinkSourceTimer *     pTimer;
 176     sal_uIntPtr             nTimeout;
 177     css::uno::Reference<css::io::XInputStream>
 178                            m_xInputStreamToLoadFrom;
 179     sal_Bool               m_bIsReadOnly;
 180
 181     SvLinkSource_Impl() : pTimer( 0 ), nTimeout( 3000 ) {}
 182     ~SvLinkSource_Impl();
 183
 184     void Closed();
 185 };
 186
 187 SvLinkSource_Impl::~SvLinkSource_Impl()
 188 {
 189     delete pTimer;
 190 }
 191
 192 SvLinkSource::SvLinkSource()
 193      : pImpl( new SvLinkSource_Impl )
 194 {
 195 }
 196
 197 SvLinkSource::~SvLinkSource()
 198 {
 199     delete pImpl;
 200 }
 201
 202
 203 SvLinkSource::StreamToLoadFrom SvLinkSource::getStreamToLoadFrom()
 204 {
 205     return StreamToLoadFrom(
 206         pImpl->m_xInputStreamToLoadFrom,
 207         pImpl->m_bIsReadOnly);
 208 }
 209
 210 void SvLinkSource::setStreamToLoadFrom(const com::sun::star::uno::Reference<com::sun::star::io::XInputStream>& xInputStream,sal_Bool bIsReadOnly )
 211 {
 212     pImpl->m_xInputStreamToLoadFrom = xInputStream;
 213     pImpl->m_bIsReadOnly = bIsReadOnly;
 214 }
 215
 216 // #i88291#
 217 void SvLinkSource::clearStreamToLoadFrom()
 218 {
 219     pImpl->m_xInputStreamToLoadFrom.clear();
 220 }
 221
 222 void  SvLinkSource::Closed()
 223 {
 224     SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 225     for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 226         if( !p->bIsDataSink )
 227             p->xSink->Closed();
 228 }
 229
 230 sal_uIntPtr SvLinkSource::GetUpdateTimeout() const
 231 {
 232     return pImpl->nTimeout;
 233 }
 234
 235 void SvLinkSource::SetUpdateTimeout( sal_uIntPtr nTimeout )
 236 {
 237     pImpl->nTimeout = nTimeout;
 238     if( pImpl->pTimer )
 239         pImpl->pTimer->SetTimeout( nTimeout );
 240 }
 241
 242 void SvLinkSource::SendDataChanged()
 243 {
 244     SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 245     for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 246     {
 247         if( p->bIsDataSink )
 248         {
 249             OUString sDataMimeType( pImpl->aDataMimeType );
 250             if( sDataMimeType.isEmpty() )
 251                 sDataMimeType = p->aDataMimeType;
 252
 253             Any aVal;
 254             if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
 255                 GetData( aVal, sDataMimeType, sal_True ) )
 256             {
 257                 p->xSink->DataChanged( sDataMimeType, aVal );
 258
 259                 if ( !aIter.IsValidCurrValue( p ) )
 260                     continue;
 261
 262                 if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 263                 {
 264                     pImpl->aArr.DeleteAndDestroy( p );
 265                 }
 266
 267             }
 268         }
 269     }
 270     if( pImpl->pTimer )
 271     {
 272         delete pImpl->pTimer;
 273         pImpl->pTimer = NULL;
 274     }
 275     pImpl->aDataMimeType = "";
 276 }
 277
 278 void SvLinkSource::NotifyDataChanged()
 279 {
 280     if( pImpl->nTimeout )
 281         StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // New timeout
 282     else
 283     {
 284         SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 285         for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 286             if( p->bIsDataSink )
 287             {
 288                 Any aVal;
 289                 if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
 290                     GetData( aVal, p->aDataMimeType, sal_True ) )
 291                 {
 292                     p->xSink->DataChanged( p->aDataMimeType, aVal );
 293
 294                     if ( !aIter.IsValidCurrValue( p ) )
 295                         continue;
 296
 297                     if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 298                     {
 299                         pImpl->aArr.DeleteAndDestroy( p );
 300                     }
 301                 }
 302             }
 303
 304         if( pImpl->pTimer )
 305         {
 306             delete pImpl->pTimer;
 307             pImpl->pTimer = NULL;
 308         }
 309     }
 310 }
 311
 312 // notify the sink, the mime type is not
 313 // a selection criterion
 314 void SvLinkSource::DataChanged( const OUString & rMimeType,
 315                                 const ::com::sun::star::uno::Any & rVal )
 316 {
 317     if( pImpl->nTimeout && !rVal.hasValue() )
 318     {   // only when no data was included
 319         // fire all data to the sink, independent of the requested format
 320         pImpl->aDataMimeType = rMimeType;
 321         StartTimer( &pImpl->pTimer, this, pImpl->nTimeout ); // New timeout
 322     }
 323     else
 324     {
 325         SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 326         for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 327         {
 328             if( p->bIsDataSink )
 329             {
 330                 p->xSink->DataChanged( rMimeType, rVal );
 331
 332                 if ( !aIter.IsValidCurrValue( p ) )
 333                     continue;
 334
 335                 if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
 336                 {
 337                     pImpl->aArr.DeleteAndDestroy( p );
 338                 }
 339             }
 340         }
 341
 342         if( pImpl->pTimer )
 343         {
 344             delete pImpl->pTimer;
 345             pImpl->pTimer = NULL;
 346         }
 347     }
 348 }
 349
 350
 351 // only one link is correct
 352 void SvLinkSource::AddDataAdvise( SvBaseLink * pLink, const OUString& rMimeType,
 353                                     sal_uInt16 nAdviseModes )
 354 {
 355     SvLinkSource_Entry_Impl* pNew = new SvLinkSource_Entry_Impl(
 356                     pLink, rMimeType, nAdviseModes );
 357     pImpl->aArr.push_back( pNew );
 358 }
 359
 360 void SvLinkSource::RemoveAllDataAdvise( SvBaseLink * pLink )
 361 {
 362     SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 363     for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 364         if( p->bIsDataSink && &p->xSink == pLink )
 365         {
 366             pImpl->aArr.DeleteAndDestroy( p );
 367         }
 368 }
 369
 370 // only one link is correct
 371 void SvLinkSource::AddConnectAdvise( SvBaseLink * pLink )
 372 {
 373     SvLinkSource_Entry_Impl* pNew = new SvLinkSource_Entry_Impl( pLink );
 374     pImpl->aArr.push_back( pNew );
 375 }
 376
 377 void SvLinkSource::RemoveConnectAdvise( SvBaseLink * pLink )
 378 {
 379     SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
 380     for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
 381         if( !p->bIsDataSink && &p->xSink == pLink )
 382         {
 383             pImpl->aArr.DeleteAndDestroy( p );
 384         }
 385 }
 386
 387 sal_Bool SvLinkSource::HasDataLinks( const SvBaseLink* pLink ) const
 388 {
 389     sal_Bool bRet = sal_False;
 390     const SvLinkSource_Entry_Impl* p;
 391     for( sal_uInt16 n = 0, nEnd = pImpl->aArr.size(); n < nEnd; ++n )
 392         if( ( p = pImpl->aArr[ n ] )->bIsDataSink &&
 393             ( !pLink || &p->xSink == pLink ) )
 394         {
 395             bRet = sal_True;
 396             break;
 397         }
 398     return bRet;
 399 }
 400
 401 // sal_True => waitinmg for data
 402 sal_Bool SvLinkSource::IsPending() const
 403 {
 404     return sal_False;
 405 }
 406
 407 // sal_True => data complete loaded
 408 sal_Bool SvLinkSource::IsDataComplete() const
 409 {
 410     return sal_True;
 411 }
 412
 413 sal_Bool SvLinkSource::Connect( SvBaseLink* )
 414 {
 415     return sal_True;
 416 }
 417
 418 sal_Bool SvLinkSource::GetData( ::com::sun::star::uno::Any &, const OUString &, sal_Bool )
 419 {
 420     return sal_False;
 421 }
 422
 423 void SvLinkSource::Edit( Window *, SvBaseLink *, const Link& )
 424 {
 425 }
 426
 427 }
 428
 429 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */