LCOV - code coverage report
Current view: top level - UnoControls/source/base - basecontainercontrol.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 169 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 21 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11