svtools/source/uno/unoiface.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
  21 #include <tools/debug.hxx>
  22 #include <vcl/fixedhyper.hxx>
  23 #include <vcl/prgsbar.hxx>
  24 #include <vcl/svapp.hxx>
  25 #include <svtools/svmedit.hxx>
  26 #include <unoiface.hxx>
  27 #include <svtools/filectrl.hxx>
  28 #include <svtools/roadmap.hxx>
  29 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  30 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  31 #include <com/sun/star/awt/LineEndFormat.hpp>
  32 #include <comphelper/processfactory.hxx>
  33 #include <toolkit/helper/convert.hxx>
  34 #include <toolkit/helper/property.hxx>
  35 #include <svtools/fmtfield.hxx>
  36 #include <svl/numuno.hxx>
  37 #include <svtools/calendar.hxx>
  38 #include <svtools/treelistbox.hxx>
  39 #include "treecontrolpeer.hxx"
  40 #include "svtxgridcontrol.hxx"
  41 #include <svtools/table/tablecontrol.hxx>
  42
  43 namespace
  44 {
  45     static void lcl_setWinBits( Window* _pWindow, WinBits _nBits, sal_Bool _bSet )
  46     {
  47         WinBits nStyle = _pWindow->GetStyle();
  48         if ( _bSet )
  49             nStyle |= _nBits;
  50         else
  51             nStyle &= ~_nBits;
  52         _pWindow->SetStyle( nStyle );
  53     }
  54 }
  55
  56 //  ----------------------------------------------------
  57 //  help function for the toolkit...
  58 //  ----------------------------------------------------
  59
  60 extern "C" {
  61
  62 SAL_DLLPUBLIC_EXPORT Window* CreateWindow( VCLXWindow** ppNewComp, const ::com::sun::star::awt::WindowDescriptor* pDescriptor, Window* pParent, WinBits nWinBits )
  63 {
  64     Window* pWindow = NULL;
  65     String aServiceName( pDescriptor->WindowServiceName );
  66     if ( aServiceName.EqualsIgnoreCaseAscii( "MultiLineEdit" ) )
  67     {
  68         if ( pParent )
  69         {
  70             pWindow = new MultiLineEdit( pParent, nWinBits|WB_IGNORETAB);
  71             static_cast< MultiLineEdit* >( pWindow )->DisableSelectionOnFocus();
  72             *ppNewComp = new VCLXMultiLineEdit;
  73         }
  74         else
  75         {
  76             *ppNewComp = NULL;
  77             return NULL;
  78         }
  79     }
  80     else if ( aServiceName.EqualsIgnoreCaseAscii( "FileControl" ) )
  81     {
  82         if ( pParent )
  83         {
  84             pWindow = new FileControl( pParent, nWinBits );
  85             *ppNewComp = new VCLXFileControl;
  86         }
  87         else
  88         {
  89             *ppNewComp = NULL;
  90             return NULL;
  91         }
  92     }
  93     else if (aServiceName.EqualsIgnoreCaseAscii("FormattedField") )
  94     {
  95         pWindow = new FormattedField( pParent, nWinBits );
  96         *ppNewComp = new SVTXFormattedField;
  97     }
  98     else if (aServiceName.EqualsIgnoreCaseAscii("NumericField") )
  99     {
 100         pWindow = new DoubleNumericField( pParent, nWinBits );
 101         *ppNewComp = new SVTXNumericField;
 102     }
 103     else if (aServiceName.EqualsIgnoreCaseAscii("LongCurrencyField") )
 104     {
 105         pWindow = new DoubleCurrencyField( pParent, nWinBits );
 106         *ppNewComp = new SVTXCurrencyField;
 107     }
 108     else if (aServiceName.EqualsIgnoreCaseAscii("datefield") )
 109     {
 110         pWindow = new CalendarField( pParent, nWinBits);
 111         static_cast<CalendarField*>(pWindow)->EnableToday();
 112         static_cast<CalendarField*>(pWindow)->EnableNone();
 113         static_cast<CalendarField*>(pWindow)->EnableEmptyFieldValue( sal_True );
 114         *ppNewComp = new SVTXDateField;
 115         ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(DateField*)pWindow );
 116     }
 117     else if (aServiceName.EqualsIgnoreCaseAscii("roadmap") )
 118     {
 119         pWindow = new ::svt::ORoadmap( pParent, WB_TABSTOP );
 120         *ppNewComp = new SVTXRoadmap;
 121     }
 122     else if ( aServiceName.EqualsIgnoreCaseAscii( "ProgressBar" ) )
 123     {
 124         if ( pParent )
 125         {
 126             pWindow = new ProgressBar( pParent, nWinBits );
 127             *ppNewComp = new VCLXProgressBar;
 128         }
 129         else
 130         {
 131             *ppNewComp = NULL;
 132             return NULL;
 133         }
 134     }
 135     else if ( aServiceName.EqualsIgnoreCaseAscii( "Tree" ) )
 136     {
 137         TreeControlPeer* pPeer = new TreeControlPeer;
 138         *ppNewComp = pPeer;
 139         pWindow = pPeer->createVclControl( pParent, nWinBits );
 140     }
 141     else if ( aServiceName.EqualsIgnoreCaseAscii( "FixedHyperlink" ) )
 142     {
 143         if ( pParent )
 144         {
 145             pWindow = new FixedHyperlink( pParent, nWinBits );
 146             *ppNewComp = new VCLXFixedHyperlink;
 147         }
 148         else
 149         {
 150             *ppNewComp = NULL;
 151             return NULL;
 152         }
 153     }
 154     else if ( aServiceName.EqualsIgnoreCaseAscii( "Grid" ) )
 155     {
 156         if ( pParent )
 157         {
 158             pWindow = new ::svt::table::TableControl(pParent, nWinBits);
 159             *ppNewComp = new SVTXGridControl;
 160         }
 161         else
 162         {
 163             *ppNewComp = NULL;
 164             return NULL;
 165         }
 166     }
 167     return pWindow;
 168 }
 169
 170 }   // extern "C"
 171
 172 //  ----------------------------------------------------
 173 //  class VCLXMultiLineEdit
 174 //  ----------------------------------------------------
 175 VCLXMultiLineEdit::VCLXMultiLineEdit()
 176     :maTextListeners( *this )
 177     ,meLineEndType( LINEEND_LF )    // default behavior before introducing this property: LF (unix-like)
 178 {
 179 }
 180
 181 VCLXMultiLineEdit::~VCLXMultiLineEdit()
 182 {
 183 }
 184
 185 ::com::sun::star::uno::Any VCLXMultiLineEdit::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
 186 {
 187     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
 188                                         (static_cast< ::com::sun::star::awt::XTextComponent* >(this)),
 189                                         (static_cast< ::com::sun::star::awt::XTextArea* >(this)),
 190                                         (static_cast< ::com::sun::star::awt::XTextLayoutConstrains* >(this)),
 191                                         (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
 192     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
 193 }
 194
 195 // ::com::sun::star::lang::XTypeProvider
 196 IMPL_XTYPEPROVIDER_START( VCLXMultiLineEdit )
 197     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ),
 198     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextArea>* ) NULL ),
 199     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
 200     VCLXWindow::getTypes()
 201 IMPL_XTYPEPROVIDER_END
 202
 203 void VCLXMultiLineEdit::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 204 {
 205     maTextListeners.addInterface( l );
 206 }
 207
 208 void VCLXMultiLineEdit::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 209 {
 210     maTextListeners.removeInterface( l );
 211 }
 212
 213 void VCLXMultiLineEdit::setText( const OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
 214 {
 215     SolarMutexGuard aGuard;
 216
 217     MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
 218     if ( pEdit )
 219     {
 220         pEdit->SetText( aText );
 221
 222         // #107218# Call same listeners like VCL would do after user interaction
 223         SetSynthesizingVCLEvent( sal_True );
 224         pEdit->SetModifyFlag();
 225         pEdit->Modify();
 226         SetSynthesizingVCLEvent( sal_False );
 227     }
 228 }
 229
 230 void VCLXMultiLineEdit::insertText( const ::com::sun::star::awt::Selection& rSel, const OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
 231 {
 232     SolarMutexGuard aGuard;
 233
 234     MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
 235     if ( pEdit )
 236     {
 237         setSelection( rSel );
 238         pEdit->ReplaceSelected( aText );
 239     }
 240 }
 241
 242 OUString VCLXMultiLineEdit::getText() throw(::com::sun::star::uno::RuntimeException)
 243 {
 244     SolarMutexGuard aGuard;
 245
 246     OUString aText;
 247     MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
 248     if ( pEdit )
 249         aText = pEdit->GetText( meLineEndType );
 250     return aText;
 251 }
 252
 253 OUString VCLXMultiLineEdit::getSelectedText() throw(::com::sun::star::uno::RuntimeException)
 254 {
 255     SolarMutexGuard aGuard;
 256
 257     OUString aText;
 258     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 259     if ( pMultiLineEdit)
 260         aText = pMultiLineEdit->GetSelected( meLineEndType );
 261     return aText;
 262
 263 }
 264
 265 void VCLXMultiLineEdit::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException)
 266 {
 267     SolarMutexGuard aGuard;
 268
 269     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 270     if ( pMultiLineEdit )
 271     {
 272         pMultiLineEdit->SetSelection( Selection( aSelection.Min, aSelection.Max ) );
 273     }
 274 }
 275
 276 ::com::sun::star::awt::Selection VCLXMultiLineEdit::getSelection() throw(::com::sun::star::uno::RuntimeException)
 277 {
 278     SolarMutexGuard aGuard;
 279
 280     ::com::sun::star::awt::Selection aSel;
 281     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 282     if ( pMultiLineEdit )
 283     {
 284         aSel.Min = pMultiLineEdit->GetSelection().Min();
 285         aSel.Max = pMultiLineEdit->GetSelection().Max();
 286     }
 287     return aSel;
 288 }
 289
 290 sal_Bool VCLXMultiLineEdit::isEditable() throw(::com::sun::star::uno::RuntimeException)
 291 {
 292     SolarMutexGuard aGuard;
 293
 294     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 295     return ( pMultiLineEdit && !pMultiLineEdit->IsReadOnly() && pMultiLineEdit->IsEnabled() ) ? sal_True : sal_False;
 296 }
 297
 298 void VCLXMultiLineEdit::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException)
 299 {
 300     SolarMutexGuard aGuard;
 301
 302     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 303     if ( pMultiLineEdit )
 304         pMultiLineEdit->SetReadOnly( !bEditable );
 305 }
 306
 307 void VCLXMultiLineEdit::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException)
 308 {
 309     SolarMutexGuard aGuard;
 310
 311     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 312     if ( pMultiLineEdit )
 313         pMultiLineEdit->SetMaxTextLen( nLen );
 314 }
 315
 316 sal_Int16 VCLXMultiLineEdit::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException)
 317 {
 318     SolarMutexGuard aGuard;
 319
 320     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
 321     return pMultiLineEdit ? (sal_Int16)pMultiLineEdit->GetMaxTextLen() : (sal_Int16)0;
 322 }
 323
 324 OUString VCLXMultiLineEdit::getTextLines() throw(::com::sun::star::uno::RuntimeException)
 325 {
 326     SolarMutexGuard aGuard;
 327
 328     OUString aText;
 329     MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
 330     if ( pEdit )
 331         aText = pEdit->GetTextLines( meLineEndType );
 332     return aText;
 333 }
 334
 335 ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
 336 {
 337     SolarMutexGuard aGuard;
 338
 339     ::com::sun::star::awt::Size aSz;
 340     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
 341     if ( pEdit )
 342         aSz = AWTSize(pEdit->CalcMinimumSize());
 343     return aSz;
 344 }
 345
 346 ::com::sun::star::awt::Size VCLXMultiLineEdit::getPreferredSize() throw(::com::sun::star::uno::RuntimeException)
 347 {
 348     return getMinimumSize();
 349 }
 350
 351 ::com::sun::star::awt::Size VCLXMultiLineEdit::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
 352 {
 353     SolarMutexGuard aGuard;
 354
 355     ::com::sun::star::awt::Size aSz = rNewSize;
 356     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
 357     if ( pEdit )
 358         aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize )));
 359     return aSz;
 360 }
 361
 362 ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
 363 {
 364     SolarMutexGuard aGuard;
 365
 366     ::com::sun::star::awt::Size aSz;
 367     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
 368     if ( pEdit )
 369         aSz = AWTSize(pEdit->CalcSize( nCols, nLines ));
 370     return aSz;
 371 }
 372
 373 void VCLXMultiLineEdit::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
 374 {
 375     SolarMutexGuard aGuard;
 376
 377     nCols = nLines = 0;
 378     MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
 379     if ( pEdit )
 380     {
 381         sal_uInt16 nC, nL;
 382         pEdit->GetMaxVisColumnsAndLines( nC, nL );
 383         nCols = nC;
 384         nLines = nL;
 385     }
 386 }
 387
 388 void VCLXMultiLineEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 389 {
 390     switch ( rVclWindowEvent.GetId() )
 391     {
 392         case VCLEVENT_EDIT_MODIFY:
 393         {
 394             if ( maTextListeners.getLength() )
 395             {
 396                 ::com::sun::star::awt::TextEvent aEvent;
 397                 aEvent.Source = (::cppu::OWeakObject*)this;
 398                 maTextListeners.textChanged( aEvent );
 399             }
 400         }
 401         break;
 402         default:
 403         {
 404             VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
 405         }
 406         break;
 407     }
 408 }
 409
 410 void VCLXMultiLineEdit::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 411 {
 412     SolarMutexGuard aGuard;
 413
 414     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow();
 415     if ( pMultiLineEdit )
 416     {
 417         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 418         switch ( nPropType )
 419         {
 420             case BASEPROPERTY_LINE_END_FORMAT:
 421             {
 422                 sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED;
 423                 OSL_VERIFY( Value >>= nLineEndType );
 424                 switch ( nLineEndType )
 425                 {
 426                 case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN:           meLineEndType = LINEEND_CR; break;
 427                 case ::com::sun::star::awt::LineEndFormat::LINE_FEED:                 meLineEndType = LINEEND_LF; break;
 428                 case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED: meLineEndType = LINEEND_CRLF; break;
 429                 default: OSL_FAIL( "VCLXMultiLineEdit::setProperty: invalid line end value!" ); break;
 430                 }
 431             }
 432             break;
 433
 434             case BASEPROPERTY_READONLY:
 435             {
 436                 sal_Bool b = sal_Bool();
 437                 if ( Value >>= b )
 438                     pMultiLineEdit->SetReadOnly( b );
 439             }
 440             break;
 441             case BASEPROPERTY_MAXTEXTLEN:
 442             {
 443                 sal_Int16 n = sal_Int16();
 444                 if ( Value >>= n )
 445                     pMultiLineEdit->SetMaxTextLen( n );
 446             }
 447             break;
 448             case BASEPROPERTY_HIDEINACTIVESELECTION:
 449             {
 450                 sal_Bool b = sal_Bool();
 451                 if ( Value >>= b )
 452                 {
 453                     pMultiLineEdit->EnableFocusSelectionHide( b );
 454                     lcl_setWinBits( pMultiLineEdit, WB_NOHIDESELECTION, !b );
 455                 }
 456             }
 457             break;
 458             default:
 459             {
 460                 VCLXWindow::setProperty( PropertyName, Value );
 461             }
 462         }
 463     }
 464 }
 465
 466 ::com::sun::star::uno::Any VCLXMultiLineEdit::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
 467 {
 468     SolarMutexGuard aGuard;
 469
 470     ::com::sun::star::uno::Any aProp;
 471     MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow();
 472     if ( pMultiLineEdit )
 473     {
 474         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 475         switch ( nPropType )
 476         {
 477             case BASEPROPERTY_LINE_END_FORMAT:
 478             {
 479                 sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED;
 480                 switch ( meLineEndType )
 481                 {
 482                 case LINEEND_CR:   nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN; break;
 483                 case LINEEND_LF:   nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED; break;
 484                 case LINEEND_CRLF: nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED; break;
 485                 default: OSL_FAIL( "VCLXMultiLineEdit::getProperty: invalid line end value!" ); break;
 486                 }
 487                 aProp <<= nLineEndType;
 488             }
 489             break;
 490
 491             case BASEPROPERTY_READONLY:
 492             {
 493                 aProp <<= pMultiLineEdit->IsReadOnly();
 494             }
 495             break;
 496             case BASEPROPERTY_MAXTEXTLEN:
 497             {
 498                 aProp <<= (sal_Int16) pMultiLineEdit->GetMaxTextLen();
 499             }
 500             break;
 501             default:
 502             {
 503                 aProp <<= VCLXWindow::getProperty( PropertyName );
 504             }
 505         }
 506     }
 507     return aProp;
 508 }
 509
 510 void SAL_CALL VCLXMultiLineEdit::setFocus(  ) throw(::com::sun::star::uno::RuntimeException)
 511 {
 512     SolarMutexGuard aGuard;
 513
 514     // don't grab the focus if we already have it. Reason is that the only thing which the edit
 515     // does is forwarding the focus to it's text window. This text window then does a "select all".
 516     // So if the text window already has the focus, and we give the focus to the multi line
 517     // edit, then all which happens is that everything is selected.
 518     // #i27072#
 519     if ( GetWindow() && !GetWindow()->HasChildPathFocus() )
 520         GetWindow()->GrabFocus();
 521 }
 522
 523 void VCLXMultiLineEdit::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 524 {
 525     PushPropertyIds( rIds,
 526                      // FIXME: elide duplication ?
 527                      BASEPROPERTY_LINE_END_FORMAT,
 528                      BASEPROPERTY_READONLY,
 529                      BASEPROPERTY_MAXTEXTLEN,
 530                      BASEPROPERTY_HIDEINACTIVESELECTION,
 531                      0);
 532     VCLXWindow::ImplGetPropertyIds( rIds, true );
 533
 534 }
 535 //  ----------------------------------------------------
 536 //  class VCLXFileControl
 537 //  ----------------------------------------------------
 538 VCLXFileControl::VCLXFileControl() : maTextListeners( *this )
 539 {
 540 }
 541
 542 VCLXFileControl::~VCLXFileControl()
 543 {
 544     FileControl* pControl = (FileControl*) GetWindow();
 545     if ( pControl )
 546         pControl->GetEdit().SetModifyHdl( Link() );
 547 }
 548
 549 ::com::sun::star::uno::Any VCLXFileControl::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
 550 {
 551     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
 552                                         (static_cast< ::com::sun::star::awt::XTextComponent* >(this)),
 553                                         (static_cast< ::com::sun::star::awt::XTextLayoutConstrains* >(this)),
 554                                         (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
 555     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
 556 }
 557
 558 // ::com::sun::star::lang::XTypeProvider
 559 IMPL_XTYPEPROVIDER_START( VCLXFileControl )
 560     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ),
 561     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
 562     VCLXWindow::getTypes()
 563 IMPL_XTYPEPROVIDER_END
 564
 565 void SAL_CALL VCLXFileControl::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 566 {
 567     SolarMutexGuard aGuard;
 568
 569     FileControl* pControl = (FileControl*)GetWindow();
 570     if ( pControl )
 571     {
 572         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 573         switch ( nPropType )
 574         {
 575         case BASEPROPERTY_HIDEINACTIVESELECTION:
 576         {
 577             sal_Bool bValue( sal_False );
 578             OSL_VERIFY( Value >>= bValue );
 579
 580             lcl_setWinBits( pControl, WB_NOHIDESELECTION, !bValue );
 581             lcl_setWinBits( &pControl->GetEdit(), WB_NOHIDESELECTION, !bValue );
 582         }
 583         break;
 584
 585         default:
 586             VCLXWindow::setProperty( PropertyName, Value );
 587             break;
 588         }
 589     }
 590 }
 591
 592 void VCLXFileControl::SetWindow( Window* pWindow )
 593 {
 594     FileControl* pPrevFileControl = dynamic_cast<FileControl*>( GetWindow() );
 595     if ( pPrevFileControl )
 596         pPrevFileControl->GetEdit().SetModifyHdl( Link() );
 597
 598     FileControl* pNewFileControl = dynamic_cast<FileControl*>( pWindow );
 599     if ( pNewFileControl )
 600         pNewFileControl->GetEdit().SetModifyHdl( LINK( this, VCLXFileControl, ModifyHdl ) );
 601
 602     VCLXWindow::SetWindow( pWindow );
 603 }
 604
 605 void VCLXFileControl::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 606 {
 607     maTextListeners.addInterface( l );
 608 }
 609
 610 void VCLXFileControl::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
 611 {
 612     maTextListeners.removeInterface( l );
 613 }
 614
 615 void VCLXFileControl::setText( const OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
 616 {
 617     SolarMutexGuard aGuard;
 618
 619     Window* pWindow = GetWindow();
 620     if ( pWindow )
 621     {
 622         pWindow->SetText( aText );
 623
 624         // In JAVA wird auch ein textChanged ausgeloest, in VCL nicht.
 625         // ::com::sun::star::awt::Toolkit soll JAVA-komform sein...
 626         ModifyHdl( NULL );
 627     }
 628 }
 629
 630 void VCLXFileControl::insertText( const ::com::sun::star::awt::Selection& rSel, const OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
 631 {
 632     SolarMutexGuard aGuard;
 633
 634     FileControl* pFileControl = (FileControl*) GetWindow();
 635     if ( pFileControl )
 636     {
 637         pFileControl->GetEdit().SetSelection( Selection( rSel.Min, rSel.Max ) );
 638         pFileControl->GetEdit().ReplaceSelected( aText );
 639     }
 640 }
 641
 642 OUString VCLXFileControl::getText() throw(::com::sun::star::uno::RuntimeException)
 643 {
 644     SolarMutexGuard aGuard;
 645
 646     OUString aText;
 647     Window* pWindow = GetWindow();
 648     if ( pWindow )
 649         aText = pWindow->GetText();
 650     return aText;
 651 }
 652
 653 OUString VCLXFileControl::getSelectedText() throw(::com::sun::star::uno::RuntimeException)
 654 {
 655     SolarMutexGuard aGuard;
 656
 657     OUString aText;
 658     FileControl* pFileControl = (FileControl*) GetWindow();
 659     if ( pFileControl)
 660         aText = pFileControl->GetEdit().GetSelected();
 661     return aText;
 662
 663 }
 664
 665 void VCLXFileControl::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException)
 666 {
 667     SolarMutexGuard aGuard;
 668
 669     FileControl* pFileControl = (FileControl*) GetWindow();
 670     if ( pFileControl )
 671         pFileControl->GetEdit().SetSelection( Selection( aSelection.Min, aSelection.Max ) );
 672 }
 673
 674 ::com::sun::star::awt::Selection VCLXFileControl::getSelection() throw(::com::sun::star::uno::RuntimeException)
 675 {
 676     SolarMutexGuard aGuard;
 677
 678     ::com::sun::star::awt::Selection aSel;
 679     FileControl* pFileControl = (FileControl*) GetWindow();
 680     if ( pFileControl )
 681     {
 682         aSel.Min = pFileControl->GetEdit().GetSelection().Min();
 683         aSel.Max = pFileControl->GetEdit().GetSelection().Max();
 684     }
 685     return aSel;
 686 }
 687
 688 sal_Bool VCLXFileControl::isEditable() throw(::com::sun::star::uno::RuntimeException)
 689 {
 690     SolarMutexGuard aGuard;
 691
 692     FileControl* pFileControl = (FileControl*) GetWindow();
 693     return ( pFileControl && !pFileControl->GetEdit().IsReadOnly() && pFileControl->GetEdit().IsEnabled() ) ? sal_True : sal_False;
 694 }
 695
 696 void VCLXFileControl::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException)
 697 {
 698     SolarMutexGuard aGuard;
 699
 700     FileControl* pFileControl = (FileControl*) GetWindow();
 701     if ( pFileControl )
 702         pFileControl->GetEdit().SetReadOnly( !bEditable );
 703 }
 704
 705 void VCLXFileControl::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException)
 706 {
 707     SolarMutexGuard aGuard;
 708
 709     FileControl* pFileControl = (FileControl*) GetWindow();
 710     if ( pFileControl )
 711         pFileControl->GetEdit().SetMaxTextLen( nLen );
 712 }
 713
 714 sal_Int16 VCLXFileControl::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException)
 715 {
 716     SolarMutexGuard aGuard;
 717
 718     FileControl* pFileControl = (FileControl*) GetWindow();
 719     return pFileControl ? pFileControl->GetEdit().GetMaxTextLen() : 0;
 720 }
 721
 722
 723 IMPL_LINK_NOARG(VCLXFileControl, ModifyHdl)
 724 {
 725     ::com::sun::star::awt::TextEvent aEvent;
 726     aEvent.Source = (::cppu::OWeakObject*)this;
 727     maTextListeners.textChanged( aEvent );
 728
 729     return 1;
 730 }
 731
 732 ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
 733 {
 734     SolarMutexGuard aGuard;
 735
 736     ::com::sun::star::awt::Size aSz;
 737     FileControl* pControl = (FileControl*) GetWindow();
 738     if ( pControl )
 739     {
 740         Size aTmpSize = pControl->GetEdit().CalcMinimumSize();
 741         aTmpSize.Width() += pControl->GetButton().CalcMinimumSize().Width();
 742         aSz = AWTSize(pControl->CalcWindowSize( aTmpSize ));
 743     }
 744     return aSz;
 745 }
 746
 747 ::com::sun::star::awt::Size VCLXFileControl::getPreferredSize() throw(::com::sun::star::uno::RuntimeException)
 748 {
 749     ::com::sun::star::awt::Size aSz = getMinimumSize();
 750     aSz.Height += 4;
 751     return aSz;
 752 }
 753
 754 ::com::sun::star::awt::Size VCLXFileControl::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
 755 {
 756     SolarMutexGuard aGuard;
 757
 758     ::com::sun::star::awt::Size aSz =rNewSize;
 759     FileControl* pControl = (FileControl*) GetWindow();
 760     if ( pControl )
 761     {
 762         ::com::sun::star::awt::Size aMinSz = getMinimumSize();
 763         if ( aSz.Height != aMinSz.Height )
 764             aSz.Height = aMinSz.Height;
 765     }
 766     return aSz;
 767 }
 768
 769 ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize( sal_Int16 nCols, sal_Int16 ) throw(::com::sun::star::uno::RuntimeException)
 770 {
 771     SolarMutexGuard aGuard;
 772
 773     ::com::sun::star::awt::Size aSz;
 774     FileControl* pControl = (FileControl*) GetWindow();
 775     if ( pControl )
 776     {
 777         aSz = AWTSize(pControl->GetEdit().CalcSize( nCols ));
 778         aSz.Width += pControl->GetButton().CalcMinimumSize().Width();
 779     }
 780     return aSz;
 781 }
 782
 783 void VCLXFileControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
 784 {
 785     SolarMutexGuard aGuard;
 786
 787     nCols = 0;
 788     nLines = 1;
 789     FileControl* pControl = (FileControl*) GetWindow();
 790     if ( pControl )
 791         nCols = (sal_Int16) pControl->GetEdit().GetMaxVisChars();
 792 }
 793
 794 void VCLXFileControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
 795 {
 796     PushPropertyIds( rIds,
 797                      // FIXME: elide duplication ?
 798                      BASEPROPERTY_HIDEINACTIVESELECTION,
 799                      0);
 800     VCLXWindow::ImplGetPropertyIds( rIds, true );
 801 }
 802
 803
 804 //  ----------------------------------------------------
 805 //  class SVTXFormattedField
 806 //  ----------------------------------------------------
 807 // --------------------------------------------------------------------------------------
 808 SVTXFormattedField::SVTXFormattedField()
 809     :m_pCurrentSupplier(NULL)
 810     ,bIsStandardSupplier(sal_True)
 811     ,nKeyToSetDelayed(-1)
 812 {
 813 }
 814
 815 // --------------------------------------------------------------------------------------
 816 SVTXFormattedField::~SVTXFormattedField()
 817 {
 818     if (m_pCurrentSupplier)
 819     {
 820         m_pCurrentSupplier->release();
 821         m_pCurrentSupplier = NULL;
 822     }
 823 }
 824
 825 // --------------------------------------------------------------------------------------
 826 void SVTXFormattedField::SetWindow( Window* _pWindow )
 827 {
 828     VCLXSpinField::SetWindow(_pWindow);
 829     if (GetFormattedField())
 830         GetFormattedField()->SetAutoColor(sal_True);
 831 }
 832
 833 // --------------------------------------------------------------------------------------
 834 void SVTXFormattedField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
 835 {
 836     SolarMutexGuard aGuard;
 837
 838     FormattedField* pField = GetFormattedField();
 839     if ( pField )
 840     {
 841         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 842         switch (nPropType)
 843         {
 844             case BASEPROPERTY_ENFORCE_FORMAT:
 845             {
 846                 sal_Bool bEnable( sal_True );
 847                 if ( Value >>= bEnable )
 848                     pField->EnableNotANumber( !bEnable );
 849             }
 850             break;
 851
 852             case BASEPROPERTY_EFFECTIVE_MIN:
 853             case BASEPROPERTY_VALUEMIN_DOUBLE:
 854                 SetMinValue(Value);
 855                 break;
 856
 857             case BASEPROPERTY_EFFECTIVE_MAX:
 858             case BASEPROPERTY_VALUEMAX_DOUBLE:
 859                 SetMaxValue(Value);
 860                 break;
 861
 862             case BASEPROPERTY_EFFECTIVE_DEFAULT:
 863                 SetDefaultValue(Value);
 864                 break;
 865
 866             case BASEPROPERTY_TREATASNUMBER:
 867             {
 868                 sal_Bool b = sal_Bool();
 869                 if ( Value >>= b )
 870                     SetTreatAsNumber(b);
 871             }
 872             break;
 873
 874             case BASEPROPERTY_FORMATSSUPPLIER:
 875                 if (!Value.hasValue())
 876                     setFormatsSupplier(::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > (NULL));
 877                 else
 878                 {
 879                     ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > xNFS;
 880                     if ( Value >>= xNFS )
 881                         setFormatsSupplier(xNFS);
 882                 }
 883                 break;
 884             case BASEPROPERTY_FORMATKEY:
 885                 if (!Value.hasValue())
 886                     setFormatKey(0);
 887                 else
 888                 {
 889                     sal_Int32 n = 0;
 890                     if ( Value >>= n )
 891                         setFormatKey(n);
 892                 }
 893                 break;
 894
 895             case BASEPROPERTY_EFFECTIVE_VALUE:
 896             case BASEPROPERTY_VALUE_DOUBLE:
 897             {
 898                 const ::com::sun::star::uno::TypeClass rTC = Value.getValueType().getTypeClass();
 899                 if (rTC != ::com::sun::star::uno::TypeClass_STRING)
 900                     // no string
 901                     if (rTC != ::com::sun::star::uno::TypeClass_DOUBLE)
 902                         // no double
 903                         if (Value.hasValue())
 904                         {   // but a value
 905                             // try if it is something converitble
 906                             sal_Int32 nValue = 0;
 907                             if (!(Value >>= nValue))
 908                                 throw ::com::sun::star::lang::IllegalArgumentException();
 909                             SetValue(::com::sun::star::uno::makeAny((double)nValue));
 910                             break;
 911                         }
 912
 913                 SetValue(Value);
 914             }
 915             break;
 916             case BASEPROPERTY_VALUESTEP_DOUBLE:
 917             {
 918                 double d = 0.0;
 919                 if ( Value >>= d )
 920                      pField->SetSpinSize( d );
 921                 else
 922                 {
 923                     sal_Int32 n = 0;
 924                     if ( Value >>= n )
 925                          pField->SetSpinSize( n );
 926                 }
 927             }
 928             break;
 929             case BASEPROPERTY_DECIMALACCURACY:
 930             {
 931                 sal_Int32 n = 0;
 932                 if ( Value >>= n )
 933                      pField->SetDecimalDigits( (sal_uInt16)n );
 934             }
 935             break;
 936             case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
 937             {
 938                     sal_Bool b = sal_Bool();
 939                     if ( Value >>= b )
 940                      pField->SetThousandsSep( b );
 941             }
 942             break;
 943
 944             default:
 945                 VCLXSpinField::setProperty( PropertyName, Value );
 946         }
 947
 948         if (BASEPROPERTY_TEXTCOLOR == nPropType)
 949         {   // after setting a new text color, think again about the AutoColor flag of the control
 950             // 17.05.2001 - 86859 - frank.schoenheit@germany.sun.com
 951             pField->SetAutoColor(!Value.hasValue());
 952         }
 953     }
 954     else
 955         VCLXSpinField::setProperty( PropertyName, Value );
 956 }
 957
 958 // --------------------------------------------------------------------------------------
 959 ::com::sun::star::uno::Any SVTXFormattedField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
 960 {
 961     SolarMutexGuard aGuard;
 962
 963     ::com::sun::star::uno::Any aReturn;
 964
 965     FormattedField* pField = GetFormattedField();
 966     if ( pField )
 967     {
 968         sal_uInt16 nPropType = GetPropertyId( PropertyName );
 969         switch (nPropType)
 970         {
 971             case BASEPROPERTY_EFFECTIVE_MIN:
 972             case BASEPROPERTY_VALUEMIN_DOUBLE:
 973                 aReturn <<= GetMinValue();
 974                 break;
 975
 976             case BASEPROPERTY_EFFECTIVE_MAX:
 977             case BASEPROPERTY_VALUEMAX_DOUBLE:
 978                 aReturn <<= GetMaxValue();
 979                 break;
 980
 981             case BASEPROPERTY_EFFECTIVE_DEFAULT:
 982                 aReturn <<= GetDefaultValue();
 983                 break;
 984
 985             case BASEPROPERTY_TREATASNUMBER:
 986                 aReturn <<= GetTreatAsNumber();
 987                 break;
 988
 989             case BASEPROPERTY_EFFECTIVE_VALUE:
 990             case BASEPROPERTY_VALUE_DOUBLE:
 991                 aReturn <<= GetValue();
 992                 break;
 993
 994             case BASEPROPERTY_VALUESTEP_DOUBLE:
 995                 aReturn <<= pField->GetSpinSize();
 996                 break;
 997
 998             case BASEPROPERTY_DECIMALACCURACY:
 999                 aReturn <<= pField->GetDecimalDigits();
1000                 break;
1001
1002             case BASEPROPERTY_FORMATSSUPPLIER:
1003             {
1004                 if (!bIsStandardSupplier)
1005                 {   // ansonsten void
1006                     ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >  xSupplier = getFormatsSupplier();
1007                     aReturn <<= xSupplier;
1008                 }
1009             }
1010             break;
1011
1012             case BASEPROPERTY_FORMATKEY:
1013             {
1014                 if (!bIsStandardSupplier)
1015                     aReturn <<= getFormatKey();
1016             }
1017             break;
1018
1019             default:
1020                 aReturn <<= VCLXSpinField::getProperty(PropertyName);
1021         }
1022     }
1023     return aReturn;
1024 }
1025
1026 // --------------------------------------------------------------------------------------
1027 ::com::sun::star::uno::Any SVTXFormattedField::convertEffectiveValue(const ::com::sun::star::uno::Any& rValue)
1028 {
1029     ::com::sun::star::uno::Any aReturn;
1030
1031     FormattedField* pField = GetFormattedField();
1032     if (!pField)
1033         return aReturn;
1034
1035     switch (rValue.getValueType().getTypeClass())
1036     {
1037         case ::com::sun::star::uno::TypeClass_DOUBLE:
1038             if (pField->TreatingAsNumber())
1039             {
1040                 double d = 0.0;
1041                 rValue >>= d;
1042                 aReturn <<= d;
1043             }
1044             else
1045             {
1046                 SvNumberFormatter* pFormatter = pField->GetFormatter();
1047                 if (!pFormatter)
1048                     pFormatter = pField->StandardFormatter();
1049                     // should never fail
1050
1051                 Color* pDum;
1052                 double d = 0.0;
1053                 rValue >>= d;
1054                 String sConverted;
1055                 pFormatter->GetOutputString(d, 0, sConverted, &pDum);
1056                 aReturn <<= OUString( sConverted );
1057             }
1058             break;
1059         case ::com::sun::star::uno::TypeClass_STRING:
1060         {
1061             OUString aStr;
1062             rValue >>= aStr;
1063             String sValue = aStr;
1064             if (pField->TreatingAsNumber())
1065             {
1066                 SvNumberFormatter* pFormatter = pField->GetFormatter();
1067                 if (!pFormatter)
1068                     pFormatter = pField->StandardFormatter();
1069
1070                 double dVal;
1071                 sal_uInt32 nTestFormat(0);
1072                 if (!pFormatter->IsNumberFormat(sValue, nTestFormat, dVal))
1073                     aReturn.clear();
1074                 aReturn <<=dVal;
1075             }
1076             else
1077                 aReturn <<= aStr;
1078         }
1079         break;
1080         default:
1081             aReturn.clear();
1082             break;
1083     }
1084     return aReturn;
1085 }
1086
1087 // --------------------------------------------------------------------------------------
1088 void SVTXFormattedField::SetMinValue(const ::com::sun::star::uno::Any& rValue)
1089 {
1090     FormattedField* pField = GetFormattedField();
1091     if (!pField)
1092         return;
1093
1094     switch (rValue.getValueType().getTypeClass())
1095
1096     {
1097         case ::com::sun::star::uno::TypeClass_DOUBLE:
1098         {
1099             double d = 0.0;
1100             rValue >>= d;
1101             pField->SetMinValue(d);
1102         }
1103             break;
1104         default:
1105             DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID, "SVTXFormattedField::SetMinValue : invalid argument (an exception will be thrown) !");
1106             if ( rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID )
1107
1108             {
1109                 throw ::com::sun::star::lang::IllegalArgumentException();
1110             }
1111             pField->ClearMinValue();
1112             break;
1113     }
1114 }
1115
1116 // --------------------------------------------------------------------------------------
1117 ::com::sun::star::uno::Any SVTXFormattedField::GetMinValue()
1118 {
1119     FormattedField* pField = GetFormattedField();
1120     if (!pField || !pField->HasMinValue())
1121         return ::com::sun::star::uno::Any();
1122
1123     ::com::sun::star::uno::Any aReturn;
1124     aReturn <<= pField->GetMinValue();
1125     return aReturn;
1126 }
1127
1128 // --------------------------------------------------------------------------------------
1129 void SVTXFormattedField::SetMaxValue(const ::com::sun::star::uno::Any& rValue)
1130 {
1131     FormattedField* pField = GetFormattedField();
1132     if (!pField)
1133         return;
1134
1135     switch (rValue.getValueType().getTypeClass())
1136
1137     {
1138         case ::com::sun::star::uno::TypeClass_DOUBLE:
1139         {
1140             double d = 0.0;
1141             rValue >>= d;
1142             pField->SetMaxValue(d);
1143         }
1144             break;
1145         default:
1146             if (rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID)
1147
1148             {
1149                 throw ::com::sun::star::lang::IllegalArgumentException();
1150             }
1151             pField->ClearMaxValue();
1152             break;
1153     }
1154 }
1155
1156 // --------------------------------------------------------------------------------------
1157 ::com::sun::star::uno::Any SVTXFormattedField::GetMaxValue()
1158 {
1159     FormattedField* pField = GetFormattedField();
1160     if (!pField || !pField->HasMaxValue())
1161         return ::com::sun::star::uno::Any();
1162
1163     ::com::sun::star::uno::Any aReturn;
1164     aReturn <<= pField->GetMaxValue();
1165     return aReturn;
1166 }
1167
1168 // --------------------------------------------------------------------------------------
1169 void SVTXFormattedField::SetDefaultValue(const ::com::sun::star::uno::Any& rValue)
1170 {
1171     FormattedField* pField = GetFormattedField();
1172     if (!pField)
1173         return;
1174
1175     ::com::sun::star::uno::Any aConverted = convertEffectiveValue(rValue);
1176
1177     switch (aConverted.getValueType().getTypeClass())
1178
1179     {
1180         case ::com::sun::star::uno::TypeClass_DOUBLE:
1181         {
1182             double d = 0.0;
1183             aConverted >>= d;
1184             pField->SetDefaultValue(d);
1185         }
1186         break;
1187         case ::com::sun::star::uno::TypeClass_STRING:
1188         {
1189             OUString aStr;
1190             aConverted >>= aStr;
1191             pField->SetDefaultText( aStr );
1192         }
1193         break;
1194         default:
1195             pField->EnableEmptyField(sal_True);
1196                 // nur noch void erlaubt
1197             break;
1198     }
1199 }
1200
1201 // --------------------------------------------------------------------------------------
1202 ::com::sun::star::uno::Any SVTXFormattedField::GetDefaultValue()
1203 {
1204     FormattedField* pField = GetFormattedField();
1205     if (!pField || pField->IsEmptyFieldEnabled())
1206         return ::com::sun::star::uno::Any();
1207
1208     ::com::sun::star::uno::Any aReturn;
1209     if (pField->TreatingAsNumber())
1210         aReturn <<= pField->GetDefaultValue();
1211     else
1212         aReturn <<= OUString( pField->GetDefaultText() );
1213     return aReturn;
1214 }
1215
1216 // --------------------------------------------------------------------------------------
1217 sal_Bool SVTXFormattedField::GetTreatAsNumber()
1218 {
1219     FormattedField* pField = GetFormattedField();
1220     if (pField)
1221         return pField->TreatingAsNumber();
1222
1223     return sal_True;
1224 }
1225
1226 // --------------------------------------------------------------------------------------
1227 void SVTXFormattedField::SetTreatAsNumber(sal_Bool bSet)
1228 {
1229     FormattedField* pField = GetFormattedField();
1230     if (pField)
1231         pField->TreatAsNumber(bSet);
1232 }
1233
1234 // --------------------------------------------------------------------------------------
1235 ::com::sun::star::uno::Any SVTXFormattedField::GetValue()
1236 {
1237     FormattedField* pField = GetFormattedField();
1238     if (!pField)
1239         return ::com::sun::star::uno::Any();
1240
1241     ::com::sun::star::uno::Any aReturn;
1242     if (!pField->TreatingAsNumber())
1243     {
1244         OUString sText = pField->GetTextValue();
1245         aReturn <<= sText;
1246     }
1247     else
1248     {
1249         if (!pField->GetText().isEmpty())    // empty wird erst mal standardmaessig als void nach draussen gereicht
1250             aReturn <<= pField->GetValue();
1251     }
1252
1253     return aReturn;
1254 }
1255
1256 // --------------------------------------------------------------------------------------
1257 void SVTXFormattedField::SetValue(const ::com::sun::star::uno::Any& rValue)
1258 {
1259     FormattedField* pField = GetFormattedField();
1260     if (!pField)
1261         return;
1262
1263     if (!rValue.hasValue())
1264     {
1265         pField->SetText(String());
1266     }
1267     else
1268     {
1269         if (rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE )
1270         {
1271             double d = 0.0;
1272             rValue >>= d;
1273             pField->SetValue(d);
1274         }
1275         else
1276         {
1277             DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING, "SVTXFormattedField::SetValue : invalid argument !");
1278
1279             OUString sText;
1280             rValue >>= sText;
1281             String aStr( sText );
1282             if (!pField->TreatingAsNumber())
1283                 pField->SetTextFormatted(aStr);
1284             else
1285                 pField->SetTextValue(aStr);
1286         }
1287     }
1288 //  NotifyTextListeners();
1289 }
1290
1291 // --------------------------------------------------------------------------------------
1292 ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier >  SVTXFormattedField::getFormatsSupplier(void) const
1293 {
1294     return ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > ((::com::sun::star::util::XNumberFormatsSupplier*)m_pCurrentSupplier);
1295 }
1296
1297 // --------------------------------------------------------------------------------------
1298 void SVTXFormattedField::setFormatsSupplier(const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > & xSupplier)
1299 {
1300     FormattedField* pField = GetFormattedField();
1301
1302     SvNumberFormatsSupplierObj* pNew = NULL;
1303     if (!xSupplier.is())
1304     {
1305         if (pField)
1306         {
1307             pNew = new SvNumberFormatsSupplierObj(pField->StandardFormatter());
1308             bIsStandardSupplier = sal_True;
1309         }
1310     }
1311     else
1312     {
1313         pNew = SvNumberFormatsSupplierObj::getImplementation(xSupplier);
1314         bIsStandardSupplier = sal_False;
1315     }
1316
1317     if (!pNew)
1318         return;     // TODO : wie das behandeln ?
1319
1320     if (m_pCurrentSupplier)
1321         m_pCurrentSupplier->release();
1322     m_pCurrentSupplier = pNew;
1323     m_pCurrentSupplier->acquire();
1324     if (pField)
1325     {
1326         // den aktuellen Value mit hinueberretten
1327         ::com::sun::star::uno::Any aCurrent = GetValue();
1328         pField->SetFormatter(m_pCurrentSupplier->GetNumberFormatter(), sal_False);
1329         if (nKeyToSetDelayed != -1)
1330         {
1331             pField->SetFormatKey(nKeyToSetDelayed);
1332             nKeyToSetDelayed = -1;
1333         }
1334         SetValue(aCurrent);
1335         NotifyTextListeners();
1336     }
1337 }
1338
1339 // --------------------------------------------------------------------------------------
1340 sal_Int32 SVTXFormattedField::getFormatKey(void) const
1341 {
1342     FormattedField* pField = GetFormattedField();
1343     return pField ? pField->GetFormatKey() : 0;
1344 }
1345
1346 // --------------------------------------------------------------------------------------
1347 void SVTXFormattedField::setFormatKey(sal_Int32 nKey)
1348 {
1349     FormattedField* pField = GetFormattedField();
1350     if (pField)
1351     {
1352         if (pField->GetFormatter())
1353             pField->SetFormatKey(nKey);
1354         else
1355         {   // Wahrscheinlich bin ich gerade in einem Block, in dem erst der Key und dann der Formatter gesetzt
1356             // wird, das passiert initial mit ziemlicher Sicherheit, da die Properties in alphabetischer Reihenfolge
1357             // gesetzt werden, und der FormatsSupplier nun mal vor dem FormatKey kommt
1358             nKeyToSetDelayed = nKey;
1359         }
1360         NotifyTextListeners();
1361     }
1362 }
1363
1364 // --------------------------------------------------------------------------------------
1365 void SVTXFormattedField::NotifyTextListeners()
1366 {
1367     if ( GetTextListeners().getLength() )
1368     {
1369         ::com::sun::star::awt::TextEvent aEvent;
1370         aEvent.Source = (::cppu::OWeakObject*)this;
1371         GetTextListeners().textChanged( aEvent );
1372     }
1373 }
1374
1375 void SVTXFormattedField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1376 {
1377     PushPropertyIds( rIds,
1378                      // FIXME: elide duplication ?
1379                      BASEPROPERTY_EFFECTIVE_MIN,
1380                      BASEPROPERTY_VALUEMIN_DOUBLE,
1381                      BASEPROPERTY_EFFECTIVE_MAX,
1382                      BASEPROPERTY_VALUEMAX_DOUBLE,
1383                      BASEPROPERTY_EFFECTIVE_DEFAULT,
1384                      BASEPROPERTY_TREATASNUMBER,
1385                      BASEPROPERTY_EFFECTIVE_VALUE,
1386                      BASEPROPERTY_VALUE_DOUBLE,
1387                      BASEPROPERTY_VALUESTEP_DOUBLE,
1388                      BASEPROPERTY_DECIMALACCURACY,
1389                      BASEPROPERTY_FORMATSSUPPLIER,
1390                      BASEPROPERTY_NUMSHOWTHOUSANDSEP,
1391                      BASEPROPERTY_FORMATKEY,
1392                      BASEPROPERTY_TREATASNUMBER,
1393                      BASEPROPERTY_ENFORCE_FORMAT,
1394                      0);
1395     VCLXWindow::ImplGetPropertyIds( rIds, true );
1396     VCLXSpinField::ImplGetPropertyIds( rIds );
1397 }
1398
1399
1400 //  ----------------------------------------------------
1401 //  class SVTXRoadmap
1402 //  ----------------------------------------------------
1403
1404 using namespace svt;
1405
1406 // --------------------------------------------------------------------------------------
1407 SVTXRoadmap::SVTXRoadmap() : maItemListeners( *this )
1408 {
1409 }
1410
1411 // --------------------------------------------------------------------------------------
1412 SVTXRoadmap::~SVTXRoadmap()
1413 {
1414 }
1415
1416 void SVTXRoadmap::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1417 {
1418     switch ( rVclWindowEvent.GetId() )
1419     {
1420         case VCLEVENT_ROADMAP_ITEMSELECTED:
1421         {
1422             SolarMutexGuard aGuard;
1423             ::svt::ORoadmap* pField = GetRoadmap();
1424             if ( pField )
1425             {
1426                 sal_Int16 CurItemID = pField->GetCurrentRoadmapItemID();
1427                 ::com::sun::star::awt::ItemEvent aEvent;
1428                 aEvent.Selected = CurItemID;
1429                 aEvent.Highlighted = CurItemID;
1430                 aEvent.ItemId = CurItemID;
1431                 maItemListeners.itemStateChanged( aEvent );
1432             }
1433         }
1434         break;
1435         default:
1436             SVTXRoadmap_Base::ProcessWindowEvent( rVclWindowEvent );
1437             break;
1438     }
1439 }
1440
1441
1442 void SVTXRoadmap::propertyChange( const ::com::sun::star::beans::PropertyChangeEvent& evt ) throw (::com::sun::star::uno::RuntimeException)
1443 {
1444     SolarMutexGuard aGuard;
1445     ::svt::ORoadmap* pField = GetRoadmap();
1446     if ( pField )
1447     {
1448         ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem;
1449         xRoadmapItem = evt.Source;
1450         sal_Int32 nID = 0;
1451         ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY );
1452         ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(OUString( "ID" ));
1453         aValue >>= nID;
1454
1455         ::com::sun::star::uno::Any rVal = evt.NewValue;
1456         evt.NewValue >>= rVal;
1457         OUString sPropertyName = evt.PropertyName;
1458         if ( sPropertyName == "Enabled" )
1459         {
1460             sal_Bool bEnable = false;
1461             evt.NewValue >>= bEnable;
1462             pField->EnableRoadmapItem( (RoadmapTypes::ItemId)nID , bEnable );
1463         }
1464         else if ( sPropertyName == "Label" )
1465         {
1466             OUString sLabel;
1467             evt.NewValue >>= sLabel;
1468             pField->ChangeRoadmapItemLabel( (RoadmapTypes::ItemId)nID , sLabel );
1469         }
1470         else if  ( sPropertyName == "ID" )
1471         {
1472             sal_Int32 nNewID = 0;
1473             evt.NewValue >>= nNewID;
1474             evt.OldValue >>= nID;
1475             pField->ChangeRoadmapItemID( (RoadmapTypes::ItemId)nID, (RoadmapTypes::ItemId)nNewID );
1476         }
1477     //    else
1478             // Todo: handle Interactive appropriately
1479     }
1480 }
1481
1482
1483 void SVTXRoadmap::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException)
1484 {
1485     maItemListeners.addInterface( l );
1486 }
1487
1488 void SVTXRoadmap::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException)
1489 {
1490     maItemListeners.removeInterface( l );
1491 }
1492
1493 RMItemData SVTXRoadmap::GetRMItemData( const ::com::sun::star::container::ContainerEvent& _rEvent )
1494 {
1495     RMItemData aCurRMItemData;
1496     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem;
1497     _rEvent.Element >>= xRoadmapItem;
1498     ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY );
1499     if ( xPropertySet.is() )
1500     {
1501         ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(OUString( "Label" ));
1502         aValue >>= aCurRMItemData.Label;
1503         aValue = xPropertySet->getPropertyValue(OUString( "ID" ));
1504         aValue >>= aCurRMItemData.n_ID;
1505         aValue = xPropertySet->getPropertyValue(OUString( "Enabled" ));
1506         aValue >>= aCurRMItemData.b_Enabled;
1507     }
1508     return aCurRMItemData;
1509 }
1510
1511 void SVTXRoadmap::elementInserted( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1512 {
1513     SolarMutexGuard aGuard;
1514     ::svt::ORoadmap* pField = GetRoadmap();
1515     if ( pField )
1516     {
1517         RMItemData CurItemData = GetRMItemData(  _rEvent );
1518         sal_Int32 InsertIndex = 0;
1519         _rEvent.Accessor >>= InsertIndex;
1520         pField->InsertRoadmapItem( InsertIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled );
1521     }
1522 }
1523
1524 void SVTXRoadmap::elementRemoved( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1525 {
1526     SolarMutexGuard aGuard;
1527     ::svt::ORoadmap* pField = GetRoadmap();
1528     if ( pField )
1529     {
1530         sal_Int32 DelIndex = 0;
1531         _rEvent.Accessor >>= DelIndex;
1532         pField->DeleteRoadmapItem(DelIndex);
1533     }
1534 }
1535
1536 void SVTXRoadmap::elementReplaced( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1537 {
1538     SolarMutexGuard aGuard;
1539     ::svt::ORoadmap* pField = GetRoadmap();
1540     if ( pField )
1541     {
1542         RMItemData CurItemData = GetRMItemData(  _rEvent );
1543         sal_Int32 ReplaceIndex = 0;
1544         _rEvent.Accessor >>= ReplaceIndex;
1545         pField->ReplaceRoadmapItem( ReplaceIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled );
1546     }
1547 }
1548
1549
1550
1551 // --------------------------------------------------------------------------------------
1552 void SVTXRoadmap::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1553 {
1554     SolarMutexGuard aGuard;
1555
1556     ::svt::ORoadmap* pField = GetRoadmap();
1557     if ( pField )
1558     {
1559         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1560         switch (nPropType)
1561         {
1562             case BASEPROPERTY_COMPLETE:
1563             {
1564                 sal_Bool b = false;
1565                 Value >>= b;
1566                 pField->SetRoadmapComplete( b);
1567             }
1568             break;
1569
1570             case BASEPROPERTY_ACTIVATED:
1571             {
1572                    sal_Bool b = false;
1573                 Value >>= b;
1574                 pField->SetRoadmapInteractive( b);
1575             }
1576             break;
1577
1578             case BASEPROPERTY_CURRENTITEMID:
1579             {
1580                    sal_Int32 nId = 0;
1581                 Value >>= nId;
1582                 pField->SelectRoadmapItemByID( (RoadmapTypes::ItemId)nId );
1583             }
1584             break;
1585
1586             case BASEPROPERTY_TEXT:
1587             {
1588                    OUString aStr;
1589                 Value >>= aStr;
1590                 pField->SetText( aStr );
1591                 pField->Invalidate();
1592             }
1593             break;
1594
1595             default:
1596                 SVTXRoadmap_Base::setProperty( PropertyName, Value );
1597                 break;
1598         }
1599
1600     }
1601     else
1602         SVTXRoadmap_Base::setProperty( PropertyName, Value );
1603 }
1604
1605
1606 // --------------------------------------------------------------------------------------
1607 ::com::sun::star::uno::Any SVTXRoadmap::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
1608 {
1609     SolarMutexGuard aGuard;
1610
1611     ::com::sun::star::uno::Any aReturn;
1612
1613     ::svt::ORoadmap* pField = GetRoadmap();
1614     if ( pField )
1615     {
1616         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1617         switch (nPropType)
1618         {
1619             case BASEPROPERTY_COMPLETE:
1620                 aReturn <<= pField->IsRoadmapComplete();
1621                 break;
1622             case BASEPROPERTY_ACTIVATED:
1623                 aReturn <<= pField->IsRoadmapInteractive();
1624                 break;
1625             case BASEPROPERTY_CURRENTITEMID:
1626                 aReturn <<= pField->GetCurrentRoadmapItemID();
1627                 break;
1628             default:
1629                 aReturn = SVTXRoadmap_Base::getProperty(PropertyName);
1630                 break;
1631         }
1632     }
1633     return aReturn;
1634 }
1635
1636 void SVTXRoadmap::ImplSetNewImage()
1637 {
1638     OSL_PRECOND( GetWindow(), "SVTXRoadmap::ImplSetNewImage: window is required to be not-NULL!" );
1639     ::svt::ORoadmap* pButton = static_cast< ::svt::ORoadmap* >( GetWindow() );
1640     pButton->SetRoadmapBitmap( GetImage().GetBitmapEx() );
1641 }
1642
1643 void SVTXRoadmap::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1644 {
1645     PushPropertyIds( rIds,
1646                      BASEPROPERTY_COMPLETE,
1647                      BASEPROPERTY_ACTIVATED,
1648                      BASEPROPERTY_CURRENTITEMID,
1649                      BASEPROPERTY_TEXT,
1650                      0);
1651     VCLXWindow::ImplGetPropertyIds( rIds, true );
1652     VCLXGraphicControl::ImplGetPropertyIds( rIds );
1653 }
1654
1655 //  ----------------------------------------------------
1656 //  class SVTXNumericField
1657 //  ----------------------------------------------------
1658 SVTXNumericField::SVTXNumericField()
1659 {
1660 }
1661
1662 SVTXNumericField::~SVTXNumericField()
1663 {
1664 }
1665
1666 ::com::sun::star::uno::Any SVTXNumericField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1667 {
1668     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1669                                         (static_cast< ::com::sun::star::awt::XNumericField* >(this)),
1670                                         (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
1671     return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType ));
1672 }
1673
1674 // ::com::sun::star::lang::XTypeProvider
1675 IMPL_XTYPEPROVIDER_START( SVTXNumericField )
1676     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XNumericField>* ) NULL ),
1677     SVTXFormattedField::getTypes()
1678 IMPL_XTYPEPROVIDER_END
1679
1680
1681 void SVTXNumericField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
1682 {
1683     SolarMutexGuard aGuard;
1684
1685     FormattedField* pField = GetFormattedField();
1686     if ( pField )
1687         pField->SetValue( Value );
1688 }
1689
1690 double SVTXNumericField::getValue() throw(::com::sun::star::uno::RuntimeException)
1691 {
1692     SolarMutexGuard aGuard;
1693
1694     FormattedField* pField = GetFormattedField();
1695     return pField ? pField->GetValue() : 0;
1696 }
1697
1698 void SVTXNumericField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
1699 {
1700     SolarMutexGuard aGuard;
1701
1702     FormattedField* pField = GetFormattedField();
1703     if ( pField )
1704         pField->SetMinValue( Value );
1705 }
1706
1707 double SVTXNumericField::getMin() throw(::com::sun::star::uno::RuntimeException)
1708 {
1709     SolarMutexGuard aGuard;
1710
1711     FormattedField* pField = GetFormattedField();
1712     return pField ? pField->GetMinValue() : 0;
1713 }
1714
1715 void SVTXNumericField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
1716 {
1717     SolarMutexGuard aGuard;
1718
1719     FormattedField* pField = GetFormattedField();
1720     if ( pField )
1721         pField->SetMaxValue( Value );
1722 }
1723
1724 double SVTXNumericField::getMax() throw(::com::sun::star::uno::RuntimeException)
1725 {
1726     SolarMutexGuard aGuard;
1727
1728     FormattedField* pField = GetFormattedField();
1729     return pField ? pField->GetMaxValue() : 0;
1730 }
1731
1732 void SVTXNumericField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
1733 {
1734     SolarMutexGuard aGuard;
1735
1736     FormattedField* pField = GetFormattedField();
1737     if ( pField )
1738         pField->SetSpinFirst( Value );
1739 }
1740
1741 double SVTXNumericField::getFirst() throw(::com::sun::star::uno::RuntimeException)
1742 {
1743     SolarMutexGuard aGuard;
1744
1745     FormattedField* pField = GetFormattedField();
1746     return pField ? pField->GetSpinFirst() : 0;
1747 }
1748
1749 void SVTXNumericField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
1750 {
1751     SolarMutexGuard aGuard;
1752
1753     FormattedField* pField = GetFormattedField();
1754     if ( pField )
1755         pField->SetSpinLast( Value );
1756 }
1757
1758 double SVTXNumericField::getLast() throw(::com::sun::star::uno::RuntimeException)
1759 {
1760     SolarMutexGuard aGuard;
1761
1762     FormattedField* pField = GetFormattedField();
1763     return pField ? pField->GetSpinLast() : 0;
1764 }
1765
1766 void SVTXNumericField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
1767 {
1768     SolarMutexGuard aGuard;
1769
1770     FormattedField* pField = GetFormattedField();
1771     if ( pField )
1772         pField->SetSpinSize( Value );
1773 }
1774
1775 double SVTXNumericField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
1776 {
1777     SolarMutexGuard aGuard;
1778
1779     FormattedField* pField = GetFormattedField();
1780     return pField ? pField->GetSpinSize() : 0;
1781 }
1782
1783 void SVTXNumericField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
1784 {
1785     SolarMutexGuard aGuard;
1786
1787     FormattedField* pField = GetFormattedField();
1788     if ( pField )
1789         pField->SetDecimalDigits( Value );
1790 }
1791
1792 sal_Int16 SVTXNumericField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
1793 {
1794     SolarMutexGuard aGuard;
1795
1796     FormattedField* pField = GetFormattedField();
1797     return pField ? pField->GetDecimalDigits() : 0;
1798 }
1799
1800 void SVTXNumericField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
1801 {
1802     SolarMutexGuard aGuard;
1803
1804     FormattedField* pField = GetFormattedField();
1805     if ( pField )
1806         pField->SetStrictFormat( bStrict );
1807 }
1808
1809 sal_Bool SVTXNumericField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
1810 {
1811     SolarMutexGuard aGuard;
1812
1813     FormattedField* pField = GetFormattedField();
1814     return pField ? pField->IsStrictFormat() : sal_False;
1815 }
1816
1817 void SVTXNumericField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1818 {
1819     SVTXFormattedField::ImplGetPropertyIds( rIds );
1820 }
1821
1822 //  ----------------------------------------------------
1823 //  class SVTXCurrencyField
1824 //  ----------------------------------------------------
1825 SVTXCurrencyField::SVTXCurrencyField()
1826 {
1827 }
1828
1829 SVTXCurrencyField::~SVTXCurrencyField()
1830 {
1831 }
1832
1833 ::com::sun::star::uno::Any SVTXCurrencyField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1834 {
1835     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1836                                         (static_cast< ::com::sun::star::awt::XCurrencyField* >(this)),
1837                                         (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
1838     return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType ));
1839 }
1840
1841 // ::com::sun::star::lang::XTypeProvider
1842 IMPL_XTYPEPROVIDER_START( SVTXCurrencyField )
1843     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XCurrencyField>* ) NULL ),
1844     SVTXFormattedField::getTypes()
1845 IMPL_XTYPEPROVIDER_END
1846
1847 void SVTXCurrencyField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
1848 {
1849     SolarMutexGuard aGuard;
1850
1851     FormattedField* pField = GetFormattedField();
1852     if ( pField )
1853         pField->SetValue( Value );
1854 }
1855
1856 double SVTXCurrencyField::getValue() throw(::com::sun::star::uno::RuntimeException)
1857 {
1858     SolarMutexGuard aGuard;
1859
1860     FormattedField* pField = GetFormattedField();
1861     return pField ? pField->GetValue() : 0;
1862 }
1863
1864 void SVTXCurrencyField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
1865 {
1866     SolarMutexGuard aGuard;
1867
1868     FormattedField* pField = GetFormattedField();
1869     if ( pField )
1870         pField->SetMinValue( Value );
1871 }
1872
1873 double SVTXCurrencyField::getMin() throw(::com::sun::star::uno::RuntimeException)
1874 {
1875     SolarMutexGuard aGuard;
1876
1877     FormattedField* pField = GetFormattedField();
1878     return pField ? pField->GetMinValue() : 0;
1879 }
1880
1881 void SVTXCurrencyField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
1882 {
1883     SolarMutexGuard aGuard;
1884
1885     FormattedField* pField = GetFormattedField();
1886     if ( pField )
1887         pField->SetMaxValue( Value );
1888 }
1889
1890 double SVTXCurrencyField::getMax() throw(::com::sun::star::uno::RuntimeException)
1891 {
1892     SolarMutexGuard aGuard;
1893
1894     FormattedField* pField = GetFormattedField();
1895     return pField ? pField->GetMaxValue() : 0;
1896 }
1897
1898 void SVTXCurrencyField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
1899 {
1900     SolarMutexGuard aGuard;
1901
1902     FormattedField* pField = GetFormattedField();
1903     if ( pField )
1904         pField->SetSpinFirst( Value );
1905 }
1906
1907 double SVTXCurrencyField::getFirst() throw(::com::sun::star::uno::RuntimeException)
1908 {
1909     SolarMutexGuard aGuard;
1910
1911     FormattedField* pField = GetFormattedField();
1912     return pField ? pField->GetSpinFirst() : 0;
1913 }
1914
1915 void SVTXCurrencyField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
1916 {
1917     SolarMutexGuard aGuard;
1918
1919     FormattedField* pField = GetFormattedField();
1920     if ( pField )
1921         pField->SetSpinLast( Value );
1922 }
1923
1924 double SVTXCurrencyField::getLast() throw(::com::sun::star::uno::RuntimeException)
1925 {
1926     SolarMutexGuard aGuard;
1927
1928     FormattedField* pField = GetFormattedField();
1929     return pField ? pField->GetSpinLast() : 0;
1930 }
1931
1932 void SVTXCurrencyField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
1933 {
1934     SolarMutexGuard aGuard;
1935
1936     FormattedField* pField = GetFormattedField();
1937     if ( pField )
1938         pField->SetSpinSize( Value );
1939 }
1940
1941 double SVTXCurrencyField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
1942 {
1943     SolarMutexGuard aGuard;
1944
1945     FormattedField* pField = GetFormattedField();
1946     return pField ? pField->GetSpinSize() : 0;
1947 }
1948
1949 void SVTXCurrencyField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
1950 {
1951     SolarMutexGuard aGuard;
1952
1953     FormattedField* pField = GetFormattedField();
1954     if ( pField )
1955         pField->SetDecimalDigits( Value );
1956 }
1957
1958 sal_Int16 SVTXCurrencyField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
1959 {
1960     SolarMutexGuard aGuard;
1961
1962     FormattedField* pField = GetFormattedField();
1963     return pField ? pField->GetDecimalDigits() : 0;
1964 }
1965
1966 void SVTXCurrencyField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
1967 {
1968     SolarMutexGuard aGuard;
1969
1970     FormattedField* pField = GetFormattedField();
1971     if ( pField )
1972         pField->SetStrictFormat( bStrict );
1973 }
1974
1975 sal_Bool SVTXCurrencyField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
1976 {
1977     SolarMutexGuard aGuard;
1978
1979     FormattedField* pField = GetFormattedField();
1980     return pField ? pField->IsStrictFormat() : sal_False;
1981 }
1982
1983 void SVTXCurrencyField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1984 {
1985     SolarMutexGuard aGuard;
1986
1987     ::com::sun::star::uno::Any aReturn;
1988
1989     DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField();
1990     if ( pField )
1991     {
1992         sal_uInt16 nPropType = GetPropertyId( PropertyName );
1993         switch (nPropType)
1994         {
1995             case BASEPROPERTY_CURRENCYSYMBOL:
1996             {
1997                 OUString aStr;
1998                 Value >>= aStr;
1999                 pField->setCurrencySymbol( aStr );
2000             }
2001             break;
2002             case BASEPROPERTY_CURSYM_POSITION:
2003             {
2004                 sal_Bool b = false;
2005                 Value >>= b;
2006                 pField->setPrependCurrSym(b);
2007             }
2008             break;
2009
2010             default:
2011                 SVTXFormattedField::setProperty(PropertyName, Value);
2012         }
2013     }
2014     else
2015         SVTXFormattedField::setProperty(PropertyName, Value);
2016 }
2017
2018 ::com::sun::star::uno::Any SVTXCurrencyField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
2019 {
2020     SolarMutexGuard aGuard;
2021
2022     ::com::sun::star::uno::Any aReturn;
2023
2024     DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField();
2025     if ( pField )
2026     {
2027         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2028         switch (nPropType)
2029         {
2030             case BASEPROPERTY_CURRENCYSYMBOL:
2031             {
2032                 aReturn <<= OUString( pField->getCurrencySymbol() );
2033             }
2034             break;
2035             case BASEPROPERTY_CURSYM_POSITION:
2036             {
2037                 aReturn <<= pField->getPrependCurrSym();
2038             }
2039             break;
2040             default:
2041                 return SVTXFormattedField::getProperty(PropertyName);
2042         }
2043     }
2044     return SVTXFormattedField::getProperty(PropertyName);
2045 }
2046
2047 void SVTXCurrencyField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2048 {
2049     PushPropertyIds( rIds,
2050                      BASEPROPERTY_CURRENCYSYMBOL,
2051                      BASEPROPERTY_CURSYM_POSITION,
2052                      0);
2053     SVTXFormattedField::ImplGetPropertyIds( rIds );
2054 }
2055
2056
2057 //  ----------------------------------------------------
2058 //  class VCLXProgressBar
2059 //  ----------------------------------------------------
2060
2061 VCLXProgressBar::VCLXProgressBar()
2062             :m_nValue(0)
2063             ,m_nValueMin(0)
2064             ,m_nValueMax(100)
2065 {
2066 }
2067
2068 VCLXProgressBar::~VCLXProgressBar()
2069 {
2070 }
2071
2072 void VCLXProgressBar::ImplUpdateValue()
2073 {
2074     ProgressBar* pProgressBar = (ProgressBar*) GetWindow();
2075     if ( pProgressBar )
2076     {
2077         sal_Int32 nVal;
2078         sal_Int32 nValMin;
2079         sal_Int32 nValMax;
2080
2081         // check min and max
2082         if (m_nValueMin < m_nValueMax)
2083         {
2084             nValMin = m_nValueMin;
2085             nValMax = m_nValueMax;
2086         }
2087         else
2088         {
2089             nValMin = m_nValueMax;
2090             nValMax = m_nValueMin;
2091         }
2092
2093         // check value
2094         if (m_nValue < nValMin)
2095         {
2096             nVal = nValMin;
2097         }
2098         else if (m_nValue > nValMax)
2099         {
2100             nVal = nValMax;
2101         }
2102         else
2103         {
2104             nVal = m_nValue;
2105         }
2106
2107         // calculate percent
2108         sal_Int32 nPercent;
2109         if (nValMin != nValMax)
2110         {
2111             nPercent = 100 * (nVal - nValMin) / (nValMax - nValMin);
2112         }
2113         else
2114         {
2115             nPercent = 0;
2116         }
2117
2118         // set progressbar value
2119         pProgressBar->SetValue( (sal_uInt16) nPercent );
2120     }
2121 }
2122
2123 // ::com::sun::star::uno::XInterface
2124 ::com::sun::star::uno::Any VCLXProgressBar::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2125 {
2126     ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2127                                         (static_cast< ::com::sun::star::awt::XProgressBar* >(this)),
2128                                         (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
2129     return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2130 }
2131
2132 // ::com::sun::star::lang::XTypeProvider
2133 IMPL_XTYPEPROVIDER_START( VCLXProgressBar )
2134     getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XProgressBar>* ) NULL ),
2135     VCLXWindow::getTypes()
2136 IMPL_XTYPEPROVIDER_END
2137
2138 // ::com::sun::star::awt::XProgressBar
2139 void VCLXProgressBar::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
2140 {
2141     SolarMutexGuard aGuard;
2142
2143     Window* pWindow = GetWindow();
2144     if ( pWindow )
2145     {
2146         Color aColor( nColor );
2147         pWindow->SetControlForeground( aColor );
2148     }
2149 }
2150
2151 void VCLXProgressBar::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
2152 {
2153     SolarMutexGuard aGuard;
2154
2155     Window* pWindow = GetWindow();
2156     if ( pWindow )
2157     {
2158         Color aColor( nColor );
2159         pWindow->SetBackground( aColor );
2160         pWindow->SetControlBackground( aColor );
2161         pWindow->Invalidate();
2162     }
2163 }
2164
2165 void VCLXProgressBar::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException)
2166 {
2167     SolarMutexGuard aGuard;
2168
2169     m_nValue = nValue;
2170     ImplUpdateValue();
2171 }
2172
2173 void VCLXProgressBar::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException )
2174 {
2175     SolarMutexGuard aGuard;
2176
2177     if ( nMin < nMax )
2178     {
2179         // take correct min and max
2180         m_nValueMin = nMin;
2181         m_nValueMax = nMax;
2182     }
2183     else
2184     {
2185         // change min and max
2186         m_nValueMin = nMax;
2187         m_nValueMax = nMin;
2188     }
2189
2190     ImplUpdateValue();
2191 }
2192
2193 sal_Int32 VCLXProgressBar::getValue() throw(::com::sun::star::uno::RuntimeException)
2194 {
2195     SolarMutexGuard aGuard;
2196
2197     return m_nValue;
2198 }
2199
2200 // ::com::sun::star::awt::VclWindowPeer
2201 void VCLXProgressBar::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
2202 {
2203     SolarMutexGuard aGuard;
2204
2205     ProgressBar* pProgressBar = (ProgressBar*)GetWindow();
2206     if ( pProgressBar )
2207     {
2208         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2209         switch ( nPropType )
2210         {
2211             case BASEPROPERTY_PROGRESSVALUE:
2212             {
2213                 if ( Value >>= m_nValue )
2214                     ImplUpdateValue();
2215             }
2216             break;
2217             case BASEPROPERTY_PROGRESSVALUE_MIN:
2218             {
2219                 if ( Value >>= m_nValueMin )
2220                     ImplUpdateValue();
2221             }
2222             break;
2223             case BASEPROPERTY_PROGRESSVALUE_MAX:
2224             {
2225                 if ( Value >>= m_nValueMax )
2226                     ImplUpdateValue();
2227             }
2228             break;
2229             case BASEPROPERTY_FILLCOLOR:
2230             {
2231                 Window* pWindow = GetWindow();
2232                 if ( pWindow )
2233                 {
2234                     sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2235
2236                     if ( bVoid )
2237                     {
2238                         pWindow->SetControlForeground();
2239                     }
2240                     else
2241                     {
2242                         sal_Int32 nColor = 0;
2243                         if ( Value >>= nColor )
2244                         {
2245                             Color aColor( nColor );
2246                             pWindow->SetControlForeground( aColor );
2247                         }
2248                     }
2249                 }
2250             }
2251             break;
2252             default:
2253                 VCLXWindow::setProperty( PropertyName, Value );
2254                 break;
2255         }
2256     }
2257 }
2258
2259 ::com::sun::star::uno::Any VCLXProgressBar::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
2260 {
2261     SolarMutexGuard aGuard;
2262
2263     ::com::sun::star::uno::Any aProp;
2264     ProgressBar* pProgressBar = (ProgressBar*)GetWindow();
2265     if ( pProgressBar )
2266     {
2267         sal_uInt16 nPropType = GetPropertyId( PropertyName );
2268         switch ( nPropType )
2269         {
2270             case BASEPROPERTY_PROGRESSVALUE:
2271             {
2272                  aProp <<= m_nValue;
2273             }
2274             break;
2275             case BASEPROPERTY_PROGRESSVALUE_MIN:
2276             {
2277                  aProp <<= m_nValueMin;
2278             }
2279             break;
2280             case BASEPROPERTY_PROGRESSVALUE_MAX:
2281             {
2282                  aProp <<= m_nValueMax;
2283             }
2284             break;
2285             default:
2286                 aProp <<= VCLXWindow::getProperty( PropertyName );
2287                 break;
2288         }
2289     }
2290     return aProp;
2291 }
2292
2293 void VCLXProgressBar::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2294 {
2295     PushPropertyIds( rIds,
2296                      BASEPROPERTY_PROGRESSVALUE,
2297                      BASEPROPERTY_PROGRESSVALUE_MIN,
2298                      BASEPROPERTY_PROGRESSVALUE_MAX,
2299                      BASEPROPERTY_FILLCOLOR,
2300                      0);
2301     VCLXWindow::ImplGetPropertyIds( rIds, true );
2302 }
2303
2304
2305 //  ----------------------------------------------------
2306 //  class SVTXDateField
2307 //  ----------------------------------------------------
2308 SVTXDateField::SVTXDateField()
2309     :VCLXDateField()
2310 {
2311 }
2312
2313 SVTXDateField::~SVTXDateField()
2314 {
2315 }
2316
2317 void SAL_CALL SVTXDateField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException)
2318 {
2319     VCLXDateField::setProperty( PropertyName, Value );
2320
2321     // some properties need to be forwarded to the sub edit, too
2322     Edit* pSubEdit = GetWindow() ? static_cast< Edit* >( GetWindow() )->GetSubEdit() : NULL;
2323     if ( !pSubEdit )
2324         return;
2325
2326     switch ( GetPropertyId( PropertyName ) )
2327     {
2328     case BASEPROPERTY_TEXTLINECOLOR:
2329         if ( !Value.hasValue() )
2330             pSubEdit->SetTextLineColor();
2331         else
2332         {
2333             sal_Int32 nColor = 0;
2334             if ( Value >>= nColor )
2335                 pSubEdit->SetTextLineColor( Color( nColor ) );
2336         }
2337         break;
2338     }
2339 }
2340
2341 void SVTXDateField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2342 {
2343     PushPropertyIds( rIds,
2344                      BASEPROPERTY_TEXTLINECOLOR,
2345                      0);
2346     VCLXDateField::ImplGetPropertyIds( rIds );
2347 }
2348
2349 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */