toolkit/source/awt/vclxwindows.cxx

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