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