diff options
Diffstat (limited to 'forms/source/component/DatabaseForm.cxx')
| -rw-r--r-- | forms/source/component/DatabaseForm.cxx | 4162 |
1 files changed, 4162 insertions, 0 deletions
diff --git a/forms/source/component/DatabaseForm.cxx b/forms/source/component/DatabaseForm.cxx new file mode 100644 index 000000000000..154ed4b00272 --- /dev/null +++ b/forms/source/component/DatabaseForm.cxx @@ -0,0 +1,4162 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_forms.hxx" + +#include "componenttools.hxx" +#include "DatabaseForm.hxx" +#include "EventThread.hxx" +#include "frm_module.hxx" +#include "frm_resource.hrc" +#include "frm_resource.hxx" +#include "GroupManager.hxx" +#include "property.hrc" +#include "property.hxx" +#include "services.hxx" + +#include <com/sun/star/awt/XControlContainer.hpp> +#include <com/sun/star/awt/XTextComponent.hpp> +#include <com/sun/star/form/DataSelectionType.hpp> +#include <com/sun/star/form/FormComponentType.hpp> +#include <com/sun/star/form/TabulatorCycle.hpp> +#include <com/sun/star/frame/FrameSearchFlag.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/io/XObjectInputStream.hpp> +#include <com/sun/star/io/XObjectOutputStream.hpp> +#include <com/sun/star/sdb/CommandType.hpp> +#include <com/sun/star/sdb/RowSetVetoException.hpp> +#include <com/sun/star/sdb/SQLContext.hpp> +#include <com/sun/star/sdb/XColumnUpdate.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/sdbc/ResultSetConcurrency.hpp> +#include <com/sun/star/sdbc/ResultSetType.hpp> +#include <com/sun/star/sdbc/XRowSet.hpp> +#include <com/sun/star/sdbcx/Privilege.hpp> +#include <com/sun/star/sdbcx/XColumnsSupplier.hpp> +#include <com/sun/star/util/XCancellable.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> +#include <com/sun/star/util/XModifiable2.hpp> + +#include <comphelper/basicio.hxx> +#include <comphelper/container.hxx> +#include <comphelper/enumhelper.hxx> +#include <comphelper/extract.hxx> +#include <comphelper/seqstream.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/stl_types.hxx> +#include <comphelper/uno3.hxx> +#include <connectivity/dbtools.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <cppuhelper/implbase2.hxx> +#include <osl/mutex.hxx> +#include <rtl/math.hxx> +#include <rtl/tencinfo.h> +#include <svl/inetstrm.hxx> +#include <svl/inettype.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <tools/fsys.hxx> +#include <tools/inetmsg.hxx> +#include <tools/urlobj.hxx> +#include <unotools/ucblockbytes.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/timer.hxx> +#include <vos/mutex.hxx> + +#include <ctype.h> +#include <hash_map> + +// compatiblity: DatabaseCursorType is dead, but for compatiblity reasons we still have to write it ... +namespace com { +namespace sun { +namespace star { +namespace data { + +enum DatabaseCursorType +{ + DatabaseCursorType_FORWARD = 0, + DatabaseCursorType_SNAPSHOT = 1, + DatabaseCursorType_KEYSET = 2, + DatabaseCursorType_DYNAMIC = 3, + DatabaseCursorType_MAKE_FIXED_SIZE = SAL_MAX_ENUM +}; + +} } } } + +using namespace ::dbtools; +using namespace ::comphelper; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdb; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::sdbcx; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::task; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::form; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::data; +using namespace ::com::sun::star::util; + +//-------------------------------------------------------------------------- +extern "C" void SAL_CALL createRegistryInfo_ODatabaseForm() +{ + static ::frm::OMultiInstanceAutoRegistration< ::frm::ODatabaseForm > aAutoRegistration; +} + +//......................................................................... +namespace frm +{ +//......................................................................... + +//================================================================== +//= DocumentModifyGuard +//================================================================== +class DocumentModifyGuard +{ +public: + DocumentModifyGuard( const Reference< XInterface >& _rxFormComponent ) + :m_xDocumentModify( getXModel( _rxFormComponent ), UNO_QUERY ) + { + impl_changeModifiableFlag_nothrow( false ); + } + ~DocumentModifyGuard() + { + impl_changeModifiableFlag_nothrow( true ); + } + +private: + void impl_changeModifiableFlag_nothrow( const bool _enable ) + { + try + { + if ( m_xDocumentModify.is() ) + _enable ? m_xDocumentModify->enableSetModified() : m_xDocumentModify->disableSetModified(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + +private: + Reference< XModifiable2 > m_xDocumentModify; +}; + +//================================================================== +//= OFormSubmitResetThread +//=----------------------------------------------------------------- +//= submitting and resetting html-forms asynchronously +//================================================================== + +//------------------------------------------------------------------ +class OFormSubmitResetThread: public OComponentEventThread +{ +protected: + + // duplicate an event with respect to it's type + virtual EventObject *cloneEvent( const EventObject *pEvt ) const; + + // process an event. while processing the mutex isn't locked, and pCompImpl + // is made sure to remain valid + virtual void processEvent( ::cppu::OComponentHelper* _pCompImpl, + const EventObject* _pEvt, + const Reference<XControl>& _rControl, + sal_Bool _bSubmit); + +public: + + OFormSubmitResetThread(ODatabaseForm* pControl) : OComponentEventThread(pControl) { } +}; + +//------------------------------------------------------------------ +EventObject* OFormSubmitResetThread::cloneEvent( + const EventObject *pEvt ) const +{ + return new ::com::sun::star::awt::MouseEvent( *(::com::sun::star::awt::MouseEvent *)pEvt ); +} + +//------------------------------------------------------------------ +void OFormSubmitResetThread::processEvent( + ::cppu::OComponentHelper* pCompImpl, + const EventObject *_pEvt, + const Reference<XControl>& _rControl, + sal_Bool _bSubmit) +{ + if (_bSubmit) + ((ODatabaseForm *)pCompImpl)->submit_impl(_rControl, *static_cast<const ::com::sun::star::awt::MouseEvent*>(_pEvt), true); + else + ((ODatabaseForm *)pCompImpl)->reset_impl(true); +} + +//================================================================== +//= ODatabaseForm +//================================================================== + +//------------------------------------------------------------------ +Reference< XInterface > SAL_CALL ODatabaseForm::Create( const Reference< XMultiServiceFactory >& _rxFactory ) +{ + return *( new ODatabaseForm( _rxFactory ) ); +} + +//------------------------------------------------------------------------------ +Sequence<sal_Int8> SAL_CALL ODatabaseForm::getImplementationId() throw(RuntimeException) +{ + return OImplementationIds::getImplementationId(getTypes()); +} + +//------------------------------------------------------------------ +Sequence<Type> SAL_CALL ODatabaseForm::getTypes() throw(RuntimeException) +{ + // ask the aggregate + Sequence<Type> aAggregateTypes; + Reference<XTypeProvider> xAggregateTypes; + if (query_aggregation(m_xAggregate, xAggregateTypes)) + aAggregateTypes = xAggregateTypes->getTypes(); + + Sequence< Type > aRet = concatSequences( + aAggregateTypes, ODatabaseForm_BASE1::getTypes(), OFormComponents::getTypes() + ); + aRet = concatSequences( aRet, ODatabaseForm_BASE2::getTypes(), ODatabaseForm_BASE3::getTypes() ); + return concatSequences( aRet, OPropertySetAggregationHelper::getTypes() ); +} + +//------------------------------------------------------------------ +Any SAL_CALL ODatabaseForm::queryAggregation(const Type& _rType) throw(RuntimeException) +{ + Any aReturn = ODatabaseForm_BASE1::queryInterface(_rType); + // our own interfaces + if (!aReturn.hasValue()) + { + aReturn = ODatabaseForm_BASE2::queryInterface(_rType); + // property set related interfaces + if (!aReturn.hasValue()) + { + aReturn = OPropertySetAggregationHelper::queryInterface(_rType); + + // form component collection related interfaces + if (!aReturn.hasValue()) + { + aReturn = OFormComponents::queryAggregation(_rType); + + // interfaces already present in the aggregate which we want to reroute + // only available if we could create the aggregate + if (!aReturn.hasValue() && m_xAggregateAsRowSet.is()) + aReturn = ODatabaseForm_BASE3::queryInterface(_rType); + + // aggregate interfaces + // (ask the aggregated object _after_ the OComponentHelper (base of OFormComponents), + // so calls to the XComponent interface reach us and not the aggreagtion) + if (!aReturn.hasValue() && m_xAggregate.is()) + aReturn = m_xAggregate->queryAggregation(_rType); + } + } + } + + return aReturn; +} + +DBG_NAME(ODatabaseForm); +//------------------------------------------------------------------ +ODatabaseForm::ODatabaseForm(const Reference<XMultiServiceFactory>& _rxFactory) + :OFormComponents(_rxFactory) + ,OPropertySetAggregationHelper(OComponentHelper::rBHelper) + ,OPropertyChangeListener(m_aMutex) + ,m_aLoadListeners(m_aMutex) + ,m_aRowSetApproveListeners(m_aMutex) + ,m_aRowSetListeners(m_aMutex) + ,m_aSubmitListeners(m_aMutex) + ,m_aErrorListeners(m_aMutex) + ,m_aResetListeners( *this, m_aMutex ) + ,m_aPropertyBagHelper( *this ) + ,m_pAggregatePropertyMultiplexer(NULL) + ,m_pGroupManager( NULL ) + ,m_aParameterManager( m_aMutex, _rxFactory ) + ,m_aFilterManager( _rxFactory ) + ,m_pLoadTimer(NULL) + ,m_pThread(NULL) + ,m_nResetsPending(0) + ,m_nPrivileges(0) + ,m_bInsertOnly( sal_False ) + ,m_eSubmitMethod(FormSubmitMethod_GET) + ,m_eSubmitEncoding(FormSubmitEncoding_URL) + ,m_eNavigation(NavigationBarMode_CURRENT) + ,m_bAllowInsert(sal_True) + ,m_bAllowUpdate(sal_True) + ,m_bAllowDelete(sal_True) + ,m_bLoaded(sal_False) + ,m_bSubForm(sal_False) + ,m_bForwardingConnection(sal_False) + ,m_bSharingConnection( sal_False ) +{ + DBG_CTOR( ODatabaseForm, NULL ); + impl_construct(); +} + +//------------------------------------------------------------------ +ODatabaseForm::ODatabaseForm( const ODatabaseForm& _cloneSource ) + :OFormComponents( _cloneSource ) + ,OPropertySetAggregationHelper( OComponentHelper::rBHelper ) + ,OPropertyChangeListener( m_aMutex ) + ,ODatabaseForm_BASE1() + ,ODatabaseForm_BASE2() + ,ODatabaseForm_BASE3() + ,IPropertyBagHelperContext() + ,m_aLoadListeners( m_aMutex ) + ,m_aRowSetApproveListeners( m_aMutex ) + ,m_aRowSetListeners( m_aMutex ) + ,m_aSubmitListeners( m_aMutex ) + ,m_aErrorListeners( m_aMutex ) + ,m_aResetListeners( *this, m_aMutex ) + ,m_aPropertyBagHelper( *this ) + ,m_pAggregatePropertyMultiplexer( NULL ) + ,m_pGroupManager( NULL ) + ,m_aParameterManager( m_aMutex, _cloneSource.m_xServiceFactory ) + ,m_aFilterManager( _cloneSource.m_xServiceFactory ) + ,m_pLoadTimer( NULL ) + ,m_pThread( NULL ) + ,m_nResetsPending( 0 ) + ,m_nPrivileges( 0 ) + ,m_bInsertOnly( _cloneSource.m_bInsertOnly ) + ,m_aControlBorderColorFocus( _cloneSource.m_aControlBorderColorFocus ) + ,m_aControlBorderColorMouse( _cloneSource.m_aControlBorderColorMouse ) + ,m_aControlBorderColorInvalid( _cloneSource.m_aControlBorderColorInvalid ) + ,m_aDynamicControlBorder( _cloneSource.m_aDynamicControlBorder ) + ,m_sName( _cloneSource.m_sName ) + ,m_aTargetURL( _cloneSource.m_aTargetURL ) + ,m_aTargetFrame( _cloneSource.m_aTargetFrame ) + ,m_eSubmitMethod( _cloneSource.m_eSubmitMethod ) + ,m_eSubmitEncoding( _cloneSource.m_eSubmitEncoding ) + ,m_eNavigation( _cloneSource.m_eNavigation ) + ,m_bAllowInsert( _cloneSource.m_bAllowInsert ) + ,m_bAllowUpdate( _cloneSource.m_bAllowUpdate ) + ,m_bAllowDelete( _cloneSource.m_bAllowDelete ) + ,m_bLoaded( sal_False ) + ,m_bSubForm( sal_False ) + ,m_bForwardingConnection( sal_False ) + ,m_bSharingConnection( sal_False ) +{ + DBG_CTOR( ODatabaseForm, NULL ); + + impl_construct(); + + osl_incrementInterlockedCount( &m_refCount ); + { + // our aggregated rowset itself is not cloneable, so simply copy the properties + ::comphelper::copyProperties( _cloneSource.m_xAggregateSet, m_xAggregateSet ); + + // also care for the dynamic properties: If the clone source has properties which we do not have, + // then add them + try + { + Reference< XPropertySet > xSourceProps( const_cast< ODatabaseForm& >( _cloneSource ).queryAggregation( + XPropertySet::static_type() ), UNO_QUERY_THROW ); + Reference< XPropertySetInfo > xSourcePSI( xSourceProps->getPropertySetInfo(), UNO_SET_THROW ); + Reference< XPropertyState > xSourcePropState( xSourceProps, UNO_QUERY ); + + Reference< XPropertySetInfo > xDestPSI( getPropertySetInfo(), UNO_QUERY_THROW ); + + Sequence< Property > aSourceProperties( xSourcePSI->getProperties() ); + for ( const Property* pSourceProperty = aSourceProperties.getConstArray(); + pSourceProperty != aSourceProperties.getConstArray() + aSourceProperties.getLength(); + ++pSourceProperty + ) + { + if ( xDestPSI->hasPropertyByName( pSourceProperty->Name ) ) + continue; + + // the initial value passed to XPropertyContainer is also used as default, usually. So, try + // to retrieve the default of the source property + Any aInitialValue; + if ( xSourcePropState.is() ) + { + aInitialValue = xSourcePropState->getPropertyDefault( pSourceProperty->Name ); + } + else + { + aInitialValue = xSourceProps->getPropertyValue( pSourceProperty->Name ); + } + addProperty( pSourceProperty->Name, pSourceProperty->Attributes, aInitialValue ); + setPropertyValue( pSourceProperty->Name, xSourceProps->getPropertyValue( pSourceProperty->Name ) ); + } + } + catch( const Exception& ) + { + throw WrappedTargetException( + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Could not clone the given database form." ) ), + *const_cast< ODatabaseForm* >( &_cloneSource ), + ::cppu::getCaughtException() + ); + } + } + osl_decrementInterlockedCount( &m_refCount ); +} + +//------------------------------------------------------------------ +void ODatabaseForm::impl_construct() +{ + // aggregate a row set + increment(m_refCount); + { + m_xAggregate = Reference< XAggregation >( m_xServiceFactory->createInstance( SRV_SDB_ROWSET ), UNO_QUERY_THROW ); + m_xAggregateAsRowSet.set( m_xAggregate, UNO_QUERY_THROW ); + setAggregation( m_xAggregate ); + } + + // listen for the properties, important for Parameters + if ( m_xAggregateSet.is() ) + { + m_pAggregatePropertyMultiplexer = new OPropertyChangeMultiplexer(this, m_xAggregateSet, sal_False); + m_pAggregatePropertyMultiplexer->acquire(); + m_pAggregatePropertyMultiplexer->addProperty(PROPERTY_COMMAND); + m_pAggregatePropertyMultiplexer->addProperty(PROPERTY_ACTIVE_CONNECTION); + } + + { + Reference< XWarningsSupplier > xRowSetWarnings( m_xAggregate, UNO_QUERY ); + m_aWarnings.setExternalWarnings( xRowSetWarnings ); + } + + if ( m_xAggregate.is() ) + { + m_xAggregate->setDelegator( static_cast< XWeak* >( this ) ); + } + + { + m_aFilterManager.initialize( m_xAggregateSet ); + m_aParameterManager.initialize( this, m_xAggregate ); + + declareForwardedProperty( PROPERTY_ID_ACTIVE_CONNECTION ); + } + decrement( m_refCount ); + + m_pGroupManager = new OGroupManager( this ); + m_pGroupManager->acquire(); +} + +//------------------------------------------------------------------ +ODatabaseForm::~ODatabaseForm() +{ + DBG_DTOR(ODatabaseForm,NULL); + + m_pGroupManager->release(); + m_pGroupManager = NULL; + + if (m_xAggregate.is()) + m_xAggregate->setDelegator( NULL ); + + m_aWarnings.setExternalWarnings( NULL ); + + if (m_pAggregatePropertyMultiplexer) + { + m_pAggregatePropertyMultiplexer->dispose(); + m_pAggregatePropertyMultiplexer->release(); + m_pAggregatePropertyMultiplexer = NULL; + } +} + +//============================================================================== +// html tools +//------------------------------------------------------------------------ +::rtl::OUString ODatabaseForm::GetDataURLEncoded(const Reference<XControl>& SubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt) +{ + return GetDataEncoded(true,SubmitButton,MouseEvt); +} +// ----------------------------------------------------------------------------- +::rtl::OUString ODatabaseForm::GetDataEncoded(bool _bURLEncoded,const Reference<XControl>& SubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt) +{ + // Liste von successful Controls fuellen + HtmlSuccessfulObjList aSuccObjList; + FillSuccessfulList( aSuccObjList, SubmitButton, MouseEvt ); + + + // Liste zu ::rtl::OUString zusammensetzen + ::rtl::OUStringBuffer aResult; + ::rtl::OUString aName; + ::rtl::OUString aValue; + + for ( HtmlSuccessfulObjListIterator pSuccObj = aSuccObjList.begin(); + pSuccObj < aSuccObjList.end(); + ++pSuccObj + ) + { + aName = pSuccObj->aName; + aValue = pSuccObj->aValue; + if( pSuccObj->nRepresentation == SUCCESSFUL_REPRESENT_FILE && aValue.getLength() ) + { + // Bei File-URLs wird der Dateiname und keine URL uebertragen, + // weil Netscape dies so macht. + INetURLObject aURL; + aURL.SetSmartProtocol(INET_PROT_FILE); + aURL.SetSmartURL(aValue); + if( INET_PROT_FILE == aURL.GetProtocol() ) + aValue = INetURLObject::decode(aURL.PathToFileName(), '%', INetURLObject::DECODE_UNAMBIGUOUS); + } + Encode( aName ); + Encode( aValue ); + + aResult.append(aName); + aResult.append(sal_Unicode('=')); + aResult.append(aValue); + + if (pSuccObj < aSuccObjList.end() - 1) + { + if ( _bURLEncoded ) + aResult.append(sal_Unicode('&')); + else + aResult.appendAscii("\r\n"); + } + } + + + aSuccObjList.clear(); + + return aResult.makeStringAndClear(); +} + +//============================================================================== +// html tools +//------------------------------------------------------------------------ +::rtl::OUString ODatabaseForm::GetDataTextEncoded(const Reference<XControl>& SubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt) +{ + return GetDataEncoded(false,SubmitButton,MouseEvt); +} + +//------------------------------------------------------------------------ +Sequence<sal_Int8> ODatabaseForm::GetDataMultiPartEncoded(const Reference<XControl>& SubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt, ::rtl::OUString& rContentType) +{ + + // Parent erzeugen + INetMIMEMessage aParent; + aParent.EnableAttachChild( INETMSG_MULTIPART_FORM_DATA ); + + + // Liste von successful Controls fuellen + HtmlSuccessfulObjList aSuccObjList; + FillSuccessfulList( aSuccObjList, SubmitButton, MouseEvt ); + + + // Liste zu ::rtl::OUString zusammensetzen + ::rtl::OUString aResult; + for ( HtmlSuccessfulObjListIterator pSuccObj = aSuccObjList.begin(); + pSuccObj < aSuccObjList.end(); + ++pSuccObj + ) + { + if( pSuccObj->nRepresentation == SUCCESSFUL_REPRESENT_TEXT ) + InsertTextPart( aParent, pSuccObj->aName, pSuccObj->aValue ); + else if( pSuccObj->nRepresentation == SUCCESSFUL_REPRESENT_FILE ) + InsertFilePart( aParent, pSuccObj->aName, pSuccObj->aValue ); + } + + + // Liste loeschen + aSuccObjList.clear(); + + // Fuer Parent MessageStream erzeugen + INetMIMEMessageStream aMessStream; + aMessStream.SetSourceMessage( &aParent ); + aMessStream.GenerateHeader( sal_False ); + + // MessageStream in SvStream kopieren + SvMemoryStream aMemStream; + char* pBuf = new char[1025]; + int nRead; + while( (nRead = aMessStream.Read(pBuf, 1024)) > 0 ) + aMemStream.Write( pBuf, nRead ); + delete[] pBuf; + + aMemStream.Flush(); + aMemStream.Seek( 0 ); + void* pData = (void*)aMemStream.GetData(); + sal_Int32 nLen = aMemStream.Seek(STREAM_SEEK_TO_END); + + rContentType = UniString(aParent.GetContentType()); + return Sequence<sal_Int8>((sal_Int8*)pData, nLen); +} + +//------------------------------------------------------------------------ +namespace +{ + static void appendDigits( sal_Int32 _nNumber, sal_Int8 nDigits, ::rtl::OUStringBuffer& _rOut ) + { + sal_Int32 nCurLen = _rOut.getLength(); + _rOut.append( _nNumber ); + while ( _rOut.getLength() - nCurLen < nDigits ) + _rOut.insert( nCurLen, (sal_Unicode)'0' ); + } +} + +//------------------------------------------------------------------------ +void ODatabaseForm::AppendComponent(HtmlSuccessfulObjList& rList, const Reference<XPropertySet>& xComponentSet, const ::rtl::OUString& rNamePrefix, + const Reference<XControl>& rxSubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt) +{ + if (!xComponentSet.is()) + return; + + // MIB 25.6.98: Geschachtelte Formulare abfangen ... oder muesste + // man sie submitten? + if (!hasProperty(PROPERTY_CLASSID, xComponentSet)) + return; + + // Namen ermitteln + if (!hasProperty(PROPERTY_NAME, xComponentSet)) + return; + + sal_Int16 nClassId = 0; + xComponentSet->getPropertyValue(PROPERTY_CLASSID) >>= nClassId; + ::rtl::OUString aName; + xComponentSet->getPropertyValue( PROPERTY_NAME ) >>= aName; + if( !aName.getLength() && nClassId != FormComponentType::IMAGEBUTTON) + return; + else // Name um den Prefix erweitern + aName = rNamePrefix + aName; + + switch( nClassId ) + { + // Buttons + case FormComponentType::COMMANDBUTTON: + { + // Es wird nur der gedrueckte Submit-Button ausgewertet + // MIB: Sofern ueberhaupt einer uebergeben wurde + if( rxSubmitButton.is() ) + { + Reference<XPropertySet> xSubmitButtonComponent(rxSubmitButton->getModel(), UNO_QUERY); + if (xSubmitButtonComponent == xComponentSet && hasProperty(PROPERTY_LABEL, xComponentSet)) + { + // <name>=<label> + ::rtl::OUString aLabel; + xComponentSet->getPropertyValue( PROPERTY_LABEL ) >>= aLabel; + rList.push_back( HtmlSuccessfulObj(aName, aLabel) ); + } + } + } break; + + // ImageButtons + case FormComponentType::IMAGEBUTTON: + { + // Es wird nur der gedrueckte Submit-Button ausgewertet + // MIB: Sofern ueberhaupt einer uebergeben wurde + if( rxSubmitButton.is() ) + { + Reference<XPropertySet> xSubmitButtonComponent(rxSubmitButton->getModel(), UNO_QUERY); + if (xSubmitButtonComponent == xComponentSet) + { + // <name>.x=<pos.X>&<name>.y=<pos.Y> + ::rtl::OUString aLhs = aName; + ::rtl::OUString aRhs = ::rtl::OUString::valueOf( MouseEvt.X ); + + // nur wenn ein Name vorhanden ist, kann ein name.x + aLhs += aName.getLength() ? UniString::CreateFromAscii(".x") : UniString::CreateFromAscii("x"); + rList.push_back( HtmlSuccessfulObj(aLhs, aRhs) ); + + aLhs = aName; + aRhs = ::rtl::OUString::valueOf( MouseEvt.Y ); + aLhs += aName.getLength() ? UniString::CreateFromAscii(".y") : UniString::CreateFromAscii("y"); + rList.push_back( HtmlSuccessfulObj(aLhs, aRhs) ); + + } + } + } break; + + // CheckBoxen / RadioButtons + case FormComponentType::CHECKBOX: + case FormComponentType::RADIOBUTTON: + { + // <name>=<refValue> + if( !hasProperty(PROPERTY_STATE, xComponentSet) ) + break; + sal_Int16 nChecked = 0; + xComponentSet->getPropertyValue( PROPERTY_STATE ) >>= nChecked; + if( nChecked != 1 ) + break; + + ::rtl::OUString aStrValue; + if( hasProperty(PROPERTY_REFVALUE, xComponentSet) ) + xComponentSet->getPropertyValue( PROPERTY_REFVALUE ) >>= aStrValue; + + rList.push_back( HtmlSuccessfulObj(aName, aStrValue) ); + } break; + + // Edit + case FormComponentType::TEXTFIELD: + { + // <name>=<text> + if( !hasProperty(PROPERTY_TEXT, xComponentSet) ) + break; + + // MIB: Spezial-Behandlung fuer Multiline-Edit nur dann, wenn + // es auch ein Control dazu gibt. + Any aTmp = xComponentSet->getPropertyValue( PROPERTY_MULTILINE ); + sal_Bool bMulti = rxSubmitButton.is() + && (aTmp.getValueType().getTypeClass() == TypeClass_BOOLEAN) + && getBOOL(aTmp); + ::rtl::OUString sText; + if ( bMulti ) // Bei MultiLineEdit Text am Control abholen + { + + Reference<XControlContainer> xControlContainer(rxSubmitButton->getContext(), UNO_QUERY); + if( !xControlContainer.is() ) break; + + Sequence<Reference<XControl> > aControlSeq = xControlContainer->getControls(); + Reference<XControl> xControl; + Reference<XFormComponent> xControlComponent; + + // Richtiges Control suchen + sal_Int32 i; + for( i=0; i<aControlSeq.getLength(); i++ ) + { + xControl = aControlSeq.getConstArray()[i]; + Reference<XPropertySet> xModel(xControl->getModel(), UNO_QUERY); + if (xModel == xComponentSet) + { + Reference<XTextComponent> xTextComponent(xControl, UNO_QUERY); + if( xTextComponent.is() ) + sText = xTextComponent->getText(); + break; + } + } + // Control nicht gefunden oder nicht existent, (Edit im Grid) + if (i == aControlSeq.getLength()) + xComponentSet->getPropertyValue( PROPERTY_TEXT ) >>= sText; + } + else + xComponentSet->getPropertyValue( PROPERTY_TEXT ) >>= sText; + + rList.push_back( HtmlSuccessfulObj(aName, sText) ); + } break; + + // ComboBox, Patternfield + case FormComponentType::COMBOBOX: + case FormComponentType::PATTERNFIELD: + { + // <name>=<text> + if( hasProperty(PROPERTY_TEXT, xComponentSet) ) + { + ::rtl::OUString aText; + xComponentSet->getPropertyValue( PROPERTY_TEXT ) >>= aText; + rList.push_back( HtmlSuccessfulObj(aName, aText) ); + } + } break; + case FormComponentType::CURRENCYFIELD: + case FormComponentType::NUMERICFIELD: + { + // <name>=<wert> // wert wird als double mit Punkt als Decimaltrenner + // kein Wert angegeben (NULL) -> wert leer + if( hasProperty(PROPERTY_VALUE, xComponentSet) ) + { + ::rtl::OUString aText; + Any aVal = xComponentSet->getPropertyValue( PROPERTY_VALUE ); + + double aDoubleVal = 0; + if (aVal >>= aDoubleVal) + { + sal_Int16 nScale = 0; + xComponentSet->getPropertyValue( PROPERTY_DECIMAL_ACCURACY ) >>= nScale; + aText = ::rtl::math::doubleToUString(aDoubleVal, rtl_math_StringFormat_F, nScale, '.', sal_True); + } + rList.push_back( HtmlSuccessfulObj(aName, aText) ); + } + } break; + case FormComponentType::DATEFIELD: + { + // <name>=<wert> // Wert wird als Datum im Format (MM-DD-YYYY) + // kein Wert angegeben (NULL) -> wert leer + if( hasProperty(PROPERTY_DATE, xComponentSet) ) + { + ::rtl::OUString aText; + Any aVal = xComponentSet->getPropertyValue( PROPERTY_DATE ); + sal_Int32 nInt32Val = 0; + if (aVal >>= nInt32Val) + { + ::Date aDate( nInt32Val ); + ::rtl::OUStringBuffer aBuffer; + appendDigits( aDate.GetMonth(), 2, aBuffer ); + aBuffer.append( (sal_Unicode)'-' ); + appendDigits( aDate.GetDay(), 2, aBuffer ); + aBuffer.append( (sal_Unicode)'-' ); + appendDigits( aDate.GetYear(), 4, aBuffer ); + aText = aBuffer.makeStringAndClear(); + } + rList.push_back( HtmlSuccessfulObj(aName, aText) ); + } + } break; + case FormComponentType::TIMEFIELD: + { + // <name>=<wert> // Wert wird als Zeit im Format (HH:MM:SS) angegeben + // kein Wert angegeben (NULL) -> wert leer + if( hasProperty(PROPERTY_TIME, xComponentSet) ) + { + ::rtl::OUString aText; + Any aVal = xComponentSet->getPropertyValue( PROPERTY_TIME ); + sal_Int32 nInt32Val = 0; + if (aVal >>= nInt32Val) + { + ::Time aTime(nInt32Val); + ::rtl::OUStringBuffer aBuffer; + appendDigits( aTime.GetHour(), 2, aBuffer ); + aBuffer.append( (sal_Unicode)'-' ); + appendDigits( aTime.GetMin(), 2, aBuffer ); + aBuffer.append( (sal_Unicode)'-' ); + appendDigits( aTime.GetSec(), 2, aBuffer ); + aText = aBuffer.makeStringAndClear(); + } + rList.push_back( HtmlSuccessfulObj(aName, aText) ); + } + } break; + + // starform + case FormComponentType::HIDDENCONTROL: + { + + // <name>=<value> + if( hasProperty(PROPERTY_HIDDEN_VALUE, xComponentSet) ) + { + ::rtl::OUString aText; + xComponentSet->getPropertyValue( PROPERTY_HIDDEN_VALUE ) >>= aText; + rList.push_back( HtmlSuccessfulObj(aName, aText) ); + } + } break; + + // starform + case FormComponentType::FILECONTROL: + { + // <name>=<text> + if( hasProperty(PROPERTY_TEXT, xComponentSet) ) + { + + ::rtl::OUString aText; + xComponentSet->getPropertyValue( PROPERTY_TEXT ) >>= aText; + rList.push_back( HtmlSuccessfulObj(aName, aText, SUCCESSFUL_REPRESENT_FILE) ); + } + } break; + + // starform + case FormComponentType::LISTBOX: + { + + // <name>=<Token0>&<name>=<Token1>&...&<name>=<TokenN> (Mehrfachselektion) + if (!hasProperty(PROPERTY_SELECT_SEQ, xComponentSet) || + !hasProperty(PROPERTY_STRINGITEMLIST, xComponentSet)) + break; + + // angezeigte Werte + Sequence< ::rtl::OUString > aVisibleList; + xComponentSet->getPropertyValue( PROPERTY_STRINGITEMLIST ) >>= aVisibleList; + sal_Int32 nStringCnt = aVisibleList.getLength(); + const ::rtl::OUString* pStrings = aVisibleList.getConstArray(); + + // Werte-Liste + Sequence< ::rtl::OUString > aValueList; + xComponentSet->getPropertyValue( PROPERTY_VALUE_SEQ ) >>= aValueList; + sal_Int32 nValCnt = aValueList.getLength(); + const ::rtl::OUString* pVals = aValueList.getConstArray(); + + // Selektion + Sequence<sal_Int16> aSelectList; + xComponentSet->getPropertyValue( PROPERTY_SELECT_SEQ ) >>= aSelectList; + sal_Int32 nSelCount = aSelectList.getLength(); + const sal_Int16* pSels = aSelectList.getConstArray(); + + // Einfach- oder Mehrfach-Selektion + // Bei Einfach-Selektionen beruecksichtigt MT nur den ersten Eintrag + // in der Liste. + if (nSelCount > 1 && !getBOOL(xComponentSet->getPropertyValue(PROPERTY_MULTISELECTION))) + nSelCount = 1; + + // Die Indizes in der Selektions-Liste koennen auch ungueltig sein, + // also muss man die gueltigen erstmal raussuchen um die Laenge + // der neuen Liste zu bestimmen. + sal_Int32 nCurCnt = 0; + sal_Int32 i; + for( i=0; i<nSelCount; ++i ) + { + if( pSels[i] < nStringCnt ) + ++nCurCnt; + } + + ::rtl::OUString aSubValue; + for(i=0; i<nCurCnt; ++i ) + { + sal_Int16 nSelPos = pSels[i]; + if (nSelPos < nValCnt && pVals[nSelPos].getLength()) + { + aSubValue = pVals[nSelPos]; + } + else + { + aSubValue = pStrings[nSelPos]; + } + rList.push_back( HtmlSuccessfulObj(aName, aSubValue) ); + } + } break; + case FormComponentType::GRIDCONTROL: + { + // Die einzelnen Spaltenwerte werden verschickt, + // der Name wird mit dem Prefix des Names des Grids erweitert + Reference<XIndexAccess> xContainer(xComponentSet, UNO_QUERY); + if (!xContainer.is()) + break; + + aName += UniString('.'); + + Reference<XPropertySet> xSet; + sal_Int32 nCount = xContainer->getCount(); + // we know already how many objects should be appended, + // so why not allocate the space for them + rList.reserve( nCount + rList.capacity() ); // not size() + for (sal_Int32 i = 0; i < nCount; ++i) + { + xContainer->getByIndex(i) >>= xSet; + if (xSet.is()) + AppendComponent(rList, xSet, aName, rxSubmitButton, MouseEvt); + } + } + } +} + +//------------------------------------------------------------------------ +void ODatabaseForm::FillSuccessfulList( HtmlSuccessfulObjList& rList, + const Reference<XControl>& rxSubmitButton, const ::com::sun::star::awt::MouseEvent& MouseEvt ) +{ + // Liste loeschen + rList.clear(); + // Ueber Components iterieren + Reference<XPropertySet> xComponentSet; + ::rtl::OUString aPrefix; + + // we know already how many objects should be appended, + // so why not allocate the space for them + rList.reserve( getCount() ); + for( sal_Int32 nIndex=0; nIndex < getCount(); nIndex++ ) + { + getByIndex( nIndex ) >>= xComponentSet; + AppendComponent(rList, xComponentSet, aPrefix, rxSubmitButton, MouseEvt); + } +} + +//------------------------------------------------------------------------ +void ODatabaseForm::Encode( ::rtl::OUString& rString ) const +{ + ::rtl::OUString aResult; + + // Immer ANSI #58641 +// rString.Convert(CHARSET_SYSTEM, CHARSET_ANSI); + + + // Zeilenendezeichen werden als CR dargestellt + UniString sConverter = rString; + sConverter.ConvertLineEnd( LINEEND_CR ); + rString = sConverter; + + + // Jeden einzelnen Character ueberpruefen + sal_Int32 nStrLen = rString.getLength(); + sal_Unicode nCharCode; + for( sal_Int32 nCurPos=0; nCurPos < nStrLen; ++nCurPos ) + { + nCharCode = rString[nCurPos]; + + // Behandlung fuer chars, die kein alphanumerisches Zeichen sind + // und CharacterCodes > 127 + if( (!isalnum(nCharCode) && nCharCode != (sal_Unicode)' ') || nCharCode > 127 ) + { + switch( nCharCode ) + { + case 13: // CR + aResult += ::rtl::OUString::createFromAscii("%0D%0A"); // Hex-Darstellung CR LF + break; + + + // Netscape Sonderbehandlung + case 42: // '*' + case 45: // '-' + case 46: // '.' + case 64: // '@' + case 95: // '_' + aResult += UniString(nCharCode); + break; + + default: + { + // In Hex umrechnen + short nHi = ((sal_Int16)nCharCode) / 16; + short nLo = ((sal_Int16)nCharCode) - (nHi*16); + if( nHi > 9 ) nHi += (int)'A'-10; else nHi += (int)'0'; + if( nLo > 9 ) nLo += (int)'A'-10; else nLo += (int)'0'; + aResult += UniString('%'); + aResult += UniString((sal_Unicode)nHi); + aResult += UniString((sal_Unicode)nLo); + } + } + } + else + aResult += UniString(nCharCode); + } + + + // Spaces durch '+' ersetzen + aResult = aResult.replace(' ', '+'); + + rString = aResult; +} + +//------------------------------------------------------------------------ +void ODatabaseForm::InsertTextPart( INetMIMEMessage& rParent, const ::rtl::OUString& rName, + const ::rtl::OUString& rData ) +{ + + // Part als Message-Child erzeugen + INetMIMEMessage* pChild = new INetMIMEMessage(); + + + // Header + ::rtl::OUString aContentDisp = ::rtl::OUString::createFromAscii("form-data; name=\""); + aContentDisp += rName; + aContentDisp += UniString('\"'); + pChild->SetContentDisposition( aContentDisp ); + pChild->SetContentType( UniString::CreateFromAscii("text/plain") ); + + rtl_TextEncoding eSystemEncoding = gsl_getSystemTextEncoding(); + const sal_Char* pBestMatchingEncoding = rtl_getBestMimeCharsetFromTextEncoding( eSystemEncoding ); + UniString aBestMatchingEncoding = UniString::CreateFromAscii( pBestMatchingEncoding ); + pChild->SetContentTransferEncoding(aBestMatchingEncoding); + + // Body + SvMemoryStream* pStream = new SvMemoryStream; + pStream->WriteLine( ByteString( UniString(rData), rtl_getTextEncodingFromMimeCharset(pBestMatchingEncoding) ) ); + pStream->Flush(); + pStream->Seek( 0 ); + pChild->SetDocumentLB( new SvLockBytes(pStream, sal_True) ); + rParent.AttachChild( *pChild ); +} + +//------------------------------------------------------------------------ +sal_Bool ODatabaseForm::InsertFilePart( INetMIMEMessage& rParent, const ::rtl::OUString& rName, + const ::rtl::OUString& rFileName ) +{ + UniString aFileName( rFileName ); + UniString aContentType(UniString::CreateFromAscii(CONTENT_TYPE_STR_TEXT_PLAIN)); + SvStream *pStream = 0; + + if( aFileName.Len() ) + { + // Bisher koennen wir nur File-URLs verarbeiten + INetURLObject aURL; + aURL.SetSmartProtocol(INET_PROT_FILE); + aURL.SetSmartURL(rFileName); + if( INET_PROT_FILE == aURL.GetProtocol() ) + { + aFileName = INetURLObject::decode(aURL.PathToFileName(), '%', INetURLObject::DECODE_UNAMBIGUOUS); + DirEntry aDirEntry( aFileName ); + if( aDirEntry.Exists() ) + { + pStream = ::utl::UcbStreamHelper::CreateStream(aFileName, STREAM_READ); + if (!pStream || (pStream->GetError() != ERRCODE_NONE)) + { + delete pStream; + pStream = 0; + } + } + INetContentType eContentType = INetContentTypes::GetContentType4Extension( + aDirEntry.GetExtension() ); + if (eContentType != CONTENT_TYPE_UNKNOWN) + aContentType = INetContentTypes::GetContentType(eContentType); + } + } + + // Wenn irgendetwas nicht geklappt hat, legen wir einen leeren + // MemoryStream an + if( !pStream ) + pStream = new SvMemoryStream; + + + // Part als Message-Child erzeugen + INetMIMEMessage* pChild = new INetMIMEMessage; + + + // Header + ::rtl::OUString aContentDisp = ::rtl::OUString::createFromAscii( "form-data; name=\"" ); + aContentDisp += rName; + aContentDisp += UniString('\"'); + aContentDisp += ::rtl::OUString::createFromAscii("; filename=\""); + aContentDisp += aFileName; + aContentDisp += UniString('\"'); + pChild->SetContentDisposition( aContentDisp ); + pChild->SetContentType( aContentType ); + pChild->SetContentTransferEncoding( UniString(::rtl::OUString::createFromAscii("8bit")) ); + + + // Body + pChild->SetDocumentLB( new SvLockBytes(pStream, sal_True) ); + rParent.AttachChild( *pChild ); + + return sal_True; +} + +//============================================================================== +// internals +//------------------------------------------------------------------------------ +void ODatabaseForm::onError( const SQLErrorEvent& _rEvent ) +{ + m_aErrorListeners.notifyEach( &XSQLErrorListener::errorOccured, _rEvent ); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::onError( const SQLException& _rException, const ::rtl::OUString& _rContextDescription ) +{ + if ( !m_aErrorListeners.getLength() ) + return; + + SQLErrorEvent aEvent( *this, makeAny( prependErrorInfo( _rException, *this, _rContextDescription ) ) ); + onError( aEvent ); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::updateParameterInfo() +{ + m_aParameterManager.updateParameterInfo( m_aFilterManager ); +} + +//------------------------------------------------------------------------------ +bool ODatabaseForm::hasValidParent() const +{ + // do we have to fill the parameters again? + if (m_bSubForm) + { + Reference<XResultSet> xResultSet(m_xParent, UNO_QUERY); + if (!xResultSet.is()) + { + DBG_ERROR("ODatabaseForm::hasValidParent() : no parent resultset !"); + return false; + } + try + { + Reference< XPropertySet > xSet( m_xParent, UNO_QUERY ); + Reference< XLoadable > xLoad( m_xParent, UNO_QUERY ); + if ( xLoad->isLoaded() + && ( xResultSet->isBeforeFirst() + || xResultSet->isAfterLast() + || getBOOL( xSet->getPropertyValue( PROPERTY_ISNEW ) ) + ) + ) + // the parent form is loaded and on a "virtual" row -> not valid + return false; + } + catch(Exception&) + { + // parent could be forwardonly? + return false; + } + } + return true; +} + +//------------------------------------------------------------------------------ +bool ODatabaseForm::fillParameters( ::osl::ResettableMutexGuard& _rClearForNotifies, const Reference< XInteractionHandler >& _rxCompletionHandler ) +{ + // do we have to fill the parameters again? + if ( !m_aParameterManager.isUpToDate() ) + updateParameterInfo(); + + // is there a valid parent? + if ( m_bSubForm && !hasValidParent() ) + return true; + + // ensure we're connected + if ( !implEnsureConnection() ) + return false; + + if ( m_aParameterManager.isUpToDate() ) + return m_aParameterManager.fillParameterValues( _rxCompletionHandler, _rClearForNotifies ); + + return true; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::saveInsertOnlyState( ) +{ + OSL_ENSURE( !m_aIgnoreResult.hasValue(), "ODatabaseForm::saveInsertOnlyState: overriding old value!" ); + m_aIgnoreResult = m_xAggregateSet->getPropertyValue( PROPERTY_INSERTONLY ); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::restoreInsertOnlyState( ) +{ + if ( m_aIgnoreResult.hasValue() ) + { + m_xAggregateSet->setPropertyValue( PROPERTY_INSERTONLY, m_aIgnoreResult ); + m_aIgnoreResult = Any(); + } +} + +//------------------------------------------------------------------------------ +sal_Bool ODatabaseForm::executeRowSet(::osl::ResettableMutexGuard& _rClearForNotifies, sal_Bool bMoveToFirst, const Reference< XInteractionHandler >& _rxCompletionHandler) +{ + if (!m_xAggregateAsRowSet.is()) + return sal_False; + + if (!fillParameters(_rClearForNotifies, _rxCompletionHandler)) + return sal_False; + + restoreInsertOnlyState( ); + + // ensure the aggregated row set has the correct properties + sal_Int32 nConcurrency = ResultSetConcurrency::READ_ONLY; + + // if we have a parent, who is not positioned on a valid row + // we can't be updatable! + if (m_bSubForm && !hasValidParent()) + { + nConcurrency = ResultSetConcurrency::READ_ONLY; + + // don't use any parameters if we don't have a valid parent + m_aParameterManager.setAllParametersNull(); + + // switch to "insert only" mode + saveInsertOnlyState( ); + m_xAggregateSet->setPropertyValue( PROPERTY_INSERTONLY, makeAny( sal_True ) ); + } + else if (m_bAllowInsert || m_bAllowUpdate || m_bAllowDelete) + nConcurrency = ResultSetConcurrency::UPDATABLE; + else + nConcurrency = ResultSetConcurrency::READ_ONLY; + + m_xAggregateSet->setPropertyValue( PROPERTY_RESULTSET_CONCURRENCY, makeAny( (sal_Int32)nConcurrency ) ); + m_xAggregateSet->setPropertyValue( PROPERTY_RESULTSET_TYPE, makeAny( (sal_Int32)ResultSetType::SCROLL_SENSITIVE ) ); + + sal_Bool bSuccess = sal_False; + try + { + m_xAggregateAsRowSet->execute(); + bSuccess = sal_True; + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; + } + catch(SQLException& eDb) + { + _rClearForNotifies.clear(); + if (m_sCurrentErrorContext.getLength()) + onError(eDb, m_sCurrentErrorContext); + else + onError(eDb, FRM_RES_STRING(RID_STR_READERROR)); + _rClearForNotifies.reset(); + + restoreInsertOnlyState( ); + } + + if (bSuccess) + { + // adjust the privilege property + // m_nPrivileges; + m_xAggregateSet->getPropertyValue(PROPERTY_PRIVILEGES) >>= m_nPrivileges; + if (!m_bAllowInsert) + m_nPrivileges &= ~Privilege::INSERT; + if (!m_bAllowUpdate) + m_nPrivileges &= ~Privilege::UPDATE; + if (!m_bAllowDelete) + m_nPrivileges &= ~Privilege::DELETE; + + if (bMoveToFirst) + { + // the row set is positioned _before_ the first row (per definitionem), so move the set ... + try + { + // if we have an insert only rowset we move to the insert row + next(); + if (((m_nPrivileges & Privilege::INSERT) == Privilege::INSERT) + && isAfterLast()) + { + // move on the insert row of set + // resetting must be done later, after the load events have been posted + // see :moveToInsertRow and load , reload + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->moveToInsertRow(); + } + } + catch(SQLException& eDB) + { + _rClearForNotifies.clear(); + if (m_sCurrentErrorContext.getLength()) + onError(eDB, m_sCurrentErrorContext); + else + onError(eDB, FRM_RES_STRING(RID_STR_READERROR)); + _rClearForNotifies.reset(); + bSuccess = sal_False; + } + } + } + return bSuccess; +} + +//------------------------------------------------------------------ +void ODatabaseForm::disposing() +{ + if (m_pAggregatePropertyMultiplexer) + m_pAggregatePropertyMultiplexer->dispose(); + + if (m_bLoaded) + unload(); + + // cancel the submit/reset-thread + { + ::osl::MutexGuard aGuard( m_aMutex ); + if (m_pThread) + { + m_pThread->release(); + m_pThread = NULL; + } + } + + EventObject aEvt(static_cast<XWeak*>(this)); + m_aLoadListeners.disposeAndClear(aEvt); + m_aRowSetApproveListeners.disposeAndClear(aEvt); + m_aParameterManager.disposing( aEvt ); + m_aResetListeners.disposing(); + m_aSubmitListeners.disposeAndClear(aEvt); + m_aErrorListeners.disposeAndClear(aEvt); + + m_aParameterManager.dispose(); // (to free any references it may have to me) + m_aFilterManager.dispose(); // (dito) + + OFormComponents::disposing(); + OPropertySetAggregationHelper::disposing(); + + // stop listening on the aggregate + if (m_xAggregateAsRowSet.is()) + m_xAggregateAsRowSet->removeRowSetListener(this); + + // dispose the active connection + Reference<XComponent> xAggregationComponent; + if (query_aggregation(m_xAggregate, xAggregationComponent)) + xAggregationComponent->dispose(); + + m_aPropertyBagHelper.dispose(); +} + +//------------------------------------------------------------------------------ +Reference< XConnection > ODatabaseForm::getConnection() +{ + Reference< XConnection > xConn; + m_xAggregateSet->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ) >>= xConn; + return xConn; +} + +//------------------------------------------------------------------------------ +::osl::Mutex& ODatabaseForm::getMutex() +{ + return m_aMutex; +} + +//============================================================================== +// property handling +//------------------------------------------------------------------------------ +void ODatabaseForm::describeFixedAndAggregateProperties( + Sequence< Property >& _rProps, + Sequence< Property >& _rAggregateProps ) const +{ + BEGIN_DESCRIBE_AGGREGATION_PROPERTIES(22, m_xAggregateSet) + // we want to "override" the privileges, since we have additional "AllowInsert" etc. properties + RemoveProperty( _rAggregateProps, PROPERTY_PRIVILEGES ); + + // InsertOnly is also to be overridden, since we sometimes change it ourself + RemoveProperty( _rAggregateProps, PROPERTY_INSERTONLY ); + + // we remove and re-declare the DataSourceName property, 'cause we want it to be constrained, and the + // original property of our aggregate isn't + RemoveProperty( _rAggregateProps, PROPERTY_DATASOURCE ); + + // for connection sharing, we need to override the ActiveConnection property, too + RemoveProperty( _rAggregateProps, PROPERTY_ACTIVE_CONNECTION ); + + // the Filter property is also overwritten, since we have some implicit filters + // (e.g. the ones which result from linking master fields to detail fields + // via column names instead of parameters) + RemoveProperty( _rAggregateProps, PROPERTY_FILTER ); + RemoveProperty( _rAggregateProps, PROPERTY_APPLYFILTER ); + + DECL_IFACE_PROP4(ACTIVE_CONNECTION, XConnection, BOUND, TRANSIENT, MAYBEVOID, CONSTRAINED); + DECL_BOOL_PROP2 ( APPLYFILTER, BOUND, MAYBEDEFAULT ); + DECL_PROP1 ( NAME, ::rtl::OUString, BOUND ); + DECL_PROP1 ( MASTERFIELDS, Sequence< ::rtl::OUString >, BOUND ); + DECL_PROP1 ( DETAILFIELDS, Sequence< ::rtl::OUString >, BOUND ); + DECL_PROP2 ( DATASOURCE, ::rtl::OUString, BOUND, CONSTRAINED ); + DECL_PROP3 ( CYCLE, TabulatorCycle, BOUND, MAYBEVOID, MAYBEDEFAULT ); + DECL_PROP2 ( FILTER, ::rtl::OUString, BOUND, MAYBEDEFAULT ); + DECL_BOOL_PROP2 ( INSERTONLY, BOUND, MAYBEDEFAULT ); + DECL_PROP1 ( NAVIGATION, NavigationBarMode, BOUND ); + DECL_BOOL_PROP1 ( ALLOWADDITIONS, BOUND ); + DECL_BOOL_PROP1 ( ALLOWEDITS, BOUND ); + DECL_BOOL_PROP1 ( ALLOWDELETIONS, BOUND ); + DECL_PROP2 ( PRIVILEGES, sal_Int32, TRANSIENT, READONLY ); + DECL_PROP1 ( TARGET_URL, ::rtl::OUString, BOUND ); + DECL_PROP1 ( TARGET_FRAME, ::rtl::OUString, BOUND ); + DECL_PROP1 ( SUBMIT_METHOD, FormSubmitMethod, BOUND ); + DECL_PROP1 ( SUBMIT_ENCODING, FormSubmitEncoding, BOUND ); + DECL_BOOL_PROP3 ( DYNAMIC_CONTROL_BORDER, BOUND, MAYBEVOID, MAYBEDEFAULT ); + DECL_PROP3 ( CONTROL_BORDER_COLOR_FOCUS, sal_Int32, BOUND, MAYBEVOID, MAYBEDEFAULT ); + DECL_PROP3 ( CONTROL_BORDER_COLOR_MOUSE, sal_Int32, BOUND, MAYBEVOID, MAYBEDEFAULT ); + DECL_PROP3 ( CONTROL_BORDER_COLOR_INVALID, sal_Int32, BOUND, MAYBEVOID, MAYBEDEFAULT ); + END_DESCRIBE_PROPERTIES(); +} + +//------------------------------------------------------------------------------ +Reference< XMultiPropertySet > ODatabaseForm::getPropertiesInterface() +{ + return Reference< XMultiPropertySet >( *this, UNO_QUERY ); +} + +//------------------------------------------------------------------------------ +::cppu::IPropertyArrayHelper& ODatabaseForm::getInfoHelper() +{ + return m_aPropertyBagHelper.getInfoHelper(); +} + +//------------------------------------------------------------------------------ +Reference< XPropertySetInfo > ODatabaseForm::getPropertySetInfo() throw( RuntimeException ) +{ + return createPropertySetInfo( getInfoHelper() ); +} + +//-------------------------------------------------------------------- +void SAL_CALL ODatabaseForm::addProperty( const ::rtl::OUString& _rName, ::sal_Int16 _nAttributes, const Any& _rInitialValue ) throw (PropertyExistException, IllegalTypeException, IllegalArgumentException, RuntimeException) +{ + m_aPropertyBagHelper.addProperty( _rName, _nAttributes, _rInitialValue ); +} + +//-------------------------------------------------------------------- +void SAL_CALL ODatabaseForm::removeProperty( const ::rtl::OUString& _rName ) throw (UnknownPropertyException, NotRemoveableException, RuntimeException) +{ + m_aPropertyBagHelper.removeProperty( _rName ); +} + +//-------------------------------------------------------------------- +Sequence< PropertyValue > SAL_CALL ODatabaseForm::getPropertyValues() throw (RuntimeException) +{ + return m_aPropertyBagHelper.getPropertyValues(); +} + +//-------------------------------------------------------------------- +void SAL_CALL ODatabaseForm::setPropertyValues( const Sequence< PropertyValue >& _rProps ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException) +{ + m_aPropertyBagHelper.setPropertyValues( _rProps ); +} + +//------------------------------------------------------------------------------ +Any SAL_CALL ODatabaseForm::getWarnings( ) throw (SQLException, RuntimeException) +{ + return m_aWarnings.getWarnings(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::clearWarnings( ) throw (SQLException, RuntimeException) +{ + m_aWarnings.clearWarnings(); +} + +//------------------------------------------------------------------------------ +Reference< XCloneable > SAL_CALL ODatabaseForm::createClone( ) throw (RuntimeException) +{ + ODatabaseForm* pClone = new ODatabaseForm( *this ); + osl_incrementInterlockedCount( &pClone->m_refCount ); + pClone->clonedFrom( *this ); + osl_decrementInterlockedCount( &pClone->m_refCount ); + return pClone; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::fire( sal_Int32* pnHandles, const Any* pNewValues, const Any* pOldValues, sal_Int32 nCount, sal_Bool bVetoable ) +{ + // same as in getFastPropertyValue(INT32) : if we're resetting currently don't fire any changes of the + // IsModified property from FALSE to TRUE, as this is only temporary 'til the reset is done + if (m_nResetsPending > 0) + { + // look for the PROPERTY_ID_ISMODIFIED + sal_Int32 nPos = 0; + for (nPos=0; nPos<nCount; ++nPos) + if (pnHandles[nPos] == PROPERTY_ID_ISMODIFIED) + break; + + if ((nPos < nCount) && (pNewValues[nPos].getValueType().getTypeClass() == TypeClass_BOOLEAN) && getBOOL(pNewValues[nPos])) + { // yeah, we found it, and it changed to TRUE + if (nPos == 0) + { // just cut the first element + ++pnHandles; + ++pNewValues; + ++pOldValues; + --nCount; + } + else if (nPos == nCount - 1) + // just cut the last element + --nCount; + else + { // split into two base class calls + OPropertySetAggregationHelper::fire(pnHandles, pNewValues, pOldValues, nPos, bVetoable); + ++nPos; + OPropertySetAggregationHelper::fire(pnHandles + nPos, pNewValues + nPos, pOldValues + nPos, nCount - nPos, bVetoable); + return; + } + } + } + + OPropertySetAggregationHelper::fire(pnHandles, pNewValues, pOldValues, nCount, bVetoable); +} + +//------------------------------------------------------------------------------ +Any SAL_CALL ODatabaseForm::getFastPropertyValue( sal_Int32 nHandle ) + throw(UnknownPropertyException, WrappedTargetException, RuntimeException) +{ + if ((nHandle == PROPERTY_ID_ISMODIFIED) && (m_nResetsPending > 0)) + return ::cppu::bool2any((sal_False)); + // don't allow the aggregate which is currently being reset to return a (temporary) "yes" + else + return OPropertySetAggregationHelper::getFastPropertyValue(nHandle); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const +{ + switch (nHandle) + { + case PROPERTY_ID_INSERTONLY: + rValue <<= m_bInsertOnly; + break; + + case PROPERTY_ID_FILTER: + rValue <<= m_aFilterManager.getFilterComponent( FilterManager::fcPublicFilter ); + break; + + case PROPERTY_ID_APPLYFILTER: + rValue <<= m_aFilterManager.isApplyPublicFilter(); + break; + + case PROPERTY_ID_DATASOURCE: + rValue = m_xAggregateSet->getPropertyValue( PROPERTY_DATASOURCE ); + break; + + case PROPERTY_ID_TARGET_URL: + rValue <<= m_aTargetURL; + break; + case PROPERTY_ID_TARGET_FRAME: + rValue <<= m_aTargetFrame; + break; + case PROPERTY_ID_SUBMIT_METHOD: + rValue <<= m_eSubmitMethod; + break; + case PROPERTY_ID_SUBMIT_ENCODING: + rValue <<= m_eSubmitEncoding; + break; + case PROPERTY_ID_NAME: + rValue <<= m_sName; + break; + case PROPERTY_ID_MASTERFIELDS: + rValue <<= m_aMasterFields; + break; + case PROPERTY_ID_DETAILFIELDS: + rValue <<= m_aDetailFields; + break; + case PROPERTY_ID_CYCLE: + rValue = m_aCycle; + break; + case PROPERTY_ID_NAVIGATION: + rValue <<= m_eNavigation; + break; + case PROPERTY_ID_ALLOWADDITIONS: + rValue <<= (sal_Bool)m_bAllowInsert; + break; + case PROPERTY_ID_ALLOWEDITS: + rValue <<= (sal_Bool)m_bAllowUpdate; + break; + case PROPERTY_ID_ALLOWDELETIONS: + rValue <<= (sal_Bool)m_bAllowDelete; + break; + case PROPERTY_ID_PRIVILEGES: + rValue <<= (sal_Int32)m_nPrivileges; + break; + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + rValue = m_aDynamicControlBorder; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + rValue = m_aControlBorderColorFocus; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + rValue = m_aControlBorderColorMouse; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + rValue = m_aControlBorderColorInvalid; + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( nHandle ) ) + m_aPropertyBagHelper.getDynamicFastPropertyValue( nHandle, rValue ); + else + OPropertySetAggregationHelper::getFastPropertyValue( rValue, nHandle ); + break; + } +} + +//------------------------------------------------------------------------------ +sal_Bool ODatabaseForm::convertFastPropertyValue( Any& rConvertedValue, Any& rOldValue, + sal_Int32 nHandle, const Any& rValue ) throw( IllegalArgumentException ) +{ + sal_Bool bModified(sal_False); + switch (nHandle) + { + case PROPERTY_ID_INSERTONLY: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_bInsertOnly ); + break; + + case PROPERTY_ID_FILTER: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aFilterManager.getFilterComponent( FilterManager::fcPublicFilter ) ); + break; + + case PROPERTY_ID_APPLYFILTER: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aFilterManager.isApplyPublicFilter() ); + break; + + case PROPERTY_ID_DATASOURCE: + { + Any aAggregateProperty; + getFastPropertyValue(aAggregateProperty, PROPERTY_ID_DATASOURCE); + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, aAggregateProperty, ::getCppuType(static_cast<const ::rtl::OUString*>(NULL))); + } + break; + case PROPERTY_ID_TARGET_URL: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aTargetURL); + break; + case PROPERTY_ID_TARGET_FRAME: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aTargetFrame); + break; + case PROPERTY_ID_SUBMIT_METHOD: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_eSubmitMethod); + break; + case PROPERTY_ID_SUBMIT_ENCODING: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_eSubmitEncoding); + break; + case PROPERTY_ID_NAME: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_sName); + break; + case PROPERTY_ID_MASTERFIELDS: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aMasterFields); + break; + case PROPERTY_ID_DETAILFIELDS: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aDetailFields); + break; + case PROPERTY_ID_CYCLE: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aCycle, ::getCppuType(static_cast<const TabulatorCycle*>(NULL))); + break; + case PROPERTY_ID_NAVIGATION: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_eNavigation); + break; + case PROPERTY_ID_ALLOWADDITIONS: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAllowInsert); + break; + case PROPERTY_ID_ALLOWEDITS: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAllowUpdate); + break; + case PROPERTY_ID_ALLOWDELETIONS: + bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAllowDelete); + break; + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aDynamicControlBorder, ::getBooleanCppuType() ); + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aControlBorderColorFocus, getCppuType( static_cast< sal_Int32* >( NULL ) ) ); + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aControlBorderColorMouse, getCppuType( static_cast< sal_Int32* >( NULL ) ) ); + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aControlBorderColorInvalid, getCppuType( static_cast< sal_Int32* >( NULL ) ) ); + break; + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle ( nHandle ) ) + bModified = m_aPropertyBagHelper.convertDynamicFastPropertyValue( nHandle, rValue, rConvertedValue, rOldValue ); + else + bModified = OPropertySetAggregationHelper::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue ); + break; + } + return bModified; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw( Exception ) +{ + switch (nHandle) + { + case PROPERTY_ID_INSERTONLY: + rValue >>= m_bInsertOnly; + if ( m_aIgnoreResult.hasValue() ) + m_aIgnoreResult <<= m_bInsertOnly; + else + m_xAggregateSet->setPropertyValue( PROPERTY_INSERTONLY, makeAny( m_bInsertOnly ) ); + break; + + case PROPERTY_ID_FILTER: + { + ::rtl::OUString sNewFilter; + rValue >>= sNewFilter; + m_aFilterManager.setFilterComponent( FilterManager::fcPublicFilter, sNewFilter ); + } + break; + + case PROPERTY_ID_APPLYFILTER: + { + sal_Bool bApply = sal_True; + rValue >>= bApply; + m_aFilterManager.setApplyPublicFilter( bApply ); + } + break; + + case PROPERTY_ID_DATASOURCE: + { + Reference< XConnection > xSomeConnection; + if ( ::dbtools::isEmbeddedInDatabase( getParent(), xSomeConnection ) ) + throw PropertyVetoException(); + + try + { + m_xAggregateSet->setPropertyValue(PROPERTY_DATASOURCE, rValue); + } + catch(Exception&) { } + } + break; + case PROPERTY_ID_TARGET_URL: + rValue >>= m_aTargetURL; + break; + case PROPERTY_ID_TARGET_FRAME: + rValue >>= m_aTargetFrame; + break; + case PROPERTY_ID_SUBMIT_METHOD: + rValue >>= m_eSubmitMethod; + break; + case PROPERTY_ID_SUBMIT_ENCODING: + rValue >>= m_eSubmitEncoding; + break; + case PROPERTY_ID_NAME: + rValue >>= m_sName; + break; + case PROPERTY_ID_MASTERFIELDS: + rValue >>= m_aMasterFields; + invlidateParameters(); + break; + case PROPERTY_ID_DETAILFIELDS: + rValue >>= m_aDetailFields; + invlidateParameters(); + break; + case PROPERTY_ID_CYCLE: + m_aCycle = rValue; + break; + case PROPERTY_ID_NAVIGATION: + rValue >>= m_eNavigation; + break; + case PROPERTY_ID_ALLOWADDITIONS: + m_bAllowInsert = getBOOL(rValue); + break; + case PROPERTY_ID_ALLOWEDITS: + m_bAllowUpdate = getBOOL(rValue); + break; + case PROPERTY_ID_ALLOWDELETIONS: + m_bAllowDelete = getBOOL(rValue); + break; + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + m_aDynamicControlBorder = rValue; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + m_aControlBorderColorFocus = rValue; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + m_aControlBorderColorMouse = rValue; + break; + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + m_aControlBorderColorInvalid = rValue; + break; + + case PROPERTY_ID_ACTIVE_CONNECTION: + { + Reference< XConnection > xOuterConnection; + if ( ::dbtools::isEmbeddedInDatabase( getParent(), xOuterConnection ) ) + { + if ( xOuterConnection != Reference< XConnection >( rValue, UNO_QUERY ) ) + // somebody's trying to set a connection which is not equal the connection + // implied by the database we're embedded in + throw PropertyVetoException(); + } + OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast( nHandle, rValue ); + break; + } + + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( nHandle ) ) + m_aPropertyBagHelper.setDynamicFastPropertyValue( nHandle, rValue ); + else + OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast( nHandle, rValue ); + break; + } +} + +//------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::forwardingPropertyValue( sal_Int32 _nHandle ) +{ + OSL_ENSURE( _nHandle == PROPERTY_ID_ACTIVE_CONNECTION, "ODatabaseForm::forwardingPropertyValue: unexpected property!" ); + if ( _nHandle == PROPERTY_ID_ACTIVE_CONNECTION ) + { + if ( m_bSharingConnection ) + stopSharingConnection( ); + m_bForwardingConnection = sal_True; + } +} + +//------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::forwardedPropertyValue( sal_Int32 _nHandle, bool /*_bSuccess*/ ) +{ + OSL_ENSURE( _nHandle == PROPERTY_ID_ACTIVE_CONNECTION, "ODatabaseForm::forwardedPropertyValue: unexpected property!" ); + if ( _nHandle == PROPERTY_ID_ACTIVE_CONNECTION ) + { + m_bForwardingConnection = sal_False; + } +} + +//============================================================================== +// com::sun::star::beans::XPropertyState +//------------------------------------------------------------------ +PropertyState ODatabaseForm::getPropertyStateByHandle(sal_Int32 nHandle) +{ + PropertyState eState; + switch (nHandle) + { + case PROPERTY_ID_NAVIGATION: + return (NavigationBarMode_CURRENT == m_eNavigation) ? PropertyState_DEFAULT_VALUE : PropertyState_DIRECT_VALUE; + + case PROPERTY_ID_CYCLE: + eState = m_aCycle.hasValue() ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + case PROPERTY_ID_INSERTONLY: + eState = m_bInsertOnly ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + case PROPERTY_ID_FILTER: + if ( !m_aFilterManager.getFilterComponent( FilterManager::fcPublicFilter ).getLength() ) + eState = PropertyState_DEFAULT_VALUE; + else + eState = PropertyState_DIRECT_VALUE; + break; + + case PROPERTY_ID_APPLYFILTER: + eState = m_aFilterManager.isApplyPublicFilter() ? PropertyState_DEFAULT_VALUE : PropertyState_DIRECT_VALUE; + break; + + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + eState = m_aDynamicControlBorder.hasValue() ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + eState = m_aControlBorderColorFocus.hasValue() ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + eState = m_aControlBorderColorMouse.hasValue() ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + eState = m_aControlBorderColorInvalid.hasValue() ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE; + break; + + default: + eState = OPropertySetAggregationHelper::getPropertyStateByHandle(nHandle); + } + return eState; +} + +//------------------------------------------------------------------ +void ODatabaseForm::setPropertyToDefaultByHandle(sal_Int32 nHandle) +{ + switch (nHandle) + { + case PROPERTY_ID_INSERTONLY: + case PROPERTY_ID_FILTER: + case PROPERTY_ID_APPLYFILTER: + case PROPERTY_ID_NAVIGATION: + case PROPERTY_ID_CYCLE: + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + setFastPropertyValue( nHandle, getPropertyDefaultByHandle( nHandle ) ); + break; + + default: + OPropertySetAggregationHelper::setPropertyToDefaultByHandle(nHandle); + } +} + +//------------------------------------------------------------------ +Any ODatabaseForm::getPropertyDefaultByHandle( sal_Int32 nHandle ) const +{ + Any aReturn; + switch (nHandle) + { + case PROPERTY_ID_INSERTONLY: + case PROPERTY_ID_DYNAMIC_CONTROL_BORDER: + aReturn <<= sal_False; + break; + + case PROPERTY_ID_FILTER: + aReturn <<= ::rtl::OUString(); + break; + + case PROPERTY_ID_APPLYFILTER: + aReturn <<= sal_True; + break; + + case PROPERTY_ID_NAVIGATION: + aReturn = makeAny(NavigationBarMode_CURRENT); + break; + + case PROPERTY_ID_CYCLE: + case PROPERTY_ID_CONTROL_BORDER_COLOR_FOCUS: + case PROPERTY_ID_CONTROL_BORDER_COLOR_MOUSE: + case PROPERTY_ID_CONTROL_BORDER_COLOR_INVALID: + break; + + default: + if ( m_aPropertyBagHelper.hasDynamicPropertyByHandle( nHandle ) ) + m_aPropertyBagHelper.getDynamicPropertyDefaultByHandle( nHandle, aReturn ); + else + aReturn = OPropertySetAggregationHelper::getPropertyDefaultByHandle( nHandle ); + break; + } + return aReturn; +} + +//============================================================================== +// com::sun::star::form::XReset +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::reset() throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + if (isLoaded()) + { + ::osl::MutexGuard aResetGuard(m_aResetSafety); + ++m_nResetsPending; + reset_impl(true); + return; + } + + if ( !m_aResetListeners.empty() ) + { + ::osl::MutexGuard aResetGuard(m_aResetSafety); + ++m_nResetsPending; + // create an own thread if we have (approve-)reset-listeners (so the listeners can't do that much damage + // to this thread which is probably the main one) + if (!m_pThread) + { + m_pThread = new OFormSubmitResetThread(this); + m_pThread->acquire(); + m_pThread->create(); + } + EventObject aEvt; + m_pThread->addEvent(&aEvt, sal_False); + } + else + { + // direct call without any approving by the listeners + aGuard.clear(); + + ::osl::MutexGuard aResetGuard(m_aResetSafety); + ++m_nResetsPending; + reset_impl(false); + } +} + +//----------------------------------------------------------------------------- +void ODatabaseForm::reset_impl(bool _bAproveByListeners) +{ + if ( _bAproveByListeners ) + if ( !m_aResetListeners.approveReset() ) + return; + + ::osl::ResettableMutexGuard aResetGuard(m_aResetSafety); + // do we have a database connected form and stay on the insert row + sal_Bool bInsertRow = sal_False; + if (m_xAggregateSet.is()) + bInsertRow = getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_ISNEW)); + if (bInsertRow) + { + try + { + // Iterate through all columns and set the default value + Reference< XColumnsSupplier > xColsSuppl( m_xAggregateSet, UNO_QUERY ); + Reference< XIndexAccess > xIndexCols( xColsSuppl->getColumns(), UNO_QUERY ); + for (sal_Int32 i = 0; i < xIndexCols->getCount(); ++i) + { + Reference< XPropertySet > xColProps; + xIndexCols->getByIndex(i) >>= xColProps; + + Reference< XColumnUpdate > xColUpdate( xColProps, UNO_QUERY ); + if ( !xColUpdate.is() ) + continue; + + Reference< XPropertySetInfo > xPSI; + if ( xColProps.is() ) + xPSI = xColProps->getPropertySetInfo( ); + + static const ::rtl::OUString PROPERTY_CONTROLDEFAULT( RTL_CONSTASCII_USTRINGPARAM( "ControlDefault" ) ); + if ( xPSI.is() && xPSI->hasPropertyByName( PROPERTY_CONTROLDEFAULT ) ) + { + Any aDefault = xColProps->getPropertyValue( PROPERTY_CONTROLDEFAULT ); + + sal_Bool bReadOnly = sal_False; + if ( xPSI->hasPropertyByName( PROPERTY_ISREADONLY ) ) + xColProps->getPropertyValue( PROPERTY_ISREADONLY ) >>= bReadOnly; + + if ( !bReadOnly ) + { + try + { + if ( aDefault.hasValue() ) + xColUpdate->updateObject( aDefault ); + } + catch(Exception&) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + } + } + } + catch(Exception&) + { + } + + if (m_bSubForm) + { + Reference< XColumnsSupplier > xParentColSupp( m_xParent, UNO_QUERY ); + Reference< XNameAccess > xParentCols; + if ( xParentColSupp.is() ) + xParentCols = xParentColSupp->getColumns(); + + if ( xParentCols.is() && xParentCols->hasElements() && m_aMasterFields.getLength() ) + { + try + { + // analyze our parameters + if ( !m_aParameterManager.isUpToDate() ) + updateParameterInfo(); + + m_aParameterManager.resetParameterValues( ); + } + catch(const Exception&) + { + OSL_ENSURE(sal_False, "ODatabaseForm::reset_impl: could not initialize the master-detail-driven parameters!"); + } + } + } + } + + aResetGuard.clear(); + // iterate through all components. don't use an XIndexAccess as this will cause massive + // problems with the count. + Reference<XEnumeration> xIter = createEnumeration(); + while (xIter->hasMoreElements()) + { + Reference<XReset> xReset; + xIter->nextElement() >>= xReset; + if (xReset.is()) + { + // TODO : all reset-methods have to be thread-safe + xReset->reset(); + } + } + + aResetGuard.reset(); + // ensure that the row isn't modified + // (do this _before_ the listeners are notified ! their reaction (maybe asynchronous) may depend + // on the modified state of the row + // 21.02.00 - 73265 - FS) + if (bInsertRow) + m_xAggregateSet->setPropertyValue(PROPERTY_ISMODIFIED, ::cppu::bool2any(sal_Bool(sal_False))); + + aResetGuard.clear(); + { + m_aResetListeners.resetted(); + } + + aResetGuard.reset(); + // and again : ensure the row isn't modified + // we already did this after we (and maybe our dependents) resetted the values, but the listeners may have changed the row, too + if (bInsertRow) + m_xAggregateSet->setPropertyValue(PROPERTY_ISMODIFIED, ::cppu::bool2any((sal_False))); + + --m_nResetsPending; +} + +//----------------------------------------------------------------------------- +void SAL_CALL ODatabaseForm::addResetListener(const Reference<XResetListener>& _rListener) throw( RuntimeException ) +{ + m_aResetListeners.addTypedListener( _rListener ); +} + +//----------------------------------------------------------------------------- +void SAL_CALL ODatabaseForm::removeResetListener(const Reference<XResetListener>& _rListener) throw( RuntimeException ) +{ + m_aResetListeners.removeTypedListener( _rListener ); +} + +//============================================================================== +// com::sun::star::form::XSubmit +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::submit( const Reference<XControl>& Control, + const ::com::sun::star::awt::MouseEvent& MouseEvt ) throw( RuntimeException ) +{ + { + ::osl::MutexGuard aGuard(m_aMutex); + // Sind Controls und eine Submit-URL vorhanden? + if( !getCount() || !m_aTargetURL.getLength() ) + return; + } + + ::osl::ClearableMutexGuard aGuard(m_aMutex); + if (m_aSubmitListeners.getLength()) + { + // create an own thread if we have (approve-)submit-listeners (so the listeners can't do that much damage + // to this thread which is probably the main one) + if (!m_pThread) + { + m_pThread = new OFormSubmitResetThread(this); + m_pThread->acquire(); + m_pThread->create(); + } + m_pThread->addEvent(&MouseEvt, Control, sal_True); + } + else + { + // direct call without any approving by the listeners + aGuard.clear(); + submit_impl( Control, MouseEvt, true ); + } +} +// ----------------------------------------------------------------------------- +void lcl_dispatch(const Reference< XFrame >& xFrame,const Reference<XURLTransformer>& xTransformer,const ::rtl::OUString& aURLStr,const ::rtl::OUString& aReferer,const ::rtl::OUString& aTargetName + ,const ::rtl::OUString& aData,rtl_TextEncoding _eEncoding) +{ + URL aURL; + aURL.Complete = aURLStr; + xTransformer->parseStrict(aURL); + + Reference< XDispatch > xDisp = Reference< XDispatchProvider > (xFrame,UNO_QUERY)->queryDispatch(aURL, aTargetName, + FrameSearchFlag::SELF | FrameSearchFlag::PARENT | FrameSearchFlag::CHILDREN | + FrameSearchFlag::SIBLINGS | FrameSearchFlag::CREATE | FrameSearchFlag::TASKS); + + if (xDisp.is()) + { + Sequence<PropertyValue> aArgs(2); + aArgs.getArray()[0].Name = ::rtl::OUString::createFromAscii("Referer"); + aArgs.getArray()[0].Value <<= aReferer; + + // build a sequence from the to-be-submitted string + ByteString a8BitData(aData.getStr(), (sal_uInt16)aData.getLength(), _eEncoding); + // always ANSI #58641 + Sequence< sal_Int8 > aPostData((sal_Int8*)a8BitData.GetBuffer(), a8BitData.Len()); + Reference< XInputStream > xPostData = new SequenceInputStream(aPostData); + + aArgs.getArray()[1].Name = ::rtl::OUString::createFromAscii("PostData"); + aArgs.getArray()[1].Value <<= xPostData; + + xDisp->dispatch(aURL, aArgs); + } // if (xDisp.is()) +} +//------------------------------------------------------------------------------ +void ODatabaseForm::submit_impl(const Reference<XControl>& Control, const ::com::sun::star::awt::MouseEvent& MouseEvt, bool _bAproveByListeners) +{ + + if (_bAproveByListeners) + { + ::cppu::OInterfaceIteratorHelper aIter(m_aSubmitListeners); + EventObject aEvt(static_cast<XWeak*>(this)); + sal_Bool bCanceled = sal_False; + while (aIter.hasMoreElements() && !bCanceled) + { + if (!((XSubmitListener*)aIter.next())->approveSubmit(aEvt)) + bCanceled = sal_True; + } + + if (bCanceled) + return; + } + + FormSubmitEncoding eSubmitEncoding; + FormSubmitMethod eSubmitMethod; + ::rtl::OUString aURLStr; + ::rtl::OUString aReferer; + ::rtl::OUString aTargetName; + Reference< XModel > xModel; + { + ::vos::OGuard aGuard( Application::GetSolarMutex() ); + // starform->Forms + + Reference<XChild> xParent(m_xParent, UNO_QUERY); + + if (xParent.is()) + xModel = getXModel(xParent->getParent()); + + if (xModel.is()) + aReferer = xModel->getURL(); + + // TargetItem + aTargetName = m_aTargetFrame; + + eSubmitEncoding = m_eSubmitEncoding; + eSubmitMethod = m_eSubmitMethod; + aURLStr = m_aTargetURL; + } + + if (!xModel.is()) + return; + Reference< XFrame > xFrame = xModel->getCurrentController()->getFrame(); + if (!xFrame.is()) + return; + + Reference<XURLTransformer> + xTransformer(m_xServiceFactory->createInstance( + ::rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer")), UNO_QUERY); + DBG_ASSERT(xTransformer.is(), "ODatabaseForm::submit_impl : could not create an URL transformer !"); + + // URL-Encoding + if( eSubmitEncoding == FormSubmitEncoding_URL ) + { + ::rtl::OUString aData; + { + ::vos::OGuard aGuard( Application::GetSolarMutex() ); + aData = GetDataURLEncoded( Control, MouseEvt ); + } + + URL aURL; + // FormMethod GET + if( eSubmitMethod == FormSubmitMethod_GET ) + { + INetURLObject aUrlObj( aURLStr, INetURLObject::WAS_ENCODED ); + aUrlObj.SetParam( aData, INetURLObject::ENCODE_ALL ); + aURL.Complete = aUrlObj.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ); + if (xTransformer.is()) + xTransformer->parseStrict(aURL); + + Reference< XDispatch > xDisp = Reference< XDispatchProvider > (xFrame,UNO_QUERY)->queryDispatch(aURL, aTargetName, + FrameSearchFlag::SELF | FrameSearchFlag::PARENT | FrameSearchFlag::CHILDREN | + FrameSearchFlag::SIBLINGS | FrameSearchFlag::CREATE | FrameSearchFlag::TASKS); + + if (xDisp.is()) + { + Sequence<PropertyValue> aArgs(1); + aArgs.getArray()->Name = ::rtl::OUString::createFromAscii("Referer"); + aArgs.getArray()->Value <<= aReferer; + xDisp->dispatch(aURL, aArgs); + } + } + // FormMethod POST + else if( eSubmitMethod == FormSubmitMethod_POST ) + { + lcl_dispatch(xFrame,xTransformer,aURLStr,aReferer,aTargetName,aData,RTL_TEXTENCODING_MS_1252); + } + } + else if( eSubmitEncoding == FormSubmitEncoding_MULTIPART ) + { + URL aURL; + aURL.Complete = aURLStr; + xTransformer->parseStrict(aURL); + + Reference< XDispatch > xDisp = Reference< XDispatchProvider > (xFrame,UNO_QUERY)->queryDispatch(aURL, aTargetName, + FrameSearchFlag::SELF | FrameSearchFlag::PARENT | FrameSearchFlag::CHILDREN | + FrameSearchFlag::SIBLINGS | FrameSearchFlag::CREATE | FrameSearchFlag::TASKS); + + if (xDisp.is()) + { + ::rtl::OUString aContentType; + Sequence<sal_Int8> aData; + { + ::vos::OGuard aGuard( Application::GetSolarMutex() ); + aData = GetDataMultiPartEncoded(Control, MouseEvt, aContentType); + } + if (!aData.getLength()) + return; + + Sequence<PropertyValue> aArgs(3); + aArgs.getArray()[0].Name = ::rtl::OUString::createFromAscii("Referer"); + aArgs.getArray()[0].Value <<= aReferer; + aArgs.getArray()[1].Name = ::rtl::OUString::createFromAscii("ContentType"); + aArgs.getArray()[1].Value <<= aContentType; + + // build a sequence from the to-be-submitted string + Reference< XInputStream > xPostData = new SequenceInputStream(aData); + + aArgs.getArray()[2].Name = ::rtl::OUString::createFromAscii("PostData"); + aArgs.getArray()[2].Value <<= xPostData; + + xDisp->dispatch(aURL, aArgs); + } + } + else if( eSubmitEncoding == FormSubmitEncoding_TEXT ) + { + ::rtl::OUString aData; + { + ::vos::OGuard aGuard( Application::GetSolarMutex() ); + aData = GetDataTextEncoded( Reference<XControl> (), MouseEvt ); + } + + lcl_dispatch(xFrame,xTransformer,aURLStr,aReferer,aTargetName,aData,osl_getThreadTextEncoding()); + } + else { + DBG_ERROR("ODatabaseForm::submit_Impl : wrong encoding !"); + } + +} + +// XSubmit +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addSubmitListener(const Reference<XSubmitListener>& _rListener) throw( RuntimeException ) +{ + m_aSubmitListeners.addInterface(_rListener); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeSubmitListener(const Reference<XSubmitListener>& _rListener) throw( RuntimeException ) +{ + m_aSubmitListeners.removeInterface(_rListener); +} + +//============================================================================== +// com::sun::star::sdbc::XSQLErrorBroadcaster +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addSQLErrorListener(const Reference<XSQLErrorListener>& _rListener) throw( RuntimeException ) +{ + m_aErrorListeners.addInterface(_rListener); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeSQLErrorListener(const Reference<XSQLErrorListener>& _rListener) throw( RuntimeException ) +{ + m_aErrorListeners.removeInterface(_rListener); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::invlidateParameters() +{ + ::osl::MutexGuard aGuard(m_aMutex); + m_aParameterManager.clearAllParameterInformation(); +} + +//============================================================================== +// OChangeListener +//------------------------------------------------------------------------------ +void ODatabaseForm::_propertyChanged(const PropertyChangeEvent& evt) throw( RuntimeException ) +{ + if ((0 == evt.PropertyName.compareToAscii(PROPERTY_ACTIVE_CONNECTION)) && !m_bForwardingConnection) + { + // the rowset changed its active connection itself (without interaction from our side), so + // we need to fire this event, too + sal_Int32 nHandle = PROPERTY_ID_ACTIVE_CONNECTION; + fire(&nHandle, &evt.NewValue, &evt.OldValue, 1, sal_False); + } + else // it was one of the statement relevant props + { + // if the statement has changed we have to delete the parameter info + invlidateParameters(); + } +} + +//============================================================================== +// smartXChild +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setParent(const InterfaceRef& Parent) throw ( ::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException) +{ + // SYNCHRONIZED -----> + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + Reference<XForm> xParentForm(getParent(), UNO_QUERY); + if (xParentForm.is()) + { + try + { + Reference< XRowSetApproveBroadcaster > xParentApprBroadcast( xParentForm, UNO_QUERY_THROW ); + xParentApprBroadcast->removeRowSetApproveListener( this ); + + Reference< XLoadable > xParentLoadable( xParentForm, UNO_QUERY_THROW ); + xParentLoadable->removeLoadListener( this ); + + Reference< XPropertySet > xParentProperties( xParentForm, UNO_QUERY_THROW ); + xParentProperties->removePropertyChangeListener( PROPERTY_ISNEW, this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + + OFormComponents::setParent(Parent); + + xParentForm.set(getParent(), UNO_QUERY); + if ( xParentForm.is() ) + { + try + { + Reference< XRowSetApproveBroadcaster > xParentApprBroadcast( xParentForm, UNO_QUERY_THROW ); + xParentApprBroadcast->addRowSetApproveListener( this ); + + Reference< XLoadable > xParentLoadable( xParentForm, UNO_QUERY_THROW ); + xParentLoadable->addLoadListener( this ); + + Reference< XPropertySet > xParentProperties( xParentForm, UNO_QUERY_THROW ); + xParentProperties->addPropertyChangeListener( PROPERTY_ISNEW, this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + + Reference< XPropertySet > xAggregateProperties( m_xAggregateSet ); + aGuard.clear(); + // <----- SYNCHRONIZED + + Reference< XConnection > xOuterConnection; + sal_Bool bIsEmbedded = ::dbtools::isEmbeddedInDatabase( Parent, xOuterConnection ); + + if ( bIsEmbedded ) + xAggregateProperties->setPropertyValue( PROPERTY_DATASOURCE, makeAny( ::rtl::OUString() ) ); +} + +//============================================================================== +// smartXTabControllerModel +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::getGroupControl() throw(com::sun::star::uno::RuntimeException) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + // Sollen Controls in einer TabOrder gruppe zusammengefasst werden? + if (m_aCycle.hasValue()) + { + sal_Int32 nCycle = 0; + ::cppu::enum2int(nCycle, m_aCycle); + return nCycle != TabulatorCycle_PAGE; + } + + if (isLoaded() && getConnection().is()) + return sal_True; + + return sal_False; +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setControlModels(const Sequence<Reference<XControlModel> >& rControls) throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + // TabIndex in der Reihenfolge der Sequence setzen + const Reference<XControlModel>* pControls = rControls.getConstArray(); + sal_Int16 nTabIndex = 1; + sal_Int32 nCount = getCount(); + sal_Int32 nNewCount = rControls.getLength(); + + // HiddenControls und Formulare werden nicht aufgefuehrt + if (nNewCount <= nCount) + { + Any aElement; + for (sal_Int32 i=0; i < nNewCount; ++i, ++pControls) + { + Reference<XFormComponent> xComp(*pControls, UNO_QUERY); + if (xComp.is()) + { + // suchen der Componente in der Liste + for (sal_Int32 j = 0; j < nCount; ++j) + { + Reference<XFormComponent> xElement; + ::cppu::extractInterface(xElement, getByIndex(j)); + if (xComp == xElement) + { + Reference<XPropertySet> xSet(xComp, UNO_QUERY); + if (xSet.is() && hasProperty(PROPERTY_TABINDEX, xSet)) + xSet->setPropertyValue( PROPERTY_TABINDEX, makeAny(nTabIndex++) ); + break; + } + } + } + } + } +} + +//------------------------------------------------------------------------------ +Sequence<Reference<XControlModel> > SAL_CALL ODatabaseForm::getControlModels() throw( RuntimeException ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + return m_pGroupManager->getControlModels(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setGroup( const Sequence<Reference<XControlModel> >& _rGroup, const ::rtl::OUString& Name ) throw( RuntimeException ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + + // Die Controls werden gruppiert, indem ihr Name dem Namen des ersten + // Controls der Sequenz angepasst wird + const Reference<XControlModel>* pControls = _rGroup.getConstArray(); + Reference< XPropertySet > xSet; + ::rtl::OUString sGroupName( Name ); + + for( sal_Int32 i=0; i<_rGroup.getLength(); ++i, ++pControls ) + { + xSet = xSet.query( *pControls ); + if ( !xSet.is() ) + { + // can't throw an exception other than a RuntimeException (which would not be appropriate), + // so we ignore (and only assert) this + OSL_ENSURE( sal_False, "ODatabaseForm::setGroup: invalid arguments!" ); + continue; + } + + if (!sGroupName.getLength()) + xSet->getPropertyValue(PROPERTY_NAME) >>= sGroupName; + else + xSet->setPropertyValue(PROPERTY_NAME, makeAny(sGroupName)); + } +} + +//------------------------------------------------------------------------------ +sal_Int32 SAL_CALL ODatabaseForm::getGroupCount() throw( RuntimeException ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + return m_pGroupManager->getGroupCount(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::getGroup( sal_Int32 nGroup, Sequence<Reference<XControlModel> >& _rGroup, ::rtl::OUString& _rName ) throw( RuntimeException ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + _rGroup.realloc(0); + _rName = ::rtl::OUString(); + + if ((nGroup < 0) || (nGroup >= m_pGroupManager->getGroupCount())) + return; + m_pGroupManager->getGroup( nGroup, _rGroup, _rName ); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::getGroupByName(const ::rtl::OUString& Name, Sequence< Reference<XControlModel> >& _rGroup) throw( RuntimeException ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + _rGroup.realloc(0); + m_pGroupManager->getGroupByName( Name, _rGroup ); +} + +//============================================================================== +// com::sun::star::lang::XEventListener +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::disposing(const EventObject& Source) throw( RuntimeException ) +{ + // does the call come from the connection which we are sharing with our parent? + if ( isSharingConnection() ) + { + Reference< XConnection > xConnSource( Source.Source, UNO_QUERY ); + if ( xConnSource.is() ) + { +#if OSL_DEBUG_LEVEL > 0 + Reference< XConnection > xActiveConn; + m_xAggregateSet->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ) >>= xActiveConn; + OSL_ENSURE( xActiveConn.get() == xConnSource.get(), "ODatabaseForm::disposing: where did this come from?" ); + // there should be exactly one XConnection object we're listening at - our aggregate connection +#endif + disposingSharedConnection( xConnSource ); + } + } + + OInterfaceContainer::disposing(Source); + + // does the disposing come from the aggregate ? + if (m_xAggregate.is()) + { // no -> forward it + com::sun::star::uno::Reference<com::sun::star::lang::XEventListener> xListener; + if (query_aggregation(m_xAggregate, xListener)) + xListener->disposing(Source); + } +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::impl_createLoadTimer() +{ + OSL_PRECOND( m_pLoadTimer == NULL, "ODatabaseForm::impl_createLoadTimer: timer already exists!" ); + m_pLoadTimer = new Timer(); + m_pLoadTimer->SetTimeout(100); + m_pLoadTimer->SetTimeoutHdl(LINK(this,ODatabaseForm,OnTimeout)); +} + +//============================================================================== +// com::sun::star::form::XLoadListener +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::loaded(const EventObject& /*aEvent*/) throw( RuntimeException ) +{ + { + ::osl::MutexGuard aGuard( m_aMutex ); + Reference< XRowSet > xParentRowSet( m_xParent, UNO_QUERY_THROW ); + xParentRowSet->addRowSetListener( this ); + + impl_createLoadTimer(); + } + + load_impl( sal_True ); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::unloading(const EventObject& /*aEvent*/) throw( RuntimeException ) +{ + { + // now stop the rowset listening if we are a subform + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pLoadTimer && m_pLoadTimer->IsActive() ) + m_pLoadTimer->Stop(); + DELETEZ( m_pLoadTimer ); + + Reference< XRowSet > xParentRowSet( m_xParent, UNO_QUERY_THROW ); + xParentRowSet->removeRowSetListener( this ); + } + + unload(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::unloaded(const EventObject& /*aEvent*/) throw( RuntimeException ) +{ + // nothing to do +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::reloading(const EventObject& /*aEvent*/) throw( RuntimeException ) +{ + // now stop the rowset listening if we are a subform + ::osl::MutexGuard aGuard(m_aMutex); + Reference<XRowSet> xParentRowSet(m_xParent, UNO_QUERY); + if (xParentRowSet.is()) + xParentRowSet->removeRowSetListener(this); + + if (m_pLoadTimer && m_pLoadTimer->IsActive()) + m_pLoadTimer->Stop(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::reloaded(const EventObject& /*aEvent*/) throw( RuntimeException ) +{ + reload_impl(sal_True); + { + ::osl::MutexGuard aGuard(m_aMutex); + Reference<XRowSet> xParentRowSet(m_xParent, UNO_QUERY); + if (xParentRowSet.is()) + xParentRowSet->addRowSetListener(this); + } +} + +//------------------------------------------------------------------------------ +IMPL_LINK( ODatabaseForm, OnTimeout, void*, EMPTYARG ) +{ + reload_impl(sal_True); + return 1; +} + +//============================================================================== +// com::sun::star::form::XLoadable +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::load() throw( RuntimeException ) +{ + load_impl(sal_False); +} + +//------------------------------------------------------------------------------ +sal_Bool ODatabaseForm::canShareConnection( const Reference< XPropertySet >& _rxParentProps ) +{ + // our own data source + ::rtl::OUString sOwnDatasource; + m_xAggregateSet->getPropertyValue( PROPERTY_DATASOURCE ) >>= sOwnDatasource; + + // our parents data source + ::rtl::OUString sParentDataSource; + OSL_ENSURE( _rxParentProps.is() && _rxParentProps->getPropertySetInfo().is() && _rxParentProps->getPropertySetInfo()->hasPropertyByName( PROPERTY_DATASOURCE ), + "ODatabaseForm::doShareConnection: invalid parent form!" ); + if ( _rxParentProps.is() ) + _rxParentProps->getPropertyValue( PROPERTY_DATASOURCE ) >>= sParentDataSource; + + sal_Bool bCanShareConnection = sal_False; + + // both rowsets share are connected to the same data source + if ( sParentDataSource == sOwnDatasource ) + { + if ( 0 != sParentDataSource.getLength() ) + // and it's really a data source name (not empty) + bCanShareConnection = sal_True; + else + { // the data source name is empty + // -> ook for the URL + ::rtl::OUString sParentURL; + ::rtl::OUString sMyURL; + _rxParentProps->getPropertyValue( PROPERTY_URL ) >>= sParentURL; + m_xAggregateSet->getPropertyValue( PROPERTY_URL ) >>= sMyURL; + + bCanShareConnection = (sParentURL == sMyURL); + } + } + + if ( bCanShareConnection ) + { + // check for the user/password + + // take the user property on the rowset (if any) into account + ::rtl::OUString sParentUser, sParentPwd; + _rxParentProps->getPropertyValue( PROPERTY_USER ) >>= sParentUser; + _rxParentProps->getPropertyValue( PROPERTY_PASSWORD ) >>= sParentPwd; + + ::rtl::OUString sMyUser, sMyPwd; + m_xAggregateSet->getPropertyValue( PROPERTY_USER ) >>= sMyUser; + m_xAggregateSet->getPropertyValue( PROPERTY_PASSWORD ) >>= sMyPwd; + + bCanShareConnection = + ( sParentUser == sMyUser ) + && ( sParentPwd == sMyPwd ); + } + + return bCanShareConnection; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::doShareConnection( const Reference< XPropertySet >& _rxParentProps ) +{ + // get the conneciton of the parent + Reference< XConnection > xParentConn; + _rxParentProps->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ) >>= xParentConn; + OSL_ENSURE( xParentConn.is(), "ODatabaseForm::doShareConnection: we're a valid sub-form, but the parent has no connection?!" ); + + if ( xParentConn.is() ) + { + // add as dispose listener to the connection + Reference< XComponent > xParentConnComp( xParentConn, UNO_QUERY ); + OSL_ENSURE( xParentConnComp.is(), "ODatabaseForm::doShareConnection: invalid connection!" ); + xParentConnComp->addEventListener( static_cast< XLoadListener* >( this ) ); + + // forward the connection to our own aggreagte + m_bForwardingConnection = sal_True; + m_xAggregateSet->setPropertyValue( PROPERTY_ACTIVE_CONNECTION, makeAny( xParentConn ) ); + m_bForwardingConnection = sal_False; + + m_bSharingConnection = sal_True; + } + else + m_bSharingConnection = sal_False; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::disposingSharedConnection( const Reference< XConnection >& /*_rxConn*/ ) +{ + stopSharingConnection(); + + // TODO: we could think about whether or not to re-connect. + unload( ); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::stopSharingConnection( ) +{ + OSL_ENSURE( m_bSharingConnection, "ODatabaseForm::stopSharingConnection: invalid call!" ); + + if ( m_bSharingConnection ) + { + // get the connection + Reference< XConnection > xSharedConn; + m_xAggregateSet->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ) >>= xSharedConn; + OSL_ENSURE( xSharedConn.is(), "ODatabaseForm::stopSharingConnection: there's no conn!" ); + + // remove ourself as event listener + Reference< XComponent > xSharedConnComp( xSharedConn, UNO_QUERY ); + if ( xSharedConnComp.is() ) + xSharedConnComp->removeEventListener( static_cast< XLoadListener* >( this ) ); + + // no need to dispose the conn: we're not the owner, this is our parent + // (in addition, this method may be called if the connection is beeing disposed while we use it) + + // reset the property + xSharedConn.clear(); + m_bForwardingConnection = sal_True; + m_xAggregateSet->setPropertyValue( PROPERTY_ACTIVE_CONNECTION, makeAny( xSharedConn ) ); + m_bForwardingConnection = sal_False; + + // reset the flag + m_bSharingConnection = sal_False; + } +} + +//------------------------------------------------------------------------------ +sal_Bool ODatabaseForm::implEnsureConnection() +{ + try + { + if ( getConnection( ).is() ) + // if our aggregate already has a connection, nothing needs to be done about it + return sal_True; + + // see whether we're an embedded form + Reference< XConnection > xOuterConnection; + if ( ::dbtools::isEmbeddedInDatabase( getParent(), xOuterConnection ) ) + { + m_xAggregateSet->setPropertyValue( PROPERTY_ACTIVE_CONNECTION, makeAny( xOuterConnection ) ); + return xOuterConnection.is(); + } + + m_bSharingConnection = sal_False; + + // if we're a sub form, we try to re-use the connection of our parent + if (m_bSubForm) + { + OSL_ENSURE( Reference< XForm >( getParent(), UNO_QUERY ).is(), + "ODatabaseForm::implEnsureConnection: m_bSubForm is TRUE, but the parent is no form?" ); + + Reference< XPropertySet > xParentProps( getParent(), UNO_QUERY ); + + // can we re-use (aka share) the connection of the parent? + if ( canShareConnection( xParentProps ) ) + { + // yep -> do it + doShareConnection( xParentProps ); + // success? + if ( m_bSharingConnection ) + // yes -> outta here + return sal_True; + } + } + + if (m_xAggregateSet.is()) + { + Reference< XConnection > xConnection = connectRowset( + Reference<XRowSet> (m_xAggregate, UNO_QUERY), + m_xServiceFactory, + sal_True // set a calculated connection as ActiveConnection + ); + return xConnection.is(); + } + } + catch(SQLException& eDB) + { + onError(eDB, FRM_RES_STRING(RID_STR_CONNECTERROR)); + } + catch( Exception ) + { + DBG_UNHANDLED_EXCEPTION(); + } + + return sal_False; +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::load_impl(sal_Bool bCausedByParentForm, sal_Bool bMoveToFirst, const Reference< XInteractionHandler >& _rxCompletionHandler ) throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + // are we already loaded? + if (isLoaded()) + return; + + m_bSubForm = bCausedByParentForm; + + // if we don't have a connection, we are not intended to be a database form or the aggregate was not able + // to establish a connection + sal_Bool bConnected = implEnsureConnection(); + + // we don't have to execute if we do not have a command to execute + sal_Bool bExecute = bConnected && m_xAggregateSet.is() && getString(m_xAggregateSet->getPropertyValue(PROPERTY_COMMAND)).getLength(); + + // a database form always uses caching + // we use starting fetchsize with at least 10 rows + if (bConnected) + m_xAggregateSet->setPropertyValue(PROPERTY_FETCHSIZE, makeAny((sal_Int32)10)); + + // if we're loaded as sub form we got a "rowSetChanged" from the parent rowset _before_ we got the "loaded" + // so we don't need to execute the statement again, this was already done + // (and there were no relevant changes between these two listener calls, the "load" of a form is quite an + // atomar operation.) + + sal_Bool bSuccess = sal_False; + if (bExecute) + { + m_sCurrentErrorContext = FRM_RES_STRING(RID_ERR_LOADING_FORM); + bSuccess = executeRowSet(aGuard, bMoveToFirst, _rxCompletionHandler); + } + + if (bSuccess) + { + m_bLoaded = sal_True; + aGuard.clear(); + EventObject aEvt(static_cast<XWeak*>(this)); + m_aLoadListeners.notifyEach( &XLoadListener::loaded, aEvt ); + + // if we are on the insert row, we have to reset all controls + // to set the default values + if (bExecute && getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_ISNEW))) + reset(); + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::unload() throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + if (!isLoaded()) + return; + + DELETEZ(m_pLoadTimer); + + aGuard.clear(); + EventObject aEvt(static_cast<XWeak*>(this)); + m_aLoadListeners.notifyEach( &XLoadListener::unloading, aEvt ); + + if (m_xAggregateAsRowSet.is()) + { + // we may have reset the InsertOnly property on the aggregate - restore it + restoreInsertOnlyState( ); + + // clear the parameters if there are any + invlidateParameters(); + + try + { + // close the aggregate + Reference<XCloseable> xCloseable; + query_aggregation( m_xAggregate, xCloseable); + aGuard.clear(); + if (xCloseable.is()) + xCloseable->close(); + } + catch( const SQLException& e ) + { + (void)e; + } + aGuard.reset(); + } + + m_bLoaded = sal_False; + + // if the connection we used while we were loaded is only shared with our parent, we + // reset it + if ( isSharingConnection() ) + stopSharingConnection(); + + aGuard.clear(); + m_aLoadListeners.notifyEach( &XLoadListener::unloaded, aEvt ); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::reload() throw( RuntimeException ) +{ + reload_impl(sal_True); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::reload_impl(sal_Bool bMoveToFirst, const Reference< XInteractionHandler >& _rxCompletionHandler ) throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + if (!isLoaded()) + return; + + DocumentModifyGuard aModifyGuard( *this ); + // ensures the document is not marked as "modified" just because we change some control's content during + // reloading ... + + EventObject aEvent(static_cast<XWeak*>(this)); + { + // only if there is no approve listener we can post the event at this time + // otherwise see approveRowsetChange + // the aprrovement is done by the aggregate + if (!m_aRowSetApproveListeners.getLength()) + { + ::cppu::OInterfaceIteratorHelper aIter(m_aLoadListeners); + aGuard.clear(); + + while (aIter.hasMoreElements()) + ((XLoadListener*)aIter.next())->reloading(aEvent); + + aGuard.reset(); + } + } + + sal_Bool bSuccess = sal_True; + try + { + m_sCurrentErrorContext = FRM_RES_STRING(RID_ERR_REFRESHING_FORM); + bSuccess = executeRowSet(aGuard, bMoveToFirst, _rxCompletionHandler); + } + catch( const SQLException& e ) + { + DBG_ERROR("ODatabaseForm::reload_impl : shouldn't executeRowSet catch this exception?"); + (void)e; + } + + if (bSuccess) + { + ::cppu::OInterfaceIteratorHelper aIter(m_aLoadListeners); + aGuard.clear(); + while (aIter.hasMoreElements()) + ((XLoadListener*)aIter.next())->reloaded(aEvent); + + // if we are on the insert row, we have to reset all controls + // to set the default values + if (getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_ISNEW))) + reset(); + } + else + m_bLoaded = sal_False; +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::isLoaded() throw( RuntimeException ) +{ + return m_bLoaded; +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addLoadListener(const Reference<XLoadListener>& aListener) throw( RuntimeException ) +{ + m_aLoadListeners.addInterface(aListener); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeLoadListener(const Reference<XLoadListener>& aListener) throw( RuntimeException ) +{ + m_aLoadListeners.removeInterface(aListener); +} + +//============================================================================== +// com::sun::star::sdbc::XCloseable +//============================================================================== +void SAL_CALL ODatabaseForm::close() throw( SQLException, RuntimeException ) +{ + // unload will close the aggregate + unload(); +} + +//============================================================================== +// com::sun::star::sdbc::XRowSetListener +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::cursorMoved(const EventObject& /*event*/) throw( RuntimeException ) +{ + // reload the subform with the new parameters of the parent + // do this handling delayed to provide of execute too many SQL Statements + ::osl::ResettableMutexGuard aGuard(m_aMutex); + + DBG_ASSERT( m_pLoadTimer, "ODatabaseForm::cursorMoved: how can this happen?!" ); + if ( !m_pLoadTimer ) + impl_createLoadTimer(); + + if ( m_pLoadTimer->IsActive() ) + m_pLoadTimer->Stop(); + + // and start the timer again + m_pLoadTimer->Start(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::rowChanged(const EventObject& /*event*/) throw( RuntimeException ) +{ + // ignore it +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::rowSetChanged(const EventObject& /*event*/) throw( RuntimeException ) +{ + // not interested in : + // if our parent is an ODatabaseForm, too, then after this rowSetChanged we'll get a "reloaded" + // or a "loaded" event. + // If somebody gave us another parent which is an XRowSet but doesn't handle an execute as + // "load" respectivly "reload" ... can't do anything .... +} + +//------------------------------------------------------------------------------ +bool ODatabaseForm::impl_approveRowChange_throw( const EventObject& _rEvent, const bool _bAllowSQLException, + ::osl::ClearableMutexGuard& _rGuard ) +{ + ::cppu::OInterfaceIteratorHelper aIter( m_aRowSetApproveListeners ); + _rGuard.clear(); + while ( aIter.hasMoreElements() ) + { + Reference< XRowSetApproveListener > xListener( static_cast< XRowSetApproveListener* >( aIter.next() ) ); + if ( !xListener.is() ) + continue; + + try + { + if ( !xListener->approveRowSetChange( _rEvent ) ) + return false; + } + catch ( const DisposedException& e ) + { + if ( e.Context == xListener ) + aIter.remove(); + } + catch ( const RuntimeException& ) { throw; } + catch ( const SQLException& ) + { + if ( _bAllowSQLException ) + throw; + DBG_UNHANDLED_EXCEPTION(); + } + catch ( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + return true; +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::approveCursorMove(const EventObject& event) throw( RuntimeException ) +{ + // is our aggregate calling? + if (event.Source == InterfaceRef(static_cast<XWeak*>(this))) + { + // Our aggregate doesn't have any ApproveRowSetListeners (expect ourself), as we re-routed the queryInterface + // for XRowSetApproveBroadcaster-interface. + // So we have to multiplex this approve request. + ::cppu::OInterfaceIteratorHelper aIter( m_aRowSetApproveListeners ); + while ( aIter.hasMoreElements() ) + { + Reference< XRowSetApproveListener > xListener( static_cast< XRowSetApproveListener* >( aIter.next() ) ); + if ( !xListener.is() ) + continue; + + try + { + if ( !xListener->approveCursorMove( event ) ) + return sal_False; + } + catch ( const DisposedException& e ) + { + if ( e.Context == xListener ) + aIter.remove(); + } + catch ( const RuntimeException& ) { throw; } + catch ( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + return true; + } + else + { + // this is a call from our parent ... + // a parent's cursor move will result in a re-execute of our own row-set, so we have to + // ask our own RowSetChangesListeners, too + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + if ( !impl_approveRowChange_throw( event, false, aGuard ) ) + return sal_False; + } + return sal_True; +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::approveRowChange(const RowChangeEvent& event) throw( RuntimeException ) +{ + // is our aggregate calling? + if (event.Source == InterfaceRef(static_cast<XWeak*>(this))) + { + // Our aggregate doesn't have any ApproveRowSetListeners (expect ourself), as we re-routed the queryInterface + // for XRowSetApproveBroadcaster-interface. + // So we have to multiplex this approve request. + ::cppu::OInterfaceIteratorHelper aIter( m_aRowSetApproveListeners ); + while ( aIter.hasMoreElements() ) + { + Reference< XRowSetApproveListener > xListener( static_cast< XRowSetApproveListener* >( aIter.next() ) ); + if ( !xListener.is() ) + continue; + + try + { + if ( !xListener->approveRowChange( event ) ) + return false; + } + catch ( const DisposedException& e ) + { + if ( e.Context == xListener ) + aIter.remove(); + } + catch ( const RuntimeException& ) { throw; } + catch ( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION(); + } + } + return true; + } + return sal_True; +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::approveRowSetChange(const EventObject& event) throw( RuntimeException ) +{ + if (event.Source == InterfaceRef(static_cast<XWeak*>(this))) // ignore our aggregate as we handle this approve ourself + { + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + bool bWasLoaded = isLoaded(); + if ( !impl_approveRowChange_throw( event, false, aGuard ) ) + return sal_False; + + if ( bWasLoaded ) + { + m_aLoadListeners.notifyEach( &XLoadListener::reloading, event ); + } + } + else + { + // this is a call from our parent ... + // a parent's cursor move will result in a re-execute of our own row-set, so we have to + // ask our own RowSetChangesListeners, too + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + if ( !impl_approveRowChange_throw( event, false, aGuard ) ) + return sal_False; + } + return sal_True; +} + +//============================================================================== +// com::sun::star::sdb::XRowSetApproveBroadcaster +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addRowSetApproveListener(const Reference<XRowSetApproveListener>& _rListener) throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + m_aRowSetApproveListeners.addInterface(_rListener); + + // do we have to multiplex ? + if (m_aRowSetApproveListeners.getLength() == 1) + { + Reference<XRowSetApproveBroadcaster> xBroadcaster; + if (query_aggregation( m_xAggregate, xBroadcaster)) + { + Reference<XRowSetApproveListener> xListener((XRowSetApproveListener*)this); + xBroadcaster->addRowSetApproveListener(xListener); + } + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeRowSetApproveListener(const Reference<XRowSetApproveListener>& _rListener) throw( RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + // do we have to remove the multiplex ? + m_aRowSetApproveListeners.removeInterface(_rListener); + if ( m_aRowSetApproveListeners.getLength() == 0 ) + { + Reference<XRowSetApproveBroadcaster> xBroadcaster; + if (query_aggregation( m_xAggregate, xBroadcaster)) + { + Reference<XRowSetApproveListener> xListener((XRowSetApproveListener*)this); + xBroadcaster->removeRowSetApproveListener(xListener); + } + } +} + +//============================================================================== +// com::sun:star::form::XDatabaseParameterBroadcaster +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addDatabaseParameterListener(const Reference<XDatabaseParameterListener>& _rListener) throw( RuntimeException ) +{ + m_aParameterManager.addParameterListener( _rListener ); +} +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeDatabaseParameterListener(const Reference<XDatabaseParameterListener>& _rListener) throw( RuntimeException ) +{ + m_aParameterManager.removeParameterListener( _rListener ); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addParameterListener(const Reference<XDatabaseParameterListener>& _rListener) throw( RuntimeException ) +{ + ODatabaseForm::addDatabaseParameterListener( _rListener ); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeParameterListener(const Reference<XDatabaseParameterListener>& _rListener) throw( RuntimeException ) +{ + ODatabaseForm::removeDatabaseParameterListener( _rListener ); +} + +//============================================================================== +// com::sun::star::sdb::XCompletedExecution +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::executeWithCompletion( const Reference< XInteractionHandler >& _rxHandler ) throw(SQLException, RuntimeException) +{ + ::osl::ClearableMutexGuard aGuard(m_aMutex); + // the difference between execute and load is, that we position on the first row in case of load + // after execute we remain before the first row + if (!isLoaded()) + { + aGuard.clear(); + load_impl(sal_False, sal_False, _rxHandler); + } + else + { + EventObject event(static_cast< XWeak* >(this)); + if ( !impl_approveRowChange_throw( event, true, aGuard ) ) + return; + + // we're loaded and somebody want's to execute ourself -> this means a reload + reload_impl(sal_False, _rxHandler); + } +} + +//============================================================================== +// com::sun::star::sdbc::XRowSet +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::execute() throw( SQLException, RuntimeException ) +{ + ::osl::ResettableMutexGuard aGuard(m_aMutex); + // if somebody calls an execute and we're not loaded we reroute this call to our load method. + + // the difference between execute and load is, that we position on the first row in case of load + // after execute we remain before the first row + if (!isLoaded()) + { + aGuard.clear(); + load_impl(sal_False, sal_False); + } + else + { + EventObject event(static_cast< XWeak* >(this)); + if ( !impl_approveRowChange_throw( event, true, aGuard ) ) + return; + + // we're loaded and somebody want's to execute ourself -> this means a reload + reload_impl(sal_False); + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::addRowSetListener(const Reference<XRowSetListener>& _rListener) throw( RuntimeException ) +{ + if (m_xAggregateAsRowSet.is()) + m_xAggregateAsRowSet->addRowSetListener(_rListener); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::removeRowSetListener(const Reference<XRowSetListener>& _rListener) throw( RuntimeException ) +{ + if (m_xAggregateAsRowSet.is()) + m_xAggregateAsRowSet->removeRowSetListener(_rListener); +} + +//============================================================================== +// com::sun::star::sdbc::XResultSet +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::next() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->next(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::isBeforeFirst() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->isBeforeFirst(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::isAfterLast() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->isAfterLast(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::isFirst() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->isFirst(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::isLast() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->isLast(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::beforeFirst() throw( SQLException, RuntimeException ) +{ + m_xAggregateAsRowSet->beforeFirst(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::afterLast() throw( SQLException, RuntimeException ) +{ + m_xAggregateAsRowSet->afterLast(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::first() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->first(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::last() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->last(); +} + +//------------------------------------------------------------------------------ +sal_Int32 SAL_CALL ODatabaseForm::getRow() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->getRow(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::absolute(sal_Int32 row) throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->absolute(row); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::relative(sal_Int32 rows) throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->relative(rows); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::previous() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->previous(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::refreshRow() throw( SQLException, RuntimeException ) +{ + m_xAggregateAsRowSet->refreshRow(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::rowUpdated() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->rowUpdated(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::rowInserted() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->rowInserted(); +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::rowDeleted() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->rowDeleted(); +} + +//------------------------------------------------------------------------------ +InterfaceRef SAL_CALL ODatabaseForm::getStatement() throw( SQLException, RuntimeException ) +{ + return m_xAggregateAsRowSet->getStatement(); +} + +// com::sun::star::sdbc::XResultSetUpdate +// exceptions during insert update and delete will be forwarded to the errorlistener +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::insertRow() throw( SQLException, RuntimeException ) +{ + try + { + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->insertRow(); + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; + throw; + } + catch(SQLException& eDb) + { + onError(eDb, FRM_RES_STRING(RID_STR_ERR_INSERTRECORD)); + throw; + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::updateRow() throw( SQLException, RuntimeException ) +{ + try + { + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->updateRow(); + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; + throw; + } + catch(SQLException& eDb) + { + onError(eDb, FRM_RES_STRING(RID_STR_ERR_UPDATERECORD)); + throw; + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::deleteRow() throw( SQLException, RuntimeException ) +{ + try + { + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->deleteRow(); + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; + throw; + } + catch(SQLException& eDb) + { + onError(eDb, FRM_RES_STRING(RID_STR_ERR_DELETERECORD)); + throw; + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::cancelRowUpdates() throw( SQLException, RuntimeException ) +{ + try + { + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->cancelRowUpdates(); + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; + throw; + } + catch(SQLException& eDb) + { + onError(eDb, FRM_RES_STRING(RID_STR_ERR_INSERTRECORD)); + throw; + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::moveToInsertRow() throw( SQLException, RuntimeException ) +{ + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + { + // _always_ move to the insert row + // + // Formerly, the following line was conditioned with a "not is new", means we did not move the aggregate + // to the insert row if it was already positioned there. + // + // This prevented the RowSet implementation from resetting it's column values. We, ourself, formerly + // did this reset of columns in reset_impl, where we set every column to the ControlDefault, or, if this + // was not present, to NULL. However, the problem with setting to NULL was #88888#, the problem with + // _not_ setting to NULL (which was the original fix for #88888#) was #97955#. + // + // So now we + // * move our aggregate to the insert row + // * in reset_impl + // - set the control defaults into the columns if not void + // - do _not_ set the columns to NULL if no control default is set + // This fixes both #88888# and #97955# + // + // Still, there is #72756#. During fixing this bug, DG introduced not calling the aggregate here. So + // in theory, we re-introduced #72756#. But the bug described therein does not happen anymore, as the + // preliminaries for it changed (no display of guessed values for new records with autoinc fields) + // + // BTW: the public Issuezilla bug for #97955# is #i2815# + // + // 16.04.2002 - 97955 - fs@openoffice.org + xUpdate->moveToInsertRow(); + + // then set the default values and the parameters given from the parent + reset(); + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::moveToCurrentRow() throw( SQLException, RuntimeException ) +{ + Reference<XResultSetUpdate> xUpdate; + if (query_aggregation( m_xAggregate, xUpdate)) + xUpdate->moveToCurrentRow(); +} + +// com::sun::star::sdbcx::XDeleteRows +//------------------------------------------------------------------------------ +Sequence<sal_Int32> SAL_CALL ODatabaseForm::deleteRows(const Sequence<Any>& rows) throw( SQLException, RuntimeException ) +{ + try + { + Reference<XDeleteRows> xDelete; + if (query_aggregation( m_xAggregate, xDelete)) + return xDelete->deleteRows(rows); + } + catch( const RowSetVetoException& eVeto ) + { + (void)eVeto; // make compiler happy + throw; + } + catch(SQLException& eDb) + { + onError(eDb, FRM_RES_STRING(RID_STR_ERR_DELETERECORDS)); + throw; + } + + return Sequence< sal_Int32 >(); +} + +// com::sun::star::sdbc::XParameters +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setNull(sal_Int32 parameterIndex, sal_Int32 sqlType) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setNull(parameterIndex, sqlType); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setObjectNull(sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& typeName) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setObjectNull(parameterIndex, sqlType, typeName); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setBoolean(sal_Int32 parameterIndex, sal_Bool x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setBoolean(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setByte(sal_Int32 parameterIndex, sal_Int8 x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setByte(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setShort(sal_Int32 parameterIndex, sal_Int16 x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setShort(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setInt(sal_Int32 parameterIndex, sal_Int32 x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setInt(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setLong(sal_Int32 parameterIndex, sal_Int64 x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setLong(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setFloat(sal_Int32 parameterIndex, float x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setFloat(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setDouble(sal_Int32 parameterIndex, double x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setDouble(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setString(sal_Int32 parameterIndex, const ::rtl::OUString& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setString(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setBytes(sal_Int32 parameterIndex, const Sequence< sal_Int8 >& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setBytes(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setDate(sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setDate(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setTime(sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setTime(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setTimestamp(sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setTimestamp(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setBinaryStream(sal_Int32 parameterIndex, const Reference<XInputStream>& x, sal_Int32 length) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setBinaryStream(parameterIndex, x, length); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setCharacterStream(sal_Int32 parameterIndex, const Reference<XInputStream>& x, sal_Int32 length) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setCharacterStream(parameterIndex, x, length); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setObjectWithInfo(sal_Int32 parameterIndex, const Any& x, sal_Int32 targetSqlType, sal_Int32 scale) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setObjectWithInfo(parameterIndex, x, targetSqlType, scale); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setObject(sal_Int32 parameterIndex, const Any& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setObject(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setRef(sal_Int32 parameterIndex, const Reference<XRef>& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setRef(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setBlob(sal_Int32 parameterIndex, const Reference<XBlob>& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setBlob(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setClob(sal_Int32 parameterIndex, const Reference<XClob>& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setClob(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setArray(sal_Int32 parameterIndex, const Reference<XArray>& x) throw( SQLException, RuntimeException ) +{ + m_aParameterManager.setArray(parameterIndex, x); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::clearParameters() throw( SQLException, RuntimeException ) +{ + m_aParameterManager.clearParameters(); +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::propertyChange( const PropertyChangeEvent& evt ) throw (RuntimeException) +{ + if ( evt.Source == m_xParent ) + { + if ( evt.PropertyName == PROPERTY_ISNEW ) + { + sal_Bool bCurrentIsNew( sal_False ); + OSL_VERIFY( evt.NewValue >>= bCurrentIsNew ); + if ( !bCurrentIsNew ) + reload_impl( sal_True ); + } + return; + } + OFormComponents::propertyChange( evt ); +} + +// com::sun::star::lang::XServiceInfo +//------------------------------------------------------------------------------ +::rtl::OUString SAL_CALL ODatabaseForm::getImplementationName_Static() +{ + return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.forms.ODatabaseForm" ) ); +} + +//------------------------------------------------------------------------------ +Sequence< ::rtl::OUString > SAL_CALL ODatabaseForm::getCompatibleServiceNames_Static() +{ + Sequence< ::rtl::OUString > aServices( 1 ); + ::rtl::OUString* pServices = aServices.getArray(); + + *pServices++ = FRM_COMPONENT_FORM; + + return aServices; +} + +//------------------------------------------------------------------------------ +Sequence< ::rtl::OUString > SAL_CALL ODatabaseForm::getCurrentServiceNames_Static() +{ + Sequence< ::rtl::OUString > aServices( 5 ); + ::rtl::OUString* pServices = aServices.getArray(); + + *pServices++ = FRM_SUN_FORMCOMPONENT; + *pServices++ = ::rtl::OUString::createFromAscii("com.sun.star.form.FormComponents"); + *pServices++ = FRM_SUN_COMPONENT_FORM; + *pServices++ = FRM_SUN_COMPONENT_HTMLFORM; + *pServices++ = FRM_SUN_COMPONENT_DATAFORM; + + return aServices; +} + +//------------------------------------------------------------------------------ +Sequence< ::rtl::OUString > SAL_CALL ODatabaseForm::getSupportedServiceNames_Static() +{ + return ::comphelper::concatSequences( + getCurrentServiceNames_Static(), + getCompatibleServiceNames_Static() + ); +} + +//------------------------------------------------------------------------------ +::rtl::OUString SAL_CALL ODatabaseForm::getImplementationName() throw( RuntimeException ) +{ + return getImplementationName_Static(); +} + +//------------------------------------------------------------------------------ +Sequence< ::rtl::OUString > SAL_CALL ODatabaseForm::getSupportedServiceNames() throw( RuntimeException ) +{ + // the services of our aggregate + Sequence< ::rtl::OUString > aServices; + Reference< XServiceInfo > xInfo; + if (query_aggregation(m_xAggregate, xInfo)) + aServices = xInfo->getSupportedServiceNames(); + + // concat with out own services + return ::comphelper::concatSequences( + getCurrentServiceNames_Static(), + aServices + ); + // use getCurrentXXX instead of getSupportedXXX, because at runtime, we do not want to have + // the compatible names + // This is maily to be consistent with the implementation before fixing #97083#, though the + // better solution _may_ be to return the compatible names at runtime, too + // 04.03.2002 - fs@openoffice.org +} + +//------------------------------------------------------------------------------ +sal_Bool SAL_CALL ODatabaseForm::supportsService(const ::rtl::OUString& ServiceName) throw( RuntimeException ) +{ + Sequence< ::rtl::OUString > aSupported( getSupportedServiceNames() ); + const ::rtl::OUString* pArray = aSupported.getConstArray(); + for( sal_Int32 i = 0; i < aSupported.getLength(); ++i, ++pArray ) + if( pArray->equals( ServiceName ) ) + return sal_True; + return sal_False; +} + +//============================================================================== +// com::sun::star::io::XPersistObject +//------------------------------------------------------------------------------ + +const sal_uInt16 CYCLE = 0x0001; +const sal_uInt16 DONTAPPLYFILTER = 0x0002; + +//------------------------------------------------------------------------------ +::rtl::OUString ODatabaseForm::getServiceName() throw( RuntimeException ) +{ + return FRM_COMPONENT_FORM; // old (non-sun) name for compatibility ! +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::write(const Reference<XObjectOutputStream>& _rxOutStream) throw( IOException, RuntimeException ) +{ + DBG_ASSERT(m_xAggregateSet.is(), "ODatabaseForm::write : only to be called if the aggregate exists !"); + + // all children + OFormComponents::write(_rxOutStream); + + // version + _rxOutStream->writeShort(0x0003); + + // Name + _rxOutStream << m_sName; + + ::rtl::OUString sDataSource; + if (m_xAggregateSet.is()) + m_xAggregateSet->getPropertyValue(PROPERTY_DATASOURCE) >>= sDataSource; + _rxOutStream << sDataSource; + + // former CursorSource + ::rtl::OUString sCommand; + if (m_xAggregateSet.is()) + m_xAggregateSet->getPropertyValue(PROPERTY_COMMAND) >>= sCommand; + _rxOutStream << sCommand; + + // former MasterFields + _rxOutStream << m_aMasterFields; + // former DetailFields + _rxOutStream << m_aDetailFields; + + // former DataSelectionType + DataSelectionType eTranslated = DataSelectionType_TABLE; + if (m_xAggregateSet.is()) + { + sal_Int32 nCommandType = 0; + m_xAggregateSet->getPropertyValue(PROPERTY_COMMANDTYPE) >>= nCommandType; + switch (nCommandType) + { + case CommandType::TABLE : eTranslated = DataSelectionType_TABLE; break; + case CommandType::QUERY : eTranslated = DataSelectionType_QUERY; break; + case CommandType::COMMAND: + { + sal_Bool bEscapeProcessing = getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_ESCAPE_PROCESSING)); + eTranslated = bEscapeProcessing ? DataSelectionType_SQL : DataSelectionType_SQLPASSTHROUGH; + } + break; + default : DBG_ERROR("ODatabaseForm::write : wrong CommandType !"); + } + } + _rxOutStream->writeShort((sal_Int16)eTranslated); // former DataSelectionType + + // very old versions expect a CursorType here + _rxOutStream->writeShort(DatabaseCursorType_KEYSET); + + _rxOutStream->writeBoolean(m_eNavigation != NavigationBarMode_NONE); + + // former DataEntry + if (m_xAggregateSet.is()) + _rxOutStream->writeBoolean(getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_INSERTONLY))); + else + _rxOutStream->writeBoolean(sal_False); + + _rxOutStream->writeBoolean(m_bAllowInsert); + _rxOutStream->writeBoolean(m_bAllowUpdate); + _rxOutStream->writeBoolean(m_bAllowDelete); + + // html form stuff + ::rtl::OUString sTmp = INetURLObject::decode( m_aTargetURL, '%', INetURLObject::DECODE_UNAMBIGUOUS); + _rxOutStream << sTmp; + _rxOutStream->writeShort( (sal_Int16)m_eSubmitMethod ); + _rxOutStream->writeShort( (sal_Int16)m_eSubmitEncoding ); + _rxOutStream << m_aTargetFrame; + + // version 2 didn't know some options and the "default" state + sal_Int32 nCycle = TabulatorCycle_RECORDS; + if (m_aCycle.hasValue()) + { + ::cppu::enum2int(nCycle, m_aCycle); + if (m_aCycle == TabulatorCycle_PAGE) + // unknown in earlier versions + nCycle = TabulatorCycle_RECORDS; + } + _rxOutStream->writeShort((sal_Int16) nCycle); + + _rxOutStream->writeShort((sal_Int16)m_eNavigation); + + ::rtl::OUString sFilter; + ::rtl::OUString sOrder; + if (m_xAggregateSet.is()) + { + m_xAggregateSet->getPropertyValue(PROPERTY_FILTER) >>= sFilter; + m_xAggregateSet->getPropertyValue(PROPERTY_SORT) >>= sOrder; + } + _rxOutStream << sFilter; + _rxOutStream << sOrder; + + + // version 3 + sal_uInt16 nAnyMask = 0; + if (m_aCycle.hasValue()) + nAnyMask |= CYCLE; + + if (m_xAggregateSet.is() && !getBOOL(m_xAggregateSet->getPropertyValue(PROPERTY_APPLYFILTER))) + nAnyMask |= DONTAPPLYFILTER; + + _rxOutStream->writeShort(nAnyMask); + + if (nAnyMask & CYCLE) + { + sal_Int32 nRealCycle = 0; + ::cppu::enum2int(nRealCycle, m_aCycle); + _rxOutStream->writeShort((sal_Int16)nRealCycle); + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::read(const Reference<XObjectInputStream>& _rxInStream) throw( IOException, RuntimeException ) +{ + DBG_ASSERT(m_xAggregateSet.is(), "ODatabaseForm::read : only to be called if the aggregate exists !"); + + OFormComponents::read(_rxInStream); + + // version + sal_uInt16 nVersion = _rxInStream->readShort(); + + _rxInStream >> m_sName; + + ::rtl::OUString sAggregateProp; + _rxInStream >> sAggregateProp; + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_DATASOURCE, makeAny(sAggregateProp)); + _rxInStream >> sAggregateProp; + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_COMMAND, makeAny(sAggregateProp)); + + _rxInStream >> m_aMasterFields; + _rxInStream >> m_aDetailFields; + + sal_Int16 nCursorSourceType = _rxInStream->readShort(); + sal_Int32 nCommandType = 0; + switch ((DataSelectionType)nCursorSourceType) + { + case DataSelectionType_TABLE : nCommandType = CommandType::TABLE; break; + case DataSelectionType_QUERY : nCommandType = CommandType::QUERY; break; + case DataSelectionType_SQL: + case DataSelectionType_SQLPASSTHROUGH: + { + nCommandType = CommandType::COMMAND; + sal_Bool bEscapeProcessing = ((DataSelectionType)nCursorSourceType) != DataSelectionType_SQLPASSTHROUGH; + m_xAggregateSet->setPropertyValue(PROPERTY_ESCAPE_PROCESSING, makeAny((sal_Bool)bEscapeProcessing)); + } + break; + default : DBG_ERROR("ODatabaseForm::read : wrong CommandType !"); + } + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_COMMANDTYPE, makeAny(nCommandType)); + + // obsolete + _rxInStream->readShort(); + + // navigation mode was a boolean in version 1 + // war in der version 1 ein sal_Bool + sal_Bool bNavigation = _rxInStream->readBoolean(); + if (nVersion == 1) + m_eNavigation = bNavigation ? NavigationBarMode_CURRENT : NavigationBarMode_NONE; + + sal_Bool bInsertOnly = _rxInStream->readBoolean(); + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_INSERTONLY, makeAny(bInsertOnly)); + + m_bAllowInsert = _rxInStream->readBoolean(); + m_bAllowUpdate = _rxInStream->readBoolean(); + m_bAllowDelete = _rxInStream->readBoolean(); + + // html stuff + ::rtl::OUString sTmp; + _rxInStream >> sTmp; + m_aTargetURL = INetURLObject::decode( sTmp, '%', INetURLObject::DECODE_UNAMBIGUOUS); + m_eSubmitMethod = (FormSubmitMethod)_rxInStream->readShort(); + m_eSubmitEncoding = (FormSubmitEncoding)_rxInStream->readShort(); + _rxInStream >> m_aTargetFrame; + + if (nVersion > 1) + { + sal_Int32 nCycle = _rxInStream->readShort(); + m_aCycle = ::cppu::int2enum(nCycle, ::getCppuType(static_cast<const TabulatorCycle*>(NULL))); + m_eNavigation = (NavigationBarMode)_rxInStream->readShort(); + + _rxInStream >> sAggregateProp; + setPropertyValue(PROPERTY_FILTER, makeAny(sAggregateProp)); + + _rxInStream >> sAggregateProp; + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_SORT, makeAny(sAggregateProp)); + } + + sal_uInt16 nAnyMask = 0; + if (nVersion > 2) + { + nAnyMask = _rxInStream->readShort(); + if (nAnyMask & CYCLE) + { + sal_Int32 nCycle = _rxInStream->readShort(); + m_aCycle = ::cppu::int2enum(nCycle, ::getCppuType(static_cast<const TabulatorCycle*>(NULL))); + } + else + m_aCycle.clear(); + } + if (m_xAggregateSet.is()) + m_xAggregateSet->setPropertyValue(PROPERTY_APPLYFILTER, makeAny((sal_Bool)((nAnyMask & DONTAPPLYFILTER) == 0))); +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::implInserted( const ElementDescription* _pElement ) +{ + OFormComponents::implInserted( _pElement ); + + Reference< XSQLErrorBroadcaster > xBroadcaster( _pElement->xInterface, UNO_QUERY ); + Reference< XForm > xForm ( _pElement->xInterface, UNO_QUERY ); + + if ( xBroadcaster.is() && !xForm.is() ) + { // the object is an error broadcaster, but no form itself -> add ourself as listener + xBroadcaster->addSQLErrorListener( this ); + } +} + +//------------------------------------------------------------------------------ +void ODatabaseForm::implRemoved(const InterfaceRef& _rxObject) +{ + OFormComponents::implRemoved( _rxObject ); + + Reference<XSQLErrorBroadcaster> xBroadcaster(_rxObject, UNO_QUERY); + Reference<XForm> xForm(_rxObject, UNO_QUERY); + if (xBroadcaster.is() && !xForm.is()) + { // the object is an error broadcaster, but no form itself -> remove ourself as listener + xBroadcaster->removeSQLErrorListener(this); + } +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::errorOccured(const SQLErrorEvent& _rEvent) throw( RuntimeException ) +{ + // give it to my own error listener + onError(_rEvent); + // TODO : think about extending the chain with an SQLContext object saying + // "this was an error of one of my children" +} + +// com::sun::star::container::XNamed +//------------------------------------------------------------------------------ +::rtl::OUString SAL_CALL ODatabaseForm::getName() throw( RuntimeException ) +{ + ::rtl::OUString sReturn; + OPropertySetHelper::getFastPropertyValue(PROPERTY_ID_NAME) >>= sReturn; + return sReturn; +} + +//------------------------------------------------------------------------------ +void SAL_CALL ODatabaseForm::setName(const ::rtl::OUString& aName) throw( RuntimeException ) +{ + setFastPropertyValue(PROPERTY_ID_NAME, makeAny(aName)); +} + +//......................................................................... +} // namespace frm +//......................................................................... + |