toolkit/source/controls/dialogcontrol.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
  21 #include <vcl/svapp.hxx>
  22 #include <osl/mutex.hxx>
  23 #include <controls/dialogcontrol.hxx>
  24 #include <controls/geometrycontrolmodel.hxx>
  25 #include <toolkit/helper/property.hxx>
  26 #include <helper/servicenames.hxx>
  27 #include <com/sun/star/awt/PosSize.hpp>
  28 #include <com/sun/star/awt/WindowAttribute.hpp>
  29 #include <com/sun/star/uno/XComponentContext.hpp>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <cppuhelper/typeprovider.hxx>
  32 #include <cppuhelper/queryinterface.hxx>
  33 #include <cppuhelper/weak.hxx>
  34 #include <tools/debug.hxx>
  35 #include <comphelper/sequence.hxx>
  36 #include <vcl/outdev.hxx>
  37
  38 #include <vcl/image.hxx>
  39 #include <cppuhelper/implbase.hxx>
  40 #include <unordered_map>
  41
  42 #include <vcl/tabctrl.hxx>
  43 #include <toolkit/awt/vclxwindows.hxx>
  44 #include <toolkit/controls/unocontrols.hxx>
  45
  46 #include <helper/unopropertyarrayhelper.hxx>
  47 #include "controlmodelcontainerbase_internal.hxx"
  48
  49 using namespace ::com::sun::star;
  50 using namespace ::com::sun::star::uno;
  51 using namespace ::com::sun::star::awt;
  52 using namespace ::com::sun::star::lang;
  53 using namespace ::com::sun::star::container;
  54 using namespace ::com::sun::star::beans;
  55 using namespace ::com::sun::star::util;
  56
  57 #define PROPERTY_DIALOGSOURCEURL "DialogSourceURL"
  58 #define PROPERTY_IMAGEURL "ImageURL"
  59 #define PROPERTY_GRAPHIC "Graphic"
  60
  61
  62 // we probably will need both a hash of control models and hash of controls
  63 // => use some template magic
  64
  65 namespace {
  66
  67 template< typename T >
  68 class SimpleNamedThingContainer : public ::cppu::WeakImplHelper< container::XNameContainer >
  69 {
  70     std::unordered_map< OUString, Reference< T > > things;
  71     ::osl::Mutex m_aMutex;
  72 public:
  73     // css::container::XNameContainer, XNameReplace, XNameAccess
  74     virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) override
  75     {
  76         ::osl::MutexGuard aGuard( m_aMutex );
  77         if ( !hasByName( aName ) )
  78             throw NoSuchElementException();
  79         Reference< T > xElement;
  80         if ( ! ( aElement >>= xElement ) )
  81             throw IllegalArgumentException();
  82         things[ aName ] = xElement;
  83     }
  84     virtual Any SAL_CALL getByName( const OUString& aName ) override
  85     {
  86         ::osl::MutexGuard aGuard( m_aMutex );
  87         if ( !hasByName( aName ) )
  88             throw NoSuchElementException();
  89         return uno::makeAny( things[ aName ] );
  90     }
  91     virtual Sequence< OUString > SAL_CALL getElementNames(  ) override
  92     {
  93         ::osl::MutexGuard aGuard( m_aMutex );
  94         return comphelper::mapKeysToSequence( things );
  95     }
  96     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
  97     {
  98         ::osl::MutexGuard aGuard( m_aMutex );
  99         return ( things.find( aName ) != things.end() );
 100     }
 101     virtual void SAL_CALL insertByName( const OUString& aName, const Any& aElement ) override
 102     {
 103         ::osl::MutexGuard aGuard( m_aMutex );
 104         if ( hasByName( aName ) )
 105             throw ElementExistException();
 106         Reference< T > xElement;
 107         if ( ! ( aElement >>= xElement ) )
 108             throw IllegalArgumentException();
 109         things[ aName ] = xElement;
 110     }
 111     virtual void SAL_CALL removeByName( const OUString& aName ) override
 112     {
 113         ::osl::MutexGuard aGuard( m_aMutex );
 114         if ( things.erase( aName ) == 0 )
 115             throw NoSuchElementException();
 116     }
 117     virtual Type SAL_CALL getElementType(  ) override
 118     {
 119         return cppu::UnoType<T>::get();
 120     }
 121     virtual sal_Bool SAL_CALL hasElements(  ) override
 122     {
 123         ::osl::MutexGuard aGuard( m_aMutex );
 124         return ( !things.empty() );
 125     }
 126 };
 127
 128 class UnoControlDialogModel :   public ControlModelContainerBase
 129 {
 130 protected:
 131     css::uno::Reference< css::graphic::XGraphicObject > mxGrfObj;
 132     css::uno::Any          ImplGetDefaultValue( sal_uInt16 nPropId ) const override;
 133     ::cppu::IPropertyArrayHelper&       SAL_CALL getInfoHelper() override;
 134     // ::cppu::OPropertySetHelper
 135     void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue ) override;
 136 public:
 137     explicit UnoControlDialogModel( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
 138     UnoControlDialogModel( const UnoControlDialogModel& rModel );
 139
 140     rtl::Reference<UnoControlModel> Clone() const override;
 141     // css::beans::XMultiPropertySet
 142     css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) override;
 143
 144     // css::io::XPersistObject
 145     OUString SAL_CALL getServiceName() override;
 146
 147     // XServiceInfo
 148     OUString SAL_CALL getImplementationName() override
 149     { return "stardiv.Toolkit.UnoControlDialogModel"; }
 150
 151     css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
 152     {
 153         auto s(ControlModelContainerBase::getSupportedServiceNames());
 154         s.realloc(s.getLength() + 2);
 155         s[s.getLength() - 2] = "com.sun.star.awt.UnoControlDialogModel";
 156         s[s.getLength() - 1] = "stardiv.vcl.controlmodel.Dialog";
 157         return s;
 158     }
 159 };
 160
 161 UnoControlDialogModel::UnoControlDialogModel( const Reference< XComponentContext >& rxContext )
 162     :ControlModelContainerBase( rxContext )
 163 {
 164     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
 165 //  ImplRegisterProperty( BASEPROPERTY_BORDER );
 166     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
 167     ImplRegisterProperty( BASEPROPERTY_ENABLED );
 168     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
 169 //  ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
 170     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
 171     ImplRegisterProperty( BASEPROPERTY_HELPURL );
 172     ImplRegisterProperty( BASEPROPERTY_TITLE );
 173     ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
 174     ImplRegisterProperty( BASEPROPERTY_DESKTOP_AS_PARENT );
 175     ImplRegisterProperty( BASEPROPERTY_DECORATION );
 176     ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
 177     ImplRegisterProperty( BASEPROPERTY_GRAPHIC );
 178     ImplRegisterProperty( BASEPROPERTY_IMAGEURL );
 179     ImplRegisterProperty( BASEPROPERTY_HSCROLL );
 180     ImplRegisterProperty( BASEPROPERTY_VSCROLL );
 181     ImplRegisterProperty( BASEPROPERTY_SCROLLWIDTH );
 182     ImplRegisterProperty( BASEPROPERTY_SCROLLHEIGHT );
 183     ImplRegisterProperty( BASEPROPERTY_SCROLLTOP );
 184     ImplRegisterProperty( BASEPROPERTY_SCROLLLEFT );
 185
 186     Any aBool;
 187     aBool <<= true;
 188     ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
 189     ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
 190     // #TODO separate class for 'UserForm' ( instead of re-using Dialog ? )
 191     uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >;
 192     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
 193 }
 194
 195 UnoControlDialogModel::UnoControlDialogModel( const UnoControlDialogModel& rModel )
 196     : ControlModelContainerBase( rModel )
 197 {
 198     // need to clone BASEPROPERTY_USERFORMCONTAINEES too
 199     Reference< XNameContainer > xSrcNameCont( const_cast< UnoControlDialogModel& >(rModel).getPropertyValue( GetPropertyName( BASEPROPERTY_USERFORMCONTAINEES ) ), UNO_QUERY );
 200     Reference<XNameContainer > xNameCont( new SimpleNamedThingContainer< XControlModel > );
 201
 202     const uno::Sequence< OUString > sNames = xSrcNameCont->getElementNames();
 203     for ( OUString const & name : sNames )
 204     {
 205         if ( xSrcNameCont->hasByName( name ) )
 206             xNameCont->insertByName( name, xSrcNameCont->getByName( name ) );
 207     }
 208     setFastPropertyValue_NoBroadcast( BASEPROPERTY_USERFORMCONTAINEES, makeAny( xNameCont ) );
 209 }
 210
 211 rtl::Reference<UnoControlModel> UnoControlDialogModel::Clone() const
 212 {
 213     // clone the container itself
 214     UnoControlDialogModel* pClone = new UnoControlDialogModel( *this );
 215
 216     Clone_Impl(*pClone);
 217
 218     return pClone;
 219 }
 220
 221
 222 OUString UnoControlDialogModel::getServiceName( )
 223 {
 224     return "stardiv.vcl.controlmodel.Dialog";
 225 }
 226
 227 Any UnoControlDialogModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 228 {
 229     Any aAny;
 230
 231     switch ( nPropId )
 232     {
 233         case BASEPROPERTY_DEFAULTCONTROL:
 234             aAny <<= OUString::createFromAscii( szServiceName_UnoControlDialog );
 235             break;
 236         case BASEPROPERTY_SCROLLWIDTH:
 237         case BASEPROPERTY_SCROLLHEIGHT:
 238         case BASEPROPERTY_SCROLLTOP:
 239         case BASEPROPERTY_SCROLLLEFT:
 240             aAny <<= sal_Int32(0);
 241             break;
 242         default:
 243             aAny = UnoControlModel::ImplGetDefaultValue( nPropId );
 244     }
 245
 246     return aAny;
 247 }
 248
 249 ::cppu::IPropertyArrayHelper& UnoControlDialogModel::getInfoHelper()
 250 {
 251     static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );
 252     return aHelper;
 253 }
 254
 255 // XMultiPropertySet
 256 Reference< XPropertySetInfo > UnoControlDialogModel::getPropertySetInfo(  )
 257 {
 258     static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 259     return xInfo;
 260 }
 261
 262 void SAL_CALL UnoControlDialogModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue )
 263 {
 264     ControlModelContainerBase::setFastPropertyValue_NoBroadcast( nHandle, rValue );
 265     try
 266     {
 267         if ( nHandle == BASEPROPERTY_IMAGEURL && ImplHasProperty( BASEPROPERTY_GRAPHIC ) )
 268         {
 269             OUString sImageURL;
 270             uno::Reference<graphic::XGraphic> xGraphic;
 271             if (rValue >>= sImageURL)
 272             {
 273                 setPropertyValue(
 274                     GetPropertyName(BASEPROPERTY_GRAPHIC),
 275                     uno::makeAny(ImageHelper::getGraphicAndGraphicObjectFromURL_nothrow(
 276                         mxGrfObj, sImageURL)));
 277             }
 278             else if (rValue >>= xGraphic)
 279             {
 280                 setPropertyValue("Graphic", uno::makeAny(xGraphic));
 281             }
 282         }
 283     }
 284     catch( const css::uno::Exception& )
 285     {
 286         OSL_ENSURE( false, "UnoControlDialogModel::setFastPropertyValue_NoBroadcast: caught an exception while setting ImageURL properties!" );
 287     }
 288 }
 289
 290 }
 291
 292
 293 // = class UnoDialogControl
 294
 295
 296 UnoDialogControl::UnoDialogControl( const uno::Reference< uno::XComponentContext >& rxContext )
 297     :UnoDialogControl_Base( rxContext )
 298     ,maTopWindowListeners( *this )
 299     ,mbWindowListener(false)
 300 {
 301     maComponentInfos.nWidth = 300;
 302     maComponentInfos.nHeight = 450;
 303  }
 304
 305 UnoDialogControl::~UnoDialogControl()
 306 {
 307 }
 308
 309 OUString UnoDialogControl::GetComponentServiceName()
 310 {
 311
 312     bool bDecoration( true );
 313     ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
 314     if ( bDecoration )
 315         return "Dialog";
 316     else
 317         return "TabPage";
 318 }
 319
 320 void UnoDialogControl::dispose()
 321 {
 322     SolarMutexGuard aGuard;
 323
 324     EventObject aEvt;
 325     aEvt.Source = static_cast< ::cppu::OWeakObject* >( this );
 326     maTopWindowListeners.disposeAndClear( aEvt );
 327     ControlContainerBase::dispose();
 328 }
 329
 330 void SAL_CALL UnoDialogControl::disposing(
 331     const EventObject& Source )
 332 {
 333     ControlContainerBase::disposing( Source );
 334 }
 335
 336 sal_Bool UnoDialogControl::setModel( const Reference< XControlModel >& rxModel )
 337 {
 338         // #Can we move all the Resource stuff to the ControlContainerBase ?
 339     SolarMutexGuard aGuard;
 340     bool bRet = ControlContainerBase::setModel( rxModel );
 341     ImplStartListingForResourceEvents();
 342     return bRet;
 343 }
 344
 345 void UnoDialogControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer >  & rParentPeer )
 346 {
 347     SolarMutexGuard aGuard;
 348
 349     UnoControlContainer::createPeer( rxToolkit, rParentPeer );
 350
 351     Reference < XTopWindow > xTW( getPeer(), UNO_QUERY );
 352     if ( !xTW.is() )
 353         return;
 354
 355     xTW->setMenuBar( mxMenuBar );
 356
 357     if ( !mbWindowListener )
 358     {
 359         Reference< XWindowListener > xWL( static_cast< cppu::OWeakObject*>( this ), UNO_QUERY );
 360         addWindowListener( xWL );
 361         mbWindowListener = true;
 362     }
 363
 364     if ( maTopWindowListeners.getLength() )
 365         xTW->addTopWindowListener( &maTopWindowListeners );
 366     // there must be a better way than doing this, we can't
 367     // process the scrolltop & scrollleft in XDialog because
 368     // the children haven't been added when those props are applied
 369     ImplSetPeerProperty( GetPropertyName( BASEPROPERTY_SCROLLTOP ), ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_SCROLLTOP ) ) );
 370     ImplSetPeerProperty( GetPropertyName( BASEPROPERTY_SCROLLLEFT ), ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_SCROLLLEFT ) ) );
 371 }
 372
 373 OUString UnoDialogControl::getImplementationName()
 374 {
 375     return "stardiv.Toolkit.UnoDialogControl";
 376 }
 377
 378 sal_Bool UnoDialogControl::supportsService(OUString const & ServiceName)
 379 {
 380     return cppu::supportsService(this, ServiceName);
 381 }
 382
 383 css::uno::Sequence<OUString> UnoDialogControl::getSupportedServiceNames()
 384 {
 385     return css::uno::Sequence<OUString>{
 386         "com.sun.star.awt.UnoControlDialog",
 387         "stardiv.vcl.control.Dialog"};
 388 }
 389
 390 void UnoDialogControl::PrepareWindowDescriptor( css::awt::WindowDescriptor& rDesc )
 391 {
 392     UnoControlContainer::PrepareWindowDescriptor( rDesc );
 393     bool bDecoration( true );
 394     ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
 395     if ( !bDecoration )
 396     {
 397         // Now we have to manipulate the WindowDescriptor
 398         rDesc.WindowAttributes = rDesc.WindowAttributes | css::awt::WindowAttribute::NODECORATION;
 399     }
 400
 401     // We have to set the graphic property before the peer
 402     // will be created. Otherwise the properties will be copied
 403     // into the peer via propertiesChangeEvents. As the order of
 404     // can lead to overwrites we have to set the graphic property
 405     // before the propertiesChangeEvents are sent!
 406     OUString aImageURL;
 407     Reference< graphic::XGraphic > xGraphic;
 408     if (( ImplGetPropertyValue( PROPERTY_IMAGEURL ) >>= aImageURL ) &&
 409         ( !aImageURL.isEmpty() ))
 410     {
 411         OUString absoluteUrl = getPhysicalLocation(ImplGetPropertyValue(PROPERTY_DIALOGSOURCEURL), uno::makeAny(aImageURL));
 412         xGraphic = ImageHelper::getGraphicFromURL_nothrow( absoluteUrl );
 413         ImplSetPropertyValue( PROPERTY_GRAPHIC, uno::makeAny( xGraphic ), true );
 414     }
 415 }
 416
 417 void UnoDialogControl::addTopWindowListener( const Reference< XTopWindowListener >& rxListener )
 418 {
 419     maTopWindowListeners.addInterface( rxListener );
 420     if( getPeer().is() && maTopWindowListeners.getLength() == 1 )
 421     {
 422         Reference < XTopWindow >  xTW( getPeer(), UNO_QUERY );
 423         xTW->addTopWindowListener( &maTopWindowListeners );
 424     }
 425 }
 426
 427 void UnoDialogControl::removeTopWindowListener( const Reference< XTopWindowListener >& rxListener )
 428 {
 429     if( getPeer().is() && maTopWindowListeners.getLength() == 1 )
 430     {
 431         Reference < XTopWindow >  xTW( getPeer(), UNO_QUERY );
 432         xTW->removeTopWindowListener( &maTopWindowListeners );
 433     }
 434     maTopWindowListeners.removeInterface( rxListener );
 435 }
 436
 437 void UnoDialogControl::toFront(  )
 438 {
 439     SolarMutexGuard aGuard;
 440     if ( getPeer().is() )
 441     {
 442         Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
 443         if( xTW.is() )
 444             xTW->toFront();
 445     }
 446 }
 447
 448 void UnoDialogControl::toBack(  )
 449 {
 450     SolarMutexGuard aGuard;
 451     if ( getPeer().is() )
 452     {
 453         Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
 454         if( xTW.is() )
 455             xTW->toBack();
 456     }
 457 }
 458
 459 void UnoDialogControl::setMenuBar( const Reference< XMenuBar >& rxMenuBar )
 460 {
 461     SolarMutexGuard aGuard;
 462     mxMenuBar = rxMenuBar;
 463     if ( getPeer().is() )
 464     {
 465         Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
 466         if( xTW.is() )
 467             xTW->setMenuBar( mxMenuBar );
 468     }
 469 }
 470 static ::Size ImplMapPixelToAppFont( OutputDevice const * pOutDev, const ::Size& aSize )
 471 {
 472     ::Size aTmp = pOutDev->PixelToLogic(aSize, MapMode(MapUnit::MapAppFont));
 473     return aTmp;
 474 }
 475 // css::awt::XWindowListener
 476 void SAL_CALL UnoDialogControl::windowResized( const css::awt::WindowEvent& e )
 477 {
 478     OutputDevice*pOutDev = Application::GetDefaultDevice();
 479     DBG_ASSERT( pOutDev, "Missing Default Device!" );
 480     if ( !pOutDev || mbSizeModified )
 481         return;
 482
 483     // Currently we are simply using MapUnit::MapAppFont
 484     ::Size aAppFontSize( e.Width, e.Height );
 485
 486     Reference< XControl > xDialogControl( *this, UNO_QUERY_THROW );
 487     Reference< XDevice > xDialogDevice( xDialogControl->getPeer(), UNO_QUERY );
 488     OSL_ENSURE( xDialogDevice.is(), "UnoDialogControl::windowResized: no peer, but a windowResized event?" );
 489
 490     // #i87592 In design mode the drawing layer works with sizes with decoration.
 491     // Therefore we have to subtract them before writing back to the properties (model).
 492     if ( xDialogDevice.is() && mbDesignMode )
 493     {
 494         DeviceInfo aDeviceInfo( xDialogDevice->getInfo() );
 495         aAppFontSize.AdjustWidth( -(aDeviceInfo.LeftInset + aDeviceInfo.RightInset) );
 496         aAppFontSize.AdjustHeight( -(aDeviceInfo.TopInset + aDeviceInfo.BottomInset) );
 497     }
 498
 499     aAppFontSize = ImplMapPixelToAppFont( pOutDev, aAppFontSize );
 500
 501     // Remember that changes have been done by listener. No need to
 502     // update the position because of property change event.
 503     mbSizeModified = true;
 504     Sequence< OUString > aProps( 2 );
 505     Sequence< Any > aValues( 2 );
 506     // Properties in a sequence must be sorted!
 507     aProps[0] = "Height";
 508     aProps[1] = "Width";
 509     aValues[0] <<= aAppFontSize.Height();
 510     aValues[1] <<= aAppFontSize.Width();
 511
 512     ImplSetPropertyValues( aProps, aValues, true );
 513     mbSizeModified = false;
 514
 515 }
 516
 517 void SAL_CALL UnoDialogControl::windowMoved( const css::awt::WindowEvent& e )
 518 {
 519     OutputDevice*pOutDev = Application::GetDefaultDevice();
 520     DBG_ASSERT( pOutDev, "Missing Default Device!" );
 521     if ( !pOutDev || mbPosModified )
 522         return;
 523
 524     // Currently we are simply using MapUnit::MapAppFont
 525     ::Size aTmp( e.X, e.Y );
 526     aTmp = ImplMapPixelToAppFont( pOutDev, aTmp );
 527
 528     // Remember that changes have been done by listener. No need to
 529     // update the position because of property change event.
 530     mbPosModified = true;
 531     Sequence< OUString > aProps( 2 );
 532     Sequence< Any > aValues( 2 );
 533     aProps[0] = "PositionX";
 534     aProps[1] = "PositionY";
 535     aValues[0] <<= aTmp.Width();
 536     aValues[1] <<= aTmp.Height();
 537
 538     ImplSetPropertyValues( aProps, aValues, true );
 539     mbPosModified = false;
 540
 541 }
 542
 543 void SAL_CALL UnoDialogControl::windowShown( const EventObject& ) {}
 544
 545 void SAL_CALL UnoDialogControl::windowHidden( const EventObject& ) {}
 546
 547 void SAL_CALL UnoDialogControl::endDialog( ::sal_Int32 i_result )
 548 {
 549     Reference< XDialog2 > xPeerDialog( getPeer(), UNO_QUERY );
 550     if ( xPeerDialog.is() )
 551         xPeerDialog->endDialog( i_result );
 552 }
 553
 554 void SAL_CALL UnoDialogControl::setHelpId( const OUString& i_id )
 555 {
 556     Reference< XDialog2 > xPeerDialog( getPeer(), UNO_QUERY );
 557     if ( xPeerDialog.is() )
 558         xPeerDialog->setHelpId( i_id );
 559 }
 560
 561 void UnoDialogControl::setTitle( const OUString& Title )
 562 {
 563     SolarMutexGuard aGuard;
 564     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ), uno::Any(Title), true );
 565 }
 566
 567 OUString UnoDialogControl::getTitle()
 568 {
 569     SolarMutexGuard aGuard;
 570     return ImplGetPropertyValue_UString( BASEPROPERTY_TITLE );
 571 }
 572
 573 sal_Int16 UnoDialogControl::execute()
 574 {
 575     SolarMutexGuard aGuard;
 576     sal_Int16 nDone = -1;
 577     if ( getPeer().is() )
 578     {
 579         Reference< XDialog > xDlg( getPeer(), UNO_QUERY );
 580         if( xDlg.is() )
 581         {
 582             GetComponentInfos().bVisible = true;
 583             nDone = xDlg->execute();
 584             GetComponentInfos().bVisible = false;
 585         }
 586     }
 587     return nDone;
 588 }
 589
 590 void UnoDialogControl::endExecute()
 591 {
 592     SolarMutexGuard aGuard;
 593     if ( getPeer().is() )
 594     {
 595         Reference< XDialog > xDlg( getPeer(), UNO_QUERY );
 596         if( xDlg.is() )
 597         {
 598             xDlg->endExecute();
 599             GetComponentInfos().bVisible = false;
 600         }
 601     }
 602 }
 603
 604 // XModifyListener
 605 void SAL_CALL UnoDialogControl::modified(
 606     const lang::EventObject& /*rEvent*/ )
 607 {
 608     ImplUpdateResourceResolver();
 609 }
 610
 611 void UnoDialogControl::ImplModelPropertiesChanged( const Sequence< PropertyChangeEvent >& rEvents )
 612 {
 613     for( const PropertyChangeEvent& rEvt : rEvents )
 614     {
 615         Reference< XControlModel > xModel( rEvt.Source, UNO_QUERY );
 616         bool bOwnModel = xModel.get() == getModel().get();
 617         if (bOwnModel && rEvt.PropertyName == "ImageURL" && !ImplHasProperty(BASEPROPERTY_GRAPHIC))
 618         {
 619             OUString aImageURL;
 620             Reference< graphic::XGraphic > xGraphic;
 621             if (( ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_IMAGEURL ) ) >>= aImageURL ) &&
 622                 ( !aImageURL.isEmpty() ))
 623             {
 624                 OUString absoluteUrl = getPhysicalLocation(ImplGetPropertyValue(GetPropertyName(BASEPROPERTY_DIALOGSOURCEURL)), uno::makeAny(aImageURL));
 625                 xGraphic = ImageHelper::getGraphicFromURL_nothrow( absoluteUrl );
 626             }
 627             ImplSetPropertyValue(  GetPropertyName( BASEPROPERTY_GRAPHIC), uno::makeAny( xGraphic ), true );
 628             break;
 629         }
 630         else if (bOwnModel && rEvt.PropertyName == "Graphic")
 631         {
 632             uno::Reference<graphic::XGraphic> xGraphic;
 633             if (ImplGetPropertyValue("Graphic") >>= xGraphic)
 634             {
 635                 ImplSetPropertyValue("Graphic", uno::makeAny(xGraphic), true);
 636             }
 637             break;
 638         }
 639     }
 640     ControlContainerBase::ImplModelPropertiesChanged(rEvents);
 641 }
 642
 643
 644
 645 UnoMultiPageControl::UnoMultiPageControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext), maTabListeners( *this )
 646 {
 647     maComponentInfos.nWidth = 280;
 648     maComponentInfos.nHeight = 400;
 649 }
 650
 651 UnoMultiPageControl::~UnoMultiPageControl()
 652 {
 653 }
 654 // XTabListener
 655
 656 void SAL_CALL UnoMultiPageControl::inserted( SAL_UNUSED_PARAMETER ::sal_Int32 )
 657 {
 658 }
 659 void SAL_CALL UnoMultiPageControl::removed( SAL_UNUSED_PARAMETER ::sal_Int32 )
 660 {
 661 }
 662 void SAL_CALL UnoMultiPageControl::changed( SAL_UNUSED_PARAMETER ::sal_Int32,
 663                                             SAL_UNUSED_PARAMETER const Sequence< NamedValue >& )
 664 {
 665 }
 666 void SAL_CALL UnoMultiPageControl::activated( ::sal_Int32 ID )
 667 {
 668     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( ID ), false );
 669
 670 }
 671 void SAL_CALL UnoMultiPageControl::deactivated( SAL_UNUSED_PARAMETER ::sal_Int32 )
 672 {
 673 }
 674 void SAL_CALL UnoMultiPageControl::disposing(const EventObject&)
 675 {
 676 }
 677
 678 void SAL_CALL UnoMultiPageControl::dispose()
 679 {
 680     lang::EventObject aEvt;
 681     aEvt.Source = static_cast<cppu::OWeakObject*>(this);
 682     maTabListeners.disposeAndClear( aEvt );
 683     ControlContainerBase::dispose();
 684 }
 685
 686 // css::awt::XSimpleTabController
 687 ::sal_Int32 SAL_CALL UnoMultiPageControl::insertTab()
 688 {
 689     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 690     return xMultiPage->insertTab();
 691 }
 692
 693 void SAL_CALL UnoMultiPageControl::removeTab( ::sal_Int32 ID )
 694 {
 695     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 696     xMultiPage->removeTab( ID );
 697 }
 698
 699 void SAL_CALL UnoMultiPageControl::setTabProps( ::sal_Int32 ID, const Sequence< NamedValue >& Properties )
 700 {
 701     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 702     xMultiPage->setTabProps( ID, Properties );
 703 }
 704
 705 Sequence< NamedValue > SAL_CALL UnoMultiPageControl::getTabProps( ::sal_Int32 ID )
 706 {
 707     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 708     return xMultiPage->getTabProps( ID );
 709 }
 710
 711 void SAL_CALL UnoMultiPageControl::activateTab( ::sal_Int32 ID )
 712 {
 713     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 714     xMultiPage->activateTab( ID );
 715     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( ID ), true );
 716
 717 }
 718
 719 ::sal_Int32 SAL_CALL UnoMultiPageControl::getActiveTabID()
 720 {
 721     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY_THROW );
 722     return xMultiPage->getActiveTabID();
 723 }
 724
 725 void SAL_CALL UnoMultiPageControl::addTabListener( const Reference< XTabListener >& Listener )
 726 {
 727     maTabListeners.addInterface( Listener );
 728     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
 729     if ( xMultiPage.is()  && maTabListeners.getLength() == 1 )
 730         xMultiPage->addTabListener( &maTabListeners );
 731 }
 732
 733 void SAL_CALL UnoMultiPageControl::removeTabListener( const Reference< XTabListener >& Listener )
 734 {
 735     Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
 736     if ( xMultiPage.is()  && maTabListeners.getLength() == 1 )
 737         xMultiPage->removeTabListener( &maTabListeners );
 738     maTabListeners.removeInterface( Listener );
 739 }
 740
 741 IMPL_IMPLEMENTATION_ID( UnoMultiPageControl )
 742
 743 // lang::XTypeProvider
 744 css::uno::Sequence< css::uno::Type > UnoMultiPageControl::getTypes()
 745 {
 746     static const ::cppu::OTypeCollection aTypeList(
 747         cppu::UnoType<css::lang::XTypeProvider>::get(),
 748         cppu::UnoType<awt::XSimpleTabController>::get(),
 749         cppu::UnoType<awt::XTabListener>::get(),
 750         ControlContainerBase::getTypes()
 751     );
 752     return aTypeList.getTypes();
 753 }
 754
 755 // uno::XInterface
 756 uno::Any UnoMultiPageControl::queryAggregation( const uno::Type & rType )
 757 {
 758     uno::Any aRet = ::cppu::queryInterface( rType,
 759                                         static_cast< awt::XTabListener* >(this),
 760                                         static_cast< awt::XSimpleTabController* >(this) );
 761     return (aRet.hasValue() ? aRet : ControlContainerBase::queryAggregation( rType ));
 762 }
 763
 764 OUString UnoMultiPageControl::GetComponentServiceName()
 765 {
 766     bool bDecoration( true );
 767     ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
 768     if ( bDecoration )
 769         return "tabcontrol";
 770     // Hopefully we can tweak the tabcontrol to display without tabs
 771     return "tabcontrolnotabs";
 772 }
 773
 774 void UnoMultiPageControl::bindPage( const uno::Reference< awt::XControl >& _rxControl )
 775 {
 776     uno::Reference< awt::XWindowPeer > xPage( _rxControl->getPeer() );
 777     uno::Reference< awt::XSimpleTabController > xTabCntrl( getPeer(), uno::UNO_QUERY );
 778     uno::Reference< beans::XPropertySet > xProps( _rxControl->getModel(), uno::UNO_QUERY );
 779
 780     VCLXTabPage* pXPage = dynamic_cast< VCLXTabPage* >( xPage.get() );
 781     TabPage* pPage = pXPage ? pXPage->getTabPage() : nullptr;
 782     if ( xTabCntrl.is() && pPage )
 783     {
 784         VCLXMultiPage* pXTab = dynamic_cast< VCLXMultiPage* >( xTabCntrl.get() );
 785         if ( pXTab )
 786         {
 787             OUString sTitle;
 788             xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ) ) >>= sTitle;
 789             pXTab->insertTab( pPage, sTitle);
 790         }
 791     }
 792
 793 }
 794
 795 void UnoMultiPageControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer >  & rParentPeer )
 796 {
 797     SolarMutexGuard aSolarGuard;
 798
 799     UnoControlContainer::createPeer( rxToolkit, rParentPeer );
 800
 801     const uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
 802     for( const auto& rCtrl : aCtrls )
 803        bindPage( rCtrl );
 804     sal_Int32 nActiveTab(0);
 805     Reference< XPropertySet > xMultiProps( getModel(), UNO_QUERY );
 806     xMultiProps->getPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ) ) >>= nActiveTab;
 807
 808     uno::Reference< awt::XSimpleTabController > xTabCntrl( getPeer(), uno::UNO_QUERY );
 809     if ( xTabCntrl.is() )
 810     {
 811         xTabCntrl->addTabListener( this );
 812         if ( nActiveTab && aCtrls.hasElements() ) // Ensure peer is initialise with correct activated tab
 813         {
 814             xTabCntrl->activateTab( nActiveTab );
 815             ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( nActiveTab ), true );
 816         }
 817     }
 818 }
 819
 820 void    UnoMultiPageControl::impl_createControlPeerIfNecessary( const uno::Reference< awt::XControl >& _rxControl)
 821 {
 822     OSL_PRECOND( _rxControl.is(), "UnoMultiPageControl::impl_createControlPeerIfNecessary: invalid control, this will crash!" );
 823
 824     // if the container already has a peer, then also create a peer for the control
 825     uno::Reference< awt::XWindowPeer > xMyPeer( getPeer() );
 826
 827     if( xMyPeer.is() )
 828     {
 829         _rxControl->createPeer( nullptr, xMyPeer );
 830         bindPage( _rxControl );
 831         ImplActivateTabControllers();
 832     }
 833
 834 }
 835
 836 // ------------- UnoMultiPageModel -----------------
 837
 838 UnoMultiPageModel::UnoMultiPageModel( const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
 839 {
 840     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
 841     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
 842     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
 843     ImplRegisterProperty( BASEPROPERTY_ENABLED );
 844
 845     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
 846     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
 847     ImplRegisterProperty( BASEPROPERTY_HELPURL );
 848     ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
 849     //ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
 850     ImplRegisterProperty( BASEPROPERTY_MULTIPAGEVALUE );
 851     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
 852     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
 853
 854     Any aBool;
 855     aBool <<= true;
 856     ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
 857     ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
 858     ImplRegisterProperty( BASEPROPERTY_DECORATION, aBool );
 859     // MultiPage Control has the tab stop property. And the default value is True.
 860     ImplRegisterProperty( BASEPROPERTY_TABSTOP, aBool );
 861
 862     uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >;
 863     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
 864 }
 865
 866 UnoMultiPageModel::~UnoMultiPageModel()
 867 {
 868 }
 869
 870 rtl::Reference<UnoControlModel> UnoMultiPageModel::Clone() const
 871 {
 872     // clone the container itself
 873     UnoMultiPageModel* pClone = new UnoMultiPageModel( *this );
 874     Clone_Impl( *pClone );
 875     return pClone;
 876 }
 877
 878 OUString UnoMultiPageModel::getServiceName()
 879 {
 880     return "com.sun.star.awt.UnoMultiPageModel";
 881 }
 882
 883 uno::Any UnoMultiPageModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 884 {
 885     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
 886     {
 887         return uno::Any( OUString( "com.sun.star.awt.UnoControlMultiPage" ) );
 888     }
 889     return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
 890 }
 891
 892 ::cppu::IPropertyArrayHelper& UnoMultiPageModel::getInfoHelper()
 893 {
 894     static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );
 895     return aHelper;
 896 }
 897
 898 // beans::XMultiPropertySet
 899 uno::Reference< beans::XPropertySetInfo > UnoMultiPageModel::getPropertySetInfo(  )
 900 {
 901     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 902     return xInfo;
 903 }
 904
 905 void UnoMultiPageModel::insertByName( const OUString& aName, const Any& aElement )
 906 {
 907     Reference< XServiceInfo > xInfo;
 908     aElement >>= xInfo;
 909
 910     if ( !xInfo.is() )
 911         throw IllegalArgumentException();
 912
 913     // Only a Page model can be inserted into the multipage
 914     if ( !xInfo->supportsService( "com.sun.star.awt.UnoPageModel" ) )
 915         throw IllegalArgumentException();
 916
 917     return ControlModelContainerBase::insertByName( aName, aElement );
 918 }
 919
 920
 921 sal_Bool SAL_CALL UnoMultiPageModel::getGroupControl(  )
 922 {
 923     return true;
 924 }
 925
 926
 927
 928 UnoPageControl::UnoPageControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext)
 929 {
 930     maComponentInfos.nWidth = 280;
 931     maComponentInfos.nHeight = 400;
 932 }
 933
 934 UnoPageControl::~UnoPageControl()
 935 {
 936 }
 937
 938 OUString UnoPageControl::GetComponentServiceName()
 939 {
 940     return "tabpage";
 941 }
 942
 943
 944 // ------------- UnoPageModel -----------------
 945
 946 UnoPageModel::UnoPageModel( const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
 947 {
 948     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
 949     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
 950     ImplRegisterProperty( BASEPROPERTY_ENABLED );
 951     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
 952
 953     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
 954     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
 955     ImplRegisterProperty( BASEPROPERTY_HELPURL );
 956     ImplRegisterProperty( BASEPROPERTY_TITLE );
 957     ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
 958     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
 959     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
 960 //    ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
 961
 962     Any aBool;
 963     aBool <<= true;
 964     ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
 965     ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
 966     //ImplRegisterProperty( BASEPROPERTY_TABSTOP, aBool );
 967
 968     uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >;
 969     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
 970 }
 971
 972 UnoPageModel::~UnoPageModel()
 973 {
 974 }
 975
 976 rtl::Reference<UnoControlModel> UnoPageModel::Clone() const
 977 {
 978     // clone the container itself
 979     UnoPageModel* pClone = new UnoPageModel( *this );
 980     Clone_Impl( *pClone );
 981     return pClone;
 982 }
 983
 984 OUString UnoPageModel::getServiceName()
 985 {
 986     return "com.sun.star.awt.UnoPageModel";
 987 }
 988
 989 uno::Any UnoPageModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 990 {
 991     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
 992     {
 993         return uno::Any( OUString( "com.sun.star.awt.UnoControlPage" ) );
 994     }
 995     return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
 996 }
 997
 998 ::cppu::IPropertyArrayHelper& UnoPageModel::getInfoHelper()
 999 {
1000     static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );
1001     return aHelper;
1002 }
1003
1004 // beans::XMultiPropertySet
1005 uno::Reference< beans::XPropertySetInfo > UnoPageModel::getPropertySetInfo(  )
1006 {
1007     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1008     return xInfo;
1009 }
1010
1011
1012 sal_Bool SAL_CALL UnoPageModel::getGroupControl(  )
1013 {
1014     return false;
1015 }
1016
1017 // Frame control
1018
1019
1020
1021 UnoFrameControl::UnoFrameControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext)
1022 {
1023     maComponentInfos.nWidth = 280;
1024     maComponentInfos.nHeight = 400;
1025 }
1026
1027 UnoFrameControl::~UnoFrameControl()
1028 {
1029 }
1030
1031 OUString UnoFrameControl::GetComponentServiceName()
1032 {
1033     return "frame";
1034 }
1035
1036 void UnoFrameControl::ImplSetPosSize( Reference< XControl >& rxCtrl )
1037 {
1038     bool bOwnCtrl = false;
1039     OUString sTitle;
1040     if ( rxCtrl.get() == Reference<XControl>( this ).get() )
1041         bOwnCtrl = true;
1042     Reference< XPropertySet > xProps( getModel(), UNO_QUERY );
1043     //xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ) ) >>= sTitle;
1044     xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ) ) >>= sTitle;
1045
1046     ControlContainerBase::ImplSetPosSize( rxCtrl );
1047     Reference < XWindow > xW( rxCtrl, UNO_QUERY );
1048     if ( bOwnCtrl || !xW.is() || sTitle.isEmpty() )
1049         return;
1050
1051     awt::Rectangle aSizePos = xW->getPosSize();
1052
1053     sal_Int32 nX = aSizePos.X, nY = aSizePos.Y, nWidth = aSizePos.Width, nHeight = aSizePos.Height;
1054     // Retrieve the values set by the base class
1055     OutputDevice*pOutDev = Application::GetDefaultDevice();
1056     if ( pOutDev )
1057     {
1058         // Adjust Y based on height of Title
1059         ::tools::Rectangle aRect = pOutDev->GetTextRect( {}, sTitle );
1060         nY = nY + ( aRect.GetHeight() / 2 );
1061     }
1062     else
1063     {
1064         Reference< XWindowPeer > xPeer = ImplGetCompatiblePeer();
1065         Reference< XDevice > xD( xPeer, UNO_QUERY );
1066
1067         SimpleFontMetric aFM;
1068         FontDescriptor aFD;
1069         Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_FONTDESCRIPTOR ) );
1070
1071         aVal >>= aFD;
1072         if ( !aFD.StyleName.isEmpty() )
1073         {
1074             Reference< XFont > xFont = xD->getFont( aFD );
1075             aFM = xFont->getFontMetric();
1076         }
1077         else
1078         {
1079             Reference< XGraphics > xG = xD->createGraphics();
1080             aFM = xG->getFontMetric();
1081         }
1082
1083         sal_Int16 nH = aFM.Ascent + aFM.Descent;
1084         // offset y based on height of font ( not sure if my guess at the correct calculation is correct here )
1085         nY = nY + ( nH / 8); // how do I test this
1086     }
1087     xW->setPosSize( nX, nY, nWidth, nHeight, PosSize::POSSIZE );
1088 }
1089
1090 // ------------- UnoFrameModel -----------------
1091
1092 UnoFrameModel::UnoFrameModel(  const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
1093 {
1094     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
1095     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
1096     ImplRegisterProperty( BASEPROPERTY_ENABLED );
1097     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
1098     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
1099     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
1100     ImplRegisterProperty( BASEPROPERTY_HELPURL );
1101     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
1102     ImplRegisterProperty( BASEPROPERTY_LABEL );
1103     ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
1104     ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
1105     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
1106     ImplRegisterProperty( BASEPROPERTY_HSCROLL );
1107     ImplRegisterProperty( BASEPROPERTY_VSCROLL );
1108     ImplRegisterProperty( BASEPROPERTY_SCROLLWIDTH );
1109     ImplRegisterProperty( BASEPROPERTY_SCROLLHEIGHT );
1110     ImplRegisterProperty( BASEPROPERTY_SCROLLTOP );
1111     ImplRegisterProperty( BASEPROPERTY_SCROLLLEFT );
1112
1113
1114     uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >;
1115     ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
1116 }
1117
1118 UnoFrameModel::~UnoFrameModel()
1119 {
1120 }
1121
1122 rtl::Reference<UnoControlModel> UnoFrameModel::Clone() const
1123 {
1124     // clone the container itself
1125     UnoFrameModel* pClone = new UnoFrameModel( *this );
1126     Clone_Impl( *pClone );
1127     return pClone;
1128 }
1129
1130 OUString UnoFrameModel::getServiceName()
1131 {
1132     return "com.sun.star.awt.UnoFrameModel";
1133 }
1134
1135 uno::Any UnoFrameModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1136 {
1137     switch ( nPropId )
1138     {
1139         case BASEPROPERTY_DEFAULTCONTROL:
1140         {
1141             return uno::Any( OUString( "com.sun.star.awt.UnoControlFrame" ) );
1142         }
1143         case BASEPROPERTY_SCROLLWIDTH:
1144         case BASEPROPERTY_SCROLLHEIGHT:
1145         case BASEPROPERTY_SCROLLTOP:
1146         case BASEPROPERTY_SCROLLLEFT:
1147             return uno::Any( sal_Int32(0) );
1148         case BASEPROPERTY_USERFORMCONTAINEES:
1149         {
1150             uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >;
1151             return makeAny( xNameCont );
1152         }
1153     }
1154     return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
1155 }
1156
1157 ::cppu::IPropertyArrayHelper& UnoFrameModel::getInfoHelper()
1158 {
1159     static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );
1160     return aHelper;
1161 }
1162
1163 // beans::XMultiPropertySet
1164 uno::Reference< beans::XPropertySetInfo > UnoFrameModel::getPropertySetInfo(  )
1165 {
1166     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1167     return xInfo;
1168 }
1169
1170 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1171 stardiv_Toolkit_UnoControlDialogModel_get_implementation(
1172     css::uno::XComponentContext *context,
1173     css::uno::Sequence<css::uno::Any> const &)
1174 {
1175     return cppu::acquire(new OGeometryControlModel<UnoControlDialogModel>(context));
1176 }
1177
1178 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1179 stardiv_Toolkit_UnoDialogControl_get_implementation(
1180     css::uno::XComponentContext *context,
1181     css::uno::Sequence<css::uno::Any> const &)
1182 {
1183     return cppu::acquire(new UnoDialogControl(context));
1184 }
1185
1186 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1187 stardiv_Toolkit_UnoMultiPageControl_get_implementation(
1188     css::uno::XComponentContext *context,
1189     css::uno::Sequence<css::uno::Any> const &)
1190 {
1191     return cppu::acquire(new UnoMultiPageControl(context));
1192 }
1193
1194 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1195 stardiv_Toolkit_UnoMultiPageModel_get_implementation(
1196     css::uno::XComponentContext *context,
1197     css::uno::Sequence<css::uno::Any> const &)
1198 {
1199     return cppu::acquire(new UnoMultiPageModel(context));
1200 }
1201
1202 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1203 stardiv_Toolkit_UnoPageControl_get_implementation(
1204     css::uno::XComponentContext *context,
1205     css::uno::Sequence<css::uno::Any> const &)
1206 {
1207     return cppu::acquire(new UnoPageControl(context));
1208 }
1209
1210 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1211 stardiv_Toolkit_UnoPageModel_get_implementation(
1212     css::uno::XComponentContext *context,
1213     css::uno::Sequence<css::uno::Any> const &)
1214 {
1215     return cppu::acquire(new UnoPageModel(context));
1216 }
1217
1218 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1219 stardiv_Toolkit_UnoFrameControl_get_implementation(
1220     css::uno::XComponentContext *context,
1221     css::uno::Sequence<css::uno::Any> const &)
1222 {
1223     return cppu::acquire(new UnoFrameControl(context));
1224 }
1225
1226 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1227 stardiv_Toolkit_UnoFrameModel_get_implementation(
1228     css::uno::XComponentContext *context,
1229     css::uno::Sequence<css::uno::Any> const &)
1230 {
1231     return cppu::acquire(new UnoFrameModel(context));
1232 }
1233
1234 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */