toolkit/source/awt/vclxwindows.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: vclxwindows.cxx,v $
  10  * $Revision: 1.69.4.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_toolkit.hxx"
  33 #include <toolkit/awt/vclxwindows.hxx>
  34 #include <com/sun/star/awt/ScrollBarOrientation.hpp>
  35 #include <com/sun/star/graphic/XGraphic.hpp>
  36 #include <toolkit/helper/vclunohelper.hxx>
  37 #include <toolkit/helper/macros.hxx>
  38 #include <toolkit/helper/property.hxx>
  39 #include <toolkit/helper/convert.hxx>
  40 #include <toolkit/helper/imagealign.hxx>
  41 #include <toolkit/helper/accessibilityclient.hxx>
  42 #include <toolkit/helper/fixedhyperbase.hxx>
  43 #include <cppuhelper/typeprovider.hxx>
  44 #include <com/sun/star/awt/VisualEffect.hpp>
  45 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  46 #include <com/sun/star/system/XSystemShellExecute.hpp>
  47 #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
  48 #include <com/sun/star/awt/ImageScaleMode.hpp>
  49 #include <comphelper/processfactory.hxx>
  50
  51 #ifndef _SV_BUTTON_HXX
  52 #include <vcl/button.hxx>
  53 #endif
  54 #include <vcl/lstbox.hxx>
  55 #include <vcl/combobox.hxx>
  56 #include <vcl/field.hxx>
  57 #include <vcl/longcurr.hxx>
  58 #include <vcl/imgctrl.hxx>
  59 #include <vcl/dialog.hxx>
  60 #include <vcl/msgbox.hxx>
  61 #include <vcl/scrbar.hxx>
  62 #include <vcl/svapp.hxx>
  63 #include <vcl/tabpage.hxx>
  64 #include <tools/debug.hxx>
  65
  66 using ::com::sun::star::uno::Any;
  67 using ::com::sun::star::uno::Reference;
  68 using ::com::sun::star::uno::makeAny;
  69 using ::com::sun::star::graphic::XGraphic;
  70
  71 using namespace ::com::sun::star;
  72 using namespace ::com::sun::star::awt::VisualEffect;
  73 namespace ImageScaleMode = ::com::sun::star::awt::ImageScaleMode;
  74
  75 static double ImplCalcLongValue( double nValue, sal_uInt16 nDigits )
  76 {
  77     double n = nValue;
  78     for ( sal_uInt16 d = 0; d < nDigits; d++ )
  79         n *= 10;
  80     return n;
  81 }
  82
  83 static double ImplCalcDoubleValue( double nValue, sal_uInt16 nDigits )
  84 {
  85     double n = nValue;
  86     for ( sal_uInt16 d = 0; d < nDigits; d++ )
  87         n /= 10;
  88     return n;
  89 }
  90
  91 namespace toolkit
  92 {
  93     /** sets the "face color" for button like controls (scroll bar, spin button)
  94     */
  95     void setButtonLikeFaceColor( Window* _pWindow, const ::com::sun::star::uno::Any& _rColorValue )
  96     {
  97         AllSettings aSettings = _pWindow->GetSettings();
  98         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
  99
 100         if ( !_rColorValue.hasValue() )
 101         {
 102             const StyleSettings& aAppStyle = Application::GetSettings().GetStyleSettings();
 103             aStyleSettings.SetFaceColor( aAppStyle.GetFaceColor( ) );
 104             aStyleSettings.SetCheckedColor( aAppStyle.GetCheckedColor( ) );
 105             aStyleSettings.SetLightBorderColor( aAppStyle.GetLightBorderColor() );
 106             aStyleSettings.SetLightColor( aAppStyle.GetLightColor() );
 107             aStyleSettings.SetShadowColor( aAppStyle.GetShadowColor() );
 108             aStyleSettings.SetDarkShadowColor( aAppStyle.GetDarkShadowColor() );
 109         }
 110         else
 111         {
 112             sal_Int32 nBackgroundColor = 0;
 113             _rColorValue >>= nBackgroundColor;
 114             aStyleSettings.SetFaceColor( nBackgroundColor );
 115
 116             // for the real background (everything except the buttons and the thumb),
 117             // use an average between the desired color and "white"
 118             Color aWhite( COL_WHITE );
 119             Color aBackground( nBackgroundColor );
 120             aBackground.SetRed( ( aBackground.GetRed() + aWhite.GetRed() ) / 2 );
 121             aBackground.SetGreen( ( aBackground.GetGreen() + aWhite.GetGreen() ) / 2 );
 122             aBackground.SetBlue( ( aBackground.GetBlue() + aWhite.GetBlue() ) / 2 );
 123             aStyleSettings.SetCheckedColor( aBackground );
 124
 125             sal_Int32 nBackgroundLuminance = Color( nBackgroundColor ).GetLuminance();
 126             sal_Int32 nWhiteLuminance = Color( COL_WHITE ).GetLuminance();
 127
 128             Color aLightShadow( nBackgroundColor );
 129             aLightShadow.IncreaseLuminance( (UINT8)( ( nWhiteLuminance - nBackgroundLuminance ) * 2 / 3 ) );
 130             aStyleSettings.SetLightBorderColor( aLightShadow );
 131
 132             Color aLight( nBackgroundColor );
 133             aLight.IncreaseLuminance( (UINT8)( ( nWhiteLuminance - nBackgroundLuminance ) * 1 / 3 ) );
 134             aStyleSettings.SetLightColor( aLight );
 135
 136             Color aShadow( nBackgroundColor );
 137             aShadow.DecreaseLuminance( (UINT8)( nBackgroundLuminance * 1 / 3 ) );
 138             aStyleSettings.SetShadowColor( aShadow );
 139
 140             Color aDarkShadow( nBackgroundColor );
 141             aDarkShadow.DecreaseLuminance( (UINT8)( nBackgroundLuminance * 2 / 3 ) );
 142             aStyleSettings.SetDarkShadowColor( aDarkShadow );
 143         }
 144
 145         aSettings.SetStyleSettings( aStyleSettings );
 146         _pWindow->SetSettings( aSettings, TRUE );
 147     }
 148
 149     Any getButtonLikeFaceColor( const Window* _pWindow )
 150     {
 151         sal_Int32 nBackgroundColor = _pWindow->GetSettings().GetStyleSettings().GetFaceColor().GetColor();
 152         return makeAny( nBackgroundColor );
 153     }
 154
 155     static void adjustBooleanWindowStyle( const Any& _rValue, Window* _pWindow, WinBits _nBits, sal_Bool _bInverseSemantics )
 156     {
 157         WinBits nStyle = _pWindow->GetStyle();
 158         sal_Bool bValue( sal_False );
 159         OSL_VERIFY( _rValue >>= bValue );
 160         if ( bValue != _bInverseSemantics )
 161             nStyle |= _nBits;
 162         else
 163             nStyle &= ~_nBits;
 164         _pWindow->SetStyle( nStyle );
 165     }
 166
 167     static void setVisualEffect( const Any& _rValue, Window* _pWindow, void (StyleSettings::*pSetter)( USHORT ), sal_Int16 _nFlatBits, sal_Int16 _n3DBits )
 168     {
 169         AllSettings aSettings = _pWindow->GetSettings();
 170         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
 171
 172         sal_Int16 nStyle = LOOK3D;
 173         OSL_VERIFY( _rValue >>= nStyle );
 174         switch ( nStyle )
 175         {
 176         case FLAT:
 177             (aStyleSettings.*pSetter)( _nFlatBits );
 178             break;
 179         case LOOK3D:
 180         default:
 181             (aStyleSettings.*pSetter)( _n3DBits );
 182         }
 183         aSettings.SetStyleSettings( aStyleSettings );
 184         _pWindow->SetSettings( aSettings );
 185     }
 186
 187     static Any getVisualEffect( Window* _pWindow, USHORT (StyleSettings::*pGetter)( ) const, sal_Int16 _nFlatBits )
 188     {
 189         Any aEffect;
 190
 191         StyleSettings aStyleSettings = _pWindow->GetSettings().GetStyleSettings();
 192         if ( (aStyleSettings.*pGetter)() == _nFlatBits )
 193             aEffect <<= (sal_Int16)FLAT;
 194         else
 195             aEffect <<= (sal_Int16)LOOK3D;
 196         return aEffect;
 197     }
 198 }
 199
 200 //      ----------------------------------------------------
 201 //      class VCLXImageConsumer
 202 //      ----------------------------------------------------
 203
 204 void VCLXImageConsumer::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 205 {
 206     VCLXWindow::ImplGetPropertyIds( rIds );
 207 }
 208
 209 void VCLXImageConsumer::ImplSetNewImage()
 210 {
 211     OSL_PRECOND( GetWindow(), "VCLXImageConsumer::ImplSetNewImage: window is required to be not-NULL!" );
 212     Button* pButton = static_cast< Button* >( GetWindow() );
 213     pButton->SetModeBitmap( GetBitmap() );
 214 }
 215
 216 void VCLXImageConsumer::ImplUpdateImage( sal_Bool bGetNewImage )
 217 {
 218     if ( !GetWindow() )
 219         return;
 220
 221     if ( bGetNewImage && !maImageConsumer.GetData( maImage ) )
 222         return;
 223
 224     ImplSetNewImage();
 225 }
 226
 227 void VCLXImageConsumer::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, short Flags ) throw(::com::sun::star::uno::RuntimeException)
 228 {
 229     ::vos::OGuard aGuard( GetMutex() );
 230
 231     if ( GetWindow() )
 232     {
 233         Size aOldSize = GetWindow()->GetSizePixel();
 234         VCLXWindow::setPosSize( X, Y, Width, Height, Flags );
 235         if ( ( aOldSize.Width() != Width ) || ( aOldSize.Height() != Height ) )
 236             ImplUpdateImage( sal_False );
 237     }
 238 }
 239
 240 void VCLXImageConsumer::init( sal_Int32 Width, sal_Int32 Height ) throw(::com::sun::star::uno::RuntimeException)
 241 {
 242     ::vos::OGuard aGuard( GetMutex() );
 243
 244     maImageConsumer.Init( Width, Height );
 245 }
 246
 247 void VCLXImageConsumer::setColorModel( sal_Int16 BitCount, const ::com::sun::star::uno::Sequence< sal_Int32 >& RGBAPal, sal_Int32 RedMask, sal_Int32 GreenMask, sal_Int32 BlueMask, sal_Int32 AlphaMask ) throw(::com::sun::star::uno::RuntimeException)
 248 {
 249     ::vos::OGuard aGuard( GetMutex() );
 250
 251     maImageConsumer.SetColorModel( BitCount, RGBAPal.getLength(), (const sal_uInt32*) RGBAPal.getConstArray(), RedMask, GreenMask, BlueMask, AlphaMask );
 252 }
 253
 254 void VCLXImageConsumer::setPixelsByBytes( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, const ::com::sun::star::uno::Sequence< sal_Int8 >& ProducerData, sal_Int32 Offset, sal_Int32 Scansize ) throw(::com::sun::star::uno::RuntimeException)
 255 {
 256     ::vos::OGuard aGuard( GetMutex() );
 257
 258     maImageConsumer.SetPixelsByBytes( X, Y, Width, Height, (sal_uInt8*)ProducerData.getConstArray(), Offset, Scansize );
 259     ImplUpdateImage( sal_True );
 260 }
 261
 262 void VCLXImageConsumer::setPixelsByLongs( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, const ::com::sun::star::uno::Sequence< sal_Int32 >& ProducerData, sal_Int32 Offset, sal_Int32 Scansize ) throw(::com::sun::star::uno::RuntimeException)
 263 {
 264     ::vos::OGuard aGuard( GetMutex() );
 265
 266     maImageConsumer.SetPixelsByLongs( X, Y, Width, Height, (const sal_uInt32*) ProducerData.getConstArray(), Offset, Scansize );
 267     ImplUpdateImage( sal_True );
 268 }
 269
 270 void VCLXImageConsumer::complete( sal_Int32 Status, const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XImageProducer > & ) throw(::com::sun::star::uno::RuntimeException)
 271 {
 272     ::vos::OGuard aGuard( GetMutex() );
 273
 274     maImageConsumer.Completed( Status );
 275     ImplUpdateImage( sal_True );
 276 }
 277
 278 void VCLXImageConsumer::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 279 {
 280     ::vos::OGuard aGuard( GetMutex() );
 281
 282     Button* pButton = static_cast< Button* >( GetWindow() );
 283     if ( !pButton )
 284         return;
 285     sal_uInt16 nPropType = GetPropertyId( PropertyName );
 286     switch ( nPropType )
 287     {
 288         case BASEPROPERTY_GRAPHIC:
 289         {
 290             Reference< XGraphic > xGraphic;
 291             OSL_VERIFY( Value >>= xGraphic );
 292             maImage = Image( xGraphic );
 293             ImplSetNewImage();
 294         }
 295         break;
 296
 297         case BASEPROPERTY_IMAGEALIGN:
 298         {
 299             WindowType eType = GetWindow()->GetType();
 300             if (  ( eType == WINDOW_PUSHBUTTON )
 301                || ( eType == WINDOW_RADIOBUTTON )
 302                || ( eType == WINDOW_CHECKBOX )
 303                )
 304             {
 305                 sal_Int16 nAlignment = sal_Int16();
 306                 if ( Value >>= nAlignment )
 307                     pButton->SetImageAlign( static_cast< ImageAlign >( nAlignment ) );
 308             }
 309         }
 310         break;
 311         case BASEPROPERTY_IMAGEPOSITION:
 312         {
 313             WindowType eType = GetWindow()->GetType();
 314             if (  ( eType == WINDOW_PUSHBUTTON )
 315                || ( eType == WINDOW_RADIOBUTTON )
 316                || ( eType == WINDOW_CHECKBOX )
 317                )
 318             {
 319                 sal_Int16 nImagePosition = 2;
 320                 OSL_VERIFY( Value >>= nImagePosition );
 321                 pButton->SetImageAlign( ::toolkit::translateImagePosition( nImagePosition ) );
 322             }
 323         }
 324         break;
 325         default:
 326             VCLXWindow::setProperty( PropertyName, Value );
 327             break;
 328     }
 329 }
 330
 331 ::com::sun::star::uno::Any VCLXImageConsumer::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
 332 {
 333     ::vos::OGuard aGuard( GetMutex() );
 334
 335     ::com::sun::star::uno::Any aProp;
 336     if ( !GetWindow() )
 337         return aProp;
 338
 339     sal_uInt16 nPropType = GetPropertyId( PropertyName );
 340     switch ( nPropType )
 341     {
 342         case BASEPROPERTY_GRAPHIC:
 343             aProp <<= maImage.GetXGraphic();
 344             break;
 345         case BASEPROPERTY_IMAGEALIGN:
 346         {
 347             WindowType eType = GetWindow()->GetType();
 348             if  (  ( eType == WINDOW_PUSHBUTTON )
 349                 || ( eType == WINDOW_RADIOBUTTON )
 350                 || ( eType == WINDOW_CHECKBOX )
 351                 )
 352             {
 353                  aProp <<= ::toolkit::getCompatibleImageAlign( static_cast< Button* >( GetWindow() )->GetImageAlign() );
 354             }
 355         }
 356         break;
 357         case BASEPROPERTY_IMAGEPOSITION:
 358         {
 359             WindowType eType = GetWindow()->GetType();
 360             if  (  ( eType == WINDOW_PUSHBUTTON )
 361                 || ( eType == WINDOW_RADIOBUTTON )
 362                 || ( eType == WINDOW_CHECKBOX )
 363                 )
 364             {
 365                 aProp <<= ::toolkit::translateImagePosition( static_cast< Button* >( GetWindow() )->GetImageAlign() );
 366             }
 367         }
 368         break;
 369         default:
 370         {
 371             aProp <<= VCLXWindow::getProperty( PropertyName );
 372         }
 373         break;
 374     }
 375     return aProp;
 376 }
 377
 378 //--------------------------------------------------------------------
 379 //      class VCLXButton
 380 //      ----------------------------------------------------
 381
 382 void VCLXButton::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 383 {
 384     PushPropertyIds( rIds,
 385                      BASEPROPERTY_BACKGROUNDCOLOR,
 386                      BASEPROPERTY_DEFAULTBUTTON,
 387                      BASEPROPERTY_DEFAULTCONTROL,
 388                      BASEPROPERTY_ENABLED,
 389                      BASEPROPERTY_ENABLEVISIBLE,
 390                      BASEPROPERTY_FONTDESCRIPTOR,
 391                      BASEPROPERTY_GRAPHIC,
 392                      BASEPROPERTY_HELPTEXT,
 393                      BASEPROPERTY_HELPURL,
 394                      BASEPROPERTY_IMAGEALIGN,
 395                      BASEPROPERTY_IMAGEPOSITION,
 396                      BASEPROPERTY_IMAGEURL,
 397                      BASEPROPERTY_LABEL,
 398                      BASEPROPERTY_PRINTABLE,
 399                      BASEPROPERTY_PUSHBUTTONTYPE,
 400                      BASEPROPERTY_REPEAT,
 401                      BASEPROPERTY_REPEAT_DELAY,
 402                      BASEPROPERTY_STATE,
 403                      BASEPROPERTY_TABSTOP,
 404                      BASEPROPERTY_TOGGLE,
 405                      BASEPROPERTY_FOCUSONCLICK,
 406                      BASEPROPERTY_MULTILINE,
 407                      BASEPROPERTY_ALIGN,
 408                      BASEPROPERTY_VERTICALALIGN,
 409                      BASEPROPERTY_WRITING_MODE,
 410                      BASEPROPERTY_CONTEXT_WRITING_MODE,
 411                      0);
 412     VCLXImageConsumer::ImplGetPropertyIds( rIds );
 413 }
 414
 415 VCLXButton::VCLXButton()
 416     :maActionListeners( *this )
 417     ,maItemListeners( *this )
 418 {
 419 }
 420
 421 VCLXButton::~VCLXButton()
 422 {
 423 #ifndef __SUNPRO_CC
 424     OSL_TRACE ("%s", __FUNCTION__);
 425 #endif
 426 }
 427
 428 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXButton::CreateAccessibleContext()
 429 {
 430     return getAccessibleFactory().createAccessibleContext( this );
 431 }
 432
 433 void VCLXButton::dispose() throw(::com::sun::star::uno::RuntimeException)
 434 {
 435     ::vos::OGuard aGuard( GetMutex() );
 436
 437     ::com::sun::star::lang::EventObject aObj;
 438     aObj.Source = (::cppu::OWeakObject*)this;
 439     maActionListeners.disposeAndClear( aObj );
 440     maItemListeners.disposeAndClear( aObj );
 441     VCLXImageConsumer::dispose();
 442 }
 443
 444 void VCLXButton::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l  )throw(::com::sun::star::uno::RuntimeException)
 445 {
 446     ::vos::OGuard aGuard( GetMutex() );
 447     maActionListeners.addInterface( l );
 448 }
 449
 450 void VCLXButton::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 451 {
 452     ::vos::OGuard aGuard( GetMutex() );
 453     maActionListeners.removeInterface( l );
 454 }
 455
 456 void VCLXButton::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l  )throw(::com::sun::star::uno::RuntimeException)
 457 {
 458     ::vos::OGuard aGuard( GetMutex() );
 459     maItemListeners.addInterface( l );
 460 }
 461
 462 void VCLXButton::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 463 {
 464     ::vos::OGuard aGuard( GetMutex() );
 465     maItemListeners.removeInterface( l );
 466 }
 467
 468 void VCLXButton::setLabel( const ::rtl::OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException)
 469 {
 470     ::vos::OGuard aGuard( GetMutex() );
 471
 472     Window* pWindow = GetWindow();
 473     if ( pWindow )
 474         pWindow->SetText( rLabel );
 475 }
 476
 477 void VCLXButton::setActionCommand( const ::rtl::OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException)
 478 {
 479     ::vos::OGuard aGuard( GetMutex() );
 480
 481     maActionCommand = rCommand;
 482 }
 483
 484 ::com::sun::star::awt::Size VCLXButton::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
 485 {
 486     ::vos::OGuard aGuard( GetMutex() );
 487
 488     Size aSz;
 489     PushButton* pButton = (PushButton*) GetWindow();
 490     if ( pButton )
 491         aSz = pButton->CalcMinimumSize();
 492     return AWTSize(aSz);
 493 }
 494
 495 ::com::sun::star::awt::Size VCLXButton::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
 496 {
 497     ::com::sun::star::awt::Size aSz = getMinimumSize();
 498     aSz.Width += 16;
 499     aSz.Height += 10;
 500     return aSz;
 501 }
 502
 503 ::com::sun::star::awt::Size VCLXButton::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
 504 {
 505     ::vos::OGuard aGuard( GetMutex() );
 506
 507     Size aSz = VCLSize(rNewSize);
 508     PushButton* pButton = (PushButton*) GetWindow();
 509     if ( pButton )
 510     {
 511         Size aMinSz = pButton->CalcMinimumSize();
 512         // Kein Text, also Image
 513         if ( !pButton->GetText().Len() )
 514         {
 515             if ( aSz.Width() < aMinSz.Width() )
 516                 aSz.Width() = aMinSz.Width();
 517             if ( aSz.Height() < aMinSz.Height() )
 518                 aSz.Height() = aMinSz.Height();
 519         }
 520         else
 521         {
 522             if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
 523                 aSz.Height() = aMinSz.Height();
 524             else
 525                 aSz = aMinSz;
 526         }
 527     }
 528     return AWTSize(aSz);
 529 }
 530
 531 void VCLXButton::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 532 {
 533     ::vos::OGuard aGuard( GetMutex() );
 534
 535     Button* pButton = (Button*)GetWindow();
 536     if ( pButton )
 537     {
 538         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 539         switch ( nPropType )
 540         {
 541             case BASEPROPERTY_FOCUSONCLICK:
 542                 ::toolkit::adjustBooleanWindowStyle( Value, pButton, WB_NOPOINTERFOCUS, sal_True );
 543                 break;
 544
 545             case BASEPROPERTY_TOGGLE:
 546                 ::toolkit::adjustBooleanWindowStyle( Value, pButton, WB_TOGGLE, sal_False );
 547                 break;
 548
 549             case BASEPROPERTY_DEFAULTBUTTON:
 550             {
 551                 WinBits nStyle = pButton->GetStyle() | WB_DEFBUTTON;
 552                 sal_Bool b = sal_Bool();
 553                 if ( ( Value >>= b ) && !b )
 554                     nStyle &= ~WB_DEFBUTTON;
 555                 pButton->SetStyle( nStyle );
 556             }
 557             break;
 558             case BASEPROPERTY_STATE:
 559             {
 560                 if ( GetWindow()->GetType() == WINDOW_PUSHBUTTON )
 561                 {
 562                     sal_Int16 n = sal_Int16();
 563                     if ( Value >>= n )
 564                         ((PushButton*)pButton)->SetState( (TriState)n );
 565                 }
 566             }
 567             break;
 568             default:
 569             {
 570                 VCLXImageConsumer::setProperty( PropertyName, Value );
 571             }
 572         }
 573     }
 574 }
 575
 576 ::com::sun::star::uno::Any VCLXButton::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
 577 {
 578     ::vos::OGuard aGuard( GetMutex() );
 579
 580     ::com::sun::star::uno::Any aProp;
 581     Button* pButton = (Button*)GetWindow();
 582     if ( pButton )
 583     {
 584         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 585         switch ( nPropType )
 586         {
 587             case BASEPROPERTY_FOCUSONCLICK:
 588                 aProp <<= (sal_Bool)( ( pButton->GetStyle() & WB_NOPOINTERFOCUS ) == 0 );
 589                 break;
 590
 591             case BASEPROPERTY_TOGGLE:
 592                 aProp <<= (sal_Bool)( ( pButton->GetStyle() & WB_TOGGLE ) != 0 );
 593                 break;
 594
 595             case BASEPROPERTY_DEFAULTBUTTON:
 596             {
 597                 aProp <<= (sal_Bool) ( ( pButton->GetStyle() & WB_DEFBUTTON ) ? sal_True : sal_False );
 598             }
 599             break;
 600             case BASEPROPERTY_STATE:
 601             {
 602                 if ( GetWindow()->GetType() == WINDOW_PUSHBUTTON )
 603                 {
 604                      aProp <<= (sal_Int16)((PushButton*)pButton)->GetState();
 605                 }
 606             }
 607             break;
 608             default:
 609             {
 610                 aProp <<= VCLXImageConsumer::getProperty( PropertyName );
 611             }
 612         }
 613     }
 614     return aProp;
 615 }
 616
 617 void VCLXButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 618 {
 619     switch ( rVclWindowEvent.GetId() )
 620     {
 621         case VCLEVENT_BUTTON_CLICK:
 622         {
 623             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
 624                 // since we call listeners below, there is a potential that we will be destroyed
 625                 // during the listener call. To prevent the resulting crashs, we keep us
 626                 // alive as long as we're here
 627                 // #20178# - 2003-10-01 - fs@openoffice.org
 628
 629             if ( maActionListeners.getLength() )
 630             {
 631                 ::com::sun::star::awt::ActionEvent aEvent;
 632                 aEvent.Source = (::cppu::OWeakObject*)this;
 633                 aEvent.ActionCommand = maActionCommand;
 634                 maActionListeners.actionPerformed( aEvent );
 635             }
 636         }
 637         break;
 638
 639         case VCLEVENT_PUSHBUTTON_TOGGLE:
 640         {
 641             PushButton& rButton = dynamic_cast< PushButton& >( *rVclWindowEvent.GetWindow() );
 642
 643             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
 644             if ( maItemListeners.getLength() )
 645             {
 646                 ::com::sun::star::awt::ItemEvent aEvent;
 647                 aEvent.Source = (::cppu::OWeakObject*)this;
 648                 aEvent.Selected = ( rButton.GetState() == STATE_CHECK ) ? 1 : 0;
 649                 maItemListeners.itemStateChanged( aEvent );
 650             }
 651         }
 652         break;
 653
 654         default:
 655             VCLXImageConsumer::ProcessWindowEvent( rVclWindowEvent );
 656             break;
 657     }
 658 }
 659
 660 //      ----------------------------------------------------
 661 //      class VCLXImageControl
 662 //      ----------------------------------------------------
 663
 664 void VCLXImageControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 665 {
 666     PushPropertyIds( rIds,
 667                      BASEPROPERTY_BACKGROUNDCOLOR,
 668                      BASEPROPERTY_BORDER,
 669                      BASEPROPERTY_BORDERCOLOR,
 670                      BASEPROPERTY_DEFAULTCONTROL,
 671                      BASEPROPERTY_ENABLED,
 672                      BASEPROPERTY_ENABLEVISIBLE,
 673                      BASEPROPERTY_GRAPHIC,
 674                      BASEPROPERTY_HELPTEXT,
 675                      BASEPROPERTY_HELPURL,
 676                      BASEPROPERTY_IMAGEURL,
 677                      BASEPROPERTY_PRINTABLE,
 678                      BASEPROPERTY_SCALEIMAGE,
 679                      BASEPROPERTY_IMAGE_SCALE_MODE,
 680                      BASEPROPERTY_TABSTOP,
 681                      BASEPROPERTY_WRITING_MODE,
 682                      BASEPROPERTY_CONTEXT_WRITING_MODE,
 683                      0);
 684     VCLXImageConsumer::ImplGetPropertyIds( rIds );
 685 }
 686
 687 VCLXImageControl::VCLXImageControl()
 688 {
 689 }
 690
 691 VCLXImageControl::~VCLXImageControl()
 692 {
 693 }
 694
 695 void VCLXImageControl::ImplSetNewImage()
 696 {
 697     OSL_PRECOND( GetWindow(), "VCLXImageControl::ImplSetNewImage: window is required to be not-NULL!" );
 698     ImageControl* pControl = static_cast< ImageControl* >( GetWindow() );
 699     pControl->SetBitmap( GetBitmap() );
 700 }
 701
 702 ::com::sun::star::awt::Size VCLXImageControl::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
 703 {
 704     ::vos::OGuard aGuard( GetMutex() );
 705
 706     Size aSz = GetBitmap().GetSizePixel();
 707     aSz = ImplCalcWindowSize( aSz );
 708
 709     return AWTSize(aSz);
 710 }
 711
 712 ::com::sun::star::awt::Size VCLXImageControl::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
 713 {
 714     return getMinimumSize();
 715 }
 716
 717 ::com::sun::star::awt::Size VCLXImageControl::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
 718 {
 719     ::vos::OGuard aGuard( GetMutex() );
 720
 721     ::com::sun::star::awt::Size aSz = rNewSize;
 722     ::com::sun::star::awt::Size aMinSz = getMinimumSize();
 723     if ( aSz.Width < aMinSz.Width )
 724         aSz.Width = aMinSz.Width;
 725     if ( aSz.Height < aMinSz.Height )
 726         aSz.Height = aMinSz.Height;
 727     return aSz;
 728 }
 729
 730 void VCLXImageControl::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 731 {
 732     ::vos::OGuard aGuard( GetMutex() );
 733
 734     ImageControl* pImageControl = (ImageControl*)GetWindow();
 735
 736     sal_uInt16 nPropType = GetPropertyId( PropertyName );
 737     switch ( nPropType )
 738     {
 739         case BASEPROPERTY_IMAGE_SCALE_MODE:
 740         {
 741             sal_Int16 nScaleMode( ImageScaleMode::Anisotropic );
 742             if ( pImageControl && ( Value >>= nScaleMode ) )
 743             {
 744                 pImageControl->SetScaleMode( nScaleMode );
 745             }
 746         }
 747         break;
 748
 749         case BASEPROPERTY_SCALEIMAGE:
 750         {
 751             // this is for compatibility only, nowadays, the ImageScaleMode property should be used
 752             sal_Bool bScaleImage = sal_False;
 753             if ( pImageControl && ( Value >>= bScaleImage ) )
 754             {
 755                 pImageControl->SetScaleMode( bScaleImage ? ImageScaleMode::Anisotropic : ImageScaleMode::None );
 756             }
 757         }
 758         break;
 759
 760         default:
 761             VCLXImageConsumer::setProperty( PropertyName, Value );
 762             break;
 763     }
 764 }
 765
 766 ::com::sun::star::uno::Any VCLXImageControl::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
 767 {
 768     ::vos::OGuard aGuard( GetMutex() );
 769
 770     ::com::sun::star::uno::Any aProp;
 771     ImageControl* pImageControl = (ImageControl*)GetWindow();
 772     sal_uInt16 nPropType = GetPropertyId( PropertyName );
 773
 774     switch ( nPropType )
 775     {
 776         case BASEPROPERTY_IMAGE_SCALE_MODE:
 777             aProp <<= ( pImageControl ? pImageControl->GetScaleMode() : ImageScaleMode::Anisotropic );
 778             break;
 779
 780         case BASEPROPERTY_SCALEIMAGE:
 781             aProp <<= ( pImageControl && pImageControl->GetScaleMode() != ImageScaleMode::None ) ? sal_True : sal_False;
 782             break;
 783
 784         default:
 785             aProp = VCLXImageConsumer::getProperty( PropertyName );
 786             break;
 787     }
 788     return aProp;
 789 }
 790
 791 //      ----------------------------------------------------
 792 //      class VCLXCheckBox
 793 //      ----------------------------------------------------
 794
 795
 796 void VCLXCheckBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 797 {
 798     PushPropertyIds( rIds,
 799                      BASEPROPERTY_DEFAULTCONTROL,
 800                      BASEPROPERTY_ENABLED,
 801                      BASEPROPERTY_ENABLEVISIBLE,
 802                      BASEPROPERTY_FONTDESCRIPTOR,
 803                      BASEPROPERTY_GRAPHIC,
 804                      BASEPROPERTY_HELPTEXT,
 805                      BASEPROPERTY_HELPURL,
 806                      BASEPROPERTY_IMAGEPOSITION,
 807                      BASEPROPERTY_IMAGEURL,
 808                      BASEPROPERTY_LABEL,
 809                      BASEPROPERTY_PRINTABLE,
 810                      BASEPROPERTY_STATE,
 811                      BASEPROPERTY_TABSTOP,
 812                      BASEPROPERTY_TRISTATE,
 813                      BASEPROPERTY_VISUALEFFECT,
 814                      BASEPROPERTY_MULTILINE,
 815                      BASEPROPERTY_BACKGROUNDCOLOR,
 816                      BASEPROPERTY_ALIGN,
 817                      BASEPROPERTY_VERTICALALIGN,
 818                      BASEPROPERTY_WRITING_MODE,
 819                      BASEPROPERTY_CONTEXT_WRITING_MODE,
 820                      0);
 821     VCLXImageConsumer::ImplGetPropertyIds( rIds );
 822 }
 823
 824 VCLXCheckBox::VCLXCheckBox() :  maActionListeners( *this ), maItemListeners( *this )
 825 {
 826 }
 827
 828 // ::com::sun::star::uno::XInterface
 829 ::com::sun::star::uno::Any VCLXCheckBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
 830 {
 831     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
 832                                         SAL_STATIC_CAST( ::com::sun::star::awt::XButton*, this ),
 833                                         SAL_STATIC_CAST( ::com::sun::star::awt::XCheckBox*, this ) );
 834     return (aRet.hasValue() ? aRet : VCLXImageConsumer::queryInterface( rType ));
 835 }
 836
 837 // ::com::sun::star::lang::XTypeProvider
 838 IMPL_XTYPEPROVIDER_START( VCLXCheckBox )
 839     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XButton>* ) NULL ),
 840     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XCheckBox>* ) NULL ),
 841     VCLXImageConsumer::getTypes()
 842 IMPL_XTYPEPROVIDER_END
 843
 844 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXCheckBox::CreateAccessibleContext()
 845 {
 846     return getAccessibleFactory().createAccessibleContext( this );
 847 }
 848
 849 void VCLXCheckBox::dispose() throw(::com::sun::star::uno::RuntimeException)
 850 {
 851     ::vos::OGuard aGuard( GetMutex() );
 852
 853     ::com::sun::star::lang::EventObject aObj;
 854     aObj.Source = (::cppu::OWeakObject*)this;
 855     maItemListeners.disposeAndClear( aObj );
 856     VCLXImageConsumer::dispose();
 857 }
 858
 859 void VCLXCheckBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 860 {
 861     ::vos::OGuard aGuard( GetMutex() );
 862     maItemListeners.addInterface( l );
 863 }
 864
 865 void VCLXCheckBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 866 {
 867     ::vos::OGuard aGuard( GetMutex() );
 868     maItemListeners.removeInterface( l );
 869 }
 870
 871 void VCLXCheckBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l  )throw(::com::sun::star::uno::RuntimeException)
 872 {
 873     ::vos::OGuard aGuard( GetMutex() );
 874     maActionListeners.addInterface( l );
 875 }
 876
 877 void VCLXCheckBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 878 {
 879     ::vos::OGuard aGuard( GetMutex() );
 880     maActionListeners.removeInterface( l );
 881 }
 882
 883 void VCLXCheckBox::setActionCommand( const ::rtl::OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException)
 884 {
 885     ::vos::OGuard aGuard( GetMutex() );
 886     maActionCommand = rCommand;
 887 }
 888
 889 void VCLXCheckBox::setLabel( const ::rtl::OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException)
 890 {
 891     ::vos::OGuard aGuard( GetMutex() );
 892
 893     Window* pWindow = GetWindow();
 894     if ( pWindow )
 895         pWindow->SetText( rLabel );
 896 }
 897
 898 void VCLXCheckBox::setState( short n ) throw(::com::sun::star::uno::RuntimeException)
 899 {
 900     ::vos::OGuard aGuard( GetMutex() );
 901
 902     CheckBox* pCheckBox = (CheckBox*)GetWindow();
 903     if ( pCheckBox)
 904     {
 905         TriState eState;
 906         switch ( n )
 907         {
 908             case 0:     eState = STATE_NOCHECK;     break;
 909             case 1:     eState = STATE_CHECK;       break;
 910             case 2:     eState = STATE_DONTKNOW;    break;
 911             default:    eState = STATE_NOCHECK;
 912         }
 913         pCheckBox->SetState( eState );
 914
 915         // #105198# call C++ click listeners (needed for accessibility)
 916         // pCheckBox->GetClickHdl().Call( pCheckBox );
 917
 918         // #107218# Call same virtual methods and listeners like VCL would do after user interaction
 919         SetSynthesizingVCLEvent( sal_True );
 920         pCheckBox->Toggle();
 921         pCheckBox->Click();
 922         SetSynthesizingVCLEvent( sal_False );
 923     }
 924 }
 925
 926 short VCLXCheckBox::getState() throw(::com::sun::star::uno::RuntimeException)
 927 {
 928     ::vos::OGuard aGuard( GetMutex() );
 929
 930     short nState = -1;
 931     CheckBox* pCheckBox = (CheckBox*)GetWindow();
 932     if ( pCheckBox )
 933     {
 934         switch ( pCheckBox->GetState() )
 935         {
 936             case STATE_NOCHECK:     nState = 0; break;
 937             case STATE_CHECK:       nState = 1; break;
 938             case STATE_DONTKNOW:    nState = 2; break;
 939             default:                DBG_ERROR( "VCLXCheckBox::getState(): unknown TriState!" );
 940         }
 941     }
 942
 943     return nState;
 944 }
 945
 946 void VCLXCheckBox::enableTriState( sal_Bool b ) throw(::com::sun::star::uno::RuntimeException)
 947 {
 948     ::vos::OGuard aGuard( GetMutex() );
 949
 950     CheckBox* pCheckBox = (CheckBox*)GetWindow();
 951     if ( pCheckBox)
 952         pCheckBox->EnableTriState( b );
 953 }
 954
 955 ::com::sun::star::awt::Size VCLXCheckBox::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
 956 {
 957     ::vos::OGuard aGuard( GetMutex() );
 958
 959     Size aSz;
 960     CheckBox* pCheckBox = (CheckBox*) GetWindow();
 961     if ( pCheckBox )
 962         aSz = pCheckBox->CalcMinimumSize();
 963     return AWTSize(aSz);
 964 }
 965
 966 ::com::sun::star::awt::Size VCLXCheckBox::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
 967 {
 968     return getMinimumSize();
 969 }
 970
 971 ::com::sun::star::awt::Size VCLXCheckBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
 972 {
 973     ::vos::OGuard aGuard( GetMutex() );
 974
 975     Size aSz = VCLSize(rNewSize);
 976     CheckBox* pCheckBox = (CheckBox*) GetWindow();
 977     if ( pCheckBox )
 978     {
 979         Size aMinSz = pCheckBox->CalcMinimumSize();
 980         if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
 981             aSz.Height() = aMinSz.Height();
 982         else
 983             aSz = aMinSz;
 984     }
 985     return AWTSize(aSz);
 986 }
 987
 988 void VCLXCheckBox::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 989 {
 990     ::vos::OGuard aGuard( GetMutex() );
 991
 992     CheckBox* pCheckBox = (CheckBox*)GetWindow();
 993     if ( pCheckBox )
 994     {
 995         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 996         switch ( nPropType )
 997         {
 998             case BASEPROPERTY_VISUALEFFECT:
 999                 ::toolkit::setVisualEffect( Value, pCheckBox, &StyleSettings::SetCheckBoxStyle, STYLE_CHECKBOX_MONO, STYLE_CHECKBOX_WIN );
1000                 break;
1001
1002             case BASEPROPERTY_TRISTATE:
1003             {
1004                 sal_Bool b = sal_Bool();
1005                 if ( Value >>= b )
1006                      pCheckBox->EnableTriState( b );
1007             }
1008             break;
1009             case BASEPROPERTY_STATE:
1010             {
1011                 sal_Int16 n = sal_Int16();
1012                 if ( Value >>= n )
1013                     setState( n );
1014             }
1015             break;
1016             default:
1017             {
1018                 VCLXImageConsumer::setProperty( PropertyName, Value );
1019             }
1020         }
1021     }
1022 }
1023
1024 ::com::sun::star::uno::Any VCLXCheckBox::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
1025 {
1026     ::vos::OGuard aGuard( GetMutex() );
1027
1028     ::com::sun::star::uno::Any aProp;
1029     CheckBox* pCheckBox = (CheckBox*)GetWindow();
1030     if ( pCheckBox )
1031     {
1032         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1033         switch ( nPropType )
1034         {
1035             case BASEPROPERTY_VISUALEFFECT:
1036                 aProp = ::toolkit::getVisualEffect( pCheckBox, &StyleSettings::GetCheckBoxStyle, STYLE_CHECKBOX_MONO );
1037                 break;
1038             case BASEPROPERTY_TRISTATE:
1039                  aProp <<= (sal_Bool)pCheckBox->IsTriStateEnabled();
1040                 break;
1041             case BASEPROPERTY_STATE:
1042                  aProp <<= (sal_Int16)pCheckBox->GetState();
1043                 break;
1044             default:
1045             {
1046                 aProp <<= VCLXImageConsumer::getProperty( PropertyName );
1047             }
1048         }
1049     }
1050     return aProp;
1051 }
1052
1053 void VCLXCheckBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1054 {
1055     switch ( rVclWindowEvent.GetId() )
1056     {
1057         case VCLEVENT_CHECKBOX_TOGGLE:
1058         {
1059             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1060                 // since we call listeners below, there is a potential that we will be destroyed
1061                 // in during the listener call. To prevent the resulting crashs, we keep us
1062                 // alive as long as we're here
1063                 // #20178# - 2003-10-01 - fs@openoffice.org
1064
1065             CheckBox* pCheckBox = (CheckBox*)GetWindow();
1066             if ( pCheckBox )
1067             {
1068                 if ( maItemListeners.getLength() )
1069                 {
1070                     ::com::sun::star::awt::ItemEvent aEvent;
1071                     aEvent.Source = (::cppu::OWeakObject*)this;
1072                     aEvent.Highlighted = sal_False;
1073                     aEvent.Selected = pCheckBox->GetState();
1074                     maItemListeners.itemStateChanged( aEvent );
1075                 }
1076                 if ( !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1077                 {
1078                     ::com::sun::star::awt::ActionEvent aEvent;
1079                     aEvent.Source = (::cppu::OWeakObject*)this;
1080                     aEvent.ActionCommand = maActionCommand;
1081                     maActionListeners.actionPerformed( aEvent );
1082                 }
1083             }
1084         }
1085         break;
1086
1087         default:
1088             VCLXImageConsumer::ProcessWindowEvent( rVclWindowEvent );
1089             break;
1090     }
1091 }
1092
1093 //      ----------------------------------------------------
1094 //      class VCLXRadioButton
1095 //      ----------------------------------------------------
1096 void VCLXRadioButton::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1097 {
1098     PushPropertyIds( rIds,
1099                      BASEPROPERTY_DEFAULTCONTROL,
1100                      BASEPROPERTY_ENABLED,
1101                      BASEPROPERTY_ENABLEVISIBLE,
1102                      BASEPROPERTY_FONTDESCRIPTOR,
1103                      BASEPROPERTY_GRAPHIC,
1104                      BASEPROPERTY_HELPTEXT,
1105                      BASEPROPERTY_HELPURL,
1106                      BASEPROPERTY_IMAGEPOSITION,
1107                      BASEPROPERTY_IMAGEURL,
1108                      BASEPROPERTY_LABEL,
1109                      BASEPROPERTY_PRINTABLE,
1110                      BASEPROPERTY_STATE,
1111                      BASEPROPERTY_TABSTOP,
1112                      BASEPROPERTY_VISUALEFFECT,
1113                      BASEPROPERTY_MULTILINE,
1114                      BASEPROPERTY_BACKGROUNDCOLOR,
1115                      BASEPROPERTY_ALIGN,
1116                      BASEPROPERTY_VERTICALALIGN,
1117                      BASEPROPERTY_WRITING_MODE,
1118                      BASEPROPERTY_CONTEXT_WRITING_MODE,
1119                      BASEPROPERTY_GROUPNAME,
1120                      0);
1121     VCLXImageConsumer::ImplGetPropertyIds( rIds );
1122 }
1123
1124
1125 VCLXRadioButton::VCLXRadioButton() : maItemListeners( *this ), maActionListeners( *this )
1126 {
1127 }
1128
1129 // ::com::sun::star::uno::XInterface
1130 ::com::sun::star::uno::Any VCLXRadioButton::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1131 {
1132     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1133                                         SAL_STATIC_CAST( ::com::sun::star::awt::XRadioButton*, this ),
1134                                         SAL_STATIC_CAST( ::com::sun::star::awt::XButton*, this ) );
1135     return (aRet.hasValue() ? aRet : VCLXImageConsumer::queryInterface( rType ));
1136 }
1137
1138 // ::com::sun::star::lang::XTypeProvider
1139 IMPL_XTYPEPROVIDER_START( VCLXRadioButton )
1140     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XRadioButton>* ) NULL ),
1141     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XButton>* ) NULL ),
1142     VCLXImageConsumer::getTypes()
1143 IMPL_XTYPEPROVIDER_END
1144
1145 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXRadioButton::CreateAccessibleContext()
1146 {
1147     return getAccessibleFactory().createAccessibleContext( this );
1148 }
1149
1150 void VCLXRadioButton::dispose() throw(::com::sun::star::uno::RuntimeException)
1151 {
1152     ::vos::OGuard aGuard( GetMutex() );
1153
1154     ::com::sun::star::lang::EventObject aObj;
1155     aObj.Source = (::cppu::OWeakObject*)this;
1156     maItemListeners.disposeAndClear( aObj );
1157     VCLXImageConsumer::dispose();
1158 }
1159
1160 void VCLXRadioButton::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1161 {
1162     ::vos::OGuard aGuard( GetMutex() );
1163
1164     RadioButton* pButton = (RadioButton*)GetWindow();
1165     if ( pButton )
1166     {
1167         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1168         switch ( nPropType )
1169         {
1170             case BASEPROPERTY_VISUALEFFECT:
1171                 ::toolkit::setVisualEffect( Value, pButton, &StyleSettings::SetRadioButtonStyle, STYLE_RADIOBUTTON_MONO, STYLE_RADIOBUTTON_WIN );
1172                 break;
1173
1174             case BASEPROPERTY_STATE:
1175             {
1176                 sal_Int16 n = sal_Int16();
1177                 if ( Value >>= n )
1178                 {
1179                     BOOL b = n ? sal_True : sal_False;
1180                     if ( pButton->IsRadioCheckEnabled() )
1181                         pButton->Check( b );
1182                     else
1183                         pButton->SetState( b );
1184                                         // If VBA - need to be able to test
1185                                         // simulate click event
1186                                         if ( maActionListeners.getLength() )
1187                                         {
1188                                                 ::com::sun::star::awt::ActionEvent aEvent;
1189                                                 aEvent.Source = (::cppu::OWeakObject*)this;
1190                                                 aEvent.ActionCommand = maActionCommand;
1191                                                 maActionListeners.actionPerformed( aEvent );
1192                 }
1193
1194             }
1195                         }
1196             break;
1197             case BASEPROPERTY_AUTOTOGGLE:
1198             {
1199                 sal_Bool b = sal_Bool();
1200                 if ( Value >>= b )
1201                     pButton->EnableRadioCheck( b );
1202             }
1203             break;
1204             default:
1205             {
1206                 VCLXImageConsumer::setProperty( PropertyName, Value );
1207             }
1208         }
1209     }
1210 }
1211
1212 ::com::sun::star::uno::Any VCLXRadioButton::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
1213 {
1214     ::vos::OGuard aGuard( GetMutex() );
1215
1216     ::com::sun::star::uno::Any aProp;
1217     RadioButton* pButton = (RadioButton*)GetWindow();
1218     if ( pButton )
1219     {
1220         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1221         switch ( nPropType )
1222         {
1223             case BASEPROPERTY_VISUALEFFECT:
1224                 aProp = ::toolkit::getVisualEffect( pButton, &StyleSettings::GetRadioButtonStyle, STYLE_RADIOBUTTON_MONO );
1225                 break;
1226             case BASEPROPERTY_STATE:
1227                 aProp <<= (sal_Int16) ( pButton->IsChecked() ? 1 : 0 );
1228                 break;
1229             case BASEPROPERTY_AUTOTOGGLE:
1230                 aProp <<= (sal_Bool) pButton->IsRadioCheckEnabled();
1231                 break;
1232             default:
1233             {
1234                 aProp <<= VCLXImageConsumer::getProperty( PropertyName );
1235             }
1236         }
1237     }
1238     return aProp;
1239 }
1240
1241 void VCLXRadioButton::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1242 {
1243     ::vos::OGuard aGuard( GetMutex() );
1244     maItemListeners.addInterface( l );
1245 }
1246
1247 void VCLXRadioButton::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1248 {
1249     ::vos::OGuard aGuard( GetMutex() );
1250     maItemListeners.removeInterface( l );
1251 }
1252
1253 void VCLXRadioButton::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l  )throw(::com::sun::star::uno::RuntimeException)
1254 {
1255     ::vos::OGuard aGuard( GetMutex() );
1256     maActionListeners.addInterface( l );
1257 }
1258
1259 void VCLXRadioButton::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1260 {
1261     ::vos::OGuard aGuard( GetMutex() );
1262     maActionListeners.removeInterface( l );
1263 }
1264
1265 void VCLXRadioButton::setLabel( const ::rtl::OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException)
1266 {
1267     ::vos::OGuard aGuard( GetMutex() );
1268
1269     Window* pWindow = GetWindow();
1270     if ( pWindow )
1271         pWindow->SetText( rLabel );
1272 }
1273
1274 void VCLXRadioButton::setActionCommand( const ::rtl::OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException)
1275 {
1276     ::vos::OGuard aGuard( GetMutex() );
1277     maActionCommand = rCommand;
1278 }
1279
1280 void VCLXRadioButton::setState( sal_Bool b ) throw(::com::sun::star::uno::RuntimeException)
1281 {
1282     ::vos::OGuard aGuard( GetMutex() );
1283
1284     RadioButton* pRadioButton = (RadioButton*)GetWindow();
1285     if ( pRadioButton)
1286     {
1287         pRadioButton->Check( b );
1288         // #102717# item listeners are called, but not C++ click listeners in StarOffice code => call click hdl
1289         // But this is needed in old code because Accessibility API uses it.
1290         // pRadioButton->GetClickHdl().Call( pRadioButton );
1291
1292         // #107218# Call same virtual methods and listeners like VCL would do after user interaction
1293         SetSynthesizingVCLEvent( sal_True );
1294         pRadioButton->Click();
1295         SetSynthesizingVCLEvent( sal_False );
1296     }
1297 }
1298
1299 sal_Bool VCLXRadioButton::getState() throw(::com::sun::star::uno::RuntimeException)
1300 {
1301     ::vos::OGuard aGuard( GetMutex() );
1302
1303     RadioButton* pRadioButton = (RadioButton*)GetWindow();
1304     return pRadioButton ? pRadioButton->IsChecked() : sal_False;
1305 }
1306
1307 ::com::sun::star::awt::Size VCLXRadioButton::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
1308 {
1309     ::vos::OGuard aGuard( GetMutex() );
1310
1311     Size aSz;
1312     RadioButton* pRadioButton = (RadioButton*) GetWindow();
1313     if ( pRadioButton )
1314         aSz = pRadioButton->CalcMinimumSize();
1315     return AWTSize(aSz);
1316 }
1317
1318 ::com::sun::star::awt::Size VCLXRadioButton::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
1319 {
1320     return getMinimumSize();
1321 }
1322
1323 ::com::sun::star::awt::Size VCLXRadioButton::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
1324 {
1325     ::vos::OGuard aGuard( GetMutex() );
1326
1327     Size aSz = VCLSize(rNewSize);
1328     RadioButton* pRadioButton = (RadioButton*) GetWindow();
1329     if ( pRadioButton )
1330     {
1331         Size aMinSz = pRadioButton->CalcMinimumSize();
1332         if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
1333             aSz.Height() = aMinSz.Height();
1334         else
1335             aSz = aMinSz;
1336     }
1337     return AWTSize(aSz);
1338 }
1339
1340 void VCLXRadioButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1341 {
1342     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1343         // since we call listeners below, there is a potential that we will be destroyed
1344         // in during the listener call. To prevent the resulting crashs, we keep us
1345         // alive as long as we're here
1346         // #20178# - 2003-10-01 - fs@openoffice.org
1347
1348     switch ( rVclWindowEvent.GetId() )
1349     {
1350         case VCLEVENT_BUTTON_CLICK:
1351             if ( !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1352             {
1353                 ::com::sun::star::awt::ActionEvent aEvent;
1354                 aEvent.Source = (::cppu::OWeakObject*)this;
1355                 aEvent.ActionCommand = maActionCommand;
1356                 maActionListeners.actionPerformed( aEvent );
1357             }
1358             ImplClickedOrToggled( FALSE );
1359             break;
1360
1361         case VCLEVENT_RADIOBUTTON_TOGGLE:
1362             ImplClickedOrToggled( TRUE );
1363             break;
1364
1365         default:
1366             VCLXImageConsumer::ProcessWindowEvent( rVclWindowEvent );
1367             break;
1368     }
1369 }
1370
1371 void VCLXRadioButton::ImplClickedOrToggled( BOOL bToggled )
1372 {
1373     // In the formulars, RadioChecked is not enabled, call itemStateChanged only for click
1374     // In the dialog editor, RadioChecked is enabled, call itemStateChanged only for bToggled
1375     RadioButton* pRadioButton = (RadioButton*)GetWindow();
1376     if ( pRadioButton && ( pRadioButton->IsRadioCheckEnabled() == bToggled ) && ( bToggled || pRadioButton->IsStateChanged() ) && maItemListeners.getLength() )
1377     {
1378         ::com::sun::star::awt::ItemEvent aEvent;
1379         aEvent.Source = (::cppu::OWeakObject*)this;
1380         aEvent.Highlighted = sal_False;
1381         aEvent.Selected = pRadioButton->IsChecked();
1382         maItemListeners.itemStateChanged( aEvent );
1383     }
1384 }
1385
1386 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > VCLXRadioButton::getFirstActionListener ()
1387 {
1388     if (!maItemListeners.getLength ())
1389         return ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > ();
1390     return maActionListeners.getElements()[0];
1391 }
1392
1393 //      ----------------------------------------------------
1394 //      class VCLXSpinField
1395 //      ----------------------------------------------------
1396 void VCLXSpinField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1397 {
1398     PushPropertyIds( rIds,
1399                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
1400                      0 );
1401     VCLXEdit::ImplGetPropertyIds( rIds );
1402 }
1403
1404 VCLXSpinField::VCLXSpinField() : maSpinListeners( *this )
1405 {
1406 }
1407
1408 // ::com::sun::star::uno::XInterface
1409 ::com::sun::star::uno::Any VCLXSpinField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1410 {
1411     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1412                                         SAL_STATIC_CAST( ::com::sun::star::awt::XSpinField*, this ) );
1413     return (aRet.hasValue() ? aRet : VCLXEdit::queryInterface( rType ));
1414 }
1415
1416 // ::com::sun::star::lang::XTypeProvider
1417 IMPL_XTYPEPROVIDER_START( VCLXSpinField )
1418     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinField>* ) NULL ),
1419     VCLXEdit::getTypes()
1420 IMPL_XTYPEPROVIDER_END
1421
1422 void VCLXSpinField::addSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1423 {
1424     ::vos::OGuard aGuard( GetMutex() );
1425     maSpinListeners.addInterface( l );
1426 }
1427
1428 void VCLXSpinField::removeSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1429 {
1430     ::vos::OGuard aGuard( GetMutex() );
1431     maSpinListeners.removeInterface( l );
1432 }
1433
1434 void VCLXSpinField::up() throw(::com::sun::star::uno::RuntimeException)
1435 {
1436     ::vos::OGuard aGuard( GetMutex() );
1437
1438     SpinField* pSpinField = (SpinField*) GetWindow();
1439     if ( pSpinField )
1440         pSpinField->Up();
1441 }
1442
1443 void VCLXSpinField::down() throw(::com::sun::star::uno::RuntimeException)
1444 {
1445     ::vos::OGuard aGuard( GetMutex() );
1446
1447     SpinField* pSpinField = (SpinField*) GetWindow();
1448     if ( pSpinField )
1449         pSpinField->Down();
1450 }
1451
1452 void VCLXSpinField::first() throw(::com::sun::star::uno::RuntimeException)
1453 {
1454     ::vos::OGuard aGuard( GetMutex() );
1455
1456     SpinField* pSpinField = (SpinField*) GetWindow();
1457     if ( pSpinField )
1458         pSpinField->First();
1459 }
1460
1461 void VCLXSpinField::last() throw(::com::sun::star::uno::RuntimeException)
1462 {
1463     ::vos::OGuard aGuard( GetMutex() );
1464
1465     SpinField* pSpinField = (SpinField*) GetWindow();
1466     if ( pSpinField )
1467         pSpinField->Last();
1468 }
1469
1470 void VCLXSpinField::enableRepeat( sal_Bool bRepeat ) throw(::com::sun::star::uno::RuntimeException)
1471 {
1472     ::vos::OGuard aGuard( GetMutex() );
1473
1474     Window* pWindow = GetWindow();
1475     if ( pWindow )
1476     {
1477         WinBits nStyle = pWindow->GetStyle();
1478         if ( bRepeat )
1479             nStyle |= WB_REPEAT;
1480         else
1481             nStyle &= ~WB_REPEAT;
1482         pWindow->SetStyle( nStyle );
1483     }
1484 }
1485
1486 void VCLXSpinField::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1487 {
1488     switch ( rVclWindowEvent.GetId() )
1489     {
1490         case VCLEVENT_SPINFIELD_UP:
1491         case VCLEVENT_SPINFIELD_DOWN:
1492         case VCLEVENT_SPINFIELD_FIRST:
1493         case VCLEVENT_SPINFIELD_LAST:
1494         {
1495             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1496                 // since we call listeners below, there is a potential that we will be destroyed
1497                 // in during the listener call. To prevent the resulting crashs, we keep us
1498                 // alive as long as we're here
1499                 // #20178# - 2003-10-01 - fs@openoffice.org
1500
1501             if ( maSpinListeners.getLength() )
1502             {
1503                 ::com::sun::star::awt::SpinEvent aEvent;
1504                 aEvent.Source = (::cppu::OWeakObject*)this;
1505                 switch ( rVclWindowEvent.GetId() )
1506                 {
1507                     case VCLEVENT_SPINFIELD_UP:     maSpinListeners.up( aEvent );
1508                                                     break;
1509                     case VCLEVENT_SPINFIELD_DOWN:   maSpinListeners.down( aEvent );
1510                                                     break;
1511                     case VCLEVENT_SPINFIELD_FIRST:  maSpinListeners.first( aEvent );
1512                                                     break;
1513                     case VCLEVENT_SPINFIELD_LAST:   maSpinListeners.last( aEvent );
1514                                                     break;
1515                 }
1516
1517             }
1518         }
1519         break;
1520
1521         default:
1522             VCLXEdit::ProcessWindowEvent( rVclWindowEvent );
1523             break;
1524     }
1525 }
1526
1527
1528 //      ----------------------------------------------------
1529 //      class VCLXListBox
1530 //      ----------------------------------------------------
1531 void VCLXListBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1532 {
1533     PushPropertyIds( rIds,
1534                      BASEPROPERTY_BACKGROUNDCOLOR,
1535                      BASEPROPERTY_BORDER,
1536                      BASEPROPERTY_BORDERCOLOR,
1537                      BASEPROPERTY_DEFAULTCONTROL,
1538                      BASEPROPERTY_DROPDOWN,
1539                      BASEPROPERTY_ENABLED,
1540                      BASEPROPERTY_ENABLEVISIBLE,
1541                      BASEPROPERTY_FONTDESCRIPTOR,
1542                      BASEPROPERTY_HELPTEXT,
1543                      BASEPROPERTY_HELPURL,
1544                      BASEPROPERTY_LINECOUNT,
1545                      BASEPROPERTY_MULTISELECTION,
1546                      BASEPROPERTY_PRINTABLE,
1547                      BASEPROPERTY_SELECTEDITEMS,
1548                      BASEPROPERTY_STRINGITEMLIST,
1549                      BASEPROPERTY_TABSTOP,
1550                      BASEPROPERTY_READONLY,
1551                      BASEPROPERTY_ALIGN,
1552                      BASEPROPERTY_WRITING_MODE,
1553                      BASEPROPERTY_CONTEXT_WRITING_MODE,
1554                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
1555                      0);
1556     VCLXWindow::ImplGetPropertyIds( rIds );
1557 }
1558
1559
1560 VCLXListBox::VCLXListBox()
1561     : maActionListeners( *this ),
1562       maItemListeners( *this )
1563 {
1564 }
1565
1566 // ::com::sun::star::uno::XInterface
1567 ::com::sun::star::uno::Any VCLXListBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1568 {
1569     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1570                                         SAL_STATIC_CAST( ::com::sun::star::awt::XListBox*, this ),
1571                                         SAL_STATIC_CAST( ::com::sun::star::awt::XTextLayoutConstrains*, this ) );
1572     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
1573 }
1574
1575 // ::com::sun::star::lang::XTypeProvider
1576 IMPL_XTYPEPROVIDER_START( VCLXListBox )
1577     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XListBox>* ) NULL ),
1578     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
1579     VCLXWindow::getTypes()
1580 IMPL_XTYPEPROVIDER_END
1581
1582 void VCLXListBox::dispose() throw(::com::sun::star::uno::RuntimeException)
1583 {
1584     ::vos::OGuard aGuard( GetMutex() );
1585
1586     ::com::sun::star::lang::EventObject aObj;
1587     aObj.Source = (::cppu::OWeakObject*)this;
1588     maItemListeners.disposeAndClear( aObj );
1589     maActionListeners.disposeAndClear( aObj );
1590     VCLXWindow::dispose();
1591 }
1592
1593 void VCLXListBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1594 {
1595     ::vos::OGuard aGuard( GetMutex() );
1596     maItemListeners.addInterface( l );
1597 }
1598
1599 void VCLXListBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1600 {
1601     ::vos::OGuard aGuard( GetMutex() );
1602     maItemListeners.removeInterface( l );
1603 }
1604
1605 void VCLXListBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1606 {
1607     ::vos::OGuard aGuard( GetMutex() );
1608     maActionListeners.addInterface( l );
1609 }
1610
1611 void VCLXListBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
1612 {
1613     ::vos::OGuard aGuard( GetMutex() );
1614     maActionListeners.removeInterface( l );
1615 }
1616
1617 void VCLXListBox::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
1618 {
1619     ::vos::OGuard aGuard( GetMutex() );
1620
1621     ListBox* pBox = (ListBox*) GetWindow();
1622     if ( pBox )
1623         pBox->InsertEntry( aItem, nPos );
1624 }
1625
1626 void VCLXListBox::addItems( const ::com::sun::star::uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
1627 {
1628     ::vos::OGuard aGuard( GetMutex() );
1629
1630     ListBox* pBox = (ListBox*) GetWindow();
1631     if ( pBox )
1632     {
1633         sal_uInt16 nP = nPos;
1634         const ::rtl::OUString* pItems = aItems.getConstArray();
1635         const ::rtl::OUString* pItemsEnd = aItems.getConstArray() + aItems.getLength();
1636         while ( pItems != pItemsEnd )
1637         {
1638             if ( (sal_uInt16)nP == 0xFFFF )
1639             {
1640                 OSL_ENSURE( false, "VCLXListBox::addItems: too many entries!" );
1641                 // skip remaining entries, list cannot hold them, anyway
1642                 break;
1643             }
1644
1645             pBox->InsertEntry( *pItems++, nP++ );
1646         }
1647     }
1648 }
1649
1650 void VCLXListBox::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(::com::sun::star::uno::RuntimeException)
1651 {
1652     ::vos::OGuard aGuard( GetMutex() );
1653
1654     ListBox* pBox = (ListBox*) GetWindow();
1655     if ( pBox )
1656     {
1657         for ( sal_uInt16 n = nCount; n; )
1658             pBox->RemoveEntry( nPos + (--n) );
1659     }
1660 }
1661
1662 sal_Int16 VCLXListBox::getItemCount() throw(::com::sun::star::uno::RuntimeException)
1663 {
1664     ::vos::OGuard aGuard( GetMutex() );
1665
1666     ListBox* pBox = (ListBox*) GetWindow();
1667     return pBox ? pBox->GetEntryCount() : 0;
1668 }
1669
1670 ::rtl::OUString VCLXListBox::getItem( sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
1671 {
1672     ::vos::OGuard aGuard( GetMutex() );
1673
1674     String aItem;
1675     ListBox* pBox = (ListBox*) GetWindow();
1676     if ( pBox )
1677         aItem = pBox->GetEntry( nPos );
1678     return aItem;
1679 }
1680
1681 ::com::sun::star::uno::Sequence< ::rtl::OUString> VCLXListBox::getItems() throw(::com::sun::star::uno::RuntimeException)
1682 {
1683     ::vos::OGuard aGuard( GetMutex() );
1684
1685     ::com::sun::star::uno::Sequence< ::rtl::OUString> aSeq;
1686     ListBox* pBox = (ListBox*) GetWindow();
1687     if ( pBox )
1688     {
1689         sal_uInt16 nEntries = pBox->GetEntryCount();
1690         aSeq = ::com::sun::star::uno::Sequence< ::rtl::OUString>( nEntries );
1691         for ( sal_uInt16 n = nEntries; n; )
1692         {
1693             --n;
1694             aSeq.getArray()[n] = ::rtl::OUString( pBox->GetEntry( n ) );
1695         }
1696     }
1697     return aSeq;
1698 }
1699
1700 sal_Int16 VCLXListBox::getSelectedItemPos() throw(::com::sun::star::uno::RuntimeException)
1701 {
1702     ::vos::OGuard aGuard( GetMutex() );
1703
1704     ListBox* pBox = (ListBox*) GetWindow();
1705     return pBox ? pBox->GetSelectEntryPos() : 0;
1706 }
1707
1708 ::com::sun::star::uno::Sequence<sal_Int16> VCLXListBox::getSelectedItemsPos() throw(::com::sun::star::uno::RuntimeException)
1709 {
1710     ::vos::OGuard aGuard( GetMutex() );
1711
1712     ::com::sun::star::uno::Sequence<sal_Int16> aSeq;
1713     ListBox* pBox = (ListBox*) GetWindow();
1714     if ( pBox )
1715     {
1716         sal_uInt16 nSelEntries = pBox->GetSelectEntryCount();
1717         aSeq = ::com::sun::star::uno::Sequence<sal_Int16>( nSelEntries );
1718         for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
1719             aSeq.getArray()[n] = pBox->GetSelectEntryPos( n );
1720     }
1721     return aSeq;
1722 }
1723
1724 ::rtl::OUString VCLXListBox::getSelectedItem() throw(::com::sun::star::uno::RuntimeException)
1725 {
1726     ::vos::OGuard aGuard( GetMutex() );
1727
1728     String aItem;
1729     ListBox* pBox = (ListBox*) GetWindow();
1730     if ( pBox )
1731         aItem = pBox->GetSelectEntry();
1732     return aItem;
1733 }
1734
1735 ::com::sun::star::uno::Sequence< ::rtl::OUString> VCLXListBox::getSelectedItems() throw(::com::sun::star::uno::RuntimeException)
1736 {
1737     ::vos::OGuard aGuard( GetMutex() );
1738
1739     ::com::sun::star::uno::Sequence< ::rtl::OUString> aSeq;
1740     ListBox* pBox = (ListBox*) GetWindow();
1741     if ( pBox )
1742     {
1743         sal_uInt16 nSelEntries = pBox->GetSelectEntryCount();
1744         aSeq = ::com::sun::star::uno::Sequence< ::rtl::OUString>( nSelEntries );
1745         for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
1746             aSeq.getArray()[n] = ::rtl::OUString( pBox->GetSelectEntry( n ) );
1747     }
1748     return aSeq;
1749 }
1750
1751 void VCLXListBox::selectItemPos( sal_Int16 nPos, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException)
1752 {
1753     ::vos::OGuard aGuard( GetMutex() );
1754
1755     ListBox* pBox = (ListBox*) GetWindow();
1756     if ( pBox && ( pBox->IsEntryPosSelected( nPos ) != bSelect ) )
1757     {
1758         pBox->SelectEntryPos( nPos, bSelect );
1759
1760         // VCL doesn't call select handler after API call.
1761         // ImplCallItemListeners();
1762
1763         // #107218# Call same listeners like VCL would do after user interaction
1764         SetSynthesizingVCLEvent( sal_True );
1765         pBox->Select();
1766         SetSynthesizingVCLEvent( sal_False );
1767     }
1768 }
1769
1770 void VCLXListBox::selectItemsPos( const ::com::sun::star::uno::Sequence<sal_Int16>& aPositions, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException)
1771 {
1772     ::vos::OGuard aGuard( GetMutex() );
1773
1774     ListBox* pBox = (ListBox*) GetWindow();
1775     if ( pBox )
1776     {
1777         BOOL bChanged = FALSE;
1778         for ( sal_uInt16 n = (sal_uInt16)aPositions.getLength(); n; )
1779         {
1780             USHORT nPos = (USHORT) aPositions.getConstArray()[--n];
1781             if ( pBox->IsEntryPosSelected( nPos ) != bSelect )
1782             {
1783                 pBox->SelectEntryPos( nPos, bSelect );
1784                 bChanged = TRUE;
1785             }
1786         }
1787
1788         if ( bChanged )
1789         {
1790             // VCL doesn't call select handler after API call.
1791             // ImplCallItemListeners();
1792
1793             // #107218# Call same listeners like VCL would do after user interaction
1794             SetSynthesizingVCLEvent( sal_True );
1795             pBox->Select();
1796             SetSynthesizingVCLEvent( sal_False );
1797         }
1798     }
1799 }
1800
1801 void VCLXListBox::selectItem( const ::rtl::OUString& rItemText, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException)
1802 {
1803     ::vos::OGuard aGuard( GetMutex() );
1804
1805     ListBox* pBox = (ListBox*) GetWindow();
1806     if ( pBox )
1807     {
1808         String aItemText( rItemText );
1809         selectItemPos( pBox->GetEntryPos( aItemText ), bSelect );
1810     }
1811 }
1812
1813
1814 void VCLXListBox::setDropDownLineCount( sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
1815 {
1816     ::vos::OGuard aGuard( GetMutex() );
1817
1818     ListBox* pBox = (ListBox*) GetWindow();
1819     if ( pBox )
1820         pBox->SetDropDownLineCount( nLines );
1821 }
1822
1823 sal_Int16 VCLXListBox::getDropDownLineCount() throw(::com::sun::star::uno::RuntimeException)
1824 {
1825     ::vos::OGuard aGuard( GetMutex() );
1826
1827     sal_Int16 nLines = 0;
1828     ListBox* pBox = (ListBox*) GetWindow();
1829     if ( pBox )
1830         nLines = pBox->GetDropDownLineCount();
1831     return nLines;
1832 }
1833
1834 sal_Bool VCLXListBox::isMutipleMode() throw(::com::sun::star::uno::RuntimeException)
1835 {
1836     ::vos::OGuard aGuard( GetMutex() );
1837
1838     sal_Bool bMulti = sal_False;
1839     ListBox* pBox = (ListBox*) GetWindow();
1840     if ( pBox )
1841         bMulti = pBox->IsMultiSelectionEnabled();
1842     return bMulti;
1843 }
1844
1845 void VCLXListBox::setMultipleMode( sal_Bool bMulti ) throw(::com::sun::star::uno::RuntimeException)
1846 {
1847     ::vos::OGuard aGuard( GetMutex() );
1848
1849     ListBox* pBox = (ListBox*) GetWindow();
1850     if ( pBox )
1851         pBox->EnableMultiSelection( bMulti );
1852 }
1853
1854 void VCLXListBox::makeVisible( sal_Int16 nEntry ) throw(::com::sun::star::uno::RuntimeException)
1855 {
1856     ::vos::OGuard aGuard( GetMutex() );
1857
1858     ListBox* pBox = (ListBox*) GetWindow();
1859     if ( pBox )
1860         pBox->SetTopEntry( nEntry );
1861 }
1862
1863 void VCLXListBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1864 {
1865     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1866         // since we call listeners below, there is a potential that we will be destroyed
1867         // in during the listener call. To prevent the resulting crashs, we keep us
1868         // alive as long as we're here
1869         // #20178# - 2003-10-01 - fs@openoffice.org
1870
1871     switch ( rVclWindowEvent.GetId() )
1872     {
1873         case VCLEVENT_LISTBOX_SELECT:
1874         {
1875             ListBox* pListBox = (ListBox*)GetWindow();
1876
1877             if( pListBox )
1878             {
1879                 sal_Bool bDropDown = ( pListBox->GetStyle() & WB_DROPDOWN ) ? sal_True : sal_False;
1880                 if ( bDropDown && !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1881                 {
1882                     // Bei DropDown den ActionListener rufen...
1883                     ::com::sun::star::awt::ActionEvent aEvent;
1884                     aEvent.Source = (::cppu::OWeakObject*)this;
1885                     aEvent.ActionCommand = pListBox->GetSelectEntry();
1886                     maActionListeners.actionPerformed( aEvent );
1887                 }
1888
1889                 if ( maItemListeners.getLength() )
1890                 {
1891                     ImplCallItemListeners();
1892                 }
1893             }
1894         }
1895         break;
1896
1897         case VCLEVENT_LISTBOX_DOUBLECLICK:
1898             if ( GetWindow() && maActionListeners.getLength() )
1899             {
1900                 ::com::sun::star::awt::ActionEvent aEvent;
1901                 aEvent.Source = (::cppu::OWeakObject*)this;
1902                 aEvent.ActionCommand = ((ListBox*)GetWindow())->GetSelectEntry();
1903                 maActionListeners.actionPerformed( aEvent );
1904             }
1905             break;
1906
1907         default:
1908             VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
1909             break;
1910     }
1911 }
1912
1913 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXListBox::CreateAccessibleContext()
1914 {
1915     ::vos::OGuard aGuard( GetMutex() );
1916
1917     return getAccessibleFactory().createAccessibleContext( this );
1918 }
1919
1920 void VCLXListBox::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1921 {
1922     ::vos::OGuard aGuard( GetMutex() );
1923
1924     ListBox* pListBox = (ListBox*)GetWindow();
1925     if ( pListBox )
1926     {
1927         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1928         switch ( nPropType )
1929         {
1930             case BASEPROPERTY_READONLY:
1931             {
1932                 sal_Bool b = sal_Bool();
1933                 if ( Value >>= b )
1934                      pListBox->SetReadOnly( b);
1935             }
1936             break;
1937             case BASEPROPERTY_MULTISELECTION:
1938             {
1939                 sal_Bool b = sal_Bool();
1940                 if ( Value >>= b )
1941                      pListBox->EnableMultiSelection( b );
1942             }
1943             break;
1944             case BASEPROPERTY_LINECOUNT:
1945             {
1946                 sal_Int16 n = sal_Int16();
1947                 if ( Value >>= n )
1948                      pListBox->SetDropDownLineCount( n );
1949             }
1950             break;
1951             case BASEPROPERTY_STRINGITEMLIST:
1952             {
1953                 ::com::sun::star::uno::Sequence< ::rtl::OUString> aItems;
1954                 if ( Value >>= aItems )
1955                 {
1956                                         sal_Int16 nElem  = pListBox->GetEntryCount();
1957                     pListBox->Clear();
1958                     addItems( aItems, 0 );
1959                                         if ( aItems.getLength() == 0 && nElem && maItemListeners.getLength() )
1960                                                 ImplCallItemListeners();
1961                 }
1962             }
1963             break;
1964             case BASEPROPERTY_SELECTEDITEMS:
1965             {
1966                 ::com::sun::star::uno::Sequence<sal_Int16> aItems;
1967                 if ( Value >>= aItems )
1968                 {
1969                     for ( sal_uInt16 n = pListBox->GetEntryCount(); n; )
1970                         pListBox->SelectEntryPos( --n, sal_False );
1971
1972                     if ( aItems.getLength() )
1973                     {
1974                         selectItemsPos( aItems, sal_True );
1975                        if ( maItemListeners.getLength() )
1976                            ImplCallItemListeners();
1977                     }
1978                     else
1979                         pListBox->SetNoSelection();
1980
1981                     if ( !pListBox->GetSelectEntryCount() )
1982                         pListBox->SetTopEntry( 0 );
1983                 }
1984             }
1985             break;
1986             default:
1987             {
1988                 VCLXWindow::setProperty( PropertyName, Value );
1989             }
1990         }
1991     }
1992 }
1993
1994 ::com::sun::star::uno::Any VCLXListBox::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
1995 {
1996     ::vos::OGuard aGuard( GetMutex() );
1997
1998     ::com::sun::star::uno::Any aProp;
1999     ListBox* pListBox = (ListBox*)GetWindow();
2000     if ( pListBox )
2001     {
2002         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2003         switch ( nPropType )
2004         {
2005             case BASEPROPERTY_READONLY:
2006             {
2007                  aProp <<= (sal_Bool) pListBox->IsReadOnly();
2008             }
2009             break;
2010             case BASEPROPERTY_MULTISELECTION:
2011             {
2012                  aProp <<= (sal_Bool) pListBox->IsMultiSelectionEnabled();
2013             }
2014             break;
2015             case BASEPROPERTY_LINECOUNT:
2016             {
2017                  aProp <<= (sal_Int16) pListBox->GetDropDownLineCount();
2018             }
2019             break;
2020             case BASEPROPERTY_STRINGITEMLIST:
2021             {
2022                 sal_uInt16 nItems = pListBox->GetEntryCount();
2023                 ::com::sun::star::uno::Sequence< ::rtl::OUString> aSeq( nItems );
2024                 ::rtl::OUString* pStrings = aSeq.getArray();
2025                 for ( sal_uInt16 n = 0; n < nItems; n++ )
2026                     pStrings[n] = pListBox->GetEntry( n );
2027                 aProp <<= aSeq;
2028
2029             }
2030             break;
2031             default:
2032             {
2033                 aProp <<= VCLXWindow::getProperty( PropertyName );
2034             }
2035         }
2036     }
2037     return aProp;
2038 }
2039
2040 ::com::sun::star::awt::Size VCLXListBox::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
2041 {
2042     ::vos::OGuard aGuard( GetMutex() );
2043
2044     Size aSz;
2045     ListBox* pListBox = (ListBox*) GetWindow();
2046     if ( pListBox )
2047         aSz = pListBox->CalcMinimumSize();
2048     return AWTSize(aSz);
2049 }
2050
2051 ::com::sun::star::awt::Size VCLXListBox::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
2052 {
2053     ::vos::OGuard aGuard( GetMutex() );
2054
2055     Size aSz;
2056     ListBox* pListBox = (ListBox*) GetWindow();
2057     if ( pListBox )
2058     {
2059         aSz = pListBox->CalcMinimumSize();
2060         if ( pListBox->GetStyle() & WB_DROPDOWN )
2061             aSz.Height() += 4;
2062     }
2063     return AWTSize(aSz);
2064 }
2065
2066 ::com::sun::star::awt::Size VCLXListBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
2067 {
2068     ::vos::OGuard aGuard( GetMutex() );
2069
2070     Size aSz = VCLSize(rNewSize);
2071     ListBox* pListBox = (ListBox*) GetWindow();
2072     if ( pListBox )
2073         aSz = pListBox->CalcAdjustedSize( aSz );
2074     return AWTSize(aSz);
2075 }
2076
2077 ::com::sun::star::awt::Size VCLXListBox::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
2078 {
2079     ::vos::OGuard aGuard( GetMutex() );
2080
2081     Size aSz;
2082     ListBox* pListBox = (ListBox*) GetWindow();
2083     if ( pListBox )
2084         aSz = pListBox->CalcSize( nCols, nLines );
2085     return AWTSize(aSz);
2086 }
2087
2088 void VCLXListBox::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
2089 {
2090     ::vos::OGuard aGuard( GetMutex() );
2091
2092     nCols = nLines = 0;
2093     ListBox* pListBox = (ListBox*) GetWindow();
2094     if ( pListBox )
2095     {
2096         sal_uInt16 nC, nL;
2097         pListBox->GetMaxVisColumnsAndLines( nC, nL );
2098         nCols = nC;
2099         nLines = nL;
2100     }
2101 }
2102
2103 void VCLXListBox::ImplCallItemListeners()
2104 {
2105     ListBox* pListBox = (ListBox*) GetWindow();
2106     if ( pListBox && maItemListeners.getLength() )
2107     {
2108         ::com::sun::star::awt::ItemEvent aEvent;
2109         aEvent.Source = (::cppu::OWeakObject*)this;
2110         aEvent.Highlighted = sal_False;
2111
2112         // Bei Mehrfachselektion 0xFFFF, sonst die ID
2113         aEvent.Selected = (pListBox->GetSelectEntryCount() == 1 ) ? pListBox->GetSelectEntryPos() : 0xFFFF;
2114
2115         maItemListeners.itemStateChanged( aEvent );
2116     }
2117 }
2118
2119
2120 //      ----------------------------------------------------
2121 //      class VCLXMessageBox
2122 //      ----------------------------------------------------
2123
2124 void VCLXMessageBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2125 {
2126     VCLXTopWindow::ImplGetPropertyIds( rIds );
2127 }
2128
2129 VCLXMessageBox::VCLXMessageBox()
2130 {
2131 }
2132
2133 VCLXMessageBox::~VCLXMessageBox()
2134 {
2135 }
2136
2137 // ::com::sun::star::uno::XInterface
2138 ::com::sun::star::uno::Any VCLXMessageBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2139 {
2140     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2141                                         SAL_STATIC_CAST( ::com::sun::star::awt::XMessageBox*, this ) );
2142     return (aRet.hasValue() ? aRet : VCLXTopWindow::queryInterface( rType ));
2143 }
2144
2145 // ::com::sun::star::lang::XTypeProvider
2146 IMPL_XTYPEPROVIDER_START( VCLXMessageBox )
2147     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMessageBox>* ) NULL ),
2148     VCLXTopWindow::getTypes()
2149 IMPL_XTYPEPROVIDER_END
2150
2151 void VCLXMessageBox::setCaptionText( const ::rtl::OUString& rText ) throw(::com::sun::star::uno::RuntimeException)
2152 {
2153     ::vos::OGuard aGuard( GetMutex() );
2154
2155     Window* pWindow = GetWindow();
2156     if ( pWindow )
2157         pWindow->SetText( rText );
2158 }
2159
2160 ::rtl::OUString VCLXMessageBox::getCaptionText() throw(::com::sun::star::uno::RuntimeException)
2161 {
2162     ::vos::OGuard aGuard( GetMutex() );
2163
2164     String aText;
2165     Window* pWindow = GetWindow();
2166     if ( pWindow )
2167         aText = pWindow->GetText();
2168     return aText;
2169 }
2170
2171 void VCLXMessageBox::setMessageText( const ::rtl::OUString& rText ) throw(::com::sun::star::uno::RuntimeException)
2172 {
2173     ::vos::OGuard aGuard( GetMutex() );
2174
2175     MessBox* pBox = (MessBox*)GetWindow();
2176     if ( pBox )
2177         pBox->SetMessText( rText );
2178 }
2179
2180 ::rtl::OUString VCLXMessageBox::getMessageText() throw(::com::sun::star::uno::RuntimeException)
2181 {
2182     ::vos::OGuard aGuard( GetMutex() );
2183
2184     ::rtl::OUString aText;
2185     MessBox* pBox = (MessBox*)GetWindow();
2186     if ( pBox )
2187         aText = pBox->GetMessText();
2188     return aText;
2189 }
2190
2191 sal_Int16 VCLXMessageBox::execute() throw(::com::sun::star::uno::RuntimeException)
2192 {
2193     ::vos::OGuard aGuard( GetMutex() );
2194
2195     MessBox* pBox = (MessBox*)GetWindow();
2196     return pBox ? pBox->Execute() : 0;
2197 }
2198
2199 ::com::sun::star::awt::Size SAL_CALL VCLXMessageBox::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
2200 {
2201     ::vos::OGuard aGuard( GetMutex() );
2202     return ::com::sun::star::awt::Size( 250, 100 );
2203 }
2204
2205 //      ----------------------------------------------------
2206 //      class VCLXDialog
2207 //      ----------------------------------------------------
2208 void VCLXDialog::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2209 {
2210     VCLXTopWindow::ImplGetPropertyIds( rIds );
2211 }
2212
2213 VCLXDialog::VCLXDialog()
2214 {
2215 }
2216
2217 VCLXDialog::~VCLXDialog()
2218 {
2219 #ifndef __SUNPRO_CC
2220     OSL_TRACE ("%s", __FUNCTION__);
2221 #endif
2222 }
2223
2224 // ::com::sun::star::uno::XInterface
2225 ::com::sun::star::uno::Any VCLXDialog::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2226 {
2227     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2228                                                                                 SAL_STATIC_CAST( ::com::sun::star::document::XVbaMethodParameter*, this ), //liuchen 2009-6-23
2229                                         SAL_STATIC_CAST( ::com::sun::star::awt::XDialog*, this ) );
2230     return (aRet.hasValue() ? aRet : VCLXTopWindow::queryInterface( rType ));
2231 }
2232
2233 // ::com::sun::star::lang::XTypeProvider
2234 IMPL_XTYPEPROVIDER_START( VCLXDialog )
2235         getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::document::XVbaMethodParameter>* ) NULL ), //liuchen 2009-6-23
2236     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDialog>* ) NULL ),
2237     VCLXTopWindow::getTypes()
2238 IMPL_XTYPEPROVIDER_END
2239
2240 void VCLXDialog::setTitle( const ::rtl::OUString& Title ) throw(::com::sun::star::uno::RuntimeException)
2241 {
2242     ::vos::OGuard aGuard( GetMutex() );
2243
2244     Window* pWindow = GetWindow();
2245     if ( pWindow )
2246         pWindow->SetText( Title );
2247 }
2248
2249 ::rtl::OUString VCLXDialog::getTitle() throw(::com::sun::star::uno::RuntimeException)
2250 {
2251     ::vos::OGuard aGuard( GetMutex() );
2252
2253     ::rtl::OUString aTitle;
2254     Window* pWindow = GetWindow();
2255     if ( pWindow )
2256         aTitle = pWindow->GetText();
2257     return aTitle;
2258 }
2259
2260 sal_Int16 VCLXDialog::execute() throw(::com::sun::star::uno::RuntimeException)
2261 {
2262     ::vos::OGuard aGuard( GetMutex() );
2263
2264     sal_Int16 nRet = 0;
2265     if ( GetWindow() )
2266     {
2267         Dialog* pDlg = (Dialog*) GetWindow();
2268         Window* pParent = pDlg->GetWindow( WINDOW_PARENTOVERLAP );
2269         Window* pOldParent = NULL;
2270         if ( pParent && !pParent->IsReallyVisible() )
2271         {
2272             pOldParent = pDlg->GetParent();
2273             Window* pFrame = pDlg->GetWindow( WINDOW_FRAME );
2274             if( pFrame != pDlg )
2275                 pDlg->SetParent( pFrame );
2276         }
2277         nRet = pDlg->Execute();
2278         if ( pOldParent )
2279             pDlg->SetParent( pOldParent );
2280     }
2281     return nRet;
2282 }
2283
2284 void VCLXDialog::endExecute() throw(::com::sun::star::uno::RuntimeException)
2285 {
2286     ::vos::OGuard aGuard( GetMutex() );
2287
2288     Dialog* pDlg = (Dialog*) GetWindow();
2289     if ( pDlg )
2290         pDlg->EndDialog( 0 );
2291 }
2292
2293 void SAL_CALL VCLXDialog::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException)
2294 {
2295     ::vos::OGuard aGuard( GetMutex() );
2296     Window* pWindow = GetWindow();
2297
2298     if ( pWindow )
2299     {
2300         OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
2301         if ( !pDev )
2302             pDev = pWindow->GetParent();
2303
2304         Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
2305         Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
2306
2307         pWindow->Draw( pDev, aPos, aSize, WINDOW_DRAW_NOCONTROLS );
2308     }
2309 }
2310
2311 ::com::sun::star::awt::DeviceInfo VCLXDialog::getInfo() throw(::com::sun::star::uno::RuntimeException)
2312 {
2313     ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
2314
2315     ::vos::OGuard aGuard( GetMutex() );
2316     Dialog* pDlg = (Dialog*) GetWindow();
2317     if ( pDlg )
2318         pDlg->GetDrawWindowBorder( aInfo.LeftInset, aInfo.TopInset, aInfo.RightInset, aInfo.BottomInset );
2319
2320     return aInfo;
2321 }
2322
2323 //liuchen 2009-7-22
2324 // ::com::sun::star::document::XVbaMethodParameter
2325 void SAL_CALL VCLXDialog::setVbaMethodParameter(
2326         const ::rtl::OUString& PropertyName,
2327         const ::com::sun::star::uno::Any& Value )
2328 throw(::com::sun::star::uno::RuntimeException)
2329 {
2330         if (rtl::OUString::createFromAscii( "Cancel" ) == PropertyName)
2331         {
2332                 ::vos::OGuard aGuard( GetMutex() );
2333                 if ( GetWindow() )
2334                 {
2335                         sal_Int8 nCancel;
2336                         Value >>= nCancel;
2337
2338                         Dialog* pDlg = (Dialog*) GetWindow();
2339                         pDlg->SetCloseFlag(nCancel);
2340                 }
2341         }
2342 }
2343
2344 ::com::sun::star::uno::Any SAL_CALL VCLXDialog::getVbaMethodParameter(
2345         const ::rtl::OUString& PropertyName )
2346 throw(::com::sun::star::uno::RuntimeException)
2347 {
2348         ::vos::OGuard aGuard( GetMutex() );
2349
2350         ::com::sun::star::uno::Any aRet;
2351         return aRet;
2352 }
2353 //liuchen 2009-7-22
2354
2355
2356
2357
2358 void SAL_CALL VCLXDialog::setProperty(
2359     const ::rtl::OUString& PropertyName,
2360     const ::com::sun::star::uno::Any& Value )
2361 throw(::com::sun::star::uno::RuntimeException)
2362 {
2363     ::vos::OGuard aGuard( GetMutex() );
2364
2365     Dialog* pDialog = (Dialog*)GetWindow();
2366     if ( pDialog )
2367     {
2368         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2369
2370         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2371         switch ( nPropType )
2372         {
2373             case BASEPROPERTY_GRAPHIC:
2374             {
2375                 Reference< XGraphic > xGraphic;
2376                 if (( Value >>= xGraphic ) && xGraphic.is() )
2377                 {
2378                     Image aImage( xGraphic );
2379
2380                     Wallpaper aWallpaper( aImage.GetBitmapEx());
2381                     aWallpaper.SetStyle( WALLPAPER_SCALE );
2382                     pDialog->SetBackground( aWallpaper );
2383                 }
2384                 else if ( bVoid || !xGraphic.is() )
2385                 {
2386                     Color aColor = pDialog->GetControlBackground().GetColor();
2387                     if ( aColor == COL_AUTO )
2388                         aColor = pDialog->GetSettings().GetStyleSettings().GetDialogColor();
2389
2390                     Wallpaper aWallpaper( aColor );
2391                     pDialog->SetBackground( aWallpaper );
2392                 }
2393             }
2394             break;
2395
2396             default:
2397             {
2398                 VCLXWindow::setProperty( PropertyName, Value );
2399             }
2400         }
2401     }
2402 }
2403
2404 //      ----------------------------------------------------
2405 //      class VCLXTabPage
2406 //      ----------------------------------------------------
2407 VCLXTabPage::VCLXTabPage()
2408 {
2409 }
2410
2411 VCLXTabPage::~VCLXTabPage()
2412 {
2413 }
2414
2415 ::com::sun::star::uno::Any SAL_CALL VCLXTabPage::queryInterface(const ::com::sun::star::uno::Type & rType )
2416 throw(::com::sun::star::uno::RuntimeException)
2417 {
2418     return VCLXContainer::queryInterface( rType );
2419 }
2420
2421 // ::com::sun::star::lang::XTypeProvider
2422 IMPL_XTYPEPROVIDER_START( VCLXTabPage )
2423     VCLXContainer::getTypes()
2424 IMPL_XTYPEPROVIDER_END
2425
2426 // ::com::sun::star::awt::XView
2427 void SAL_CALL VCLXTabPage::draw( sal_Int32 nX, sal_Int32 nY )
2428 throw(::com::sun::star::uno::RuntimeException)
2429 {
2430     ::vos::OGuard aGuard( GetMutex() );
2431     Window* pWindow = GetWindow();
2432
2433     if ( pWindow )
2434     {
2435         OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
2436         if ( !pDev )
2437             pDev = pWindow->GetParent();
2438
2439         Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
2440         Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
2441
2442         pWindow->Draw( pDev, aPos, aSize, WINDOW_DRAW_NOCONTROLS );
2443     }
2444 }
2445
2446 // ::com::sun::star::awt::XDevice,
2447 ::com::sun::star::awt::DeviceInfo SAL_CALL VCLXTabPage::getInfo()
2448 throw(::com::sun::star::uno::RuntimeException)
2449 {
2450     ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
2451     return aInfo;
2452 }
2453
2454 void SAL_CALL VCLXTabPage::setProperty(
2455     const ::rtl::OUString& PropertyName,
2456     const ::com::sun::star::uno::Any& Value )
2457 throw(::com::sun::star::uno::RuntimeException)
2458 {
2459     ::vos::OGuard aGuard( GetMutex() );
2460
2461     TabPage* pTabPage = (TabPage*)GetWindow();
2462     if ( pTabPage )
2463     {
2464         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2465
2466         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2467         switch ( nPropType )
2468         {
2469             case BASEPROPERTY_GRAPHIC:
2470             {
2471                 Reference< XGraphic > xGraphic;
2472                 if (( Value >>= xGraphic ) && xGraphic.is() )
2473                 {
2474                     Image aImage( xGraphic );
2475
2476                     Wallpaper aWallpaper( aImage.GetBitmapEx());
2477                     aWallpaper.SetStyle( WALLPAPER_SCALE );
2478                     pTabPage->SetBackground( aWallpaper );
2479                 }
2480                 else if ( bVoid || !xGraphic.is() )
2481                 {
2482                     Color aColor = pTabPage->GetControlBackground().GetColor();
2483                     if ( aColor == COL_AUTO )
2484                         aColor = pTabPage->GetSettings().GetStyleSettings().GetDialogColor();
2485
2486                     Wallpaper aWallpaper( aColor );
2487                     pTabPage->SetBackground( aWallpaper );
2488                 }
2489             }
2490             break;
2491
2492             default:
2493             {
2494                 VCLXContainer::setProperty( PropertyName, Value );
2495             }
2496         }
2497     }
2498 }
2499
2500 //      ----------------------------------------------------
2501 //  class VCLXFixedHyperlink
2502 //      ----------------------------------------------------
2503 VCLXFixedHyperlink::VCLXFixedHyperlink() :
2504
2505     maActionListeners( *this )
2506
2507 {
2508 }
2509
2510 VCLXFixedHyperlink::~VCLXFixedHyperlink()
2511 {
2512 }
2513
2514 // ::com::sun::star::uno::XInterface
2515 ::com::sun::star::uno::Any VCLXFixedHyperlink::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2516 {
2517     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2518                                         SAL_STATIC_CAST( ::com::sun::star::awt::XFixedHyperlink*, this ) );
2519     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2520 }
2521
2522 void VCLXFixedHyperlink::dispose() throw(::com::sun::star::uno::RuntimeException)
2523 {
2524         ::vos::OGuard aGuard( GetMutex() );
2525
2526         ::com::sun::star::lang::EventObject aObj;
2527         aObj.Source = (::cppu::OWeakObject*)this;
2528         maActionListeners.disposeAndClear( aObj );
2529         VCLXWindow::dispose();
2530 }
2531
2532 // ::com::sun::star::lang::XTypeProvider
2533 IMPL_XTYPEPROVIDER_START( VCLXFixedHyperlink )
2534     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFixedHyperlink>* ) NULL ),
2535     VCLXWindow::getTypes()
2536 IMPL_XTYPEPROVIDER_END
2537
2538 void VCLXFixedHyperlink::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
2539 {
2540     switch ( rVclWindowEvent.GetId() )
2541     {
2542         case VCLEVENT_BUTTON_CLICK:
2543         {
2544             if ( maActionListeners.getLength() )
2545             {
2546                 ::com::sun::star::awt::ActionEvent aEvent;
2547                 aEvent.Source = (::cppu::OWeakObject*)this;
2548                 maActionListeners.actionPerformed( aEvent );
2549             }
2550             else
2551             {
2552                 // open the URL
2553                 ::rtl::OUString sURL;
2554                 ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2555                 if ( pBase )
2556                     sURL = pBase->GetURL();
2557                 Reference< ::com::sun::star::system::XSystemShellExecute > xSystemShellExecute(
2558                     ::comphelper::getProcessServiceFactory()->createInstance(
2559                         ::rtl::OUString::createFromAscii( "com.sun.star.system.SystemShellExecute" )), uno::UNO_QUERY );
2560                 if ( sURL.getLength() > 0 && xSystemShellExecute.is() )
2561                 {
2562                     try
2563                     {
2564                         // start browser
2565                         xSystemShellExecute->execute(
2566                             sURL, ::rtl::OUString(), ::com::sun::star::system::SystemShellExecuteFlags::DEFAULTS );
2567                     }
2568                     catch( uno::Exception& )
2569                     {
2570                     }
2571                 }
2572             }
2573         }
2574
2575         default:
2576             VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
2577             break;
2578     }
2579 }
2580
2581 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXFixedHyperlink::CreateAccessibleContext()
2582 {
2583     return getAccessibleFactory().createAccessibleContext( this );
2584 }
2585
2586 void VCLXFixedHyperlink::setText( const ::rtl::OUString& Text ) throw(::com::sun::star::uno::RuntimeException)
2587 {
2588     ::vos::OGuard aGuard( GetMutex() );
2589
2590     ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2591     if ( pBase )
2592         pBase->SetDescription( Text );
2593 }
2594
2595 ::rtl::OUString VCLXFixedHyperlink::getText() throw(::com::sun::star::uno::RuntimeException)
2596 {
2597     ::vos::OGuard aGuard( GetMutex() );
2598
2599     ::rtl::OUString aText;
2600     Window* pWindow = GetWindow();
2601     if ( pWindow )
2602         aText = pWindow->GetText();
2603     return aText;
2604 }
2605
2606 void VCLXFixedHyperlink::setURL( const ::rtl::OUString& URL ) throw(::com::sun::star::uno::RuntimeException)
2607 {
2608     ::vos::OGuard aGuard( GetMutex() );
2609
2610     ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2611     if ( pBase )
2612         pBase->SetURL( URL );
2613 }
2614
2615 ::rtl::OUString VCLXFixedHyperlink::getURL(  ) throw(::com::sun::star::uno::RuntimeException)
2616 {
2617     ::vos::OGuard aGuard( GetMutex() );
2618
2619     ::rtl::OUString aText;
2620     ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2621     if ( pBase )
2622         aText = pBase->GetURL();
2623     return aText;
2624 }
2625
2626 void VCLXFixedHyperlink::setAlignment( short nAlign ) throw(::com::sun::star::uno::RuntimeException)
2627 {
2628     ::vos::OGuard aGuard( GetMutex() );
2629
2630     Window* pWindow = GetWindow();
2631     if ( pWindow )
2632     {
2633         WinBits nNewBits = 0;
2634         if ( nAlign == ::com::sun::star::awt::TextAlign::LEFT )
2635             nNewBits = WB_LEFT;
2636         else if ( nAlign == ::com::sun::star::awt::TextAlign::CENTER )
2637             nNewBits = WB_CENTER;
2638         else
2639             nNewBits = WB_RIGHT;
2640
2641         WinBits nStyle = pWindow->GetStyle();
2642         nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
2643         pWindow->SetStyle( nStyle | nNewBits );
2644     }
2645 }
2646
2647 short VCLXFixedHyperlink::getAlignment() throw(::com::sun::star::uno::RuntimeException)
2648 {
2649     ::vos::OGuard aGuard( GetMutex() );
2650
2651     short nAlign = 0;
2652     Window* pWindow = GetWindow();
2653     if ( pWindow )
2654     {
2655         WinBits nStyle = pWindow->GetStyle();
2656         if ( nStyle & WB_LEFT )
2657             nAlign = ::com::sun::star::awt::TextAlign::LEFT;
2658         else if ( nStyle & WB_CENTER )
2659             nAlign = ::com::sun::star::awt::TextAlign::CENTER;
2660         else
2661             nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
2662     }
2663     return nAlign;
2664 }
2665
2666 void VCLXFixedHyperlink::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l  )throw(::com::sun::star::uno::RuntimeException)
2667 {
2668         ::vos::OGuard aGuard( GetMutex() );
2669         maActionListeners.addInterface( l );
2670 }
2671
2672 void VCLXFixedHyperlink::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
2673 {
2674         ::vos::OGuard aGuard( GetMutex() );
2675         maActionListeners.removeInterface( l );
2676 }
2677
2678 ::com::sun::star::awt::Size VCLXFixedHyperlink::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
2679 {
2680     ::vos::OGuard aGuard( GetMutex() );
2681
2682     Size aSz;
2683     FixedText* pFixedText = (FixedText*)GetWindow();
2684     if ( pFixedText )
2685         aSz = pFixedText->CalcMinimumSize();
2686     return AWTSize(aSz);
2687 }
2688
2689 ::com::sun::star::awt::Size VCLXFixedHyperlink::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
2690 {
2691     return getMinimumSize();
2692 }
2693
2694 ::com::sun::star::awt::Size VCLXFixedHyperlink::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
2695 {
2696     ::vos::OGuard aGuard( GetMutex() );
2697
2698     ::com::sun::star::awt::Size aSz = rNewSize;
2699     ::com::sun::star::awt::Size aMinSz = getMinimumSize();
2700     if ( aSz.Height != aMinSz.Height )
2701         aSz.Height = aMinSz.Height;
2702
2703     return aSz;
2704 }
2705
2706 void VCLXFixedHyperlink::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
2707 {
2708     ::vos::OGuard aGuard( GetMutex() );
2709
2710     ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2711     if ( pBase )
2712     {
2713         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2714         switch ( nPropType )
2715         {
2716             case BASEPROPERTY_LABEL:
2717             {
2718                 ::rtl::OUString sNewLabel;
2719                 if ( Value >>= sNewLabel )
2720                     pBase->SetDescription( sNewLabel );
2721                 break;
2722             }
2723
2724             case BASEPROPERTY_URL:
2725             {
2726                 ::rtl::OUString sNewURL;
2727                 if ( Value >>= sNewURL )
2728                     pBase->SetURL( sNewURL );
2729                 break;
2730             }
2731
2732             default:
2733             {
2734                 VCLXWindow::setProperty( PropertyName, Value );
2735             }
2736         }
2737     }
2738 }
2739
2740 ::com::sun::star::uno::Any VCLXFixedHyperlink::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
2741 {
2742     ::vos::OGuard aGuard( GetMutex() );
2743
2744     ::com::sun::star::uno::Any aProp;
2745     ::toolkit::FixedHyperlinkBase* pBase = (::toolkit::FixedHyperlinkBase*)GetWindow();
2746     if ( pBase )
2747     {
2748         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2749         switch ( nPropType )
2750         {
2751             case BASEPROPERTY_URL:
2752             {
2753                 aProp = makeAny( ::rtl::OUString( pBase->GetURL() ) );
2754                 break;
2755             }
2756
2757             default:
2758             {
2759                 aProp <<= VCLXWindow::getProperty( PropertyName );
2760             }
2761         }
2762     }
2763     return aProp;
2764 }
2765
2766 void VCLXFixedHyperlink::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2767 {
2768     PushPropertyIds( rIds,
2769                      BASEPROPERTY_ALIGN,
2770                      BASEPROPERTY_BACKGROUNDCOLOR,
2771                      BASEPROPERTY_BORDER,
2772                      BASEPROPERTY_BORDERCOLOR,
2773                      BASEPROPERTY_DEFAULTCONTROL,
2774                      BASEPROPERTY_ENABLED,
2775                      BASEPROPERTY_ENABLEVISIBLE,
2776                      BASEPROPERTY_FONTDESCRIPTOR,
2777                      BASEPROPERTY_HELPTEXT,
2778                      BASEPROPERTY_HELPURL,
2779                      BASEPROPERTY_LABEL,
2780                      BASEPROPERTY_MULTILINE,
2781                      BASEPROPERTY_NOLABEL,
2782                      BASEPROPERTY_PRINTABLE,
2783                      BASEPROPERTY_TABSTOP,
2784                      BASEPROPERTY_VERTICALALIGN,
2785                      BASEPROPERTY_URL,
2786                      BASEPROPERTY_WRITING_MODE,
2787                      BASEPROPERTY_CONTEXT_WRITING_MODE,
2788                      0);
2789     VCLXWindow::ImplGetPropertyIds( rIds );
2790 }
2791
2792 //  ----------------------------------------------------
2793 //  class VCLXFixedText
2794 //  ----------------------------------------------------
2795 void VCLXFixedText::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2796 {
2797     PushPropertyIds( rIds,
2798                      BASEPROPERTY_ALIGN,
2799                      BASEPROPERTY_BACKGROUNDCOLOR,
2800                      BASEPROPERTY_BORDER,
2801                      BASEPROPERTY_BORDERCOLOR,
2802                      BASEPROPERTY_DEFAULTCONTROL,
2803                      BASEPROPERTY_ENABLED,
2804                      BASEPROPERTY_ENABLEVISIBLE,
2805                      BASEPROPERTY_FONTDESCRIPTOR,
2806                      BASEPROPERTY_HELPTEXT,
2807                      BASEPROPERTY_HELPURL,
2808                      BASEPROPERTY_LABEL,
2809                      BASEPROPERTY_MULTILINE,
2810                      BASEPROPERTY_NOLABEL,
2811                      BASEPROPERTY_PRINTABLE,
2812                      BASEPROPERTY_TABSTOP,
2813                      BASEPROPERTY_VERTICALALIGN,
2814                      BASEPROPERTY_WRITING_MODE,
2815                      BASEPROPERTY_CONTEXT_WRITING_MODE,
2816                      0);
2817     VCLXWindow::ImplGetPropertyIds( rIds );
2818 }
2819
2820 VCLXFixedText::VCLXFixedText()
2821 {
2822 }
2823
2824 VCLXFixedText::~VCLXFixedText()
2825 {
2826 }
2827
2828 // ::com::sun::star::uno::XInterface
2829 ::com::sun::star::uno::Any VCLXFixedText::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2830 {
2831     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2832                                         SAL_STATIC_CAST( ::com::sun::star::awt::XFixedText*, this ) );
2833     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2834 }
2835
2836 // ::com::sun::star::lang::XTypeProvider
2837 IMPL_XTYPEPROVIDER_START( VCLXFixedText )
2838     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFixedText>* ) NULL ),
2839     VCLXWindow::getTypes()
2840 IMPL_XTYPEPROVIDER_END
2841
2842 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXFixedText::CreateAccessibleContext()
2843 {
2844     return getAccessibleFactory().createAccessibleContext( this );
2845 }
2846
2847 void VCLXFixedText::setText( const ::rtl::OUString& Text ) throw(::com::sun::star::uno::RuntimeException)
2848 {
2849     ::vos::OGuard aGuard( GetMutex() );
2850
2851     Window* pWindow = GetWindow();
2852     if ( pWindow )
2853         pWindow->SetText( Text );
2854 }
2855
2856 ::rtl::OUString VCLXFixedText::getText() throw(::com::sun::star::uno::RuntimeException)
2857 {
2858     ::vos::OGuard aGuard( GetMutex() );
2859
2860     ::rtl::OUString aText;
2861     Window* pWindow = GetWindow();
2862     if ( pWindow )
2863         aText = pWindow->GetText();
2864     return aText;
2865 }
2866
2867 void VCLXFixedText::setAlignment( short nAlign ) throw(::com::sun::star::uno::RuntimeException)
2868 {
2869     ::vos::OGuard aGuard( GetMutex() );
2870
2871     Window* pWindow = GetWindow();
2872     if ( pWindow )
2873     {
2874         WinBits nNewBits = 0;
2875         if ( nAlign == ::com::sun::star::awt::TextAlign::LEFT )
2876             nNewBits = WB_LEFT;
2877         else if ( nAlign == ::com::sun::star::awt::TextAlign::CENTER )
2878             nNewBits = WB_CENTER;
2879         else
2880             nNewBits = WB_RIGHT;
2881
2882         WinBits nStyle = pWindow->GetStyle();
2883         nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
2884         pWindow->SetStyle( nStyle | nNewBits );
2885     }
2886 }
2887
2888 short VCLXFixedText::getAlignment() throw(::com::sun::star::uno::RuntimeException)
2889 {
2890     ::vos::OGuard aGuard( GetMutex() );
2891
2892     short nAlign = 0;
2893     Window* pWindow = GetWindow();
2894     if ( pWindow )
2895     {
2896         WinBits nStyle = pWindow->GetStyle();
2897         if ( nStyle & WB_LEFT )
2898             nAlign = ::com::sun::star::awt::TextAlign::LEFT;
2899         else if ( nStyle & WB_CENTER )
2900             nAlign = ::com::sun::star::awt::TextAlign::CENTER;
2901         else
2902             nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
2903     }
2904     return nAlign;
2905 }
2906
2907 ::com::sun::star::awt::Size VCLXFixedText::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
2908 {
2909     ::vos::OGuard aGuard( GetMutex() );
2910
2911     Size aSz;
2912     FixedText* pFixedText = (FixedText*)GetWindow();
2913     if ( pFixedText )
2914         aSz = pFixedText->CalcMinimumSize();
2915     return AWTSize(aSz);
2916 }
2917
2918 ::com::sun::star::awt::Size VCLXFixedText::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
2919 {
2920     return getMinimumSize();
2921 }
2922
2923 ::com::sun::star::awt::Size VCLXFixedText::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
2924 {
2925     ::vos::OGuard aGuard( GetMutex() );
2926
2927     ::com::sun::star::awt::Size aSz = rNewSize;
2928     ::com::sun::star::awt::Size aMinSz = getMinimumSize();
2929     if ( aSz.Height != aMinSz.Height )
2930         aSz.Height = aMinSz.Height;
2931
2932     return aSz;
2933 }
2934
2935 //      ----------------------------------------------------
2936 //      class VCLXScrollBar
2937 //      ----------------------------------------------------
2938 void VCLXScrollBar::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2939 {
2940     PushPropertyIds( rIds,
2941                      BASEPROPERTY_BACKGROUNDCOLOR,
2942                      BASEPROPERTY_BLOCKINCREMENT,
2943                      BASEPROPERTY_BORDER,
2944                      BASEPROPERTY_BORDERCOLOR,
2945                      BASEPROPERTY_DEFAULTCONTROL,
2946                      BASEPROPERTY_ENABLED,
2947                      BASEPROPERTY_ENABLEVISIBLE,
2948                      BASEPROPERTY_HELPTEXT,
2949                      BASEPROPERTY_HELPURL,
2950                      BASEPROPERTY_LINEINCREMENT,
2951                      BASEPROPERTY_LIVE_SCROLL,
2952                      BASEPROPERTY_ORIENTATION,
2953                      BASEPROPERTY_PRINTABLE,
2954                      BASEPROPERTY_REPEAT_DELAY,
2955                      BASEPROPERTY_SCROLLVALUE,
2956                      BASEPROPERTY_SCROLLVALUE_MAX,
2957                      BASEPROPERTY_SCROLLVALUE_MIN,
2958                      BASEPROPERTY_SYMBOL_COLOR,
2959                      BASEPROPERTY_TABSTOP,
2960                      BASEPROPERTY_VISIBLESIZE,
2961                      BASEPROPERTY_WRITING_MODE,
2962                      BASEPROPERTY_CONTEXT_WRITING_MODE,
2963                      0);
2964     VCLXWindow::ImplGetPropertyIds( rIds );
2965 }
2966
2967 VCLXScrollBar::VCLXScrollBar() : maAdjustmentListeners( *this )
2968 {
2969 }
2970
2971 // ::com::sun::star::uno::XInterface
2972 ::com::sun::star::uno::Any VCLXScrollBar::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2973 {
2974     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2975                                         SAL_STATIC_CAST( ::com::sun::star::awt::XScrollBar*, this ) );
2976     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2977 }
2978
2979 // ::com::sun::star::lang::XTypeProvider
2980 IMPL_XTYPEPROVIDER_START( VCLXScrollBar )
2981     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XScrollBar>* ) NULL ),
2982     VCLXWindow::getTypes()
2983 IMPL_XTYPEPROVIDER_END
2984
2985 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXScrollBar::CreateAccessibleContext()
2986 {
2987     return getAccessibleFactory().createAccessibleContext( this );
2988 }
2989
2990 // ::com::sun::star::lang::XComponent
2991 void VCLXScrollBar::dispose() throw(::com::sun::star::uno::RuntimeException)
2992 {
2993     ::vos::OGuard aGuard( GetMutex() );
2994
2995     ::com::sun::star::lang::EventObject aObj;
2996     aObj.Source = (::cppu::OWeakObject*)this;
2997     maAdjustmentListeners.disposeAndClear( aObj );
2998     VCLXWindow::dispose();
2999 }
3000
3001 // ::com::sun::star::awt::XScrollbar
3002 void VCLXScrollBar::addAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3003 {
3004     ::vos::OGuard aGuard( GetMutex() );
3005     maAdjustmentListeners.addInterface( l );
3006 }
3007
3008 void VCLXScrollBar::removeAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3009 {
3010     ::vos::OGuard aGuard( GetMutex() );
3011     maAdjustmentListeners.removeInterface( l );
3012 }
3013
3014 void VCLXScrollBar::setValue( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3015 {
3016     ::vos::OGuard aGuard( GetMutex() );
3017
3018     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3019     if ( pScrollBar )
3020         pScrollBar->DoScroll( n );
3021 }
3022
3023 void VCLXScrollBar::setValues( sal_Int32 nValue, sal_Int32 nVisible, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException)
3024 {
3025     ::vos::OGuard aGuard( GetMutex() );
3026
3027     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3028     if ( pScrollBar )
3029     {
3030         pScrollBar->SetVisibleSize( nVisible );
3031         pScrollBar->SetRangeMax( nMax );
3032         pScrollBar->DoScroll( nValue );
3033     }
3034 }
3035
3036 sal_Int32 VCLXScrollBar::getValue() throw(::com::sun::star::uno::RuntimeException)
3037 {
3038     ::vos::OGuard aGuard( GetMutex() );
3039
3040     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3041     return pScrollBar ? pScrollBar->GetThumbPos() : 0;
3042 }
3043
3044 void VCLXScrollBar::setMaximum( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3045 {
3046     ::vos::OGuard aGuard( GetMutex() );
3047
3048     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3049     if ( pScrollBar )
3050         pScrollBar->SetRangeMax( n );
3051 }
3052
3053 sal_Int32 VCLXScrollBar::getMaximum() throw(::com::sun::star::uno::RuntimeException)
3054 {
3055     ::vos::OGuard aGuard( GetMutex() );
3056
3057     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3058     return pScrollBar ? pScrollBar->GetRangeMax() : 0;
3059 }
3060
3061 void VCLXScrollBar::setMinimum( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3062 {
3063     ::vos::OGuard aGuard( GetMutex() );
3064
3065     ScrollBar* pScrollBar = static_cast< ScrollBar* >( GetWindow() );
3066     if ( pScrollBar )
3067         pScrollBar->SetRangeMin( n );
3068 }
3069
3070 sal_Int32 VCLXScrollBar::getMinimum() throw(::com::sun::star::uno::RuntimeException)
3071 {
3072     ::vos::OGuard aGuard( GetMutex() );
3073
3074     ScrollBar* pScrollBar = static_cast< ScrollBar* >( GetWindow() );
3075     return pScrollBar ? pScrollBar->GetRangeMin() : 0;
3076 }
3077
3078 void VCLXScrollBar::setLineIncrement( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3079 {
3080     ::vos::OGuard aGuard( GetMutex() );
3081
3082     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3083     if ( pScrollBar )
3084         pScrollBar->SetLineSize( n );
3085 }
3086
3087 sal_Int32 VCLXScrollBar::getLineIncrement() throw(::com::sun::star::uno::RuntimeException)
3088 {
3089     ::vos::OGuard aGuard( GetMutex() );
3090
3091     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3092     return pScrollBar ? pScrollBar->GetLineSize() : 0;
3093 }
3094
3095 void VCLXScrollBar::setBlockIncrement( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3096 {
3097     ::vos::OGuard aGuard( GetMutex() );
3098
3099     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3100     if ( pScrollBar )
3101         pScrollBar->SetPageSize( n );
3102 }
3103
3104 sal_Int32 VCLXScrollBar::getBlockIncrement() throw(::com::sun::star::uno::RuntimeException)
3105 {
3106     ::vos::OGuard aGuard( GetMutex() );
3107
3108     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3109     return pScrollBar ? pScrollBar->GetPageSize() : 0;
3110 }
3111
3112 void VCLXScrollBar::setVisibleSize( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3113 {
3114     ::vos::OGuard aGuard( GetMutex() );
3115
3116     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3117     if ( pScrollBar )
3118         pScrollBar->SetVisibleSize( n );
3119 }
3120
3121 sal_Int32 VCLXScrollBar::getVisibleSize() throw(::com::sun::star::uno::RuntimeException)
3122 {
3123     ::vos::OGuard aGuard( GetMutex() );
3124
3125     ScrollBar* pScrollBar = (ScrollBar*) GetWindow();
3126     return pScrollBar ? pScrollBar->GetVisibleSize() : 0;
3127 }
3128
3129 void VCLXScrollBar::setOrientation( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3130 {
3131     ::vos::OGuard aGuard( GetMutex() );
3132
3133     Window* pWindow = GetWindow();
3134     if ( pWindow )
3135     {
3136         WinBits nStyle = pWindow->GetStyle();
3137         nStyle &= ~(WB_HORZ|WB_VERT);
3138         if ( n == ::com::sun::star::awt::ScrollBarOrientation::HORIZONTAL )
3139             nStyle |= WB_HORZ;
3140         else
3141             nStyle |= WB_VERT;
3142
3143         pWindow->SetStyle( nStyle );
3144         pWindow->Resize();
3145     }
3146 }
3147
3148 sal_Int32 VCLXScrollBar::getOrientation() throw(::com::sun::star::uno::RuntimeException)
3149 {
3150     ::vos::OGuard aGuard( GetMutex() );
3151
3152     sal_Int32 n = 0;
3153     Window* pWindow = GetWindow();
3154     if ( pWindow )
3155     {
3156         WinBits nStyle = pWindow->GetStyle();
3157         if ( nStyle & WB_HORZ )
3158             n = ::com::sun::star::awt::ScrollBarOrientation::HORIZONTAL;
3159         else
3160             n = ::com::sun::star::awt::ScrollBarOrientation::VERTICAL;
3161     }
3162     return n;
3163
3164 }
3165
3166 // ::com::sun::star::awt::VclWindowPeer
3167 void VCLXScrollBar::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
3168 {
3169     ::vos::OGuard aGuard( GetMutex() );
3170
3171     ScrollBar* pScrollBar = (ScrollBar*)GetWindow();
3172     if ( pScrollBar )
3173     {
3174         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
3175
3176         sal_uInt16 nPropType = GetPropertyId( PropertyName );
3177         switch ( nPropType )
3178         {
3179             case BASEPROPERTY_LIVE_SCROLL:
3180             {
3181                 sal_Bool bDo = sal_False;
3182                 if ( !bVoid )
3183                 {
3184                     OSL_VERIFY( Value >>= bDo );
3185                 }
3186                 AllSettings aSettings( pScrollBar->GetSettings() );
3187                 StyleSettings aStyle( aSettings.GetStyleSettings() );
3188                 ULONG nDragOptions = aStyle.GetDragFullOptions();
3189                 if ( bDo )
3190                     nDragOptions |= DRAGFULL_OPTION_SCROLL;
3191                 else
3192                     nDragOptions &= ~DRAGFULL_OPTION_SCROLL;
3193                 aStyle.SetDragFullOptions( nDragOptions );
3194                 aSettings.SetStyleSettings( aStyle );
3195                 pScrollBar->SetSettings( aSettings );
3196             }
3197             break;
3198
3199             case BASEPROPERTY_SCROLLVALUE:
3200             {
3201                 if ( !bVoid )
3202                 {
3203                     sal_Int32 n = 0;
3204                     if ( Value >>= n )
3205                         setValue( n );
3206                 }
3207             }
3208             break;
3209             case BASEPROPERTY_SCROLLVALUE_MAX:
3210             case BASEPROPERTY_SCROLLVALUE_MIN:
3211             {
3212                 if ( !bVoid )
3213                 {
3214                     sal_Int32 n = 0;
3215                     if ( Value >>= n )
3216                     {
3217                         if ( nPropType == BASEPROPERTY_SCROLLVALUE_MAX )
3218                             setMaximum( n );
3219                         else
3220                             setMinimum( n );
3221                     }
3222                 }
3223             }
3224             break;
3225             case BASEPROPERTY_LINEINCREMENT:
3226             {
3227                 if ( !bVoid )
3228                 {
3229                     sal_Int32 n = 0;
3230                     if ( Value >>= n )
3231                         setLineIncrement( n );
3232                 }
3233             }
3234             break;
3235             case BASEPROPERTY_BLOCKINCREMENT:
3236             {
3237                 if ( !bVoid )
3238                 {
3239                     sal_Int32 n = 0;
3240                     if ( Value >>= n )
3241                         setBlockIncrement( n );
3242                 }
3243             }
3244             break;
3245             case BASEPROPERTY_VISIBLESIZE:
3246             {
3247                 if ( !bVoid )
3248                 {
3249                     sal_Int32 n = 0;
3250                     if ( Value >>= n )
3251                         setVisibleSize( n );
3252                 }
3253             }
3254             break;
3255             case BASEPROPERTY_ORIENTATION:
3256             {
3257                 if ( !bVoid )
3258                 {
3259                     sal_Int32 n = 0;
3260                     if ( Value >>= n )
3261                         setOrientation( n );
3262                 }
3263             }
3264             break;
3265
3266             case BASEPROPERTY_BACKGROUNDCOLOR:
3267             {
3268                 // the default implementation of the base class doesn't work here, since our
3269                 // interpretation for this property is slightly different
3270                 ::toolkit::setButtonLikeFaceColor( pScrollBar, Value);
3271             }
3272             break;
3273
3274             default:
3275             {
3276                 VCLXWindow::setProperty( PropertyName, Value );
3277             }
3278         }
3279     }
3280 }
3281
3282 ::com::sun::star::uno::Any VCLXScrollBar::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
3283 {
3284     ::vos::OGuard aGuard( GetMutex() );
3285
3286     ::com::sun::star::uno::Any aProp;
3287     ScrollBar* pScrollBar = (ScrollBar*)GetWindow();
3288     if ( pScrollBar )
3289     {
3290         sal_uInt16 nPropType = GetPropertyId( PropertyName );
3291
3292         switch ( nPropType )
3293         {
3294             case BASEPROPERTY_LIVE_SCROLL:
3295             {
3296                 aProp <<= (sal_Bool)( 0 != ( pScrollBar->GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_SCROLL ) );
3297             }
3298             break;
3299             case BASEPROPERTY_SCROLLVALUE:
3300             {
3301                 aProp <<= (sal_Int32) getValue();
3302             }
3303             break;
3304             case BASEPROPERTY_SCROLLVALUE_MAX:
3305             {
3306                 aProp <<= (sal_Int32) getMaximum();
3307             }
3308             break;
3309             case BASEPROPERTY_SCROLLVALUE_MIN:
3310             {
3311                 aProp <<= (sal_Int32) getMinimum();
3312             }
3313             break;
3314             case BASEPROPERTY_LINEINCREMENT:
3315             {
3316                 aProp <<= (sal_Int32) getLineIncrement();
3317             }
3318             break;
3319             case BASEPROPERTY_BLOCKINCREMENT:
3320             {
3321                 aProp <<= (sal_Int32) getBlockIncrement();
3322             }
3323             break;
3324             case BASEPROPERTY_VISIBLESIZE:
3325             {
3326                 aProp <<= (sal_Int32) getVisibleSize();
3327             }
3328             break;
3329             case BASEPROPERTY_ORIENTATION:
3330             {
3331                 aProp <<= (sal_Int32) getOrientation();
3332             }
3333             break;
3334             case BASEPROPERTY_BACKGROUNDCOLOR:
3335             {
3336                 // the default implementation of the base class doesn't work here, since our
3337                 // interpretation for this property is slightly different
3338                 aProp = ::toolkit::getButtonLikeFaceColor( pScrollBar );
3339             }
3340             break;
3341
3342             default:
3343             {
3344                 aProp <<= VCLXWindow::getProperty( PropertyName );
3345             }
3346         }
3347     }
3348     return aProp;
3349 }
3350
3351 void VCLXScrollBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
3352 {
3353     switch ( rVclWindowEvent.GetId() )
3354     {
3355         case VCLEVENT_SCROLLBAR_SCROLL:
3356         {
3357             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
3358                 // since we call listeners below, there is a potential that we will be destroyed
3359                 // in during the listener call. To prevent the resulting crashs, we keep us
3360                 // alive as long as we're here
3361                 // #20178# - 2003-10-01 - fs@openoffice.org
3362
3363             if ( maAdjustmentListeners.getLength() )
3364             {
3365                 ScrollBar* pScrollBar = (ScrollBar*)GetWindow();
3366
3367                 if( pScrollBar )
3368                 {
3369                     ::com::sun::star::awt::AdjustmentEvent aEvent;
3370                     aEvent.Source = (::cppu::OWeakObject*)this;
3371                     aEvent.Value = pScrollBar->GetThumbPos();
3372
3373                     // set adjustment type
3374                     ScrollType aType = pScrollBar->GetType();
3375                     if ( aType == SCROLL_LINEUP || aType == SCROLL_LINEDOWN )
3376                     {
3377                         aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_LINE;
3378                     }
3379                     else if ( aType == SCROLL_PAGEUP || aType == SCROLL_PAGEDOWN )
3380                     {
3381                         aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_PAGE;
3382                     }
3383                     else if ( aType == SCROLL_DRAG )
3384                     {
3385                         aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_ABS;
3386                     }
3387
3388                     maAdjustmentListeners.adjustmentValueChanged( aEvent );
3389                 }
3390             }
3391         }
3392         break;
3393
3394         default:
3395             VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
3396             break;
3397     }
3398 }
3399
3400 ::com::sun::star::awt::Size SAL_CALL VCLXScrollBar::implGetMinimumSize( Window* p ) throw(::com::sun::star::uno::RuntimeException)
3401 {
3402     long n = p->GetSettings().GetStyleSettings().GetScrollBarSize();
3403     return ::com::sun::star::awt::Size( n, n );
3404 }
3405
3406 ::com::sun::star::awt::Size SAL_CALL VCLXScrollBar::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
3407 {
3408     ::vos::OGuard aGuard( GetMutex() );
3409     return implGetMinimumSize( GetWindow() );
3410 }
3411
3412
3413 //      ----------------------------------------------------
3414 //      class VCLXEdit
3415 //      ----------------------------------------------------
3416
3417 void VCLXEdit::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3418 {
3419     PushPropertyIds( rIds,
3420                      BASEPROPERTY_ALIGN,
3421                      BASEPROPERTY_BACKGROUNDCOLOR,
3422                      BASEPROPERTY_BORDER,
3423                      BASEPROPERTY_BORDERCOLOR,
3424                      BASEPROPERTY_DEFAULTCONTROL,
3425                      BASEPROPERTY_ECHOCHAR,
3426                      BASEPROPERTY_ENABLED,
3427                      BASEPROPERTY_ENABLEVISIBLE,
3428                      BASEPROPERTY_FONTDESCRIPTOR,
3429                      BASEPROPERTY_HARDLINEBREAKS,
3430                      BASEPROPERTY_HELPTEXT,
3431                      BASEPROPERTY_HELPURL,
3432                      BASEPROPERTY_HSCROLL,
3433                      BASEPROPERTY_LINE_END_FORMAT,
3434                      BASEPROPERTY_MAXTEXTLEN,
3435                      BASEPROPERTY_MULTILINE,
3436                      BASEPROPERTY_PRINTABLE,
3437                      BASEPROPERTY_READONLY,
3438                      BASEPROPERTY_TABSTOP,
3439                      BASEPROPERTY_TEXT,
3440                      BASEPROPERTY_VSCROLL,
3441                      BASEPROPERTY_HIDEINACTIVESELECTION,
3442                      BASEPROPERTY_PAINTTRANSPARENT,
3443                      BASEPROPERTY_AUTOHSCROLL,
3444                      BASEPROPERTY_AUTOVSCROLL,
3445                      BASEPROPERTY_WRITING_MODE,
3446                      BASEPROPERTY_CONTEXT_WRITING_MODE,
3447                      0);
3448     VCLXWindow::ImplGetPropertyIds( rIds );
3449 }
3450
3451 VCLXEdit::VCLXEdit() : maTextListeners( *this )
3452 {
3453 }
3454
3455 // ::com::sun::star::uno::XInterface
3456 ::com::sun::star::uno::Any VCLXEdit::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
3457 {
3458     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
3459                                         SAL_STATIC_CAST( ::com::sun::star::awt::XTextComponent*, this ),
3460                                         SAL_STATIC_CAST( ::com::sun::star::awt::XTextEditField*, this ),
3461                                         SAL_STATIC_CAST( ::com::sun::star::awt::XTextLayoutConstrains*, this ) );
3462     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
3463 }
3464
3465 // ::com::sun::star::lang::XTypeProvider
3466 IMPL_XTYPEPROVIDER_START( VCLXEdit )
3467     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ),
3468     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextEditField>* ) NULL ),
3469     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
3470     VCLXWindow::getTypes()
3471 IMPL_XTYPEPROVIDER_END
3472
3473 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXEdit::CreateAccessibleContext()
3474 {
3475     return getAccessibleFactory().createAccessibleContext( this );
3476 }
3477
3478 void VCLXEdit::dispose() throw(::com::sun::star::uno::RuntimeException)
3479 {
3480     ::vos::OGuard aGuard( GetMutex() );
3481
3482     ::com::sun::star::lang::EventObject aObj;
3483     aObj.Source = (::cppu::OWeakObject*)this;
3484     maTextListeners.disposeAndClear( aObj );
3485     VCLXWindow::dispose();
3486 }
3487
3488 void VCLXEdit::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3489 {
3490     ::vos::OGuard aGuard( GetMutex() );
3491     GetTextListeners().addInterface( l );
3492 }
3493
3494 void VCLXEdit::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3495 {
3496     ::vos::OGuard aGuard( GetMutex() );
3497     GetTextListeners().removeInterface( l );
3498 }
3499
3500 void VCLXEdit::setText( const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
3501 {
3502     ::vos::OGuard aGuard( GetMutex() );
3503
3504     Edit* pEdit = (Edit*)GetWindow();
3505     if ( pEdit )
3506     {
3507         pEdit->SetText( aText );
3508
3509         // #107218# Call same listeners like VCL would do after user interaction
3510         SetSynthesizingVCLEvent( sal_True );
3511         pEdit->SetModifyFlag();
3512         pEdit->Modify();
3513         SetSynthesizingVCLEvent( sal_False );
3514     }
3515 }
3516
3517 void VCLXEdit::insertText( const ::com::sun::star::awt::Selection& rSel, const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
3518 {
3519     ::vos::OGuard aGuard( GetMutex() );
3520
3521     Edit* pEdit = (Edit*)GetWindow();
3522     if ( pEdit )
3523     {
3524         pEdit->SetSelection( Selection( rSel.Min, rSel.Max ) );
3525         pEdit->ReplaceSelected( aText );
3526
3527         // #107218# Call same listeners like VCL would do after user interaction
3528         SetSynthesizingVCLEvent( sal_True );
3529         pEdit->SetModifyFlag();
3530         pEdit->Modify();
3531         SetSynthesizingVCLEvent( sal_False );
3532     }
3533 }
3534
3535 ::rtl::OUString VCLXEdit::getText() throw(::com::sun::star::uno::RuntimeException)
3536 {
3537     ::vos::OGuard aGuard( GetMutex() );
3538
3539     ::rtl::OUString aText;
3540     Window* pWindow = GetWindow();
3541     if ( pWindow )
3542         aText = pWindow->GetText();
3543     return aText;
3544 }
3545
3546 ::rtl::OUString VCLXEdit::getSelectedText() throw(::com::sun::star::uno::RuntimeException)
3547 {
3548     ::vos::OGuard aGuard( GetMutex() );
3549
3550     ::rtl::OUString aText;
3551     Edit* pEdit = (Edit*) GetWindow();
3552     if ( pEdit)
3553         aText = pEdit->GetSelected();
3554     return aText;
3555
3556 }
3557
3558 void VCLXEdit::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException)
3559 {
3560     ::vos::OGuard aGuard( GetMutex() );
3561
3562     Edit* pEdit = (Edit*) GetWindow();
3563     if ( pEdit )
3564         pEdit->SetSelection( Selection( aSelection.Min, aSelection.Max ) );
3565 }
3566
3567 ::com::sun::star::awt::Selection VCLXEdit::getSelection() throw(::com::sun::star::uno::RuntimeException)
3568 {
3569     ::vos::OGuard aGuard( GetMutex() );
3570
3571     Selection aSel;
3572     Edit* pEdit = (Edit*) GetWindow();
3573     if ( pEdit )
3574         aSel = pEdit->GetSelection();
3575     return ::com::sun::star::awt::Selection( aSel.Min(), aSel.Max() );
3576 }
3577
3578 sal_Bool VCLXEdit::isEditable() throw(::com::sun::star::uno::RuntimeException)
3579 {
3580     ::vos::OGuard aGuard( GetMutex() );
3581
3582     Edit* pEdit = (Edit*) GetWindow();
3583     return ( pEdit && !pEdit->IsReadOnly() && pEdit->IsEnabled() ) ? sal_True : sal_False;
3584 }
3585
3586 void VCLXEdit::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException)
3587 {
3588     ::vos::OGuard aGuard( GetMutex() );
3589
3590     Edit* pEdit = (Edit*) GetWindow();
3591     if ( pEdit )
3592         pEdit->SetReadOnly( !bEditable );
3593 }
3594
3595
3596 void VCLXEdit::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException)
3597 {
3598     ::vos::OGuard aGuard( GetMutex() );
3599
3600     Edit* pEdit = (Edit*) GetWindow();
3601     if ( pEdit )
3602         pEdit->SetMaxTextLen( nLen );
3603 }
3604
3605 sal_Int16 VCLXEdit::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException)
3606 {
3607     ::vos::OGuard aGuard( GetMutex() );
3608
3609     Edit* pEdit = (Edit*) GetWindow();
3610     return pEdit ? pEdit->GetMaxTextLen() : 0;
3611 }
3612
3613 void VCLXEdit::setEchoChar( sal_Unicode cEcho ) throw(::com::sun::star::uno::RuntimeException)
3614 {
3615     ::vos::OGuard aGuard( GetMutex() );
3616
3617     Edit* pEdit = (Edit*) GetWindow();
3618     if ( pEdit )
3619         pEdit->SetEchoChar( cEcho );
3620 }
3621
3622 void VCLXEdit::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
3623 {
3624     ::vos::OGuard aGuard( GetMutex() );
3625
3626     Edit* pEdit = (Edit*)GetWindow();
3627     if ( pEdit )
3628     {
3629         sal_uInt16 nPropType = GetPropertyId( PropertyName );
3630         switch ( nPropType )
3631         {
3632             case BASEPROPERTY_HIDEINACTIVESELECTION:
3633                 ::toolkit::adjustBooleanWindowStyle( Value, pEdit, WB_NOHIDESELECTION, sal_True );
3634                 if ( pEdit->GetSubEdit() )
3635                     ::toolkit::adjustBooleanWindowStyle( Value, pEdit->GetSubEdit(), WB_NOHIDESELECTION, sal_True );
3636                 break;
3637
3638             case BASEPROPERTY_READONLY:
3639             {
3640                 sal_Bool b = sal_Bool();
3641                 if ( Value >>= b )
3642                      pEdit->SetReadOnly( b );
3643             }
3644             break;
3645             case BASEPROPERTY_ECHOCHAR:
3646             {
3647                 sal_Int16 n = sal_Int16();
3648                 if ( Value >>= n )
3649                      pEdit->SetEchoChar( n );
3650             }
3651             break;
3652             case BASEPROPERTY_MAXTEXTLEN:
3653             {
3654                 sal_Int16 n = sal_Int16();
3655                 if ( Value >>= n )
3656                      pEdit->SetMaxTextLen( n );
3657             }
3658             break;
3659             default:
3660             {
3661                 VCLXWindow::setProperty( PropertyName, Value );
3662             }
3663         }
3664     }
3665 }
3666
3667 ::com::sun::star::uno::Any VCLXEdit::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
3668 {
3669     ::vos::OGuard aGuard( GetMutex() );
3670
3671     ::com::sun::star::uno::Any aProp;
3672     Edit* pEdit = (Edit*)GetWindow();
3673     if ( pEdit )
3674     {
3675         sal_uInt16 nPropType = GetPropertyId( PropertyName );
3676         switch ( nPropType )
3677         {
3678             case BASEPROPERTY_HIDEINACTIVESELECTION:
3679                 aProp <<= (sal_Bool)( ( pEdit->GetStyle() & WB_NOHIDESELECTION ) == 0 );
3680                 break;
3681             case BASEPROPERTY_READONLY:
3682                  aProp <<= (sal_Bool) pEdit->IsReadOnly();
3683                 break;
3684             case BASEPROPERTY_ECHOCHAR:
3685                  aProp <<= (sal_Int16) pEdit->GetEchoChar();
3686                 break;
3687             case BASEPROPERTY_MAXTEXTLEN:
3688                  aProp <<= (sal_Int16) pEdit->GetMaxTextLen();
3689                 break;
3690             default:
3691             {
3692                 aProp = VCLXWindow::getProperty( PropertyName );
3693             }
3694         }
3695     }
3696     return aProp;
3697 }
3698
3699 ::com::sun::star::awt::Size VCLXEdit::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
3700 {
3701     ::vos::OGuard aGuard( GetMutex() );
3702
3703     Size aSz;
3704     Edit* pEdit = (Edit*) GetWindow();
3705     if ( pEdit )
3706         aSz = pEdit->CalcMinimumSize();
3707     return AWTSize(aSz);
3708 }
3709
3710 ::com::sun::star::awt::Size VCLXEdit::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
3711 {
3712     ::vos::OGuard aGuard( GetMutex() );
3713
3714     Size aSz;
3715     Edit* pEdit = (Edit*) GetWindow();
3716     if ( pEdit )
3717     {
3718         aSz = pEdit->CalcMinimumSize();
3719         aSz.Height() += 4;
3720     }
3721     return AWTSize(aSz);
3722 }
3723
3724 ::com::sun::star::awt::Size VCLXEdit::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
3725 {
3726     ::vos::OGuard aGuard( GetMutex() );
3727
3728     ::com::sun::star::awt::Size aSz = rNewSize;
3729     ::com::sun::star::awt::Size aMinSz = getMinimumSize();
3730     if ( aSz.Height != aMinSz.Height )
3731         aSz.Height = aMinSz.Height;
3732
3733     return aSz;
3734 }
3735
3736 ::com::sun::star::awt::Size VCLXEdit::getMinimumSize( sal_Int16 nCols, sal_Int16 ) throw(::com::sun::star::uno::RuntimeException)
3737 {
3738     ::vos::OGuard aGuard( GetMutex() );
3739
3740     Size aSz;
3741     Edit* pEdit = (Edit*) GetWindow();
3742     if ( pEdit )
3743     {
3744         if ( nCols )
3745             aSz = pEdit->CalcSize( nCols );
3746         else
3747             aSz = pEdit->CalcMinimumSize();
3748     }
3749     return AWTSize(aSz);
3750 }
3751
3752 void VCLXEdit::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
3753 {
3754     ::vos::OGuard aGuard( GetMutex() );
3755
3756     nLines = 1;
3757     nCols = 0;
3758     Edit* pEdit = (Edit*) GetWindow();
3759     if ( pEdit )
3760         nCols = pEdit->GetMaxVisChars();
3761 }
3762
3763 void VCLXEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
3764 {
3765     switch ( rVclWindowEvent.GetId() )
3766     {
3767         case VCLEVENT_EDIT_MODIFY:
3768         {
3769             ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
3770                 // since we call listeners below, there is a potential that we will be destroyed
3771                 // during the listener call. To prevent the resulting crashs, we keep us
3772                 // alive as long as we're here
3773                 // #20178# - 2003-10-01 - fs@openoffice.org
3774
3775             if ( GetTextListeners().getLength() )
3776             {
3777                 ::com::sun::star::awt::TextEvent aEvent;
3778                 aEvent.Source = (::cppu::OWeakObject*)this;
3779                 GetTextListeners().textChanged( aEvent );
3780             }
3781         }
3782         break;
3783
3784         default:
3785             VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
3786             break;
3787     }
3788 }
3789
3790 //      ----------------------------------------------------
3791 //      class VCLXComboBox
3792 //      ----------------------------------------------------
3793
3794 void VCLXComboBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3795 {
3796     PushPropertyIds( rIds,
3797                      BASEPROPERTY_AUTOCOMPLETE,
3798                      BASEPROPERTY_BACKGROUNDCOLOR,
3799                      BASEPROPERTY_BORDER,
3800                      BASEPROPERTY_BORDERCOLOR,
3801                      BASEPROPERTY_DEFAULTCONTROL,
3802                      BASEPROPERTY_DROPDOWN,
3803                      BASEPROPERTY_ENABLED,
3804                      BASEPROPERTY_ENABLEVISIBLE,
3805                      BASEPROPERTY_FONTDESCRIPTOR,
3806                      BASEPROPERTY_HELPTEXT,
3807                      BASEPROPERTY_HELPURL,
3808                      BASEPROPERTY_LINECOUNT,
3809                      BASEPROPERTY_MAXTEXTLEN,
3810                      BASEPROPERTY_PRINTABLE,
3811                      BASEPROPERTY_READONLY,
3812                      BASEPROPERTY_STRINGITEMLIST,
3813                      BASEPROPERTY_TABSTOP,
3814                      BASEPROPERTY_TEXT,
3815                      BASEPROPERTY_HIDEINACTIVESELECTION,
3816                      BASEPROPERTY_ALIGN,
3817                      BASEPROPERTY_WRITING_MODE,
3818                      BASEPROPERTY_CONTEXT_WRITING_MODE,
3819                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
3820                      0);
3821     // no, don't call VCLXEdit here - it has properties which we do *not* want to have at at combo box
3822     // #i92690# / 2008-08-12 / frank.schoenheit@sun.com
3823     // VCLXEdit::ImplGetPropertyIds( rIds );
3824     VCLXWindow::ImplGetPropertyIds( rIds );
3825 }
3826
3827 VCLXComboBox::VCLXComboBox()
3828     : maActionListeners( *this ), maItemListeners( *this )
3829 {
3830 }
3831
3832 VCLXComboBox::~VCLXComboBox()
3833 {
3834 #ifndef __SUNPRO_CC
3835     OSL_TRACE ("%s", __FUNCTION__);
3836 #endif
3837 }
3838
3839 // ::com::sun::star::uno::XInterface
3840 ::com::sun::star::uno::Any VCLXComboBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
3841 {
3842     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
3843                                         SAL_STATIC_CAST( ::com::sun::star::awt::XComboBox*, this ) );
3844     return (aRet.hasValue() ? aRet : VCLXEdit::queryInterface( rType ));
3845 }
3846
3847 // ::com::sun::star::lang::XTypeProvider
3848 IMPL_XTYPEPROVIDER_START( VCLXComboBox )
3849     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XComboBox>* ) NULL ),
3850     VCLXEdit::getTypes()
3851 IMPL_XTYPEPROVIDER_END
3852
3853 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXComboBox::CreateAccessibleContext()
3854 {
3855     ::vos::OGuard aGuard( GetMutex() );
3856
3857     return getAccessibleFactory().createAccessibleContext( this );
3858 }
3859
3860 void VCLXComboBox::dispose() throw(::com::sun::star::uno::RuntimeException)
3861 {
3862     ::vos::OGuard aGuard( GetMutex() );
3863
3864     ::com::sun::star::lang::EventObject aObj;
3865     aObj.Source = (::cppu::OWeakObject*)this;
3866     maItemListeners.disposeAndClear( aObj );
3867     maActionListeners.disposeAndClear( aObj );
3868     VCLXEdit::dispose();
3869 }
3870
3871
3872 void VCLXComboBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3873 {
3874     ::vos::OGuard aGuard( GetMutex() );
3875     maItemListeners.addInterface( l );
3876 }
3877
3878 void VCLXComboBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3879 {
3880     ::vos::OGuard aGuard( GetMutex() );
3881     maItemListeners.removeInterface( l );
3882 }
3883
3884 void VCLXComboBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3885 {
3886     ::vos::OGuard aGuard( GetMutex() );
3887     maActionListeners.addInterface( l );
3888 }
3889
3890 void VCLXComboBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException)
3891 {
3892     ::vos::OGuard aGuard( GetMutex() );
3893     maActionListeners.removeInterface( l );
3894 }
3895
3896 void VCLXComboBox::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
3897 {
3898     ::vos::OGuard aGuard( GetMutex() );
3899
3900     ComboBox* pBox = (ComboBox*) GetWindow();
3901     if ( pBox )
3902         pBox->InsertEntry( aItem, nPos );
3903 }
3904
3905 void VCLXComboBox::addItems( const ::com::sun::star::uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
3906 {
3907     ::vos::OGuard aGuard( GetMutex() );
3908
3909     ComboBox* pBox = (ComboBox*) GetWindow();
3910     if ( pBox )
3911     {
3912         sal_uInt16 nP = nPos;
3913         for ( sal_uInt16 n = 0; n < aItems.getLength(); n++ )
3914         {
3915             pBox->InsertEntry( aItems.getConstArray()[n], nP );
3916             if ( (sal_uInt16)nPos < 0xFFFF )    // Nicht wenn 0xFFFF, weil LIST_APPEND
3917                 nP++;
3918         }
3919     }
3920 }
3921
3922 void VCLXComboBox::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(::com::sun::star::uno::RuntimeException)
3923 {
3924     ::vos::OGuard aGuard( GetMutex() );
3925
3926     ComboBox* pBox = (ComboBox*) GetWindow();
3927     if ( pBox )
3928     {
3929         for ( sal_uInt16 n = nCount; n; )
3930             pBox->RemoveEntry( nPos + (--n) );
3931     }
3932 }
3933
3934 sal_Int16 VCLXComboBox::getItemCount() throw(::com::sun::star::uno::RuntimeException)
3935 {
3936     ::vos::OGuard aGuard( GetMutex() );
3937
3938     ComboBox* pBox = (ComboBox*) GetWindow();
3939     return pBox ? pBox->GetEntryCount() : 0;
3940 }
3941
3942 ::rtl::OUString VCLXComboBox::getItem( sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException)
3943 {
3944     ::vos::OGuard aGuard( GetMutex() );
3945
3946     ::rtl::OUString aItem;
3947     ComboBox* pBox = (ComboBox*) GetWindow();
3948     if ( pBox )
3949         aItem = pBox->GetEntry( nPos );
3950     return aItem;
3951 }
3952
3953 ::com::sun::star::uno::Sequence< ::rtl::OUString> VCLXComboBox::getItems() throw(::com::sun::star::uno::RuntimeException)
3954 {
3955     ::vos::OGuard aGuard( GetMutex() );
3956
3957     ::com::sun::star::uno::Sequence< ::rtl::OUString> aSeq;
3958     ComboBox* pBox = (ComboBox*) GetWindow();
3959     if ( pBox )
3960     {
3961         sal_uInt16 nEntries = pBox->GetEntryCount();
3962         aSeq = ::com::sun::star::uno::Sequence< ::rtl::OUString>( nEntries );
3963         for ( sal_uInt16 n = nEntries; n; )
3964         {
3965             --n;
3966             aSeq.getArray()[n] = pBox->GetEntry( n );
3967         }
3968     }
3969     return aSeq;
3970 }
3971
3972 void VCLXComboBox::setDropDownLineCount( sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
3973 {
3974     ::vos::OGuard aGuard( GetMutex() );
3975
3976     ComboBox* pBox = (ComboBox*) GetWindow();
3977     if ( pBox )
3978         pBox->SetDropDownLineCount( nLines );
3979 }
3980
3981 sal_Int16 VCLXComboBox::getDropDownLineCount() throw(::com::sun::star::uno::RuntimeException)
3982 {
3983     ::vos::OGuard aGuard( GetMutex() );
3984
3985     sal_Int16 nLines = 0;
3986     ComboBox* pBox = (ComboBox*) GetWindow();
3987     if ( pBox )
3988         nLines = pBox->GetDropDownLineCount();
3989     return nLines;
3990 }
3991
3992 void VCLXComboBox::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
3993 {
3994     ::vos::OGuard aGuard( GetMutex() );
3995
3996     ComboBox* pComboBox = (ComboBox*)GetWindow();
3997     if ( pComboBox )
3998     {
3999         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4000         switch ( nPropType )
4001         {
4002             case BASEPROPERTY_LINECOUNT:
4003             {
4004                 sal_Int16 n = sal_Int16();
4005                 if ( Value >>= n )
4006                      pComboBox->SetDropDownLineCount( n );
4007             }
4008             break;
4009             case BASEPROPERTY_AUTOCOMPLETE:
4010             {
4011                 sal_Int16 n = sal_Int16();
4012                 if ( Value >>= n )
4013                      pComboBox->EnableAutocomplete( n != 0 );
4014             }
4015             break;
4016             case BASEPROPERTY_STRINGITEMLIST:
4017             {
4018                 ::com::sun::star::uno::Sequence< ::rtl::OUString> aItems;
4019                 if ( Value >>= aItems )
4020                 {
4021                     sal_Bool bUpdate = pComboBox->IsUpdateMode();
4022                     pComboBox->SetUpdateMode( sal_False );
4023                     pComboBox->Clear();
4024                     const ::rtl::OUString* pStrings = aItems.getConstArray();
4025                     sal_Int32 nItems = aItems.getLength();
4026                     for ( sal_Int32 n = 0; n < nItems; n++ )
4027                         pComboBox->InsertEntry( pStrings[n], LISTBOX_APPEND );
4028                     pComboBox->SetUpdateMode( bUpdate );
4029                 }
4030             }
4031             break;
4032             default:
4033             {
4034                 VCLXEdit::setProperty( PropertyName, Value );
4035
4036                 // #109385# SetBorderStyle is not virtual
4037                 if ( nPropType == BASEPROPERTY_BORDER )
4038                 {
4039                     sal_uInt16 nBorder = sal_uInt16();
4040                     if ( (Value >>= nBorder) && nBorder != 0 )
4041                         pComboBox->SetBorderStyle( nBorder );
4042                 }
4043             }
4044         }
4045     }
4046 }
4047
4048 ::com::sun::star::uno::Any VCLXComboBox::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
4049 {
4050     ::vos::OGuard aGuard( GetMutex() );
4051
4052     ::com::sun::star::uno::Any aProp;
4053     ComboBox* pComboBox = (ComboBox*)GetWindow();
4054     if ( pComboBox )
4055     {
4056         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4057         switch ( nPropType )
4058         {
4059             case BASEPROPERTY_LINECOUNT:
4060             {
4061                  aProp <<= (sal_Int16)  pComboBox->GetDropDownLineCount();
4062             }
4063             break;
4064             case BASEPROPERTY_AUTOCOMPLETE:
4065             {
4066                  aProp <<= (sal_Bool) pComboBox->IsAutocompleteEnabled();
4067             }
4068             break;
4069             case BASEPROPERTY_STRINGITEMLIST:
4070             {
4071                 sal_uInt16 nItems = pComboBox->GetEntryCount();
4072                 ::com::sun::star::uno::Sequence< ::rtl::OUString> aSeq( nItems );
4073                 ::rtl::OUString* pStrings = aSeq.getArray();
4074                 for ( sal_uInt16 n = 0; n < nItems; n++ )
4075                     pStrings[n] = pComboBox->GetEntry( n );
4076                 aProp <<= aSeq;
4077
4078             }
4079             break;
4080             default:
4081             {
4082                 aProp <<= VCLXEdit::getProperty( PropertyName );
4083             }
4084         }
4085     }
4086     return aProp;
4087 }
4088
4089 void VCLXComboBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
4090 {
4091     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
4092         // since we call listeners below, there is a potential that we will be destroyed
4093         // during the listener call. To prevent the resulting crashs, we keep us
4094         // alive as long as we're here
4095         // #20178# - 2003-10-01 - fs@openoffice.org
4096
4097     switch ( rVclWindowEvent.GetId() )
4098     {
4099         case VCLEVENT_COMBOBOX_SELECT:
4100             if ( maItemListeners.getLength() )
4101             {
4102                 ComboBox* pComboBox = (ComboBox*)GetWindow();
4103                 if( pComboBox )
4104                 {
4105                     if ( !pComboBox->IsTravelSelect() )
4106                     {
4107                         ::com::sun::star::awt::ItemEvent aEvent;
4108                         aEvent.Source = (::cppu::OWeakObject*)this;
4109                         aEvent.Highlighted = sal_False;
4110
4111                         // Bei Mehrfachselektion 0xFFFF, sonst die ID
4112                         aEvent.Selected = pComboBox->GetEntryPos( pComboBox->GetText() );
4113
4114                         maItemListeners.itemStateChanged( aEvent );
4115                     }
4116                 }
4117             }
4118             break;
4119
4120         case VCLEVENT_COMBOBOX_DOUBLECLICK:
4121             if ( maActionListeners.getLength() )
4122             {
4123                 ::com::sun::star::awt::ActionEvent aEvent;
4124                 aEvent.Source = (::cppu::OWeakObject*)this;
4125 //                              aEvent.ActionCommand = ...;
4126                 maActionListeners.actionPerformed( aEvent );
4127             }
4128             break;
4129
4130         default:
4131             VCLXEdit::ProcessWindowEvent( rVclWindowEvent );
4132             break;
4133     }
4134 }
4135
4136 ::com::sun::star::awt::Size VCLXComboBox::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
4137 {
4138     ::vos::OGuard aGuard( GetMutex() );
4139
4140     Size aSz;
4141     ComboBox* pComboBox = (ComboBox*) GetWindow();
4142     if ( pComboBox )
4143         aSz = pComboBox->CalcMinimumSize();
4144     return AWTSize(aSz);
4145 }
4146
4147 ::com::sun::star::awt::Size VCLXComboBox::getPreferredSize(  ) throw(::com::sun::star::uno::RuntimeException)
4148 {
4149     ::vos::OGuard aGuard( GetMutex() );
4150
4151     Size aSz;
4152     ComboBox* pComboBox = (ComboBox*) GetWindow();
4153     if ( pComboBox )
4154     {
4155         aSz = pComboBox->CalcMinimumSize();
4156         if ( pComboBox->GetStyle() & WB_DROPDOWN )
4157             aSz.Height() += 4;
4158     }
4159     return AWTSize(aSz);
4160 }
4161
4162 ::com::sun::star::awt::Size VCLXComboBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
4163 {
4164     ::vos::OGuard aGuard( GetMutex() );
4165
4166     Size aSz = VCLSize(rNewSize);
4167     ComboBox* pComboBox = (ComboBox*) GetWindow();
4168     if ( pComboBox )
4169         aSz = pComboBox->CalcAdjustedSize( aSz );
4170     return AWTSize(aSz);
4171 }
4172
4173 ::com::sun::star::awt::Size VCLXComboBox::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
4174 {
4175     ::vos::OGuard aGuard( GetMutex() );
4176
4177     Size aSz;
4178     ComboBox* pComboBox = (ComboBox*) GetWindow();
4179     if ( pComboBox )
4180         aSz = pComboBox->CalcSize( nCols, nLines );
4181     return AWTSize(aSz);
4182 }
4183
4184 void VCLXComboBox::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
4185 {
4186     ::vos::OGuard aGuard( GetMutex() );
4187
4188     nCols = nLines = 0;
4189     ComboBox* pComboBox = (ComboBox*) GetWindow();
4190     if ( pComboBox )
4191     {
4192         sal_uInt16 nC, nL;
4193         pComboBox->GetMaxVisColumnsAndLines( nC, nL );
4194         nCols = nC;
4195         nLines = nL;
4196     }
4197 }
4198
4199 //      ----------------------------------------------------
4200 //      class VCLXFormattedSpinField
4201 //      ----------------------------------------------------
4202 void VCLXFormattedSpinField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4203 {
4204     // Interestingly in the UnoControl API this is
4205     // - not derived from XEdit ultimately, (correct ?) - so cut this here ...
4206 //    VCLXSpinField::ImplGetPropertyIds( rIds );
4207     VCLXWindow::ImplGetPropertyIds( rIds );
4208 }
4209
4210 VCLXFormattedSpinField::VCLXFormattedSpinField()
4211 {
4212 }
4213
4214 VCLXFormattedSpinField::~VCLXFormattedSpinField()
4215 {
4216 }
4217
4218 void VCLXFormattedSpinField::setStrictFormat( sal_Bool bStrict )
4219 {
4220     ::vos::OGuard aGuard( GetMutex() );
4221
4222     FormatterBase* pFormatter = GetFormatter();
4223     if ( pFormatter )
4224         pFormatter->SetStrictFormat( bStrict );
4225 }
4226
4227 sal_Bool VCLXFormattedSpinField::isStrictFormat()
4228 {
4229     FormatterBase* pFormatter = GetFormatter();
4230     return pFormatter ? pFormatter->IsStrictFormat() : sal_False;
4231 }
4232
4233
4234 void VCLXFormattedSpinField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
4235 {
4236     ::vos::OGuard aGuard( GetMutex() );
4237
4238     FormatterBase* pFormatter = GetFormatter();
4239     if ( pFormatter )
4240     {
4241         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4242         switch ( nPropType )
4243         {
4244             case BASEPROPERTY_SPIN:
4245             {
4246                 sal_Bool b = sal_Bool();
4247                 if ( Value >>= b )
4248                 {
4249                     WinBits nStyle = GetWindow()->GetStyle() | WB_SPIN;
4250                     if ( !b )
4251                         nStyle &= ~WB_SPIN;
4252                     GetWindow()->SetStyle( nStyle );
4253                 }
4254             }
4255             break;
4256             case BASEPROPERTY_STRICTFORMAT:
4257             {
4258                 sal_Bool b = sal_Bool();
4259                 if ( Value >>= b )
4260                 {
4261                      pFormatter->SetStrictFormat( b );
4262                 }
4263             }
4264             break;
4265             default:
4266             {
4267                 VCLXSpinField::setProperty( PropertyName, Value );
4268             }
4269         }
4270     }
4271 }
4272
4273 ::com::sun::star::uno::Any VCLXFormattedSpinField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
4274 {
4275     ::vos::OGuard aGuard( GetMutex() );
4276
4277     ::com::sun::star::uno::Any aProp;
4278     FormatterBase* pFormatter = GetFormatter();
4279     if ( pFormatter )
4280     {
4281         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4282         switch ( nPropType )
4283         {
4284             case BASEPROPERTY_TABSTOP:
4285             {
4286                 aProp <<= (sal_Bool) ( ( GetWindow()->GetStyle() & WB_SPIN ) ? sal_True : sal_False );
4287             }
4288             break;
4289             case BASEPROPERTY_STRICTFORMAT:
4290             {
4291                 aProp <<= (sal_Bool) pFormatter->IsStrictFormat();
4292             }
4293             break;
4294             default:
4295             {
4296                 aProp <<= VCLXSpinField::getProperty( PropertyName );
4297             }
4298         }
4299     }
4300     return aProp;
4301 }
4302
4303
4304 //      ----------------------------------------------------
4305 //      class VCLXDateField
4306 //      ----------------------------------------------------
4307
4308 void VCLXDateField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4309 {
4310     PushPropertyIds( rIds,
4311                      BASEPROPERTY_ALIGN,
4312                      BASEPROPERTY_BACKGROUNDCOLOR,
4313                      BASEPROPERTY_BORDER,
4314                      BASEPROPERTY_BORDERCOLOR,
4315                      BASEPROPERTY_DATE,
4316                      BASEPROPERTY_DATEMAX,
4317                      BASEPROPERTY_DATEMIN,
4318                      BASEPROPERTY_DATESHOWCENTURY,
4319                      BASEPROPERTY_DEFAULTCONTROL,
4320                      BASEPROPERTY_DROPDOWN,
4321                      BASEPROPERTY_ENABLED,
4322                      BASEPROPERTY_ENABLEVISIBLE,
4323                      BASEPROPERTY_EXTDATEFORMAT,
4324                      BASEPROPERTY_FONTDESCRIPTOR,
4325                      BASEPROPERTY_HELPTEXT,
4326                      BASEPROPERTY_HELPURL,
4327                      BASEPROPERTY_PRINTABLE,
4328                      BASEPROPERTY_READONLY,
4329                      BASEPROPERTY_REPEAT,
4330                      BASEPROPERTY_REPEAT_DELAY,
4331                      BASEPROPERTY_SPIN,
4332                      BASEPROPERTY_STRICTFORMAT,
4333                      BASEPROPERTY_TABSTOP,
4334                      BASEPROPERTY_ENFORCE_FORMAT,
4335                      BASEPROPERTY_TEXT,
4336                      BASEPROPERTY_HIDEINACTIVESELECTION,
4337                      BASEPROPERTY_WRITING_MODE,
4338                      BASEPROPERTY_CONTEXT_WRITING_MODE,
4339                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
4340                      0);
4341     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
4342 }
4343
4344 VCLXDateField::VCLXDateField()
4345 {
4346 }
4347
4348 VCLXDateField::~VCLXDateField()
4349 {
4350 }
4351
4352 // ::com::sun::star::uno::XInterface
4353 ::com::sun::star::uno::Any VCLXDateField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
4354 {
4355     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
4356                                         SAL_STATIC_CAST( ::com::sun::star::awt::XDateField*, this ) );
4357     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
4358 }
4359
4360 // ::com::sun::star::lang::XTypeProvider
4361 IMPL_XTYPEPROVIDER_START( VCLXDateField )
4362     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDateField>* ) NULL ),
4363     VCLXFormattedSpinField::getTypes()
4364 IMPL_XTYPEPROVIDER_END
4365
4366 void VCLXDateField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
4367 {
4368     ::vos::OGuard aGuard( GetMutex() );
4369
4370     if ( GetWindow() )
4371     {
4372         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
4373
4374         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4375         switch ( nPropType )
4376         {
4377             case BASEPROPERTY_DATE:
4378             {
4379                 if ( bVoid )
4380                 {
4381                     ((DateField*)GetWindow())->EnableEmptyFieldValue( sal_True );
4382                     ((DateField*)GetWindow())->SetEmptyFieldValue();
4383                 }
4384                 else
4385                 {
4386                     sal_Int32 n = 0;
4387                     if ( Value >>= n )
4388                          setDate( n );
4389                 }
4390             }
4391             break;
4392             case BASEPROPERTY_DATEMIN:
4393             {
4394                 sal_Int32 n = 0;
4395                 if ( Value >>= n )
4396                      setMin( n );
4397             }
4398             break;
4399             case BASEPROPERTY_DATEMAX:
4400             {
4401                 sal_Int32 n = 0;
4402                 if ( Value >>= n )
4403                      setMax( n );
4404             }
4405             break;
4406             case BASEPROPERTY_EXTDATEFORMAT:
4407             {
4408                 sal_Int16 n = sal_Int16();
4409                 if ( Value >>= n )
4410                     ((DateField*)GetWindow())->SetExtDateFormat( (ExtDateFieldFormat) n );
4411             }
4412             break;
4413             case BASEPROPERTY_DATESHOWCENTURY:
4414             {
4415                 sal_Bool b = sal_Bool();
4416                 if ( Value >>= b )
4417                      ((DateField*)GetWindow())->SetShowDateCentury( b );
4418             }
4419             break;
4420             case BASEPROPERTY_ENFORCE_FORMAT:
4421             {
4422                 sal_Bool bEnforce( sal_True );
4423                 OSL_VERIFY( Value >>= bEnforce );
4424                 static_cast< DateField* >( GetWindow() )->EnforceValidValue( bEnforce );
4425             }
4426             break;
4427             default:
4428             {
4429                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
4430             }
4431         }
4432     }
4433 }
4434
4435 ::com::sun::star::uno::Any VCLXDateField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
4436 {
4437     ::vos::OGuard aGuard( GetMutex() );
4438
4439     ::com::sun::star::uno::Any aProp;
4440     FormatterBase* pFormatter = GetFormatter();
4441     if ( pFormatter )
4442     {
4443         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4444         switch ( nPropType )
4445         {
4446             case BASEPROPERTY_DATE:
4447             {
4448                 aProp <<= (sal_Int32) getDate();
4449             }
4450             break;
4451             case BASEPROPERTY_DATEMIN:
4452             {
4453                 aProp <<= (sal_Int32) getMin();
4454             }
4455             break;
4456             case BASEPROPERTY_DATEMAX:
4457             {
4458                 aProp <<= (sal_Int32) getMax();
4459             }
4460             break;
4461             case BASEPROPERTY_DATESHOWCENTURY:
4462             {
4463                 aProp <<= ((DateField*)GetWindow())->IsShowDateCentury();
4464             }
4465             break;
4466             case BASEPROPERTY_ENFORCE_FORMAT:
4467             {
4468                 aProp <<= (sal_Bool)static_cast< DateField* >( GetWindow() )->IsEnforceValidValue( );
4469             }
4470             break;
4471             default:
4472             {
4473                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
4474             }
4475         }
4476     }
4477     return aProp;
4478 }
4479
4480
4481 void VCLXDateField::setDate( sal_Int32 nDate ) throw(::com::sun::star::uno::RuntimeException)
4482 {
4483     ::vos::OGuard aGuard( GetMutex() );
4484
4485     DateField* pDateField = (DateField*) GetWindow();
4486     if ( pDateField )
4487     {
4488         pDateField->SetDate( nDate );
4489
4490         // #107218# Call same listeners like VCL would do after user interaction
4491         SetSynthesizingVCLEvent( sal_True );
4492         pDateField->SetModifyFlag();
4493         pDateField->Modify();
4494         SetSynthesizingVCLEvent( sal_False );
4495     }
4496 }
4497
4498 sal_Int32 VCLXDateField::getDate() throw(::com::sun::star::uno::RuntimeException)
4499 {
4500     ::vos::OGuard aGuard( GetMutex() );
4501
4502     sal_Int32 nDate = 0;
4503     DateField* pDateField = (DateField*) GetWindow();
4504     if ( pDateField )
4505         nDate = pDateField->GetDate().GetDate();
4506
4507     return nDate;
4508 }
4509
4510 void VCLXDateField::setMin( sal_Int32 nDate ) throw(::com::sun::star::uno::RuntimeException)
4511 {
4512     ::vos::OGuard aGuard( GetMutex() );
4513
4514     DateField* pDateField = (DateField*) GetWindow();
4515     if ( pDateField )
4516         pDateField->SetMin( nDate );
4517 }
4518
4519 sal_Int32 VCLXDateField::getMin() throw(::com::sun::star::uno::RuntimeException)
4520 {
4521     ::vos::OGuard aGuard( GetMutex() );
4522
4523     sal_Int32 nDate = 0;
4524     DateField* pDateField = (DateField*) GetWindow();
4525     if ( pDateField )
4526         nDate = pDateField->GetMin().GetDate();
4527
4528     return nDate;
4529 }
4530
4531 void VCLXDateField::setMax( sal_Int32 nDate ) throw(::com::sun::star::uno::RuntimeException)
4532 {
4533     ::vos::OGuard aGuard( GetMutex() );
4534
4535     DateField* pDateField = (DateField*) GetWindow();
4536     if ( pDateField )
4537         pDateField->SetMax( nDate );
4538 }
4539
4540 sal_Int32 VCLXDateField::getMax() throw(::com::sun::star::uno::RuntimeException)
4541 {
4542     ::vos::OGuard aGuard( GetMutex() );
4543
4544     sal_Int32 nDate = 0;
4545     DateField* pDateField = (DateField*) GetWindow();
4546     if ( pDateField )
4547         nDate = pDateField->GetMax().GetDate();
4548
4549     return nDate;
4550 }
4551
4552 void VCLXDateField::setFirst( sal_Int32 nDate ) throw(::com::sun::star::uno::RuntimeException)
4553 {
4554     ::vos::OGuard aGuard( GetMutex() );
4555
4556     DateField* pDateField = (DateField*) GetWindow();
4557     if ( pDateField )
4558         pDateField->SetFirst( nDate );
4559 }
4560
4561 sal_Int32 VCLXDateField::getFirst() throw(::com::sun::star::uno::RuntimeException)
4562 {
4563     ::vos::OGuard aGuard( GetMutex() );
4564
4565     sal_Int32 nDate = 0;
4566     DateField* pDateField = (DateField*) GetWindow();
4567     if ( pDateField )
4568         nDate = pDateField->GetFirst().GetDate();
4569
4570     return nDate;
4571 }
4572
4573 void VCLXDateField::setLast( sal_Int32 nDate ) throw(::com::sun::star::uno::RuntimeException)
4574 {
4575     ::vos::OGuard aGuard( GetMutex() );
4576
4577     DateField* pDateField = (DateField*) GetWindow();
4578     if ( pDateField )
4579         pDateField->SetLast( nDate );
4580 }
4581
4582 sal_Int32 VCLXDateField::getLast() throw(::com::sun::star::uno::RuntimeException)
4583 {
4584     ::vos::OGuard aGuard( GetMutex() );
4585
4586     sal_Int32 nDate = 0;
4587     DateField* pDateField = (DateField*) GetWindow();
4588     if ( pDateField )
4589         nDate = pDateField->GetLast().GetDate();
4590
4591     return nDate;
4592 }
4593
4594 void VCLXDateField::setLongFormat( sal_Bool bLong ) throw(::com::sun::star::uno::RuntimeException)
4595 {
4596     ::vos::OGuard aGuard( GetMutex() );
4597
4598     DateField* pDateField = (DateField*) GetWindow();
4599     if ( pDateField )
4600         pDateField->SetLongFormat( bLong );
4601 }
4602
4603 sal_Bool VCLXDateField::isLongFormat() throw(::com::sun::star::uno::RuntimeException)
4604 {
4605     ::vos::OGuard aGuard( GetMutex() );
4606
4607     DateField* pDateField = (DateField*) GetWindow();
4608     return pDateField ? pDateField->IsLongFormat() : sal_False;
4609 }
4610
4611 void VCLXDateField::setEmpty() throw(::com::sun::star::uno::RuntimeException)
4612 {
4613     ::vos::OGuard aGuard( GetMutex() );
4614
4615     DateField* pDateField = (DateField*) GetWindow();
4616     if ( pDateField )
4617     {
4618         pDateField->SetEmptyDate();
4619
4620         // #107218# Call same listeners like VCL would do after user interaction
4621         SetSynthesizingVCLEvent( sal_True );
4622         pDateField->SetModifyFlag();
4623         pDateField->Modify();
4624         SetSynthesizingVCLEvent( sal_False );
4625     }
4626 }
4627
4628 sal_Bool VCLXDateField::isEmpty() throw(::com::sun::star::uno::RuntimeException)
4629 {
4630     ::vos::OGuard aGuard( GetMutex() );
4631
4632     DateField* pDateField = (DateField*) GetWindow();
4633     return pDateField ? pDateField->IsEmptyDate() : sal_False;
4634 }
4635
4636 void VCLXDateField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
4637 {
4638     VCLXFormattedSpinField::setStrictFormat( bStrict );
4639 }
4640
4641 sal_Bool VCLXDateField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
4642 {
4643     return VCLXFormattedSpinField::isStrictFormat();
4644 }
4645
4646
4647 //      ----------------------------------------------------
4648 //      class VCLXTimeField
4649 //      ----------------------------------------------------
4650
4651 void VCLXTimeField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4652 {
4653     PushPropertyIds( rIds,
4654                      BASEPROPERTY_ALIGN,
4655                      BASEPROPERTY_BACKGROUNDCOLOR,
4656                      BASEPROPERTY_BORDER,
4657                      BASEPROPERTY_BORDERCOLOR,
4658                      BASEPROPERTY_DEFAULTCONTROL,
4659                      BASEPROPERTY_ENABLED,
4660                      BASEPROPERTY_ENABLEVISIBLE,
4661                      BASEPROPERTY_EXTTIMEFORMAT,
4662                      BASEPROPERTY_FONTDESCRIPTOR,
4663                      BASEPROPERTY_HELPTEXT,
4664                      BASEPROPERTY_HELPURL,
4665                      BASEPROPERTY_PRINTABLE,
4666                      BASEPROPERTY_READONLY,
4667                      BASEPROPERTY_REPEAT,
4668                      BASEPROPERTY_REPEAT_DELAY,
4669                      BASEPROPERTY_SPIN,
4670                      BASEPROPERTY_STRICTFORMAT,
4671                      BASEPROPERTY_TABSTOP,
4672                      BASEPROPERTY_TIME,
4673                      BASEPROPERTY_TIMEMAX,
4674                      BASEPROPERTY_TIMEMIN,
4675                      BASEPROPERTY_ENFORCE_FORMAT,
4676                      BASEPROPERTY_TEXT,
4677                      BASEPROPERTY_HIDEINACTIVESELECTION,
4678                      BASEPROPERTY_WRITING_MODE,
4679                      BASEPROPERTY_CONTEXT_WRITING_MODE,
4680                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
4681                      0);
4682     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
4683 }
4684
4685 VCLXTimeField::VCLXTimeField()
4686 {
4687 }
4688
4689 VCLXTimeField::~VCLXTimeField()
4690 {
4691 }
4692
4693 // ::com::sun::star::uno::XInterface
4694 ::com::sun::star::uno::Any VCLXTimeField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
4695 {
4696     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
4697                                         SAL_STATIC_CAST( ::com::sun::star::awt::XTimeField*, this ) );
4698     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
4699 }
4700
4701 // ::com::sun::star::lang::XTypeProvider
4702 IMPL_XTYPEPROVIDER_START( VCLXTimeField )
4703     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTimeField>* ) NULL ),
4704     VCLXFormattedSpinField::getTypes()
4705 IMPL_XTYPEPROVIDER_END
4706
4707 void VCLXTimeField::setTime( sal_Int32 nTime ) throw(::com::sun::star::uno::RuntimeException)
4708 {
4709     ::vos::OGuard aGuard( GetMutex() );
4710
4711     TimeField* pTimeField = (TimeField*) GetWindow();
4712     if ( pTimeField )
4713     {
4714         pTimeField->SetTime( nTime );
4715
4716         // #107218# Call same listeners like VCL would do after user interaction
4717         SetSynthesizingVCLEvent( sal_True );
4718         pTimeField->SetModifyFlag();
4719         pTimeField->Modify();
4720         SetSynthesizingVCLEvent( sal_False );
4721     }
4722 }
4723
4724 sal_Int32 VCLXTimeField::getTime() throw(::com::sun::star::uno::RuntimeException)
4725 {
4726     ::vos::OGuard aGuard( GetMutex() );
4727
4728     sal_Int32 nTime = 0;
4729     TimeField* pTimeField = (TimeField*) GetWindow();
4730     if ( pTimeField )
4731         nTime = pTimeField->GetTime().GetTime();
4732
4733     return nTime;
4734 }
4735
4736 void VCLXTimeField::setMin( sal_Int32 nTime ) throw(::com::sun::star::uno::RuntimeException)
4737 {
4738     ::vos::OGuard aGuard( GetMutex() );
4739
4740     TimeField* pTimeField = (TimeField*) GetWindow();
4741     if ( pTimeField )
4742         pTimeField->SetMin( nTime );
4743 }
4744
4745 sal_Int32 VCLXTimeField::getMin() throw(::com::sun::star::uno::RuntimeException)
4746 {
4747     ::vos::OGuard aGuard( GetMutex() );
4748
4749     sal_Int32 nTime = 0;
4750     TimeField* pTimeField = (TimeField*) GetWindow();
4751     if ( pTimeField )
4752         nTime = pTimeField->GetMin().GetTime();
4753
4754     return nTime;
4755 }
4756
4757 void VCLXTimeField::setMax( sal_Int32 nTime ) throw(::com::sun::star::uno::RuntimeException)
4758 {
4759     ::vos::OGuard aGuard( GetMutex() );
4760
4761     TimeField* pTimeField = (TimeField*) GetWindow();
4762     if ( pTimeField )
4763         pTimeField->SetMax( nTime );
4764 }
4765
4766 sal_Int32 VCLXTimeField::getMax() throw(::com::sun::star::uno::RuntimeException)
4767 {
4768     ::vos::OGuard aGuard( GetMutex() );
4769
4770     sal_Int32 nTime = 0;
4771     TimeField* pTimeField = (TimeField*) GetWindow();
4772     if ( pTimeField )
4773         nTime = pTimeField->GetMax().GetTime();
4774
4775     return nTime;
4776 }
4777
4778 void VCLXTimeField::setFirst( sal_Int32 nTime ) throw(::com::sun::star::uno::RuntimeException)
4779 {
4780     ::vos::OGuard aGuard( GetMutex() );
4781
4782     TimeField* pTimeField = (TimeField*) GetWindow();
4783     if ( pTimeField )
4784         pTimeField->SetFirst( nTime );
4785 }
4786
4787 sal_Int32 VCLXTimeField::getFirst() throw(::com::sun::star::uno::RuntimeException)
4788 {
4789     ::vos::OGuard aGuard( GetMutex() );
4790
4791     sal_Int32 nTime = 0;
4792     TimeField* pTimeField = (TimeField*) GetWindow();
4793     if ( pTimeField )
4794         nTime = pTimeField->GetFirst().GetTime();
4795
4796     return nTime;
4797 }
4798
4799 void VCLXTimeField::setLast( sal_Int32 nTime ) throw(::com::sun::star::uno::RuntimeException)
4800 {
4801     ::vos::OGuard aGuard( GetMutex() );
4802
4803     TimeField* pTimeField = (TimeField*) GetWindow();
4804     if ( pTimeField )
4805         pTimeField->SetLast( nTime );
4806 }
4807
4808 sal_Int32 VCLXTimeField::getLast() throw(::com::sun::star::uno::RuntimeException)
4809 {
4810     ::vos::OGuard aGuard( GetMutex() );
4811
4812     sal_Int32 nTime = 0;
4813     TimeField* pTimeField = (TimeField*) GetWindow();
4814     if ( pTimeField )
4815         nTime = pTimeField->GetLast().GetTime();
4816
4817     return nTime;
4818 }
4819
4820 void VCLXTimeField::setEmpty() throw(::com::sun::star::uno::RuntimeException)
4821 {
4822     ::vos::OGuard aGuard( GetMutex() );
4823
4824     TimeField* pTimeField = (TimeField*) GetWindow();
4825     if ( pTimeField )
4826         pTimeField->SetEmptyTime();
4827 }
4828
4829 sal_Bool VCLXTimeField::isEmpty() throw(::com::sun::star::uno::RuntimeException)
4830 {
4831     ::vos::OGuard aGuard( GetMutex() );
4832
4833     TimeField* pTimeField = (TimeField*) GetWindow();
4834     return pTimeField ? pTimeField->IsEmptyTime() : sal_False;
4835 }
4836
4837 void VCLXTimeField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
4838 {
4839     VCLXFormattedSpinField::setStrictFormat( bStrict );
4840 }
4841
4842 sal_Bool VCLXTimeField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
4843 {
4844     return VCLXFormattedSpinField::isStrictFormat();
4845 }
4846
4847
4848 void VCLXTimeField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
4849 {
4850     ::vos::OGuard aGuard( GetMutex() );
4851
4852     if ( GetWindow() )
4853     {
4854         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
4855
4856         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4857         switch ( nPropType )
4858         {
4859             case BASEPROPERTY_TIME:
4860             {
4861                 if ( bVoid )
4862                 {
4863                     ((TimeField*)GetWindow())->EnableEmptyFieldValue( sal_True );
4864                     ((TimeField*)GetWindow())->SetEmptyFieldValue();
4865                 }
4866                 else
4867                 {
4868                     sal_Int32 n = 0;
4869                     if ( Value >>= n )
4870                          setTime( n );
4871                 }
4872             }
4873             break;
4874             case BASEPROPERTY_TIMEMIN:
4875             {
4876                 sal_Int32 n = 0;
4877                 if ( Value >>= n )
4878                      setMin( n );
4879             }
4880             break;
4881             case BASEPROPERTY_TIMEMAX:
4882             {
4883                 sal_Int32 n = 0;
4884                 if ( Value >>= n )
4885                      setMax( n );
4886             }
4887             break;
4888             case BASEPROPERTY_EXTTIMEFORMAT:
4889             {
4890                 sal_Int16 n = sal_Int16();
4891                 if ( Value >>= n )
4892                     ((TimeField*)GetWindow())->SetExtFormat( (ExtTimeFieldFormat) n );
4893             }
4894             break;
4895             case BASEPROPERTY_ENFORCE_FORMAT:
4896             {
4897                 sal_Bool bEnforce( sal_True );
4898                 OSL_VERIFY( Value >>= bEnforce );
4899                 static_cast< TimeField* >( GetWindow() )->EnforceValidValue( bEnforce );
4900             }
4901             break;
4902             default:
4903             {
4904                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
4905             }
4906         }
4907     }
4908 }
4909
4910 ::com::sun::star::uno::Any VCLXTimeField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
4911 {
4912     ::vos::OGuard aGuard( GetMutex() );
4913
4914     ::com::sun::star::uno::Any aProp;
4915     if ( GetWindow() )
4916     {
4917         sal_uInt16 nPropType = GetPropertyId( PropertyName );
4918         switch ( nPropType )
4919         {
4920             case BASEPROPERTY_TIME:
4921             {
4922                 aProp <<= (sal_Int32) getTime();
4923             }
4924             break;
4925             case BASEPROPERTY_TIMEMIN:
4926             {
4927                 aProp <<= (sal_Int32) getMin();
4928             }
4929             break;
4930             case BASEPROPERTY_TIMEMAX:
4931             {
4932                 aProp <<= (sal_Int32) getMax();
4933             }
4934             break;
4935             case BASEPROPERTY_ENFORCE_FORMAT:
4936             {
4937                 aProp <<= (sal_Bool)static_cast< TimeField* >( GetWindow() )->IsEnforceValidValue( );
4938             }
4939             break;
4940             default:
4941             {
4942                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
4943             }
4944         }
4945     }
4946     return aProp;
4947 }
4948
4949 //      ----------------------------------------------------
4950 //      class VCLXNumericField
4951 //      ----------------------------------------------------
4952
4953 void VCLXNumericField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4954 {
4955     PushPropertyIds( rIds,
4956                      BASEPROPERTY_ALIGN,
4957                      BASEPROPERTY_BACKGROUNDCOLOR,
4958                      BASEPROPERTY_BORDER,
4959                      BASEPROPERTY_BORDERCOLOR,
4960                      BASEPROPERTY_DECIMALACCURACY,
4961                      BASEPROPERTY_DEFAULTCONTROL,
4962                      BASEPROPERTY_ENABLED,
4963                      BASEPROPERTY_ENABLEVISIBLE,
4964                      BASEPROPERTY_FONTDESCRIPTOR,
4965                      BASEPROPERTY_HELPTEXT,
4966                      BASEPROPERTY_HELPURL,
4967                      BASEPROPERTY_NUMSHOWTHOUSANDSEP,
4968                      BASEPROPERTY_PRINTABLE,
4969                      BASEPROPERTY_READONLY,
4970                      BASEPROPERTY_REPEAT,
4971                      BASEPROPERTY_REPEAT_DELAY,
4972                      BASEPROPERTY_SPIN,
4973                      BASEPROPERTY_STRICTFORMAT,
4974                      BASEPROPERTY_TABSTOP,
4975                      BASEPROPERTY_VALUEMAX_DOUBLE,
4976                      BASEPROPERTY_VALUEMIN_DOUBLE,
4977                      BASEPROPERTY_VALUESTEP_DOUBLE,
4978                      BASEPROPERTY_VALUE_DOUBLE,
4979                      BASEPROPERTY_ENFORCE_FORMAT,
4980                      BASEPROPERTY_HIDEINACTIVESELECTION,
4981                      BASEPROPERTY_WRITING_MODE,
4982                      BASEPROPERTY_CONTEXT_WRITING_MODE,
4983                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
4984                      0);
4985     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
4986 }
4987
4988 VCLXNumericField::VCLXNumericField()
4989 {
4990 }
4991
4992 VCLXNumericField::~VCLXNumericField()
4993 {
4994 }
4995
4996 // ::com::sun::star::uno::XInterface
4997 ::com::sun::star::uno::Any VCLXNumericField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
4998 {
4999     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5000                                         SAL_STATIC_CAST( ::com::sun::star::awt::XNumericField*, this ) );
5001     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5002 }
5003
5004 // ::com::sun::star::lang::XTypeProvider
5005 IMPL_XTYPEPROVIDER_START( VCLXNumericField )
5006     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XNumericField>* ) NULL ),
5007     VCLXFormattedSpinField::getTypes()
5008 IMPL_XTYPEPROVIDER_END
5009
5010 void VCLXNumericField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
5011 {
5012     ::vos::OGuard aGuard( GetMutex() );
5013
5014     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5015     if ( pNumericFormatter )
5016     {
5017         // z.B. 105, 2 Digits => 1,05
5018         // ein float 1,05 muss also eine 105 einstellen...
5019         pNumericFormatter->SetValue(
5020             (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5021
5022         // #107218# Call same listeners like VCL would do after user interaction
5023         Edit* pEdit = (Edit*)GetWindow();
5024         if ( pEdit )
5025         {
5026             SetSynthesizingVCLEvent( sal_True );
5027             pEdit->SetModifyFlag();
5028             pEdit->Modify();
5029             SetSynthesizingVCLEvent( sal_False );
5030         }
5031     }
5032 }
5033
5034 double VCLXNumericField::getValue() throw(::com::sun::star::uno::RuntimeException)
5035 {
5036     ::vos::OGuard aGuard( GetMutex() );
5037
5038     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5039     return pNumericFormatter
5040         ? ImplCalcDoubleValue( (double)pNumericFormatter->GetValue(), pNumericFormatter->GetDecimalDigits() )
5041         : 0;
5042 }
5043
5044 void VCLXNumericField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
5045 {
5046     ::vos::OGuard aGuard( GetMutex() );
5047
5048     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5049     if ( pNumericFormatter )
5050         pNumericFormatter->SetMin(
5051             (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5052 }
5053
5054 double VCLXNumericField::getMin() throw(::com::sun::star::uno::RuntimeException)
5055 {
5056     ::vos::OGuard aGuard( GetMutex() );
5057
5058     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5059     return pNumericFormatter
5060         ? ImplCalcDoubleValue( (double)pNumericFormatter->GetMin(), pNumericFormatter->GetDecimalDigits() )
5061         : 0;
5062 }
5063
5064 void VCLXNumericField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
5065 {
5066     ::vos::OGuard aGuard( GetMutex() );
5067
5068     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5069     if ( pNumericFormatter )
5070         pNumericFormatter->SetMax(
5071             (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5072 }
5073
5074 double VCLXNumericField::getMax() throw(::com::sun::star::uno::RuntimeException)
5075 {
5076     ::vos::OGuard aGuard( GetMutex() );
5077
5078     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5079     return pNumericFormatter
5080         ? ImplCalcDoubleValue( (double)pNumericFormatter->GetMax(), pNumericFormatter->GetDecimalDigits() )
5081         : 0;
5082 }
5083
5084 void VCLXNumericField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
5085 {
5086     ::vos::OGuard aGuard( GetMutex() );
5087
5088     NumericField* pNumericField = (NumericField*) GetWindow();
5089     if ( pNumericField )
5090         pNumericField->SetFirst(
5091             (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5092 }
5093
5094 double VCLXNumericField::getFirst() throw(::com::sun::star::uno::RuntimeException)
5095 {
5096     ::vos::OGuard aGuard( GetMutex() );
5097
5098     NumericField* pNumericField = (NumericField*) GetWindow();
5099     return pNumericField
5100         ? ImplCalcDoubleValue( (double)pNumericField->GetFirst(), pNumericField->GetDecimalDigits() )
5101         : 0;
5102 }
5103
5104 void VCLXNumericField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
5105 {
5106     ::vos::OGuard aGuard( GetMutex() );
5107
5108     NumericField* pNumericField = (NumericField*) GetWindow();
5109     if ( pNumericField )
5110         pNumericField->SetLast(
5111             (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5112 }
5113
5114 double VCLXNumericField::getLast() throw(::com::sun::star::uno::RuntimeException)
5115 {
5116     ::vos::OGuard aGuard( GetMutex() );
5117
5118     NumericField* pNumericField = (NumericField*) GetWindow();
5119     return pNumericField
5120         ? ImplCalcDoubleValue( (double)pNumericField->GetLast(), pNumericField->GetDecimalDigits() )
5121         : 0;
5122 }
5123
5124 void VCLXNumericField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
5125 {
5126     VCLXFormattedSpinField::setStrictFormat( bStrict );
5127 }
5128
5129 sal_Bool VCLXNumericField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
5130 {
5131     return VCLXFormattedSpinField::isStrictFormat();
5132 }
5133
5134
5135 void VCLXNumericField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
5136 {
5137     ::vos::OGuard aGuard( GetMutex() );
5138
5139     NumericField* pNumericField = (NumericField*) GetWindow();
5140     if ( pNumericField )
5141         pNumericField->SetSpinSize(
5142             (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5143 }
5144
5145 double VCLXNumericField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
5146 {
5147     ::vos::OGuard aGuard( GetMutex() );
5148
5149     NumericField* pNumericField = (NumericField*) GetWindow();
5150     return pNumericField
5151         ? ImplCalcDoubleValue( (double)pNumericField->GetSpinSize(), pNumericField->GetDecimalDigits() )
5152         : 0;
5153 }
5154
5155 void VCLXNumericField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
5156 {
5157     ::vos::OGuard aGuard( GetMutex() );
5158
5159     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5160     if ( pNumericFormatter )
5161     {
5162         double n = getValue();
5163         pNumericFormatter->SetDecimalDigits( Value );
5164         setValue( n );
5165        }
5166 }
5167
5168 sal_Int16 VCLXNumericField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
5169 {
5170     ::vos::OGuard aGuard( GetMutex() );
5171
5172     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5173     return pNumericFormatter ? pNumericFormatter->GetDecimalDigits() : 0;
5174 }
5175
5176 void VCLXNumericField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
5177 {
5178     ::vos::OGuard aGuard( GetMutex() );
5179
5180     if ( GetWindow() )
5181     {
5182         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
5183
5184         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5185         switch ( nPropType )
5186         {
5187             case BASEPROPERTY_VALUE_DOUBLE:
5188             {
5189                 if ( bVoid )
5190                 {
5191                     ((NumericField*)GetWindow())->EnableEmptyFieldValue( sal_True );
5192                     ((NumericField*)GetWindow())->SetEmptyFieldValue();
5193                 }
5194                 else
5195                 {
5196                     double d = 0;
5197                     if ( Value >>= d )
5198                          setValue( d );
5199                 }
5200             }
5201             break;
5202             case BASEPROPERTY_VALUEMIN_DOUBLE:
5203             {
5204                 double d = 0;
5205                 if ( Value >>= d )
5206                      setMin( d );
5207             }
5208             break;
5209             case BASEPROPERTY_VALUEMAX_DOUBLE:
5210             {
5211                 double d = 0;
5212                 if ( Value >>= d )
5213                      setMax( d );
5214             }
5215             break;
5216             case BASEPROPERTY_VALUESTEP_DOUBLE:
5217             {
5218                 double d = 0;
5219                 if ( Value >>= d )
5220                      setSpinSize( d );
5221             }
5222             break;
5223             case BASEPROPERTY_DECIMALACCURACY:
5224             {
5225                 sal_Int16 n = sal_Int16();
5226                 if ( Value >>= n )
5227                      setDecimalDigits( n );
5228             }
5229             break;
5230             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5231             {
5232                 sal_Bool b = sal_Bool();
5233                 if ( Value >>= b )
5234                      ((NumericField*)GetWindow())->SetUseThousandSep( b );
5235             }
5236             break;
5237             default:
5238             {
5239                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
5240             }
5241         }
5242     }
5243 }
5244
5245 ::com::sun::star::uno::Any VCLXNumericField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
5246 {
5247     ::vos::OGuard aGuard( GetMutex() );
5248
5249     ::com::sun::star::uno::Any aProp;
5250     FormatterBase* pFormatter = GetFormatter();
5251     if ( pFormatter )
5252     {
5253         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5254         switch ( nPropType )
5255         {
5256             case BASEPROPERTY_VALUE_DOUBLE:
5257             {
5258                 aProp <<= (double) getValue();
5259             }
5260             break;
5261             case BASEPROPERTY_VALUEMIN_DOUBLE:
5262             {
5263                 aProp <<= (double) getMin();
5264             }
5265             break;
5266             case BASEPROPERTY_VALUEMAX_DOUBLE:
5267             {
5268                 aProp <<= (double) getMax();
5269             }
5270             break;
5271             case BASEPROPERTY_VALUESTEP_DOUBLE:
5272             {
5273                 aProp <<= (double) getSpinSize();
5274             }
5275             break;
5276             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5277             {
5278                 aProp <<= (sal_Bool) ((NumericField*)GetWindow())->IsUseThousandSep();
5279             }
5280             break;
5281             default:
5282             {
5283                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5284             }
5285         }
5286     }
5287     return aProp;
5288 }
5289
5290
5291 //    ----------------------------------------------------
5292 //    class VCLXMetricField
5293 //    ----------------------------------------------------
5294
5295 void VCLXMetricField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5296 {
5297     PushPropertyIds( rIds,
5298                      BASEPROPERTY_ALIGN,
5299                      BASEPROPERTY_BACKGROUNDCOLOR,
5300                      BASEPROPERTY_BORDER,
5301                      BASEPROPERTY_BORDERCOLOR,
5302                      BASEPROPERTY_DECIMALACCURACY,
5303                      BASEPROPERTY_DEFAULTCONTROL,
5304                      BASEPROPERTY_ENABLED,
5305                      BASEPROPERTY_ENABLEVISIBLE,
5306                      BASEPROPERTY_FONTDESCRIPTOR,
5307                      BASEPROPERTY_HELPTEXT,
5308                      BASEPROPERTY_HELPURL,
5309                      BASEPROPERTY_NUMSHOWTHOUSANDSEP,
5310                      BASEPROPERTY_PRINTABLE,
5311                      BASEPROPERTY_READONLY,
5312                      BASEPROPERTY_REPEAT,
5313                      BASEPROPERTY_REPEAT_DELAY,
5314                      BASEPROPERTY_SPIN,
5315                      BASEPROPERTY_STRICTFORMAT,
5316                      BASEPROPERTY_TABSTOP,
5317                      BASEPROPERTY_ENFORCE_FORMAT,
5318                      BASEPROPERTY_HIDEINACTIVESELECTION,
5319                      BASEPROPERTY_UNIT,
5320                      BASEPROPERTY_CUSTOMUNITTEXT,
5321                      BASEPROPERTY_WRITING_MODE,
5322                      BASEPROPERTY_CONTEXT_WRITING_MODE,
5323                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5324                      0);
5325     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5326 }
5327
5328 VCLXMetricField::VCLXMetricField()
5329 {
5330 }
5331
5332 VCLXMetricField::~VCLXMetricField()
5333 {
5334 }
5335
5336 MetricFormatter *VCLXMetricField::GetMetricFormatter() throw(::com::sun::star::uno::RuntimeException)
5337 {
5338     MetricFormatter *pFormatter = (MetricFormatter *) GetFormatter();
5339     if (!pFormatter)
5340         throw ::com::sun::star::uno::RuntimeException();
5341     return pFormatter;
5342 }
5343
5344 MetricField *VCLXMetricField::GetMetricField() throw(::com::sun::star::uno::RuntimeException)
5345 {
5346     MetricField *pField = (MetricField *) GetWindow();
5347     if (!pField)
5348         throw ::com::sun::star::uno::RuntimeException();
5349     return pField;
5350 }
5351
5352 // ::com::sun::star::uno::XInterface
5353 ::com::sun::star::uno::Any VCLXMetricField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
5354 {
5355     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5356                                                               SAL_STATIC_CAST( ::com::sun::star::awt::XMetricField*, this ) );
5357     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5358 }
5359
5360 // ::com::sun::star::lang::XTypeProvider
5361 IMPL_XTYPEPROVIDER_START( VCLXMetricField )
5362     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMetricField>* ) NULL ),
5363     VCLXFormattedSpinField::getTypes()
5364 IMPL_XTYPEPROVIDER_END
5365
5366 // FIXME: later ...
5367 #define MetricUnitUnoToVcl(a) ((FieldUnit)(a))
5368
5369 #define METRIC_MAP_PAIR(method,parent) \
5370     sal_Int64 VCLXMetricField::get##method( sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException) \
5371     { \
5372         ::vos::OGuard aGuard( GetMutex() ); \
5373         return GetMetric##parent()->Get##method( MetricUnitUnoToVcl( nUnit ) ); \
5374     } \
5375     void VCLXMetricField::set##method( sal_Int64 nValue, sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException) \
5376     { \
5377         ::vos::OGuard aGuard( GetMutex() ); \
5378         GetMetric##parent()->Set##method( nValue, MetricUnitUnoToVcl( nUnit ) ); \
5379     }
5380
5381 METRIC_MAP_PAIR(Min, Formatter)
5382 METRIC_MAP_PAIR(Max, Formatter)
5383 METRIC_MAP_PAIR(First, Field)
5384 METRIC_MAP_PAIR(Last,  Field)
5385
5386 #undef METRIC_MAP_PAIR
5387
5388 ::sal_Int64 VCLXMetricField::getValue( ::sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException)
5389 {
5390     ::vos::OGuard aGuard( GetMutex() );
5391     return GetMetricFormatter()->GetValue( MetricUnitUnoToVcl( nUnit ) );
5392 }
5393
5394 ::sal_Int64 VCLXMetricField::getCorrectedValue( ::sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException)
5395 {
5396     ::vos::OGuard aGuard( GetMutex() );
5397     return GetMetricFormatter()->GetCorrectedValue( MetricUnitUnoToVcl( nUnit ) );
5398 }
5399
5400 // FIXME: acute cut/paste evilness - move this to the parent Edit class ?
5401 void VCLXMetricField::CallListeners()
5402 {
5403     // #107218# Call same listeners like VCL would do after user interaction
5404     Edit* pEdit = (Edit*)GetWindow();
5405     if ( pEdit )
5406     {
5407         SetSynthesizingVCLEvent( sal_True );
5408         pEdit->SetModifyFlag();
5409         pEdit->Modify();
5410         SetSynthesizingVCLEvent( sal_False );
5411     }
5412 }
5413
5414 void VCLXMetricField::setValue( ::sal_Int64 Value, ::sal_Int16 Unit ) throw (::com::sun::star::uno::RuntimeException)
5415 {
5416     ::vos::OGuard aGuard( GetMutex() );
5417     GetMetricFormatter()->SetValue( Value, MetricUnitUnoToVcl( Unit ) );
5418     CallListeners();
5419 }
5420
5421 void VCLXMetricField::setUserValue( ::sal_Int64 Value, ::sal_Int16 Unit ) throw (::com::sun::star::uno::RuntimeException)
5422 {
5423     ::vos::OGuard aGuard( GetMutex() );
5424     GetMetricFormatter()->SetUserValue( Value, MetricUnitUnoToVcl( Unit ) );
5425     CallListeners();
5426 }
5427
5428 void VCLXMetricField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
5429 {
5430     VCLXFormattedSpinField::setStrictFormat( bStrict );
5431 }
5432
5433 sal_Bool VCLXMetricField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
5434 {
5435     return VCLXFormattedSpinField::isStrictFormat();
5436 }
5437
5438 void VCLXMetricField::setSpinSize( sal_Int64 Value ) throw(::com::sun::star::uno::RuntimeException)
5439 {
5440     ::vos::OGuard aGuard( GetMutex() );
5441     GetMetricField()->SetSpinSize( Value );
5442 }
5443
5444 sal_Int64 VCLXMetricField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
5445 {
5446     ::vos::OGuard aGuard( GetMutex() );
5447     return GetMetricField()->GetSpinSize();
5448 }
5449
5450 void VCLXMetricField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
5451 {
5452     ::vos::OGuard aGuard( GetMutex() );
5453     GetMetricFormatter()->SetDecimalDigits( Value );
5454 }
5455
5456 sal_Int16 VCLXMetricField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
5457 {
5458     ::vos::OGuard aGuard( GetMutex() );
5459
5460     NumericFormatter* pNumericFormatter = (NumericFormatter*) GetFormatter();
5461     return pNumericFormatter ? pNumericFormatter->GetDecimalDigits() : 0;
5462 }
5463
5464 void VCLXMetricField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
5465 {
5466     ::vos::OGuard aGuard( GetMutex() );
5467
5468     if ( GetWindow() )
5469     {
5470         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5471         switch ( nPropType )
5472         {
5473             case BASEPROPERTY_DECIMALACCURACY:
5474             {
5475                 sal_Int16 n = 0;
5476                 if ( Value >>= n )
5477                      setDecimalDigits( n );
5478                 break;
5479             }
5480             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5481             {
5482                 sal_Bool b = sal_False;
5483                 if ( Value >>= b )
5484                      ((NumericField*)GetWindow())->SetUseThousandSep( b );
5485             }
5486             break;
5487             case BASEPROPERTY_UNIT:
5488             {
5489                 sal_uInt16 nVal = 0;
5490                 if ( Value >>= nVal )
5491                     ((MetricField*)GetWindow())->SetUnit( (FieldUnit) nVal );
5492                 break;
5493             }
5494             case BASEPROPERTY_CUSTOMUNITTEXT:
5495             {
5496                 rtl::OUString aStr;
5497                 if ( Value >>= aStr )
5498                     ((MetricField*)GetWindow())->SetCustomUnitText( aStr );
5499                 break;
5500             }
5501             default:
5502             {
5503                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
5504                 break;
5505             }
5506         }
5507     }
5508 }
5509
5510 ::com::sun::star::uno::Any VCLXMetricField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
5511 {
5512     ::vos::OGuard aGuard( GetMutex() );
5513
5514     ::com::sun::star::uno::Any aProp;
5515     FormatterBase* pFormatter = GetFormatter();
5516     if ( pFormatter )
5517     {
5518         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5519         switch ( nPropType )
5520         {
5521             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5522                 aProp <<= (sal_Bool) ((NumericField*)GetWindow())->IsUseThousandSep();
5523                 break;
5524             case BASEPROPERTY_UNIT:
5525                 aProp <<= (sal_uInt16) ((MetricField*)GetWindow())->GetUnit();
5526                 break;
5527             case BASEPROPERTY_CUSTOMUNITTEXT:
5528                 aProp <<= rtl::OUString (((MetricField*)GetWindow())->GetCustomUnitText());
5529                 break;
5530             default:
5531             {
5532                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5533                 break;
5534             }
5535         }
5536     }
5537     return aProp;
5538 }
5539
5540
5541 //      ----------------------------------------------------
5542 //      class VCLXCurrencyField
5543 //      ----------------------------------------------------
5544
5545 void VCLXCurrencyField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5546 {
5547     PushPropertyIds( rIds,
5548                      BASEPROPERTY_ALIGN,
5549                      BASEPROPERTY_BACKGROUNDCOLOR,
5550                      BASEPROPERTY_BORDER,
5551                      BASEPROPERTY_BORDERCOLOR,
5552                      BASEPROPERTY_CURRENCYSYMBOL,
5553                      BASEPROPERTY_CURSYM_POSITION,
5554                      BASEPROPERTY_DECIMALACCURACY,
5555                      BASEPROPERTY_DEFAULTCONTROL,
5556                      BASEPROPERTY_ENABLED,
5557                      BASEPROPERTY_ENABLEVISIBLE,
5558                      BASEPROPERTY_FONTDESCRIPTOR,
5559                      BASEPROPERTY_HELPTEXT,
5560                      BASEPROPERTY_HELPURL,
5561                      BASEPROPERTY_NUMSHOWTHOUSANDSEP,
5562                      BASEPROPERTY_PRINTABLE,
5563                      BASEPROPERTY_READONLY,
5564                      BASEPROPERTY_REPEAT,
5565                      BASEPROPERTY_REPEAT_DELAY,
5566                      BASEPROPERTY_SPIN,
5567                      BASEPROPERTY_STRICTFORMAT,
5568                      BASEPROPERTY_TABSTOP,
5569                      BASEPROPERTY_VALUEMAX_DOUBLE,
5570                      BASEPROPERTY_VALUEMIN_DOUBLE,
5571                      BASEPROPERTY_VALUESTEP_DOUBLE,
5572                      BASEPROPERTY_VALUE_DOUBLE,
5573                      BASEPROPERTY_ENFORCE_FORMAT,
5574                      BASEPROPERTY_HIDEINACTIVESELECTION,
5575                      BASEPROPERTY_WRITING_MODE,
5576                      BASEPROPERTY_CONTEXT_WRITING_MODE,
5577                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5578                      0);
5579     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5580 }
5581
5582 VCLXCurrencyField::VCLXCurrencyField()
5583 {
5584 }
5585
5586 VCLXCurrencyField::~VCLXCurrencyField()
5587 {
5588 }
5589
5590 // ::com::sun::star::uno::XInterface
5591 ::com::sun::star::uno::Any VCLXCurrencyField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
5592 {
5593     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5594                                         SAL_STATIC_CAST( ::com::sun::star::awt::XCurrencyField*, this ) );
5595     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5596 }
5597
5598 // ::com::sun::star::lang::XTypeProvider
5599 IMPL_XTYPEPROVIDER_START( VCLXCurrencyField )
5600     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XCurrencyField>* ) NULL ),
5601     VCLXFormattedSpinField::getTypes()
5602 IMPL_XTYPEPROVIDER_END
5603
5604 void VCLXCurrencyField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
5605 {
5606     ::vos::OGuard aGuard( GetMutex() );
5607
5608     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5609     if ( pCurrencyFormatter )
5610     {
5611         // z.B. 105, 2 Digits => 1,05
5612         // ein float 1,05 muss also eine 105 einstellen...
5613         pCurrencyFormatter->SetValue(
5614             ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
5615
5616         // #107218# Call same listeners like VCL would do after user interaction
5617         Edit* pEdit = (Edit*)GetWindow();
5618         if ( pEdit )
5619         {
5620             SetSynthesizingVCLEvent( sal_True );
5621             pEdit->SetModifyFlag();
5622             pEdit->Modify();
5623             SetSynthesizingVCLEvent( sal_False );
5624         }
5625     }
5626 }
5627
5628 double VCLXCurrencyField::getValue() throw(::com::sun::star::uno::RuntimeException)
5629 {
5630     ::vos::OGuard aGuard( GetMutex() );
5631
5632     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5633     return pCurrencyFormatter
5634         ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetValue(), pCurrencyFormatter->GetDecimalDigits() )
5635         : 0;
5636 }
5637
5638 void VCLXCurrencyField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
5639 {
5640     ::vos::OGuard aGuard( GetMutex() );
5641
5642     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5643     if ( pCurrencyFormatter )
5644         pCurrencyFormatter->SetMin(
5645             ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
5646 }
5647
5648 double VCLXCurrencyField::getMin() throw(::com::sun::star::uno::RuntimeException)
5649 {
5650     ::vos::OGuard aGuard( GetMutex() );
5651
5652     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5653     return pCurrencyFormatter
5654         ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetMin(), pCurrencyFormatter->GetDecimalDigits() )
5655         : 0;
5656 }
5657
5658 void VCLXCurrencyField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
5659 {
5660     ::vos::OGuard aGuard( GetMutex() );
5661
5662     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5663     if ( pCurrencyFormatter )
5664         pCurrencyFormatter->SetMax(
5665             ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
5666 }
5667
5668 double VCLXCurrencyField::getMax() throw(::com::sun::star::uno::RuntimeException)
5669 {
5670     ::vos::OGuard aGuard( GetMutex() );
5671
5672     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5673     return pCurrencyFormatter
5674         ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetMax(), pCurrencyFormatter->GetDecimalDigits() )
5675         : 0;
5676 }
5677
5678 void VCLXCurrencyField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
5679 {
5680     ::vos::OGuard aGuard( GetMutex() );
5681
5682     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5683     if ( pCurrencyField )
5684         pCurrencyField->SetFirst(
5685             ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
5686 }
5687
5688 double VCLXCurrencyField::getFirst() throw(::com::sun::star::uno::RuntimeException)
5689 {
5690     ::vos::OGuard aGuard( GetMutex() );
5691
5692     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5693     return pCurrencyField
5694         ? ImplCalcDoubleValue( (double)pCurrencyField->GetFirst(), pCurrencyField->GetDecimalDigits() )
5695         : 0;
5696 }
5697
5698 void VCLXCurrencyField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
5699 {
5700     ::vos::OGuard aGuard( GetMutex() );
5701
5702     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5703     if ( pCurrencyField )
5704         pCurrencyField->SetLast(
5705             ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
5706 }
5707
5708 double VCLXCurrencyField::getLast() throw(::com::sun::star::uno::RuntimeException)
5709 {
5710     ::vos::OGuard aGuard( GetMutex() );
5711
5712     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5713     return pCurrencyField
5714         ? ImplCalcDoubleValue( (double)pCurrencyField->GetLast(), pCurrencyField->GetDecimalDigits() )
5715         : 0;
5716 }
5717
5718 void VCLXCurrencyField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
5719 {
5720     ::vos::OGuard aGuard( GetMutex() );
5721
5722     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5723     if ( pCurrencyField )
5724         pCurrencyField->SetSpinSize(
5725             ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
5726 }
5727
5728 double VCLXCurrencyField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
5729 {
5730     ::vos::OGuard aGuard( GetMutex() );
5731
5732     LongCurrencyField* pCurrencyField = (LongCurrencyField*) GetWindow();
5733     return pCurrencyField
5734         ? ImplCalcDoubleValue( (double)pCurrencyField->GetSpinSize(), pCurrencyField->GetDecimalDigits() )
5735         : 0;
5736 }
5737
5738 void VCLXCurrencyField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
5739 {
5740     VCLXFormattedSpinField::setStrictFormat( bStrict );
5741 }
5742
5743 sal_Bool VCLXCurrencyField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
5744 {
5745     return VCLXFormattedSpinField::isStrictFormat();
5746 }
5747
5748
5749 void VCLXCurrencyField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
5750 {
5751     ::vos::OGuard aGuard( GetMutex() );
5752
5753     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5754     if ( pCurrencyFormatter )
5755     {
5756         double n = getValue();
5757         pCurrencyFormatter->SetDecimalDigits( Value );
5758         setValue( n );
5759        }
5760 }
5761
5762 sal_Int16 VCLXCurrencyField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
5763 {
5764     ::vos::OGuard aGuard( GetMutex() );
5765
5766     LongCurrencyFormatter* pCurrencyFormatter = (LongCurrencyFormatter*) GetFormatter();
5767     return pCurrencyFormatter ? pCurrencyFormatter->GetDecimalDigits() : 0;
5768 }
5769
5770 void VCLXCurrencyField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
5771 {
5772     ::vos::OGuard aGuard( GetMutex() );
5773
5774     if ( GetWindow() )
5775     {
5776         sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
5777
5778         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5779         switch ( nPropType )
5780         {
5781             case BASEPROPERTY_VALUE_DOUBLE:
5782             {
5783                 if ( bVoid )
5784                 {
5785                     ((LongCurrencyField*)GetWindow())->EnableEmptyFieldValue( sal_True );
5786                     ((LongCurrencyField*)GetWindow())->SetEmptyFieldValue();
5787                 }
5788                 else
5789                 {
5790                     double d = 0;
5791                     if ( Value >>= d )
5792                          setValue( d );
5793                 }
5794             }
5795             break;
5796             case BASEPROPERTY_VALUEMIN_DOUBLE:
5797             {
5798                 double d = 0;
5799                 if ( Value >>= d )
5800                      setMin( d );
5801             }
5802             break;
5803             case BASEPROPERTY_VALUEMAX_DOUBLE:
5804             {
5805                 double d = 0;
5806                 if ( Value >>= d )
5807                      setMax( d );
5808             }
5809             break;
5810             case BASEPROPERTY_VALUESTEP_DOUBLE:
5811             {
5812                 double d = 0;
5813                 if ( Value >>= d )
5814                      setSpinSize( d );
5815             }
5816             break;
5817             case BASEPROPERTY_DECIMALACCURACY:
5818             {
5819                 sal_Int16 n = sal_Int16();
5820                 if ( Value >>= n )
5821                      setDecimalDigits( n );
5822             }
5823             break;
5824             case BASEPROPERTY_CURRENCYSYMBOL:
5825             {
5826                 ::rtl::OUString aString;
5827                 if ( Value >>= aString )
5828                      ((LongCurrencyField*)GetWindow())->SetCurrencySymbol( aString );
5829             }
5830             break;
5831             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5832             {
5833                 sal_Bool b = sal_Bool();
5834                 if ( Value >>= b )
5835                      ((LongCurrencyField*)GetWindow())->SetUseThousandSep( b );
5836             }
5837             break;
5838             default:
5839             {
5840                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
5841             }
5842         }
5843     }
5844 }
5845
5846 ::com::sun::star::uno::Any VCLXCurrencyField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
5847 {
5848     ::vos::OGuard aGuard( GetMutex() );
5849
5850     ::com::sun::star::uno::Any aProp;
5851     FormatterBase* pFormatter = GetFormatter();
5852     if ( pFormatter )
5853     {
5854         sal_uInt16 nPropType = GetPropertyId( PropertyName );
5855         switch ( nPropType )
5856         {
5857             case BASEPROPERTY_VALUE_DOUBLE:
5858             {
5859                 aProp <<= (double) getValue();
5860             }
5861             break;
5862             case BASEPROPERTY_VALUEMIN_DOUBLE:
5863             {
5864                 aProp <<= (double) getMin();
5865             }
5866             break;
5867             case BASEPROPERTY_VALUEMAX_DOUBLE:
5868             {
5869                 aProp <<= (double) getMax();
5870             }
5871             break;
5872             case BASEPROPERTY_VALUESTEP_DOUBLE:
5873             {
5874                 aProp <<= (double) getSpinSize();
5875             }
5876             break;
5877             case BASEPROPERTY_CURRENCYSYMBOL:
5878             {
5879                 aProp <<= ::rtl::OUString( ((LongCurrencyField*)GetWindow())->GetCurrencySymbol() );
5880             }
5881             break;
5882             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5883             {
5884                 aProp <<= (sal_Bool) ((LongCurrencyField*)GetWindow())->IsUseThousandSep();
5885             }
5886             break;
5887             default:
5888             {
5889                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5890             }
5891         }
5892     }
5893     return aProp;
5894 }
5895
5896 //      ----------------------------------------------------
5897 //      class VCLXPatternField
5898 //      ----------------------------------------------------
5899
5900 void VCLXPatternField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5901 {
5902     PushPropertyIds( rIds,
5903                      BASEPROPERTY_ALIGN,
5904                      BASEPROPERTY_BACKGROUNDCOLOR,
5905                      BASEPROPERTY_BORDER,
5906                      BASEPROPERTY_BORDERCOLOR,
5907                      BASEPROPERTY_DEFAULTCONTROL,
5908                      BASEPROPERTY_EDITMASK,
5909                      BASEPROPERTY_ENABLED,
5910                      BASEPROPERTY_ENABLEVISIBLE,
5911                      BASEPROPERTY_FONTDESCRIPTOR,
5912                      BASEPROPERTY_HELPTEXT,
5913                      BASEPROPERTY_HELPURL,
5914                      BASEPROPERTY_LITERALMASK,
5915                      BASEPROPERTY_MAXTEXTLEN,
5916                      BASEPROPERTY_PRINTABLE,
5917                      BASEPROPERTY_READONLY,
5918                      BASEPROPERTY_STRICTFORMAT,
5919                      BASEPROPERTY_TABSTOP,
5920                      BASEPROPERTY_TEXT,
5921                      BASEPROPERTY_HIDEINACTIVESELECTION,
5922                      BASEPROPERTY_WRITING_MODE,
5923                      BASEPROPERTY_CONTEXT_WRITING_MODE,
5924                      BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5925                      0);
5926     VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5927 }
5928
5929 VCLXPatternField::VCLXPatternField()
5930 {
5931 }
5932
5933 VCLXPatternField::~VCLXPatternField()
5934 {
5935 }
5936
5937 // ::com::sun::star::uno::XInterface
5938 ::com::sun::star::uno::Any VCLXPatternField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
5939 {
5940     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5941                                         SAL_STATIC_CAST( ::com::sun::star::awt::XPatternField*, this ) );
5942     return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5943 }
5944
5945 // ::com::sun::star::lang::XTypeProvider
5946 IMPL_XTYPEPROVIDER_START( VCLXPatternField )
5947     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPatternField>* ) NULL ),
5948     VCLXFormattedSpinField::getTypes()
5949 IMPL_XTYPEPROVIDER_END
5950
5951 void VCLXPatternField::setMasks( const ::rtl::OUString& EditMask, const ::rtl::OUString& LiteralMask ) throw(::com::sun::star::uno::RuntimeException)
5952 {
5953     ::vos::OGuard aGuard( GetMutex() );
5954
5955     PatternField* pPatternField = (PatternField*) GetWindow();
5956     if ( pPatternField )
5957     {
5958         pPatternField->SetMask( ByteString( UniString( EditMask ), RTL_TEXTENCODING_ASCII_US ), LiteralMask );
5959     }
5960 }
5961
5962 void VCLXPatternField::getMasks( ::rtl::OUString& EditMask, ::rtl::OUString& LiteralMask ) throw(::com::sun::star::uno::RuntimeException)
5963 {
5964     ::vos::OGuard aGuard( GetMutex() );
5965
5966     PatternField* pPatternField = (PatternField*) GetWindow();
5967     if ( pPatternField )
5968     {
5969         EditMask = String( pPatternField->GetEditMask(), RTL_TEXTENCODING_ASCII_US );
5970         LiteralMask = pPatternField->GetLiteralMask();
5971     }
5972 }
5973
5974 void VCLXPatternField::setString( const ::rtl::OUString& Str ) throw(::com::sun::star::uno::RuntimeException)
5975 {
5976     ::vos::OGuard aGuard( GetMutex() );
5977
5978     PatternField* pPatternField = (PatternField*) GetWindow();
5979     if ( pPatternField )
5980     {
5981         pPatternField->SetString( Str );
5982     }
5983 }
5984
5985 ::rtl::OUString VCLXPatternField::getString() throw(::com::sun::star::uno::RuntimeException)
5986 {
5987     ::vos::OGuard aGuard( GetMutex() );
5988
5989     ::rtl::OUString aString;
5990     PatternField* pPatternField = (PatternField*) GetWindow();
5991     if ( pPatternField )
5992         aString = pPatternField->GetString();
5993     return aString;
5994 }
5995
5996 void VCLXPatternField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
5997 {
5998     VCLXFormattedSpinField::setStrictFormat( bStrict );
5999 }
6000
6001 sal_Bool VCLXPatternField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
6002 {
6003     return VCLXFormattedSpinField::isStrictFormat();
6004 }
6005
6006 void VCLXPatternField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
6007 {
6008     ::vos::OGuard aGuard( GetMutex() );
6009
6010     if ( GetWindow() )
6011     {
6012         sal_uInt16 nPropType = GetPropertyId( PropertyName );
6013         switch ( nPropType )
6014         {
6015             case BASEPROPERTY_EDITMASK:
6016             case BASEPROPERTY_LITERALMASK:
6017             {
6018                 ::rtl::OUString aString;
6019                 if ( Value >>= aString )
6020                 {
6021                     ::rtl::OUString aEditMask, aLiteralMask;
6022                     getMasks( aEditMask, aLiteralMask );
6023                     if ( nPropType == BASEPROPERTY_EDITMASK )
6024                         aEditMask = aString;
6025                     else
6026                         aLiteralMask = aString;
6027                      setMasks( aEditMask, aLiteralMask );
6028                 }
6029             }
6030             break;
6031             default:
6032             {
6033                 VCLXFormattedSpinField::setProperty( PropertyName, Value );
6034             }
6035         }
6036     }
6037 }
6038
6039 ::com::sun::star::uno::Any VCLXPatternField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
6040 {
6041     ::vos::OGuard aGuard( GetMutex() );
6042
6043     ::com::sun::star::uno::Any aProp;
6044     if ( GetWindow() )
6045     {
6046         sal_uInt16 nPropType = GetPropertyId( PropertyName );
6047         switch ( nPropType )
6048         {
6049             case BASEPROPERTY_EDITMASK:
6050             case BASEPROPERTY_LITERALMASK:
6051             {
6052                 ::rtl::OUString aEditMask, aLiteralMask;
6053                 getMasks( aEditMask, aLiteralMask );
6054                 if ( nPropType == BASEPROPERTY_EDITMASK )
6055                     aProp <<= aEditMask;
6056                 else
6057                     aProp <<= aLiteralMask;
6058             }
6059             break;
6060             default:
6061             {
6062                 aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
6063             }
6064         }
6065     }
6066     return aProp;
6067 }
6068
6069 //      ----------------------------------------------------
6070 //      class VCLXToolBox
6071 //      ----------------------------------------------------
6072 VCLXToolBox::VCLXToolBox()
6073 {
6074 }
6075
6076 VCLXToolBox::~VCLXToolBox()
6077 {
6078 }
6079
6080 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXToolBox::CreateAccessibleContext()
6081 {
6082     return getAccessibleFactory().createAccessibleContext( this );
6083 }
6084