toolkit/source/awt/vclxwindows.cxx

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