forms/source/misc/InterfaceContainer.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 <strings.hrc>
  22 #include <frm_resource.hxx>
  23 #include <frm_strings.hxx>
  24 #include <InterfaceContainer.hxx>
  25 #include <componenttools.hxx>
  26 #include <services.hxx>
  27
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/io/WrongFormatException.hpp>
  30 #include <com/sun/star/io/XMarkableStream.hpp>
  31 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  33 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
  34 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  35 #include <com/sun/star/lang/XComponent.hpp>
  36 #include <com/sun/star/uno/XComponentContext.hpp>
  37 #include <com/sun/star/util/XCloneable.hpp>
  38 #include <com/sun/star/form/XForm.hpp>
  39
  40 #include <comphelper/enumhelper.hxx>
  41 #include <comphelper/eventattachermgr.hxx>
  42 #include <comphelper/property.hxx>
  43 #include <comphelper/sequence.hxx>
  44 #include <comphelper/types.hxx>
  45 #include <cppuhelper/exc_hlp.hxx>
  46 #include <tools/debug.hxx>
  47 #include <tools/diagnose_ex.h>
  48 #include <sal/log.hxx>
  49
  50 #include <algorithm>
  51 #include <memory>
  52
  53
  54 #include <com/sun/star/frame/XModel.hpp>
  55 #include <com/sun/star/document/XCodeNameQuery.hpp>
  56 #include <ooo/vba/XVBAToOOEventDescGen.hpp>
  57
  58 namespace frm
  59 {
  60
  61
  62 using namespace ::com::sun::star::frame;
  63 using namespace ::com::sun::star::lang;
  64 using namespace ::com::sun::star::uno;
  65 using namespace ::com::sun::star::beans;
  66 using namespace ::com::sun::star::document;
  67 using namespace ::com::sun::star::container;
  68 using namespace ::com::sun::star::script;
  69 using namespace ::com::sun::star::io;
  70 using namespace ::com::sun::star::form;
  71 using namespace ::com::sun::star::util;
  72
  73 namespace
  74 {
  75
  76     void lcl_throwIllegalArgumentException()
  77     {
  78         throw IllegalArgumentException();
  79     }
  80 }
  81
  82 static bool
  83 lcl_hasVbaEvents( const Sequence< ScriptEventDescriptor >& sEvents  )
  84 {
  85     for ( auto const& rDesc : sEvents )
  86     {
  87         if ( rDesc.ScriptType == "VBAInterop" )
  88             return true;
  89     }
  90     return false;
  91 }
  92
  93 static Sequence< ScriptEventDescriptor >
  94 lcl_stripVbaEvents( const Sequence< ScriptEventDescriptor >& sEvents )
  95 {
  96     Sequence< ScriptEventDescriptor > sStripped( sEvents.getLength() );
  97     ScriptEventDescriptor* pStripped = sStripped.getArray();
  98
  99     sal_Int32 nCopied = 0;
 100     for ( auto const& rDesc : sEvents )
 101     {
 102         if ( rDesc.ScriptType != "VBAInterop" )
 103         {
 104             pStripped[ nCopied++ ] = rDesc;
 105         }
 106     }
 107     sStripped.realloc( nCopied );
 108     return sStripped;
 109 }
 110
 111 void OInterfaceContainer::impl_addVbEvents_nolck_nothrow(  const sal_Int32 i_nIndex )
 112 {
 113     // we are dealing with form controls
 114     try
 115     {
 116         do
 117         {
 118             Reference< XModel > xDoc( getXModel( static_cast< XContainer *> ( this ) ) );
 119             if ( !xDoc.is() )
 120                 break;
 121
 122             Reference< XMultiServiceFactory > xDocFac( xDoc, UNO_QUERY_THROW );
 123             Reference< XCodeNameQuery > xNameQuery( xDocFac->createInstance("ooo.vba.VBACodeNameProvider"), UNO_QUERY );
 124             if ( !xNameQuery.is() )
 125                 break;
 126
 127             ::osl::MutexGuard aGuard( m_rMutex );
 128             bool hasVBABindings = lcl_hasVbaEvents( m_xEventAttacher->getScriptEvents( i_nIndex ) );
 129             if ( hasVBABindings )
 130                 break;
 131
 132             Reference< XInterface > xElement( getByIndex( i_nIndex ) , UNO_QUERY_THROW );
 133             Reference< XForm > xElementAsForm( xElement, UNO_QUERY );
 134             if ( xElementAsForm.is() )
 135                 break;
 136
 137             // Try getting the code name from the container first (faster),
 138             // then from the element if that fails (slower).
 139             Reference<XInterface> xThis = static_cast<XContainer*>(this);
 140             OUString sCodeName = xNameQuery->getCodeNameForContainer(xThis);
 141             if (sCodeName.isEmpty())
 142                 sCodeName = xNameQuery->getCodeNameForObject(xElement);
 143
 144             Reference< XPropertySet > xProps( xElement, UNO_QUERY_THROW );
 145             OUString sServiceName;
 146             xProps->getPropertyValue("DefaultControl") >>= sServiceName;
 147
 148             Reference< ooo::vba::XVBAToOOEventDescGen > xDescSupplier( m_xContext->getServiceManager()->createInstanceWithContext("ooo.vba.VBAToOOEventDesc", m_xContext), UNO_QUERY_THROW );
 149             Sequence< ScriptEventDescriptor > vbaEvents = xDescSupplier->getEventDescriptions( sServiceName , sCodeName );
 150
 151             // register the vba script events
 152             m_xEventAttacher->registerScriptEvents( i_nIndex, vbaEvents );
 153         }
 154         while ( false );
 155     }
 156     catch ( const ServiceNotRegisteredException& )
 157     {
 158         // silence this, not all document types support the ooo.vba.VBACodeNameProvider service
 159     }
 160     catch( const Exception& )
 161     {
 162         DBG_UNHANDLED_EXCEPTION("forms.misc");
 163     }
 164
 165 }
 166
 167 ElementDescription::ElementDescription( )
 168 {
 169 }
 170
 171
 172 OInterfaceContainer::OInterfaceContainer(
 173                 const Reference<XComponentContext>& _rxContext,
 174                 ::osl::Mutex& _rMutex,
 175                 const Type& _rElementType)
 176     :OInterfaceContainer_BASE()
 177     ,m_rMutex(_rMutex)
 178     ,m_aContainerListeners(_rMutex)
 179     ,m_aElementType(_rElementType)
 180     ,m_xContext(_rxContext)
 181 {
 182     impl_createEventAttacher_nothrow();
 183 }
 184
 185
 186 OInterfaceContainer::OInterfaceContainer( ::osl::Mutex& _rMutex, const OInterfaceContainer& _cloneSource )
 187     :OInterfaceContainer_BASE()
 188     ,m_rMutex( _rMutex )
 189     ,m_aContainerListeners( _rMutex )
 190     ,m_aElementType( _cloneSource.m_aElementType )
 191     ,m_xContext( _cloneSource.m_xContext )
 192 {
 193     impl_createEventAttacher_nothrow();
 194 }
 195
 196 void OInterfaceContainer::clonedFrom(const OInterfaceContainer& _cloneSource)
 197 {
 198     try
 199     {
 200         const Reference< XIndexAccess > xSourceHierarchy( const_cast< OInterfaceContainer* >( &_cloneSource ) );
 201         const sal_Int32 nCount = xSourceHierarchy->getCount();
 202         for ( sal_Int32 i=0; i<nCount; ++i )
 203         {
 204             Reference< XCloneable > xCloneable( xSourceHierarchy->getByIndex( i ), UNO_QUERY_THROW );
 205             Reference< XInterface > xClone( xCloneable->createClone() );
 206             insertByIndex( i, makeAny( xClone ) );
 207         }
 208     }
 209     catch (const RuntimeException&)
 210     {
 211         throw;
 212     }
 213     catch (const Exception&)
 214     {
 215         throw WrappedTargetRuntimeException(
 216             "Could not clone the given interface hierarchy.",
 217             static_cast< XIndexContainer* >( const_cast< OInterfaceContainer* >( &_cloneSource ) ),
 218             ::cppu::getCaughtException()
 219         );
 220     }
 221 }
 222
 223 void OInterfaceContainer::impl_createEventAttacher_nothrow()
 224 {
 225     try
 226     {
 227         m_xEventAttacher.set( ::comphelper::createEventAttacherManager( m_xContext ), UNO_SET_THROW );
 228     }
 229     catch( const Exception& )
 230     {
 231         DBG_UNHANDLED_EXCEPTION("forms.misc");
 232     }
 233 }
 234
 235
 236 OInterfaceContainer::~OInterfaceContainer()
 237 {
 238 }
 239
 240
 241 void OInterfaceContainer::disposing()
 242 {
 243     // dispose all elements
 244     for (sal_Int32 i = m_aItems.size(); i > 0; --i)
 245     {
 246         Reference<XPropertySet>  xSet(m_aItems[i - 1], UNO_QUERY);
 247         if (xSet.is())
 248             xSet->removePropertyChangeListener(PROPERTY_NAME, this);
 249
 250         // revoke event knittings
 251         if ( m_xEventAttacher.is() )
 252         {
 253             m_xEventAttacher->detach( i - 1, Reference<XInterface>(xSet, UNO_QUERY) );
 254             m_xEventAttacher->removeEntry( i - 1 );
 255         }
 256
 257         Reference<XComponent>  xComponent(xSet, UNO_QUERY);
 258         if (xComponent.is())
 259             xComponent->dispose();
 260     }
 261     m_aMap.clear();
 262     m_aItems.clear();
 263
 264     css::lang::EventObject aEvt(static_cast<XContainer*>(this));
 265     m_aContainerListeners.disposeAndClear(aEvt);
 266 }
 267
 268 // XPersistObject
 269
 270 namespace
 271 {
 272
 273     void lcl_saveEvents( ::std::vector< Sequence< ScriptEventDescriptor > >& _rSave,
 274         const Reference< XEventAttacherManager >& _rxManager, const sal_Int32 _nItemCount )
 275     {
 276         OSL_ENSURE( _rxManager.is(), "lcl_saveEvents: invalid event attacher manager!" );
 277         if ( !_rxManager.is() )
 278             return;
 279
 280         // reserve the space needed
 281         _rSave.reserve( _nItemCount );
 282
 283         // copy the events
 284         for (sal_Int32 i=0; i<_nItemCount; ++i)
 285             _rSave.push_back(_rxManager->getScriptEvents( i ));
 286     }
 287
 288
 289     void lcl_restoreEvents( const ::std::vector< Sequence< ScriptEventDescriptor > >& _rSave,
 290         const Reference< XEventAttacherManager >& _rxManager )
 291     {
 292         OSL_ENSURE( _rxManager.is(), "lcl_restoreEvents: invalid event attacher manager!" );
 293         if ( !_rxManager.is() )
 294             return;
 295
 296         sal_Int32 i=0;
 297         for (auto const& elem : _rSave)
 298         {
 299             _rxManager->revokeScriptEvents( i );
 300             _rxManager->registerScriptEvents(i, elem);
 301             ++i;
 302         }
 303     }
 304 }
 305
 306
 307 void SAL_CALL OInterfaceContainer::writeEvents(const Reference<XObjectOutputStream>& _rxOutStream)
 308 {
 309     // We're writing a document in SO 5.2 format (or even from earlier versions)
 310     // -> convert the events from the new runtime format to the format of the 5.2 files
 311     // but before, remember the current script events set for our children
 312     ::std::vector< Sequence< ScriptEventDescriptor > > aSave;
 313     if ( m_xEventAttacher.is() )
 314         lcl_saveEvents( aSave, m_xEventAttacher, m_aItems.size() );
 315
 316     transformEvents();
 317
 318     try
 319     {
 320         Reference<XMarkableStream>  xMark(_rxOutStream, UNO_QUERY);
 321         sal_Int32 nMark = xMark->createMark();
 322
 323         sal_Int32 nObjLen = 0;
 324         _rxOutStream->writeLong(nObjLen);
 325
 326         Reference<XPersistObject>  xScripts(m_xEventAttacher, UNO_QUERY);
 327         if (xScripts.is())
 328             xScripts->write(_rxOutStream);
 329
 330         // Determine length
 331         nObjLen = xMark->offsetToMark(nMark) - 4;
 332         xMark->jumpToMark(nMark);
 333         _rxOutStream->writeLong(nObjLen);
 334         xMark->jumpToFurthest();
 335         xMark->deleteMark(nMark);
 336     }
 337     catch( const Exception& )
 338     {
 339         // restore the events
 340         if ( m_xEventAttacher.is() )
 341             lcl_restoreEvents( aSave, m_xEventAttacher );
 342         throw;
 343     }
 344
 345     // restore the events
 346     if ( m_xEventAttacher.is() )
 347         lcl_restoreEvents( aSave, m_xEventAttacher );
 348 }
 349
 350 namespace {
 351
 352 struct TransformEventTo52Format
 353 {
 354     void operator()( ScriptEventDescriptor& _rDescriptor )
 355     {
 356         if ( _rDescriptor.ScriptType != "StarBasic" )
 357             return;
 358
 359         // it's a starbasic macro
 360         sal_Int32 nPrefixLength = _rDescriptor.ScriptCode.indexOf( ':' );
 361         if ( 0 <= nPrefixLength )
 362         {   // the macro name does not already contain a :
 363 #ifdef DBG_UTIL
 364             const OUString sPrefix = _rDescriptor.ScriptCode.copy( 0, nPrefixLength );
 365             DBG_ASSERT( sPrefix == "document"
 366                     ||  sPrefix == "application",
 367                     "TransformEventTo52Format: invalid (unknown) prefix!" );
 368 #endif
 369             // cut the prefix
 370             _rDescriptor.ScriptCode = _rDescriptor.ScriptCode.copy( nPrefixLength + 1 );
 371         }
 372     }
 373 };
 374
 375 }
 376
 377 void OInterfaceContainer::transformEvents()
 378 {
 379     OSL_ENSURE( m_xEventAttacher.is(), "OInterfaceContainer::transformEvents: no event attacher manager!" );
 380     if ( !m_xEventAttacher.is() )
 381         return;
 382
 383     try
 384     {
 385         // loop through all our children
 386         sal_Int32 nItems = m_aItems.size();
 387         Sequence< ScriptEventDescriptor > aChildEvents;
 388
 389         for (sal_Int32 i=0; i<nItems; ++i)
 390         {
 391             // get the script events for this object
 392             aChildEvents = m_xEventAttacher->getScriptEvents( i );
 393
 394             if ( aChildEvents.hasElements() )
 395             {
 396                 // do the transformation
 397                 ::std::for_each( aChildEvents.begin(), aChildEvents.end(), TransformEventTo52Format() );
 398
 399                 // revoke the script events
 400                 m_xEventAttacher->revokeScriptEvents( i );
 401                 // and re-register them
 402                 m_xEventAttacher->registerScriptEvents( i, aChildEvents );
 403             }
 404         }
 405     }
 406     catch( const Exception& )
 407     {
 408         DBG_UNHANDLED_EXCEPTION("forms.misc");
 409     }
 410 }
 411
 412
 413 void SAL_CALL OInterfaceContainer::readEvents(const Reference<XObjectInputStream>& _rxInStream)
 414 {
 415     ::osl::MutexGuard aGuard( m_rMutex );
 416
 417     // Read scripting info
 418     Reference<XMarkableStream>  xMark(_rxInStream, UNO_QUERY);
 419     sal_Int32 nObjLen = _rxInStream->readLong();
 420     if (nObjLen)
 421     {
 422         sal_Int32 nMark = xMark->createMark();
 423         Reference<XPersistObject>  xObj(m_xEventAttacher, UNO_QUERY);
 424         if (xObj.is())
 425             xObj->read(_rxInStream);
 426         xMark->jumpToMark(nMark);
 427         _rxInStream->skipBytes(nObjLen);
 428         xMark->deleteMark(nMark);
 429     }
 430
 431     // Read Attachment
 432     if ( m_xEventAttacher.is() )
 433     {
 434         sal_Int32 i=0;
 435         for (auto const& item : m_aItems)
 436         {
 437             Reference< XInterface > xAsIFace( item, UNO_QUERY );    // important to normalize this...
 438             Reference< XPropertySet > xAsSet( xAsIFace, UNO_QUERY );
 439             m_xEventAttacher->attach( i++, xAsIFace, makeAny( xAsSet ) );
 440         }
 441     }
 442 }
 443
 444
 445 void SAL_CALL OInterfaceContainer::write( const Reference< XObjectOutputStream >& _rxOutStream )
 446 {
 447     ::osl::MutexGuard aGuard( m_rMutex );
 448     sal_Int32 nLen = m_aItems.size();
 449
 450     // Write length
 451     _rxOutStream->writeLong(nLen);
 452
 453     if (!nLen)
 454         return;
 455
 456     // 1. Version
 457     _rxOutStream->writeShort(0x0001);
 458
 459     // 2. Objects
 460     for (sal_Int32 i = 0; i < nLen; i++)
 461     {
 462         Reference<XPersistObject>  xObj(m_aItems[i], UNO_QUERY);
 463         if (xObj.is())
 464             _rxOutStream->writeObject(xObj);
 465         else
 466         {
 467             // Error
 468         }
 469     }
 470
 471     // 3. Scripts
 472     writeEvents(_rxOutStream);
 473 }
 474
 475
 476 namespace
 477 {
 478     Reference< XPersistObject > lcl_createPlaceHolder( const Reference< XComponentContext >& _rxORB )
 479     {
 480         Reference< XPersistObject > xObject( _rxORB->getServiceManager()->createInstanceWithContext(FRM_COMPONENT_HIDDENCONTROL, _rxORB), UNO_QUERY );
 481         DBG_ASSERT( xObject.is(), "lcl_createPlaceHolder: could not create a substitute for the unknown object!" );
 482         if ( xObject.is() )
 483         {
 484             // set some properties describing what we did
 485             Reference< XPropertySet > xObjProps( xObject, UNO_QUERY );
 486             if ( xObject.is()  )
 487             {
 488                 try
 489                 {
 490                     xObjProps->setPropertyValue( PROPERTY_NAME, makeAny( FRM_RES_STRING( RID_STR_CONTROL_SUBSTITUTED_NAME ) ) );
 491                     xObjProps->setPropertyValue( PROPERTY_TAG, makeAny( FRM_RES_STRING( RID_STR_CONTROL_SUBSTITUTED_EPXPLAIN ) ) );
 492                 }
 493                 catch(const Exception&)
 494                 {
 495                 }
 496             }
 497         }
 498         return xObject;
 499     }
 500 }
 501
 502
 503 void SAL_CALL OInterfaceContainer::read( const Reference< XObjectInputStream >& _rxInStream )
 504 {
 505     ::osl::MutexGuard aGuard( m_rMutex );
 506
 507     // after ::read the object is expected to be in the state it was when ::write was called, so we have
 508     // to empty ourself here
 509     while (getCount())
 510         removeByIndex(0);
 511
 512     // Only writes depending on the length
 513     sal_Int32 nLen = _rxInStream->readLong();
 514
 515     if (nLen)
 516     {
 517         // 1. Version
 518         _rxInStream->readShort();
 519
 520         // 2. Objects
 521         for (sal_Int32 i = 0; i < nLen; i++)
 522         {
 523             Reference<XPersistObject>  xObj;
 524             try
 525             {
 526                 xObj = _rxInStream->readObject();
 527             }
 528             catch(const WrongFormatException&)
 529             {
 530                 // the object could not be read
 531                 // create an object (so the readEvents below will assign the events to the right controls)
 532                 xObj = lcl_createPlaceHolder( m_xContext );
 533                 if ( !xObj.is() )
 534                     // couldn't handle it
 535                     throw;
 536             }
 537             catch(const Exception&)
 538             {
 539                 // Clear the map
 540                 while (!m_aItems.empty())
 541                     removeElementsNoEvents();
 542
 543                 // Rethrow the exception
 544                 throw;
 545             }
 546
 547             if ( xObj.is() )
 548             {
 549                 Reference< XPropertySet > xElement( xObj, UNO_QUERY );
 550                 try
 551                 {
 552                     implInsert(
 553                         m_aItems.size(),    // position
 554                         xElement,           // element to insert
 555                         false,              // no event attacher manager handling
 556                         nullptr,               // not yet approved - let implInsert do it
 557                         true                // fire the event
 558                     );
 559                 }
 560                 catch( const Exception& )
 561                 {
 562                     SAL_WARN("forms.misc", "OInterfaceContainerHelper2::read: reading succeeded, but not inserting!" );
 563                     // create a placeholder
 564                     xElement.set(lcl_createPlaceHolder( m_xContext ), css::uno::UNO_QUERY);
 565                     if ( !xElement.is() )
 566                         // couldn't handle it
 567                         throw;
 568                     // insert the placeholder
 569                     implInsert( m_aItems.size(), xElement, false, nullptr, true );
 570                 }
 571             }
 572         }
 573
 574         readEvents(_rxInStream);
 575     }
 576     else
 577     {
 578         try
 579         {
 580             m_xEventAttacher = ::comphelper::createEventAttacherManager( m_xContext );
 581             OSL_ENSURE( m_xEventAttacher.is(), "OInterfaceContainer::read: could not create an event attacher manager!" );
 582         }
 583         catch( const Exception& )
 584         {
 585             DBG_UNHANDLED_EXCEPTION("forms.misc");
 586         }
 587     }
 588 }
 589
 590 // XContainer
 591
 592 void SAL_CALL OInterfaceContainer::addContainerListener(const Reference<XContainerListener>& _rxListener)
 593 {
 594     m_aContainerListeners.addInterface(_rxListener);
 595 }
 596
 597
 598 void SAL_CALL OInterfaceContainer::removeContainerListener(const Reference<XContainerListener>& _rxListener)
 599 {
 600     m_aContainerListeners.removeInterface(_rxListener);
 601 }
 602
 603 // XEventListener
 604
 605 void SAL_CALL OInterfaceContainer::disposing(const css::lang::EventObject& _rSource)
 606 {
 607     ::osl::MutexGuard aGuard( m_rMutex );
 608
 609     Reference< XInterface > xSource( _rSource.Source, UNO_QUERY );
 610         // normalized source
 611
 612     OInterfaceArray::iterator j;
 613     for ( j = m_aItems.begin(); j != m_aItems.end(); ++j )
 614     {
 615         DBG_ASSERT( j->get() == Reference< XInterface >( *j, UNO_QUERY ).get(),
 616             "OInterfaceContainer::disposing: vector element not normalized!" );
 617
 618         if ( xSource.get() == j->get() )
 619             // found the element
 620             break;
 621     }
 622
 623     if ( m_aItems.end() == j )
 624         return;
 625
 626     m_aItems.erase(j);
 627
 628     // look up in, and erase from, m_aMap, too
 629     OInterfaceMap::iterator i = m_aMap.begin();
 630     while ( i != m_aMap.end() )
 631     {
 632         DBG_ASSERT( i->second.get() == Reference< XInterface >( i->second, UNO_QUERY ).get(),
 633             "OInterfaceContainer::disposing: map element not normalized!" );
 634
 635         if ( i->second.get() == xSource.get() )
 636         {
 637             // found it
 638             m_aMap.erase(i);
 639             break;
 640         }
 641
 642         ++i;
 643
 644         DBG_ASSERT( i != m_aMap.end(), "OInterfaceContainer::disposing: inconsistency: the element was in m_aItems, but not in m_aMap!" );
 645     }
 646 }
 647
 648 // XPropertyChangeListener
 649
 650 void OInterfaceContainer::propertyChange(const PropertyChangeEvent& evt) {
 651     if (evt.PropertyName != PROPERTY_NAME)
 652         return;
 653
 654     ::osl::MutexGuard aGuard( m_rMutex );
 655     auto range = m_aMap.equal_range(::comphelper::getString(evt.OldValue));
 656     for (auto it = range.first; it != range.second; ++it)
 657         if (it->second == evt.Source)
 658         {
 659             css::uno::Reference<css::uno::XInterface>  xCorrectType(it->second);
 660             m_aMap.erase(it);
 661             m_aMap.insert(::std::pair<const OUString, css::uno::Reference<css::uno::XInterface> >(::comphelper::getString(evt.NewValue),xCorrectType));
 662             break;
 663         }
 664 }
 665
 666 // XElementAccess
 667
 668 sal_Bool SAL_CALL OInterfaceContainer::hasElements()
 669 {
 670     return !m_aMap.empty();
 671 }
 672
 673
 674 Type SAL_CALL OInterfaceContainer::getElementType()
 675 {
 676     return m_aElementType;
 677 }
 678
 679 // XEnumerationAccess
 680
 681 Reference<XEnumeration> SAL_CALL OInterfaceContainer::createEnumeration()
 682 {
 683     ::osl::MutexGuard aGuard( m_rMutex );
 684     return new ::comphelper::OEnumerationByIndex(static_cast<XIndexAccess*>(this));
 685 }
 686
 687 // XNameAccess
 688
 689 Any SAL_CALL OInterfaceContainer::getByName( const OUString& _rName )
 690 {
 691     ::std::pair <OInterfaceMap::iterator,
 692           OInterfaceMap::iterator> aPair = m_aMap.equal_range(_rName);
 693
 694     if (aPair.first == aPair.second)
 695         throw NoSuchElementException();
 696
 697     return (*aPair.first).second->queryInterface( m_aElementType );
 698 }
 699
 700
 701 css::uno::Sequence<OUString> SAL_CALL OInterfaceContainer::getElementNames()
 702 {
 703     return comphelper::mapKeysToSequence(m_aMap);
 704 }
 705
 706
 707 sal_Bool SAL_CALL OInterfaceContainer::hasByName( const OUString& _rName )
 708 {
 709     ::std::pair <OInterfaceMap::iterator,
 710           OInterfaceMap::iterator> aPair = m_aMap.equal_range(_rName);
 711     return aPair.first != aPair.second;
 712 }
 713
 714 // XIndexAccess
 715
 716 sal_Int32 OInterfaceContainer::getCount()
 717 {
 718     return m_aItems.size();
 719 }
 720
 721
 722 Any OInterfaceContainer::getByIndex(sal_Int32 _nIndex)
 723 {
 724     if (_nIndex < 0 || (_nIndex >= static_cast<sal_Int32>(m_aItems.size())))
 725         throw IndexOutOfBoundsException();
 726
 727     return m_aItems[_nIndex]->queryInterface( m_aElementType );
 728 }
 729
 730
 731 void OInterfaceContainer::approveNewElement( const Reference< XPropertySet >& _rxObject, ElementDescription* _pElement )
 732 {
 733     // it has to be non-NULL
 734     if ( !_rxObject.is() )
 735         throw IllegalArgumentException(FRM_RES_STRING(RID_STR_NEED_NON_NULL_OBJECT), static_cast<XContainer*>(this), 1);
 736
 737     // it has to support our element type interface
 738     Any aCorrectType = _rxObject->queryInterface( m_aElementType );
 739     if ( !aCorrectType.hasValue() )
 740         lcl_throwIllegalArgumentException();
 741
 742     // it has to have a "Name" property
 743     if ( !hasProperty( PROPERTY_NAME, _rxObject ) )
 744         lcl_throwIllegalArgumentException();
 745
 746     // it has to be a child, and it must not have a parent already
 747     Reference< XChild > xChild( _rxObject, UNO_QUERY );
 748     if ( !xChild.is() || xChild->getParent().is() )
 749     {
 750         lcl_throwIllegalArgumentException();
 751     }
 752
 753     // passed all tests. cache the information we have so far
 754     DBG_ASSERT( _pElement, "OInterfaceContainer::approveNewElement: invalid event descriptor!" );
 755     if ( _pElement )
 756     {
 757         _pElement->xPropertySet = _rxObject;
 758         _pElement->xChild = xChild;
 759         _pElement->aElementTypeInterface = aCorrectType;
 760         _pElement->xInterface = Reference< XInterface >( _rxObject, UNO_QUERY );    // normalized XInterface
 761     }
 762 }
 763
 764
 765 void OInterfaceContainer::implInsert(sal_Int32 _nIndex, const Reference< XPropertySet >& _rxElement,
 766     bool _bEvents, ElementDescription* _pApprovalResult, bool _bFire )
 767 {
 768     const bool bHandleEvents = _bEvents && m_xEventAttacher.is();
 769
 770     // SYNCHRONIZED ----->
 771     ::osl::ClearableMutexGuard aGuard( m_rMutex );
 772
 773     std::unique_ptr< ElementDescription > aAutoDeleteMetaData;
 774     ElementDescription* pElementMetaData = _pApprovalResult;
 775     if ( !pElementMetaData )
 776     {   // not yet approved by the caller -> do ourself
 777         pElementMetaData = createElementMetaData();
 778         DBG_ASSERT( pElementMetaData, "OInterfaceContainer::implInsert: createElementMetaData returned nonsense!" );
 779
 780         // ensure that the meta data structure will be deleted later on
 781         aAutoDeleteMetaData.reset( pElementMetaData );
 782
 783         // will throw an exception if necessary
 784         approveNewElement( _rxElement, pElementMetaData );
 785     }
 786
 787
 788     // approveNewElement (no matter if called here or outside) has ensure that all relevant interfaces
 789     // exist
 790
 791     // set the name, and add as change listener for the name
 792     OUString sName;
 793     _rxElement->getPropertyValue(PROPERTY_NAME) >>= sName;
 794     _rxElement->addPropertyChangeListener(PROPERTY_NAME, this);
 795
 796     // insert the object into our internal structures
 797     if (_nIndex > static_cast<sal_Int32>(m_aItems.size())) // Calculate the actual index
 798     {
 799         _nIndex = m_aItems.size();
 800         m_aItems.push_back( pElementMetaData->xInterface );
 801     }
 802     else
 803         m_aItems.insert( m_aItems.begin() + _nIndex, pElementMetaData->xInterface );
 804
 805     m_aMap.insert( ::std::pair< const OUString, css::uno::Reference<css::uno::XInterface> >( sName, pElementMetaData->xInterface ) );
 806
 807     // announce ourself as parent to the new element
 808     pElementMetaData->xChild->setParent(static_cast<XContainer*>(this));
 809
 810     // handle the events
 811     if ( bHandleEvents )
 812     {
 813         m_xEventAttacher->insertEntry(_nIndex);
 814         m_xEventAttacher->attach( _nIndex, pElementMetaData->xInterface, makeAny( _rxElement ) );
 815     }
 816
 817     // notify derived classes
 818     implInserted( pElementMetaData );
 819
 820     aGuard.clear();
 821     // <----- SYNCHRONIZED
 822
 823     // insert faked VBA events?
 824     bool bHandleVbaEvents = false;
 825     try
 826     {
 827         _rxElement->getPropertyValue("GenerateVbaEvents") >>= bHandleVbaEvents;
 828     }
 829     catch( const Exception& )
 830     {
 831     }
 832     if ( bHandleVbaEvents )
 833     {
 834         Reference< XEventAttacherManager > xMgr ( pElementMetaData->xInterface, UNO_QUERY );
 835         OInterfaceContainer* pIfcMgr = xMgr.is() ? dynamic_cast<OInterfaceContainer*>(xMgr.get()) : nullptr;
 836         if (pIfcMgr)
 837         {
 838             sal_Int32 nLen = pIfcMgr->getCount();
 839             for (sal_Int32 i = 0; i < nLen; ++i)
 840             {
 841                 // add fake events to the control at index i
 842                 pIfcMgr->impl_addVbEvents_nolck_nothrow( i );
 843             }
 844         }
 845         else
 846         {
 847             // add fake events to the control at index i
 848             impl_addVbEvents_nolck_nothrow( _nIndex );
 849         }
 850     }
 851
 852     // fire the notification about the change
 853     if ( _bFire )
 854     {
 855         // notify listeners
 856         ContainerEvent aEvt;
 857         aEvt.Source   = static_cast<XContainer*>(this);
 858         aEvt.Accessor <<= _nIndex;
 859         aEvt.Element  = pElementMetaData->aElementTypeInterface;
 860
 861         m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvt );
 862     }
 863 }
 864
 865
 866 void OInterfaceContainer::removeElementsNoEvents()
 867 {
 868     OInterfaceArray::iterator i = m_aItems.begin();
 869     css::uno::Reference<css::uno::XInterface>  xElement(*i);
 870
 871     OInterfaceMap::iterator j = std::find_if(m_aMap.begin(), m_aMap.end(),
 872         [&xElement](const OInterfaceMap::value_type& rEntry) { return rEntry.second == xElement; });
 873
 874     m_aItems.erase(i);
 875     m_aMap.erase(j);
 876
 877     Reference<XPropertySet>  xSet(xElement, UNO_QUERY);
 878     if (xSet.is())
 879         xSet->removePropertyChangeListener(PROPERTY_NAME, this);
 880
 881     Reference<XChild>  xChild(xElement, UNO_QUERY);
 882     if (xChild.is())
 883         xChild->setParent(css::uno::Reference<css::uno::XInterface> ());
 884 }
 885
 886
 887 void OInterfaceContainer::implInserted( const ElementDescription* /*_pElement*/ )
 888 {
 889     // not interested in
 890 }
 891
 892
 893 void OInterfaceContainer::implRemoved( const css::uno::Reference<css::uno::XInterface>& /*_rxObject*/ )
 894 {
 895     // not interested in
 896 }
 897
 898
 899 void OInterfaceContainer::impl_replacedElement( const ContainerEvent& _rEvent, ::osl::ClearableMutexGuard& _rInstanceLock )
 900 {
 901     _rInstanceLock.clear();
 902     m_aContainerListeners.notifyEach( &XContainerListener::elementReplaced, _rEvent );
 903 }
 904
 905 // XIndexContainer
 906
 907 void SAL_CALL OInterfaceContainer::insertByIndex( sal_Int32 _nIndex, const Any& _rElement )
 908 {
 909     Reference< XPropertySet > xElement;
 910     _rElement >>= xElement;
 911     implInsert( _nIndex, xElement, true /* event handling */ , nullptr /* not yet approved */ , true /* notification */ );
 912 }
 913
 914
 915 void OInterfaceContainer::implReplaceByIndex( const sal_Int32 _nIndex, const Any& _rNewElement, ::osl::ClearableMutexGuard& _rClearBeforeNotify )
 916 {
 917     OSL_PRECOND( ( _nIndex >= 0 ) && ( _nIndex < static_cast<sal_Int32>(m_aItems.size()) ), "OInterfaceContainer::implReplaceByIndex: precondition not met (index)!" );
 918
 919     // approve the new object
 920     std::unique_ptr< ElementDescription > aElementMetaData( createElementMetaData() );
 921     DBG_ASSERT(aElementMetaData,
 922                "OInterfaceContainer::implReplaceByIndex: createElementMetaData returned nonsense!");
 923     {
 924         Reference< XPropertySet > xElementProps;
 925         _rNewElement >>= xElementProps;
 926         approveNewElement( xElementProps, aElementMetaData.get() );
 927     }
 928
 929     // get the old element
 930     css::uno::Reference<css::uno::XInterface>  xOldElement( m_aItems[ _nIndex ] );
 931     DBG_ASSERT( xOldElement.get() == Reference< XInterface >( xOldElement, UNO_QUERY ).get(),
 932         "OInterfaceContainer::implReplaceByIndex: elements should be held normalized!" );
 933
 934     // locate the old element in the map
 935     OInterfaceMap::iterator j = std::find_if(m_aMap.begin(), m_aMap.end(),
 936         [&xOldElement](const OInterfaceMap::value_type& rEntry) { return rEntry.second.get() == xOldElement.get(); });
 937
 938     // remove event knittings
 939     if ( m_xEventAttacher.is() )
 940     {
 941         css::uno::Reference<css::uno::XInterface> xNormalized( xOldElement, UNO_QUERY );
 942         m_xEventAttacher->detach( _nIndex, xNormalized );
 943         m_xEventAttacher->removeEntry( _nIndex );
 944     }
 945
 946     // don't listen for property changes anymore
 947     Reference<XPropertySet>  xSet( xOldElement, UNO_QUERY );
 948     if (xSet.is())
 949         xSet->removePropertyChangeListener(PROPERTY_NAME, this);
 950
 951     // give the old element a new (void) parent
 952     Reference<XChild>  xChild(xOldElement, UNO_QUERY);
 953     if (xChild.is())
 954         xChild->setParent(css::uno::Reference<css::uno::XInterface> ());
 955
 956     // remove the old one
 957     m_aMap.erase(j);
 958
 959     // examine the new element
 960     OUString sName;
 961     DBG_ASSERT(aElementMetaData->xPropertySet.is(),
 962                "OInterfaceContainer::implReplaceByIndex: what did approveNewElement do?");
 963
 964     aElementMetaData->xPropertySet->getPropertyValue(PROPERTY_NAME) >>= sName;
 965     aElementMetaData->xPropertySet->addPropertyChangeListener(PROPERTY_NAME, this);
 966
 967     // insert the new one
 968     m_aMap.insert(::std::pair<const OUString, css::uno::Reference<css::uno::XInterface>>(
 969         sName, aElementMetaData->xInterface));
 970     m_aItems[_nIndex] = aElementMetaData->xInterface;
 971
 972     aElementMetaData->xChild->setParent(static_cast<XContainer*>(this));
 973
 974     if ( m_xEventAttacher.is() )
 975     {
 976         m_xEventAttacher->insertEntry( _nIndex );
 977         m_xEventAttacher->attach(_nIndex, aElementMetaData->xInterface,
 978                                  makeAny(aElementMetaData->xPropertySet));
 979     }
 980
 981     ContainerEvent aReplaceEvent;
 982     aReplaceEvent.Source   = static_cast< XContainer* >( this );
 983     aReplaceEvent.Accessor <<= _nIndex;
 984     aReplaceEvent.Element = aElementMetaData->xInterface->queryInterface(m_aElementType);
 985     aReplaceEvent.ReplacedElement = xOldElement->queryInterface( m_aElementType );
 986
 987     impl_replacedElement( aReplaceEvent, _rClearBeforeNotify );
 988 }
 989
 990
 991 void OInterfaceContainer::implCheckIndex( const sal_Int32 _nIndex )
 992 {
 993     if (_nIndex < 0 || _nIndex >= static_cast<sal_Int32>(m_aItems.size()))
 994         throw IndexOutOfBoundsException();
 995 }
 996
 997
 998 void SAL_CALL OInterfaceContainer::replaceByIndex(sal_Int32 _nIndex, const Any& Element)
 999 {
1000     ::osl::ClearableMutexGuard aGuard( m_rMutex );
1001     // check the index
1002     implCheckIndex( _nIndex );
1003     // do the replace
1004     implReplaceByIndex( _nIndex, Element, aGuard );
1005 }
1006
1007
1008 void OInterfaceContainer::implRemoveByIndex( const sal_Int32 _nIndex, ::osl::ClearableMutexGuard& _rClearBeforeNotify )
1009 {
1010     OSL_PRECOND( ( _nIndex >= 0 ) && ( _nIndex < static_cast<sal_Int32>(m_aItems.size()) ), "OInterfaceContainer::implRemoveByIndex: precondition not met (index)!" );
1011
1012     OInterfaceArray::iterator i = m_aItems.begin() + _nIndex;
1013     css::uno::Reference<css::uno::XInterface>  xElement(*i);
1014
1015     OInterfaceMap::iterator j = std::find_if(m_aMap.begin(), m_aMap.end(),
1016         [&xElement](const OInterfaceMap::value_type& rEntry) { return rEntry.second == xElement; });
1017
1018     m_aItems.erase(i);
1019     m_aMap.erase(j);
1020
1021     // remove event knittings
1022     if ( m_xEventAttacher.is() )
1023     {
1024         css::uno::Reference<css::uno::XInterface> xNormalized( xElement, UNO_QUERY );
1025         m_xEventAttacher->detach( _nIndex, xNormalized );
1026         m_xEventAttacher->removeEntry( _nIndex );
1027     }
1028
1029     Reference<XPropertySet>  xSet(xElement, UNO_QUERY);
1030     if (xSet.is())
1031         xSet->removePropertyChangeListener(PROPERTY_NAME, this);
1032
1033     Reference<XChild>  xChild(xElement, UNO_QUERY);
1034     if (xChild.is())
1035         xChild->setParent(css::uno::Reference<css::uno::XInterface> ());
1036
1037     // notify derived classes
1038     implRemoved(xElement);
1039
1040     // notify listeners
1041     ContainerEvent aEvt;
1042     aEvt.Source     = static_cast<XContainer*>(this);
1043     aEvt.Element    = xElement->queryInterface( m_aElementType );
1044     aEvt.Accessor   <<= _nIndex;
1045
1046     _rClearBeforeNotify.clear();
1047     m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, aEvt );
1048 }
1049
1050
1051 void SAL_CALL OInterfaceContainer::removeByIndex(sal_Int32 _nIndex)
1052 {
1053     ::osl::ClearableMutexGuard aGuard( m_rMutex );
1054     // check the index
1055     implCheckIndex( _nIndex );
1056     // do the removal
1057     implRemoveByIndex( _nIndex, aGuard );
1058 }
1059
1060
1061 ElementDescription* OInterfaceContainer::createElementMetaData( )
1062 {
1063     return new ElementDescription;
1064 }
1065
1066
1067 void SAL_CALL OInterfaceContainer::insertByName(const OUString& _rName, const Any& _rElement)
1068 {
1069     Reference< XPropertySet > xElementProps;
1070
1071     std::unique_ptr< ElementDescription > aElementMetaData( createElementMetaData() );
1072     DBG_ASSERT(aElementMetaData,
1073                "OInterfaceContainer::insertByName: createElementMetaData returned nonsense!");
1074
1075     // ensure the correct name of the element
1076     try
1077     {
1078         _rElement >>= xElementProps;
1079         approveNewElement( xElementProps, aElementMetaData.get() );
1080
1081         xElementProps->setPropertyValue( PROPERTY_NAME, makeAny( _rName ) );
1082     }
1083     catch( const IllegalArgumentException& )
1084     {
1085         throw;  // allowed to leave
1086     }
1087     catch( const ElementExistException& )
1088     {
1089         throw;  // allowed to leave
1090     }
1091     catch( const Exception& )
1092     {
1093         TOOLS_WARN_EXCEPTION("forms.misc", "OInterfaceContainer::insertByName" );
1094     }
1095     implInsert( m_aItems.size(), xElementProps, true, aElementMetaData.get(), true );
1096 }
1097
1098
1099 void SAL_CALL OInterfaceContainer::replaceByName(const OUString& Name, const Any& Element)
1100 {
1101     ::osl::ClearableMutexGuard aGuard( m_rMutex );
1102     ::std::pair <OInterfaceMap::iterator,
1103           OInterfaceMap::iterator> aPair = m_aMap.equal_range(Name);
1104     if (aPair.first == aPair.second)
1105         throw NoSuchElementException();
1106
1107     if (Element.getValueType().getTypeClass() != TypeClass_INTERFACE)
1108         lcl_throwIllegalArgumentException();
1109
1110     Reference<XPropertySet> xSet;
1111     Element >>= xSet;
1112     if (xSet.is())
1113     {
1114         if (!hasProperty(PROPERTY_NAME, xSet))
1115             lcl_throwIllegalArgumentException();
1116
1117         xSet->setPropertyValue(PROPERTY_NAME, makeAny(Name));
1118     }
1119
1120     // determine the element pos
1121     sal_Int32 nPos = ::std::find(m_aItems.begin(), m_aItems.end(), (*aPair.first).second) - m_aItems.begin();
1122
1123     implReplaceByIndex( nPos, Element, aGuard );
1124 }
1125
1126
1127 void SAL_CALL OInterfaceContainer::removeByName(const OUString& Name)
1128 {
1129     ::osl::MutexGuard aGuard( m_rMutex );
1130     ::std::pair <OInterfaceMap::iterator,
1131           OInterfaceMap::iterator> aPair = m_aMap.equal_range(Name);
1132     if (aPair.first == aPair.second)
1133         throw NoSuchElementException();
1134
1135     sal_Int32 nPos = ::std::find(m_aItems.begin(), m_aItems.end(), (*aPair.first).second) - m_aItems.begin();
1136     removeByIndex(nPos);
1137 }
1138
1139
1140 // XEventAttacherManager
1141
1142 void SAL_CALL OInterfaceContainer::registerScriptEvent( sal_Int32 nIndex, const ScriptEventDescriptor& aScriptEvent )
1143 {
1144     ::osl::ClearableMutexGuard aGuard( m_rMutex );
1145     if ( m_xEventAttacher.is() )
1146     {
1147         m_xEventAttacher->registerScriptEvent( nIndex, aScriptEvent );
1148         aGuard.clear();
1149         impl_addVbEvents_nolck_nothrow( nIndex ); // add fake vba events
1150     }
1151 }
1152
1153
1154 void SAL_CALL OInterfaceContainer::registerScriptEvents( sal_Int32 nIndex, const Sequence< ScriptEventDescriptor >& aScriptEvents )
1155 {
1156     ::osl::ClearableMutexGuard aGuard( m_rMutex );
1157     if ( m_xEventAttacher.is() )
1158     {
1159         m_xEventAttacher->registerScriptEvents( nIndex, aScriptEvents );
1160         aGuard.clear();
1161         impl_addVbEvents_nolck_nothrow( nIndex ); // add fake vba events
1162     }
1163 }
1164
1165
1166 void SAL_CALL OInterfaceContainer::revokeScriptEvent( sal_Int32 nIndex, const OUString& aListenerType, const OUString& aEventMethod, const OUString& aRemoveListenerParam )
1167 {
1168     if ( m_xEventAttacher.is() )
1169         m_xEventAttacher->revokeScriptEvent( nIndex, aListenerType, aEventMethod, aRemoveListenerParam );
1170 }
1171
1172
1173 void SAL_CALL OInterfaceContainer::revokeScriptEvents( sal_Int32 nIndex )
1174 {
1175     if ( m_xEventAttacher.is() )
1176         m_xEventAttacher->revokeScriptEvents( nIndex );
1177 }
1178
1179
1180 void SAL_CALL OInterfaceContainer::insertEntry( sal_Int32 nIndex )
1181 {
1182     if ( m_xEventAttacher.is() )
1183         m_xEventAttacher->insertEntry( nIndex );
1184 }
1185
1186
1187 void SAL_CALL OInterfaceContainer::removeEntry( sal_Int32 nIndex )
1188 {
1189     if ( m_xEventAttacher.is() )
1190         m_xEventAttacher->removeEntry( nIndex );
1191 }
1192
1193
1194 Sequence< ScriptEventDescriptor > SAL_CALL OInterfaceContainer::getScriptEvents( sal_Int32 nIndex )
1195 {
1196     Sequence< ScriptEventDescriptor > aReturn;
1197     if ( m_xEventAttacher.is() )
1198     {
1199         aReturn = m_xEventAttacher->getScriptEvents( nIndex );
1200         if ( lcl_hasVbaEvents( aReturn ) )
1201         {
1202             aReturn = lcl_stripVbaEvents( aReturn );
1203         }
1204     }
1205     return aReturn;
1206 }
1207
1208
1209 void SAL_CALL OInterfaceContainer::attach( sal_Int32 nIndex, const Reference< XInterface >& xObject, const Any& aHelper )
1210 {
1211     if ( m_xEventAttacher.is() )
1212         m_xEventAttacher->attach( nIndex, xObject, aHelper );
1213 }
1214
1215
1216 void SAL_CALL OInterfaceContainer::detach( sal_Int32 nIndex, const Reference< XInterface >& xObject )
1217 {
1218     if ( m_xEventAttacher.is() )
1219         m_xEventAttacher->detach( nIndex, xObject );
1220 }
1221
1222
1223 void SAL_CALL OInterfaceContainer::addScriptListener( const Reference< XScriptListener >& xListener )
1224 {
1225     if ( m_xEventAttacher.is() )
1226         m_xEventAttacher->addScriptListener( xListener );
1227 }
1228
1229
1230 void SAL_CALL OInterfaceContainer::removeScriptListener( const Reference< XScriptListener >& xListener )
1231 {
1232     if ( m_xEventAttacher.is() )
1233         m_xEventAttacher->removeScriptListener( xListener );
1234 }
1235
1236
1237 //= OFormComponents
1238
1239
1240 Any SAL_CALL OFormComponents::queryAggregation(const Type& _rType)
1241 {
1242     Any aReturn = OFormComponents_BASE::queryInterface(_rType);
1243     if (!aReturn.hasValue())
1244     {
1245         aReturn = OInterfaceContainer::queryInterface(_rType);
1246
1247         if (!aReturn.hasValue())
1248             aReturn =  ::cppu::OComponentHelper::queryAggregation(_rType);
1249     }
1250
1251     return aReturn;
1252 }
1253
1254
1255 Sequence<Type> SAL_CALL OFormComponents::getTypes()
1256 {
1257     return ::comphelper::concatSequences(OInterfaceContainer::getTypes(),  ::cppu::OComponentHelper::getTypes(), OFormComponents_BASE::getTypes());
1258 }
1259
1260
1261 OFormComponents::OFormComponents(const Reference<XComponentContext>& _rxFactory)
1262     : ::cppu::OComponentHelper( m_aMutex )
1263     ,OInterfaceContainer( _rxFactory, m_aMutex, cppu::UnoType<XFormComponent>::get() )
1264     ,OFormComponents_BASE()
1265 {
1266 }
1267
1268
1269 OFormComponents::OFormComponents( const OFormComponents& _cloneSource )
1270     : ::cppu::OComponentHelper( m_aMutex )
1271     ,OInterfaceContainer( m_aMutex, _cloneSource )
1272     ,OFormComponents_BASE()
1273 {
1274 }
1275
1276
1277 OFormComponents::~OFormComponents()
1278 {
1279     if (! ::cppu::OComponentHelper::rBHelper.bDisposed)
1280     {
1281         acquire();
1282         dispose();
1283     }
1284 }
1285
1286 // OComponentHelper
1287
1288 void OFormComponents::disposing()
1289 {
1290     OInterfaceContainer::disposing();
1291     ::cppu::OComponentHelper::disposing();
1292     m_xParent = nullptr;
1293 }
1294
1295 //XChild
1296
1297 void OFormComponents::setParent(const css::uno::Reference<css::uno::XInterface>& Parent)
1298 {
1299     ::osl::MutexGuard aGuard( m_aMutex );
1300     m_xParent = Parent;
1301 }
1302
1303
1304 css::uno::Reference<css::uno::XInterface> OFormComponents::getParent()
1305 {
1306     return m_xParent;
1307 }
1308
1309
1310 }   // namespace frm
1311
1312
1313 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */