toolkit/source/controls/unocontrol.cxx

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