UnoControls/source/base/basecontainercontrol.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 "basecontainercontrol.hxx"
  21
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <cppuhelper/typeprovider.hxx>
  24
  25 //  namespaces
  26
  27 using namespace ::cppu;
  28 using namespace ::osl;
  29 using namespace ::com::sun::star::uno;
  30 using namespace ::com::sun::star::lang;
  31 using namespace ::com::sun::star::awt;
  32 using namespace ::com::sun::star::container;
  33
  34 namespace unocontrols{
  35
  36 //  construct/destruct
  37
  38 BaseContainerControl::BaseContainerControl( const Reference< XComponentContext >& rxContext )
  39     : BaseControl   ( rxContext  )
  40     , m_aListeners  ( m_aMutex  )
  41 {
  42 }
  43
  44 BaseContainerControl::~BaseContainerControl()
  45 {
  46     impl_cleanMemory();
  47 }
  48
  49 //  XInterface
  50
  51 Any SAL_CALL BaseContainerControl::queryInterface( const Type& rType ) throw( RuntimeException, std::exception )
  52 {
  53     // Attention:
  54     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  55     Any aReturn;
  56     Reference< XInterface > xDel = BaseControl::impl_getDelegator();
  57     if ( xDel.is() )
  58     {
  59         // If an delegator exist, forward question to his queryInterface.
  60         // Delegator will ask his own queryAggregation!
  61         aReturn = xDel->queryInterface( rType );
  62     }
  63     else
  64     {
  65         // If an delegator unknown, forward question to own queryAggregation.
  66         aReturn = queryAggregation( rType );
  67     }
  68
  69     return aReturn;
  70 }
  71
  72 //  XTypeProvider
  73
  74 Sequence< Type > SAL_CALL BaseContainerControl::getTypes() throw( RuntimeException, std::exception )
  75 {
  76     // Optimize this method !
  77     // We initialize a static variable only one time. And we don't must use a mutex at every call!
  78     // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
  79     static OTypeCollection* pTypeCollection = NULL;
  80
  81     if ( pTypeCollection == NULL )
  82     {
  83         // Ready for multithreading; get global mutex for first call of this method only! see before
  84         MutexGuard aGuard( Mutex::getGlobalMutex() );
  85
  86         // Control these pointer again ... it can be, that another instance will be faster then these!
  87         if ( pTypeCollection == NULL )
  88         {
  89             // Create a static typecollection ...
  90             static OTypeCollection aTypeCollection  (   cppu::UnoType<XControlModel>::get(),
  91                                                           cppu::UnoType<XControlContainer>::get(),
  92                                                         BaseControl::getTypes()
  93                                                     );
  94             // ... and set his address to static pointer!
  95             pTypeCollection = &aTypeCollection;
  96         }
  97     }
  98
  99     return pTypeCollection->getTypes();
 100 }
 101
 102 //  XAggregation
 103
 104 Any SAL_CALL BaseContainerControl::queryAggregation( const Type& aType ) throw( RuntimeException, std::exception )
 105 {
 106     // Ask for my own supported interfaces ...
 107     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 108     Any aReturn ( ::cppu::queryInterface(   aType                                       ,
 109                                                static_cast< XControlModel*      > ( this )  ,
 110                                                static_cast< XControlContainer*  > ( this )
 111                                         )
 112                 );
 113
 114     // If searched interface supported by this class ...
 115     if ( aReturn.hasValue() )
 116     {
 117         // ... return this information.
 118         return aReturn;
 119     }
 120     else
 121     {
 122         // Else; ... ask baseclass for interfaces!
 123         return BaseControl::queryAggregation( aType );
 124     }
 125 }
 126
 127 //  XControl
 128
 129 void SAL_CALL BaseContainerControl::createPeer( const   Reference< XToolkit >&      xToolkit    ,
 130                                                 const   Reference< XWindowPeer >&   xParent     ) throw( RuntimeException, std::exception )
 131 {
 132     if ( !getPeer().is() )
 133     {
 134         // create own peer
 135         BaseControl::createPeer( xToolkit, xParent );
 136
 137         // create peers at all children
 138         Sequence< Reference< XControl > >   seqControlList  = getControls();
 139         sal_uInt32                          nControls       = seqControlList.getLength();
 140
 141         for ( sal_uInt32 n=0; n<nControls; n++ )
 142         {
 143             seqControlList.getArray()[n]->createPeer( xToolkit, getPeer() );
 144         }
 145
 146         // activate new tab order
 147         impl_activateTabControllers();
 148
 149     }
 150 }
 151
 152 //  XControl
 153
 154 sal_Bool SAL_CALL BaseContainerControl::setModel( const Reference< XControlModel >& ) throw( RuntimeException, std::exception )
 155 {
 156     // This object has NO model.
 157     return false;
 158 }
 159
 160 //  XControl
 161
 162 Reference< XControlModel > SAL_CALL BaseContainerControl::getModel() throw( RuntimeException, std::exception )
 163 {
 164     // This object has NO model.
 165     // return (XControlModel*)this;
 166     return Reference< XControlModel >();
 167 }
 168
 169 //  XComponent
 170
 171 void SAL_CALL BaseContainerControl::dispose() throw( RuntimeException, std::exception )
 172 {
 173     // Tell everything that this container is now gone.
 174     // It's faster if you listen to both the control and the container.
 175
 176     // Ready for multithreading
 177     MutexGuard aGuard( m_aMutex );
 178
 179     // remove listeners
 180     EventObject aObject;
 181
 182     aObject.Source = Reference< XComponent > ( (XControlContainer*)this, UNO_QUERY );
 183     m_aListeners.disposeAndClear( aObject );
 184
 185     // remove controls
 186     Sequence< Reference< XControl > >   seqCtrls    =   getControls();
 187     Reference< XControl > *             pCtrls      =   seqCtrls.getArray();
 188     sal_uInt32                          nCtrls      =   seqCtrls.getLength();
 189     size_t                              nMaxCount   =   maControlInfoList.size();
 190     size_t                              nCount      =   0;
 191
 192     for ( nCount = 0; nCount < nMaxCount; ++nCount )
 193     {
 194         delete maControlInfoList[ nCount ];
 195     }
 196     maControlInfoList.clear();
 197
 198     for ( nCount = 0; nCount < nCtrls; ++nCount )
 199     {
 200         pCtrls [ nCount ] -> removeEventListener    ( static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) ) );
 201         pCtrls [ nCount ] -> dispose                (       );
 202     }
 203
 204     // call baseclass
 205     BaseControl::dispose();
 206 }
 207
 208 //  XEventListener
 209
 210 void SAL_CALL BaseContainerControl::disposing( const EventObject& rEvent ) throw( RuntimeException, std::exception )
 211 {
 212     Reference< XControl > xControl( rEvent.Source, UNO_QUERY );
 213
 214     // "removeControl" remove only, when control is an active control
 215     removeControl( xControl );
 216 }
 217
 218 //  XControlContainer
 219
 220 void SAL_CALL BaseContainerControl::addControl ( const OUString& rName, const Reference< XControl > & rControl ) throw( RuntimeException, std::exception )
 221 {
 222     if ( !rControl.is () )
 223         return;
 224
 225     // take memory for new item
 226     IMPL_ControlInfo* pNewControl = new IMPL_ControlInfo;
 227
 228     // Ready for multithreading
 229     MutexGuard aGuard (m_aMutex);
 230
 231     // set control
 232     pNewControl->sName      = rName;
 233     pNewControl->xControl   = rControl;
 234
 235     // and insert in list
 236     maControlInfoList.push_back( pNewControl );
 237
 238     // initialize new control
 239     pNewControl->xControl->setContext       ( (OWeakObject*)this    );
 240     pNewControl->xControl->addEventListener ( static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) ) );
 241
 242     // when container has a peer ...
 243     if (getPeer().is())
 244     {
 245         // .. then create a peer on child
 246         pNewControl->xControl->createPeer ( getPeer()->getToolkit(), getPeer() );
 247         impl_activateTabControllers ();
 248     }
 249
 250     // Send message to all listener
 251     OInterfaceContainerHelper* pInterfaceContainer = m_aListeners.getContainer( cppu::UnoType<XContainerListener>::get());
 252
 253     if (pInterfaceContainer)
 254     {
 255         // Build event
 256         ContainerEvent  aEvent;
 257
 258         aEvent.Source   = *this;
 259         aEvent.Element <<= rControl;
 260
 261         // Get all listener
 262         OInterfaceIteratorHelper    aIterator (*pInterfaceContainer);
 263
 264         // Send event
 265         while ( aIterator.hasMoreElements() )
 266         {
 267             static_cast<XContainerListener*>(aIterator.next())->elementInserted (aEvent);
 268         }
 269     }
 270 }
 271
 272 //  XControlContainer
 273
 274 void SAL_CALL BaseContainerControl::removeControl ( const Reference< XControl > & rControl ) throw( RuntimeException, std::exception )
 275 {
 276     if ( rControl.is() )
 277     {
 278         // Ready for multithreading
 279         MutexGuard aGuard (m_aMutex);
 280
 281         size_t nControls = maControlInfoList.size();
 282
 283         for ( size_t n = 0; n < nControls; n++ )
 284         {
 285             // Search for right control
 286             IMPL_ControlInfo* pControl = maControlInfoList[ n ];
 287             if ( rControl == pControl->xControl )
 288             {
 289                 //.is it found ... remove listener from control
 290                 pControl->xControl->removeEventListener (static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) ));
 291                 pControl->xControl->setContext          ( Reference< XInterface >  ()   );
 292
 293                 // ... free memory
 294                 delete pControl;
 295                 ::std::vector<IMPL_ControlInfo*>::iterator itr = maControlInfoList.begin();
 296                 ::std::advance(itr, n);
 297                 maControlInfoList.erase(itr);
 298
 299                 // Send message to all other listener
 300                 OInterfaceContainerHelper * pInterfaceContainer = m_aListeners.getContainer( cppu::UnoType<XContainerListener>::get());
 301
 302                 if (pInterfaceContainer)
 303                 {
 304                     ContainerEvent  aEvent;
 305
 306                     aEvent.Source    = *this;
 307                     aEvent.Element <<= rControl;
 308
 309                     OInterfaceIteratorHelper    aIterator (*pInterfaceContainer);
 310
 311                     while ( aIterator.hasMoreElements() )
 312                     {
 313                         static_cast<XContainerListener*>(aIterator.next())->elementRemoved (aEvent);
 314                     }
 315                 }
 316                 // Break "for" !
 317                 break;
 318             }
 319         }
 320     }
 321 }
 322
 323 //  XControlContainer
 324
 325 void SAL_CALL BaseContainerControl::setStatusText ( const OUString& rStatusText ) throw( RuntimeException, std::exception )
 326 {
 327     // go down to each parent
 328     Reference< XControlContainer >  xContainer ( getContext(), UNO_QUERY );
 329
 330     if ( xContainer.is () )
 331     {
 332         xContainer->setStatusText ( rStatusText );
 333     }
 334 }
 335
 336 //  XControlContainer
 337
 338 Reference< XControl > SAL_CALL BaseContainerControl::getControl ( const OUString& rName ) throw( RuntimeException, std::exception )
 339 {
 340     // Ready for multithreading
 341     MutexGuard  aGuard ( Mutex::getGlobalMutex() );
 342
 343     size_t                  nControls   = maControlInfoList.size();
 344
 345     // Search for right control
 346     for( size_t nCount = 0; nCount < nControls; ++nCount )
 347     {
 348         IMPL_ControlInfo* pSearchControl = maControlInfoList[ nCount ];
 349
 350         if ( pSearchControl->sName == rName )
 351         {
 352             // We have found it ...
 353             // Break operation and return.
 354             return pSearchControl->xControl;
 355         }
 356     }
 357
 358     // We have not found it ... return NULL.
 359     return Reference< XControl >  ();
 360 }
 361
 362 //  XControlContainer
 363
 364 Sequence< Reference< XControl > > SAL_CALL BaseContainerControl::getControls () throw( RuntimeException, std::exception )
 365 {
 366     // Ready for multithreading
 367     MutexGuard  aGuard ( Mutex::getGlobalMutex() );
 368
 369     size_t                              nControls       = maControlInfoList.size();
 370     size_t                              nCount          = 0;
 371     Sequence< Reference< XControl > >   aDescriptor     ( nControls );
 372     Reference< XControl > *             pDestination    = aDescriptor.getArray ();
 373
 374     // Copy controls to sequence
 375     for( nCount = 0; nCount < nControls; ++nCount )
 376     {
 377         IMPL_ControlInfo* pCopyControl = maControlInfoList[ nCount ];
 378         pDestination [ nCount ] = pCopyControl->xControl;
 379     }
 380
 381     // Return sequence
 382     return aDescriptor;
 383 }
 384
 385 //  XWindow
 386
 387 void SAL_CALL BaseContainerControl::setVisible ( sal_Bool bVisible ) throw( RuntimeException, std::exception )
 388 {
 389     // override baseclass definition
 390     BaseControl::setVisible ( bVisible );
 391
 392     // is it a top window ?
 393     if ( !getContext().is() && bVisible )
 394     {
 395         // then show it automatically
 396         createPeer ( Reference< XToolkit > (), Reference< XWindowPeer > () );
 397     }
 398 }
 399
 400 //  protected method
 401
 402 WindowDescriptor* BaseContainerControl::impl_getWindowDescriptor ( const Reference< XWindowPeer > & rParentPeer )
 403 {
 404     // - used from "createPeer()" to set the values of an WindowDescriptor !!!
 405     // - if you will change the descriptor-values, you must override thid virtuell function
 406     // - the caller must release the memory for this dynamical descriptor !!!
 407
 408     WindowDescriptor    *   aDescriptor = new WindowDescriptor;
 409
 410     aDescriptor->Type               = WindowClass_CONTAINER;
 411     aDescriptor->WindowServiceName  = "window";
 412     aDescriptor->ParentIndex        = -1;
 413     aDescriptor->Parent             = rParentPeer;
 414     aDescriptor->Bounds             = getPosSize ();
 415     aDescriptor->WindowAttributes   = 0;
 416
 417     return aDescriptor;
 418 }
 419
 420 //  protected method
 421
 422 void BaseContainerControl::impl_paint ( sal_Int32 /*nX*/, sal_Int32 /*nY*/, const Reference< XGraphics > & /*rGraphics*/ )
 423 {
 424 }
 425
 426 //  private method
 427
 428 void BaseContainerControl::impl_activateTabControllers ()
 429 {
 430     // Ready for multithreading
 431     MutexGuard aGuard (m_aMutex);
 432
 433     sal_uInt32  nMaxCount   =   m_xTabControllerList.getLength ();
 434     sal_uInt32  nCount      =   0;
 435
 436     for ( nCount = 0; nCount < nMaxCount; ++nCount )
 437     {
 438          m_xTabControllerList.getArray () [nCount]->setContainer        ( this  );
 439          m_xTabControllerList.getArray () [nCount]->activateTabOrder    (       );
 440     }
 441 }
 442
 443 //  private method
 444
 445 void BaseContainerControl::impl_cleanMemory ()
 446 {
 447     // Get count of listitems.
 448     size_t  nMaxCount   = maControlInfoList.size();
 449     size_t  nCount      = 0;
 450
 451     // Delete all items.
 452     for ( nCount = 0; nCount < nMaxCount; ++nCount )
 453     {
 454         // Delete every time first element of list!
 455         // We count from 0 to MAX, where "MAX=count of items" BEFORE we delete some elements!
 456         // If we use "GetObject ( nCount )" ... it can be, that we have an index greater then count of current elements!
 457
 458         IMPL_ControlInfo* pSearchControl = maControlInfoList[ nCount ];
 459         delete pSearchControl;
 460     }
 461
 462     // Delete list himself.
 463     maControlInfoList.clear ();
 464 }
 465
 466 } // namespace unocontrols
 467
 468 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */