svtools/source/uno/unoiface.cxx

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