| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #define _SVT_UNOIFACE_CXX |
| #include <tools/debug.hxx> |
| #include <vcl/svapp.hxx> |
| #include <svtools/svmedit.hxx> |
| #include <unoiface.hxx> |
| #include <svtools/filedlg.hxx> |
| #include <svtools/filectrl.hxx> |
| #include <svtools/roadmap.hxx> |
| #include <svtools/fixedhyper.hxx> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> |
| #include <com/sun/star/awt/LineEndFormat.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <toolkit/helper/convert.hxx> |
| #include <toolkit/helper/property.hxx> |
| #include <svtools/fmtfield.hxx> |
| #include <svl/numuno.hxx> |
| #include <svtools/calendar.hxx> |
| #include <svtools/prgsbar.hxx> |
| #include <svtools/svtreebx.hxx> |
| #include "treecontrolpeer.hxx" |
| #include "svtxgridcontrol.hxx" |
| #include <svtools/table/tablecontrol.hxx> |
| |
| namespace |
| { |
| static void lcl_setWinBits( Window* _pWindow, WinBits _nBits, sal_Bool _bSet ) |
| { |
| WinBits nStyle = _pWindow->GetStyle(); |
| if ( _bSet ) |
| nStyle |= _nBits; |
| else |
| nStyle &= ~_nBits; |
| _pWindow->SetStyle( nStyle ); |
| } |
| } |
| |
| // ---------------------------------------------------- |
| // help function for the toolkit... |
| // ---------------------------------------------------- |
| |
| extern "C" { |
| |
| SAL_DLLPUBLIC_EXPORT Window* CreateWindow( VCLXWindow** ppNewComp, const ::com::sun::star::awt::WindowDescriptor* pDescriptor, Window* pParent, WinBits nWinBits ) |
| { |
| Window* pWindow = NULL; |
| String aServiceName( pDescriptor->WindowServiceName ); |
| if ( aServiceName.EqualsIgnoreCaseAscii( "MultiLineEdit" ) ) |
| { |
| if ( pParent ) |
| { |
| pWindow = new MultiLineEdit( pParent, nWinBits|WB_IGNORETAB); |
| static_cast< MultiLineEdit* >( pWindow )->DisableSelectionOnFocus(); |
| *ppNewComp = new VCLXMultiLineEdit; |
| } |
| else |
| { |
| *ppNewComp = NULL; |
| return NULL; |
| } |
| } |
| else if ( aServiceName.EqualsIgnoreCaseAscii( "FileControl" ) ) |
| { |
| if ( pParent ) |
| { |
| pWindow = new FileControl( pParent, nWinBits ); |
| *ppNewComp = new VCLXFileControl; |
| } |
| else |
| { |
| *ppNewComp = NULL; |
| return NULL; |
| } |
| } |
| else if (aServiceName.EqualsIgnoreCaseAscii("FormattedField") ) |
| { |
| pWindow = new FormattedField( pParent, nWinBits ); |
| *ppNewComp = new SVTXFormattedField; |
| } |
| else if (aServiceName.EqualsIgnoreCaseAscii("NumericField") ) |
| { |
| pWindow = new DoubleNumericField( pParent, nWinBits ); |
| *ppNewComp = new SVTXNumericField; |
| } |
| else if (aServiceName.EqualsIgnoreCaseAscii("LongCurrencyField") ) |
| { |
| pWindow = new DoubleCurrencyField( pParent, nWinBits ); |
| *ppNewComp = new SVTXCurrencyField; |
| } |
| else if (aServiceName.EqualsIgnoreCaseAscii("datefield") ) |
| { |
| pWindow = new CalendarField( pParent, nWinBits); |
| static_cast<CalendarField*>(pWindow)->EnableToday(); |
| static_cast<CalendarField*>(pWindow)->EnableNone(); |
| static_cast<CalendarField*>(pWindow)->EnableEmptyFieldValue( sal_True ); |
| *ppNewComp = new SVTXDateField; |
| ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(DateField*)pWindow ); |
| } |
| else if (aServiceName.EqualsIgnoreCaseAscii("roadmap") ) |
| { |
| pWindow = new ::svt::ORoadmap( pParent, WB_TABSTOP ); |
| *ppNewComp = new SVTXRoadmap; |
| } |
| else if ( aServiceName.EqualsIgnoreCaseAscii( "ProgressBar" ) ) |
| { |
| if ( pParent ) |
| { |
| pWindow = new ProgressBar( pParent, nWinBits ); |
| *ppNewComp = new VCLXProgressBar; |
| } |
| else |
| { |
| *ppNewComp = NULL; |
| return NULL; |
| } |
| } |
| else if ( aServiceName.EqualsIgnoreCaseAscii( "Tree" ) ) |
| { |
| TreeControlPeer* pPeer = new TreeControlPeer; |
| *ppNewComp = pPeer; |
| pWindow = pPeer->createVclControl( pParent, nWinBits ); |
| } |
| else if ( aServiceName.EqualsIgnoreCaseAscii( "FixedHyperlink" ) ) |
| { |
| if ( pParent ) |
| { |
| pWindow = new ::svt::FixedHyperlink( pParent, nWinBits ); |
| *ppNewComp = new VCLXFixedHyperlink; |
| } |
| else |
| { |
| *ppNewComp = NULL; |
| return NULL; |
| } |
| } |
| else if ( aServiceName.EqualsIgnoreCaseAscii( "Grid" ) ) |
| { |
| if ( pParent ) |
| { |
| pWindow = new ::svt::table::TableControl(pParent, nWinBits); |
| *ppNewComp = new SVTXGridControl; |
| } |
| else |
| { |
| *ppNewComp = NULL; |
| return NULL; |
| } |
| } |
| return pWindow; |
| } |
| |
| } // extern "C" |
| |
| // ---------------------------------------------------- |
| // class VCLXMultiLineEdit |
| // ---------------------------------------------------- |
| VCLXMultiLineEdit::VCLXMultiLineEdit() |
| :maTextListeners( *this ) |
| ,meLineEndType( LINEEND_LF ) // default behavior before introducing this property: LF (unix-like) |
| { |
| } |
| |
| VCLXMultiLineEdit::~VCLXMultiLineEdit() |
| { |
| } |
| |
| ::com::sun::star::uno::Any VCLXMultiLineEdit::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, |
| SAL_STATIC_CAST( ::com::sun::star::awt::XTextComponent*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::awt::XTextArea*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::awt::XTextLayoutConstrains*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) ); |
| return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType )); |
| } |
| |
| // ::com::sun::star::lang::XTypeProvider |
| IMPL_XTYPEPROVIDER_START( VCLXMultiLineEdit ) |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ), |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextArea>* ) NULL ), |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ), |
| VCLXWindow::getTypes() |
| IMPL_XTYPEPROVIDER_END |
| |
| void VCLXMultiLineEdit::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| maTextListeners.addInterface( l ); |
| } |
| |
| void VCLXMultiLineEdit::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| maTextListeners.removeInterface( l ); |
| } |
| |
| void VCLXMultiLineEdit::setText( const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow(); |
| if ( pEdit ) |
| { |
| pEdit->SetText( aText ); |
| |
| // #107218# Call same listeners like VCL would do after user interaction |
| SetSynthesizingVCLEvent( sal_True ); |
| pEdit->SetModifyFlag(); |
| pEdit->Modify(); |
| SetSynthesizingVCLEvent( sal_False ); |
| } |
| } |
| |
| void VCLXMultiLineEdit::insertText( const ::com::sun::star::awt::Selection& rSel, const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow(); |
| if ( pEdit ) |
| { |
| setSelection( rSel ); |
| pEdit->ReplaceSelected( aText ); |
| } |
| } |
| |
| ::rtl::OUString VCLXMultiLineEdit::getText() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::rtl::OUString aText; |
| MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow(); |
| if ( pEdit ) |
| aText = pEdit->GetText( meLineEndType ); |
| return aText; |
| } |
| |
| ::rtl::OUString VCLXMultiLineEdit::getSelectedText() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::rtl::OUString aText; |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| if ( pMultiLineEdit) |
| aText = pMultiLineEdit->GetSelected( meLineEndType ); |
| return aText; |
| |
| } |
| |
| void VCLXMultiLineEdit::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| if ( pMultiLineEdit ) |
| { |
| pMultiLineEdit->SetSelection( Selection( aSelection.Min, aSelection.Max ) ); |
| } |
| } |
| |
| ::com::sun::star::awt::Selection VCLXMultiLineEdit::getSelection() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Selection aSel; |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| if ( pMultiLineEdit ) |
| { |
| aSel.Min = pMultiLineEdit->GetSelection().Min(); |
| aSel.Max = pMultiLineEdit->GetSelection().Max(); |
| } |
| return aSel; |
| } |
| |
| sal_Bool VCLXMultiLineEdit::isEditable() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| return ( pMultiLineEdit && !pMultiLineEdit->IsReadOnly() && pMultiLineEdit->IsEnabled() ) ? sal_True : sal_False; |
| } |
| |
| void VCLXMultiLineEdit::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| if ( pMultiLineEdit ) |
| pMultiLineEdit->SetReadOnly( !bEditable ); |
| } |
| |
| void VCLXMultiLineEdit::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| if ( pMultiLineEdit ) |
| pMultiLineEdit->SetMaxTextLen( nLen ); |
| } |
| |
| sal_Int16 VCLXMultiLineEdit::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow(); |
| return pMultiLineEdit ? (sal_Int16)pMultiLineEdit->GetMaxTextLen() : (sal_Int16)0; |
| } |
| |
| ::rtl::OUString VCLXMultiLineEdit::getTextLines() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::rtl::OUString aText; |
| MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow(); |
| if ( pEdit ) |
| aText = pEdit->GetTextLines( meLineEndType ); |
| return aText; |
| } |
| |
| ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz; |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| aSz = AWTSize(pEdit->CalcMinimumSize()); |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size VCLXMultiLineEdit::getPreferredSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| return getMinimumSize(); |
| } |
| |
| ::com::sun::star::awt::Size VCLXMultiLineEdit::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz = rNewSize; |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize ))); |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz; |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| aSz = AWTSize(pEdit->CalcSize( nCols, nLines )); |
| return aSz; |
| } |
| |
| void VCLXMultiLineEdit::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| nCols = nLines = 0; |
| MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow(); |
| if ( pEdit ) |
| { |
| sal_uInt16 nC, nL; |
| pEdit->GetMaxVisColumnsAndLines( nC, nL ); |
| nCols = nC; |
| nLines = nL; |
| } |
| } |
| |
| void VCLXMultiLineEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) |
| { |
| switch ( rVclWindowEvent.GetId() ) |
| { |
| case VCLEVENT_EDIT_MODIFY: |
| { |
| if ( maTextListeners.getLength() ) |
| { |
| ::com::sun::star::awt::TextEvent aEvent; |
| aEvent.Source = (::cppu::OWeakObject*)this; |
| maTextListeners.textChanged( aEvent ); |
| } |
| } |
| break; |
| default: |
| { |
| VCLXWindow::ProcessWindowEvent( rVclWindowEvent ); |
| } |
| break; |
| } |
| } |
| |
| void VCLXMultiLineEdit::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow(); |
| if ( pMultiLineEdit ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch ( nPropType ) |
| { |
| case BASEPROPERTY_LINE_END_FORMAT: |
| { |
| sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED; |
| OSL_VERIFY( Value >>= nLineEndType ); |
| switch ( nLineEndType ) |
| { |
| case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN: meLineEndType = LINEEND_CR; break; |
| case ::com::sun::star::awt::LineEndFormat::LINE_FEED: meLineEndType = LINEEND_LF; break; |
| case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED: meLineEndType = LINEEND_CRLF; break; |
| default: DBG_ERROR( "VCLXMultiLineEdit::setProperty: invalid line end value!" ); break; |
| } |
| } |
| break; |
| |
| case BASEPROPERTY_READONLY: |
| { |
| sal_Bool b = sal_Bool(); |
| if ( Value >>= b ) |
| pMultiLineEdit->SetReadOnly( b ); |
| } |
| break; |
| case BASEPROPERTY_MAXTEXTLEN: |
| { |
| sal_Int16 n = sal_Int16(); |
| if ( Value >>= n ) |
| pMultiLineEdit->SetMaxTextLen( n ); |
| } |
| break; |
| case BASEPROPERTY_HIDEINACTIVESELECTION: |
| { |
| sal_Bool b = sal_Bool(); |
| if ( Value >>= b ) |
| { |
| pMultiLineEdit->EnableFocusSelectionHide( b ); |
| lcl_setWinBits( pMultiLineEdit, WB_NOHIDESELECTION, !b ); |
| } |
| } |
| break; |
| default: |
| { |
| VCLXWindow::setProperty( PropertyName, Value ); |
| } |
| } |
| } |
| } |
| |
| ::com::sun::star::uno::Any VCLXMultiLineEdit::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aProp; |
| MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow(); |
| if ( pMultiLineEdit ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch ( nPropType ) |
| { |
| case BASEPROPERTY_LINE_END_FORMAT: |
| { |
| sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED; |
| switch ( meLineEndType ) |
| { |
| case LINEEND_CR: nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN; break; |
| case LINEEND_LF: nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED; break; |
| case LINEEND_CRLF: nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED; break; |
| default: DBG_ERROR( "VCLXMultiLineEdit::getProperty: invalid line end value!" ); break; |
| } |
| aProp <<= nLineEndType; |
| } |
| break; |
| |
| case BASEPROPERTY_READONLY: |
| { |
| aProp <<= pMultiLineEdit->IsReadOnly(); |
| } |
| break; |
| case BASEPROPERTY_MAXTEXTLEN: |
| { |
| aProp <<= (sal_Int16) pMultiLineEdit->GetMaxTextLen(); |
| } |
| break; |
| default: |
| { |
| aProp <<= VCLXWindow::getProperty( PropertyName ); |
| } |
| } |
| } |
| return aProp; |
| } |
| |
| void SAL_CALL VCLXMultiLineEdit::setFocus( ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| // don't grab the focus if we already have it. Reason is that the only thing which the edit |
| // does is forwarding the focus to it's text window. This text window then does a "select all". |
| // So if the text window already has the focus, and we give the focus to the multi line |
| // edit, then all which happens is that everything is selected. |
| // #i27072# - 2004-04-25 - fs@openoffice.org |
| if ( GetWindow() && !GetWindow()->HasChildPathFocus() ) |
| GetWindow()->GrabFocus(); |
| } |
| |
| void VCLXMultiLineEdit::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| // FIXME: elide duplication ? |
| BASEPROPERTY_LINE_END_FORMAT, |
| BASEPROPERTY_READONLY, |
| BASEPROPERTY_MAXTEXTLEN, |
| BASEPROPERTY_HIDEINACTIVESELECTION, |
| 0); |
| VCLXWindow::ImplGetPropertyIds( rIds, true ); |
| |
| } |
| // ---------------------------------------------------- |
| // class VCLXFileControl |
| // ---------------------------------------------------- |
| VCLXFileControl::VCLXFileControl() : maTextListeners( *this ) |
| { |
| } |
| |
| VCLXFileControl::~VCLXFileControl() |
| { |
| FileControl* pControl = (FileControl*) GetWindow(); |
| if ( pControl ) |
| pControl->GetEdit().SetModifyHdl( Link() ); |
| } |
| |
| ::com::sun::star::uno::Any VCLXFileControl::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, |
| SAL_STATIC_CAST( ::com::sun::star::awt::XTextComponent*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::awt::XTextLayoutConstrains*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) ); |
| return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType )); |
| } |
| |
| // ::com::sun::star::lang::XTypeProvider |
| IMPL_XTYPEPROVIDER_START( VCLXFileControl ) |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ), |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ), |
| VCLXWindow::getTypes() |
| IMPL_XTYPEPROVIDER_END |
| |
| void SAL_CALL VCLXFileControl::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pControl = (FileControl*)GetWindow(); |
| if ( pControl ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch ( nPropType ) |
| { |
| case BASEPROPERTY_HIDEINACTIVESELECTION: |
| { |
| sal_Bool bValue( sal_False ); |
| OSL_VERIFY( Value >>= bValue ); |
| |
| lcl_setWinBits( pControl, WB_NOHIDESELECTION, !bValue ); |
| lcl_setWinBits( &pControl->GetEdit(), WB_NOHIDESELECTION, !bValue ); |
| } |
| break; |
| |
| default: |
| VCLXWindow::setProperty( PropertyName, Value ); |
| break; |
| } |
| } |
| } |
| |
| void VCLXFileControl::SetWindow( Window* pWindow ) |
| { |
| FileControl* pPrevFileControl = dynamic_cast<FileControl*>( GetWindow() ); |
| if ( pPrevFileControl ) |
| pPrevFileControl->GetEdit().SetModifyHdl( Link() ); |
| |
| FileControl* pNewFileControl = dynamic_cast<FileControl*>( pWindow ); |
| if ( pNewFileControl ) |
| pNewFileControl->GetEdit().SetModifyHdl( LINK( this, VCLXFileControl, ModifyHdl ) ); |
| |
| VCLXWindow::SetWindow( pWindow ); |
| } |
| |
| void VCLXFileControl::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| maTextListeners.addInterface( l ); |
| } |
| |
| void VCLXFileControl::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| maTextListeners.removeInterface( l ); |
| } |
| |
| void VCLXFileControl::setText( const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| Window* pWindow = GetWindow(); |
| if ( pWindow ) |
| { |
| pWindow->SetText( aText ); |
| |
| // In JAVA wird auch ein textChanged ausgeloest, in VCL nicht. |
| // ::com::sun::star::awt::Toolkit soll JAVA-komform sein... |
| ModifyHdl( NULL ); |
| } |
| } |
| |
| void VCLXFileControl::insertText( const ::com::sun::star::awt::Selection& rSel, const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl ) |
| { |
| pFileControl->GetEdit().SetSelection( Selection( rSel.Min, rSel.Max ) ); |
| pFileControl->GetEdit().ReplaceSelected( aText ); |
| } |
| } |
| |
| ::rtl::OUString VCLXFileControl::getText() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::rtl::OUString aText; |
| Window* pWindow = GetWindow(); |
| if ( pWindow ) |
| aText = pWindow->GetText(); |
| return aText; |
| } |
| |
| ::rtl::OUString VCLXFileControl::getSelectedText() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::rtl::OUString aText; |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl) |
| aText = pFileControl->GetEdit().GetSelected(); |
| return aText; |
| |
| } |
| |
| void VCLXFileControl::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl ) |
| pFileControl->GetEdit().SetSelection( Selection( aSelection.Min, aSelection.Max ) ); |
| } |
| |
| ::com::sun::star::awt::Selection VCLXFileControl::getSelection() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Selection aSel; |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl ) |
| { |
| aSel.Min = pFileControl->GetEdit().GetSelection().Min(); |
| aSel.Max = pFileControl->GetEdit().GetSelection().Max(); |
| } |
| return aSel; |
| } |
| |
| sal_Bool VCLXFileControl::isEditable() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| return ( pFileControl && !pFileControl->GetEdit().IsReadOnly() && pFileControl->GetEdit().IsEnabled() ) ? sal_True : sal_False; |
| } |
| |
| void VCLXFileControl::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl ) |
| pFileControl->GetEdit().SetReadOnly( !bEditable ); |
| } |
| |
| void VCLXFileControl::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| if ( pFileControl ) |
| pFileControl->GetEdit().SetMaxTextLen( nLen ); |
| } |
| |
| sal_Int16 VCLXFileControl::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FileControl* pFileControl = (FileControl*) GetWindow(); |
| return pFileControl ? pFileControl->GetEdit().GetMaxTextLen() : 0; |
| } |
| |
| |
| IMPL_LINK( VCLXFileControl, ModifyHdl, Edit*, EMPTYARG ) |
| { |
| ::com::sun::star::awt::TextEvent aEvent; |
| aEvent.Source = (::cppu::OWeakObject*)this; |
| maTextListeners.textChanged( aEvent ); |
| |
| return 1; |
| } |
| |
| ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz; |
| FileControl* pControl = (FileControl*) GetWindow(); |
| if ( pControl ) |
| { |
| Size aTmpSize = pControl->GetEdit().CalcMinimumSize(); |
| aTmpSize.Width() += pControl->GetButton().CalcMinimumSize().Width(); |
| aSz = AWTSize(pControl->CalcWindowSize( aTmpSize )); |
| } |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size VCLXFileControl::getPreferredSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::awt::Size aSz = getMinimumSize(); |
| aSz.Height += 4; |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size VCLXFileControl::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz =rNewSize; |
| FileControl* pControl = (FileControl*) GetWindow(); |
| if ( pControl ) |
| { |
| ::com::sun::star::awt::Size aMinSz = getMinimumSize(); |
| if ( aSz.Height != aMinSz.Height ) |
| aSz.Height = aMinSz.Height; |
| } |
| return aSz; |
| } |
| |
| ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize( sal_Int16 nCols, sal_Int16 ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::awt::Size aSz; |
| FileControl* pControl = (FileControl*) GetWindow(); |
| if ( pControl ) |
| { |
| aSz = AWTSize(pControl->GetEdit().CalcSize( nCols )); |
| aSz.Width += pControl->GetButton().CalcMinimumSize().Width(); |
| } |
| return aSz; |
| } |
| |
| void VCLXFileControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| nCols = 0; |
| nLines = 1; |
| FileControl* pControl = (FileControl*) GetWindow(); |
| if ( pControl ) |
| nCols = (sal_Int16) pControl->GetEdit().GetMaxVisChars(); |
| } |
| |
| void VCLXFileControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| // FIXME: elide duplication ? |
| BASEPROPERTY_HIDEINACTIVESELECTION, |
| 0); |
| VCLXWindow::ImplGetPropertyIds( rIds, true ); |
| } |
| |
| |
| // ---------------------------------------------------- |
| // class SVTXFormattedField |
| // ---------------------------------------------------- |
| // -------------------------------------------------------------------------------------- |
| SVTXFormattedField::SVTXFormattedField() |
| :m_pCurrentSupplier(NULL) |
| ,bIsStandardSupplier(sal_True) |
| ,nKeyToSetDelayed(-1) |
| { |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| SVTXFormattedField::~SVTXFormattedField() |
| { |
| if (m_pCurrentSupplier) |
| { |
| m_pCurrentSupplier->release(); |
| m_pCurrentSupplier = NULL; |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetWindow( Window* _pWindow ) |
| { |
| VCLXSpinField::SetWindow(_pWindow); |
| if (GetFormattedField()) |
| GetFormattedField()->SetAutoColor(sal_True); |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_ENFORCE_FORMAT: |
| { |
| sal_Bool bEnable( sal_True ); |
| if ( Value >>= bEnable ) |
| pField->EnableNotANumber( !bEnable ); |
| } |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_MIN: |
| case BASEPROPERTY_VALUEMIN_DOUBLE: |
| SetMinValue(Value); |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_MAX: |
| case BASEPROPERTY_VALUEMAX_DOUBLE: |
| SetMaxValue(Value); |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_DEFAULT: |
| SetDefaultValue(Value); |
| break; |
| |
| case BASEPROPERTY_TREATASNUMBER: |
| { |
| sal_Bool b = sal_Bool(); |
| if ( Value >>= b ) |
| SetTreatAsNumber(b); |
| } |
| break; |
| |
| case BASEPROPERTY_FORMATSSUPPLIER: |
| if (!Value.hasValue()) |
| setFormatsSupplier(::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > (NULL)); |
| else |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > xNFS; |
| if ( Value >>= xNFS ) |
| setFormatsSupplier(xNFS); |
| } |
| break; |
| case BASEPROPERTY_FORMATKEY: |
| if (!Value.hasValue()) |
| setFormatKey(0); |
| else |
| { |
| sal_Int32 n = 0; |
| if ( Value >>= n ) |
| setFormatKey(n); |
| } |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_VALUE: |
| case BASEPROPERTY_VALUE_DOUBLE: |
| { |
| const ::com::sun::star::uno::TypeClass rTC = Value.getValueType().getTypeClass(); |
| if (rTC != ::com::sun::star::uno::TypeClass_STRING) |
| // no string |
| if (rTC != ::com::sun::star::uno::TypeClass_DOUBLE) |
| // no double |
| if (Value.hasValue()) |
| { // but a value |
| // try if it is something converitble |
| sal_Int32 nValue = 0; |
| if (!(Value >>= nValue)) |
| throw ::com::sun::star::lang::IllegalArgumentException(); |
| SetValue(::com::sun::star::uno::makeAny((double)nValue)); |
| break; |
| } |
| |
| SetValue(Value); |
| } |
| break; |
| case BASEPROPERTY_VALUESTEP_DOUBLE: |
| { |
| double d = 0.0; |
| if ( Value >>= d ) |
| pField->SetSpinSize( d ); |
| else |
| { |
| sal_Int32 n = 0; |
| if ( Value >>= n ) |
| pField->SetSpinSize( n ); |
| } |
| } |
| break; |
| case BASEPROPERTY_DECIMALACCURACY: |
| { |
| sal_Int32 n = 0; |
| if ( Value >>= n ) |
| pField->SetDecimalDigits( (sal_uInt16)n ); |
| } |
| break; |
| case BASEPROPERTY_NUMSHOWTHOUSANDSEP: |
| { |
| sal_Bool b = sal_Bool(); |
| if ( Value >>= b ) |
| pField->SetThousandsSep( b ); |
| } |
| break; |
| |
| default: |
| VCLXSpinField::setProperty( PropertyName, Value ); |
| } |
| |
| if (BASEPROPERTY_TEXTCOLOR == nPropType) |
| { // after setting a new text color, think again about the AutoColor flag of the control |
| // 17.05.2001 - 86859 - frank.schoenheit@germany.sun.com |
| pField->SetAutoColor(!Value.hasValue()); |
| } |
| } |
| else |
| VCLXSpinField::setProperty( PropertyName, Value ); |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aReturn; |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_EFFECTIVE_MIN: |
| case BASEPROPERTY_VALUEMIN_DOUBLE: |
| aReturn <<= GetMinValue(); |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_MAX: |
| case BASEPROPERTY_VALUEMAX_DOUBLE: |
| aReturn <<= GetMaxValue(); |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_DEFAULT: |
| aReturn <<= GetDefaultValue(); |
| break; |
| |
| case BASEPROPERTY_TREATASNUMBER: |
| aReturn <<= GetTreatAsNumber(); |
| break; |
| |
| case BASEPROPERTY_EFFECTIVE_VALUE: |
| case BASEPROPERTY_VALUE_DOUBLE: |
| aReturn <<= GetValue(); |
| break; |
| |
| case BASEPROPERTY_VALUESTEP_DOUBLE: |
| aReturn <<= pField->GetSpinSize(); |
| break; |
| |
| case BASEPROPERTY_DECIMALACCURACY: |
| aReturn <<= pField->GetDecimalDigits(); |
| break; |
| |
| case BASEPROPERTY_FORMATSSUPPLIER: |
| { |
| if (!bIsStandardSupplier) |
| { // ansonsten void |
| ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > xSupplier = getFormatsSupplier(); |
| aReturn <<= xSupplier; |
| } |
| } |
| break; |
| |
| case BASEPROPERTY_FORMATKEY: |
| { |
| if (!bIsStandardSupplier) |
| aReturn <<= getFormatKey(); |
| } |
| break; |
| |
| default: |
| aReturn <<= VCLXSpinField::getProperty(PropertyName); |
| } |
| } |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::convertEffectiveValue(const ::com::sun::star::uno::Any& rValue) |
| { |
| ::com::sun::star::uno::Any aReturn; |
| |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return aReturn; |
| |
| switch (rValue.getValueType().getTypeClass()) |
| { |
| case ::com::sun::star::uno::TypeClass_DOUBLE: |
| if (pField->TreatingAsNumber()) |
| { |
| double d = 0.0; |
| rValue >>= d; |
| aReturn <<= d; |
| } |
| else |
| { |
| SvNumberFormatter* pFormatter = pField->GetFormatter(); |
| if (!pFormatter) |
| pFormatter = pField->StandardFormatter(); |
| // should never fail |
| |
| Color* pDum; |
| double d = 0.0; |
| rValue >>= d; |
| String sConverted; |
| pFormatter->GetOutputString(d, 0, sConverted, &pDum); |
| aReturn <<= ::rtl::OUString( sConverted ); |
| } |
| break; |
| case ::com::sun::star::uno::TypeClass_STRING: |
| { |
| ::rtl::OUString aStr; |
| rValue >>= aStr; |
| String sValue = aStr; |
| if (pField->TreatingAsNumber()) |
| { |
| SvNumberFormatter* pFormatter = pField->GetFormatter(); |
| if (!pFormatter) |
| pFormatter = pField->StandardFormatter(); |
| |
| double dVal; |
| sal_uInt32 nTestFormat(0); |
| if (!pFormatter->IsNumberFormat(sValue, nTestFormat, dVal)) |
| aReturn.clear(); |
| aReturn <<=dVal; |
| } |
| else |
| aReturn <<= aStr; |
| } |
| break; |
| default: |
| aReturn.clear(); |
| break; |
| } |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetMinValue(const ::com::sun::star::uno::Any& rValue) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return; |
| |
| switch (rValue.getValueType().getTypeClass()) |
| |
| { |
| case ::com::sun::star::uno::TypeClass_DOUBLE: |
| { |
| double d = 0.0; |
| rValue >>= d; |
| pField->SetMinValue(d); |
| } |
| break; |
| default: |
| DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID, "SVTXFormattedField::SetMinValue : invalid argument (an exception will be thrown) !"); |
| if ( rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID ) |
| |
| { |
| throw ::com::sun::star::lang::IllegalArgumentException(); |
| } |
| pField->ClearMinValue(); |
| break; |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::GetMinValue() |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField || !pField->HasMinValue()) |
| return ::com::sun::star::uno::Any(); |
| |
| ::com::sun::star::uno::Any aReturn; |
| aReturn <<= pField->GetMinValue(); |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetMaxValue(const ::com::sun::star::uno::Any& rValue) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return; |
| |
| switch (rValue.getValueType().getTypeClass()) |
| |
| { |
| case ::com::sun::star::uno::TypeClass_DOUBLE: |
| { |
| double d = 0.0; |
| rValue >>= d; |
| pField->SetMaxValue(d); |
| } |
| break; |
| default: |
| if (rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID) |
| |
| { |
| throw ::com::sun::star::lang::IllegalArgumentException(); |
| } |
| pField->ClearMaxValue(); |
| break; |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::GetMaxValue() |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField || !pField->HasMaxValue()) |
| return ::com::sun::star::uno::Any(); |
| |
| ::com::sun::star::uno::Any aReturn; |
| aReturn <<= pField->GetMaxValue(); |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetDefaultValue(const ::com::sun::star::uno::Any& rValue) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return; |
| |
| ::com::sun::star::uno::Any aConverted = convertEffectiveValue(rValue); |
| |
| switch (aConverted.getValueType().getTypeClass()) |
| |
| { |
| case ::com::sun::star::uno::TypeClass_DOUBLE: |
| { |
| double d = 0.0; |
| aConverted >>= d; |
| pField->SetDefaultValue(d); |
| } |
| break; |
| case ::com::sun::star::uno::TypeClass_STRING: |
| { |
| ::rtl::OUString aStr; |
| aConverted >>= aStr; |
| pField->SetDefaultText( aStr ); |
| } |
| break; |
| default: |
| pField->EnableEmptyField(sal_True); |
| // nur noch void erlaubt |
| break; |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::GetDefaultValue() |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField || pField->IsEmptyFieldEnabled()) |
| return ::com::sun::star::uno::Any(); |
| |
| ::com::sun::star::uno::Any aReturn; |
| if (pField->TreatingAsNumber()) |
| aReturn <<= pField->GetDefaultValue(); |
| else |
| aReturn <<= ::rtl::OUString( pField->GetDefaultText() ); |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| sal_Bool SVTXFormattedField::GetTreatAsNumber() |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (pField) |
| return pField->TreatingAsNumber(); |
| |
| return sal_True; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetTreatAsNumber(sal_Bool bSet) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (pField) |
| pField->TreatAsNumber(bSet); |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXFormattedField::GetValue() |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return ::com::sun::star::uno::Any(); |
| |
| ::com::sun::star::uno::Any aReturn; |
| if (!pField->TreatingAsNumber()) |
| { |
| ::rtl::OUString sText = pField->GetTextValue(); |
| aReturn <<= sText; |
| } |
| else |
| { |
| if (pField->GetText().Len()) // empty wird erst mal standardmaessig als void nach draussen gereicht |
| aReturn <<= pField->GetValue(); |
| } |
| |
| return aReturn; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::SetValue(const ::com::sun::star::uno::Any& rValue) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (!pField) |
| return; |
| |
| if (!rValue.hasValue()) |
| { |
| pField->SetText(String()); |
| } |
| else |
| { |
| if (rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE ) |
| { |
| double d = 0.0; |
| rValue >>= d; |
| pField->SetValue(d); |
| } |
| else |
| { |
| DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING, "SVTXFormattedField::SetValue : invalid argument !"); |
| |
| ::rtl::OUString sText; |
| rValue >>= sText; |
| String aStr( sText ); |
| if (!pField->TreatingAsNumber()) |
| pField->SetTextFormatted(aStr); |
| else |
| pField->SetTextValue(aStr); |
| } |
| } |
| // NotifyTextListeners(); |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > SVTXFormattedField::getFormatsSupplier(void) const |
| { |
| return ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > ((::com::sun::star::util::XNumberFormatsSupplier*)m_pCurrentSupplier); |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::setFormatsSupplier(const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > & xSupplier) |
| { |
| FormattedField* pField = GetFormattedField(); |
| |
| SvNumberFormatsSupplierObj* pNew = NULL; |
| if (!xSupplier.is()) |
| { |
| if (pField) |
| { |
| pNew = new SvNumberFormatsSupplierObj(pField->StandardFormatter()); |
| bIsStandardSupplier = sal_True; |
| } |
| } |
| else |
| { |
| pNew = SvNumberFormatsSupplierObj::getImplementation(xSupplier); |
| bIsStandardSupplier = sal_False; |
| } |
| |
| if (!pNew) |
| return; // TODO : wie das behandeln ? |
| |
| if (m_pCurrentSupplier) |
| m_pCurrentSupplier->release(); |
| m_pCurrentSupplier = pNew; |
| m_pCurrentSupplier->acquire(); |
| if (pField) |
| { |
| // den aktuellen Value mit hinueberretten |
| ::com::sun::star::uno::Any aCurrent = GetValue(); |
| pField->SetFormatter(m_pCurrentSupplier->GetNumberFormatter(), sal_False); |
| if (nKeyToSetDelayed != -1) |
| { |
| pField->SetFormatKey(nKeyToSetDelayed); |
| nKeyToSetDelayed = -1; |
| } |
| SetValue(aCurrent); |
| NotifyTextListeners(); |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| sal_Int32 SVTXFormattedField::getFormatKey(void) const |
| { |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetFormatKey() : 0; |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::setFormatKey(sal_Int32 nKey) |
| { |
| FormattedField* pField = GetFormattedField(); |
| if (pField) |
| { |
| if (pField->GetFormatter()) |
| pField->SetFormatKey(nKey); |
| else |
| { // Wahrscheinlich bin ich gerade in einem Block, in dem erst der Key und dann der Formatter gesetzt |
| // wird, das passiert initial mit ziemlicher Sicherheit, da die Properties in alphabetischer Reihenfolge |
| // gesetzt werden, und der FormatsSupplier nun mal vor dem FormatKey kommt |
| nKeyToSetDelayed = nKey; |
| } |
| NotifyTextListeners(); |
| } |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXFormattedField::NotifyTextListeners() |
| { |
| if ( GetTextListeners().getLength() ) |
| { |
| ::com::sun::star::awt::TextEvent aEvent; |
| aEvent.Source = (::cppu::OWeakObject*)this; |
| GetTextListeners().textChanged( aEvent ); |
| } |
| } |
| |
| void SVTXFormattedField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| // FIXME: elide duplication ? |
| BASEPROPERTY_EFFECTIVE_MIN, |
| BASEPROPERTY_VALUEMIN_DOUBLE, |
| BASEPROPERTY_EFFECTIVE_MAX, |
| BASEPROPERTY_VALUEMAX_DOUBLE, |
| BASEPROPERTY_EFFECTIVE_DEFAULT, |
| BASEPROPERTY_TREATASNUMBER, |
| BASEPROPERTY_EFFECTIVE_VALUE, |
| BASEPROPERTY_VALUE_DOUBLE, |
| BASEPROPERTY_VALUESTEP_DOUBLE, |
| BASEPROPERTY_DECIMALACCURACY, |
| BASEPROPERTY_FORMATSSUPPLIER, |
| BASEPROPERTY_NUMSHOWTHOUSANDSEP, |
| BASEPROPERTY_FORMATKEY, |
| BASEPROPERTY_TREATASNUMBER, |
| BASEPROPERTY_ENFORCE_FORMAT, |
| 0); |
| VCLXWindow::ImplGetPropertyIds( rIds, true ); |
| VCLXSpinField::ImplGetPropertyIds( rIds ); |
| } |
| |
| |
| // ---------------------------------------------------- |
| // class SVTXRoadmap |
| // ---------------------------------------------------- |
| |
| using namespace svt; |
| |
| // -------------------------------------------------------------------------------------- |
| SVTXRoadmap::SVTXRoadmap() : maItemListeners( *this ) |
| { |
| } |
| |
| // -------------------------------------------------------------------------------------- |
| SVTXRoadmap::~SVTXRoadmap() |
| { |
| } |
| |
| void SVTXRoadmap::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) |
| { |
| switch ( rVclWindowEvent.GetId() ) |
| { |
| case VCLEVENT_ROADMAP_ITEMSELECTED: |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| sal_Int16 CurItemID = pField->GetCurrentRoadmapItemID(); |
| ::com::sun::star::awt::ItemEvent aEvent; |
| aEvent.Selected = CurItemID; |
| aEvent.Highlighted = CurItemID; |
| aEvent.ItemId = CurItemID; |
| maItemListeners.itemStateChanged( aEvent ); |
| } |
| } |
| break; |
| default: |
| SVTXRoadmap_Base::ProcessWindowEvent( rVclWindowEvent ); |
| break; |
| } |
| } |
| |
| |
| void SVTXRoadmap::propertyChange( const ::com::sun::star::beans::PropertyChangeEvent& evt ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem; |
| xRoadmapItem = evt.Source; |
| sal_Int32 nID = 0; |
| ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY ); |
| ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(::rtl::OUString::createFromAscii( "ID" )); |
| aValue >>= nID; |
| |
| ::com::sun::star::uno::Any rVal = evt.NewValue; |
| evt.NewValue >>= rVal; |
| ::rtl::OUString sPropertyName = evt.PropertyName; |
| if ( sPropertyName.equals(::rtl::OUString::createFromAscii( "Enabled" ) ) ) |
| { |
| sal_Bool bEnable = false; |
| evt.NewValue >>= bEnable; |
| pField->EnableRoadmapItem( (RoadmapTypes::ItemId)nID , bEnable ); |
| } |
| else if ( sPropertyName.equals(::rtl::OUString::createFromAscii( "Label" ) ) ) |
| { |
| ::rtl::OUString sLabel; |
| evt.NewValue >>= sLabel; |
| pField->ChangeRoadmapItemLabel( (RoadmapTypes::ItemId)nID , sLabel ); |
| } |
| else if ( sPropertyName.equals(::rtl::OUString::createFromAscii( "ID" ) ) ) |
| { |
| sal_Int32 nNewID = 0; |
| evt.NewValue >>= nNewID; |
| evt.OldValue >>= nID; |
| pField->ChangeRoadmapItemID( (RoadmapTypes::ItemId)nID, (RoadmapTypes::ItemId)nNewID ); |
| } |
| // else |
| // Todo: handle Interactive appropriately |
| } |
| } |
| |
| |
| void SVTXRoadmap::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| maItemListeners.addInterface( l ); |
| } |
| |
| void SVTXRoadmap::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| maItemListeners.removeInterface( l ); |
| } |
| |
| RMItemData SVTXRoadmap::GetRMItemData( const ::com::sun::star::container::ContainerEvent& _rEvent ) |
| { |
| RMItemData aCurRMItemData; |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem; |
| _rEvent.Element >>= xRoadmapItem; |
| ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY ); |
| if ( xPropertySet.is() ) |
| { |
| ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(::rtl::OUString::createFromAscii( "Label" )); |
| aValue >>= aCurRMItemData.Label; |
| aValue = xPropertySet->getPropertyValue(::rtl::OUString::createFromAscii( "ID" )); |
| aValue >>= aCurRMItemData.n_ID; |
| aValue = xPropertySet->getPropertyValue(::rtl::OUString::createFromAscii( "Enabled" )); |
| aValue >>= aCurRMItemData.b_Enabled; |
| } |
| return aCurRMItemData;; |
| } |
| |
| void SVTXRoadmap::elementInserted( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| RMItemData CurItemData = GetRMItemData( _rEvent ); |
| sal_Int32 InsertIndex = 0; |
| _rEvent.Accessor >>= InsertIndex; |
| pField->InsertRoadmapItem( InsertIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled ); |
| } |
| } |
| |
| void SVTXRoadmap::elementRemoved( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| sal_Int32 DelIndex = 0; |
| _rEvent.Accessor >>= DelIndex; |
| pField->DeleteRoadmapItem(DelIndex); |
| // pField->GetCurrentRoadmapItem() |
| // setProperty(::rtl::OUString.createFromAscii( "CurrentItem" )aAny, |
| } |
| } |
| |
| void SVTXRoadmap::elementReplaced( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| RMItemData CurItemData = GetRMItemData( _rEvent ); |
| sal_Int32 ReplaceIndex = 0; |
| _rEvent.Accessor >>= ReplaceIndex; |
| pField->ReplaceRoadmapItem( ReplaceIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled ); |
| } |
| } |
| |
| |
| |
| // -------------------------------------------------------------------------------------- |
| void SVTXRoadmap::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_COMPLETE: |
| { |
| sal_Bool b = false; |
| Value >>= b; |
| pField->SetRoadmapComplete( b); |
| } |
| break; |
| |
| case BASEPROPERTY_ACTIVATED: |
| { |
| sal_Bool b = false; |
| Value >>= b; |
| pField->SetRoadmapInteractive( b); |
| } |
| break; |
| |
| case BASEPROPERTY_CURRENTITEMID: |
| { |
| sal_Int32 nId = 0; |
| Value >>= nId; |
| pField->SelectRoadmapItemByID( (RoadmapTypes::ItemId)nId ); |
| } |
| break; |
| |
| case BASEPROPERTY_TEXT: |
| { |
| ::rtl::OUString aStr; |
| Value >>= aStr; |
| pField->SetText( aStr ); |
| pField->Invalidate(); |
| } |
| break; |
| |
| default: |
| SVTXRoadmap_Base::setProperty( PropertyName, Value ); |
| break; |
| } |
| |
| } |
| else |
| SVTXRoadmap_Base::setProperty( PropertyName, Value ); |
| } |
| |
| |
| // -------------------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any SVTXRoadmap::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aReturn; |
| |
| ::svt::ORoadmap* pField = GetRoadmap(); |
| if ( pField ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_COMPLETE: |
| aReturn <<= pField->IsRoadmapComplete(); |
| break; |
| case BASEPROPERTY_ACTIVATED: |
| aReturn <<= pField->IsRoadmapInteractive(); |
| break; |
| case BASEPROPERTY_CURRENTITEMID: |
| aReturn <<= pField->GetCurrentRoadmapItemID(); |
| break; |
| default: |
| aReturn = SVTXRoadmap_Base::getProperty(PropertyName); |
| break; |
| } |
| } |
| return aReturn; |
| } |
| |
| void SVTXRoadmap::ImplSetNewImage() |
| { |
| OSL_PRECOND( GetWindow(), "SVTXRoadmap::ImplSetNewImage: window is required to be not-NULL!" ); |
| ::svt::ORoadmap* pButton = static_cast< ::svt::ORoadmap* >( GetWindow() ); |
| pButton->SetRoadmapBitmap( GetImage().GetBitmapEx() ); |
| } |
| |
| void SVTXRoadmap::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| BASEPROPERTY_COMPLETE, |
| BASEPROPERTY_ACTIVATED, |
| BASEPROPERTY_CURRENTITEMID, |
| BASEPROPERTY_TEXT, |
| 0); |
| VCLXWindow::ImplGetPropertyIds( rIds, true ); |
| VCLXGraphicControl::ImplGetPropertyIds( rIds ); |
| } |
| |
| // ---------------------------------------------------- |
| // class SVTXNumericField |
| // ---------------------------------------------------- |
| SVTXNumericField::SVTXNumericField() |
| { |
| } |
| |
| SVTXNumericField::~SVTXNumericField() |
| { |
| } |
| |
| ::com::sun::star::uno::Any SVTXNumericField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, |
| SAL_STATIC_CAST( ::com::sun::star::awt::XNumericField*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) ); |
| return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType )); |
| } |
| |
| // ::com::sun::star::lang::XTypeProvider |
| IMPL_XTYPEPROVIDER_START( SVTXNumericField ) |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XNumericField>* ) NULL ), |
| SVTXFormattedField::getTypes() |
| IMPL_XTYPEPROVIDER_END |
| |
| |
| void SVTXNumericField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetValue( Value ); |
| } |
| |
| double SVTXNumericField::getValue() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetValue() : 0; |
| } |
| |
| void SVTXNumericField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetMinValue( Value ); |
| } |
| |
| double SVTXNumericField::getMin() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetMinValue() : 0; |
| } |
| |
| void SVTXNumericField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetMaxValue( Value ); |
| } |
| |
| double SVTXNumericField::getMax() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetMaxValue() : 0; |
| } |
| |
| void SVTXNumericField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinFirst( Value ); |
| } |
| |
| double SVTXNumericField::getFirst() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinFirst() : 0; |
| } |
| |
| void SVTXNumericField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinLast( Value ); |
| } |
| |
| double SVTXNumericField::getLast() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinLast() : 0; |
| } |
| |
| void SVTXNumericField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinSize( Value ); |
| } |
| |
| double SVTXNumericField::getSpinSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinSize() : 0; |
| } |
| |
| void SVTXNumericField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetDecimalDigits( Value ); |
| } |
| |
| sal_Int16 SVTXNumericField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetDecimalDigits() : 0; |
| } |
| |
| void SVTXNumericField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetStrictFormat( bStrict ); |
| } |
| |
| sal_Bool SVTXNumericField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->IsStrictFormat() : sal_False; |
| } |
| |
| void SVTXNumericField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| SVTXFormattedField::ImplGetPropertyIds( rIds ); |
| } |
| |
| // ---------------------------------------------------- |
| // class SVTXCurrencyField |
| // ---------------------------------------------------- |
| SVTXCurrencyField::SVTXCurrencyField() |
| { |
| } |
| |
| SVTXCurrencyField::~SVTXCurrencyField() |
| { |
| } |
| |
| ::com::sun::star::uno::Any SVTXCurrencyField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, |
| SAL_STATIC_CAST( ::com::sun::star::awt::XCurrencyField*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) ); |
| return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType )); |
| } |
| |
| // ::com::sun::star::lang::XTypeProvider |
| IMPL_XTYPEPROVIDER_START( SVTXCurrencyField ) |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XCurrencyField>* ) NULL ), |
| SVTXFormattedField::getTypes() |
| IMPL_XTYPEPROVIDER_END |
| |
| void SVTXCurrencyField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetValue( Value ); |
| } |
| |
| double SVTXCurrencyField::getValue() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetValue() : 0; |
| } |
| |
| void SVTXCurrencyField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetMinValue( Value ); |
| } |
| |
| double SVTXCurrencyField::getMin() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetMinValue() : 0; |
| } |
| |
| void SVTXCurrencyField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetMaxValue( Value ); |
| } |
| |
| double SVTXCurrencyField::getMax() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetMaxValue() : 0; |
| } |
| |
| void SVTXCurrencyField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinFirst( Value ); |
| } |
| |
| double SVTXCurrencyField::getFirst() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinFirst() : 0; |
| } |
| |
| void SVTXCurrencyField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinLast( Value ); |
| } |
| |
| double SVTXCurrencyField::getLast() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinLast() : 0; |
| } |
| |
| void SVTXCurrencyField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetSpinSize( Value ); |
| } |
| |
| double SVTXCurrencyField::getSpinSize() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetSpinSize() : 0; |
| } |
| |
| void SVTXCurrencyField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetDecimalDigits( Value ); |
| } |
| |
| sal_Int16 SVTXCurrencyField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->GetDecimalDigits() : 0; |
| } |
| |
| void SVTXCurrencyField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| if ( pField ) |
| pField->SetStrictFormat( bStrict ); |
| } |
| |
| sal_Bool SVTXCurrencyField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| FormattedField* pField = GetFormattedField(); |
| return pField ? pField->IsStrictFormat() : sal_False; |
| } |
| |
| void SVTXCurrencyField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aReturn; |
| |
| DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField(); |
| if ( pField ) |
| { |
| #ifdef DBG_UTIL |
| String sAssertion( String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "SVTXCurrencyField::setProperty(" ) ) ); |
| sAssertion += String( PropertyName ); |
| sAssertion.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ") : invalid value !" ) ); |
| #endif |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_CURRENCYSYMBOL: |
| { |
| ::rtl::OUString aStr; |
| Value >>= aStr; |
| pField->setCurrencySymbol( aStr ); |
| } |
| break; |
| case BASEPROPERTY_CURSYM_POSITION: |
| { |
| sal_Bool b = false; |
| Value >>= b; |
| pField->setPrependCurrSym(b); |
| } |
| break; |
| |
| default: |
| SVTXFormattedField::setProperty(PropertyName, Value); |
| } |
| } |
| else |
| SVTXFormattedField::setProperty(PropertyName, Value); |
| } |
| |
| ::com::sun::star::uno::Any SVTXCurrencyField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aReturn; |
| |
| DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField(); |
| if ( pField ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch (nPropType) |
| { |
| case BASEPROPERTY_CURRENCYSYMBOL: |
| { |
| aReturn <<= ::rtl::OUString( pField->getCurrencySymbol() ); |
| } |
| break; |
| case BASEPROPERTY_CURSYM_POSITION: |
| { |
| aReturn <<= pField->getPrependCurrSym(); |
| } |
| break; |
| default: |
| return SVTXFormattedField::getProperty(PropertyName); |
| } |
| } |
| return SVTXFormattedField::getProperty(PropertyName); |
| } |
| |
| void SVTXCurrencyField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| BASEPROPERTY_CURRENCYSYMBOL, |
| BASEPROPERTY_CURSYM_POSITION, |
| 0); |
| SVTXFormattedField::ImplGetPropertyIds( rIds ); |
| } |
| |
| |
| // ---------------------------------------------------- |
| // class VCLXProgressBar |
| // ---------------------------------------------------- |
| |
| VCLXProgressBar::VCLXProgressBar() |
| :m_nValue(0) |
| ,m_nValueMin(0) |
| ,m_nValueMax(100) |
| { |
| } |
| |
| VCLXProgressBar::~VCLXProgressBar() |
| { |
| } |
| |
| void VCLXProgressBar::ImplUpdateValue() |
| { |
| ProgressBar* pProgressBar = (ProgressBar*) GetWindow(); |
| if ( pProgressBar ) |
| { |
| sal_Int32 nVal; |
| sal_Int32 nValMin; |
| sal_Int32 nValMax; |
| |
| // check min and max |
| if (m_nValueMin < m_nValueMax) |
| { |
| nValMin = m_nValueMin; |
| nValMax = m_nValueMax; |
| } |
| else |
| { |
| nValMin = m_nValueMax; |
| nValMax = m_nValueMin; |
| } |
| |
| // check value |
| if (m_nValue < nValMin) |
| { |
| nVal = nValMin; |
| } |
| else if (m_nValue > nValMax) |
| { |
| nVal = nValMax; |
| } |
| else |
| { |
| nVal = m_nValue; |
| } |
| |
| // calculate percent |
| sal_Int32 nPercent; |
| if (nValMin != nValMax) |
| { |
| nPercent = 100 * (nVal - nValMin) / (nValMax - nValMin); |
| } |
| else |
| { |
| nPercent = 0; |
| } |
| |
| // set progressbar value |
| pProgressBar->SetValue( (sal_uInt16) nPercent ); |
| } |
| } |
| |
| // ::com::sun::star::uno::XInterface |
| ::com::sun::star::uno::Any VCLXProgressBar::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType, |
| SAL_STATIC_CAST( ::com::sun::star::awt::XProgressBar*, this ), |
| SAL_STATIC_CAST( ::com::sun::star::lang::XTypeProvider*, this ) ); |
| return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType )); |
| } |
| |
| // ::com::sun::star::lang::XTypeProvider |
| IMPL_XTYPEPROVIDER_START( VCLXProgressBar ) |
| getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XProgressBar>* ) NULL ), |
| VCLXWindow::getTypes() |
| IMPL_XTYPEPROVIDER_END |
| |
| // ::com::sun::star::awt::XProgressBar |
| void VCLXProgressBar::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| Window* pWindow = GetWindow(); |
| if ( pWindow ) |
| { |
| Color aColor( nColor ); |
| pWindow->SetControlForeground( aColor ); |
| } |
| } |
| |
| void VCLXProgressBar::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| Window* pWindow = GetWindow(); |
| if ( pWindow ) |
| { |
| Color aColor( nColor ); |
| pWindow->SetBackground( aColor ); |
| pWindow->SetControlBackground( aColor ); |
| pWindow->Invalidate(); |
| } |
| } |
| |
| void VCLXProgressBar::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| m_nValue = nValue; |
| ImplUpdateValue(); |
| } |
| |
| void VCLXProgressBar::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| if ( nMin < nMax ) |
| { |
| // take correct min and max |
| m_nValueMin = nMin; |
| m_nValueMax = nMax; |
| } |
| else |
| { |
| // change min and max |
| m_nValueMin = nMax; |
| m_nValueMax = nMin; |
| } |
| |
| ImplUpdateValue(); |
| } |
| |
| sal_Int32 VCLXProgressBar::getValue() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| return m_nValue; |
| } |
| |
| // ::com::sun::star::awt::VclWindowPeer |
| void VCLXProgressBar::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ProgressBar* pProgressBar = (ProgressBar*)GetWindow(); |
| if ( pProgressBar ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch ( nPropType ) |
| { |
| case BASEPROPERTY_PROGRESSVALUE: |
| { |
| if ( Value >>= m_nValue ) |
| ImplUpdateValue(); |
| } |
| break; |
| case BASEPROPERTY_PROGRESSVALUE_MIN: |
| { |
| if ( Value >>= m_nValueMin ) |
| ImplUpdateValue(); |
| } |
| break; |
| case BASEPROPERTY_PROGRESSVALUE_MAX: |
| { |
| if ( Value >>= m_nValueMax ) |
| ImplUpdateValue(); |
| } |
| break; |
| case BASEPROPERTY_FILLCOLOR: |
| { |
| Window* pWindow = GetWindow(); |
| if ( pWindow ) |
| { |
| sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID; |
| |
| if ( bVoid ) |
| { |
| pWindow->SetControlForeground(); |
| } |
| else |
| { |
| sal_Int32 nColor = 0; |
| if ( Value >>= nColor ) |
| { |
| Color aColor( nColor ); |
| pWindow->SetControlForeground( aColor ); |
| } |
| } |
| } |
| } |
| break; |
| default: |
| VCLXWindow::setProperty( PropertyName, Value ); |
| break; |
| } |
| } |
| } |
| |
| ::com::sun::star::uno::Any VCLXProgressBar::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( GetMutex() ); |
| |
| ::com::sun::star::uno::Any aProp; |
| ProgressBar* pProgressBar = (ProgressBar*)GetWindow(); |
| if ( pProgressBar ) |
| { |
| sal_uInt16 nPropType = GetPropertyId( PropertyName ); |
| switch ( nPropType ) |
| { |
| case BASEPROPERTY_PROGRESSVALUE: |
| { |
| aProp <<= m_nValue; |
| } |
| break; |
| case BASEPROPERTY_PROGRESSVALUE_MIN: |
| { |
| aProp <<= m_nValueMin; |
| } |
| break; |
| case BASEPROPERTY_PROGRESSVALUE_MAX: |
| { |
| aProp <<= m_nValueMax; |
| } |
| break; |
| default: |
| aProp <<= VCLXWindow::getProperty( PropertyName ); |
| break; |
| } |
| } |
| return aProp; |
| } |
| |
| void VCLXProgressBar::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| BASEPROPERTY_PROGRESSVALUE, |
| BASEPROPERTY_PROGRESSVALUE_MIN, |
| BASEPROPERTY_PROGRESSVALUE_MAX, |
| BASEPROPERTY_FILLCOLOR, |
| 0); |
| VCLXWindow::ImplGetPropertyIds( rIds, true ); |
| } |
| |
| |
| // ---------------------------------------------------- |
| // class SVTXDateField |
| // ---------------------------------------------------- |
| SVTXDateField::SVTXDateField() |
| :VCLXDateField() |
| { |
| } |
| |
| SVTXDateField::~SVTXDateField() |
| { |
| } |
| |
| void SAL_CALL SVTXDateField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| VCLXDateField::setProperty( PropertyName, Value ); |
| |
| // some properties need to be forwarded to the sub edit, too |
| Edit* pSubEdit = GetWindow() ? static_cast< Edit* >( GetWindow() )->GetSubEdit() : NULL; |
| if ( !pSubEdit ) |
| return; |
| |
| switch ( GetPropertyId( PropertyName ) ) |
| { |
| case BASEPROPERTY_TEXTLINECOLOR: |
| if ( !Value.hasValue() ) |
| pSubEdit->SetTextLineColor(); |
| else |
| { |
| sal_Int32 nColor = 0; |
| if ( Value >>= nColor ) |
| pSubEdit->SetTextLineColor( Color( nColor ) ); |
| } |
| break; |
| } |
| } |
| |
| void SVTXDateField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds ) |
| { |
| PushPropertyIds( rIds, |
| BASEPROPERTY_TEXTLINECOLOR, |
| 0); |
| VCLXDateField::ImplGetPropertyIds( rIds ); |
| } |