LCOV - code coverage report
Current view: top level - libreoffice/toolkit/source/controls - unocontrol.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 79 784 10.1 %
Date: 2012-12-27 Functions: 11 81 13.6 %
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 <com/sun/star/awt/XControlContainer.hpp>
      21             : #include <com/sun/star/awt/WindowAttribute.hpp>
      22             : #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
      23             : #include <com/sun/star/awt/PosSize.hpp>
      24             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      25             : #include <com/sun/star/beans/PropertyValue.hpp>
      26             : #include <com/sun/star/resource/XStringResourceResolver.hpp>
      27             : #include <toolkit/controls/unocontrol.hxx>
      28             : #include <toolkit/helper/vclunohelper.hxx>
      29             : #include <cppuhelper/typeprovider.hxx>
      30             : #include <rtl/uuid.h>
      31             : #include <osl/mutex.hxx>
      32             : #include <tools/date.hxx>
      33             : #include <tools/debug.hxx>
      34             : #include <tools/diagnose_ex.h>
      35             : #include <vcl/svapp.hxx>
      36             : #include <vcl/wrkwin.hxx>
      37             : #include <comphelper/stl_types.hxx>
      38             : #include <comphelper/processfactory.hxx>
      39             : #include <toolkit/helper/property.hxx>
      40             : #include <toolkit/helper/servicenames.hxx>
      41             : #include <toolkit/helper/vclunohelper.hxx>
      42             : #include <toolkit/awt/vclxwindow.hxx>
      43             : #include <vcl/svapp.hxx>
      44             : #include <osl/mutex.hxx>
      45             : #include <toolkit/controls/accessiblecontrolcontext.hxx>
      46             : #include <comphelper/container.hxx>
      47             : 
      48             : #include <algorithm>
      49             : #include <set>
      50             : 
      51             : using namespace ::com::sun::star;
      52             : using namespace ::com::sun::star::uno;
      53             : using namespace ::com::sun::star::awt;
      54             : using namespace ::com::sun::star::beans;
      55             : using namespace ::com::sun::star::lang;
      56             : using namespace ::com::sun::star::util;
      57             : 
      58             : using ::com::sun::star::accessibility::XAccessibleContext;
      59             : using ::com::sun::star::accessibility::XAccessible;
      60             : 
      61             : struct LanguageDependentProp
      62             : {
      63             :     const char* pPropName;
      64             :     sal_Int32   nPropNameLength;
      65             : };
      66             : 
      67             : static const LanguageDependentProp aLanguageDependentProp[] =
      68             : {
      69             :     { "Text",            4 },
      70             :     { "Label",           5 },
      71             :     { "Title",           5 },
      72             :     { "HelpText",        8 },
      73             :     { "CurrencySymbol", 14 },
      74             :     { "StringItemList", 14 },
      75             :     { 0, 0                 }
      76             : };
      77             : 
      78           9 : static Sequence< ::rtl::OUString> lcl_ImplGetPropertyNames( const Reference< XMultiPropertySet > & rxModel )
      79             : {
      80           9 :     Sequence< ::rtl::OUString> aNames;
      81           9 :     Reference< XPropertySetInfo >  xPSInf = rxModel->getPropertySetInfo();
      82             :     DBG_ASSERT( xPSInf.is(), "UpdateFromModel: No PropertySetInfo!" );
      83           9 :     if ( xPSInf.is() )
      84             :     {
      85           9 :         Sequence< Property> aProps = xPSInf->getProperties();
      86           9 :         sal_Int32 nLen = aProps.getLength();
      87           9 :         aNames = Sequence< ::rtl::OUString>( nLen );
      88           9 :         ::rtl::OUString* pNames = aNames.getArray();
      89           9 :         const Property* pProps = aProps.getConstArray();
      90          90 :         for ( sal_Int32 n = 0; n < nLen; ++n, ++pProps, ++pNames)
      91          90 :             *pNames = pProps->Name;
      92             :     }
      93           9 :     return aNames;
      94             : }
      95             : 
      96             : //  ====================================================
      97             : class VclListenerLock
      98             : {
      99             : private:
     100             :     VCLXWindow*  m_pLockWindow;
     101             : 
     102             : public:
     103           0 :     inline VclListenerLock( VCLXWindow* _pLockWindow )
     104           0 :         :m_pLockWindow( _pLockWindow )
     105             :     {
     106           0 :         if ( m_pLockWindow )
     107           0 :             m_pLockWindow->suspendVclEventListening( );
     108           0 :     }
     109           0 :     inline ~VclListenerLock( )
     110             :     {
     111           0 :         if ( m_pLockWindow )
     112           0 :             m_pLockWindow->resumeVclEventListening( );
     113           0 :     }
     114             : 
     115             : private:
     116             :     VclListenerLock();                                      // never implemented
     117             :     VclListenerLock( const VclListenerLock& );              // never implemented
     118             :     VclListenerLock& operator=( const VclListenerLock& );   // never implemented
     119             : };
     120             : 
     121             : typedef ::std::map< ::rtl::OUString, sal_Int32 >    MapString2Int;
     122           2 : struct UnoControl_Data
     123             : {
     124             :     MapString2Int   aSuspendedPropertyNotifications;
     125             :     /// true if and only if our model has a property ResourceResolver
     126             :     bool            bLocalizationSupport;
     127             : 
     128           9 :     UnoControl_Data()
     129             :         :aSuspendedPropertyNotifications()
     130           9 :         ,bLocalizationSupport( false )
     131             :     {
     132           9 :     }
     133             : };
     134             : 
     135             : //  ----------------------------------------------------
     136             : //  class UnoControl
     137             : //  ----------------------------------------------------
     138             : DBG_NAME( UnoControl )
     139           0 : UnoControl::UnoControl()
     140             :     :maContext( ::comphelper::getProcessServiceFactory() )
     141             :     ,maDisposeListeners( *this )
     142             :     ,maWindowListeners( *this )
     143             :     ,maFocusListeners( *this )
     144             :     ,maKeyListeners( *this )
     145             :     ,maMouseListeners( *this )
     146             :     ,maMouseMotionListeners( *this )
     147             :     ,maPaintListeners( *this )
     148           0 :     ,maModeChangeListeners( GetMutex() )
     149           0 :     ,mpData( new UnoControl_Data )
     150             : {
     151             :     DBG_CTOR( UnoControl, NULL );
     152             :     OSL_ENSURE( false, "UnoControl::UnoControl: not implemented. Well, not really." );
     153             :     // just implemented to let the various FooImplInheritanceHelper compile, you should use the
     154             :     // version taking a service factory
     155           0 : }
     156             : 
     157           9 : UnoControl::UnoControl( const Reference< XMultiServiceFactory >& i_factory )
     158             :     : maContext( i_factory )
     159             :     , maDisposeListeners( *this )
     160             :     , maWindowListeners( *this )
     161             :     , maFocusListeners( *this )
     162             :     , maKeyListeners( *this )
     163             :     , maMouseListeners( *this )
     164             :     , maMouseMotionListeners( *this )
     165             :     , maPaintListeners( *this )
     166           9 :     , maModeChangeListeners( GetMutex() )
     167          18 :     , mpData( new UnoControl_Data )
     168             : {
     169             :     DBG_CTOR( UnoControl, NULL );
     170           9 :     mbDisposePeer = sal_True;
     171           9 :     mbRefeshingPeer = sal_False;
     172           9 :     mbCreatingPeer = sal_False;
     173           9 :     mbCreatingCompatiblePeer = sal_False;
     174           9 :     mbDesignMode = sal_False;
     175           9 : }
     176             : 
     177           4 : UnoControl::~UnoControl()
     178             : {
     179           2 :     DELETEZ( mpData );
     180             :     DBG_DTOR( UnoControl, NULL );
     181           2 : }
     182             : 
     183           0 : ::rtl::OUString UnoControl::GetComponentServiceName()
     184             : {
     185           0 :     return ::rtl::OUString();
     186             : }
     187             : 
     188           0 : Reference< XWindowPeer >    UnoControl::ImplGetCompatiblePeer( sal_Bool bAcceptExistingPeer )
     189             : {
     190             :     DBG_ASSERT( !mbCreatingCompatiblePeer, "ImplGetCompatiblePeer - rekursive?" );
     191             : 
     192           0 :     mbCreatingCompatiblePeer = sal_True;
     193             : 
     194           0 :     Reference< XWindowPeer > xCompatiblePeer;
     195             : 
     196           0 :     if ( bAcceptExistingPeer )
     197           0 :         xCompatiblePeer = getPeer();
     198             : 
     199           0 :     if ( !xCompatiblePeer.is() )
     200             :     {
     201             :         // Create the pair as invisible
     202           0 :         sal_Bool bVis = maComponentInfos.bVisible;
     203           0 :         if( bVis )
     204           0 :             maComponentInfos.bVisible = sal_False;
     205             : 
     206           0 :         Reference< XWindowPeer >    xCurrentPeer = getPeer();
     207           0 :         setPeer( NULL );
     208             : 
     209             :         // queryInterface ourself, to allow aggregation
     210           0 :         Reference< XControl > xMe;
     211           0 :         OWeakAggObject::queryInterface( ::getCppuType( &xMe ) ) >>= xMe;
     212             : 
     213           0 :         Window* pParentWindow( NULL );
     214             :         {
     215           0 :             SolarMutexGuard aGuard;
     216           0 :             pParentWindow = dynamic_cast< Window* >( Application::GetDefaultDevice() );
     217           0 :             ENSURE_OR_THROW( pParentWindow != NULL, "could obtain a default parent window!" );
     218             :         }
     219             :         try
     220             :         {
     221           0 :             xMe->createPeer( NULL, pParentWindow->GetComponentInterface( sal_True ) );
     222             :         }
     223           0 :         catch( const Exception& )
     224             :         {
     225           0 :             mbCreatingCompatiblePeer = sal_False;
     226           0 :             throw;
     227             :         }
     228           0 :         xCompatiblePeer = getPeer();
     229           0 :         setPeer( xCurrentPeer );
     230             : 
     231           0 :         if ( xCompatiblePeer.is() && mxGraphics.is() )
     232             :         {
     233           0 :             Reference< XView > xPeerView( xCompatiblePeer, UNO_QUERY );
     234           0 :             if ( xPeerView.is() )
     235           0 :                 xPeerView->setGraphics( mxGraphics );
     236             :         }
     237             : 
     238           0 :         if( bVis )
     239           0 :             maComponentInfos.bVisible = sal_True;
     240             :     }
     241             : 
     242           0 :     mbCreatingCompatiblePeer = sal_False;
     243             : 
     244           0 :     return xCompatiblePeer;
     245             : }
     246             : 
     247           0 : bool UnoControl::ImplCheckLocalize( ::rtl::OUString& _rPossiblyLocalizable )
     248             : {
     249           0 :     if  (   !mpData->bLocalizationSupport
     250           0 :         ||  ( _rPossiblyLocalizable.isEmpty() )
     251           0 :         ||  ( _rPossiblyLocalizable[0] != '&' )
     252             :             // TODO: make this reasonable. At the moment, everything which by accident starts with a & is considered
     253             :             // localizable, which is probably wrong.
     254             :         )
     255           0 :         return false;
     256             : 
     257             :     try
     258             :     {
     259           0 :         Reference< XPropertySet > xPropSet( mxModel, UNO_QUERY_THROW );
     260             :         Reference< resource::XStringResourceResolver > xStringResourceResolver(
     261           0 :             xPropSet->getPropertyValue( ::rtl::OUString( "ResourceResolver" ) ),
     262             :             UNO_QUERY
     263           0 :         );
     264           0 :         if ( xStringResourceResolver.is() )
     265             :         {
     266           0 :             ::rtl::OUString aLocalizationKey( _rPossiblyLocalizable.copy( 1 ) );
     267           0 :             _rPossiblyLocalizable = xStringResourceResolver->resolveString( aLocalizationKey );
     268           0 :             return true;
     269           0 :         }
     270             :     }
     271           0 :     catch( const Exception& )
     272             :     {
     273             :         DBG_UNHANDLED_EXCEPTION();
     274             :     }
     275           0 :     return false;
     276             : }
     277             : 
     278           0 : void UnoControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const Any& rVal )
     279             : {
     280             :     // since a change made in propertiesChange, we can't be sure that this is called with an valid getPeer(),
     281             :     // this assumption may be false in some (seldom) multi-threading scenarios (cause propertiesChange
     282             :     // releases our mutex before calling here in)
     283             :     // That's why this additional check
     284             : 
     285           0 :     if ( mxVclWindowPeer.is() )
     286             :     {
     287           0 :         Any aConvertedValue( rVal );
     288             : 
     289           0 :         if ( mpData->bLocalizationSupport )
     290             :         {
     291             :             // We now support a mapping for language dependent properties. This is the
     292             :             // central method to implement it.
     293           0 :             if (( rPropName.equalsAsciiL( "Text",            4 )) ||
     294           0 :                 ( rPropName.equalsAsciiL( "Label",           5 )) ||
     295           0 :                 ( rPropName.equalsAsciiL( "Title",           5 )) ||
     296           0 :                 ( rPropName.equalsAsciiL( "HelpText",        8 )) ||
     297           0 :                 ( rPropName.equalsAsciiL( "CurrencySymbol", 14 )) ||
     298           0 :                 ( rPropName.equalsAsciiL( "StringItemList", 14 )) )
     299             :             {
     300           0 :                 ::rtl::OUString aValue;
     301           0 :                 uno::Sequence< rtl::OUString > aSeqValue;
     302           0 :                 if ( aConvertedValue >>= aValue )
     303             :                 {
     304           0 :                     if ( ImplCheckLocalize( aValue ) )
     305           0 :                         aConvertedValue <<= aValue;
     306             :                 }
     307           0 :                 else if ( aConvertedValue >>= aSeqValue )
     308             :                 {
     309           0 :                     for ( sal_Int32 i = 0; i < aSeqValue.getLength(); i++ )
     310           0 :                         ImplCheckLocalize( aSeqValue[i] );
     311           0 :                     aConvertedValue <<= aSeqValue;
     312           0 :                 }
     313             :             }
     314             :         }
     315             : 
     316           0 :         mxVclWindowPeer->setProperty( rPropName, aConvertedValue );
     317             :     }
     318           0 : }
     319             : 
     320           0 : void UnoControl::PrepareWindowDescriptor( WindowDescriptor& )
     321             : {
     322           0 : }
     323             : 
     324           0 : Reference< XWindow >    UnoControl::getParentPeer() const
     325             : {
     326           0 :     Reference< XWindow > xPeer;
     327           0 :     if( mxContext.is() )
     328             :     {
     329           0 :         Reference< XControl > xContComp( mxContext, UNO_QUERY );
     330           0 :         if ( xContComp.is() )
     331             :         {
     332           0 :             Reference< XWindowPeer > xP = xContComp->getPeer();
     333           0 :             if ( xP.is() )
     334           0 :                 xP->queryInterface( ::getCppuType((const Reference< XWindow >*)0) ) >>= xPeer;
     335           0 :         }
     336             :     }
     337           0 :     return xPeer;
     338             : }
     339             : 
     340           0 : void UnoControl::updateFromModel()
     341             : {
     342             :     // Read default properties and hand over to peer
     343           0 :     if( getPeer().is() )
     344             :     {
     345           0 :         Reference< XMultiPropertySet >  xPropSet( mxModel, UNO_QUERY );
     346           0 :         if( xPropSet.is() )
     347             :         {
     348           0 :             Sequence< ::rtl::OUString> aNames = lcl_ImplGetPropertyNames( xPropSet );
     349           0 :             xPropSet->firePropertiesChangeEvent( aNames, this );
     350           0 :         }
     351             :     }
     352           0 : }
     353             : 
     354             : 
     355             : // XTypeProvider
     356           0 : IMPL_IMPLEMENTATION_ID( UnoControl )
     357             : 
     358           2 : void UnoControl::disposeAccessibleContext()
     359             : {
     360           2 :     Reference< XComponent > xContextComp( maAccessibleContext.get(), UNO_QUERY );
     361           2 :     if ( xContextComp.is() )
     362             :     {
     363           0 :         maAccessibleContext = NULL;
     364             :         try
     365             :         {
     366           0 :             xContextComp->removeEventListener( this );
     367           0 :             xContextComp->dispose();
     368             :         }
     369           0 :         catch( const Exception& )
     370             :         {
     371             :             OSL_FAIL( "UnoControl::disposeAccessibleContext: could not dispose my AccessibleContext!" );
     372             :         }
     373           2 :     }
     374           2 : }
     375             : 
     376           2 : void UnoControl::dispose(  ) throw(RuntimeException)
     377             : {
     378           2 :     Reference< XWindowPeer > xPeer;
     379             :     {
     380           2 :         ::osl::MutexGuard aGuard( GetMutex() );
     381           2 :         if( mbDisposePeer )
     382             :         {
     383           0 :             xPeer = mxPeer;
     384             :         }
     385           2 :         setPeer( NULL );
     386             :     }
     387           2 :     if( xPeer.is() )
     388             :     {
     389           0 :         xPeer->dispose();
     390             :     }
     391             : 
     392             :     // dispose and release our AccessibleContext
     393           2 :     disposeAccessibleContext();
     394             : 
     395           2 :     EventObject aDisposeEvent;
     396           2 :     aDisposeEvent.Source = static_cast< XAggregation* >( this );
     397             : 
     398           2 :     maDisposeListeners.disposeAndClear( aDisposeEvent );
     399           2 :     maWindowListeners.disposeAndClear( aDisposeEvent );
     400           2 :     maFocusListeners.disposeAndClear( aDisposeEvent );
     401           2 :     maKeyListeners.disposeAndClear( aDisposeEvent );
     402           2 :     maMouseListeners.disposeAndClear( aDisposeEvent );
     403           2 :     maMouseMotionListeners.disposeAndClear( aDisposeEvent );
     404           2 :     maPaintListeners.disposeAndClear( aDisposeEvent );
     405           2 :     maModeChangeListeners.disposeAndClear( aDisposeEvent );
     406             : 
     407             :     // release Model again
     408           2 :     setModel( Reference< XControlModel > () );
     409           2 :     setContext( Reference< XInterface > () );
     410           2 : }
     411             : 
     412           0 : void UnoControl::addEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException)
     413             : {
     414           0 :     ::osl::MutexGuard aGuard( GetMutex() );
     415             : 
     416           0 :     maDisposeListeners.addInterface( rxListener );
     417           0 : }
     418             : 
     419           0 : void UnoControl::removeEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException)
     420             : {
     421           0 :     ::osl::MutexGuard aGuard( GetMutex() );
     422             : 
     423           0 :     maDisposeListeners.removeInterface( rxListener );
     424           0 : }
     425             : 
     426           0 : sal_Bool UnoControl::requiresNewPeer( const ::rtl::OUString& /* _rPropertyName */ ) const
     427             : {
     428           0 :     return sal_False;
     429             : }
     430             : 
     431             : // XPropertiesChangeListener
     432           0 : void UnoControl::propertiesChange( const Sequence< PropertyChangeEvent >& rEvents ) throw(RuntimeException)
     433             : {
     434           0 :     Sequence< PropertyChangeEvent > aEvents( rEvents );
     435             :     {
     436           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     437             : 
     438           0 :         if ( !mpData->aSuspendedPropertyNotifications.empty() )
     439             :         {
     440             :             // strip the property which we are currently updating (somewhere up the stack)
     441           0 :             PropertyChangeEvent* pEvents = aEvents.getArray();
     442           0 :             PropertyChangeEvent* pEventsEnd = pEvents + aEvents.getLength();
     443           0 :             for ( ; pEvents < pEventsEnd; )
     444           0 :                 if ( mpData->aSuspendedPropertyNotifications.find( pEvents->PropertyName ) != mpData->aSuspendedPropertyNotifications.end() )
     445             :                 {
     446           0 :                     if ( pEvents != pEventsEnd )
     447           0 :                         ::std::copy( pEvents + 1, pEventsEnd, pEvents );
     448           0 :                     --pEventsEnd;
     449             :                 }
     450             :                 else
     451           0 :                     ++pEvents;
     452           0 :             aEvents.realloc( pEventsEnd - aEvents.getConstArray() );
     453             : 
     454           0 :             if ( !aEvents.getLength() )
     455           0 :                 return;
     456           0 :         }
     457             :     }
     458             : 
     459           0 :     ImplModelPropertiesChanged( aEvents );
     460             : }
     461             : 
     462           0 : void UnoControl::ImplLockPropertyChangeNotification( const ::rtl::OUString& rPropertyName, bool bLock )
     463             : {
     464           0 :     MapString2Int::iterator pos = mpData->aSuspendedPropertyNotifications.find( rPropertyName );
     465           0 :     if ( bLock )
     466             :     {
     467           0 :         if ( pos == mpData->aSuspendedPropertyNotifications.end() )
     468           0 :             pos = mpData->aSuspendedPropertyNotifications.insert( MapString2Int::value_type( rPropertyName, 0 ) ).first;
     469           0 :         ++pos->second;
     470             :     }
     471             :     else
     472             :     {
     473             :         OSL_ENSURE( pos != mpData->aSuspendedPropertyNotifications.end(), "UnoControl::ImplLockPropertyChangeNotification: property not locked!" );
     474           0 :         if ( pos != mpData->aSuspendedPropertyNotifications.end() )
     475             :         {
     476             :             OSL_ENSURE( pos->second > 0, "UnoControl::ImplLockPropertyChangeNotification: invalid suspension counter!" );
     477           0 :             if ( 0 == --pos->second )
     478           0 :                 mpData->aSuspendedPropertyNotifications.erase( pos );
     479             :         }
     480             :     }
     481           0 : }
     482             : 
     483           0 : void UnoControl::ImplLockPropertyChangeNotifications( const Sequence< ::rtl::OUString >& rPropertyNames, bool bLock )
     484             : {
     485           0 :     for (   const ::rtl::OUString* pPropertyName = rPropertyNames.getConstArray();
     486           0 :             pPropertyName != rPropertyNames.getConstArray() + rPropertyNames.getLength();
     487             :             ++pPropertyName
     488             :         )
     489           0 :         ImplLockPropertyChangeNotification( *pPropertyName, bLock );
     490           0 : }
     491             : 
     492           0 : void UnoControl::ImplModelPropertiesChanged( const Sequence< PropertyChangeEvent >& rEvents )
     493             : {
     494           0 :     ::osl::ClearableGuard< ::osl::Mutex > aGuard( GetMutex() );
     495             : 
     496           0 :     if( getPeer().is() )
     497             :     {
     498             :         DECLARE_STL_VECTOR( PropertyValue, PropertyValueVector);
     499           0 :         PropertyValueVector     aPeerPropertiesToSet;
     500           0 :         sal_Int32               nIndependentPos = 0;
     501           0 :         bool                    bResourceResolverSet( false );
     502             :             // position where to insert the independent properties into aPeerPropertiesToSet,
     503             :             // dependent ones are inserted at the end of the vector
     504             : 
     505           0 :         sal_Bool bNeedNewPeer = sal_False;
     506             :             // some properties require a re-creation of the peer, 'cause they can't be changed on the fly
     507             : 
     508           0 :         Reference< XControlModel > xOwnModel( getModel(), UNO_QUERY );
     509             :             // our own model for comparison
     510           0 :         Reference< XPropertySet > xPS( xOwnModel, UNO_QUERY );
     511           0 :         Reference< XPropertySetInfo > xPSI( xPS->getPropertySetInfo(), UNO_QUERY );
     512             :         OSL_ENSURE( xPSI.is(), "UnoControl::ImplModelPropertiesChanged: should have property set meta data!" );
     513             : 
     514           0 :         const PropertyChangeEvent* pEvents = rEvents.getConstArray();
     515             : 
     516           0 :         sal_Int32 nLen = rEvents.getLength();
     517           0 :         aPeerPropertiesToSet.reserve(nLen);
     518             : 
     519           0 :         for( sal_Int32 i = 0; i < nLen; ++i, ++pEvents )
     520             :         {
     521           0 :             Reference< XControlModel > xModel( pEvents->Source, UNO_QUERY );
     522           0 :             sal_Bool bOwnModel = xModel.get() == xOwnModel.get();
     523           0 :             if ( !bOwnModel )
     524           0 :                 continue;
     525             : 
     526             :             // Detect changes on our resource resolver which invalidates
     527             :             // automatically some language dependent properties.
     528           0 :             if ( pEvents->PropertyName.equalsAsciiL( "ResourceResolver", 16 ))
     529             :             {
     530           0 :                 Reference< resource::XStringResourceResolver > xStrResolver;
     531           0 :                 if ( pEvents->NewValue >>= xStrResolver )
     532           0 :                     bResourceResolverSet = xStrResolver.is();
     533             :             }
     534             : 
     535           0 :             sal_uInt16 nPType = GetPropertyId( pEvents->PropertyName );
     536           0 :             if ( mbDesignMode && mbDisposePeer && !mbRefeshingPeer && !mbCreatingPeer )
     537             :             {
     538             :                 // if we're in design mode, then some properties can change which
     539             :                 // require creating a *new* peer (since these properties cannot
     540             :                 // be switched at existing peers)
     541           0 :                 if ( nPType )
     542             :                     bNeedNewPeer = ( nPType == BASEPROPERTY_BORDER )
     543             :                                 || ( nPType == BASEPROPERTY_MULTILINE )
     544             :                                 || ( nPType == BASEPROPERTY_DROPDOWN )
     545             :                                 || ( nPType == BASEPROPERTY_HSCROLL )
     546             :                                 || ( nPType == BASEPROPERTY_VSCROLL )
     547             :                                 || ( nPType == BASEPROPERTY_AUTOHSCROLL )
     548             :                                 || ( nPType == BASEPROPERTY_AUTOVSCROLL )
     549             :                                 || ( nPType == BASEPROPERTY_ORIENTATION )
     550             :                                 || ( nPType == BASEPROPERTY_SPIN )
     551             :                                 || ( nPType == BASEPROPERTY_ALIGN )
     552           0 :                                 || ( nPType == BASEPROPERTY_PAINTTRANSPARENT );
     553             :                 else
     554           0 :                     bNeedNewPeer = requiresNewPeer( pEvents->PropertyName );
     555             : 
     556           0 :                 if ( bNeedNewPeer )
     557             :                     break;
     558             :             }
     559             : 
     560           0 :             if ( nPType && ( nLen > 1 ) && DoesDependOnOthers( nPType ) )
     561             :             {
     562             :                 // Add properties with dependencies on other properties last
     563             :                 // since they're dependent on properties added later (such as
     564             :                 // VALUE dependency on VALUEMIN/MAX)
     565           0 :                 aPeerPropertiesToSet.push_back(PropertyValue(pEvents->PropertyName, 0, pEvents->NewValue, PropertyState_DIRECT_VALUE));
     566             :             }
     567             :             else
     568             :             {
     569           0 :                 if ( bResourceResolverSet )
     570             :                 {
     571             :                     // The resource resolver property change should be one of the first ones.
     572             :                     // All language dependent properties are dependent on this property.
     573             :                     // As BASEPROPERTY_NATIVE_WIDGET_LOOK is not dependent on resource
     574             :                     // resolver. We don't need to handle a special order for these two props.
     575             :                     aPeerPropertiesToSet.insert(
     576             :                         aPeerPropertiesToSet.begin(),
     577           0 :                         PropertyValue( pEvents->PropertyName, 0, pEvents->NewValue, PropertyState_DIRECT_VALUE ) );
     578           0 :                     ++nIndependentPos;
     579             :                 }
     580           0 :                 else if ( nPType == BASEPROPERTY_NATIVE_WIDGET_LOOK )
     581             :                 {
     582             :                     // since *a lot* of other properties might be overruled by this one, we need
     583             :                     // a special handling:
     584             :                     // NativeWidgetLook needs to be set first: If it is set to ON, all other
     585             :                     // properties describing the look (e.g. BackgroundColor) are ignored, anyway.
     586             :                     // If it is switched OFF, then we need to do it first because else it will
     587             :                     // overrule other look-related properties, and re-initialize them from system
     588             :                     // defaults.
     589             :                     aPeerPropertiesToSet.insert(
     590             :                         aPeerPropertiesToSet.begin(),
     591           0 :                         PropertyValue( pEvents->PropertyName, 0, pEvents->NewValue, PropertyState_DIRECT_VALUE ) );
     592           0 :                     ++nIndependentPos;
     593             :                 }
     594             :                 else
     595             :                 {
     596             :                     aPeerPropertiesToSet.insert(aPeerPropertiesToSet.begin() + nIndependentPos,
     597           0 :                         PropertyValue(pEvents->PropertyName, 0, pEvents->NewValue, PropertyState_DIRECT_VALUE));
     598           0 :                     ++nIndependentPos;
     599             :                 }
     600             :             }
     601           0 :         }
     602             : 
     603           0 :         Reference< XWindow >    xParent = getParentPeer();
     604           0 :         Reference< XControl > xThis( (XAggregation*)(::cppu::OWeakAggObject*)this, UNO_QUERY );
     605             :         // call createPeer via a interface got from queryInterface, so the aggregating class can intercept it
     606             : 
     607             :         DBG_ASSERT( !bNeedNewPeer || xParent.is(), "Need new peer, but don't have a parent!" );
     608             : 
     609             :         // Check if we have to update language dependent properties
     610           0 :         if ( !bNeedNewPeer && bResourceResolverSet )
     611             :         {
     612             :             // Add language dependent properties into the peer property set.
     613             :             // Our resource resolver has been changed and we must be sure
     614             :             // that language dependent props use the new resolver.
     615           0 :             const LanguageDependentProp* pLangDepProp = aLanguageDependentProp;
     616           0 :             while ( pLangDepProp->pPropName != 0 )
     617             :             {
     618           0 :                 bool bMustBeInserted( true );
     619           0 :                 for ( sal_uInt32 i = 0; i < aPeerPropertiesToSet.size(); i++ )
     620             :                 {
     621           0 :                     if ( aPeerPropertiesToSet[i].Name.equalsAsciiL(
     622           0 :                             pLangDepProp->pPropName, pLangDepProp->nPropNameLength ))
     623             :                     {
     624           0 :                         bMustBeInserted = false;
     625           0 :                         break;
     626             :                     }
     627             :                 }
     628             : 
     629           0 :                 if ( bMustBeInserted )
     630             :                 {
     631             :                     // Add language dependent props at the end
     632           0 :                     ::rtl::OUString aPropName( ::rtl::OUString::createFromAscii( pLangDepProp->pPropName ));
     633           0 :                     if ( xPSI.is() && xPSI->hasPropertyByName( aPropName ) )
     634             :                     {
     635             :                         aPeerPropertiesToSet.push_back(
     636           0 :                             PropertyValue( aPropName, 0, xPS->getPropertyValue( aPropName ), PropertyState_DIRECT_VALUE ) );
     637           0 :                     }
     638             :                 }
     639             : 
     640           0 :                 ++pLangDepProp;
     641             :             }
     642             :         }
     643           0 :         aGuard.clear();
     644             : 
     645             :         // clear the guard before creating a new peer - as usual, our peer implementations use the SolarMutex
     646             : 
     647           0 :         if (bNeedNewPeer && xParent.is())
     648             :         {
     649           0 :             SolarMutexGuard aVclGuard;
     650             :                 // and now this is the final withdrawal:
     651             :                 // I have no other idea than locking the SolarMutex here ....
     652             :                 // I really hate the fact that VCL is not theadsafe ....
     653             : 
     654             :             // Doesn't work for Container!
     655           0 :             getPeer()->dispose();
     656           0 :             mxPeer.clear();
     657           0 :             mxVclWindowPeer = NULL;
     658           0 :             mbRefeshingPeer = sal_True;
     659           0 :             Reference< XWindowPeer >    xP( xParent, UNO_QUERY );
     660           0 :             xThis->createPeer( Reference< XToolkit > (), xP );
     661           0 :             mbRefeshingPeer = sal_False;
     662           0 :             aPeerPropertiesToSet.clear();
     663             :         }
     664             : 
     665             :         // lock the multiplexing of VCL events to our UNO listeners
     666             :         // this is for compatibility reasons: in OOo 1.0.x, changes which were done at the
     667             :         // model did not cause the listeners of the controls/peers to be called
     668             :         // Since the implementations for the listeners changed a lot towards 1.1, this
     669             :         // would not be the case anymore, if we would not do this listener-lock below
     670             :         // #i14703#
     671           0 :         Window* pVclPeer = VCLUnoHelper::GetWindow( getPeer() );
     672           0 :         VCLXWindow* pPeer = pVclPeer ? pVclPeer->GetWindowPeer() : NULL;
     673           0 :         VclListenerLock aNoVclEventMultiplexing( pPeer );
     674             : 
     675             :         // setting peer properties may result in an attemp to acquire the solar mutex, 'cause the peers
     676             :         // usually don't have an own mutex but use the SolarMutex instead.
     677             :         // To prevent deadlocks resulting from this, we do this without our own mutex locked
     678           0 :         PropertyValueVectorIterator aEnd = aPeerPropertiesToSet.end();
     679           0 :         for (   PropertyValueVectorIterator aLoop = aPeerPropertiesToSet.begin();
     680             :                 aLoop != aEnd;
     681             :                 ++aLoop
     682             :             )
     683             :         {
     684           0 :             ImplSetPeerProperty( aLoop->Name, aLoop->Value );
     685           0 :         }
     686           0 :     }
     687           0 : }
     688             : 
     689           0 : void UnoControl::disposing( const EventObject& rEvt ) throw(RuntimeException)
     690             : {
     691           0 :     ::osl::ClearableMutexGuard aGuard( GetMutex() );
     692             :     // do not compare differing types in case of multible inheritance
     693             : 
     694           0 :     if ( maAccessibleContext.get() == rEvt.Source )
     695             :     {
     696             :         // just in case the context is disposed, but not released - ensure that we do not re-use it in the future
     697           0 :         maAccessibleContext = NULL;
     698             :     }
     699           0 :     else if( mxModel.get() == Reference< XControlModel >(rEvt.Source,UNO_QUERY).get() )
     700             :     {
     701             :         // #62337# if the model dies, it does not make sense for us to live ...
     702           0 :         Reference< XControl >  xThis = this;
     703             : 
     704           0 :         aGuard.clear();
     705           0 :         xThis->dispose();
     706             : 
     707             :         DBG_ASSERT( !mxModel.is(), "UnoControl::disposing: invalid dispose behaviour!" );
     708           0 :         mxModel.clear();
     709           0 :     }
     710           0 : }
     711             : 
     712             : 
     713           0 : void SAL_CALL UnoControl::setOutputSize( const awt::Size& aSize ) throw (RuntimeException)
     714             : {
     715           0 :     Reference< XWindow2 > xPeerWindow;
     716             :     {
     717           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     718           0 :         xPeerWindow = xPeerWindow.query( getPeer() );
     719             :     }
     720             : 
     721           0 :     if ( xPeerWindow.is() )
     722           0 :         xPeerWindow->setOutputSize( aSize );
     723           0 : }
     724             : 
     725             : namespace
     726             : {
     727             :     template < typename RETVALTYPE >
     728           0 :     RETVALTYPE lcl_askPeer( const uno::Reference< awt::XWindowPeer >& _rxPeer, RETVALTYPE (SAL_CALL XWindow2::*_pMethod)(), RETVALTYPE _aDefault )
     729             :     {
     730           0 :         RETVALTYPE aReturn( _aDefault );
     731             : 
     732           0 :         Reference< XWindow2 > xPeerWindow( _rxPeer, UNO_QUERY );
     733           0 :         if ( xPeerWindow.is() )
     734           0 :             aReturn = (xPeerWindow.get()->*_pMethod)();
     735             : 
     736           0 :         return aReturn;
     737             :     }
     738             : }
     739             : 
     740           0 : awt::Size SAL_CALL UnoControl::getOutputSize(  ) throw (RuntimeException)
     741             : {
     742           0 :     return lcl_askPeer( getPeer(), &XWindow2::getOutputSize, awt::Size() );
     743             : }
     744             : 
     745           0 : ::sal_Bool SAL_CALL UnoControl::isVisible(  ) throw (RuntimeException)
     746             : {
     747           0 :     return lcl_askPeer( getPeer(), &XWindow2::isVisible, maComponentInfos.bVisible );
     748             : }
     749             : 
     750           0 : ::sal_Bool SAL_CALL UnoControl::isActive(  ) throw (RuntimeException)
     751             : {
     752           0 :     return lcl_askPeer( getPeer(), &XWindow2::isActive, sal_False );
     753             : }
     754             : 
     755           0 : ::sal_Bool SAL_CALL UnoControl::isEnabled(  ) throw (RuntimeException)
     756             : {
     757           0 :     return lcl_askPeer( getPeer(), &XWindow2::isEnabled, maComponentInfos.bEnable );
     758             : }
     759             : 
     760           0 : ::sal_Bool SAL_CALL UnoControl::hasFocus(  ) throw (RuntimeException)
     761             : {
     762           0 :     return lcl_askPeer( getPeer(), &XWindow2::hasFocus, sal_False );
     763             : }
     764             : 
     765             : // XWindow
     766           0 : void UnoControl::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags ) throw(RuntimeException)
     767             : {
     768           0 :     Reference< XWindow > xWindow;
     769             :     {
     770           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     771             : 
     772           0 :         if ( Flags & awt::PosSize::X )
     773           0 :             maComponentInfos.nX = X;
     774           0 :         if ( Flags & awt::PosSize::Y )
     775           0 :             maComponentInfos.nY = Y;
     776           0 :         if ( Flags & awt::PosSize::WIDTH )
     777           0 :             maComponentInfos.nWidth = Width;
     778           0 :         if ( Flags & awt::PosSize::HEIGHT )
     779           0 :             maComponentInfos.nHeight = Height;
     780           0 :         maComponentInfos.nFlags |= Flags;
     781             : 
     782           0 :         xWindow = xWindow.query( getPeer() );
     783             :     }
     784             : 
     785           0 :     if( xWindow.is() )
     786           0 :         xWindow->setPosSize( X, Y, Width, Height, Flags );
     787           0 : }
     788             : 
     789           0 : awt::Rectangle UnoControl::getPosSize(  ) throw(RuntimeException)
     790             : {
     791           0 :     awt::Rectangle aRect( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight);
     792           0 :     Reference< XWindow > xWindow;
     793             : 
     794             :     {
     795           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     796           0 :         xWindow = xWindow.query( getPeer() );
     797             :     }
     798             : 
     799           0 :     if( xWindow.is() )
     800           0 :         aRect = xWindow->getPosSize();
     801           0 :     return aRect;
     802             : }
     803             : 
     804           0 : void UnoControl::setVisible( sal_Bool bVisible ) throw(RuntimeException)
     805             : {
     806           0 :     Reference< XWindow > xWindow;
     807             :     {
     808           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     809             : 
     810             :         // Visible status is handled by View
     811           0 :         maComponentInfos.bVisible = bVisible;
     812           0 :         xWindow = xWindow.query( getPeer() );
     813             :     }
     814           0 :     if ( xWindow.is() )
     815           0 :         xWindow->setVisible( bVisible );
     816           0 : }
     817             : 
     818           0 : void UnoControl::setEnable( sal_Bool bEnable ) throw(RuntimeException)
     819             : {
     820           0 :     Reference< XWindow > xWindow;
     821             :     {
     822           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     823             : 
     824             :         // Enable status is handled by View
     825           0 :         maComponentInfos.bEnable = bEnable;
     826           0 :         xWindow = xWindow.query( getPeer() );
     827             :     }
     828           0 :     if ( xWindow.is() )
     829           0 :         xWindow->setEnable( bEnable );
     830           0 : }
     831             : 
     832           0 : void UnoControl::setFocus(  ) throw(RuntimeException)
     833             : {
     834           0 :     Reference< XWindow > xWindow;
     835             :     {
     836           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     837           0 :         xWindow = xWindow.query( getPeer() );
     838             :     }
     839           0 :     if ( xWindow.is() )
     840           0 :         xWindow->setFocus();
     841           0 : }
     842             : 
     843           0 : void UnoControl::addWindowListener( const Reference< XWindowListener >& rxListener ) throw(RuntimeException)
     844             : {
     845           0 :     Reference< XWindow > xPeerWindow;
     846             :     {
     847           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     848           0 :         maWindowListeners.addInterface( rxListener );
     849           0 :         if ( maWindowListeners.getLength() == 1 )
     850           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     851             :     }
     852           0 :     if ( xPeerWindow.is() )
     853           0 :         xPeerWindow->addWindowListener( &maWindowListeners );
     854           0 : }
     855             : 
     856           0 : void UnoControl::removeWindowListener( const Reference< XWindowListener >& rxListener ) throw(RuntimeException)
     857             : {
     858           0 :     Reference< XWindow > xPeerWindow;
     859             :     {
     860           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     861           0 :         if ( maWindowListeners.getLength() == 1 )
     862           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     863           0 :         maWindowListeners.removeInterface( rxListener );
     864             :     }
     865           0 :     if ( xPeerWindow.is() )
     866           0 :         xPeerWindow->removeWindowListener( &maWindowListeners );
     867           0 : }
     868             : 
     869           0 : void UnoControl::addFocusListener( const Reference< XFocusListener >& rxListener ) throw(RuntimeException)
     870             : {
     871           0 :     Reference< XWindow > xPeerWindow;
     872             :     {
     873           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     874           0 :         maFocusListeners.addInterface( rxListener );
     875           0 :         if ( maFocusListeners.getLength() == 1 )
     876           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     877             :     }
     878           0 :     if ( xPeerWindow.is() )
     879           0 :         xPeerWindow->addFocusListener( &maFocusListeners );
     880           0 : }
     881             : 
     882           0 : void UnoControl::removeFocusListener( const Reference< XFocusListener >& rxListener ) throw(RuntimeException)
     883             : {
     884           0 :     Reference< XWindow > xPeerWindow;
     885             :     {
     886           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     887           0 :         if ( maFocusListeners.getLength() == 1 )
     888           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     889           0 :         maFocusListeners.removeInterface( rxListener );
     890             :     }
     891           0 :     if ( xPeerWindow.is() )
     892           0 :         xPeerWindow->removeFocusListener( &maFocusListeners );
     893           0 : }
     894             : 
     895           0 : void UnoControl::addKeyListener( const Reference< XKeyListener >& rxListener ) throw(RuntimeException)
     896             : {
     897           0 :     Reference< XWindow > xPeerWindow;
     898             :     {
     899           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     900           0 :         maKeyListeners.addInterface( rxListener );
     901           0 :         if ( maKeyListeners.getLength() == 1 )
     902           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     903             :     }
     904           0 :     if ( xPeerWindow.is() )
     905           0 :         xPeerWindow->addKeyListener( &maKeyListeners);
     906           0 : }
     907             : 
     908           0 : void UnoControl::removeKeyListener( const Reference< XKeyListener >& rxListener ) throw(RuntimeException)
     909             : {
     910           0 :     Reference< XWindow > xPeerWindow;
     911             :     {
     912           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     913           0 :         if ( maKeyListeners.getLength() == 1 )
     914           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     915           0 :         maKeyListeners.removeInterface( rxListener );
     916             :     }
     917           0 :     if ( xPeerWindow.is() )
     918           0 :         xPeerWindow->removeKeyListener( &maKeyListeners);
     919           0 : }
     920             : 
     921           0 : void UnoControl::addMouseListener( const Reference< XMouseListener >& rxListener ) throw(RuntimeException)
     922             : {
     923           0 :     Reference< XWindow > xPeerWindow;
     924             :     {
     925           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     926           0 :         maMouseListeners.addInterface( rxListener );
     927           0 :         if ( maMouseListeners.getLength() == 1 )
     928           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     929             :     }
     930           0 :     if ( xPeerWindow.is() )
     931           0 :         xPeerWindow->addMouseListener( &maMouseListeners);
     932           0 : }
     933             : 
     934           0 : void UnoControl::removeMouseListener( const Reference< XMouseListener >& rxListener ) throw(RuntimeException)
     935             : {
     936           0 :     Reference< XWindow > xPeerWindow;
     937             :     {
     938           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     939           0 :         if ( maMouseListeners.getLength() == 1 )
     940           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     941           0 :         maMouseListeners.removeInterface( rxListener );
     942             :     }
     943           0 :     if ( xPeerWindow.is() )
     944           0 :         xPeerWindow->removeMouseListener( &maMouseListeners );
     945           0 : }
     946             : 
     947           0 : void UnoControl::addMouseMotionListener( const Reference< XMouseMotionListener >& rxListener ) throw(RuntimeException)
     948             : {
     949           0 :     Reference< XWindow > xPeerWindow;
     950             :     {
     951           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     952           0 :         maMouseMotionListeners.addInterface( rxListener );
     953           0 :         if ( maMouseMotionListeners.getLength() == 1 )
     954           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     955             :     }
     956           0 :     if ( xPeerWindow.is() )
     957           0 :         xPeerWindow->addMouseMotionListener( &maMouseMotionListeners);
     958           0 : }
     959             : 
     960           0 : void UnoControl::removeMouseMotionListener( const Reference< XMouseMotionListener >& rxListener ) throw(RuntimeException)
     961             : {
     962           0 :     Reference< XWindow > xPeerWindow;
     963             :     {
     964           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     965           0 :         if ( maMouseMotionListeners.getLength() == 1 )
     966           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     967           0 :         maMouseMotionListeners.removeInterface( rxListener );
     968             :     }
     969           0 :     if ( xPeerWindow.is() )
     970           0 :         xPeerWindow->removeMouseMotionListener( &maMouseMotionListeners );
     971           0 : }
     972             : 
     973           0 : void UnoControl::addPaintListener( const Reference< XPaintListener >& rxListener ) throw(RuntimeException)
     974             : {
     975           0 :     Reference< XWindow > xPeerWindow;
     976             :     {
     977           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     978           0 :         maPaintListeners.addInterface( rxListener );
     979           0 :         if ( maPaintListeners.getLength() == 1 )
     980           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     981             :     }
     982           0 :     if ( xPeerWindow.is() )
     983           0 :         xPeerWindow->addPaintListener( &maPaintListeners);
     984           0 : }
     985             : 
     986           0 : void UnoControl::removePaintListener( const Reference< XPaintListener >& rxListener ) throw(RuntimeException)
     987             : {
     988           0 :     Reference< XWindow > xPeerWindow;
     989             :     {
     990           0 :         ::osl::MutexGuard aGuard( GetMutex() );
     991           0 :         if ( maPaintListeners.getLength() == 1 )
     992           0 :             xPeerWindow = xPeerWindow.query( getPeer() );
     993           0 :         maPaintListeners.removeInterface( rxListener );
     994             :     }
     995           0 :     if ( xPeerWindow.is() )
     996           0 :         xPeerWindow->removePaintListener( &maPaintListeners );
     997           0 : }
     998             : 
     999             : // XView
    1000           0 : sal_Bool UnoControl::setGraphics( const Reference< XGraphics >& rDevice ) throw(RuntimeException)
    1001             : {
    1002           0 :     Reference< XView > xView;
    1003             :     {
    1004           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1005             : 
    1006           0 :         mxGraphics = rDevice;
    1007           0 :         xView = xView.query( getPeer() );
    1008             :     }
    1009           0 :     return xView.is() ? xView->setGraphics( rDevice ) : sal_True;
    1010             : }
    1011             : 
    1012           0 : Reference< XGraphics > UnoControl::getGraphics(  ) throw(RuntimeException)
    1013             : {
    1014           0 :     return mxGraphics;
    1015             : }
    1016             : 
    1017           0 : awt::Size UnoControl::getSize(  ) throw(RuntimeException)
    1018             : {
    1019           0 :     ::osl::MutexGuard aGuard( GetMutex() );
    1020           0 :     return awt::Size( maComponentInfos.nWidth, maComponentInfos.nHeight );
    1021             : }
    1022             : 
    1023           0 : void UnoControl::draw( sal_Int32 x, sal_Int32 y ) throw(RuntimeException)
    1024             : {
    1025           0 :     Reference< XWindowPeer > xDrawPeer;
    1026           0 :     Reference< XView > xDrawPeerView;
    1027             : 
    1028           0 :     bool bDisposeDrawPeer( false );
    1029             :     {
    1030           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1031             : 
    1032           0 :         xDrawPeer = ImplGetCompatiblePeer( sal_True );
    1033           0 :         bDisposeDrawPeer = xDrawPeer.is() && ( xDrawPeer != getPeer() );
    1034             : 
    1035           0 :         xDrawPeerView.set( xDrawPeer, UNO_QUERY );
    1036           0 :         DBG_ASSERT( xDrawPeerView.is(), "UnoControl::draw: no peer!" );
    1037             :     }
    1038             : 
    1039           0 :     if ( xDrawPeerView.is() )
    1040             :     {
    1041           0 :         Reference< XVclWindowPeer > xWindowPeer;
    1042           0 :         xWindowPeer.set( xDrawPeer, UNO_QUERY );
    1043           0 :         if ( xWindowPeer.is() )
    1044           0 :             xWindowPeer->setDesignMode( mbDesignMode );
    1045           0 :         xDrawPeerView->draw( x, y );
    1046             :     }
    1047             : 
    1048           0 :     if ( bDisposeDrawPeer )
    1049           0 :         xDrawPeer->dispose();
    1050           0 : }
    1051             : 
    1052           0 : void UnoControl::setZoom( float fZoomX, float fZoomY ) throw(RuntimeException)
    1053             : {
    1054           0 :     Reference< XView > xView;
    1055             :     {
    1056           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1057             : 
    1058           0 :         maComponentInfos.nZoomX = fZoomX;
    1059           0 :         maComponentInfos.nZoomY = fZoomY;
    1060             : 
    1061           0 :         xView = xView.query( getPeer() );
    1062             :     }
    1063           0 :     if ( xView.is() )
    1064           0 :         xView->setZoom( fZoomX, fZoomY );
    1065           0 : }
    1066             : 
    1067             : // XControl
    1068           2 : void UnoControl::setContext( const Reference< XInterface >& rxContext ) throw(RuntimeException)
    1069             : {
    1070           2 :     ::osl::MutexGuard aGuard( GetMutex() );
    1071             : 
    1072           2 :     mxContext = rxContext;
    1073           2 : }
    1074             : 
    1075           9 : Reference< XInterface > UnoControl::getContext(  ) throw(RuntimeException)
    1076             : {
    1077           9 :     ::osl::MutexGuard aGuard( GetMutex() );
    1078             : 
    1079           9 :     return mxContext;
    1080             : }
    1081             : 
    1082           0 : void UnoControl::peerCreated()
    1083             : {
    1084           0 :     Reference< XWindow > xWindow( getPeer(), UNO_QUERY );
    1085           0 :     if ( !xWindow.is() )
    1086           0 :         return;
    1087             : 
    1088           0 :     if ( maWindowListeners.getLength() )
    1089           0 :         xWindow->addWindowListener( &maWindowListeners );
    1090             : 
    1091           0 :     if ( maFocusListeners.getLength() )
    1092           0 :         xWindow->addFocusListener( &maFocusListeners );
    1093             : 
    1094           0 :     if ( maKeyListeners.getLength() )
    1095           0 :         xWindow->addKeyListener( &maKeyListeners );
    1096             : 
    1097           0 :     if ( maMouseListeners.getLength() )
    1098           0 :         xWindow->addMouseListener( &maMouseListeners );
    1099             : 
    1100           0 :     if ( maMouseMotionListeners.getLength() )
    1101           0 :         xWindow->addMouseMotionListener( &maMouseMotionListeners );
    1102             : 
    1103           0 :     if ( maPaintListeners.getLength() )
    1104           0 :         xWindow->addPaintListener( &maPaintListeners );
    1105             : }
    1106             : 
    1107           0 : void UnoControl::createPeer( const Reference< XToolkit >& rxToolkit, const Reference< XWindowPeer >& rParentPeer ) throw(RuntimeException)
    1108             : {
    1109           0 :     ::osl::ClearableMutexGuard aGuard( GetMutex() );
    1110           0 :     if ( !mxModel.is() )
    1111             :     {
    1112           0 :         RuntimeException aException;
    1113           0 :         aException.Message = ::rtl::OUString("createPeer: no model!");
    1114           0 :         aException.Context = (XAggregation*)(::cppu::OWeakAggObject*)this;
    1115           0 :         throw( aException );
    1116             :     }
    1117             : 
    1118           0 :     if( !getPeer().is() )
    1119             :     {
    1120           0 :         mbCreatingPeer = sal_True;
    1121             : 
    1122             :         WindowClass eType;
    1123           0 :         Reference< XToolkit >  xToolkit = rxToolkit;
    1124           0 :         if( rParentPeer.is() && mxContext.is() )
    1125             :         {
    1126             :             // kein TopWindow
    1127           0 :             if ( !xToolkit.is() )
    1128           0 :                 xToolkit = rParentPeer->getToolkit();
    1129           0 :             Any aAny = OWeakAggObject::queryInterface( ::getCppuType((const Reference< XControlContainer>*)0) );
    1130           0 :             Reference< XControlContainer > xC;
    1131           0 :             aAny >>= xC;
    1132           0 :             if( xC.is() )
    1133             :                 // It's a container
    1134           0 :                 eType = WindowClass_CONTAINER;
    1135             :             else
    1136           0 :                 eType = WindowClass_SIMPLE;
    1137             :         }
    1138             :         else
    1139             :         { // This is only correct for Top Window
    1140           0 :             if( rParentPeer.is() )
    1141             :             {
    1142           0 :                 if ( !xToolkit.is() )
    1143           0 :                     xToolkit = rParentPeer->getToolkit();
    1144           0 :                 eType = WindowClass_CONTAINER;
    1145             :             }
    1146             :             else
    1147             :             {
    1148           0 :                 if ( !xToolkit.is() )
    1149           0 :                     xToolkit = VCLUnoHelper::CreateToolkit();
    1150           0 :                 eType = WindowClass_TOP;
    1151             :             }
    1152             :         }
    1153           0 :         WindowDescriptor aDescr;
    1154           0 :         aDescr.Type = eType;
    1155           0 :         aDescr.WindowServiceName = GetComponentServiceName();
    1156           0 :         aDescr.Parent = rParentPeer;
    1157           0 :         aDescr.Bounds = getPosSize();
    1158           0 :         aDescr.WindowAttributes = 0;
    1159             : 
    1160             :         // Border
    1161           0 :         Reference< XPropertySet > xPSet( mxModel, UNO_QUERY );
    1162           0 :         Reference< XPropertySetInfo >  xInfo = xPSet->getPropertySetInfo();
    1163             : 
    1164           0 :         Any aVal;
    1165           0 :         ::rtl::OUString aPropName = GetPropertyName( BASEPROPERTY_BORDER );
    1166           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1167             :         {
    1168           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1169           0 :             sal_Int16 n = sal_Int16();
    1170           0 :             if ( aVal >>= n )
    1171             :             {
    1172           0 :                 if ( n )
    1173           0 :                     aDescr.WindowAttributes |= WindowAttribute::BORDER;
    1174             :                 else
    1175           0 :                     aDescr.WindowAttributes |= VclWindowPeerAttribute::NOBORDER;
    1176             :             }
    1177             :         }
    1178             : 
    1179             :         // DESKTOP_AS_PARENT
    1180           0 :         if ( aDescr.Type == WindowClass_TOP )
    1181             :         {
    1182           0 :             aPropName = GetPropertyName( BASEPROPERTY_DESKTOP_AS_PARENT );
    1183           0 :             if ( xInfo->hasPropertyByName( aPropName ) )
    1184             :             {
    1185           0 :                 aVal = xPSet->getPropertyValue( aPropName );
    1186           0 :                 sal_Bool b = sal_Bool();
    1187           0 :                 if ( ( aVal >>= b ) && b)
    1188           0 :                     aDescr.ParentIndex = -1;
    1189             :             }
    1190             :         }
    1191             :         // Moveable
    1192           0 :         aPropName = GetPropertyName( BASEPROPERTY_MOVEABLE );
    1193           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1194             :         {
    1195           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1196           0 :             sal_Bool b = sal_Bool();
    1197           0 :             if ( ( aVal >>= b ) && b)
    1198           0 :                 aDescr.WindowAttributes |= WindowAttribute::MOVEABLE;
    1199             :         }
    1200             : 
    1201             :         // Closeable
    1202           0 :         aPropName = GetPropertyName( BASEPROPERTY_CLOSEABLE );
    1203           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1204             :         {
    1205           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1206           0 :             sal_Bool b = sal_Bool();
    1207           0 :             if ( ( aVal >>= b ) && b)
    1208           0 :                 aDescr.WindowAttributes |= WindowAttribute::CLOSEABLE;
    1209             :         }
    1210             : 
    1211             :         // Dropdown
    1212           0 :         aPropName = GetPropertyName( BASEPROPERTY_DROPDOWN );
    1213           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1214             :         {
    1215           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1216           0 :             sal_Bool b = sal_Bool();
    1217           0 :             if ( ( aVal >>= b ) && b)
    1218           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::DROPDOWN;
    1219             :         }
    1220             : 
    1221             :         // Spin
    1222           0 :         aPropName = GetPropertyName( BASEPROPERTY_SPIN );
    1223           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1224             :         {
    1225           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1226           0 :             sal_Bool b = sal_Bool();
    1227           0 :             if ( ( aVal >>= b ) && b)
    1228           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::SPIN;
    1229             :         }
    1230             : 
    1231             :         // HScroll
    1232           0 :         aPropName = GetPropertyName( BASEPROPERTY_HSCROLL );
    1233           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1234             :         {
    1235           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1236           0 :             sal_Bool b = sal_Bool();
    1237           0 :             if ( ( aVal >>= b ) && b)
    1238           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::HSCROLL;
    1239             :         }
    1240             : 
    1241             :         // VScroll
    1242           0 :         aPropName = GetPropertyName( BASEPROPERTY_VSCROLL );
    1243           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1244             :         {
    1245           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1246           0 :             sal_Bool b = sal_Bool();
    1247           0 :             if ( ( aVal >>= b ) && b)
    1248           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::VSCROLL;
    1249             :         }
    1250             : 
    1251             :         // AutoHScroll
    1252           0 :         aPropName = GetPropertyName( BASEPROPERTY_AUTOHSCROLL );
    1253           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1254             :         {
    1255           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1256           0 :             sal_Bool b = sal_Bool();
    1257           0 :             if ( ( aVal >>= b ) && b)
    1258           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::AUTOHSCROLL;
    1259             :         }
    1260             : 
    1261             :         // AutoVScroll
    1262           0 :         aPropName = GetPropertyName( BASEPROPERTY_AUTOVSCROLL );
    1263           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1264             :         {
    1265           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1266           0 :             sal_Bool b = sal_Bool();
    1267           0 :             if ( ( aVal >>= b ) && b)
    1268           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::AUTOVSCROLL;
    1269             :         }
    1270             : 
    1271             :         //added for issue79712
    1272             :         //NoLabel
    1273           0 :         aPropName = GetPropertyName( BASEPROPERTY_NOLABEL );
    1274           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1275             :         {
    1276           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1277           0 :             sal_Bool b = sal_Bool();
    1278           0 :             if ( ( aVal >>=b ) && b )
    1279           0 :                 aDescr.WindowAttributes |= VclWindowPeerAttribute::NOLABEL;
    1280             :         }
    1281             :         //issue79712 ends
    1282             : 
    1283             :         // Align
    1284           0 :         aPropName = GetPropertyName( BASEPROPERTY_ALIGN );
    1285           0 :         if ( xInfo->hasPropertyByName( aPropName ) )
    1286             :         {
    1287           0 :             aVal = xPSet->getPropertyValue( aPropName );
    1288           0 :             sal_Int16 n = sal_Int16();
    1289           0 :             if ( aVal >>= n )
    1290             :             {
    1291           0 :                 if ( n == PROPERTY_ALIGN_LEFT )
    1292           0 :                     aDescr.WindowAttributes |= VclWindowPeerAttribute::LEFT;
    1293           0 :                 else if ( n == PROPERTY_ALIGN_CENTER )
    1294           0 :                     aDescr.WindowAttributes |= VclWindowPeerAttribute::CENTER;
    1295             :                 else
    1296           0 :                     aDescr.WindowAttributes |= VclWindowPeerAttribute::RIGHT;
    1297             :             }
    1298             :         }
    1299             : 
    1300             :         // Allow derivates to manipulate attributes
    1301           0 :         PrepareWindowDescriptor(aDescr);
    1302             : 
    1303             :         // create the peer
    1304           0 :         setPeer( xToolkit->createWindow( aDescr ) );
    1305             : 
    1306             :         // release the mutex guard (and work with copies of our members)
    1307             :         // this is necessary as our peer may lock the SolarMutex (actually, all currently known peers do), so calling
    1308             :         // into the peer with our own mutex locked may cause deadlocks
    1309             :         // (We _really_ need peers which do not use the SolarMutex. It's really pissing me off that from time to
    1310             :         // time deadlocks pop up because the low-level components like our peers use a mutex which ususally
    1311             :         // is locked at the top of the stack (it protects the global message looping). This is always dangerous, and
    1312             :         // can not always be solved by tampering with other mutexes.
    1313             :         // Unfortunately, the VCL used in the peers is not threadsafe, and by definition needs a locked SolarMutex.)
    1314             :         // 82300 - 12/21/00 - FS
    1315           0 :         UnoControlComponentInfos aComponentInfos(maComponentInfos);
    1316           0 :         sal_Bool bDesignMode(mbDesignMode);
    1317             : 
    1318           0 :         Reference< XGraphics >  xGraphics( mxGraphics           );
    1319           0 :         Reference< XView >      xView    ( getPeer(), UNO_QUERY_THROW );
    1320           0 :         Reference< XWindow >    xWindow  ( getPeer(), UNO_QUERY_THROW );
    1321             : 
    1322           0 :         aGuard.clear();
    1323             : 
    1324             :         // the updateFromModel is done without a locked mutex, too.
    1325             :         // The reason is that the only thing this method does  is firing property changes, and this in general has
    1326             :         // to be done without locked mutexes (as every notification to external listeners).
    1327             :         // 82300 - 12/21/00 - FS
    1328           0 :         updateFromModel();
    1329             : 
    1330           0 :         xView->setZoom( aComponentInfos.nZoomX, aComponentInfos.nZoomY );
    1331             : 
    1332           0 :         setPosSize( aComponentInfos.nX, aComponentInfos.nY, aComponentInfos.nWidth, aComponentInfos.nHeight, aComponentInfos.nFlags );
    1333             : 
    1334           0 :         if( aComponentInfos.bVisible && !bDesignMode )
    1335             :             // Show only after setting the data
    1336           0 :             xWindow->setVisible( aComponentInfos.bVisible );
    1337             : 
    1338           0 :         if( !aComponentInfos.bEnable )
    1339           0 :             xWindow->setEnable( aComponentInfos.bEnable );
    1340             : 
    1341           0 :         xView->setGraphics( xGraphics );
    1342             : 
    1343           0 :         peerCreated();
    1344             : 
    1345           0 :         mbCreatingPeer = sal_False;
    1346           0 :     }
    1347           0 : }
    1348             : 
    1349           9 : Reference< XWindowPeer > UnoControl::getPeer() throw(RuntimeException)
    1350             : {
    1351           9 :     ::osl::MutexGuard aGuard( GetMutex() );
    1352           9 :     return mxPeer;
    1353             : }
    1354             : 
    1355          11 : sal_Bool UnoControl::setModel( const Reference< XControlModel >& rxModel ) throw(RuntimeException)
    1356             : {
    1357          11 :     ::osl::MutexGuard aGuard( GetMutex() );
    1358             : 
    1359          11 :     Reference< XMultiPropertySet > xPropSet( mxModel, UNO_QUERY );
    1360             : 
    1361             :     // query for the XPropertiesChangeListener - our delegator is allowed to overwrite this interface
    1362          11 :     Reference< XPropertiesChangeListener > xListener;
    1363          11 :     queryInterface( ::getCppuType( &xListener ) ) >>= xListener;
    1364             : 
    1365          11 :     if( xPropSet.is() )
    1366           2 :         xPropSet->removePropertiesChangeListener( xListener );
    1367             : 
    1368          11 :     mpData->bLocalizationSupport = false;
    1369          11 :     mxModel = rxModel;
    1370             : 
    1371          11 :     if( mxModel.is() )
    1372             :     {
    1373             :         try
    1374             :         {
    1375           9 :             xPropSet.set( mxModel, UNO_QUERY_THROW );
    1376           9 :             Reference< XPropertySetInfo > xPSI( xPropSet->getPropertySetInfo(), UNO_SET_THROW );
    1377             : 
    1378           9 :             Sequence< ::rtl::OUString> aNames = lcl_ImplGetPropertyNames( xPropSet );
    1379           9 :             xPropSet->addPropertiesChangeListener( aNames, xListener );
    1380             : 
    1381           9 :             mpData->bLocalizationSupport = xPSI->hasPropertyByName( ::rtl::OUString( "ResourceResolver" ) );
    1382             :         }
    1383           0 :         catch( const Exception& )
    1384             :         {
    1385             :             DBG_UNHANDLED_EXCEPTION();
    1386           0 :             mxModel.clear();
    1387             :         }
    1388             :     }
    1389             : 
    1390          11 :     return mxModel.is();
    1391             : }
    1392             : 
    1393           0 : Reference< XControlModel > UnoControl::getModel(    ) throw(RuntimeException)
    1394             : {
    1395           0 :     return mxModel;
    1396             : }
    1397             : 
    1398           0 : Reference< XView > UnoControl::getView(  ) throw(RuntimeException)
    1399             : {
    1400           0 :     return  static_cast< XView* >( this );
    1401             : }
    1402             : 
    1403           0 : void UnoControl::setDesignMode( sal_Bool bOn ) throw(RuntimeException)
    1404             : {
    1405           0 :     ModeChangeEvent aModeChangeEvent;
    1406             : 
    1407           0 :     Reference< XWindow > xWindow;
    1408             :     {
    1409           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1410           0 :         if ( bOn == mbDesignMode )
    1411           0 :             return;
    1412             : 
    1413             :         // remember this
    1414           0 :         mbDesignMode = bOn;
    1415           0 :         xWindow = xWindow.query( getPeer() );
    1416             :         // dispose our current AccessibleContext, if we have one
    1417             :         // (changing the design mode implies having a new implementation for this context,
    1418             :         // so the old one must be declared DEFUNC)
    1419           0 :         disposeAccessibleContext();
    1420             : 
    1421           0 :         aModeChangeEvent.Source = *this;
    1422           0 :         aModeChangeEvent.NewMode = mbDesignMode ? ::rtl::OUString("design") : ::rtl::OUString("alive" );
    1423             :     }
    1424             : 
    1425             :     // ajust the visibility of our window
    1426           0 :     if ( xWindow.is() )
    1427           0 :         xWindow->setVisible( !bOn );
    1428             : 
    1429             :     // and notify our mode listeners
    1430           0 :     maModeChangeListeners.notifyEach( &XModeChangeListener::modeChanged, aModeChangeEvent );
    1431             : }
    1432             : 
    1433           0 : sal_Bool UnoControl::isDesignMode(  ) throw(RuntimeException)
    1434             : {
    1435           0 :     return mbDesignMode;
    1436             : }
    1437             : 
    1438           0 : sal_Bool UnoControl::isTransparent(  ) throw(RuntimeException)
    1439             : {
    1440           0 :     return sal_False;
    1441             : }
    1442             : 
    1443             : // XServiceInfo
    1444           0 : ::rtl::OUString UnoControl::getImplementationName(  ) throw(RuntimeException)
    1445             : {
    1446             :     OSL_FAIL( "This method should be overloaded!" );
    1447           0 :     return ::rtl::OUString();
    1448             : }
    1449             : 
    1450           0 : sal_Bool UnoControl::supportsService( const ::rtl::OUString& rServiceName ) throw(RuntimeException)
    1451             : {
    1452           0 :     ::osl::MutexGuard aGuard( GetMutex() );
    1453             : 
    1454           0 :     Sequence< ::rtl::OUString > aSNL = getSupportedServiceNames();
    1455           0 :     const ::rtl::OUString* pArray = aSNL.getConstArray();
    1456           0 :     const ::rtl::OUString* pArrayEnd = aSNL.getConstArray() + aSNL.getLength();
    1457           0 :     for (; pArray != pArrayEnd; ++pArray )
    1458           0 :         if( *pArray == rServiceName )
    1459           0 :             break;
    1460             : 
    1461           0 :     return pArray != pArrayEnd;
    1462             : }
    1463             : 
    1464           0 : Sequence< ::rtl::OUString > UnoControl::getSupportedServiceNames(  ) throw(RuntimeException)
    1465             : {
    1466           0 :     ::rtl::OUString sName( "com.sun.star.awt.UnoControl" );
    1467           0 :     return Sequence< ::rtl::OUString >( &sName, 1 );
    1468             : }
    1469             : 
    1470             : // ------------------------------------------------------------------------
    1471           0 : Reference< XAccessibleContext > SAL_CALL UnoControl::getAccessibleContext(  ) throw (RuntimeException)
    1472             : {
    1473             :     // creation of the context will certainly require the SolarMutex ...
    1474           0 :     SolarMutexGuard aSolarGuard;
    1475           0 :     ::osl::MutexGuard aGuard( GetMutex() );
    1476             : 
    1477           0 :     Reference< XAccessibleContext > xCurrentContext( maAccessibleContext.get(), UNO_QUERY );
    1478           0 :     if ( !xCurrentContext.is() )
    1479             :     {
    1480           0 :         if ( !mbDesignMode )
    1481             :         {   // in alive mode, use the AccessibleContext of the peer
    1482           0 :             Reference< XAccessible > xPeerAcc( getPeer(), UNO_QUERY );
    1483           0 :             if ( xPeerAcc.is() )
    1484           0 :                 xCurrentContext = xPeerAcc->getAccessibleContext( );
    1485             :         }
    1486             :         else
    1487             :             // in design mode, use a fallback
    1488           0 :             xCurrentContext = ::toolkit::OAccessibleControlContext::create( this );
    1489             : 
    1490             :         DBG_ASSERT( xCurrentContext.is(), "UnoControl::getAccessibleContext: invalid context (invalid peer?)!" );
    1491           0 :         maAccessibleContext = xCurrentContext;
    1492             : 
    1493             :         // get notified when the context is disposed
    1494           0 :         Reference< XComponent > xContextComp( xCurrentContext, UNO_QUERY );
    1495           0 :         if ( xContextComp.is() )
    1496           0 :             xContextComp->addEventListener( this );
    1497             :         // In an ideal world, this is not necessary - there the object would be released as soon as it has been
    1498             :         // disposed, and thus our weak reference would be empty, too.
    1499             :         // But 'til this ideal world comes (means 'til we do never have any refcount/lifetime bugs anymore), we
    1500             :         // need to listen for disposal and reset our weak reference then.
    1501             :     }
    1502             : 
    1503           0 :     return xCurrentContext;
    1504             : }
    1505             : 
    1506           0 : void SAL_CALL UnoControl::addModeChangeListener( const Reference< XModeChangeListener >& _rxListener ) throw (RuntimeException)
    1507             : {
    1508           0 :     ::osl::MutexGuard aGuard( GetMutex() );
    1509           0 :     maModeChangeListeners.addInterface( _rxListener );
    1510           0 : }
    1511             : 
    1512           0 : void SAL_CALL UnoControl::removeModeChangeListener( const Reference< XModeChangeListener >& _rxListener ) throw (RuntimeException)
    1513             : {
    1514           0 :     ::osl::MutexGuard aGuard( GetMutex() );
    1515           0 :     maModeChangeListeners.removeInterface( _rxListener );
    1516           0 : }
    1517             : 
    1518           0 : void SAL_CALL UnoControl::addModeChangeApproveListener( const Reference< XModeChangeApproveListener >& ) throw (NoSupportException, RuntimeException)
    1519             : {
    1520           0 :     throw NoSupportException( );
    1521             : }
    1522             : 
    1523           0 : void SAL_CALL UnoControl::removeModeChangeApproveListener( const Reference< XModeChangeApproveListener >&  ) throw (NoSupportException, RuntimeException)
    1524             : {
    1525           0 :     throw NoSupportException( );
    1526             : }
    1527             : 
    1528             : //----------------------------------------------------------------------------------------------------------------------
    1529           0 : awt::Point SAL_CALL UnoControl::convertPointToLogic( const awt::Point& i_Point, ::sal_Int16 i_TargetUnit ) throw (IllegalArgumentException, RuntimeException)
    1530             : {
    1531           0 :     Reference< XUnitConversion > xPeerConversion;
    1532             :     {
    1533           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1534           0 :         xPeerConversion = xPeerConversion.query( getPeer() );
    1535             :     }
    1536           0 :     if ( xPeerConversion.is() )
    1537           0 :         return xPeerConversion->convertPointToLogic( i_Point, i_TargetUnit );
    1538           0 :     return awt::Point( );
    1539             : }
    1540             : 
    1541             : //----------------------------------------------------------------------------------------------------------------------
    1542           0 : awt::Point SAL_CALL UnoControl::convertPointToPixel( const awt::Point& i_Point, ::sal_Int16 i_SourceUnit ) throw (IllegalArgumentException, RuntimeException)
    1543             : {
    1544           0 :     Reference< XUnitConversion > xPeerConversion;
    1545             :     {
    1546           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1547           0 :         xPeerConversion = xPeerConversion.query( getPeer() );
    1548             :     }
    1549           0 :     if ( xPeerConversion.is() )
    1550           0 :         return xPeerConversion->convertPointToPixel( i_Point, i_SourceUnit );
    1551           0 :     return awt::Point( );
    1552             : }
    1553             : 
    1554             : //----------------------------------------------------------------------------------------------------------------------
    1555           0 : awt::Size SAL_CALL UnoControl::convertSizeToLogic( const awt::Size& i_Size, ::sal_Int16 i_TargetUnit ) throw (IllegalArgumentException, RuntimeException)
    1556             : {
    1557           0 :     Reference< XUnitConversion > xPeerConversion;
    1558             :     {
    1559           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1560           0 :         xPeerConversion = xPeerConversion.query( getPeer() );
    1561             :     }
    1562           0 :     if ( xPeerConversion.is() )
    1563           0 :         return xPeerConversion->convertSizeToLogic( i_Size, i_TargetUnit );
    1564           0 :     return awt::Size( );
    1565             : }
    1566             : 
    1567             : //----------------------------------------------------------------------------------------------------------------------
    1568           0 : awt::Size SAL_CALL UnoControl::convertSizeToPixel( const awt::Size& i_Size, ::sal_Int16 i_SourceUnit ) throw (IllegalArgumentException, RuntimeException)
    1569             : {
    1570           0 :     Reference< XUnitConversion > xPeerConversion;
    1571             :     {
    1572           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1573           0 :         xPeerConversion = xPeerConversion.query( getPeer() );
    1574             :     }
    1575           0 :     if ( xPeerConversion.is() )
    1576           0 :         return xPeerConversion->convertSizeToPixel( i_Size, i_SourceUnit );
    1577           0 :     return awt::Size( );
    1578             : }
    1579             : 
    1580             : //----------------------------------------------------------------------------------------------------------------------
    1581           0 : uno::Reference< awt::XStyleSettings > SAL_CALL UnoControl::getStyleSettings() throw (RuntimeException)
    1582             : {
    1583           0 :     Reference< awt::XStyleSettingsSupplier > xPeerSupplier;
    1584             :     {
    1585           0 :         ::osl::MutexGuard aGuard( GetMutex() );
    1586           0 :         xPeerSupplier = xPeerSupplier.query( getPeer() );
    1587             :     }
    1588           0 :     if ( xPeerSupplier.is() )
    1589           0 :         return xPeerSupplier->getStyleSettings();
    1590           0 :     return NULL;
    1591             : }
    1592             : 
    1593             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10