toolkit/source/controls/unocontrolcontainer.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 #include <com/sun/star/awt/XVclContainerPeer.hpp>
  21 #include <com/sun/star/beans/XPropertyChangeListener.hpp>
  22
  23 #include <cppuhelper/typeprovider.hxx>
  24 #include <cppuhelper/implbase1.hxx>
  25 #include <rtl/uuid.h>
  26
  27 #include <toolkit/controls/unocontrolcontainer.hxx>
  28 #include <toolkit/helper/property.hxx>
  29 #include <toolkit/helper/servicenames.hxx>
  30 #include <comphelper/sequence.hxx>
  31
  32 #include <tools/debug.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/window.hxx>
  35
  36 #include <limits>
  37 #include <map>
  38 #include <boost/shared_ptr.hpp>
  39 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
  40
  41 using namespace ::com::sun::star;
  42
  43 //  ----------------------------------------------------
  44 //  class UnoControlHolder
  45 //  ----------------------------------------------------
  46 struct UnoControlHolder
  47 {
  48     uno::Reference< awt::XControl > mxControl;
  49     OUString                 msName;
  50
  51 public:
  52     UnoControlHolder( const OUString& rName, const uno::Reference< awt::XControl > & rControl )
  53     :   mxControl( rControl ),
  54         msName( rName )
  55     {
  56     }
  57
  58     inline const OUString&                   getName() const { return msName; }
  59     inline const uno::Reference< awt::XControl >&   getControl() const { return mxControl; }
  60 };
  61
  62 class UnoControlHolderList
  63 {
  64 public:
  65     typedef sal_Int32                                       ControlIdentifier;
  66 private:
  67     typedef ::boost::shared_ptr< UnoControlHolder >         ControlInfo;
  68     typedef ::std::map< ControlIdentifier, ControlInfo >    ControlMap;
  69
  70 private:
  71     ControlMap  maControls;
  72
  73 public:
  74     UnoControlHolderList();
  75     ~UnoControlHolderList();
  76
  77     /** adds a control with the given name to the list
  78         @param _rxControl
  79             the control to add. Must not be <NULL/>
  80         @param _pBName
  81             the name of the control, or <NULL/> if an automatic name should be generated
  82         @return
  83             the identifier of the newly added control
  84     */
  85     ControlIdentifier   addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName );
  86
  87     /** returns the number of controls in the list
  88     */
  89     inline size_t       size() const { return maControls.size(); }
  90
  91     /** determines whether or not the list is empty
  92     */
  93     inline bool         empty() const { return maControls.empty(); }
  94
  95     /** retrieves all controls currently in the list
  96         @return
  97             the number of controls in the list
  98     */
  99     size_t  getControls( uno::Sequence< uno::Reference< awt::XControl > >& _out_rControls ) const;
 100
 101     /** retrieves all identifiers of all controls currently in the list
 102         @return
 103             the number of controls in the list
 104     */
 105     size_t  getIdentifiers( uno::Sequence< sal_Int32 >& _out_rIdentifiers ) const;
 106
 107     /** returns the first control which is registered under the given name
 108     */
 109     uno::Reference< awt::XControl >
 110             getControlForName( const OUString& _rName ) const;
 111
 112     /** returns the identifier which a control is registered for, or -1 if the control
 113             isn't registered
 114     */
 115     ControlIdentifier
 116             getControlIdentifier( const uno::Reference< awt::XControl >& _rxControl );
 117
 118     /** retrieves the control for a given id
 119         @param _nIdentifier
 120             the identifier for the control
 121         @param _out_rxControl
 122             takes the XControl upon successful return
 123         @return
 124             <TRUE/> if and only if a control with the given id is part of the list
 125     */
 126     bool    getControlForIdentifier( ControlIdentifier _nIdentifier, uno::Reference< awt::XControl >& _out_rxControl ) const;
 127
 128     /** removes a control from the list, given by id
 129         @param _nId
 130             The identifier of the control to remove.
 131     */
 132     void    removeControlById( ControlIdentifier _nId );
 133
 134     /** replaces a control from the list with another one
 135         @param _nId
 136             The identifier of the control to replace
 137         @param _rxNewControl
 138             the new control to put into the list
 139     */
 140     void    replaceControlById( ControlIdentifier _nId, const uno::Reference< awt::XControl >& _rxNewControl );
 141
 142 private:
 143     /** adds a control
 144     @param _rxControl
 145         the control to add to the container
 146     @param _pName
 147         pointer to the name of the control. Might be <NULL/>, in this case, a name is generated.
 148     @return
 149         the identifier of the newly inserted control
 150     */
 151     ControlIdentifier impl_addControl(
 152         const uno::Reference< awt::XControl >& _rxControl,
 153         const OUString*  _pName
 154     );
 155
 156     /** finds a free identifier
 157         @throw uno::RuntimeException
 158             if no free identifier can be found
 159     */
 160     ControlIdentifier impl_getFreeIdentifier_throw();
 161
 162     /** finds a free name
 163         @throw uno::RuntimeException
 164             if no free name can be found
 165     */
 166     OUString impl_getFreeName_throw();
 167 };
 168
 169 //------------------------------------------------------------------------
 170 UnoControlHolderList::UnoControlHolderList()
 171 {
 172 }
 173
 174 //------------------------------------------------------------------------
 175 UnoControlHolderList::~UnoControlHolderList()
 176 {
 177 }
 178
 179 //------------------------------------------------------------------------
 180 UnoControlHolderList::ControlIdentifier UnoControlHolderList::addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
 181 {
 182     return impl_addControl( _rxControl, _pName );
 183 }
 184
 185 //------------------------------------------------------------------------
 186 size_t UnoControlHolderList::getControls( uno::Sequence< uno::Reference< awt::XControl > >& _out_rControls ) const
 187 {
 188     _out_rControls.realloc( maControls.size() );
 189     uno::Reference< awt::XControl >* pControls = _out_rControls.getArray();
 190     for (   ControlMap::const_iterator loop = maControls.begin();
 191             loop != maControls.end();
 192             ++loop, ++pControls
 193         )
 194         *pControls = loop->second->getControl();
 195     return maControls.size();
 196 }
 197
 198 //------------------------------------------------------------------------
 199 size_t UnoControlHolderList::getIdentifiers( uno::Sequence< sal_Int32 >& _out_rIdentifiers ) const
 200 {
 201     _out_rIdentifiers.realloc( maControls.size() );
 202     sal_Int32* pIndentifiers = _out_rIdentifiers.getArray();
 203     for (   ControlMap::const_iterator loop = maControls.begin();
 204             loop != maControls.end();
 205             ++loop, ++pIndentifiers
 206         )
 207         *pIndentifiers = loop->first;
 208     return maControls.size();
 209 }
 210
 211 //------------------------------------------------------------------------
 212 uno::Reference< awt::XControl > UnoControlHolderList::getControlForName( const OUString& _rName ) const
 213 {
 214     for (   ControlMap::const_iterator loop = maControls.begin();
 215             loop != maControls.end();
 216             ++loop
 217         )
 218         if ( loop->second->getName() == _rName )
 219             return loop->second->getControl();
 220     return uno::Reference< awt::XControl >();
 221 }
 222
 223 //------------------------------------------------------------------------
 224 UnoControlHolderList::ControlIdentifier UnoControlHolderList::getControlIdentifier( const uno::Reference< awt::XControl >& _rxControl )
 225 {
 226     for (   ControlMap::iterator loop = maControls.begin();
 227             loop != maControls.end();
 228             ++loop
 229         )
 230     {
 231         if ( loop->second->getControl().get() == _rxControl.get() )
 232             return loop->first;
 233     }
 234     return -1;
 235 }
 236
 237 //------------------------------------------------------------------------
 238 bool UnoControlHolderList::getControlForIdentifier( UnoControlHolderList::ControlIdentifier _nIdentifier, uno::Reference< awt::XControl >& _out_rxControl ) const
 239 {
 240     ControlMap::const_iterator pos = maControls.find( _nIdentifier );
 241     if ( pos == maControls.end() )
 242         return false;
 243     _out_rxControl = pos->second->getControl();
 244     return true;
 245 }
 246
 247 //------------------------------------------------------------------------
 248 void UnoControlHolderList::removeControlById( UnoControlHolderList::ControlIdentifier _nId )
 249 {
 250     ControlMap::iterator pos = maControls.find( _nId );
 251     DBG_ASSERT( pos != maControls.end(), "UnoControlHolderList::removeControlById: invalid id!" );
 252     if ( pos == maControls.end() )
 253         return;
 254
 255     maControls.erase( pos );
 256 }
 257
 258 //------------------------------------------------------------------------
 259 void UnoControlHolderList::replaceControlById( ControlIdentifier _nId, const uno::Reference< awt::XControl >& _rxNewControl )
 260 {
 261     DBG_ASSERT( _rxNewControl.is(), "UnoControlHolderList::replaceControlById: invalid new control!" );
 262
 263     ControlMap::iterator pos = maControls.find( _nId );
 264     DBG_ASSERT( pos != maControls.end(), "UnoControlHolderList::replaceControlById: invalid id!" );
 265     if ( pos == maControls.end() )
 266         return;
 267
 268     pos->second.reset( new UnoControlHolder( pos->second->getName(), _rxNewControl ) );
 269 }
 270
 271 //------------------------------------------------------------------------
 272 UnoControlHolderList::ControlIdentifier UnoControlHolderList::impl_addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
 273 {
 274     DBG_ASSERT( _rxControl.is(), "UnoControlHolderList::impl_addControl: invalid control!" );
 275
 276     OUString sName = _pName ? *_pName : impl_getFreeName_throw();
 277     sal_Int32 nId = impl_getFreeIdentifier_throw();
 278
 279     maControls[ nId ] = ControlInfo( new UnoControlHolder( sName, _rxControl ) );
 280     return nId;
 281 }
 282
 283 //------------------------------------------------------------------------
 284 UnoControlHolderList::ControlIdentifier UnoControlHolderList::impl_getFreeIdentifier_throw()
 285 {
 286     for ( ControlIdentifier candidateId = 0; candidateId < ::std::numeric_limits< ControlIdentifier >::max(); ++candidateId )
 287     {
 288         ControlMap::const_iterator existent = maControls.find( candidateId );
 289         if ( existent == maControls.end() )
 290             return candidateId;
 291     }
 292     throw uno::RuntimeException( OUString( "out of identifiers" ), NULL );
 293 }
 294
 295 //------------------------------------------------------------------------
 296 OUString UnoControlHolderList::impl_getFreeName_throw()
 297 {
 298     OUString name( "control_" );
 299     for ( ControlIdentifier candidateId = 0; candidateId < ::std::numeric_limits< ControlIdentifier >::max(); ++candidateId )
 300     {
 301         OUString candidateName( name + OUString::valueOf( candidateId ) );
 302         ControlMap::const_iterator loop = maControls.begin();
 303         for ( ; loop != maControls.end(); ++loop )
 304         {
 305             if ( loop->second->getName() == candidateName )
 306                 break;
 307         }
 308         if ( loop == maControls.end() )
 309             return candidateName;
 310     }
 311     throw uno::RuntimeException( OUString( "out of identifiers" ), NULL );
 312 }
 313 //  ----------------------------------------------------
 314 //  Function to set the controls' visibility according
 315 //  to the dialog's "Step" property
 316 //  ----------------------------------------------------
 317 void implUpdateVisibility
 318 (
 319     sal_Int32 nDialogStep,
 320     uno::Reference< awt::XControlContainer > xControlContainer
 321 )
 322 {
 323     uno::Sequence< uno::Reference< awt::XControl > >
 324         aCtrls = xControlContainer->getControls();
 325     const uno::Reference< awt::XControl >* pCtrls = aCtrls.getConstArray();
 326     sal_uInt32 nCtrls = aCtrls.getLength();
 327     sal_Bool bCompleteVisible = (nDialogStep == 0);
 328     for( sal_uInt32 n = 0; n < nCtrls; n++ )
 329     {
 330         uno::Reference< awt::XControl > xControl = pCtrls[ n ];
 331
 332         sal_Bool bVisible = bCompleteVisible;
 333         if( !bVisible )
 334         {
 335             uno::Reference< awt::XControlModel > xModel( xControl->getModel() );
 336             uno::Reference< beans::XPropertySet > xPSet
 337                 ( xModel, uno::UNO_QUERY );
 338             uno::Reference< beans::XPropertySetInfo >
 339                 xInfo = xPSet->getPropertySetInfo();
 340             OUString aPropName( "Step" );
 341             sal_Int32 nControlStep = 0;
 342             if ( xInfo->hasPropertyByName( aPropName ) )
 343             {
 344                 uno::Any aVal = xPSet->getPropertyValue( aPropName );
 345                 aVal >>= nControlStep;
 346             }
 347             bVisible = (nControlStep == 0) || (nControlStep == nDialogStep);
 348         }
 349
 350         uno::Reference< awt::XWindow> xWindow
 351             ( xControl, uno::UNO_QUERY );
 352         if( xWindow.is() )
 353             xWindow->setVisible( bVisible );
 354     }
 355 }
 356
 357
 358 //  ----------------------------------------------------
 359 //  class DialogStepChangedListener
 360 //  ----------------------------------------------------
 361 typedef ::cppu::WeakImplHelper1< beans::XPropertyChangeListener > PropertyChangeListenerHelper;
 362
 363 class DialogStepChangedListener: public PropertyChangeListenerHelper
 364 {
 365 private:
 366     uno::Reference< awt::XControlContainer > mxControlContainer;
 367
 368 public:
 369     DialogStepChangedListener( uno::Reference< awt::XControlContainer > xControlContainer )
 370         : mxControlContainer( xControlContainer ) {}
 371
 372     // XEventListener
 373     virtual void SAL_CALL disposing( const  lang::EventObject& Source ) throw( uno::RuntimeException);
 374
 375     // XPropertyChangeListener
 376     virtual void SAL_CALL propertyChange( const  beans::PropertyChangeEvent& evt ) throw( uno::RuntimeException);
 377
 378 };
 379
 380 void SAL_CALL DialogStepChangedListener::disposing( const  lang::EventObject& /*_rSource*/)
 381     throw( uno::RuntimeException)
 382 {
 383     mxControlContainer.clear();
 384 }
 385
 386 void SAL_CALL DialogStepChangedListener::propertyChange( const  beans::PropertyChangeEvent& evt )
 387     throw( uno::RuntimeException)
 388 {
 389     // evt.PropertyName HAS to be "Step" because we only use the listener for that
 390     sal_Int32 nDialogStep = 0;
 391     evt.NewValue >>= nDialogStep;
 392     implUpdateVisibility( nDialogStep, mxControlContainer );
 393 }
 394
 395 //  ----------------------------------------------------
 396 //  class UnoControlContainer
 397 //  ----------------------------------------------------
 398 UnoControlContainer::UnoControlContainer()
 399     :UnoControlContainer_Base()
 400     ,maCListeners( *this )
 401 {
 402     mpControls = new UnoControlHolderList;
 403 }
 404
 405 UnoControlContainer::UnoControlContainer(const uno::Reference< awt::XWindowPeer >& xP )
 406     :UnoControlContainer_Base()
 407     ,maCListeners( *this )
 408 {
 409     setPeer( xP );
 410     mbDisposePeer = sal_False;
 411     mpControls = new UnoControlHolderList;
 412 }
 413
 414 UnoControlContainer::~UnoControlContainer()
 415 {
 416     DELETEZ( mpControls );
 417 }
 418
 419 void UnoControlContainer::ImplActivateTabControllers()
 420 {
 421     sal_uInt32 nCount = maTabControllers.getLength();
 422     for ( sal_uInt32 n = 0; n < nCount; n++ )
 423     {
 424         maTabControllers.getArray()[n]->setContainer( this );
 425         maTabControllers.getArray()[n]->activateTabOrder();
 426     }
 427 }
 428
 429 // lang::XComponent
 430 void UnoControlContainer::dispose(  ) throw(uno::RuntimeException)
 431 {
 432     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 433
 434     lang::EventObject aDisposeEvent;
 435     aDisposeEvent.Source = static_cast< uno::XAggregation* >( this );
 436
 437     // Notify listeners about disposal of this Container (This is much faster if they
 438     // listen on the controls and the container).
 439     maDisposeListeners.disposeAndClear( aDisposeEvent );
 440     maCListeners.disposeAndClear( aDisposeEvent );
 441
 442
 443     uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
 444     uno::Reference< awt::XControl >* pCtrls = aCtrls.getArray();
 445     uno::Reference< awt::XControl >* pCtrlsEnd = pCtrls + aCtrls.getLength();
 446
 447     for( ; pCtrls < pCtrlsEnd; ++pCtrls )
 448     {
 449         removingControl( *pCtrls );
 450         // Delete control
 451         (*pCtrls)->dispose();
 452     }
 453
 454
 455     // Delete all structures
 456     DELETEZ( mpControls );
 457     mpControls = new UnoControlHolderList;
 458
 459     UnoControlBase::dispose();
 460 }
 461
 462 // lang::XEventListener
 463 void UnoControlContainer::disposing( const lang::EventObject& _rEvt ) throw(uno::RuntimeException)
 464 {
 465     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 466
 467     uno::Reference< awt::XControl >  xControl( _rEvt.Source, uno::UNO_QUERY );
 468     if ( xControl.is() )
 469         removeControl( xControl );
 470
 471     UnoControlBase::disposing( _rEvt );
 472 }
 473
 474 // container::XContainer
 475 void UnoControlContainer::addContainerListener( const uno::Reference< container::XContainerListener >& rxListener ) throw(uno::RuntimeException)
 476 {
 477     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 478
 479     maCListeners.addInterface( rxListener );
 480 }
 481
 482 void UnoControlContainer::removeContainerListener( const uno::Reference< container::XContainerListener >& rxListener ) throw(uno::RuntimeException)
 483 {
 484     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 485
 486     maCListeners.removeInterface( rxListener );
 487 }
 488
 489
 490 ::sal_Int32 SAL_CALL UnoControlContainer::insert( const uno::Any& _rElement ) throw (lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 491 {
 492     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 493
 494     uno::Reference< awt::XControl > xControl;
 495     if ( !( _rElement >>= xControl ) || !xControl.is() )
 496         throw lang::IllegalArgumentException(
 497             OUString( "Elements must support the XControl interface." ),
 498             *this,
 499             1
 500         );
 501
 502     return impl_addControl( xControl, NULL );
 503 }
 504
 505 void SAL_CALL UnoControlContainer::removeByIdentifier( ::sal_Int32 _nIdentifier ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 506 {
 507     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 508
 509     uno::Reference< awt::XControl > xControl;
 510     if ( !mpControls->getControlForIdentifier( _nIdentifier, xControl ) )
 511         throw container::NoSuchElementException(
 512             OUString( "There is no element with the given identifier." ),
 513             *this
 514         );
 515
 516     impl_removeControl( _nIdentifier, xControl, NULL );
 517 }
 518
 519 void SAL_CALL UnoControlContainer::replaceByIdentifer( ::sal_Int32 _nIdentifier, const uno::Any& _rElement ) throw (lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 520 {
 521     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 522
 523     uno::Reference< awt::XControl > xExistentControl;
 524     if ( !mpControls->getControlForIdentifier( _nIdentifier, xExistentControl ) )
 525         throw container::NoSuchElementException(
 526             OUString( "There is no element with the given identifier." ),
 527             *this
 528         );
 529
 530     uno::Reference< awt::XControl > xNewControl;
 531     if ( !( _rElement >>= xNewControl ) )
 532         throw lang::IllegalArgumentException(
 533             OUString( "Elements must support the XControl interface." ),
 534             *this,
 535             1
 536         );
 537
 538     removingControl( xExistentControl );
 539
 540     mpControls->replaceControlById( _nIdentifier, xNewControl );
 541
 542     addingControl( xNewControl );
 543
 544     impl_createControlPeerIfNecessary( xNewControl );
 545
 546     if ( maCListeners.getLength() )
 547     {
 548         container::ContainerEvent aEvent;
 549         aEvent.Source = *this;
 550         aEvent.Accessor <<= _nIdentifier;
 551         aEvent.Element <<= xNewControl;
 552         aEvent.ReplacedElement <<= xExistentControl;
 553         maCListeners.elementReplaced( aEvent );
 554     }
 555 }
 556
 557 uno::Any SAL_CALL UnoControlContainer::getByIdentifier( ::sal_Int32 _nIdentifier ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 558 {
 559     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 560
 561     uno::Reference< awt::XControl > xControl;
 562     if ( !mpControls->getControlForIdentifier( _nIdentifier, xControl ) )
 563         throw container::NoSuchElementException();
 564     return uno::makeAny( xControl );
 565 }
 566
 567 uno::Sequence< ::sal_Int32 > SAL_CALL UnoControlContainer::getIdentifiers(  ) throw (uno::RuntimeException)
 568 {
 569     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 570
 571     uno::Sequence< ::sal_Int32 > aIdentifiers;
 572     mpControls->getIdentifiers( aIdentifiers );
 573     return aIdentifiers;
 574 }
 575
 576 // container::XElementAccess
 577 uno::Type SAL_CALL UnoControlContainer::getElementType(  ) throw (uno::RuntimeException)
 578 {
 579     return awt::XControlModel::static_type();
 580 }
 581
 582 ::sal_Bool SAL_CALL UnoControlContainer::hasElements(  ) throw (uno::RuntimeException)
 583 {
 584     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 585     return !mpControls->empty();
 586 }
 587
 588 // awt::XControlContainer
 589 void UnoControlContainer::setStatusText( const OUString& rStatusText ) throw(uno::RuntimeException)
 590 {
 591     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 592
 593     // Descend the parent hierarchy
 594     uno::Reference< awt::XControlContainer >  xContainer( mxContext, uno::UNO_QUERY );
 595     if( xContainer.is() )
 596         xContainer->setStatusText( rStatusText );
 597 }
 598
 599 uno::Sequence< uno::Reference< awt::XControl > > UnoControlContainer::getControls(  ) throw(uno::RuntimeException)
 600 {
 601     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 602     uno::Sequence< uno::Reference< awt::XControl > > aControls;
 603     mpControls->getControls( aControls );
 604     return aControls;
 605 }
 606
 607 uno::Reference< awt::XControl > UnoControlContainer::getControl( const OUString& rName ) throw(uno::RuntimeException)
 608 {
 609     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 610     return mpControls->getControlForName( rName );
 611 }
 612
 613 void UnoControlContainer::addingControl( const uno::Reference< awt::XControl >& _rxControl )
 614 {
 615     if ( _rxControl.is() )
 616     {
 617         uno::Reference< uno::XInterface > xThis;
 618         OWeakAggObject::queryInterface( ::getCppuType( static_cast< uno::Reference< uno::XInterface >* >( NULL ) ) ) >>= xThis;
 619
 620         _rxControl->setContext( xThis );
 621         _rxControl->addEventListener( this );
 622     }
 623 }
 624
 625 void UnoControlContainer::impl_createControlPeerIfNecessary( const uno::Reference< awt::XControl >& _rxControl )
 626 {
 627     OSL_PRECOND( _rxControl.is(), "UnoControlContainer::impl_createControlPeerIfNecessary: invalid control, this will crash!" );
 628
 629     // if the container already has a peer, then also create a peer for the control
 630     uno::Reference< awt::XWindowPeer > xMyPeer( getPeer() );
 631
 632     if( xMyPeer.is() )
 633     {
 634         _rxControl->createPeer( NULL, xMyPeer );
 635         ImplActivateTabControllers();
 636     }
 637
 638 }
 639
 640 sal_Int32 UnoControlContainer::impl_addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
 641 {
 642     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 643     UnoControlHolderList::ControlIdentifier id = mpControls->addControl( _rxControl, _pName );
 644
 645     addingControl( _rxControl );
 646
 647     impl_createControlPeerIfNecessary( _rxControl );
 648
 649     if ( maCListeners.getLength() )
 650     {
 651         container::ContainerEvent aEvent;
 652         aEvent.Source = *this;
 653         _pName ? ( aEvent.Accessor <<= *_pName ) : ( aEvent.Accessor <<= (sal_Int32)id );
 654         aEvent.Element <<= _rxControl;
 655         maCListeners.elementInserted( aEvent );
 656     }
 657
 658     return id;
 659 }
 660
 661 void UnoControlContainer::addControl( const OUString& rName, const uno::Reference< awt::XControl >& rControl ) throw(uno::RuntimeException)
 662 {
 663     if ( rControl.is() )
 664         impl_addControl( rControl, &rName );
 665 }
 666
 667 void UnoControlContainer::removingControl( const uno::Reference< awt::XControl >& _rxControl )
 668 {
 669     if ( _rxControl.is() )
 670     {
 671         _rxControl->removeEventListener( this );
 672         _rxControl->setContext( NULL );
 673     }
 674 }
 675
 676 void UnoControlContainer::impl_removeControl( sal_Int32 _nId, const uno::Reference< awt::XControl >& _rxControl, const OUString* _pNameAccessor )
 677 {
 678 #ifdef DBG_UTIL
 679     {
 680         uno::Reference< awt::XControl > xControl;
 681         bool bHas = mpControls->getControlForIdentifier( _nId, xControl );
 682         DBG_ASSERT( bHas && xControl == _rxControl, "UnoControlContainer::impl_removeControl: inconsistency in the parameters!" );
 683     }
 684 #endif
 685     removingControl( _rxControl );
 686
 687     mpControls->removeControlById( _nId );
 688
 689     if ( maCListeners.getLength() )
 690     {
 691         container::ContainerEvent aEvent;
 692         aEvent.Source = *this;
 693         _pNameAccessor ? ( aEvent.Accessor <<= *_pNameAccessor ) : ( aEvent.Accessor <<= _nId );
 694         aEvent.Element <<= _rxControl;
 695         maCListeners.elementRemoved( aEvent );
 696     }
 697 }
 698
 699 void UnoControlContainer::removeControl( const uno::Reference< awt::XControl >& _rxControl ) throw(uno::RuntimeException)
 700 {
 701     if ( _rxControl.is() )
 702     {
 703         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 704
 705         UnoControlHolderList::ControlIdentifier id = mpControls->getControlIdentifier( _rxControl );
 706         if ( id != -1 )
 707             impl_removeControl( id, _rxControl, NULL );
 708     }
 709 }
 710
 711
 712
 713 // awt::XUnoControlContainer
 714 void UnoControlContainer::setTabControllers( const uno::Sequence< uno::Reference< awt::XTabController > >& TabControllers ) throw(uno::RuntimeException)
 715 {
 716     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 717
 718     maTabControllers = TabControllers;
 719 }
 720
 721 uno::Sequence< uno::Reference< awt::XTabController > > UnoControlContainer::getTabControllers(  ) throw(uno::RuntimeException)
 722 {
 723     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 724
 725     return maTabControllers;
 726 }
 727
 728 void UnoControlContainer::addTabController( const uno::Reference< awt::XTabController >& TabController ) throw(uno::RuntimeException)
 729 {
 730     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 731
 732     sal_uInt32 nCount = maTabControllers.getLength();
 733     maTabControllers.realloc( nCount + 1 );
 734     maTabControllers[ nCount ] = TabController;
 735 }
 736
 737 void UnoControlContainer::removeTabController( const uno::Reference< awt::XTabController >& TabController ) throw(uno::RuntimeException)
 738 {
 739     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 740
 741     sal_uInt32 nCount = maTabControllers.getLength();
 742     const uno::Reference< awt::XTabController >* pLoop = maTabControllers.getConstArray();
 743     for ( sal_uInt32 n = 0; n < nCount; ++n, ++pLoop )
 744     {
 745         if( pLoop->get() == TabController.get() )
 746         {
 747             ::comphelper::removeElementAt( maTabControllers, n );
 748             break;
 749         }
 750     }
 751 }
 752
 753 // awt::XControl
 754 void UnoControlContainer::createPeer( const uno::Reference< awt::XToolkit >& rxToolkit, const uno::Reference< awt::XWindowPeer >& rParent ) throw(uno::RuntimeException)
 755 {
 756     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 757
 758     if( !getPeer().is() )
 759     {
 760         sal_Bool bVis = maComponentInfos.bVisible;
 761         if( bVis )
 762             UnoControl::setVisible( sal_False );
 763
 764         uno::Reference< beans::XPropertySet > xTmpPropSet
 765                 ( getModel(), uno::UNO_QUERY );
 766
 767         // Create a new peer
 768         UnoControl::createPeer( rxToolkit, rParent );
 769
 770         // Create all children's peers
 771         if ( !mbCreatingCompatiblePeer )
 772         {
 773             // Evaluate "Step" property
 774             uno::Reference< awt::XControlModel > xModel( getModel() );
 775             uno::Reference< beans::XPropertySet > xPSet
 776                 ( xModel, uno::UNO_QUERY );
 777             uno::Reference< beans::XPropertySetInfo >
 778                 xInfo = xPSet->getPropertySetInfo();
 779             OUString aPropName( "Step" );
 780             if ( xInfo->hasPropertyByName( aPropName ) )
 781             {
 782                 ::com::sun::star::uno::Any aVal = xPSet->getPropertyValue( aPropName );
 783                 sal_Int32 nDialogStep = 0;
 784                 aVal >>= nDialogStep;
 785                 uno::Reference< awt::XControlContainer > xContainer =
 786                     (static_cast< awt::XControlContainer* >(this));
 787                 implUpdateVisibility( nDialogStep, xContainer );
 788
 789                 uno::Reference< beans::XPropertyChangeListener > xListener =
 790                     (static_cast< beans::XPropertyChangeListener* >(
 791                         new DialogStepChangedListener( xContainer ) ) );
 792                 xPSet->addPropertyChangeListener( aPropName, xListener );
 793             }
 794
 795             uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
 796             sal_uInt32 nCtrls = aCtrls.getLength();
 797             for( sal_uInt32 n = 0; n < nCtrls; n++ )
 798                 aCtrls.getArray()[n]->createPeer( rxToolkit, getPeer() );
 799
 800             uno::Reference< awt::XVclContainerPeer >  xC( getPeer(), uno::UNO_QUERY );
 801             if ( xC.is() )
 802                 xC->enableDialogControl( sal_True );
 803             ImplActivateTabControllers();
 804         }
 805
 806         if( bVis && !isDesignMode() )
 807             UnoControl::setVisible( sal_True );
 808     }
 809 }
 810
 811
 812 // awt::XWindow
 813 void UnoControlContainer::setVisible( sal_Bool bVisible ) throw(uno::RuntimeException)
 814 {
 815     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 816
 817     UnoControl::setVisible( bVisible );
 818     if( !mxContext.is() && bVisible )
 819         // This is a Topwindow, thus show it automatically
 820         createPeer( uno::Reference< awt::XToolkit > (), uno::Reference< awt::XWindowPeer > () );
 821 }
 822
 823 void UnoControlContainer::PrepareWindowDescriptor( ::com::sun::star::awt::WindowDescriptor& rDesc )
 824 {
 825     // HACK due to the fact that we can't really use VSCROLL & HSCROLL
 826     // for Dialog  ( ::com::sun::star::awt::VclWindowPeerAttribute::VSCROLL
 827     // has the same value as
 828     // ::com::sun::star::awt::WindowAttribute::NODECORATION )
 829     // For convenience in the PropBrowse using HSCROLL and VSCROLL ensures
 830     // the Correct text. We exchange them here and the control knows
 831     // about this hack ( it sucks badly I know )
 832     if ( rDesc.WindowAttributes & ::com::sun::star::awt::VclWindowPeerAttribute::VSCROLL )
 833     {
 834        rDesc.WindowAttributes &= ~::com::sun::star::awt::VclWindowPeerAttribute::VSCROLL;
 835        rDesc.WindowAttributes |= ::com::sun::star::awt::VclWindowPeerAttribute::AUTOVSCROLL;
 836     }
 837     if ( rDesc.WindowAttributes & ::com::sun::star::awt::VclWindowPeerAttribute::HSCROLL )
 838     {
 839        rDesc.WindowAttributes &= ~::com::sun::star::awt::VclWindowPeerAttribute::HSCROLL;
 840        rDesc.WindowAttributes |= ::com::sun::star::awt::VclWindowPeerAttribute::AUTOHSCROLL;
 841     }
 842 }
 843
 844 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */