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