toolkit/source/controls/unocontrols.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/awt/XTextArea.hpp>
  21 #include <com/sun/star/awt/XVclWindowPeer.hpp>
  22 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  23 #include <com/sun/star/awt/PosSize.hpp>
  24 #include <com/sun/star/awt/VisualEffect.hpp>
  25 #include <com/sun/star/awt/LineEndFormat.hpp>
  26 #include <com/sun/star/graphic/GraphicProvider.hpp>
  27 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  28 #include <com/sun/star/graphic/GraphicObject.hpp>
  29 #include <com/sun/star/util/Date.hpp>
  30 #include <com/sun/star/awt/ImageScaleMode.hpp>
  31
  32
  33 #include <toolkit/controls/formattedcontrol.hxx>
  34 #include <toolkit/controls/roadmapcontrol.hxx>
  35 #include <toolkit/controls/unocontrols.hxx>
  36 #include <toolkit/controls/stdtabcontroller.hxx>
  37 #include <toolkit/helper/property.hxx>
  38 #include <toolkit/helper/unopropertyarrayhelper.hxx>
  39 #include <toolkit/helper/servicenames.hxx>
  40 #include <toolkit/helper/macros.hxx>
  41 #include <toolkit/helper/imagealign.hxx>
  42
  43 // for introspection
  44 #include <toolkit/awt/vclxwindows.hxx>
  45 #include <cppuhelper/typeprovider.hxx>
  46 #include <comphelper/componentcontext.hxx>
  47 #include <comphelper/processfactory.hxx>
  48 #include <comphelper/extract.hxx>
  49 #include <vcl/wrkwin.hxx>
  50 #include <vcl/svapp.hxx>
  51 #include <vcl/edit.hxx>
  52 #include <vcl/button.hxx>
  53 #include <vcl/group.hxx>
  54 #include <vcl/fixed.hxx>
  55 #include <vcl/lstbox.hxx>
  56 #include <vcl/combobox.hxx>
  57 #include <tools/debug.hxx>
  58 #include <tools/diagnose_ex.h>
  59 #include <tools/date.hxx>
  60 #include <tools/time.hxx>
  61
  62 #include <algorithm>
  63 #include <functional>
  64
  65 using namespace ::com::sun::star;
  66 using ::com::sun::star::graphic::XGraphic;
  67 using ::com::sun::star::uno::Reference;
  68 using namespace ::toolkit;
  69
  70 #define IMPL_SERVICEINFO_DERIVED( ImplName, BaseClass, ServiceName ) \
  71     ::rtl::OUString SAL_CALL ImplName::getImplementationName(  ) throw(::com::sun::star::uno::RuntimeException) { return ::rtl::OUString( "stardiv.Toolkit." #ImplName ); } \
  72     ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL ImplName::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException) \
  73                             { \
  74                                 ::com::sun::star::uno::Sequence< ::rtl::OUString > aNames = BaseClass::getSupportedServiceNames( ); \
  75                                 aNames.realloc( aNames.getLength() + 1 ); \
  76                                 aNames[ aNames.getLength() - 1 ] = ::rtl::OUString::createFromAscii( ServiceName ); \
  77                                 return aNames; \
  78                             } \
  79
  80
  81 uno::Reference< graphic::XGraphic >
  82 ImageHelper::getGraphicAndGraphicObjectFromURL_nothrow( uno::Reference< graphic::XGraphicObject >& xOutGraphicObj, const ::rtl::OUString& _rURL )
  83 {
  84     if( ( _rURL.compareToAscii( UNO_NAME_GRAPHOBJ_URLPREFIX, RTL_CONSTASCII_LENGTH( UNO_NAME_GRAPHOBJ_URLPREFIX ) ) == 0 ) )
  85     {
  86         // graphic manager uniqueid
  87         rtl::OUString sID = _rURL.copy( sizeof( UNO_NAME_GRAPHOBJ_URLPREFIX ) - 1 );
  88         // get the DefaultContext
  89         ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
  90         xOutGraphicObj = graphic::GraphicObject::createWithId( aContext.getUNOContext(), sID );
  91     }
  92     else // linked
  93         xOutGraphicObj = NULL; // release the GraphicObject
  94
  95     return ImageHelper::getGraphicFromURL_nothrow( _rURL );
  96 }
  97
  98 ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic >
  99 ImageHelper::getGraphicFromURL_nothrow( const ::rtl::OUString& _rURL )
 100 {
 101     uno::Reference< graphic::XGraphic > xGraphic;
 102     if ( _rURL.isEmpty() )
 103         return xGraphic;
 104
 105     try
 106     {
 107         uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
 108         uno::Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) );
 109         uno::Sequence< beans::PropertyValue > aMediaProperties(1);
 110         aMediaProperties[0].Name = ::rtl::OUString( "URL" );
 111         aMediaProperties[0].Value <<= _rURL;
 112         xGraphic = xProvider->queryGraphic( aMediaProperties );
 113     }
 114     catch (const Exception&)
 115     {
 116         DBG_UNHANDLED_EXCEPTION();
 117     }
 118
 119     return xGraphic;
 120 }
 121 //  ----------------------------------------------------
 122 //  class UnoControlEditModel
 123 //  ----------------------------------------------------
 124 UnoControlEditModel::UnoControlEditModel( const Reference< XMultiServiceFactory >& i_factory )
 125     :UnoControlModel( i_factory )
 126 {
 127     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXEdit );
 128 }
 129
 130 ::rtl::OUString UnoControlEditModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
 131 {
 132     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlEditModel );
 133 }
 134
 135 uno::Any UnoControlEditModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 136 {
 137     uno::Any aReturn;
 138
 139     switch ( nPropId )
 140     {
 141     case BASEPROPERTY_LINE_END_FORMAT:
 142         aReturn <<= (sal_Int16)awt::LineEndFormat::LINE_FEED;   // LF
 143         break;
 144     case BASEPROPERTY_DEFAULTCONTROL:
 145         aReturn <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlEdit );
 146         break;
 147     default:
 148         aReturn = UnoControlModel::ImplGetDefaultValue( nPropId );
 149         break;
 150     }
 151     return aReturn;
 152 }
 153
 154 ::cppu::IPropertyArrayHelper& UnoControlEditModel::getInfoHelper()
 155 {
 156     static UnoPropertyArrayHelper* pHelper = NULL;
 157     if ( !pHelper )
 158     {
 159         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
 160         pHelper = new UnoPropertyArrayHelper( aIDs );
 161     }
 162     return *pHelper;
 163 }
 164
 165 // beans::XMultiPropertySet
 166 uno::Reference< beans::XPropertySetInfo > UnoControlEditModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
 167 {
 168     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 169     return xInfo;
 170 }
 171
 172
 173 //  ----------------------------------------------------
 174 //  class UnoEditControl
 175 //  ----------------------------------------------------
 176 UnoEditControl::UnoEditControl( const Reference< XMultiServiceFactory >& i_factory )
 177     :UnoControlBase( i_factory )
 178     ,maTextListeners( *this )
 179     ,mnMaxTextLen( 0 )
 180     ,mbSetTextInPeer( sal_False )
 181     ,mbSetMaxTextLenInPeer( sal_False )
 182     ,mbHasTextProperty( sal_False )
 183 {
 184     maComponentInfos.nWidth = 100;
 185     maComponentInfos.nHeight = 12;
 186     mnMaxTextLen = 0;
 187     mbSetMaxTextLenInPeer = sal_False;
 188 }
 189
 190 uno::Any SAL_CALL UnoEditControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
 191 {
 192     uno::Any aReturn = UnoControlBase::queryAggregation( rType );
 193     if ( !aReturn.hasValue() )
 194         aReturn = UnoEditControl_Base::queryInterface( rType );
 195     return aReturn;
 196 }
 197
 198 uno::Any SAL_CALL UnoEditControl::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
 199 {
 200     return UnoControlBase::queryInterface( rType );
 201 }
 202
 203 void SAL_CALL UnoEditControl::acquire(  ) throw ()
 204 {
 205     UnoControlBase::acquire();
 206 }
 207
 208 void SAL_CALL UnoEditControl::release(  ) throw ()
 209 {
 210     UnoControlBase::release();
 211 }
 212
 213 IMPLEMENT_FORWARD_XTYPEPROVIDER2( UnoEditControl, UnoControlBase, UnoEditControl_Base )
 214
 215 ::rtl::OUString UnoEditControl::GetComponentServiceName()
 216 {
 217     // by default, we want a simple edit field
 218     ::rtl::OUString sName( "Edit" );
 219
 220     // but maybe we are to display multi-line text?
 221     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_MULTILINE ) );
 222     sal_Bool b = sal_Bool();
 223     if ( ( aVal >>= b ) && b )
 224         sName= ::rtl::OUString("MultiLineEdit");
 225
 226     return sName;
 227 }
 228
 229 sal_Bool SAL_CALL UnoEditControl::setModel(const uno::Reference< awt::XControlModel >& _rModel) throw ( uno::RuntimeException )
 230 {
 231     sal_Bool bReturn = UnoControlBase::setModel( _rModel );
 232     mbHasTextProperty = ImplHasProperty( BASEPROPERTY_TEXT );
 233     return bReturn;
 234 }
 235
 236 void UnoEditControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal )
 237 {
 238     sal_Bool bDone = sal_False;
 239     if ( GetPropertyId( rPropName ) == BASEPROPERTY_TEXT )
 240     {
 241         // #96986# use setText(), or text listener will not be called.
 242         uno::Reference < awt::XTextComponent > xTextComponent( getPeer(), uno::UNO_QUERY );
 243         if ( xTextComponent.is() )
 244         {
 245             ::rtl::OUString sText;
 246             rVal >>= sText;
 247             ImplCheckLocalize( sText );
 248             xTextComponent->setText( sText );
 249             bDone = sal_True;
 250         }
 251     }
 252
 253     if ( !bDone )
 254         UnoControlBase::ImplSetPeerProperty( rPropName, rVal );
 255 }
 256
 257 void UnoEditControl::dispose() throw(uno::RuntimeException)
 258 {
 259     lang::EventObject aEvt( *this );
 260     maTextListeners.disposeAndClear( aEvt );
 261     UnoControl::dispose();
 262 }
 263
 264 void UnoEditControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
 265 {
 266     UnoControl::createPeer( rxToolkit, rParentPeer );
 267
 268     uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 269     if ( xText.is() )
 270     {
 271     xText->addTextListener( this );
 272
 273     if ( mbSetMaxTextLenInPeer )
 274         xText->setMaxTextLen( mnMaxTextLen );
 275     if ( mbSetTextInPeer )
 276         xText->setText( maText );
 277     }
 278 }
 279
 280 void UnoEditControl::textChanged(const awt::TextEvent& e) throw(uno::RuntimeException)
 281 {
 282     uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 283
 284     if ( mbHasTextProperty )
 285     {
 286         uno::Any aAny;
 287         aAny <<= xText->getText();
 288         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_False );
 289     }
 290     else
 291     {
 292         maText = xText->getText();
 293     }
 294
 295     if ( maTextListeners.getLength() )
 296         maTextListeners.textChanged( e );
 297 }
 298
 299 void UnoEditControl::addTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException)
 300 {
 301     maTextListeners.addInterface( l );
 302 }
 303
 304 void UnoEditControl::removeTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException)
 305 {
 306     maTextListeners.removeInterface( l );
 307 }
 308
 309 void UnoEditControl::setText( const ::rtl::OUString& aText ) throw(uno::RuntimeException)
 310 {
 311     if ( mbHasTextProperty )
 312     {
 313         uno::Any aAny;
 314         aAny <<= aText;
 315         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_True );
 316     }
 317     else
 318     {
 319         maText = aText;
 320         mbSetTextInPeer = sal_True;
 321             uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 322         if ( xText.is() )
 323             xText->setText( maText );
 324         }
 325
 326     // Setting the property to the VCLXWindow doesn't call textChanged
 327     if ( maTextListeners.getLength() )
 328     {
 329         awt::TextEvent aEvent;
 330         aEvent.Source = *this;
 331         maTextListeners.textChanged( aEvent );
 332     }
 333 }
 334
 335 namespace
 336 {
 337     static void lcl_normalize( awt::Selection& _rSel )
 338     {
 339         if ( _rSel.Min > _rSel.Max )
 340             ::std::swap( _rSel.Min, _rSel.Max );
 341     }
 342 }
 343
 344 void UnoEditControl::insertText( const awt::Selection& rSel, const ::rtl::OUString& rNewText ) throw(uno::RuntimeException)
 345 {
 346     // normalize the selection - OUString::replaceAt has a strange behaviour if the min is greater than the max
 347     awt::Selection aSelection( rSel );
 348     lcl_normalize( aSelection );
 349
 350     // preserve the selection resp. cursor position
 351     awt::Selection aNewSelection( getSelection() );
 352 #ifdef ALSO_PRESERVE_COMPLETE_SELECTION
 353         // (not sure - looks uglier ...)
 354     sal_Int32 nDeletedCharacters = ( aSelection.Max - aSelection.Min ) - rNewText.getLength();
 355     if ( aNewSelection.Min > aSelection.Min )
 356         aNewSelection.Min -= nDeletedCharacters;
 357     if ( aNewSelection.Max > aSelection.Max )
 358         aNewSelection.Max -= nDeletedCharacters;
 359 #else
 360     aNewSelection.Max = ::std::min( aNewSelection.Min, aNewSelection.Max ) + rNewText.getLength();
 361     aNewSelection.Min = aNewSelection.Max;
 362 #endif
 363
 364     ::rtl::OUString aOldText = getText();
 365     ::rtl::OUString  aNewText = aOldText.replaceAt( aSelection.Min, aSelection.Max - aSelection.Min, rNewText );
 366     setText( aNewText );
 367
 368     setSelection( aNewSelection );
 369 }
 370
 371 ::rtl::OUString UnoEditControl::getText() throw(uno::RuntimeException)
 372 {
 373     ::rtl::OUString aText = maText;
 374
 375     if ( mbHasTextProperty )
 376         aText = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT );
 377     else
 378     {
 379         uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 380         if ( xText.is() )
 381             aText = xText->getText();
 382     }
 383
 384     return aText;
 385 }
 386
 387 ::rtl::OUString UnoEditControl::getSelectedText( void ) throw(uno::RuntimeException)
 388 {
 389     ::rtl::OUString sSelected;
 390         uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 391     if ( xText.is() )
 392         sSelected = xText->getSelectedText();
 393
 394     return sSelected;
 395 }
 396
 397 void UnoEditControl::setSelection( const awt::Selection& aSelection ) throw(uno::RuntimeException)
 398 {
 399         uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 400     if ( xText.is() )
 401         xText->setSelection( aSelection );
 402 }
 403
 404 awt::Selection UnoEditControl::getSelection( void ) throw(uno::RuntimeException)
 405 {
 406     awt::Selection aSel;
 407         uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 408     if ( xText.is() )
 409         aSel = xText->getSelection();
 410     return aSel;
 411 }
 412
 413 sal_Bool UnoEditControl::isEditable( void ) throw(uno::RuntimeException)
 414 {
 415     return !ImplGetPropertyValue_BOOL( BASEPROPERTY_READONLY );
 416 }
 417
 418 void UnoEditControl::setEditable( sal_Bool bEditable ) throw(uno::RuntimeException)
 419 {
 420     uno::Any aAny;
 421     aAny <<= (sal_Bool)!bEditable;
 422     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_READONLY ), aAny, sal_True );
 423 }
 424
 425 sal_Int16 UnoEditControl::getMaxTextLen() throw(uno::RuntimeException)
 426 {
 427     sal_Int16 nMaxLen = mnMaxTextLen;
 428
 429     if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN ) )
 430         nMaxLen = ImplGetPropertyValue_INT16( BASEPROPERTY_MAXTEXTLEN );
 431
 432     return nMaxLen;
 433 }
 434
 435 void UnoEditControl::setMaxTextLen( sal_Int16 nLen ) throw(uno::RuntimeException)
 436 {
 437     if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN) )
 438     {
 439         uno::Any aAny;
 440         aAny <<= (sal_Int16)nLen;
 441         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MAXTEXTLEN ), aAny, sal_True );
 442     }
 443     else
 444     {
 445         mnMaxTextLen = nLen;
 446         mbSetMaxTextLenInPeer = sal_True;
 447             uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
 448         if ( xText.is() )
 449             xText->setMaxTextLen( mnMaxTextLen );
 450     }
 451 }
 452
 453 awt::Size UnoEditControl::getMinimumSize(  ) throw(uno::RuntimeException)
 454 {
 455     return Impl_getMinimumSize();
 456 }
 457
 458 awt::Size UnoEditControl::getPreferredSize(  ) throw(uno::RuntimeException)
 459 {
 460     return Impl_getPreferredSize();
 461 }
 462
 463 awt::Size UnoEditControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
 464 {
 465     return Impl_calcAdjustedSize( rNewSize );
 466 }
 467
 468 awt::Size UnoEditControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException)
 469 {
 470     return Impl_getMinimumSize( nCols, nLines );
 471 }
 472
 473 void UnoEditControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException)
 474 {
 475     Impl_getColumnsAndLines( nCols, nLines );
 476 }
 477
 478 ::rtl::OUString UnoEditControl::getImplementationName(  ) throw(uno::RuntimeException)
 479 {
 480     return ::rtl::OUString( "stardiv.Toolkit.UnoEditControl" );
 481 }
 482
 483 uno::Sequence< ::rtl::OUString > UnoEditControl::getSupportedServiceNames() throw(uno::RuntimeException)
 484 {
 485     uno::Sequence< ::rtl::OUString > aNames = UnoControlBase::getSupportedServiceNames( );
 486     aNames.realloc( aNames.getLength() + 1 );
 487     aNames[ aNames.getLength() - 1 ] = ::rtl::OUString::createFromAscii( szServiceName2_UnoControlEdit );
 488     return aNames;
 489 }
 490
 491 //  ----------------------------------------------------
 492 //  class UnoControlFileControlModel
 493 //  ----------------------------------------------------
 494 UnoControlFileControlModel::UnoControlFileControlModel( const Reference< XMultiServiceFactory >& i_factory )
 495     :UnoControlModel( i_factory )
 496 {
 497     ImplRegisterProperty( BASEPROPERTY_ALIGN );
 498     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
 499     ImplRegisterProperty( BASEPROPERTY_BORDER );
 500     ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR );
 501     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
 502     ImplRegisterProperty( BASEPROPERTY_ENABLED );
 503     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
 504     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
 505     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
 506     ImplRegisterProperty( BASEPROPERTY_HELPURL );
 507     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
 508     ImplRegisterProperty( BASEPROPERTY_READONLY );
 509     ImplRegisterProperty( BASEPROPERTY_TABSTOP );
 510     ImplRegisterProperty( BASEPROPERTY_TEXT );
 511     ImplRegisterProperty( BASEPROPERTY_VERTICALALIGN );
 512     ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
 513     ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
 514     ImplRegisterProperty( BASEPROPERTY_HIDEINACTIVESELECTION );
 515 }
 516
 517 ::rtl::OUString UnoControlFileControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
 518 {
 519     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFileControlModel );
 520 }
 521
 522 uno::Any UnoControlFileControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 523 {
 524     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
 525     {
 526         uno::Any aAny;
 527         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFileControl );
 528         return aAny;
 529     }
 530     return UnoControlModel::ImplGetDefaultValue( nPropId );
 531 }
 532
 533 ::cppu::IPropertyArrayHelper& UnoControlFileControlModel::getInfoHelper()
 534 {
 535     static UnoPropertyArrayHelper* pHelper = NULL;
 536     if ( !pHelper )
 537     {
 538         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
 539         pHelper = new UnoPropertyArrayHelper( aIDs );
 540     }
 541     return *pHelper;
 542 }
 543
 544 // beans::XMultiPropertySet
 545 uno::Reference< beans::XPropertySetInfo > UnoControlFileControlModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
 546 {
 547     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 548     return xInfo;
 549 }
 550
 551 //  ----------------------------------------------------
 552 //  class UnoFileControl
 553 //  ----------------------------------------------------
 554 UnoFileControl::UnoFileControl( const Reference< XMultiServiceFactory >& i_factory )
 555     :UnoEditControl( i_factory )
 556 {
 557 }
 558
 559 ::rtl::OUString UnoFileControl::GetComponentServiceName()
 560 {
 561     return ::rtl::OUString("filecontrol");
 562 }
 563
 564 //  ----------------------------------------------------
 565 //  class GraphicControlModel
 566 //  ----------------------------------------------------
 567 uno::Any GraphicControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 568 {
 569     if ( nPropId == BASEPROPERTY_GRAPHIC )
 570         return uno::makeAny( uno::Reference< graphic::XGraphic >() );
 571
 572     return UnoControlModel::ImplGetDefaultValue( nPropId );
 573 }
 574
 575 void SAL_CALL GraphicControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const ::com::sun::star::uno::Any& rValue ) throw (::com::sun::star::uno::Exception)
 576 {
 577     UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
 578
 579     // - ImageAlign and ImagePosition need to correspond to each other
 580     // - Graphic and ImageURL need to correspond to each other
 581     try
 582     {
 583         switch ( nHandle )
 584         {
 585         case BASEPROPERTY_IMAGEURL:
 586             if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_GRAPHIC ) )
 587             {
 588                 mbAdjustingGraphic = true;
 589                 ::rtl::OUString sImageURL;
 590                 OSL_VERIFY( rValue >>= sImageURL );
 591                 setDependentFastPropertyValue( BASEPROPERTY_GRAPHIC, uno::makeAny( ImageHelper::getGraphicFromURL_nothrow( sImageURL ) ) );
 592                 mbAdjustingGraphic = false;
 593             }
 594             break;
 595
 596         case BASEPROPERTY_GRAPHIC:
 597             if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_IMAGEURL ) )
 598             {
 599                 mbAdjustingGraphic = true;
 600                 setDependentFastPropertyValue( BASEPROPERTY_IMAGEURL, uno::makeAny( ::rtl::OUString() ) );
 601                 mbAdjustingGraphic = false;
 602             }
 603             break;
 604
 605         case BASEPROPERTY_IMAGEALIGN:
 606             if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEPOSITION ) )
 607             {
 608                 mbAdjustingImagePosition = true;
 609                 sal_Int16 nUNOValue = 0;
 610                 OSL_VERIFY( rValue >>= nUNOValue );
 611                 setDependentFastPropertyValue( BASEPROPERTY_IMAGEPOSITION, uno::makeAny( getExtendedImagePosition( nUNOValue ) ) );
 612                 mbAdjustingImagePosition = false;
 613             }
 614             break;
 615         case BASEPROPERTY_IMAGEPOSITION:
 616             if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEALIGN ) )
 617             {
 618                 mbAdjustingImagePosition = true;
 619                 sal_Int16 nUNOValue = 0;
 620                 OSL_VERIFY( rValue >>= nUNOValue );
 621                 setDependentFastPropertyValue( BASEPROPERTY_IMAGEALIGN, uno::makeAny( getCompatibleImageAlign( translateImagePosition( nUNOValue ) ) ) );
 622                 mbAdjustingImagePosition = false;
 623             }
 624             break;
 625         }
 626     }
 627     catch( const ::com::sun::star::uno::Exception& )
 628     {
 629         OSL_FAIL( "GraphicControlModel::setFastPropertyValue_NoBroadcast: caught an exception while aligning the ImagePosition/ImageAlign properties!" );
 630         mbAdjustingImagePosition = sal_False;
 631     }
 632 }
 633
 634 //  ----------------------------------------------------
 635 //  class UnoControlButtonModel
 636 //  ----------------------------------------------------
 637 UnoControlButtonModel::UnoControlButtonModel( const Reference< XMultiServiceFactory >& i_factory )
 638     :GraphicControlModel( i_factory )
 639 {
 640     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXButton );
 641
 642     osl_atomic_increment( &m_refCount );
 643     {
 644         setFastPropertyValue_NoBroadcast( BASEPROPERTY_IMAGEPOSITION, ImplGetDefaultValue( BASEPROPERTY_IMAGEPOSITION ) );
 645         // this ensures that our ImagePosition is consistent with our ImageAlign property (since both
 646         // defaults are not per se consistent), since both are coupled in setFastPropertyValue_NoBroadcast
 647     }
 648     osl_atomic_decrement( &m_refCount );
 649 }
 650
 651 ::rtl::OUString UnoControlButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
 652 {
 653     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlButtonModel );
 654 }
 655
 656 uno::Any UnoControlButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 657 {
 658     switch ( nPropId )
 659     {
 660     case BASEPROPERTY_DEFAULTCONTROL:
 661         return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlButton ) );
 662     case BASEPROPERTY_TOGGLE:
 663         return uno::makeAny( (sal_Bool)sal_False );
 664     case BASEPROPERTY_ALIGN:
 665         return uno::makeAny( (sal_Int16)PROPERTY_ALIGN_CENTER );
 666     case BASEPROPERTY_FOCUSONCLICK:
 667         return uno::makeAny( (sal_Bool)sal_True );
 668     }
 669
 670     return GraphicControlModel::ImplGetDefaultValue( nPropId );
 671 }
 672
 673 ::cppu::IPropertyArrayHelper& UnoControlButtonModel::getInfoHelper()
 674 {
 675     static UnoPropertyArrayHelper* pHelper = NULL;
 676     if ( !pHelper )
 677     {
 678         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
 679         pHelper = new UnoPropertyArrayHelper( aIDs );
 680     }
 681     return *pHelper;
 682 }
 683
 684 // beans::XMultiPropertySet
 685 uno::Reference< beans::XPropertySetInfo > UnoControlButtonModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
 686 {
 687     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 688     return xInfo;
 689 }
 690
 691 //  ----------------------------------------------------
 692 //  class UnoButtonControl
 693 //  ----------------------------------------------------
 694 UnoButtonControl::UnoButtonControl( const uno::Reference< lang::XMultiServiceFactory >& i_factory )
 695     :UnoButtonControl_Base( i_factory )
 696     ,maActionListeners( *this )
 697     ,maItemListeners( *this )
 698 {
 699     maComponentInfos.nWidth = 50;
 700     maComponentInfos.nHeight = 14;
 701 }
 702
 703 ::rtl::OUString UnoButtonControl::GetComponentServiceName()
 704 {
 705     ::rtl::OUString aName( "pushbutton" );
 706     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_PUSHBUTTONTYPE ) );
 707     sal_Int16 n = sal_Int16();
 708     if ( ( aVal >>= n ) && n )
 709     {
 710         // Use PushButtonType later when available...
 711         switch ( n )
 712         {
 713             case 1 /*PushButtonType::OK*/:      aName= ::rtl::OUString("okbutton");
 714                                                 break;
 715             case 2 /*PushButtonType::CANCEL*/:  aName= ::rtl::OUString("cancelbutton");
 716                                                 break;
 717             case 3 /*PushButtonType::HELP*/:    aName= ::rtl::OUString("helpbutton");
 718                                                 break;
 719             default:
 720             {
 721                 OSL_FAIL( "Unknown Button Type!" );
 722             }
 723         }
 724     }
 725     return aName;
 726 }
 727
 728 void UnoButtonControl::dispose() throw(uno::RuntimeException)
 729 {
 730     lang::EventObject aEvt;
 731     aEvt.Source = (::cppu::OWeakObject*)this;
 732     maActionListeners.disposeAndClear( aEvt );
 733     maItemListeners.disposeAndClear( aEvt );
 734     UnoControlBase::dispose();
 735 }
 736
 737 void UnoButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
 738 {
 739     UnoControlBase::createPeer( rxToolkit, rParentPeer );
 740
 741     uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
 742     xButton->setActionCommand( maActionCommand );
 743     if ( maActionListeners.getLength() )
 744         xButton->addActionListener( &maActionListeners );
 745
 746     uno::Reference< XToggleButton > xPushButton( getPeer(), uno::UNO_QUERY );
 747     if ( xPushButton.is() )
 748         xPushButton->addItemListener( this );
 749 }
 750
 751 void UnoButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
 752 {
 753     maActionListeners.addInterface( l );
 754     if( getPeer().is() && maActionListeners.getLength() == 1 )
 755     {
 756         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
 757         xButton->addActionListener( &maActionListeners );
 758     }
 759 }
 760
 761 void UnoButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
 762 {
 763     if( getPeer().is() && maActionListeners.getLength() == 1 )
 764     {
 765         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
 766         xButton->removeActionListener( &maActionListeners );
 767     }
 768     maActionListeners.removeInterface( l );
 769 }
 770
 771 void UnoButtonControl::addItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException)
 772 {
 773     maItemListeners.addInterface( l );
 774 }
 775
 776 void UnoButtonControl::removeItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException)
 777 {
 778     maItemListeners.removeInterface( l );
 779 }
 780
 781 void SAL_CALL UnoButtonControl::disposing( const lang::EventObject& Source ) throw (uno::RuntimeException)
 782 {
 783     UnoControlBase::disposing( Source );
 784 }
 785
 786 void SAL_CALL UnoButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw (uno::RuntimeException)
 787 {
 788     // forward to model
 789     uno::Any aAny;
 790     aAny <<= (sal_Int16)rEvent.Selected;
 791     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
 792
 793     // multiplex
 794     ItemEvent aEvent( rEvent );
 795     aEvent.Source = *this;
 796     maItemListeners.itemStateChanged( aEvent );
 797 }
 798
 799 void UnoButtonControl::setLabel( const ::rtl::OUString&  rLabel ) throw(uno::RuntimeException)
 800 {
 801     uno::Any aAny;
 802     aAny <<= rLabel;
 803     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
 804 }
 805
 806 void UnoButtonControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException)
 807 {
 808     maActionCommand = rCommand;
 809     if ( getPeer().is() )
 810     {
 811         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
 812         xButton->setActionCommand( rCommand );
 813     }
 814 }
 815
 816 awt::Size UnoButtonControl::getMinimumSize(  ) throw(uno::RuntimeException)
 817 {
 818     return Impl_getMinimumSize();
 819 }
 820
 821 awt::Size UnoButtonControl::getPreferredSize(  ) throw(uno::RuntimeException)
 822 {
 823     return Impl_getPreferredSize();
 824 }
 825
 826 awt::Size UnoButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
 827 {
 828     return Impl_calcAdjustedSize( rNewSize );
 829 }
 830
 831 //  ----------------------------------------------------
 832 //  class UnoControlImageControlModel
 833 //  ----------------------------------------------------
 834 UnoControlImageControlModel::UnoControlImageControlModel( const Reference< XMultiServiceFactory >& i_factory )
 835     :GraphicControlModel( i_factory )
 836     ,mbAdjustingImageScaleMode( false )
 837 {
 838     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXImageControl );
 839 }
 840
 841 ::rtl::OUString UnoControlImageControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
 842 {
 843     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlImageControlModel );
 844 }
 845
 846 uno::Any UnoControlImageControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 847 {
 848     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
 849         return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlImageControl ) );
 850
 851     if ( nPropId == BASEPROPERTY_IMAGE_SCALE_MODE )
 852         return makeAny( awt::ImageScaleMode::Anisotropic );
 853
 854     return GraphicControlModel::ImplGetDefaultValue( nPropId );
 855 }
 856
 857 ::cppu::IPropertyArrayHelper& UnoControlImageControlModel::getInfoHelper()
 858 {
 859     static UnoPropertyArrayHelper* pHelper = NULL;
 860     if ( !pHelper )
 861     {
 862         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
 863         pHelper = new UnoPropertyArrayHelper( aIDs );
 864     }
 865     return *pHelper;
 866 }
 867
 868 // beans::XMultiPropertySet
 869 uno::Reference< beans::XPropertySetInfo > UnoControlImageControlModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
 870 {
 871     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 872     return xInfo;
 873 }
 874
 875 void SAL_CALL UnoControlImageControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const ::com::sun::star::uno::Any& _rValue ) throw (::com::sun::star::uno::Exception)
 876 {
 877     GraphicControlModel::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
 878
 879     // ScaleImage is an older (and less powerful) version of ScaleMode, but keep both in sync as far as possible
 880     try
 881     {
 882         switch ( _nHandle )
 883         {
 884         case BASEPROPERTY_IMAGE_SCALE_MODE:
 885             if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_SCALEIMAGE ) )
 886             {
 887                 mbAdjustingImageScaleMode = true;
 888                 sal_Int16 nScaleMode( awt::ImageScaleMode::Anisotropic );
 889                 OSL_VERIFY( _rValue >>= nScaleMode );
 890                 setDependentFastPropertyValue( BASEPROPERTY_SCALEIMAGE, uno::makeAny( sal_Bool( nScaleMode != awt::ImageScaleMode::None ) ) );
 891                 mbAdjustingImageScaleMode = false;
 892             }
 893             break;
 894         case BASEPROPERTY_SCALEIMAGE:
 895             if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_IMAGE_SCALE_MODE ) )
 896             {
 897                 mbAdjustingImageScaleMode = true;
 898                 sal_Bool bScale = sal_True;
 899                 OSL_VERIFY( _rValue >>= bScale );
 900                 setDependentFastPropertyValue( BASEPROPERTY_IMAGE_SCALE_MODE, uno::makeAny( bScale ? awt::ImageScaleMode::Anisotropic : awt::ImageScaleMode::None ) );
 901                 mbAdjustingImageScaleMode = false;
 902             }
 903             break;
 904         }
 905     }
 906     catch( const Exception& )
 907     {
 908         mbAdjustingImageScaleMode = false;
 909         throw;
 910     }
 911 }
 912
 913 //  ----------------------------------------------------
 914 //  class UnoImageControlControl
 915 //  ----------------------------------------------------
 916 UnoImageControlControl::UnoImageControlControl( const Reference< XMultiServiceFactory >& i_factory )
 917     :UnoImageControlControl_Base( i_factory )
 918     ,maActionListeners( *this )
 919 {
 920     // TODO: Where should I look for defaults?
 921     maComponentInfos.nWidth = 100;
 922     maComponentInfos.nHeight = 100;
 923 }
 924
 925 ::rtl::OUString UnoImageControlControl::GetComponentServiceName()
 926 {
 927     return ::rtl::OUString("fixedimage");
 928 }
 929
 930 void UnoImageControlControl::dispose() throw(uno::RuntimeException)
 931 {
 932     lang::EventObject aEvt;
 933     aEvt.Source = (::cppu::OWeakObject*)this;
 934     maActionListeners.disposeAndClear( aEvt );
 935     UnoControl::dispose();
 936 }
 937
 938 sal_Bool UnoImageControlControl::isTransparent() throw(uno::RuntimeException)
 939 {
 940     return sal_True;
 941 }
 942
 943 awt::Size UnoImageControlControl::getMinimumSize(  ) throw(uno::RuntimeException)
 944 {
 945     return Impl_getMinimumSize();
 946 }
 947
 948 awt::Size UnoImageControlControl::getPreferredSize(  ) throw(uno::RuntimeException)
 949 {
 950     return Impl_getPreferredSize();
 951 }
 952
 953 awt::Size UnoImageControlControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
 954 {
 955     return Impl_calcAdjustedSize( rNewSize );
 956 }
 957
 958 //  ----------------------------------------------------
 959 //  class UnoControlRadioButtonModel
 960 //  ----------------------------------------------------
 961 UnoControlRadioButtonModel::UnoControlRadioButtonModel( const Reference< XMultiServiceFactory >& i_factory )
 962     :GraphicControlModel( i_factory )
 963 {
 964     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXRadioButton );
 965 }
 966
 967 ::rtl::OUString UnoControlRadioButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
 968 {
 969     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlRadioButtonModel );
 970 }
 971
 972 uno::Any UnoControlRadioButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
 973 {
 974     switch ( nPropId )
 975     {
 976     case BASEPROPERTY_DEFAULTCONTROL:
 977         return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlRadioButton ) );
 978
 979     case BASEPROPERTY_VISUALEFFECT:
 980         return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D );
 981     }
 982
 983     return GraphicControlModel::ImplGetDefaultValue( nPropId );
 984 }
 985
 986 ::cppu::IPropertyArrayHelper& UnoControlRadioButtonModel::getInfoHelper()
 987 {
 988     static UnoPropertyArrayHelper* pHelper = NULL;
 989     if ( !pHelper )
 990     {
 991         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
 992         pHelper = new UnoPropertyArrayHelper( aIDs );
 993     }
 994     return *pHelper;
 995 }
 996
 997 // beans::XMultiPropertySet
 998 uno::Reference< beans::XPropertySetInfo > UnoControlRadioButtonModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
 999 {
1000     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1001     return xInfo;
1002 }
1003
1004
1005
1006 //  ----------------------------------------------------
1007 //  class UnoRadioButtonControl
1008 //  ----------------------------------------------------
1009 UnoRadioButtonControl::UnoRadioButtonControl( const Reference< XMultiServiceFactory >& i_factory )
1010     :UnoRadioButtonControl_Base( i_factory )
1011     ,maItemListeners( *this )
1012     ,maActionListeners( *this )
1013 {
1014     maComponentInfos.nWidth = 100;
1015     maComponentInfos.nHeight = 12;
1016 }
1017
1018 ::rtl::OUString UnoRadioButtonControl::GetComponentServiceName()
1019 {
1020     return ::rtl::OUString("radiobutton");
1021 }
1022
1023 void UnoRadioButtonControl::dispose() throw(uno::RuntimeException)
1024 {
1025     lang::EventObject aEvt;
1026     aEvt.Source = (::cppu::OWeakObject*)this;
1027     maItemListeners.disposeAndClear( aEvt );
1028     UnoControlBase::dispose();
1029 }
1030
1031
1032 sal_Bool UnoRadioButtonControl::isTransparent() throw(uno::RuntimeException)
1033 {
1034     return sal_True;
1035 }
1036
1037 void UnoRadioButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
1038 {
1039     UnoControlBase::createPeer( rxToolkit, rParentPeer );
1040
1041     uno::Reference < awt::XRadioButton >  xRadioButton( getPeer(), uno::UNO_QUERY );
1042     xRadioButton->addItemListener( this );
1043
1044     uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1045     xButton->setActionCommand( maActionCommand );
1046     if ( maActionListeners.getLength() )
1047         xButton->addActionListener( &maActionListeners );
1048
1049     // as default, set the "AutoToggle" to true
1050     // (it is set to false in VCLXToolkit::ImplCreateWindow because of #87254#, but we want to
1051     // have it enabled by default because of 85071)
1052     uno::Reference< awt::XVclWindowPeer >  xVclWindowPeer( getPeer(), uno::UNO_QUERY );
1053     if ( xVclWindowPeer.is() )
1054         xVclWindowPeer->setProperty( GetPropertyName( BASEPROPERTY_AUTOTOGGLE ), ::cppu::bool2any( sal_True ) );
1055 }
1056
1057 void UnoRadioButtonControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1058 {
1059     maItemListeners.addInterface( l );
1060 }
1061
1062 void UnoRadioButtonControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1063 {
1064     maItemListeners.removeInterface( l );
1065 }
1066
1067 void UnoRadioButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1068 {
1069     maActionListeners.addInterface( l );
1070     if( getPeer().is() && maActionListeners.getLength() == 1 )
1071     {
1072         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
1073         xButton->addActionListener( &maActionListeners );
1074     }
1075 }
1076
1077 void UnoRadioButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1078 {
1079     if( getPeer().is() && maActionListeners.getLength() == 1 )
1080     {
1081         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
1082         xButton->removeActionListener( &maActionListeners );
1083     }
1084     maActionListeners.removeInterface( l );
1085 }
1086
1087 void UnoRadioButtonControl::setLabel( const ::rtl::OUString&  rLabel ) throw(uno::RuntimeException)
1088 {
1089     uno::Any aAny;
1090     aAny <<= rLabel;
1091     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1092 }
1093
1094 void UnoRadioButtonControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException)
1095 {
1096     maActionCommand = rCommand;
1097     if ( getPeer().is() )
1098     {
1099         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
1100         xButton->setActionCommand( rCommand );
1101     }
1102 }
1103
1104 void UnoRadioButtonControl::setState( sal_Bool bOn ) throw(uno::RuntimeException)
1105 {
1106     sal_Int16 nState = bOn ? 1 : 0;
1107     uno::Any aAny;
1108     aAny <<= nState;
1109     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True );
1110 }
1111
1112 sal_Bool UnoRadioButtonControl::getState() throw(uno::RuntimeException)
1113 {
1114     sal_Int16 nState = 0;
1115     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) );
1116     aVal >>= nState;
1117     return nState ? sal_True : sal_False;
1118 }
1119
1120 void UnoRadioButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
1121 {
1122     uno::Any aAny;
1123     aAny <<= (sal_Int16)rEvent.Selected;
1124     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
1125
1126     // compatibility:
1127     // in OOo 1.0.x, when the user clicked a radio button in a group of buttons, this resulted
1128     // in _one_ itemStateChanged call for exactly the radio button which's state changed from
1129     // "0" to "1".
1130     // Nowadays, since the listener handling changed a lot towards 1.1 (the VCLXWindow reacts on more
1131     // basic events from the VCL-windows, not anymore on the Link-based events like in 1.0.x), this
1132     // isn't the case anymore: For instance, this method here gets called for the radio button
1133     // which is being implicitily _de_selected, too. This is pretty bad for compatibility.
1134     // Thus, we suppress all events with a new state other than "1". This is unlogical, and weird, when looking
1135     // from a pure API perspective, but it's _compatible_ with older product versions, and this is
1136     // all which matters here.
1137     // #i14703#
1138     if ( 1 == rEvent.Selected )
1139     {
1140         if ( maItemListeners.getLength() )
1141             maItemListeners.itemStateChanged( rEvent );
1142     }
1143         // note that speaking stricly, this is wrong: When in 1.0.x, the user would have de-selected
1144         // a radio button _without_ selecing another one, this would have caused a notification.
1145         // With the change done here, this today won't cause a notification anymore.
1146         //
1147         // Fortunately, it's not possible for the user to de-select a radio button without selecting another on,
1148         // at least not via the regular UI. It _would_ be possible via the Accessibility API, which
1149         // counts as "user input", too. But in 1.0.x, there was no Accessibility API, so there is nothing
1150         // to be inconsistent with.
1151 }
1152
1153 awt::Size UnoRadioButtonControl::getMinimumSize(  ) throw(uno::RuntimeException)
1154 {
1155     return Impl_getMinimumSize();
1156 }
1157
1158 awt::Size UnoRadioButtonControl::getPreferredSize(  ) throw(uno::RuntimeException)
1159 {
1160     return Impl_getPreferredSize();
1161 }
1162
1163 awt::Size UnoRadioButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1164 {
1165     return Impl_calcAdjustedSize( rNewSize );
1166 }
1167
1168 //  ----------------------------------------------------
1169 //  class UnoControlCheckBoxModel
1170 //  ----------------------------------------------------
1171 UnoControlCheckBoxModel::UnoControlCheckBoxModel( const Reference< XMultiServiceFactory >& i_factory )
1172     :GraphicControlModel( i_factory )
1173 {
1174     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCheckBox );
1175 }
1176
1177 ::rtl::OUString UnoControlCheckBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1178 {
1179     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlCheckBoxModel );
1180 }
1181
1182 uno::Any UnoControlCheckBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1183 {
1184     switch ( nPropId )
1185     {
1186     case BASEPROPERTY_DEFAULTCONTROL:
1187         return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlCheckBox ) );
1188
1189     case BASEPROPERTY_VISUALEFFECT:
1190         return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D );
1191     }
1192
1193     return GraphicControlModel::ImplGetDefaultValue( nPropId );
1194 }
1195
1196 ::cppu::IPropertyArrayHelper& UnoControlCheckBoxModel::getInfoHelper()
1197 {
1198     static UnoPropertyArrayHelper* pHelper = NULL;
1199     if ( !pHelper )
1200     {
1201         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
1202         pHelper = new UnoPropertyArrayHelper( aIDs );
1203     }
1204     return *pHelper;
1205 }
1206
1207 // beans::XMultiPropertySet
1208 uno::Reference< beans::XPropertySetInfo > UnoControlCheckBoxModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
1209 {
1210     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1211     return xInfo;
1212 }
1213
1214
1215
1216 //  ----------------------------------------------------
1217 //  class UnoCheckBoxControl
1218 //  ----------------------------------------------------
1219 UnoCheckBoxControl::UnoCheckBoxControl( const uno::Reference< lang::XMultiServiceFactory >& i_factory )
1220     :UnoCheckBoxControl_Base( i_factory )
1221     ,maItemListeners( *this ), maActionListeners( *this )
1222 {
1223     maComponentInfos.nWidth = 100;
1224     maComponentInfos.nHeight = 12;
1225 }
1226
1227 ::rtl::OUString UnoCheckBoxControl::GetComponentServiceName()
1228 {
1229     return ::rtl::OUString("checkbox");
1230 }
1231
1232 void UnoCheckBoxControl::dispose() throw(uno::RuntimeException)
1233 {
1234     lang::EventObject aEvt;
1235     aEvt.Source = (::cppu::OWeakObject*)this;
1236     maItemListeners.disposeAndClear( aEvt );
1237     UnoControlBase::dispose();
1238 }
1239
1240 sal_Bool UnoCheckBoxControl::isTransparent() throw(uno::RuntimeException)
1241 {
1242     return sal_True;
1243 }
1244
1245 void UnoCheckBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
1246 {
1247     UnoControlBase::createPeer( rxToolkit, rParentPeer );
1248
1249     uno::Reference < awt::XCheckBox >  xCheckBox( getPeer(), uno::UNO_QUERY );
1250     xCheckBox->addItemListener( this );
1251
1252     uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1253     xButton->setActionCommand( maActionCommand );
1254     if ( maActionListeners.getLength() )
1255         xButton->addActionListener( &maActionListeners );
1256 }
1257
1258 void UnoCheckBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1259 {
1260     maItemListeners.addInterface( l );
1261 }
1262
1263 void UnoCheckBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1264 {
1265     maItemListeners.removeInterface( l );
1266 }
1267
1268 void UnoCheckBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1269 {
1270     maActionListeners.addInterface( l );
1271     if( getPeer().is() && maActionListeners.getLength() == 1 )
1272     {
1273         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
1274         xButton->addActionListener( &maActionListeners );
1275     }
1276 }
1277
1278 void UnoCheckBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1279 {
1280     if( getPeer().is() && maActionListeners.getLength() == 1 )
1281     {
1282         uno::Reference < awt::XButton >  xButton( getPeer(), uno::UNO_QUERY );
1283         xButton->removeActionListener( &maActionListeners );
1284     }
1285     maActionListeners.removeInterface( l );
1286 }
1287
1288 void UnoCheckBoxControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException)
1289 {
1290     maActionCommand = rCommand;
1291     if ( getPeer().is() )
1292     {
1293         uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1294         xButton->setActionCommand( rCommand );
1295     }
1296 }
1297
1298
1299 void UnoCheckBoxControl::setLabel( const ::rtl::OUString&  rLabel ) throw(uno::RuntimeException)
1300 {
1301     uno::Any aAny;
1302     aAny <<= rLabel;
1303     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1304 }
1305
1306 void UnoCheckBoxControl::setState( short n ) throw(uno::RuntimeException)
1307 {
1308     uno::Any aAny;
1309     aAny <<= (sal_Int16)n;
1310     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True );
1311 }
1312
1313 short UnoCheckBoxControl::getState() throw(uno::RuntimeException)
1314 {
1315     short nState = 0;
1316     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) );
1317     aVal >>= nState;
1318     return nState;
1319 }
1320
1321 void UnoCheckBoxControl::enableTriState( sal_Bool b ) throw(uno::RuntimeException)
1322 {
1323     uno::Any aAny;
1324     aAny <<= b;
1325     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TRISTATE ), aAny, sal_True );
1326 }
1327
1328 void UnoCheckBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
1329 {
1330     uno::Any aAny;
1331     aAny <<= (sal_Int16)rEvent.Selected;
1332     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
1333
1334     if ( maItemListeners.getLength() )
1335         maItemListeners.itemStateChanged( rEvent );
1336 }
1337
1338 awt::Size UnoCheckBoxControl::getMinimumSize(  ) throw(uno::RuntimeException)
1339 {
1340     return Impl_getMinimumSize();
1341 }
1342
1343 awt::Size UnoCheckBoxControl::getPreferredSize(  ) throw(uno::RuntimeException)
1344 {
1345     return Impl_getPreferredSize();
1346 }
1347
1348 awt::Size UnoCheckBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1349 {
1350     return Impl_calcAdjustedSize( rNewSize );
1351 }
1352
1353 //  ----------------------------------------------------
1354 //  class UnoControlFixedHyperlinkModel
1355 //  ----------------------------------------------------
1356 UnoControlFixedHyperlinkModel::UnoControlFixedHyperlinkModel( const Reference< XMultiServiceFactory >& i_factory )
1357     :UnoControlModel( i_factory )
1358 {
1359     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedHyperlink );
1360 }
1361
1362 ::rtl::OUString UnoControlFixedHyperlinkModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1363 {
1364     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedHyperlinkModel );
1365 }
1366
1367 uno::Any UnoControlFixedHyperlinkModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1368 {
1369     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1370     {
1371         uno::Any aAny;
1372         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedHyperlink );
1373         return aAny;
1374     }
1375     else if ( nPropId == BASEPROPERTY_BORDER )
1376     {
1377         uno::Any aAny;
1378         aAny <<= (sal_Int16)0;
1379         return aAny;
1380     }
1381     else if ( nPropId == BASEPROPERTY_URL )
1382     {
1383         uno::Any aAny;
1384         aAny <<= ::rtl::OUString();
1385         return aAny;
1386     }
1387
1388     return UnoControlModel::ImplGetDefaultValue( nPropId );
1389 }
1390
1391 ::cppu::IPropertyArrayHelper& UnoControlFixedHyperlinkModel::getInfoHelper()
1392 {
1393     static UnoPropertyArrayHelper* pHelper = NULL;
1394     if ( !pHelper )
1395     {
1396         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
1397         pHelper = new UnoPropertyArrayHelper( aIDs );
1398     }
1399     return *pHelper;
1400 }
1401
1402 // beans::XMultiPropertySet
1403 uno::Reference< beans::XPropertySetInfo > UnoControlFixedHyperlinkModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
1404 {
1405     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1406     return xInfo;
1407 }
1408
1409 //  ----------------------------------------------------
1410 //  class UnoFixedHyperlinkControl
1411 //  ----------------------------------------------------
1412 UnoFixedHyperlinkControl::UnoFixedHyperlinkControl( const Reference< XMultiServiceFactory >& i_factory )
1413     :UnoControlBase( i_factory )
1414     ,maActionListeners( *this )
1415 {
1416     maComponentInfos.nWidth = 100;
1417     maComponentInfos.nHeight = 12;
1418 }
1419
1420 ::rtl::OUString UnoFixedHyperlinkControl::GetComponentServiceName()
1421 {
1422     return ::rtl::OUString("fixedhyperlink");
1423 }
1424
1425 // uno::XInterface
1426 uno::Any UnoFixedHyperlinkControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
1427 {
1428     uno::Any aRet = ::cppu::queryInterface( rType,
1429                                         (static_cast< awt::XFixedHyperlink* >(this)),
1430                                         (static_cast< awt::XLayoutConstrains* >(this)) );
1431     return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
1432 }
1433
1434 // lang::XTypeProvider
1435 IMPL_XTYPEPROVIDER_START( UnoFixedHyperlinkControl )
1436     getCppuType( ( uno::Reference< awt::XFixedHyperlink>* ) NULL ),
1437     getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ),
1438     UnoControlBase::getTypes()
1439 IMPL_XTYPEPROVIDER_END
1440
1441 sal_Bool UnoFixedHyperlinkControl::isTransparent() throw(uno::RuntimeException)
1442 {
1443     return sal_True;
1444 }
1445
1446 void UnoFixedHyperlinkControl::setText( const ::rtl::OUString& Text ) throw(uno::RuntimeException)
1447 {
1448     uno::Any aAny;
1449     aAny <<= Text;
1450     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1451 }
1452
1453 ::rtl::OUString UnoFixedHyperlinkControl::getText() throw(uno::RuntimeException)
1454 {
1455     return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL );
1456 }
1457
1458 void UnoFixedHyperlinkControl::setURL( const ::rtl::OUString& URL ) throw(::com::sun::star::uno::RuntimeException)
1459 {
1460     uno::Any aAny;
1461     aAny <<= URL;
1462     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_URL ), aAny, sal_True );
1463 }
1464
1465 ::rtl::OUString UnoFixedHyperlinkControl::getURL(  ) throw(::com::sun::star::uno::RuntimeException)
1466 {
1467     return ImplGetPropertyValue_UString( BASEPROPERTY_URL );
1468 }
1469
1470 void UnoFixedHyperlinkControl::setAlignment( short nAlign ) throw(uno::RuntimeException)
1471 {
1472     uno::Any aAny;
1473     aAny <<= (sal_Int16)nAlign;
1474     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True );
1475 }
1476
1477 short UnoFixedHyperlinkControl::getAlignment() throw(uno::RuntimeException)
1478 {
1479     short nAlign = 0;
1480     if ( mxModel.is() )
1481     {
1482         uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) );
1483         aVal >>= nAlign;
1484     }
1485     return nAlign;
1486 }
1487
1488 awt::Size UnoFixedHyperlinkControl::getMinimumSize(  ) throw(uno::RuntimeException)
1489 {
1490     return Impl_getMinimumSize();
1491 }
1492
1493 awt::Size UnoFixedHyperlinkControl::getPreferredSize(  ) throw(uno::RuntimeException)
1494 {
1495     return Impl_getPreferredSize();
1496 }
1497
1498 awt::Size UnoFixedHyperlinkControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1499 {
1500     return Impl_calcAdjustedSize( rNewSize );
1501 }
1502
1503 void UnoFixedHyperlinkControl::dispose() throw(uno::RuntimeException)
1504 {
1505     lang::EventObject aEvt;
1506     aEvt.Source = (::cppu::OWeakObject*)this;
1507     maActionListeners.disposeAndClear( aEvt );
1508     UnoControlBase::dispose();
1509 }
1510
1511 void UnoFixedHyperlinkControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
1512 {
1513     UnoControlBase::createPeer( rxToolkit, rParentPeer );
1514
1515     uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1516     if ( maActionListeners.getLength() )
1517         xFixedHyperlink->addActionListener( &maActionListeners );
1518 }
1519
1520 void UnoFixedHyperlinkControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1521 {
1522     maActionListeners.addInterface( l );
1523     if( getPeer().is() && maActionListeners.getLength() == 1 )
1524     {
1525         uno::Reference < awt::XFixedHyperlink >  xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1526         xFixedHyperlink->addActionListener( &maActionListeners );
1527     }
1528 }
1529
1530 void UnoFixedHyperlinkControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1531 {
1532     if( getPeer().is() && maActionListeners.getLength() == 1 )
1533     {
1534         uno::Reference < awt::XFixedHyperlink >  xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1535         xFixedHyperlink->removeActionListener( &maActionListeners );
1536     }
1537     maActionListeners.removeInterface( l );
1538 }
1539
1540 //  ----------------------------------------------------
1541 //  class UnoControlFixedTextModel
1542 //  ----------------------------------------------------
1543 UnoControlFixedTextModel::UnoControlFixedTextModel( const Reference< XMultiServiceFactory >& i_factory )
1544     :UnoControlModel( i_factory )
1545 {
1546     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedText );
1547 }
1548
1549 ::rtl::OUString UnoControlFixedTextModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1550 {
1551     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedTextModel );
1552 }
1553
1554 uno::Any UnoControlFixedTextModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1555 {
1556     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1557     {
1558         uno::Any aAny;
1559         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedText );
1560         return aAny;
1561     }
1562     else if ( nPropId == BASEPROPERTY_BORDER )
1563     {
1564         uno::Any aAny;
1565         aAny <<= (sal_Int16)0;
1566         return aAny;
1567     }
1568
1569     return UnoControlModel::ImplGetDefaultValue( nPropId );
1570 }
1571
1572 ::cppu::IPropertyArrayHelper& UnoControlFixedTextModel::getInfoHelper()
1573 {
1574     static UnoPropertyArrayHelper* pHelper = NULL;
1575     if ( !pHelper )
1576     {
1577         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
1578         pHelper = new UnoPropertyArrayHelper( aIDs );
1579     }
1580     return *pHelper;
1581 }
1582
1583 // beans::XMultiPropertySet
1584 uno::Reference< beans::XPropertySetInfo > UnoControlFixedTextModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
1585 {
1586     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1587     return xInfo;
1588 }
1589
1590
1591 //  ----------------------------------------------------
1592 //  class UnoFixedTextControl
1593 //  ----------------------------------------------------
1594 UnoFixedTextControl::UnoFixedTextControl( const Reference< XMultiServiceFactory >& i_factory )
1595     :UnoControlBase( i_factory )
1596 {
1597     maComponentInfos.nWidth = 100;
1598     maComponentInfos.nHeight = 12;
1599 }
1600
1601 ::rtl::OUString UnoFixedTextControl::GetComponentServiceName()
1602 {
1603     return ::rtl::OUString("fixedtext");
1604 }
1605
1606 // uno::XInterface
1607 uno::Any UnoFixedTextControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
1608 {
1609     uno::Any aRet = ::cppu::queryInterface( rType,
1610                                         (static_cast< awt::XFixedText* >(this)),
1611                                         (static_cast< awt::XLayoutConstrains* >(this)) );
1612     return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
1613 }
1614
1615 // lang::XTypeProvider
1616 IMPL_XTYPEPROVIDER_START( UnoFixedTextControl )
1617     getCppuType( ( uno::Reference< awt::XFixedText>* ) NULL ),
1618     getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ),
1619     UnoControlBase::getTypes()
1620 IMPL_XTYPEPROVIDER_END
1621
1622 sal_Bool UnoFixedTextControl::isTransparent() throw(uno::RuntimeException)
1623 {
1624     return sal_True;
1625 }
1626
1627 void UnoFixedTextControl::setText( const ::rtl::OUString& Text ) throw(uno::RuntimeException)
1628 {
1629     uno::Any aAny;
1630     aAny <<= Text;
1631     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1632 }
1633
1634 ::rtl::OUString UnoFixedTextControl::getText() throw(uno::RuntimeException)
1635 {
1636     return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL );
1637 }
1638
1639 void UnoFixedTextControl::setAlignment( short nAlign ) throw(uno::RuntimeException)
1640 {
1641     uno::Any aAny;
1642     aAny <<= (sal_Int16)nAlign;
1643     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True );
1644 }
1645
1646 short UnoFixedTextControl::getAlignment() throw(uno::RuntimeException)
1647 {
1648     short nAlign = 0;
1649     if ( mxModel.is() )
1650     {
1651         uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) );
1652         aVal >>= nAlign;
1653     }
1654     return nAlign;
1655 }
1656
1657 awt::Size UnoFixedTextControl::getMinimumSize(  ) throw(uno::RuntimeException)
1658 {
1659     return Impl_getMinimumSize();
1660 }
1661
1662 awt::Size UnoFixedTextControl::getPreferredSize(  ) throw(uno::RuntimeException)
1663 {
1664     return Impl_getPreferredSize();
1665 }
1666
1667 awt::Size UnoFixedTextControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1668 {
1669     return Impl_calcAdjustedSize( rNewSize );
1670 }
1671
1672 //  ----------------------------------------------------
1673 //  class UnoControlGroupBoxModel
1674 //  ----------------------------------------------------
1675 UnoControlGroupBoxModel::UnoControlGroupBoxModel( const Reference< XMultiServiceFactory >& i_factory )
1676     :UnoControlModel( i_factory )
1677 {
1678     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
1679     ImplRegisterProperty( BASEPROPERTY_ENABLED );
1680     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
1681     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
1682     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
1683     ImplRegisterProperty( BASEPROPERTY_HELPURL );
1684     ImplRegisterProperty( BASEPROPERTY_LABEL );
1685     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
1686     ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
1687     ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
1688 }
1689
1690 ::rtl::OUString UnoControlGroupBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1691 {
1692     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlGroupBoxModel );
1693 }
1694
1695 uno::Any UnoControlGroupBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1696 {
1697     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1698     {
1699         uno::Any aAny;
1700         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlGroupBox );
1701         return aAny;
1702     }
1703     return UnoControlModel::ImplGetDefaultValue( nPropId );
1704 }
1705
1706 ::cppu::IPropertyArrayHelper& UnoControlGroupBoxModel::getInfoHelper()
1707 {
1708     static UnoPropertyArrayHelper* pHelper = NULL;
1709     if ( !pHelper )
1710     {
1711         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
1712         pHelper = new UnoPropertyArrayHelper( aIDs );
1713     }
1714     return *pHelper;
1715 }
1716
1717 // beans::XMultiPropertySet
1718 uno::Reference< beans::XPropertySetInfo > UnoControlGroupBoxModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
1719 {
1720     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1721     return xInfo;
1722 }
1723
1724 //  ----------------------------------------------------
1725 //  class UnoGroupBoxControl
1726 //  ----------------------------------------------------
1727 UnoGroupBoxControl::UnoGroupBoxControl( const Reference< XMultiServiceFactory >& i_factory )
1728     :UnoControlBase( i_factory )
1729 {
1730     maComponentInfos.nWidth = 100;
1731     maComponentInfos.nHeight = 100;
1732 }
1733
1734 ::rtl::OUString UnoGroupBoxControl::GetComponentServiceName()
1735 {
1736     return ::rtl::OUString("groupbox");
1737 }
1738
1739 sal_Bool UnoGroupBoxControl::isTransparent() throw(uno::RuntimeException)
1740 {
1741     return sal_True;
1742 }
1743
1744 // =====================================================================================================================
1745 // = UnoControlListBoxModel_Data
1746 // =====================================================================================================================
1747 struct ListItem
1748 {
1749     ::rtl::OUString ItemText;
1750     ::rtl::OUString ItemImageURL;
1751     Any             ItemData;
1752
1753     ListItem()
1754         :ItemText()
1755         ,ItemImageURL()
1756         ,ItemData()
1757     {
1758     }
1759
1760     ListItem( const ::rtl::OUString& i_rItemText )
1761         :ItemText( i_rItemText )
1762         ,ItemImageURL()
1763         ,ItemData()
1764     {
1765     }
1766 };
1767
1768 typedef beans::Pair< ::rtl::OUString, ::rtl::OUString > UnoListItem;
1769
1770 struct StripItemData : public ::std::unary_function< ListItem, UnoListItem >
1771 {
1772     UnoListItem operator()( const ListItem& i_rItem )
1773     {
1774         return UnoListItem( i_rItem.ItemText, i_rItem.ItemImageURL );
1775     }
1776 };
1777
1778 struct UnoControlListBoxModel_Data
1779 {
1780     UnoControlListBoxModel_Data( UnoControlListBoxModel& i_rAntiImpl )
1781         :m_bSettingLegacyProperty( false )
1782         ,m_rAntiImpl( i_rAntiImpl )
1783         ,m_aListItems()
1784     {
1785     }
1786
1787     sal_Int32 getItemCount() const { return sal_Int32( m_aListItems.size() ); }
1788
1789     const ListItem& getItem( const sal_Int32 i_nIndex ) const
1790     {
1791         if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) )
1792             throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl );
1793         return m_aListItems[ i_nIndex ];
1794     }
1795
1796     ListItem& getItem( const sal_Int32 i_nIndex )
1797     {
1798         return const_cast< ListItem& >( static_cast< const UnoControlListBoxModel_Data* >( this )->getItem( i_nIndex ) );
1799     }
1800
1801     ListItem& insertItem( const sal_Int32 i_nIndex )
1802     {
1803         if ( ( i_nIndex < 0 ) || ( i_nIndex > sal_Int32( m_aListItems.size() ) ) )
1804             throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl );
1805         return *m_aListItems.insert( m_aListItems.begin() + i_nIndex, ListItem() );
1806     }
1807
1808     Sequence< UnoListItem > getAllItems() const
1809     {
1810         Sequence< UnoListItem > aItems( sal_Int32( m_aListItems.size() ) );
1811         ::std::transform( m_aListItems.begin(), m_aListItems.end(), aItems.getArray(), StripItemData() );
1812         return aItems;
1813     }
1814
1815     void copyItems( const UnoControlListBoxModel_Data& i_copySource )
1816     {
1817         m_aListItems = i_copySource.m_aListItems;
1818     }
1819
1820     void    setAllItems( const ::std::vector< ListItem >& i_rItems )
1821     {
1822         m_aListItems = i_rItems;
1823     }
1824
1825     void    removeItem( const sal_Int32 i_nIndex )
1826     {
1827         if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) )
1828             throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl );
1829         m_aListItems.erase( m_aListItems.begin() + i_nIndex );
1830     }
1831
1832     void removeAllItems()
1833     {
1834         ::std::vector< ListItem > aEmpty;
1835         m_aListItems.swap( aEmpty );
1836     }
1837
1838 public:
1839     bool                        m_bSettingLegacyProperty;
1840
1841 private:
1842     UnoControlListBoxModel&     m_rAntiImpl;
1843     ::std::vector< ListItem >   m_aListItems;
1844 };
1845
1846 // =====================================================================================================================
1847 // = UnoControlListBoxModel
1848 // =====================================================================================================================
1849 // ---------------------------------------------------------------------------------------------------------------------
1850 UnoControlListBoxModel::UnoControlListBoxModel( const Reference< XMultiServiceFactory >& i_factory, ConstructorMode const i_mode )
1851     :UnoControlListBoxModel_Base( i_factory )
1852     ,m_pData( new UnoControlListBoxModel_Data( *this ) )
1853     ,m_aItemListListeners( GetMutex() )
1854 {
1855     if ( i_mode == ConstructDefault )
1856     {
1857         UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXListBox );
1858     }
1859 }
1860 // ---------------------------------------------------------------------------------------------------------------------
1861 UnoControlListBoxModel::UnoControlListBoxModel( const UnoControlListBoxModel& i_rSource )
1862     :UnoControlListBoxModel_Base( i_rSource )
1863     ,m_pData( new UnoControlListBoxModel_Data( *this ) )
1864     ,m_aItemListListeners( GetMutex() )
1865 {
1866     m_pData->copyItems( *i_rSource.m_pData );
1867 }
1868 UnoControlListBoxModel::~UnoControlListBoxModel()
1869 {
1870 }
1871 IMPL_SERVICEINFO_DERIVED( UnoControlListBoxModel, UnoControlModel, szServiceName2_UnoControlListBoxModel )
1872 // ---------------------------------------------------------------------------------------------------------------------
1873 ::rtl::OUString UnoControlListBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1874 {
1875     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlListBoxModel );
1876 }
1877
1878 // ---------------------------------------------------------------------------------------------------------------------
1879 uno::Any UnoControlListBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1880 {
1881     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1882     {
1883         uno::Any aAny;
1884         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlListBox );
1885         return aAny;
1886     }
1887     return UnoControlModel::ImplGetDefaultValue( nPropId );
1888 }
1889
1890 // ---------------------------------------------------------------------------------------------------------------------
1891 ::cppu::IPropertyArrayHelper& UnoControlListBoxModel::getInfoHelper()
1892 {
1893     static UnoPropertyArrayHelper* pHelper = NULL;
1894     if ( !pHelper )
1895     {
1896         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
1897         pHelper = new UnoPropertyArrayHelper( aIDs );
1898     }
1899     return *pHelper;
1900 }
1901
1902 // ---------------------------------------------------------------------------------------------------------------------
1903 // beans::XMultiPropertySet
1904 uno::Reference< beans::XPropertySetInfo > UnoControlListBoxModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
1905 {
1906     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1907     return xInfo;
1908 }
1909
1910 // ---------------------------------------------------------------------------------------------------------------------
1911 namespace
1912 {
1913     struct CreateListItem : public ::std::unary_function< ::rtl::OUString, ListItem >
1914     {
1915         ListItem operator()( const ::rtl::OUString& i_rItemText )
1916         {
1917             return ListItem( i_rItemText );
1918         }
1919     };
1920 }
1921
1922 // ---------------------------------------------------------------------------------------------------------------------
1923 void SAL_CALL UnoControlListBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception)
1924 {
1925     UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
1926
1927     if ( nHandle == BASEPROPERTY_STRINGITEMLIST )
1928     {
1929         // reset selection
1930         uno::Sequence<sal_Int16> aSeq;
1931         uno::Any aAny;
1932         aAny <<= aSeq;
1933         setDependentFastPropertyValue( BASEPROPERTY_SELECTEDITEMS, aAny );
1934
1935         if ( !m_pData->m_bSettingLegacyProperty )
1936         {
1937             // synchronize the legacy StringItemList property with our list items
1938             Sequence< ::rtl::OUString > aStringItemList;
1939             Any aPropValue;
1940             getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
1941             OSL_VERIFY( aPropValue >>= aStringItemList );
1942
1943             ::std::vector< ListItem > aItems( aStringItemList.getLength() );
1944             ::std::transform(
1945                 aStringItemList.getConstArray(),
1946                 aStringItemList.getConstArray() + aStringItemList.getLength(),
1947                 aItems.begin(),
1948                 CreateListItem()
1949             );
1950             m_pData->setAllItems( aItems );
1951
1952             // since an XItemListListener does not have a "all items modified" or some such method,
1953             // we simulate this by notifying removal of all items, followed by insertion of all new
1954             // items
1955             lang::EventObject aEvent;
1956             aEvent.Source = *this;
1957             m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent );
1958             // TODO: OPropertySetHelper calls into this method with the mutex locked ...
1959             // which is wrong for the above notifications ...
1960         }
1961     }
1962 }
1963
1964 // ---------------------------------------------------------------------------------------------------------------------
1965 void UnoControlListBoxModel::ImplNormalizePropertySequence( const sal_Int32 _nCount, sal_Int32* _pHandles,
1966     uno::Any* _pValues, sal_Int32* _pValidHandles ) const SAL_THROW(())
1967 {
1968     // dependencies we know:
1969     // BASEPROPERTY_STRINGITEMLIST->BASEPROPERTY_SELECTEDITEMS
1970     ImplEnsureHandleOrder( _nCount, _pHandles, _pValues, BASEPROPERTY_STRINGITEMLIST, BASEPROPERTY_SELECTEDITEMS );
1971
1972     UnoControlModel::ImplNormalizePropertySequence( _nCount, _pHandles, _pValues, _pValidHandles );
1973 }
1974
1975 // ---------------------------------------------------------------------------------------------------------------------
1976 ::sal_Int32 SAL_CALL UnoControlListBoxModel::getItemCount() throw (RuntimeException)
1977 {
1978     ::osl::MutexGuard aGuard( GetMutex() );
1979     return m_pData->getItemCount();
1980 }
1981
1982 // ---------------------------------------------------------------------------------------------------------------------
1983 void SAL_CALL UnoControlListBoxModel::insertItem( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
1984 {
1985     ::osl::ClearableMutexGuard aGuard( GetMutex() );
1986     // SYNCHRONIZED ----->
1987     ListItem& rItem( m_pData->insertItem( i_nPosition ) );
1988     rItem.ItemText = i_rItemText;
1989     rItem.ItemImageURL = i_rItemImageURL;
1990
1991     impl_handleInsert( i_nPosition, i_rItemText, i_rItemImageURL, aGuard );
1992     // <----- SYNCHRONIZED
1993 }
1994
1995 // ---------------------------------------------------------------------------------------------------------------------
1996 void SAL_CALL UnoControlListBoxModel::insertItemText( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException)
1997 {
1998     ::osl::ClearableMutexGuard aGuard( GetMutex() );
1999     // SYNCHRONIZED ----->
2000     ListItem& rItem( m_pData->insertItem( i_nPosition ) );
2001     rItem.ItemText = i_rItemText;
2002
2003     impl_handleInsert( i_nPosition, i_rItemText, ::boost::optional< ::rtl::OUString >(), aGuard );
2004     // <----- SYNCHRONIZED
2005 }
2006
2007 // ---------------------------------------------------------------------------------------------------------------------
2008 void SAL_CALL UnoControlListBoxModel::insertItemImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2009 {
2010     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2011     // SYNCHRONIZED ----->
2012     ListItem& rItem( m_pData->insertItem( i_nPosition ) );
2013     rItem.ItemImageURL = i_rItemImageURL;
2014
2015     impl_handleInsert( i_nPosition, ::boost::optional< ::rtl::OUString >(), i_rItemImageURL, aGuard );
2016     // <----- SYNCHRONIZED
2017 }
2018
2019 // ---------------------------------------------------------------------------------------------------------------------
2020 void SAL_CALL UnoControlListBoxModel::removeItem( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2021 {
2022     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2023     // SYNCHRONIZED ----->
2024     m_pData->removeItem( i_nPosition );
2025
2026     impl_handleRemove( i_nPosition, aGuard );
2027     // <----- SYNCHRONIZED
2028 }
2029
2030 // ---------------------------------------------------------------------------------------------------------------------
2031 void SAL_CALL UnoControlListBoxModel::removeAllItems(  ) throw (::com::sun::star::uno::RuntimeException)
2032 {
2033     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2034     // SYNCHRONIZED ----->
2035     m_pData->removeAllItems();
2036
2037     impl_handleRemove( -1, aGuard );
2038     // <----- SYNCHRONIZED
2039 }
2040
2041 // ---------------------------------------------------------------------------------------------------------------------
2042 void SAL_CALL UnoControlListBoxModel::setItemText( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException)
2043 {
2044     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2045     // SYNCHRONIZED ----->
2046     ListItem& rItem( m_pData->getItem( i_nPosition ) );
2047     rItem.ItemText = i_rItemText;
2048
2049     impl_handleModify( i_nPosition, i_rItemText, ::boost::optional< ::rtl::OUString >(), aGuard );
2050     // <----- SYNCHRONIZED
2051 }
2052
2053 // ---------------------------------------------------------------------------------------------------------------------
2054 void SAL_CALL UnoControlListBoxModel::setItemImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2055 {
2056     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2057     // SYNCHRONIZED ----->
2058     ListItem& rItem( m_pData->getItem( i_nPosition ) );
2059     rItem.ItemImageURL = i_rItemImageURL;
2060
2061     impl_handleModify( i_nPosition, ::boost::optional< ::rtl::OUString >(), i_rItemImageURL, aGuard );
2062     // <----- SYNCHRONIZED
2063 }
2064
2065 // ---------------------------------------------------------------------------------------------------------------------
2066 void SAL_CALL UnoControlListBoxModel::setItemTextAndImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2067 {
2068     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2069     // SYNCHRONIZED ----->
2070     ListItem& rItem( m_pData->getItem( i_nPosition ) );
2071     rItem.ItemText = i_rItemText;
2072     rItem.ItemImageURL = i_rItemImageURL;
2073
2074     impl_handleModify( i_nPosition, i_rItemText, i_rItemImageURL, aGuard );
2075     // <----- SYNCHRONIZED
2076 }
2077
2078 // ---------------------------------------------------------------------------------------------------------------------
2079 void SAL_CALL UnoControlListBoxModel::setItemData( ::sal_Int32 i_nPosition, const Any& i_rDataValue ) throw (IndexOutOfBoundsException, RuntimeException)
2080 {
2081     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2082     ListItem& rItem( m_pData->getItem( i_nPosition ) );
2083     rItem.ItemData = i_rDataValue;
2084 }
2085
2086 // ---------------------------------------------------------------------------------------------------------------------
2087 ::rtl::OUString SAL_CALL UnoControlListBoxModel::getItemText( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2088 {
2089     ::osl::MutexGuard aGuard( GetMutex() );
2090     const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2091     return rItem.ItemText;
2092 }
2093
2094 // ---------------------------------------------------------------------------------------------------------------------
2095 ::rtl::OUString SAL_CALL UnoControlListBoxModel::getItemImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2096 {
2097     ::osl::MutexGuard aGuard( GetMutex() );
2098     const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2099     return rItem.ItemImageURL;
2100 }
2101
2102 // ---------------------------------------------------------------------------------------------------------------------
2103 beans::Pair< ::rtl::OUString, ::rtl::OUString > SAL_CALL UnoControlListBoxModel::getItemTextAndImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2104 {
2105     ::osl::MutexGuard aGuard( GetMutex() );
2106     const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2107     return beans::Pair< ::rtl::OUString, ::rtl::OUString >( rItem.ItemText, rItem.ItemImageURL );
2108 }
2109
2110 // ---------------------------------------------------------------------------------------------------------------------
2111 Any SAL_CALL UnoControlListBoxModel::getItemData( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2112 {
2113     ::osl::ClearableMutexGuard aGuard( GetMutex() );
2114     const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2115     return rItem.ItemData;
2116 }
2117
2118 // ---------------------------------------------------------------------------------------------------------------------
2119 Sequence< beans::Pair< ::rtl::OUString, ::rtl::OUString > > SAL_CALL UnoControlListBoxModel::getAllItems(  ) throw (RuntimeException)
2120 {
2121     ::osl::MutexGuard aGuard( GetMutex() );
2122     return m_pData->getAllItems();
2123 }
2124
2125 // ---------------------------------------------------------------------------------------------------------------------
2126 void SAL_CALL UnoControlListBoxModel::addItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException)
2127 {
2128     if ( i_Listener.is() )
2129         m_aItemListListeners.addInterface( i_Listener );
2130 }
2131
2132 // ---------------------------------------------------------------------------------------------------------------------
2133 void SAL_CALL UnoControlListBoxModel::removeItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException)
2134 {
2135     if ( i_Listener.is() )
2136         m_aItemListListeners.removeInterface( i_Listener );
2137 }
2138
2139 // ---------------------------------------------------------------------------------------------------------------------
2140 void UnoControlListBoxModel::impl_getStringItemList( ::std::vector< ::rtl::OUString >& o_rStringItems ) const
2141 {
2142     Sequence< ::rtl::OUString > aStringItemList;
2143     Any aPropValue;
2144     getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
2145     OSL_VERIFY( aPropValue >>= aStringItemList );
2146
2147     o_rStringItems.resize( size_t( aStringItemList.getLength() ) );
2148     ::std::copy(
2149         aStringItemList.getConstArray(),
2150         aStringItemList.getConstArray() + aStringItemList.getLength(),
2151         o_rStringItems.begin()
2152     );
2153 }
2154
2155 // ---------------------------------------------------------------------------------------------------------------------
2156 void UnoControlListBoxModel::impl_setStringItemList_nolck( const ::std::vector< ::rtl::OUString >& i_rStringItems )
2157 {
2158     Sequence< ::rtl::OUString > aStringItems( i_rStringItems.size() );
2159     ::std::copy(
2160         i_rStringItems.begin(),
2161         i_rStringItems.end(),
2162         aStringItems.getArray()
2163     );
2164     m_pData->m_bSettingLegacyProperty = true;
2165     try
2166     {
2167         setFastPropertyValue( BASEPROPERTY_STRINGITEMLIST, uno::makeAny( aStringItems ) );
2168     }
2169     catch( const Exception& )
2170     {
2171         m_pData->m_bSettingLegacyProperty = false;
2172         throw;
2173     }
2174     m_pData->m_bSettingLegacyProperty = false;
2175 }
2176
2177 // ---------------------------------------------------------------------------------------------------------------------
2178 void UnoControlListBoxModel::impl_handleInsert( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText,
2179         const ::boost::optional< ::rtl::OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2180 {
2181     // SYNCHRONIZED ----->
2182     // sync with legacy StringItemList property
2183     ::std::vector< ::rtl::OUString > aStringItems;
2184     impl_getStringItemList( aStringItems );
2185     OSL_ENSURE( size_t( i_nItemPosition ) <= aStringItems.size(), "UnoControlListBoxModel::impl_handleInsert" );
2186     if ( size_t( i_nItemPosition ) <= aStringItems.size() )
2187     {
2188         const ::rtl::OUString sItemText( !!i_rItemText ? *i_rItemText : ::rtl::OUString() );
2189         aStringItems.insert( aStringItems.begin() + i_nItemPosition, sItemText );
2190     }
2191
2192     i_rClearBeforeNotify.clear();
2193     // <----- SYNCHRONIZED
2194     impl_setStringItemList_nolck( aStringItems );
2195
2196     // notify ItemListListeners
2197     impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemInserted );
2198 }
2199
2200 // ---------------------------------------------------------------------------------------------------------------------
2201 void UnoControlListBoxModel::impl_handleRemove( const sal_Int32 i_nItemPosition, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2202 {
2203     // SYNCHRONIZED ----->
2204     const bool bAllItems = ( i_nItemPosition < 0 );
2205     // sync with legacy StringItemList property
2206     ::std::vector< ::rtl::OUString > aStringItems;
2207     impl_getStringItemList( aStringItems );
2208     if ( !bAllItems )
2209     {
2210         OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleRemove" );
2211         if ( size_t( i_nItemPosition ) < aStringItems.size() )
2212         {
2213             aStringItems.erase( aStringItems.begin() + i_nItemPosition );
2214         }
2215     }
2216     else
2217     {
2218         aStringItems.resize(0);
2219     }
2220
2221     i_rClearBeforeNotify.clear();
2222     // <----- SYNCHRONIZED
2223     impl_setStringItemList_nolck( aStringItems );
2224
2225     // notify ItemListListeners
2226     if ( bAllItems )
2227     {
2228         EventObject aEvent( *this );
2229         m_aItemListListeners.notifyEach( &XItemListListener::allItemsRemoved, aEvent );
2230     }
2231     else
2232     {
2233         impl_notifyItemListEvent_nolck( i_nItemPosition, ::boost::optional< ::rtl::OUString >(), ::boost::optional< ::rtl::OUString >(),
2234             &XItemListListener::listItemRemoved );
2235     }
2236 }
2237
2238 // ---------------------------------------------------------------------------------------------------------------------
2239 void UnoControlListBoxModel::impl_handleModify( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText,
2240         const ::boost::optional< ::rtl::OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2241 {
2242     // SYNCHRONIZED ----->
2243     if ( !!i_rItemText )
2244     {
2245         // sync with legacy StringItemList property
2246         ::std::vector< ::rtl::OUString > aStringItems;
2247         impl_getStringItemList( aStringItems );
2248         OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleModify" );
2249         if ( size_t( i_nItemPosition ) < aStringItems.size() )
2250         {
2251             aStringItems[ i_nItemPosition] = *i_rItemText;
2252         }
2253
2254         i_rClearBeforeNotify.clear();
2255         // <----- SYNCHRONIZED
2256         impl_setStringItemList_nolck( aStringItems );
2257     }
2258     else
2259     {
2260         i_rClearBeforeNotify.clear();
2261         // <----- SYNCHRONIZED
2262     }
2263
2264     // notify ItemListListeners
2265     impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemModified );
2266 }
2267
2268 // ---------------------------------------------------------------------------------------------------------------------
2269 void UnoControlListBoxModel::impl_notifyItemListEvent_nolck( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText,
2270     const ::boost::optional< ::rtl::OUString >& i_rItemImageURL,
2271     void ( SAL_CALL XItemListListener::*NotificationMethod )( const ItemListEvent& ) )
2272 {
2273     ItemListEvent aEvent;
2274     aEvent.Source = *this;
2275     aEvent.ItemPosition = i_nItemPosition;
2276     if ( !!i_rItemText )
2277     {
2278         aEvent.ItemText.IsPresent = sal_True;
2279         aEvent.ItemText.Value = *i_rItemText;
2280     }
2281     if ( !!i_rItemImageURL )
2282     {
2283         aEvent.ItemImageURL.IsPresent = sal_True;
2284         aEvent.ItemImageURL.Value = *i_rItemImageURL;
2285     }
2286
2287     m_aItemListListeners.notifyEach( NotificationMethod, aEvent );
2288 }
2289
2290 //  ----------------------------------------------------
2291 //  class UnoListBoxControl
2292 //  ----------------------------------------------------
2293 UnoListBoxControl::UnoListBoxControl( const Reference< XMultiServiceFactory >& i_factory )
2294     :UnoListBoxControl_Base( i_factory )
2295     ,maActionListeners( *this )
2296     ,maItemListeners( *this )
2297 {
2298     maComponentInfos.nWidth = 100;
2299     maComponentInfos.nHeight = 12;
2300 }
2301
2302 ::rtl::OUString UnoListBoxControl::GetComponentServiceName()
2303 {
2304     return ::rtl::OUString("listbox");
2305 }
2306 IMPL_SERVICEINFO_DERIVED( UnoListBoxControl, UnoControlBase, szServiceName2_UnoControlListBox )
2307
2308 void UnoListBoxControl::dispose() throw(uno::RuntimeException)
2309 {
2310     lang::EventObject aEvt;
2311     aEvt.Source = (::cppu::OWeakObject*)this;
2312     maActionListeners.disposeAndClear( aEvt );
2313     maItemListeners.disposeAndClear( aEvt );
2314     UnoControl::dispose();
2315 }
2316
2317 void UnoListBoxControl::ImplUpdateSelectedItemsProperty()
2318 {
2319     if ( getPeer().is() )
2320     {
2321         uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2322         DBG_ASSERT( xListBox.is(), "XListBox?" );
2323
2324         uno::Sequence<sal_Int16> aSeq = xListBox->getSelectedItemsPos();
2325         uno::Any aAny;
2326         aAny <<= aSeq;
2327         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ), aAny, sal_False );
2328     }
2329 }
2330
2331 void UnoListBoxControl::updateFromModel()
2332 {
2333     UnoControlBase::updateFromModel();
2334
2335     Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY );
2336     ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoListBoxControl::updateFromModel: a peer which is no ItemListListener?!" );
2337
2338     EventObject aEvent( getModel() );
2339     xItemListListener->itemListChanged( aEvent );
2340
2341     // notify the change of the SelectedItems property, again. While our base class, in updateFromModel,
2342     // already did this, our peer(s) can only legitimately set the selection after they have the string
2343     // item list, which we just notified with the itemListChanged call.
2344     const ::rtl::OUString sSelectedItemsPropName( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ) );
2345     ImplSetPeerProperty( sSelectedItemsPropName, ImplGetPropertyValue( sSelectedItemsPropName ) );
2346 }
2347
2348 void UnoListBoxControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal )
2349 {
2350     if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) )
2351         // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item
2352         // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes
2353         // will be forwarded to the peer, which will update itself accordingly.
2354         return;
2355
2356     UnoControl::ImplSetPeerProperty( rPropName, rVal );
2357 }
2358
2359 void UnoListBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
2360 {
2361     UnoControl::createPeer( rxToolkit, rParentPeer );
2362
2363     uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2364     xListBox->addItemListener( this );
2365
2366     if ( maActionListeners.getLength() )
2367         xListBox->addActionListener( &maActionListeners );
2368 }
2369
2370 void UnoListBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2371 {
2372     maActionListeners.addInterface( l );
2373     if( getPeer().is() && maActionListeners.getLength() == 1 )
2374     {
2375         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2376         xListBox->addActionListener( &maActionListeners );
2377     }
2378 }
2379
2380 void UnoListBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2381 {
2382     if( getPeer().is() && maActionListeners.getLength() == 1 )
2383     {
2384         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2385         xListBox->removeActionListener( &maActionListeners );
2386     }
2387     maActionListeners.removeInterface( l );
2388 }
2389
2390 void UnoListBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2391 {
2392     maItemListeners.addInterface( l );
2393 }
2394
2395 void UnoListBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2396 {
2397     maItemListeners.removeInterface( l );
2398 }
2399
2400 void UnoListBoxControl::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException)
2401 {
2402     uno::Sequence< ::rtl::OUString> aSeq( 1 );
2403     aSeq.getArray()[0] = aItem;
2404     addItems( aSeq, nPos );
2405 }
2406
2407 void UnoListBoxControl::addItems( const uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException)
2408 {
2409     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2410     uno::Sequence< ::rtl::OUString> aSeq;
2411     aVal >>= aSeq;
2412     sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength();
2413     sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
2414     sal_uInt16 nNewLen = nOldLen + nNewItems;
2415
2416     uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen );
2417     ::rtl::OUString* pNewData = aNewSeq.getArray();
2418     ::rtl::OUString* pOldData = aSeq.getArray();
2419
2420     if ( ( nPos < 0 ) || ( nPos > nOldLen ) )
2421         nPos = (sal_uInt16) nOldLen;
2422
2423     sal_uInt16 n;
2424     // Items vor der Einfuege-Position
2425     for ( n = 0; n < nPos; n++ )
2426         pNewData[n] = pOldData[n];
2427
2428     // Neue Items
2429     for ( n = 0; n < nNewItems; n++ )
2430         pNewData[nPos+n] = aItems.getConstArray()[n];
2431
2432     // Rest der alten Items
2433     for ( n = nPos; n < nOldLen; n++ )
2434         pNewData[nNewItems+n] = pOldData[n];
2435
2436     uno::Any aAny;
2437     aAny <<= aNewSeq;
2438     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
2439 }
2440
2441 void UnoListBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException)
2442 {
2443     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2444     uno::Sequence< ::rtl::OUString> aSeq;
2445     aVal >>= aSeq;
2446     sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
2447     if ( nOldLen && ( nPos < nOldLen ) )
2448     {
2449         if ( nCount > ( nOldLen-nPos ) )
2450             nCount = nOldLen-nPos;
2451
2452         sal_uInt16 nNewLen = nOldLen - nCount;
2453
2454         uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen );
2455         ::rtl::OUString* pNewData = aNewSeq.getArray();
2456         ::rtl::OUString* pOldData = aSeq.getArray();
2457
2458         sal_uInt16 n;
2459         // Items vor der Entfern-Position
2460         for ( n = 0; n < nPos; n++ )
2461             pNewData[n] = pOldData[n];
2462
2463         // Rest der Items
2464         for ( n = nPos; n < (nOldLen-nCount); n++ )
2465             pNewData[n] = pOldData[n+nCount];
2466
2467         uno::Any aAny;
2468         aAny <<= aNewSeq;
2469         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
2470     }
2471 }
2472
2473 sal_Int16 UnoListBoxControl::getItemCount() throw(uno::RuntimeException)
2474 {
2475     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2476     uno::Sequence< ::rtl::OUString> aSeq;
2477     aVal >>= aSeq;
2478     return (sal_Int16)aSeq.getLength();
2479 }
2480
2481 ::rtl::OUString UnoListBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException)
2482 {
2483     ::rtl::OUString aItem;
2484     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2485     uno::Sequence< ::rtl::OUString> aSeq;
2486     aVal >>= aSeq;
2487     if ( nPos < aSeq.getLength() )
2488         aItem = aSeq.getConstArray()[nPos];
2489     return aItem;
2490 }
2491
2492 uno::Sequence< ::rtl::OUString> UnoListBoxControl::getItems() throw(uno::RuntimeException)
2493 {
2494     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2495     uno::Sequence< ::rtl::OUString> aSeq;
2496     aVal >>= aSeq;
2497     return aSeq;
2498 }
2499
2500 sal_Int16 UnoListBoxControl::getSelectedItemPos() throw(uno::RuntimeException)
2501 {
2502     sal_Int16 n = -1;
2503     if ( getPeer().is() )
2504     {
2505         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2506         n = xListBox->getSelectedItemPos();
2507     }
2508     return n;
2509 }
2510
2511 uno::Sequence<sal_Int16> UnoListBoxControl::getSelectedItemsPos() throw(uno::RuntimeException)
2512 {
2513     uno::Sequence<sal_Int16> aSeq;
2514     if ( getPeer().is() )
2515     {
2516         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2517         aSeq = xListBox->getSelectedItemsPos();
2518     }
2519     return aSeq;
2520 }
2521
2522 ::rtl::OUString UnoListBoxControl::getSelectedItem() throw(uno::RuntimeException)
2523 {
2524     ::rtl::OUString aItem;
2525     if ( getPeer().is() )
2526     {
2527         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2528         aItem = xListBox->getSelectedItem();
2529     }
2530     return aItem;
2531 }
2532
2533 uno::Sequence< ::rtl::OUString> UnoListBoxControl::getSelectedItems() throw(uno::RuntimeException)
2534 {
2535     uno::Sequence< ::rtl::OUString> aSeq;
2536     if ( getPeer().is() )
2537     {
2538         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2539         aSeq = xListBox->getSelectedItems();
2540     }
2541     return aSeq;
2542 }
2543
2544 void UnoListBoxControl::selectItemPos( sal_Int16 nPos, sal_Bool bSelect ) throw(uno::RuntimeException)
2545 {
2546     if ( getPeer().is() )
2547     {
2548         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2549         xListBox->selectItemPos( nPos, bSelect );
2550     }
2551     ImplUpdateSelectedItemsProperty();
2552 }
2553
2554 void UnoListBoxControl::selectItemsPos( const uno::Sequence<sal_Int16>& aPositions, sal_Bool bSelect ) throw(uno::RuntimeException)
2555 {
2556     if ( getPeer().is() )
2557     {
2558         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2559         xListBox->selectItemsPos( aPositions, bSelect );
2560     }
2561     ImplUpdateSelectedItemsProperty();
2562 }
2563
2564 void UnoListBoxControl::selectItem( const ::rtl::OUString& aItem, sal_Bool bSelect ) throw(uno::RuntimeException)
2565 {
2566     if ( getPeer().is() )
2567     {
2568         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2569         xListBox->selectItem( aItem, bSelect );
2570     }
2571     ImplUpdateSelectedItemsProperty();
2572 }
2573
2574 void UnoListBoxControl::makeVisible( sal_Int16 nEntry ) throw(uno::RuntimeException)
2575 {
2576     if ( getPeer().is() )
2577     {
2578         uno::Reference < awt::XListBox >  xListBox( getPeer(), uno::UNO_QUERY );
2579         xListBox->makeVisible( nEntry );
2580     }
2581 }
2582
2583 void UnoListBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException)
2584 {
2585     uno::Any aAny;
2586     aAny <<= (sal_Int16)nLines;
2587     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True );
2588 }
2589
2590 sal_Int16 UnoListBoxControl::getDropDownLineCount() throw(uno::RuntimeException)
2591 {
2592     return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT );
2593 }
2594
2595 sal_Bool UnoListBoxControl::isMutipleMode() throw(uno::RuntimeException)
2596 {
2597     return ImplGetPropertyValue_BOOL( BASEPROPERTY_MULTISELECTION );
2598 }
2599
2600 void UnoListBoxControl::setMultipleMode( sal_Bool bMulti ) throw(uno::RuntimeException)
2601 {
2602     uno::Any aAny;
2603     aAny <<= bMulti;
2604     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTISELECTION ), aAny, sal_True );
2605 }
2606
2607 void UnoListBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
2608 {
2609     ImplUpdateSelectedItemsProperty();
2610     if ( maItemListeners.getLength() )
2611     {
2612         try
2613         {
2614             maItemListeners.itemStateChanged( rEvent );
2615         }
2616         catch( const Exception& e )
2617         {
2618 #if OSL_DEBUG_LEVEL == 0
2619             (void) e; // suppress warning
2620 #else
2621             ::rtl::OString sMessage( "UnoListBoxControl::itemStateChanged: caught an exception:\n" );
2622             sMessage += ::rtl::OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US );
2623             OSL_FAIL( sMessage.getStr() );
2624 #endif
2625         }
2626     }
2627 }
2628
2629 awt::Size UnoListBoxControl::getMinimumSize(  ) throw(uno::RuntimeException)
2630 {
2631     return Impl_getMinimumSize();
2632 }
2633
2634 awt::Size UnoListBoxControl::getPreferredSize(  ) throw(uno::RuntimeException)
2635 {
2636     return Impl_getPreferredSize();
2637 }
2638
2639 awt::Size UnoListBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
2640 {
2641     return Impl_calcAdjustedSize( rNewSize );
2642 }
2643
2644 awt::Size UnoListBoxControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException)
2645 {
2646     return Impl_getMinimumSize( nCols, nLines );
2647 }
2648
2649 void UnoListBoxControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException)
2650 {
2651     Impl_getColumnsAndLines( nCols, nLines );
2652 }
2653
2654 sal_Bool SAL_CALL UnoListBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException )
2655 {
2656     ::osl::MutexGuard aGuard( GetMutex() );
2657
2658     const Reference< XItemList > xOldItems( getModel(), UNO_QUERY );
2659     OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoListBoxControl::setModel: illegal old model!" );
2660     const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY );
2661     OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoListBoxControl::setModel: illegal new model!" );
2662
2663     if ( !UnoListBoxControl_Base::setModel( i_rModel ) )
2664         return sal_False;
2665
2666     if ( xOldItems.is() )
2667         xOldItems->removeItemListListener( this );
2668     if ( xNewItems.is() )
2669         xNewItems->addItemListListener( this );
2670
2671     return sal_True;
2672 }
2673
2674 void SAL_CALL UnoListBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2675 {
2676     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2677     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemInserted: invalid peer!" );
2678     if ( xPeerListener.is() )
2679         xPeerListener->listItemInserted( i_rEvent );
2680 }
2681
2682 void SAL_CALL UnoListBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2683 {
2684     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2685     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemRemoved: invalid peer!" );
2686     if ( xPeerListener.is() )
2687         xPeerListener->listItemRemoved( i_rEvent );
2688 }
2689
2690 void SAL_CALL UnoListBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2691 {
2692     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2693     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemModified: invalid peer!" );
2694     if ( xPeerListener.is() )
2695         xPeerListener->listItemModified( i_rEvent );
2696 }
2697
2698 void SAL_CALL UnoListBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2699 {
2700     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2701     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::allItemsRemoved: invalid peer!" );
2702     if ( xPeerListener.is() )
2703         xPeerListener->allItemsRemoved( i_rEvent );
2704 }
2705
2706 void SAL_CALL UnoListBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2707 {
2708     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2709     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::itemListChanged: invalid peer!" );
2710     if ( xPeerListener.is() )
2711         xPeerListener->itemListChanged( i_rEvent );
2712 }
2713
2714 //  ----------------------------------------------------
2715 //  class UnoControlComboBoxModel
2716 //  ----------------------------------------------------
2717 UnoControlComboBoxModel::UnoControlComboBoxModel( const Reference< XMultiServiceFactory >& i_factory )
2718     :UnoControlListBoxModel( i_factory, ConstructWithoutProperties )
2719 {
2720     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXComboBox );
2721 }
2722
2723 IMPL_SERVICEINFO_DERIVED( UnoControlComboBoxModel, UnoControlModel, szServiceName2_UnoControlComboBoxModel )
2724
2725 uno::Reference< beans::XPropertySetInfo > UnoControlComboBoxModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
2726 {
2727     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
2728     return xInfo;
2729 }
2730 // ---------------------------------------------------------------------------------------------------------------------
2731 ::cppu::IPropertyArrayHelper& UnoControlComboBoxModel::getInfoHelper()
2732 {
2733     static UnoPropertyArrayHelper* pHelper = NULL;
2734     if ( !pHelper )
2735     {
2736         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
2737         pHelper = new UnoPropertyArrayHelper( aIDs );
2738     }
2739     return *pHelper;
2740 }
2741
2742
2743 ::rtl::OUString UnoControlComboBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
2744 {
2745     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlComboBoxModel );
2746 }
2747 void SAL_CALL UnoControlComboBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception)
2748 {
2749     UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
2750
2751     if ( nHandle == BASEPROPERTY_STRINGITEMLIST && !m_pData->m_bSettingLegacyProperty)
2752     {
2753         // synchronize the legacy StringItemList property with our list items
2754         Sequence< ::rtl::OUString > aStringItemList;
2755         Any aPropValue;
2756         getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
2757         OSL_VERIFY( aPropValue >>= aStringItemList );
2758
2759         ::std::vector< ListItem > aItems( aStringItemList.getLength() );
2760         ::std::transform(
2761             aStringItemList.getConstArray(),
2762             aStringItemList.getConstArray() + aStringItemList.getLength(),
2763             aItems.begin(),
2764             CreateListItem()
2765         );
2766         m_pData->setAllItems( aItems );
2767
2768         // since an XItemListListener does not have a "all items modified" or some such method,
2769         // we simulate this by notifying removal of all items, followed by insertion of all new
2770         // items
2771         lang::EventObject aEvent;
2772         aEvent.Source = *this;
2773         m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent );
2774         // TODO: OPropertySetHelper calls into this method with the mutex locked ...
2775         // which is wrong for the above notifications ...
2776     }
2777 }
2778
2779 uno::Any UnoControlComboBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
2780 {
2781     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
2782     {
2783         uno::Any aAny;
2784         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlComboBox );
2785         return aAny;
2786     }
2787     return UnoControlModel::ImplGetDefaultValue( nPropId );
2788 }
2789
2790 //  ----------------------------------------------------
2791 //  class UnoComboBoxControl
2792 //  ----------------------------------------------------
2793 UnoComboBoxControl::UnoComboBoxControl( const Reference< XMultiServiceFactory >& i_factory )
2794     :UnoEditControl( i_factory )
2795     ,maActionListeners( *this )
2796     ,maItemListeners( *this )
2797 {
2798     maComponentInfos.nWidth = 100;
2799     maComponentInfos.nHeight = 12;
2800 }
2801 IMPL_SERVICEINFO_DERIVED( UnoComboBoxControl, UnoEditControl, szServiceName2_UnoControlComboBox )
2802
2803 ::rtl::OUString UnoComboBoxControl::GetComponentServiceName()
2804 {
2805     return ::rtl::OUString("combobox");
2806 }
2807
2808 void UnoComboBoxControl::dispose() throw(uno::RuntimeException)
2809 {
2810     lang::EventObject aEvt;
2811     aEvt.Source = (::cppu::OWeakObject*)this;
2812     maActionListeners.disposeAndClear( aEvt );
2813     maItemListeners.disposeAndClear( aEvt );
2814     UnoControl::dispose();
2815 }
2816 uno::Any UnoComboBoxControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
2817 {
2818     uno::Any aRet = ::cppu::queryInterface( rType,
2819                                         (static_cast< awt::XComboBox* >(this)) );
2820     if ( !aRet.hasValue() )
2821     {
2822         aRet = ::cppu::queryInterface( rType,
2823                                         (static_cast< awt::XItemListener* >(this)) );
2824         if ( !aRet.hasValue() )
2825         {
2826             aRet = ::cppu::queryInterface( rType,
2827                                             (static_cast< awt::XItemListListener* >(this)) );
2828         }
2829     }
2830     return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType ));
2831 }
2832 // lang::XTypeProvider
2833 IMPL_XTYPEPROVIDER_START( UnoComboBoxControl )
2834     getCppuType( ( uno::Reference< awt::XComboBox>* ) NULL ),
2835     getCppuType( ( uno::Reference< awt::XItemListener>* ) NULL ),
2836     getCppuType( ( uno::Reference< awt::XItemListListener>* ) NULL ),
2837     UnoEditControl::getTypes()
2838 IMPL_XTYPEPROVIDER_END
2839
2840 void UnoComboBoxControl::updateFromModel()
2841 {
2842     UnoEditControl::updateFromModel();
2843
2844     Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY );
2845     ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoComboBoxControl::updateFromModel: a peer which is no ItemListListener?!" );
2846
2847     EventObject aEvent( getModel() );
2848     xItemListListener->itemListChanged( aEvent );
2849 }
2850 void UnoComboBoxControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal )
2851 {
2852     if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) )
2853         // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item
2854         // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes
2855         // will be forwarded to the peer, which will update itself accordingly.
2856         return;
2857
2858     UnoEditControl::ImplSetPeerProperty( rPropName, rVal );
2859 }
2860 void UnoComboBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
2861 {
2862     UnoEditControl::createPeer( rxToolkit, rParentPeer );
2863
2864     uno::Reference < awt::XComboBox >  xComboBox( getPeer(), uno::UNO_QUERY );
2865     if ( maActionListeners.getLength() )
2866         xComboBox->addActionListener( &maActionListeners );
2867     if ( maItemListeners.getLength() )
2868         xComboBox->addItemListener( &maItemListeners );
2869 }
2870
2871 void UnoComboBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2872 {
2873     maActionListeners.addInterface( l );
2874     if( getPeer().is() && maActionListeners.getLength() == 1 )
2875     {
2876         uno::Reference < awt::XComboBox >  xComboBox( getPeer(), uno::UNO_QUERY );
2877         xComboBox->addActionListener( &maActionListeners );
2878     }
2879 }
2880
2881 void UnoComboBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2882 {
2883     if( getPeer().is() && maActionListeners.getLength() == 1 )
2884     {
2885         uno::Reference < awt::XComboBox >  xComboBox( getPeer(), uno::UNO_QUERY );
2886         xComboBox->removeActionListener( &maActionListeners );
2887     }
2888     maActionListeners.removeInterface( l );
2889 }
2890
2891 void UnoComboBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2892 {
2893     maItemListeners.addInterface( l );
2894     if( getPeer().is() && maItemListeners.getLength() == 1 )
2895     {
2896         uno::Reference < awt::XComboBox >  xComboBox( getPeer(), uno::UNO_QUERY );
2897         xComboBox->addItemListener( &maItemListeners );
2898     }
2899 }
2900
2901 void UnoComboBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2902 {
2903     if( getPeer().is() && maItemListeners.getLength() == 1 )
2904     {
2905         // This call is prettier than creating a Ref and calling query
2906         uno::Reference < awt::XComboBox >  xComboBox( getPeer(), uno::UNO_QUERY );
2907         xComboBox->removeItemListener( &maItemListeners );
2908     }
2909     maItemListeners.removeInterface( l );
2910 }
2911 void UnoComboBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
2912 {
2913     if ( maItemListeners.getLength() )
2914     {
2915         try
2916         {
2917             maItemListeners.itemStateChanged( rEvent );
2918         }
2919         catch( const Exception& e )
2920         {
2921 #if OSL_DEBUG_LEVEL == 0
2922             (void) e; // suppress warning
2923 #else
2924             ::rtl::OString sMessage( "UnoComboBoxControl::itemStateChanged: caught an exception:\n" );
2925             sMessage += ::rtl::OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US );
2926             OSL_FAIL( sMessage.getStr() );
2927 #endif
2928         }
2929     }
2930 }
2931 sal_Bool SAL_CALL UnoComboBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException )
2932 {
2933     ::osl::MutexGuard aGuard( GetMutex() );
2934
2935     const Reference< XItemList > xOldItems( getModel(), UNO_QUERY );
2936     OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoComboBoxControl::setModel: illegal old model!" );
2937     const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY );
2938     OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoComboBoxControl::setModel: illegal new model!" );
2939
2940     if ( !UnoEditControl::setModel( i_rModel ) )
2941         return sal_False;
2942
2943     if ( xOldItems.is() )
2944         xOldItems->removeItemListListener( this );
2945     if ( xNewItems.is() )
2946         xNewItems->addItemListListener( this );
2947
2948     return sal_True;
2949 }
2950
2951 void SAL_CALL UnoComboBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2952 {
2953     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2954     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemInserted: invalid peer!" );
2955     if ( xPeerListener.is() )
2956         xPeerListener->listItemInserted( i_rEvent );
2957 }
2958
2959 void SAL_CALL UnoComboBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2960 {
2961     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2962     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemRemoved: invalid peer!" );
2963     if ( xPeerListener.is() )
2964         xPeerListener->listItemRemoved( i_rEvent );
2965 }
2966
2967 void SAL_CALL UnoComboBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2968 {
2969     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2970     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemModified: invalid peer!" );
2971     if ( xPeerListener.is() )
2972         xPeerListener->listItemModified( i_rEvent );
2973 }
2974
2975 void SAL_CALL UnoComboBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2976 {
2977     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2978     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::allItemsRemoved: invalid peer!" );
2979     if ( xPeerListener.is() )
2980         xPeerListener->allItemsRemoved( i_rEvent );
2981 }
2982
2983 void SAL_CALL UnoComboBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2984 {
2985     const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2986     OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::itemListChanged: invalid peer!" );
2987     if ( xPeerListener.is() )
2988         xPeerListener->itemListChanged( i_rEvent );
2989 }
2990
2991 void UnoComboBoxControl::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException)
2992 {
2993     uno::Sequence< ::rtl::OUString> aSeq( 1 );
2994     aSeq.getArray()[0] = aItem;
2995     addItems( aSeq, nPos );
2996 }
2997
2998 void UnoComboBoxControl::addItems( const uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException)
2999 {
3000     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3001     uno::Sequence< ::rtl::OUString> aSeq;
3002     aVal >>= aSeq;
3003     sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength();
3004     sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
3005     sal_uInt16 nNewLen = nOldLen + nNewItems;
3006
3007     uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen );
3008     ::rtl::OUString* pNewData = aNewSeq.getArray();
3009     const ::rtl::OUString* pOldData = aSeq.getConstArray();
3010
3011     if ( ( nPos < 0 ) || ( nPos > nOldLen ) )
3012         nPos = (sal_uInt16) nOldLen;
3013
3014     sal_uInt16 n;
3015     // items before the insert position
3016     for ( n = 0; n < nPos; n++ )
3017         pNewData[n] = pOldData[n];
3018
3019     // New items
3020     for ( n = 0; n < nNewItems; n++ )
3021         pNewData[nPos+n] = aItems.getConstArray()[n];
3022
3023     // remainder of old items
3024     for ( n = nPos; n < nOldLen; n++ )
3025         pNewData[nNewItems+n] = pOldData[n];
3026
3027     uno::Any aAny;
3028     aAny <<= aNewSeq;
3029     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
3030 }
3031
3032 void UnoComboBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException)
3033 {
3034     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3035     uno::Sequence< ::rtl::OUString> aSeq;
3036     aVal >>= aSeq;
3037     sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
3038     if ( nOldLen && ( nPos < nOldLen ) )
3039     {
3040         if ( nCount > ( nOldLen-nPos ) )
3041             nCount = nOldLen-nPos;
3042
3043         sal_uInt16 nNewLen = nOldLen - nCount;
3044
3045         uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen );
3046         ::rtl::OUString* pNewData = aNewSeq.getArray();
3047         ::rtl::OUString* pOldData = aSeq.getArray();
3048
3049         sal_uInt16 n;
3050         // items before the deletion position
3051         for ( n = 0; n < nPos; n++ )
3052             pNewData[n] = pOldData[n];
3053
3054         // remainder of old items
3055         for ( n = nPos; n < (nOldLen-nCount); n++ )
3056             pNewData[n] = pOldData[n+nCount];
3057
3058         uno::Any aAny;
3059         aAny <<= aNewSeq;
3060         ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
3061     }
3062 }
3063
3064 sal_Int16 UnoComboBoxControl::getItemCount() throw(uno::RuntimeException)
3065 {
3066     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3067     uno::Sequence< ::rtl::OUString> aSeq;
3068     aVal >>= aSeq;
3069     return (sal_Int16)aSeq.getLength();
3070 }
3071
3072 ::rtl::OUString UnoComboBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException)
3073 {
3074     ::rtl::OUString aItem;
3075     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3076     uno::Sequence< ::rtl::OUString> aSeq;
3077     aVal >>= aSeq;
3078     if ( nPos < aSeq.getLength() )
3079         aItem = aSeq.getConstArray()[nPos];
3080     return aItem;
3081 }
3082
3083 uno::Sequence< ::rtl::OUString> UnoComboBoxControl::getItems() throw(uno::RuntimeException)
3084 {
3085     uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3086     uno::Sequence< ::rtl::OUString> aSeq;
3087     aVal >>= aSeq;
3088     return aSeq;
3089 }
3090
3091 void UnoComboBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException)
3092 {
3093     uno::Any aAny;
3094     aAny <<= nLines;
3095     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True );
3096 }
3097
3098 sal_Int16 UnoComboBoxControl::getDropDownLineCount() throw(uno::RuntimeException)
3099 {
3100     return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT );
3101 }
3102
3103
3104 //  ----------------------------------------------------
3105 //  UnoSpinFieldControl
3106 //  ----------------------------------------------------
3107 UnoSpinFieldControl::UnoSpinFieldControl( const Reference< XMultiServiceFactory >& i_factory )
3108     :UnoEditControl( i_factory )
3109     ,maSpinListeners( *this )
3110 {
3111     mbRepeat = sal_False;
3112 }
3113
3114 // uno::XInterface
3115 uno::Any UnoSpinFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3116 {
3117     uno::Any aRet = ::cppu::queryInterface( rType,
3118                                         (static_cast< awt::XSpinField* >(this)) );
3119     return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType ));
3120 }
3121
3122 // lang::XTypeProvider
3123 IMPL_XTYPEPROVIDER_START( UnoSpinFieldControl )
3124     getCppuType( ( uno::Reference< awt::XSpinField>* ) NULL ),
3125     UnoEditControl::getTypes()
3126 IMPL_XTYPEPROVIDER_END
3127
3128 void UnoSpinFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
3129 {
3130     UnoEditControl::createPeer( rxToolkit, rParentPeer );
3131
3132     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3133     xField->enableRepeat( mbRepeat );
3134     if ( maSpinListeners.getLength() )
3135         xField->addSpinListener( &maSpinListeners );
3136 }
3137
3138     // ::com::sun::star::awt::XSpinField
3139 void UnoSpinFieldControl::addSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException)
3140 {
3141     maSpinListeners.addInterface( l );
3142     if( getPeer().is() && maSpinListeners.getLength() == 1 )
3143     {
3144         uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3145         xField->addSpinListener( &maSpinListeners );
3146     }
3147 }
3148
3149 void UnoSpinFieldControl::removeSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException)
3150 {
3151     if( getPeer().is() && maSpinListeners.getLength() == 1 )
3152     {
3153         uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3154         xField->removeSpinListener( &maSpinListeners );
3155     }
3156     maSpinListeners.removeInterface( l );
3157 }
3158
3159 void UnoSpinFieldControl::up() throw(::com::sun::star::uno::RuntimeException)
3160 {
3161     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3162     if ( xField.is() )
3163         xField->up();
3164 }
3165
3166 void UnoSpinFieldControl::down() throw(::com::sun::star::uno::RuntimeException)
3167 {
3168     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3169     if ( xField.is() )
3170         xField->down();
3171 }
3172
3173 void UnoSpinFieldControl::first() throw(::com::sun::star::uno::RuntimeException)
3174 {
3175     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3176     if ( xField.is() )
3177         xField->first();
3178 }
3179
3180 void UnoSpinFieldControl::last() throw(::com::sun::star::uno::RuntimeException)
3181 {
3182     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3183     if ( xField.is() )
3184         xField->last();
3185 }
3186
3187 void UnoSpinFieldControl::enableRepeat( sal_Bool bRepeat ) throw(::com::sun::star::uno::RuntimeException)
3188 {
3189     mbRepeat = bRepeat;
3190
3191     uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3192     if ( xField.is() )
3193         xField->enableRepeat( bRepeat );
3194 }
3195
3196 //  ----------------------------------------------------
3197 //  class UnoControlDateFieldModel
3198 //  ----------------------------------------------------
3199 UnoControlDateFieldModel::UnoControlDateFieldModel( const Reference< XMultiServiceFactory >& i_factory )
3200     :UnoControlModel( i_factory )
3201 {
3202     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXDateField );
3203 }
3204
3205 ::rtl::OUString UnoControlDateFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3206 {
3207     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlDateFieldModel );
3208 }
3209
3210 uno::Any UnoControlDateFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3211 {
3212     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3213     {
3214         uno::Any aAny;
3215         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlDateField );
3216         return aAny;
3217     }
3218     return UnoControlModel::ImplGetDefaultValue( nPropId );
3219 }
3220
3221
3222 ::cppu::IPropertyArrayHelper& UnoControlDateFieldModel::getInfoHelper()
3223 {
3224     static UnoPropertyArrayHelper* pHelper = NULL;
3225     if ( !pHelper )
3226     {
3227         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
3228         pHelper = new UnoPropertyArrayHelper( aIDs );
3229     }
3230     return *pHelper;
3231 }
3232
3233 // beans::XMultiPropertySet
3234 uno::Reference< beans::XPropertySetInfo > UnoControlDateFieldModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
3235 {
3236     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3237     return xInfo;
3238 }
3239
3240
3241
3242 //  ----------------------------------------------------
3243 //  class UnoDateFieldControl
3244 //  ----------------------------------------------------
3245 UnoDateFieldControl::UnoDateFieldControl( const Reference< XMultiServiceFactory >& i_factory )
3246     :UnoSpinFieldControl( i_factory )
3247 {
3248     mnFirst = Date( 1, 1, 1900 ).GetDate();
3249     mnLast = Date( 31, 12, 2200 ).GetDate();
3250     mbLongFormat = 2;
3251 }
3252
3253 ::rtl::OUString UnoDateFieldControl::GetComponentServiceName()
3254 {
3255     return ::rtl::OUString("datefield");
3256 }
3257
3258 // uno::XInterface
3259 uno::Any UnoDateFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3260 {
3261     uno::Any aRet = ::cppu::queryInterface( rType,
3262                                         (static_cast< awt::XDateField* >(this)) );
3263     return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3264 }
3265
3266 // lang::XTypeProvider
3267 IMPL_XTYPEPROVIDER_START( UnoDateFieldControl )
3268     getCppuType( ( uno::Reference< awt::XDateField>* ) NULL ),
3269     UnoSpinFieldControl::getTypes()
3270 IMPL_XTYPEPROVIDER_END
3271
3272 void UnoDateFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
3273 {
3274     UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3275
3276     uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3277     xField->setFirst( mnFirst );
3278     xField->setLast( mnLast );
3279     if ( mbLongFormat != 2 )    // not set
3280         xField->setLongFormat( mbLongFormat );
3281 }
3282
3283
3284 void UnoDateFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3285 {
3286     uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY );
3287
3288     // also change the text property (#i25106#)
3289     if ( xPeer.is() )
3290     {
3291         ::rtl::OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT );
3292         ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False );
3293     }
3294
3295     // re-calc the Date property
3296     uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3297     uno::Any aValue;
3298     if ( xField->isEmpty() )
3299     {
3300         // the field says it's empty
3301         sal_Bool bEnforceFormat = sal_True;
3302         if ( xPeer.is() )
3303             xPeer->getProperty( GetPropertyName( BASEPROPERTY_ENFORCE_FORMAT ) ) >>= bEnforceFormat;
3304         if ( !bEnforceFormat )
3305         {
3306             // and it also says that it is currently accepting invalid inputs, without
3307             // forcing it to a valid date
3308             uno::Reference< awt::XTextComponent > xText( xPeer, uno::UNO_QUERY );
3309             if ( xText.is() && xText->getText().getLength() )
3310                 // and in real, the text of the peer is *not* empty
3311                 // -> simulate an invalid date, which is different from "no date"
3312                 aValue <<= util::Date( 0, 0, 0 );
3313         }
3314     }
3315     else
3316         aValue <<= xField->getDate();
3317
3318     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aValue, sal_False );
3319
3320     // multiplex the event
3321     if ( GetTextListeners().getLength() )
3322         GetTextListeners().textChanged( e );
3323 }
3324
3325 void UnoDateFieldControl::setDate( sal_Int32 Date ) throw(uno::RuntimeException)
3326 {
3327     uno::Any aAny;
3328     aAny <<= Date;
3329     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aAny, sal_True );
3330 }
3331
3332 sal_Int32 UnoDateFieldControl::getDate() throw(uno::RuntimeException)
3333 {
3334     return ImplGetPropertyValue_INT32( BASEPROPERTY_DATE );
3335 }
3336
3337 void UnoDateFieldControl::setMin( sal_Int32 Date ) throw(uno::RuntimeException)
3338 {
3339     uno::Any aAny;
3340     aAny <<= Date;
3341     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMIN ), aAny, sal_True );
3342 }
3343
3344 sal_Int32 UnoDateFieldControl::getMin() throw(uno::RuntimeException)
3345 {
3346     return ImplGetPropertyValue_INT32( BASEPROPERTY_DATEMIN );
3347 }
3348
3349 void UnoDateFieldControl::setMax( sal_Int32 Date ) throw(uno::RuntimeException)
3350 {
3351     uno::Any aAny;
3352     aAny <<= Date;
3353     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMAX ), aAny, sal_True );
3354 }
3355
3356 sal_Int32 UnoDateFieldControl::getMax() throw(uno::RuntimeException)
3357 {
3358     return ImplGetPropertyValue_INT32( BASEPROPERTY_DATEMAX );
3359 }
3360
3361 void UnoDateFieldControl::setFirst( sal_Int32 Date ) throw(uno::RuntimeException)
3362 {
3363     mnFirst = Date;
3364     if ( getPeer().is() )
3365     {
3366         uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3367         xField->setFirst( Date );
3368     }
3369 }
3370
3371 sal_Int32 UnoDateFieldControl::getFirst() throw(uno::RuntimeException)
3372 {
3373     return mnFirst;
3374 }
3375
3376 void UnoDateFieldControl::setLast( sal_Int32 Date ) throw(uno::RuntimeException)
3377 {
3378     mnLast = Date;
3379     if ( getPeer().is() )
3380     {
3381         uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3382         xField->setLast( Date );
3383     }
3384 }
3385
3386 sal_Int32 UnoDateFieldControl::getLast() throw(uno::RuntimeException)
3387 {
3388     return mnLast;
3389 }
3390
3391 void UnoDateFieldControl::setLongFormat( sal_Bool bLong ) throw(uno::RuntimeException)
3392 {
3393     mbLongFormat = bLong;
3394     if ( getPeer().is() )
3395     {
3396         uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3397         xField->setLongFormat( bLong );
3398     }
3399 }
3400
3401 sal_Bool UnoDateFieldControl::isLongFormat() throw(uno::RuntimeException)
3402 {
3403     return ( mbLongFormat != 2 ) ? mbLongFormat : sal_False;
3404 }
3405
3406 void UnoDateFieldControl::setEmpty() throw(uno::RuntimeException)
3407 {
3408     if ( getPeer().is() )
3409     {
3410         uno::Reference < awt::XDateField >  xField( getPeer(), uno::UNO_QUERY );
3411         xField->setEmpty();
3412     }
3413 }
3414
3415 sal_Bool UnoDateFieldControl::isEmpty() throw(uno::RuntimeException)
3416 {
3417     sal_Bool bEmpty = sal_False;
3418     if ( getPeer().is() )
3419     {
3420         uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3421         bEmpty = xField->isEmpty();
3422     }
3423     return bEmpty;
3424 }
3425
3426 void UnoDateFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3427 {
3428     uno::Any aAny;
3429     aAny <<= bStrict;
3430     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3431 }
3432
3433 sal_Bool UnoDateFieldControl::isStrictFormat() throw(uno::RuntimeException)
3434 {
3435     return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3436 }
3437
3438 //  ----------------------------------------------------
3439 //  class UnoControlTimeFieldModel
3440 //  ----------------------------------------------------
3441 UnoControlTimeFieldModel::UnoControlTimeFieldModel( const Reference< XMultiServiceFactory >& i_factory )
3442     :UnoControlModel( i_factory )
3443 {
3444     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXTimeField );
3445 }
3446
3447 ::rtl::OUString UnoControlTimeFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3448 {
3449     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlTimeFieldModel );
3450 }
3451
3452 uno::Any UnoControlTimeFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3453 {
3454     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3455     {
3456         uno::Any aAny;
3457         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlTimeField );
3458         return aAny;
3459     }
3460     return UnoControlModel::ImplGetDefaultValue( nPropId );
3461 }
3462
3463
3464 ::cppu::IPropertyArrayHelper& UnoControlTimeFieldModel::getInfoHelper()
3465 {
3466     static UnoPropertyArrayHelper* pHelper = NULL;
3467     if ( !pHelper )
3468     {
3469         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
3470         pHelper = new UnoPropertyArrayHelper( aIDs );
3471     }
3472     return *pHelper;
3473 }
3474
3475 // beans::XMultiPropertySet
3476 uno::Reference< beans::XPropertySetInfo > UnoControlTimeFieldModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
3477 {
3478     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3479     return xInfo;
3480 }
3481
3482
3483
3484 //  ----------------------------------------------------
3485 //  class UnoTimeFieldControl
3486 //  ----------------------------------------------------
3487 UnoTimeFieldControl::UnoTimeFieldControl( const Reference< XMultiServiceFactory >& i_factory )
3488     :UnoSpinFieldControl( i_factory )
3489 {
3490     mnFirst = Time( 0, 0 ).GetTime();
3491     mnLast = Time( 23, 59, 59, 99 ).GetTime();
3492 }
3493
3494 ::rtl::OUString UnoTimeFieldControl::GetComponentServiceName()
3495 {
3496     return ::rtl::OUString("timefield");
3497 }
3498
3499 // uno::XInterface
3500 uno::Any UnoTimeFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3501 {
3502     uno::Any aRet = ::cppu::queryInterface( rType,
3503                                         (static_cast< awt::XTimeField* >(this)) );
3504     return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3505 }
3506
3507 // lang::XTypeProvider
3508 IMPL_XTYPEPROVIDER_START( UnoTimeFieldControl )
3509     getCppuType( ( uno::Reference< awt::XTimeField>* ) NULL ),
3510     UnoSpinFieldControl::getTypes()
3511 IMPL_XTYPEPROVIDER_END
3512
3513 void UnoTimeFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
3514 {
3515     UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3516
3517     uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3518     xField->setFirst( mnFirst );
3519     xField->setLast( mnLast );
3520 }
3521
3522 void UnoTimeFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3523 {
3524     // also change the text property (#i25106#)
3525     uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY );
3526     ::rtl::OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT );
3527     ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False );
3528
3529     // re-calc the Time property
3530     uno::Reference < awt::XTimeField >  xField( getPeer(), uno::UNO_QUERY );
3531     uno::Any aValue;
3532     if ( !xField->isEmpty() )
3533         aValue <<= xField->getTime();
3534     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aValue, sal_False );
3535
3536     // multiplex the event
3537     if ( GetTextListeners().getLength() )
3538         GetTextListeners().textChanged( e );
3539 }
3540
3541 void UnoTimeFieldControl::setTime( sal_Int32 Time ) throw(uno::RuntimeException)
3542 {
3543     uno::Any aAny;
3544     aAny <<= Time;
3545     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aAny, sal_True );
3546 }
3547
3548 sal_Int32 UnoTimeFieldControl::getTime() throw(uno::RuntimeException)
3549 {
3550     return ImplGetPropertyValue_INT32( BASEPROPERTY_TIME );
3551 }
3552
3553 void UnoTimeFieldControl::setMin( sal_Int32 Time ) throw(uno::RuntimeException)
3554 {
3555     uno::Any aAny;
3556     aAny <<= Time;
3557     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMIN ), aAny, sal_True );
3558 }
3559
3560 sal_Int32 UnoTimeFieldControl::getMin() throw(uno::RuntimeException)
3561 {
3562     return ImplGetPropertyValue_INT32( BASEPROPERTY_TIMEMIN );
3563 }
3564
3565 void UnoTimeFieldControl::setMax( sal_Int32 Time ) throw(uno::RuntimeException)
3566 {
3567     uno::Any aAny;
3568     aAny <<= Time;
3569     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMAX ), aAny, sal_True );
3570 }
3571
3572 sal_Int32 UnoTimeFieldControl::getMax() throw(uno::RuntimeException)
3573 {
3574     return ImplGetPropertyValue_INT32( BASEPROPERTY_TIMEMAX );
3575 }
3576
3577 void UnoTimeFieldControl::setFirst( sal_Int32 Time ) throw(uno::RuntimeException)
3578 {
3579     mnFirst = Time;
3580     if ( getPeer().is() )
3581     {
3582         uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3583         xField->setFirst( mnFirst );
3584     }
3585 }
3586
3587 sal_Int32 UnoTimeFieldControl::getFirst() throw(uno::RuntimeException)
3588 {
3589     return mnFirst;
3590 }
3591
3592 void UnoTimeFieldControl::setLast( sal_Int32 Time ) throw(uno::RuntimeException)
3593 {
3594     mnLast = Time;
3595     if ( getPeer().is() )
3596     {
3597         uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3598         xField->setFirst( mnLast );
3599     }
3600 }
3601
3602 sal_Int32 UnoTimeFieldControl::getLast() throw(uno::RuntimeException)
3603 {
3604     return mnLast;
3605 }
3606
3607 void UnoTimeFieldControl::setEmpty() throw(uno::RuntimeException)
3608 {
3609     if ( getPeer().is() )
3610     {
3611         uno::Reference < awt::XTimeField >  xField( getPeer(), uno::UNO_QUERY );
3612         xField->setEmpty();
3613     }
3614 }
3615
3616 sal_Bool UnoTimeFieldControl::isEmpty() throw(uno::RuntimeException)
3617 {
3618     sal_Bool bEmpty = sal_False;
3619     if ( getPeer().is() )
3620     {
3621         uno::Reference < awt::XTimeField >  xField( getPeer(), uno::UNO_QUERY );
3622         bEmpty = xField->isEmpty();
3623     }
3624     return bEmpty;
3625 }
3626
3627 void UnoTimeFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3628 {
3629     uno::Any aAny;
3630     aAny <<= bStrict;
3631     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3632 }
3633
3634 sal_Bool UnoTimeFieldControl::isStrictFormat() throw(uno::RuntimeException)
3635 {
3636     return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3637 }
3638
3639 //  ----------------------------------------------------
3640 //  class UnoControlNumericFieldModel
3641 //  ----------------------------------------------------
3642 UnoControlNumericFieldModel::UnoControlNumericFieldModel( const Reference< XMultiServiceFactory >& i_factory )
3643     :UnoControlModel( i_factory )
3644 {
3645     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXNumericField );
3646 }
3647
3648 ::rtl::OUString UnoControlNumericFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3649 {
3650     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlNumericFieldModel );
3651 }
3652
3653 uno::Any UnoControlNumericFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3654 {
3655     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3656     {
3657         uno::Any aAny;
3658         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlNumericField );
3659         return aAny;
3660     }
3661     return UnoControlModel::ImplGetDefaultValue( nPropId );
3662 }
3663
3664
3665 ::cppu::IPropertyArrayHelper& UnoControlNumericFieldModel::getInfoHelper()
3666 {
3667     static UnoPropertyArrayHelper* pHelper = NULL;
3668     if ( !pHelper )
3669     {
3670         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
3671         pHelper = new UnoPropertyArrayHelper( aIDs );
3672     }
3673     return *pHelper;
3674 }
3675
3676 // beans::XMultiPropertySet
3677 uno::Reference< beans::XPropertySetInfo > UnoControlNumericFieldModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
3678 {
3679     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3680     return xInfo;
3681 }
3682
3683
3684
3685 //  ----------------------------------------------------
3686 //  class UnoNumericFieldControl
3687 //  ----------------------------------------------------
3688 UnoNumericFieldControl::UnoNumericFieldControl( const Reference< XMultiServiceFactory >& i_factory )
3689     :UnoSpinFieldControl( i_factory )
3690 {
3691     mnFirst = 0;
3692     mnLast = 0x7FFFFFFF;
3693 }
3694
3695 ::rtl::OUString UnoNumericFieldControl::GetComponentServiceName()
3696 {
3697     return ::rtl::OUString("numericfield");
3698 }
3699
3700 // uno::XInterface
3701 uno::Any UnoNumericFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3702 {
3703     uno::Any aRet = ::cppu::queryInterface( rType,
3704                                         (static_cast< awt::XNumericField* >(this)) );
3705     return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3706 }
3707
3708 // lang::XTypeProvider
3709 IMPL_XTYPEPROVIDER_START( UnoNumericFieldControl )
3710     getCppuType( ( uno::Reference< awt::XNumericField>* ) NULL ),
3711     UnoSpinFieldControl::getTypes()
3712 IMPL_XTYPEPROVIDER_END
3713
3714 void UnoNumericFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
3715 {
3716     UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3717
3718     uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3719     xField->setFirst( mnFirst );
3720     xField->setLast( mnLast );
3721 }
3722
3723
3724 void UnoNumericFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3725 {
3726     uno::Reference < awt::XNumericField >  xField( getPeer(), uno::UNO_QUERY );
3727     uno::Any aAny;
3728     aAny <<= xField->getValue();
3729     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False );
3730
3731     if ( GetTextListeners().getLength() )
3732         GetTextListeners().textChanged( e );
3733 }
3734
3735 void UnoNumericFieldControl::setValue( double Value ) throw(uno::RuntimeException)
3736 {
3737     uno::Any aAny;
3738     aAny <<= Value;
3739     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True );
3740 }
3741
3742 double UnoNumericFieldControl::getValue() throw(uno::RuntimeException)
3743 {
3744     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE );
3745 }
3746
3747 void UnoNumericFieldControl::setMin( double Value ) throw(uno::RuntimeException)
3748 {
3749     uno::Any aAny;
3750     aAny <<= Value;
3751     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True );
3752 }
3753
3754 double UnoNumericFieldControl::getMin() throw(uno::RuntimeException)
3755 {
3756     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE );
3757 }
3758
3759 void UnoNumericFieldControl::setMax( double Value ) throw(uno::RuntimeException)
3760 {
3761     uno::Any aAny;
3762     aAny <<= Value;
3763     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True );
3764 }
3765
3766 double UnoNumericFieldControl::getMax() throw(uno::RuntimeException)
3767 {
3768     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE );
3769 }
3770
3771 void UnoNumericFieldControl::setFirst( double Value ) throw(uno::RuntimeException)
3772 {
3773     mnFirst = Value;
3774     if ( getPeer().is() )
3775     {
3776         uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3777         xField->setFirst( mnFirst );
3778     }
3779 }
3780
3781 double UnoNumericFieldControl::getFirst() throw(uno::RuntimeException)
3782 {
3783     return mnFirst;
3784 }
3785
3786 void UnoNumericFieldControl::setLast( double Value ) throw(uno::RuntimeException)
3787 {
3788     mnLast = Value;
3789     if ( getPeer().is() )
3790     {
3791         uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3792         xField->setLast( mnLast );
3793     }
3794 }
3795
3796 double UnoNumericFieldControl::getLast() throw(uno::RuntimeException)
3797 {
3798     return mnLast;
3799 }
3800
3801 void UnoNumericFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3802 {
3803     uno::Any aAny;
3804     aAny <<= bStrict;
3805     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3806 }
3807
3808 sal_Bool UnoNumericFieldControl::isStrictFormat() throw(uno::RuntimeException)
3809 {
3810     return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3811 }
3812
3813 void UnoNumericFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException)
3814 {
3815     uno::Any aAny;
3816     aAny <<= Digits;
3817     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True );
3818 }
3819
3820 double UnoNumericFieldControl::getSpinSize() throw(uno::RuntimeException)
3821 {
3822     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE );
3823 }
3824
3825 void UnoNumericFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException)
3826 {
3827     uno::Any aAny;
3828     aAny <<= Digits;
3829     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True );
3830 }
3831
3832 sal_Int16 UnoNumericFieldControl::getDecimalDigits() throw(uno::RuntimeException)
3833 {
3834     return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY );
3835 }
3836
3837 //  ----------------------------------------------------
3838 //  class UnoControlCurrencyFieldModel
3839 //  ----------------------------------------------------
3840 UnoControlCurrencyFieldModel::UnoControlCurrencyFieldModel( const Reference< XMultiServiceFactory >& i_factory )
3841     :UnoControlModel( i_factory )
3842 {
3843     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCurrencyField );
3844 }
3845
3846 ::rtl::OUString UnoControlCurrencyFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3847 {
3848     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlCurrencyFieldModel );
3849 }
3850
3851 uno::Any UnoControlCurrencyFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3852 {
3853     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3854     {
3855         uno::Any aAny;
3856         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlCurrencyField );
3857         return aAny;
3858     }
3859     if ( nPropId == BASEPROPERTY_CURSYM_POSITION )
3860     {
3861         uno::Any aAny;
3862         aAny <<= (sal_Bool)sal_False;
3863         return aAny;
3864     }
3865
3866     return UnoControlModel::ImplGetDefaultValue( nPropId );
3867 }
3868
3869 ::cppu::IPropertyArrayHelper& UnoControlCurrencyFieldModel::getInfoHelper()
3870 {
3871     static UnoPropertyArrayHelper* pHelper = NULL;
3872     if ( !pHelper )
3873     {
3874         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
3875         pHelper = new UnoPropertyArrayHelper( aIDs );
3876     }
3877     return *pHelper;
3878 }
3879
3880 // beans::XMultiPropertySet
3881 uno::Reference< beans::XPropertySetInfo > UnoControlCurrencyFieldModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
3882 {
3883     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3884     return xInfo;
3885 }
3886
3887 //  ----------------------------------------------------
3888 //  class UnoCurrencyFieldControl
3889 //  ----------------------------------------------------
3890 UnoCurrencyFieldControl::UnoCurrencyFieldControl( const Reference< XMultiServiceFactory >& i_factory )
3891     :UnoSpinFieldControl( i_factory )
3892 {
3893     mnFirst = 0;
3894     mnLast = 0x7FFFFFFF;
3895 }
3896
3897 ::rtl::OUString UnoCurrencyFieldControl::GetComponentServiceName()
3898 {
3899     return ::rtl::OUString("longcurrencyfield");
3900 }
3901
3902 // uno::XInterface
3903 uno::Any UnoCurrencyFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3904 {
3905     uno::Any aRet = ::cppu::queryInterface( rType,
3906                                         (static_cast< awt::XCurrencyField* >(this)) );
3907     return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3908 }
3909
3910 // lang::XTypeProvider
3911 IMPL_XTYPEPROVIDER_START( UnoCurrencyFieldControl )
3912     getCppuType( ( uno::Reference< awt::XCurrencyField>* ) NULL ),
3913     UnoSpinFieldControl::getTypes()
3914 IMPL_XTYPEPROVIDER_END
3915
3916 void UnoCurrencyFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer >  & rParentPeer ) throw(uno::RuntimeException)
3917 {
3918     UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3919
3920     uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3921     xField->setFirst( mnFirst );
3922     xField->setLast( mnLast );
3923 }
3924
3925 void UnoCurrencyFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3926 {
3927     uno::Reference < awt::XCurrencyField >  xField( getPeer(), uno::UNO_QUERY );
3928     uno::Any aAny;
3929     aAny <<= xField->getValue();
3930     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False );
3931
3932     if ( GetTextListeners().getLength() )
3933         GetTextListeners().textChanged( e );
3934 }
3935
3936 void UnoCurrencyFieldControl::setValue( double Value ) throw(uno::RuntimeException)
3937 {
3938     uno::Any aAny;
3939     aAny <<= Value;
3940     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True );
3941 }
3942
3943 double UnoCurrencyFieldControl::getValue() throw(uno::RuntimeException)
3944 {
3945     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE );
3946 }
3947
3948 void UnoCurrencyFieldControl::setMin( double Value ) throw(uno::RuntimeException)
3949 {
3950     uno::Any aAny;
3951     aAny <<= Value;
3952     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True );
3953 }
3954
3955 double UnoCurrencyFieldControl::getMin() throw(uno::RuntimeException)
3956 {
3957     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE );
3958 }
3959
3960 void UnoCurrencyFieldControl::setMax( double Value ) throw(uno::RuntimeException)
3961 {
3962     uno::Any aAny;
3963     aAny <<= Value;
3964     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True );
3965 }
3966
3967 double UnoCurrencyFieldControl::getMax() throw(uno::RuntimeException)
3968 {
3969     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE );
3970 }
3971
3972 void UnoCurrencyFieldControl::setFirst( double Value ) throw(uno::RuntimeException)
3973 {
3974     mnFirst = Value;
3975     if ( getPeer().is() )
3976     {
3977         uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3978         xField->setFirst( mnFirst );
3979     }
3980 }
3981
3982 double UnoCurrencyFieldControl::getFirst() throw(uno::RuntimeException)
3983 {
3984     return mnFirst;
3985 }
3986
3987 void UnoCurrencyFieldControl::setLast( double Value ) throw(uno::RuntimeException)
3988 {
3989     mnLast = Value;
3990     if ( getPeer().is() )
3991     {
3992         uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3993         xField->setLast( mnLast );
3994     }
3995 }
3996
3997 double UnoCurrencyFieldControl::getLast() throw(uno::RuntimeException)
3998 {
3999     return mnLast;
4000 }
4001
4002 void UnoCurrencyFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
4003 {
4004     uno::Any aAny;
4005     aAny <<= bStrict;
4006     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
4007 }
4008
4009 sal_Bool UnoCurrencyFieldControl::isStrictFormat() throw(uno::RuntimeException)
4010 {
4011     return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
4012 }
4013
4014 void UnoCurrencyFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException)
4015 {
4016     uno::Any aAny;
4017     aAny <<= Digits;
4018     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True );
4019 }
4020
4021 double UnoCurrencyFieldControl::getSpinSize() throw(uno::RuntimeException)
4022 {
4023     return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE );
4024 }
4025
4026 void UnoCurrencyFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException)
4027 {
4028     uno::Any aAny;
4029     aAny <<= Digits;
4030     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True );
4031 }
4032
4033 sal_Int16 UnoCurrencyFieldControl::getDecimalDigits() throw(uno::RuntimeException)
4034 {
4035     return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY );
4036 }
4037
4038 //  ----------------------------------------------------
4039 //  class UnoControlPatternFieldModel
4040 //  ----------------------------------------------------
4041 UnoControlPatternFieldModel::UnoControlPatternFieldModel( const Reference< XMultiServiceFactory >& i_factory )
4042     :UnoControlModel( i_factory )
4043 {
4044     UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXPatternField );
4045 }
4046
4047 ::rtl::OUString UnoControlPatternFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
4048 {
4049     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlPatternFieldModel );
4050 }
4051
4052 uno::Any UnoControlPatternFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4053 {
4054     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4055     {
4056         uno::Any aAny;
4057         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlPatternField );
4058         return aAny;
4059     }
4060     return UnoControlModel::ImplGetDefaultValue( nPropId );
4061 }
4062
4063 ::cppu::IPropertyArrayHelper& UnoControlPatternFieldModel::getInfoHelper()
4064 {
4065     static UnoPropertyArrayHelper* pHelper = NULL;
4066     if ( !pHelper )
4067     {
4068         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
4069         pHelper = new UnoPropertyArrayHelper( aIDs );
4070     }
4071     return *pHelper;
4072 }
4073
4074 // beans::XMultiPropertySet
4075 uno::Reference< beans::XPropertySetInfo > UnoControlPatternFieldModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
4076 {
4077     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4078     return xInfo;
4079 }
4080
4081
4082 //  ----------------------------------------------------
4083 //  class UnoPatternFieldControl
4084 //  ----------------------------------------------------
4085 UnoPatternFieldControl::UnoPatternFieldControl( const Reference< XMultiServiceFactory >& i_factory )
4086     :UnoSpinFieldControl( i_factory )
4087 {
4088 }
4089
4090 ::rtl::OUString UnoPatternFieldControl::GetComponentServiceName()
4091 {
4092     return ::rtl::OUString("patternfield");
4093 }
4094
4095 void UnoPatternFieldControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal )
4096 {
4097     sal_uInt16 nType = GetPropertyId( rPropName );
4098     if ( ( nType == BASEPROPERTY_TEXT ) || ( nType == BASEPROPERTY_EDITMASK ) || ( nType == BASEPROPERTY_LITERALMASK ) )
4099     {
4100         // These masks cannot be set consecutively
4101         ::rtl::OUString Text = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT );
4102         ::rtl::OUString EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK );
4103         ::rtl::OUString LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK );
4104
4105         uno::Reference < awt::XPatternField >  xPF( getPeer(), uno::UNO_QUERY );
4106         if (xPF.is())
4107         {
4108             // same comment as in UnoControl::ImplSetPeerProperty - see there
4109             ::rtl::OUString sText( Text );
4110             ImplCheckLocalize( sText );
4111             xPF->setString( sText );
4112             xPF->setMasks( EditMask, LiteralMask );
4113         }
4114     }
4115     else
4116         UnoSpinFieldControl::ImplSetPeerProperty( rPropName, rVal );
4117 }
4118
4119
4120 // uno::XInterface
4121 uno::Any UnoPatternFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
4122 {
4123     uno::Any aRet = ::cppu::queryInterface( rType,
4124                                         (static_cast< awt::XPatternField* >(this)) );
4125     return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
4126 }
4127
4128 // lang::XTypeProvider
4129 IMPL_XTYPEPROVIDER_START( UnoPatternFieldControl )
4130     getCppuType( ( uno::Reference< awt::XPatternField>* ) NULL ),
4131     UnoSpinFieldControl::getTypes()
4132 IMPL_XTYPEPROVIDER_END
4133
4134 void UnoPatternFieldControl::setString( const ::rtl::OUString& rString ) throw(uno::RuntimeException)
4135 {
4136     setText( rString );
4137 }
4138
4139 ::rtl::OUString UnoPatternFieldControl::getString() throw(uno::RuntimeException)
4140 {
4141     return getText();
4142 }
4143
4144 void UnoPatternFieldControl::setMasks( const ::rtl::OUString& EditMask, const ::rtl::OUString& LiteralMask ) throw(uno::RuntimeException)
4145 {
4146     uno::Any aAny;
4147     aAny <<= EditMask;
4148     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_EDITMASK ), aAny, sal_True );
4149     aAny <<= LiteralMask;
4150     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LITERALMASK ), aAny, sal_True );
4151 }
4152
4153 void UnoPatternFieldControl::getMasks( ::rtl::OUString& EditMask, ::rtl::OUString& LiteralMask ) throw(uno::RuntimeException)
4154 {
4155     EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK );
4156     LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK );
4157 }
4158
4159 void UnoPatternFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
4160 {
4161     uno::Any aAny;
4162     aAny <<= bStrict;
4163     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
4164 }
4165
4166 sal_Bool UnoPatternFieldControl::isStrictFormat() throw(uno::RuntimeException)
4167 {
4168     return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
4169 }
4170
4171
4172 //  ----------------------------------------------------
4173 //  class UnoControlProgressBarModel
4174 //  ----------------------------------------------------
4175 UnoControlProgressBarModel::UnoControlProgressBarModel( const Reference< XMultiServiceFactory >& i_factory )
4176     :UnoControlModel( i_factory )
4177 {
4178     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
4179     ImplRegisterProperty( BASEPROPERTY_BORDER );
4180     ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR );
4181     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
4182     ImplRegisterProperty( BASEPROPERTY_ENABLED );
4183     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
4184     ImplRegisterProperty( BASEPROPERTY_FILLCOLOR );
4185     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
4186     ImplRegisterProperty( BASEPROPERTY_HELPURL );
4187     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
4188     ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE );
4189     ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MAX );
4190     ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MIN );
4191 }
4192
4193 ::rtl::OUString UnoControlProgressBarModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
4194 {
4195     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlProgressBarModel );
4196 }
4197
4198 uno::Any UnoControlProgressBarModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4199 {
4200     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4201     {
4202         uno::Any aAny;
4203         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlProgressBar );
4204         return aAny;
4205     }
4206
4207     return UnoControlModel::ImplGetDefaultValue( nPropId );
4208 }
4209
4210 ::cppu::IPropertyArrayHelper& UnoControlProgressBarModel::getInfoHelper()
4211 {
4212     static UnoPropertyArrayHelper* pHelper = NULL;
4213     if ( !pHelper )
4214     {
4215         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
4216         pHelper = new UnoPropertyArrayHelper( aIDs );
4217     }
4218     return *pHelper;
4219 }
4220
4221 // beans::XMultiPropertySet
4222 uno::Reference< beans::XPropertySetInfo > UnoControlProgressBarModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
4223 {
4224     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4225     return xInfo;
4226 }
4227
4228
4229 //  ----------------------------------------------------
4230 //  class UnoProgressBarControl
4231 //  ----------------------------------------------------
4232 UnoProgressBarControl::UnoProgressBarControl( const Reference< XMultiServiceFactory >& i_factory )
4233     :UnoControlBase( i_factory )
4234 {
4235 }
4236
4237 ::rtl::OUString UnoProgressBarControl::GetComponentServiceName()
4238 {
4239     return ::rtl::OUString("ProgressBar");
4240 }
4241
4242 // uno::XInterface
4243 uno::Any UnoProgressBarControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
4244 {
4245     uno::Any aRet = ::cppu::queryInterface( rType,
4246                                         (static_cast< awt::XProgressBar* >(this)) );
4247     return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
4248 }
4249
4250 // lang::XTypeProvider
4251 IMPL_XTYPEPROVIDER_START( UnoProgressBarControl )
4252     getCppuType( ( uno::Reference< awt::XProgressBar>* ) NULL ),
4253     UnoControlBase::getTypes()
4254 IMPL_XTYPEPROVIDER_END
4255
4256 // ::com::sun::star::awt::XProgressBar
4257 void UnoProgressBarControl::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
4258 {
4259     uno::Any aAny;
4260     aAny <<= nColor;
4261     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_FILLCOLOR ), aAny, sal_True );
4262 }
4263
4264 void UnoProgressBarControl::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
4265 {
4266     uno::Any aAny;
4267     aAny <<= nColor;
4268     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_BACKGROUNDCOLOR ), aAny, sal_True );
4269 }
4270
4271 void UnoProgressBarControl::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException)
4272 {
4273     uno::Any aAny;
4274     aAny <<= nValue;
4275     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE ), aAny, sal_True );
4276 }
4277
4278 void UnoProgressBarControl::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException )
4279 {
4280     uno::Any aMin;
4281     uno::Any aMax;
4282
4283     if ( nMin < nMax )
4284     {
4285         // take correct min and max
4286         aMin <<= nMin;
4287         aMax <<= nMax;
4288     }
4289     else
4290     {
4291         // change min and max
4292         aMin <<= nMax;
4293         aMax <<= nMin;
4294     }
4295
4296     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MIN ), aMin, sal_True );
4297     ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MAX ), aMax, sal_True );
4298 }
4299
4300 sal_Int32 UnoProgressBarControl::getValue() throw(::com::sun::star::uno::RuntimeException)
4301 {
4302     return ImplGetPropertyValue_INT32( BASEPROPERTY_PROGRESSVALUE );
4303 }
4304
4305
4306 //  ----------------------------------------------------
4307 //  class UnoControlFixedLineModel
4308 //  ----------------------------------------------------
4309 UnoControlFixedLineModel::UnoControlFixedLineModel( const Reference< XMultiServiceFactory >& i_factory )
4310     :UnoControlModel( i_factory )
4311 {
4312     ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
4313     ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
4314     ImplRegisterProperty( BASEPROPERTY_ENABLED );
4315     ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
4316     ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
4317     ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
4318     ImplRegisterProperty( BASEPROPERTY_HELPURL );
4319     ImplRegisterProperty( BASEPROPERTY_LABEL );
4320     ImplRegisterProperty( BASEPROPERTY_ORIENTATION );
4321     ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
4322 }
4323
4324 ::rtl::OUString UnoControlFixedLineModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
4325 {
4326     return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedLineModel );
4327 }
4328
4329 uno::Any UnoControlFixedLineModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4330 {
4331     if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4332     {
4333         uno::Any aAny;
4334         aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedLine );
4335         return aAny;
4336     }
4337     return UnoControlModel::ImplGetDefaultValue( nPropId );
4338 }
4339
4340 ::cppu::IPropertyArrayHelper& UnoControlFixedLineModel::getInfoHelper()
4341 {
4342     static UnoPropertyArrayHelper* pHelper = NULL;
4343     if ( !pHelper )
4344     {
4345         uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
4346         pHelper = new UnoPropertyArrayHelper( aIDs );
4347     }
4348     return *pHelper;
4349 }
4350
4351 // beans::XMultiPropertySet
4352 uno::Reference< beans::XPropertySetInfo > UnoControlFixedLineModel::getPropertySetInfo(  ) throw(uno::RuntimeException)
4353 {
4354     static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4355     return xInfo;
4356 }
4357
4358 //  ----------------------------------------------------
4359 //  class UnoFixedLineControl
4360 //  ----------------------------------------------------
4361 UnoFixedLineControl::UnoFixedLineControl( const Reference< XMultiServiceFactory >& i_factory )
4362     :UnoControlBase( i_factory )
4363 {
4364     maComponentInfos.nWidth = 100;      // ??
4365     maComponentInfos.nHeight = 100;     // ??
4366 }
4367
4368 ::rtl::OUString UnoFixedLineControl::GetComponentServiceName()
4369 {
4370     return ::rtl::OUString("FixedLine");
4371 }
4372
4373 sal_Bool UnoFixedLineControl::isTransparent() throw(uno::RuntimeException)
4374 {
4375     return sal_True;
4376 }
4377
4378 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */