toolkit/source/controls/unocontrol.cxx

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