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