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