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