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