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