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