| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_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(sal_Int32) : if we're resetting currently don't fire any changes of the |
| // IsModified property from sal_False to sal_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)40)); |
| |
| // 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 |
| //......................................................................... |
| |
