| /************************************************************** |
| * |
| * 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_svx.hxx" |
| #include <svx/dbaexchange.hxx> |
| #include <osl/diagnose.h> |
| #include <com/sun/star/sdb/CommandType.hpp> |
| #include <com/sun/star/sdbcx/XTablesSupplier.hpp> |
| #include <com/sun/star/sdb/XSQLQueryComposerFactory.hpp> |
| #include <com/sun/star/sdb/XSQLQueryComposerFactory.hpp> |
| #ifndef _SVX_FMPROP_HRC |
| #include "fmprop.hrc" |
| #endif |
| #include <comphelper/extract.hxx> |
| #include <sot/formats.hxx> |
| #include <sot/exchange.hxx> |
| #include <comphelper/propertysetinfo.hxx> |
| #ifndef _SVX_FMPROP_HRC |
| #include "fmprop.hrc" |
| #endif |
| #include <tools/urlobj.hxx> |
| |
| //........................................................................ |
| namespace svx |
| { |
| //........................................................................ |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::sdb; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::sdbcx; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::datatransfer; |
| using namespace ::comphelper; |
| |
| //==================================================================== |
| //= OColumnTransferable |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| OColumnTransferable::OColumnTransferable(const ::rtl::OUString& _rDatasource |
| ,const ::rtl::OUString& _rConnectionResource |
| ,const sal_Int32 _nCommandType |
| ,const ::rtl::OUString& _rCommand |
| ,const ::rtl::OUString& _rFieldName |
| ,sal_Int32 _nFormats) |
| :m_nFormatFlags(_nFormats) |
| { |
| implConstruct(_rDatasource,_rConnectionResource,_nCommandType, _rCommand, _rFieldName); |
| } |
| |
| //-------------------------------------------------------------------- |
| OColumnTransferable::OColumnTransferable(const ODataAccessDescriptor& _rDescriptor, sal_Int32 _nFormats ) |
| :m_nFormatFlags(_nFormats) |
| { |
| ::rtl::OUString sDataSource, sDatabaseLocation, sConnectionResource, sCommand, sFieldName; |
| if ( _rDescriptor.has( daDataSource ) ) _rDescriptor[ daDataSource ] >>= sDataSource; |
| if ( _rDescriptor.has( daDatabaseLocation ) ) _rDescriptor[ daDatabaseLocation ] >>= sDatabaseLocation; |
| if ( _rDescriptor.has( daConnectionResource ) ) _rDescriptor[ daConnectionResource ] >>= sConnectionResource; |
| if ( _rDescriptor.has( daCommand ) ) _rDescriptor[ daCommand ] >>= sCommand; |
| if ( _rDescriptor.has( daColumnName ) ) _rDescriptor[ daColumnName ] >>= sFieldName; |
| |
| sal_Int32 nCommandType = CommandType::TABLE; |
| OSL_VERIFY( _rDescriptor[ daCommandType ] >>= nCommandType ); |
| |
| |
| implConstruct( |
| sDataSource.getLength() ? sDataSource : sDatabaseLocation, |
| sConnectionResource, nCommandType, sCommand, sFieldName ); |
| |
| if ( m_nFormatFlags & CTF_COLUMN_DESCRIPTOR ) |
| { |
| if ( _rDescriptor.has( daConnection ) ) |
| m_aDescriptor[ daConnection ] = _rDescriptor[ daConnection ]; |
| if ( _rDescriptor.has( daColumnObject ) ) |
| m_aDescriptor[ daColumnObject ] = _rDescriptor[ daColumnObject ]; |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| OColumnTransferable::OColumnTransferable(const Reference< XPropertySet >& _rxForm, |
| const ::rtl::OUString& _rFieldName, const Reference< XPropertySet >& _rxColumn, |
| const Reference< XConnection >& _rxConnection, sal_Int32 _nFormats) |
| :m_nFormatFlags(_nFormats) |
| { |
| OSL_ENSURE(_rxForm.is(), "OColumnTransferable::OColumnTransferable: invalid form!"); |
| // collect the necessary information from the form |
| ::rtl::OUString sCommand; |
| sal_Int32 nCommandType = CommandType::TABLE; |
| ::rtl::OUString sDatasource,sURL; |
| |
| sal_Bool bTryToParse = sal_True; |
| try |
| { |
| _rxForm->getPropertyValue(FM_PROP_COMMANDTYPE) >>= nCommandType; |
| _rxForm->getPropertyValue(FM_PROP_COMMAND) >>= sCommand; |
| _rxForm->getPropertyValue(FM_PROP_DATASOURCE) >>= sDatasource; |
| _rxForm->getPropertyValue(FM_PROP_URL) >>= sURL; |
| bTryToParse = ::cppu::any2bool(_rxForm->getPropertyValue(FM_PROP_ESCAPE_PROCESSING)); |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(sal_False, "OColumnTransferable::OColumnTransferable: could not collect essential data source attributes !"); |
| } |
| |
| // If the data source is an SQL-statement and simple enough (means "select <field list> from <table> where ....") |
| // we are able to fake the drag information we are about to create. |
| if (bTryToParse && (CommandType::COMMAND == nCommandType)) |
| { |
| try |
| { |
| Reference< XTablesSupplier > xSupTab; |
| _rxForm->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SingleSelectQueryComposer"))) >>= xSupTab; |
| |
| if(xSupTab.is()) |
| { |
| Reference< XNameAccess > xNames = xSupTab->getTables(); |
| if (xNames.is()) |
| { |
| Sequence< ::rtl::OUString > aTables = xNames->getElementNames(); |
| if (1 == aTables.getLength()) |
| { |
| sCommand = aTables[0]; |
| nCommandType = CommandType::TABLE; |
| } |
| } |
| } |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(sal_False, "OColumnTransferable::OColumnTransferable: could not collect essential data source attributes (part two) !"); |
| } |
| } |
| |
| implConstruct(sDatasource, sURL,nCommandType, sCommand, _rFieldName); |
| |
| if ((m_nFormatFlags & CTF_COLUMN_DESCRIPTOR) == CTF_COLUMN_DESCRIPTOR) |
| { |
| if (_rxColumn.is()) |
| m_aDescriptor[daColumnObject] <<= _rxColumn; |
| if (_rxConnection.is()) |
| m_aDescriptor[daConnection] <<= _rxConnection; |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_uInt32 OColumnTransferable::getDescriptorFormatId() |
| { |
| static sal_uInt32 s_nFormat = (sal_uInt32)-1; |
| if ((sal_uInt32)-1 == s_nFormat) |
| { |
| s_nFormat = SotExchange::RegisterFormatName(String::CreateFromAscii("application/x-openoffice;windows_formatname=\"dbaccess.ColumnDescriptorTransfer\"")); |
| OSL_ENSURE((sal_uInt32)-1 != s_nFormat, "OColumnTransferable::getDescriptorFormatId: bad exchange id!"); |
| } |
| return s_nFormat; |
| } |
| |
| //-------------------------------------------------------------------- |
| void OColumnTransferable::implConstruct( const ::rtl::OUString& _rDatasource |
| ,const ::rtl::OUString& _rConnectionResource |
| ,const sal_Int32 _nCommandType |
| ,const ::rtl::OUString& _rCommand |
| , const ::rtl::OUString& _rFieldName) |
| { |
| const sal_Unicode cSeparator = sal_Unicode(11); |
| const ::rtl::OUString sSeparator(&cSeparator, 1); |
| |
| m_sCompatibleFormat = ::rtl::OUString(); |
| m_sCompatibleFormat += _rDatasource; |
| m_sCompatibleFormat += sSeparator; |
| m_sCompatibleFormat += _rCommand; |
| m_sCompatibleFormat += sSeparator; |
| |
| sal_Unicode cCommandType; |
| switch (_nCommandType) |
| { |
| case CommandType::TABLE: |
| cCommandType = '0'; |
| break; |
| case CommandType::QUERY: |
| cCommandType = '1'; |
| break; |
| default: |
| cCommandType = '2'; |
| break; |
| } |
| m_sCompatibleFormat += ::rtl::OUString(&cCommandType, 1); |
| m_sCompatibleFormat += sSeparator; |
| m_sCompatibleFormat += _rFieldName; |
| |
| m_aDescriptor.clear(); |
| if ((m_nFormatFlags & CTF_COLUMN_DESCRIPTOR) == CTF_COLUMN_DESCRIPTOR) |
| { |
| m_aDescriptor.setDataSource(_rDatasource); |
| if ( _rConnectionResource.getLength() ) |
| m_aDescriptor[daConnectionResource] <<= _rConnectionResource; |
| |
| m_aDescriptor[daCommand] <<= _rCommand; |
| m_aDescriptor[daCommandType] <<= _nCommandType; |
| m_aDescriptor[daColumnName] <<= _rFieldName; |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void OColumnTransferable::AddSupportedFormats() |
| { |
| if (CTF_CONTROL_EXCHANGE & m_nFormatFlags) |
| AddFormat(SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE); |
| |
| if (CTF_FIELD_DESCRIPTOR & m_nFormatFlags) |
| AddFormat(SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE); |
| |
| if (CTF_COLUMN_DESCRIPTOR & m_nFormatFlags) |
| AddFormat(getDescriptorFormatId()); |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Bool OColumnTransferable::GetData( const DataFlavor& _rFlavor ) |
| { |
| const sal_uInt32 nFormatId = SotExchange::GetFormat(_rFlavor); |
| switch (nFormatId) |
| { |
| case SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE: |
| case SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE: |
| return SetString(m_sCompatibleFormat, _rFlavor); |
| } |
| if (nFormatId == getDescriptorFormatId()) |
| return SetAny( makeAny( m_aDescriptor.createPropertyValueSequence() ), _rFlavor ); |
| |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Bool OColumnTransferable::canExtractColumnDescriptor(const DataFlavorExVector& _rFlavors, sal_Int32 _nFormats) |
| { |
| sal_Bool bFieldFormat = 0 != (_nFormats & CTF_FIELD_DESCRIPTOR); |
| sal_Bool bControlFormat = 0 != (_nFormats & CTF_CONTROL_EXCHANGE); |
| sal_Bool bDescriptorFormat = 0 != (_nFormats & CTF_COLUMN_DESCRIPTOR); |
| for ( DataFlavorExVector::const_iterator aCheck = _rFlavors.begin(); |
| aCheck != _rFlavors.end(); |
| ++aCheck |
| ) |
| { |
| if (bFieldFormat && (SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE == aCheck->mnSotId)) |
| return sal_True; |
| if (bControlFormat && (SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE == aCheck->mnSotId)) |
| return sal_True; |
| if (bDescriptorFormat && (getDescriptorFormatId() == aCheck->mnSotId)) |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| ODataAccessDescriptor OColumnTransferable::extractColumnDescriptor(const TransferableDataHelper& _rData) |
| { |
| if (_rData.HasFormat(getDescriptorFormatId())) |
| { |
| // the object has a real descriptor object (not just the old compatible format) |
| |
| // extract the any from the transferable |
| DataFlavor aFlavor; |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Bool bSuccess = |
| #endif |
| SotExchange::GetFormatDataFlavor(getDescriptorFormatId(), aFlavor); |
| OSL_ENSURE(bSuccess, "OColumnTransferable::extractColumnDescriptor: invalid data format (no flavor)!"); |
| |
| Any aDescriptor = _rData.GetAny(aFlavor); |
| |
| // extract the property value sequence |
| Sequence< PropertyValue > aDescriptorProps; |
| #if OSL_DEBUG_LEVEL > 0 |
| bSuccess = |
| #endif |
| aDescriptor >>= aDescriptorProps; |
| OSL_ENSURE(bSuccess, "OColumnTransferable::extractColumnDescriptor: invalid clipboard format!"); |
| |
| // build the real descriptor |
| return ODataAccessDescriptor(aDescriptorProps); |
| } |
| |
| // only the old (compatible) format exists -> use the other extract method ... |
| ::rtl::OUString sDatasource, sCommand, sFieldName,sDatabaseLocation,sConnectionResource; |
| sal_Int32 nCommandType = CommandType::COMMAND; |
| |
| ODataAccessDescriptor aDescriptor; |
| if (extractColumnDescriptor(_rData, sDatasource, sDatabaseLocation,sConnectionResource,nCommandType, sCommand, sFieldName)) |
| { |
| // and build an own descriptor |
| if ( sDatasource.getLength() ) |
| aDescriptor[daDataSource] <<= sDatasource; |
| if ( sDatabaseLocation.getLength() ) |
| aDescriptor[daDatabaseLocation] <<= sDatabaseLocation; |
| if ( sConnectionResource.getLength() ) |
| aDescriptor[daConnectionResource] <<= sConnectionResource; |
| |
| aDescriptor[daCommand] <<= sCommand; |
| aDescriptor[daCommandType] <<= nCommandType; |
| aDescriptor[daColumnName] <<= sFieldName; |
| } |
| return aDescriptor; |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Bool OColumnTransferable::extractColumnDescriptor(const TransferableDataHelper& _rData |
| ,::rtl::OUString& _rDatasource |
| ,::rtl::OUString& _rDatabaseLocation |
| ,::rtl::OUString& _rConnectionResource |
| ,sal_Int32& _nCommandType |
| ,::rtl::OUString& _rCommand |
| ,::rtl::OUString& _rFieldName) |
| { |
| if ( _rData.HasFormat(getDescriptorFormatId()) ) |
| { |
| ODataAccessDescriptor aDescriptor = extractColumnDescriptor(_rData); |
| if ( aDescriptor.has(daDataSource) ) |
| aDescriptor[daDataSource] >>= _rDatasource; |
| if ( aDescriptor.has(daDatabaseLocation) ) |
| aDescriptor[daDatabaseLocation] >>= _rDatabaseLocation; |
| if ( aDescriptor.has(daConnectionResource) ) |
| aDescriptor[daConnectionResource] >>= _rConnectionResource; |
| |
| aDescriptor[daCommand] >>= _rCommand; |
| aDescriptor[daCommandType] >>= _nCommandType; |
| aDescriptor[daColumnName] >>= _rFieldName; |
| return sal_True; |
| } |
| |
| // check if we have a (string) format we can use .... |
| SotFormatStringId nRecognizedFormat = 0; |
| if (_rData.HasFormat(SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE)) |
| nRecognizedFormat = SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE; |
| if (_rData.HasFormat(SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE)) |
| nRecognizedFormat = SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE; |
| if (!nRecognizedFormat) |
| return sal_False; |
| |
| String sFieldDescription; |
| const_cast<TransferableDataHelper&>(_rData).GetString(nRecognizedFormat, sFieldDescription); |
| |
| const sal_Unicode cSeparator = sal_Unicode(11); |
| _rDatasource = sFieldDescription.GetToken(0, cSeparator); |
| _rCommand = sFieldDescription.GetToken(1, cSeparator); |
| _nCommandType = sFieldDescription.GetToken(2, cSeparator).ToInt32(); |
| _rFieldName = sFieldDescription.GetToken(3, cSeparator); |
| |
| return sal_True; |
| } |
| |
| //-------------------------------------------------------------------- |
| void OColumnTransferable::addDataToContainer( TransferDataContainer* _pContainer ) |
| { |
| OSL_ENSURE( _pContainer, "OColumnTransferable::addDataToContainer: invalid container!" ); |
| if ( _pContainer ) |
| { |
| if ( m_nFormatFlags & CTF_FIELD_DESCRIPTOR ) |
| _pContainer->CopyAny( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE, makeAny( m_sCompatibleFormat ) ); |
| |
| if ( m_nFormatFlags & CTF_CONTROL_EXCHANGE ) |
| _pContainer->CopyAny( SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE, makeAny( m_sCompatibleFormat ) ); |
| |
| if ( m_nFormatFlags & CTF_COLUMN_DESCRIPTOR ) |
| { |
| Any aContent = makeAny( m_aDescriptor.createPropertyValueSequence() ); |
| _pContainer->CopyAny( |
| sal::static_int_cast< sal_uInt16 >( getDescriptorFormatId() ), |
| aContent ); |
| } |
| } |
| } |
| |
| //==================================================================== |
| //= ODataAccessObjectTransferable |
| //==================================================================== |
| ODataAccessObjectTransferable::ODataAccessObjectTransferable( |
| const ::rtl::OUString& _rDatasource |
| ,const ::rtl::OUString& _rConnectionResource |
| ,const sal_Int32 _nCommandType |
| ,const ::rtl::OUString& _rCommand |
| ) |
| { |
| construct(_rDatasource,_rConnectionResource,_nCommandType,_rCommand,NULL,(CommandType::COMMAND == _nCommandType),_rCommand); |
| } |
| //-------------------------------------------------------------------- |
| ODataAccessObjectTransferable::ODataAccessObjectTransferable( |
| const ::rtl::OUString& _rDatasource |
| ,const ::rtl::OUString& _rConnectionResource |
| ,const sal_Int32 _nCommandType |
| ,const ::rtl::OUString& _rCommand |
| ,const Reference< XConnection >& _rxConnection) |
| { |
| OSL_ENSURE(_rxConnection.is(),"Wrong ctor used.!"); |
| construct(_rDatasource,_rConnectionResource,_nCommandType,_rCommand,_rxConnection,(CommandType::COMMAND == _nCommandType),_rCommand); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| ODataAccessObjectTransferable::ODataAccessObjectTransferable(const Reference< XPropertySet >& _rxLivingForm) |
| { |
| // collect some properties of the form |
| ::rtl::OUString sDatasourceName,sConnectionResource; |
| sal_Int32 nObjectType = CommandType::COMMAND; |
| ::rtl::OUString sObjectName; |
| Reference< XConnection > xConnection; |
| try |
| { |
| _rxLivingForm->getPropertyValue(FM_PROP_COMMANDTYPE) >>= nObjectType; |
| _rxLivingForm->getPropertyValue(FM_PROP_COMMAND) >>= sObjectName; |
| _rxLivingForm->getPropertyValue(FM_PROP_DATASOURCE) >>= sDatasourceName; |
| _rxLivingForm->getPropertyValue(FM_PROP_URL) >>= sConnectionResource; |
| _rxLivingForm->getPropertyValue(FM_PROP_ACTIVE_CONNECTION) >>= xConnection; |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(sal_False, "ODataAccessObjectTransferable::ODataAccessObjectTransferable: could not collect essential form attributes !"); |
| return; |
| } |
| |
| String sObjectKind = (CommandType::TABLE == nObjectType) ? String('1') : String('0'); |
| |
| // check if the SQL-statement is modified |
| ::rtl::OUString sCompleteStatement; |
| try |
| { |
| _rxLivingForm->getPropertyValue(FM_PROP_ACTIVECOMMAND) >>= sCompleteStatement; |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(sal_False, "ODataAccessObjectTransferable::ODataAccessObjectTransferable: could not collect essential form attributes (part two) !"); |
| return; |
| } |
| |
| construct( sDatasourceName |
| ,sConnectionResource |
| ,nObjectType |
| ,sObjectName,xConnection |
| ,!((CommandType::QUERY == nObjectType)) |
| ,sCompleteStatement); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ODataAccessObjectTransferable::AddSupportedFormats() |
| { |
| sal_Int32 nObjectType = CommandType::COMMAND; |
| m_aDescriptor[daCommandType] >>= nObjectType; |
| switch (nObjectType) |
| { |
| case CommandType::TABLE: |
| AddFormat(SOT_FORMATSTR_ID_DBACCESS_TABLE); |
| break; |
| case CommandType::QUERY: |
| AddFormat(SOT_FORMATSTR_ID_DBACCESS_QUERY); |
| break; |
| case CommandType::COMMAND: |
| AddFormat(SOT_FORMATSTR_ID_DBACCESS_COMMAND); |
| break; |
| } |
| |
| sal_Int32 nDescriptorLen = m_sCompatibleObjectDescription.getLength(); |
| if (nDescriptorLen) |
| { |
| if (m_sCompatibleObjectDescription.getStr()[nDescriptorLen] == 11) |
| m_sCompatibleObjectDescription = m_sCompatibleObjectDescription.copy(0, nDescriptorLen - 1); |
| |
| if (nDescriptorLen) |
| AddFormat(SOT_FORMATSTR_ID_SBA_DATAEXCHANGE); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ODataAccessObjectTransferable::GetData( const DataFlavor& rFlavor ) |
| { |
| sal_uIntPtr nFormat = SotExchange::GetFormat(rFlavor); |
| switch (nFormat) |
| { |
| case SOT_FORMATSTR_ID_DBACCESS_TABLE: |
| case SOT_FORMATSTR_ID_DBACCESS_QUERY: |
| case SOT_FORMATSTR_ID_DBACCESS_COMMAND: |
| return SetAny( makeAny(m_aDescriptor.createPropertyValueSequence()), rFlavor ); |
| |
| case SOT_FORMATSTR_ID_SBA_DATAEXCHANGE: |
| return SetString(m_sCompatibleObjectDescription, rFlavor); |
| } |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| sal_Bool ODataAccessObjectTransferable::canExtractObjectDescriptor(const DataFlavorExVector& _rFlavors) |
| { |
| for ( DataFlavorExVector::const_iterator aCheck = _rFlavors.begin(); |
| aCheck != _rFlavors.end(); |
| ++aCheck |
| ) |
| { |
| if (SOT_FORMATSTR_ID_DBACCESS_TABLE == aCheck->mnSotId) |
| return sal_True; |
| if (SOT_FORMATSTR_ID_DBACCESS_QUERY == aCheck->mnSotId) |
| return sal_True; |
| if (SOT_FORMATSTR_ID_DBACCESS_COMMAND == aCheck->mnSotId) |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| ODataAccessDescriptor ODataAccessObjectTransferable::extractObjectDescriptor(const TransferableDataHelper& _rData) |
| { |
| sal_Int32 nKnownFormatId = 0; |
| if ( _rData.HasFormat( SOT_FORMATSTR_ID_DBACCESS_TABLE ) ) |
| nKnownFormatId = SOT_FORMATSTR_ID_DBACCESS_TABLE; |
| if ( _rData.HasFormat( SOT_FORMATSTR_ID_DBACCESS_QUERY ) ) |
| nKnownFormatId = SOT_FORMATSTR_ID_DBACCESS_QUERY; |
| if ( _rData.HasFormat( SOT_FORMATSTR_ID_DBACCESS_COMMAND ) ) |
| nKnownFormatId = SOT_FORMATSTR_ID_DBACCESS_COMMAND; |
| |
| if (0 != nKnownFormatId) |
| { |
| // extract the any from the transferable |
| DataFlavor aFlavor; |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Bool bSuccess = |
| #endif |
| SotExchange::GetFormatDataFlavor(nKnownFormatId, aFlavor); |
| OSL_ENSURE(bSuccess, "OColumnTransferable::extractColumnDescriptor: invalid data format (no flavor)!"); |
| |
| Any aDescriptor = _rData.GetAny(aFlavor); |
| |
| // extract the property value sequence |
| Sequence< PropertyValue > aDescriptorProps; |
| #if OSL_DEBUG_LEVEL > 0 |
| bSuccess = |
| #endif |
| aDescriptor >>= aDescriptorProps; |
| OSL_ENSURE(bSuccess, "OColumnTransferable::extractColumnDescriptor: invalid clipboard format!"); |
| |
| // build the real descriptor |
| return ODataAccessDescriptor(aDescriptorProps); |
| } |
| |
| OSL_ENSURE( sal_False, "OColumnTransferable::extractColumnDescriptor: unsupported formats only!" ); |
| return ODataAccessDescriptor(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ODataAccessObjectTransferable::addCompatibleSelectionDescription( const Sequence< Any >& _rSelRows ) |
| { |
| const sal_Unicode cSeparator(11); |
| const ::rtl::OUString sSeparator(&cSeparator, 1); |
| |
| const Any* pSelRows = _rSelRows.getConstArray(); |
| const Any* pSelRowsEnd = pSelRows + _rSelRows.getLength(); |
| for ( ; pSelRows < pSelRowsEnd; ++pSelRows ) |
| { |
| sal_Int32 nSelectedRow( 0 ); |
| OSL_VERIFY( *pSelRows >>= nSelectedRow ); |
| |
| m_sCompatibleObjectDescription += ::rtl::OUString::valueOf((sal_Int32)nSelectedRow); |
| m_sCompatibleObjectDescription += sSeparator; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ODataAccessObjectTransferable::ObjectReleased() |
| { |
| m_aDescriptor.clear(); |
| } |
| // ----------------------------------------------------------------------------- |
| void ODataAccessObjectTransferable::construct( const ::rtl::OUString& _rDatasource |
| ,const ::rtl::OUString& _rConnectionResource |
| ,const sal_Int32 _nCommandType |
| ,const ::rtl::OUString& _rCommand |
| ,const Reference< XConnection >& _rxConnection |
| ,sal_Bool _bAddCommand |
| ,const ::rtl::OUString& _sActiveCommand) |
| { |
| m_aDescriptor.setDataSource(_rDatasource); |
| // build the descriptor (the property sequence) |
| if ( _rConnectionResource.getLength() ) |
| m_aDescriptor[daConnectionResource] <<= _rConnectionResource; |
| if ( _rxConnection.is() ) |
| m_aDescriptor[daConnection] <<= _rxConnection; |
| m_aDescriptor[daCommand] <<= _rCommand; |
| m_aDescriptor[daCommandType] <<= _nCommandType; |
| |
| // extract the single values from the sequence |
| |
| ::rtl::OUString sObjectName; |
| ::rtl::OUString sDatasourceName = _rDatasource; |
| sObjectName = _rCommand; |
| |
| // for compatibility: create a string which can be used for the SOT_FORMATSTR_ID_SBA_DATAEXCHANGE format |
| |
| sal_Bool bTreatAsStatement = (CommandType::COMMAND == _nCommandType); |
| // statements are - in this old and ugly format - described as queries |
| |
| const sal_Unicode cSeparator = sal_Unicode(11); |
| const ::rtl::OUString sSeparator(&cSeparator, 1); |
| |
| const sal_Unicode cTableMark = '1'; |
| const sal_Unicode cQueryMark = '0'; |
| |
| // build the descriptor string |
| m_sCompatibleObjectDescription += sDatasourceName; |
| m_sCompatibleObjectDescription += sSeparator; |
| m_sCompatibleObjectDescription += bTreatAsStatement ? ::rtl::OUString() : sObjectName; |
| m_sCompatibleObjectDescription += sSeparator; |
| switch (_nCommandType) |
| { |
| case CommandType::TABLE: |
| m_sCompatibleObjectDescription += ::rtl::OUString(&cTableMark, 1); |
| break; |
| case CommandType::QUERY: |
| m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1); |
| break; |
| case CommandType::COMMAND: |
| m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1); |
| // think of it as a query |
| break; |
| } |
| m_sCompatibleObjectDescription += sSeparator; |
| m_sCompatibleObjectDescription += _bAddCommand ? _sActiveCommand : ::rtl::OUString(); |
| m_sCompatibleObjectDescription += sSeparator; |
| } |
| |
| //-------------------------------------------------------------------- |
| OMultiColumnTransferable::OMultiColumnTransferable(const Sequence< PropertyValue >& _aDescriptors) : m_aDescriptors(_aDescriptors) |
| { |
| } |
| //-------------------------------------------------------------------- |
| sal_uInt32 OMultiColumnTransferable::getDescriptorFormatId() |
| { |
| static sal_uInt32 s_nFormat = (sal_uInt32)-1; |
| if ((sal_uInt32)-1 == s_nFormat) |
| { |
| s_nFormat = SotExchange::RegisterFormatName(String::CreateFromAscii("application/x-openoffice;windows_formatname=\"dbaccess.MultipleColumnDescriptorTransfer\"")); |
| OSL_ENSURE((sal_uInt32)-1 != s_nFormat, "OColumnTransferable::getDescriptorFormatId: bad exchange id!"); |
| } |
| return s_nFormat; |
| } |
| //-------------------------------------------------------------------- |
| void OMultiColumnTransferable::AddSupportedFormats() |
| { |
| AddFormat(getDescriptorFormatId()); |
| } |
| //-------------------------------------------------------------------- |
| void OMultiColumnTransferable::push_back(ODataAccessDescriptor& _aDescriptor) |
| { |
| const sal_Int32 nCount = m_aDescriptors.getLength(); |
| m_aDescriptors.realloc(nCount+1); |
| m_aDescriptors[nCount].Value <<= _aDescriptor.createPropertyValueSequence(); |
| } |
| //-------------------------------------------------------------------- |
| sal_Bool OMultiColumnTransferable::GetData( const DataFlavor& _rFlavor ) |
| { |
| const sal_uInt32 nFormatId = SotExchange::GetFormat(_rFlavor); |
| if (nFormatId == getDescriptorFormatId()) |
| { |
| return SetAny( makeAny( m_aDescriptors ), _rFlavor ); |
| } |
| |
| return sal_False; |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Bool OMultiColumnTransferable::canExtractDescriptor(const DataFlavorExVector& _rFlavors) |
| { |
| DataFlavorExVector::const_iterator aCheck = _rFlavors.begin(); |
| for ( ; |
| aCheck != _rFlavors.end() && getDescriptorFormatId() == aCheck->mnSotId; |
| ++aCheck |
| ) |
| ; |
| |
| return aCheck == _rFlavors.end(); |
| } |
| |
| //-------------------------------------------------------------------- |
| Sequence< PropertyValue > OMultiColumnTransferable::extractDescriptor(const TransferableDataHelper& _rData) |
| { |
| Sequence< PropertyValue > aList; |
| if (_rData.HasFormat(getDescriptorFormatId())) |
| { |
| // extract the any from the transferable |
| DataFlavor aFlavor; |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Bool bSuccess = |
| #endif |
| SotExchange::GetFormatDataFlavor(getDescriptorFormatId(), aFlavor); |
| OSL_ENSURE(bSuccess, "OColumnTransferable::extractColumnDescriptor: invalid data format (no flavor)!"); |
| |
| _rData.GetAny(aFlavor) >>= aList; |
| } // if (_rData.HasFormat(getDescriptorFormatId())) |
| return aList; |
| } |
| // ----------------------------------------------------------------------------- |
| void OMultiColumnTransferable::ObjectReleased() |
| { |
| m_aDescriptors.realloc(0); |
| } |
| |
| //........................................................................ |
| } // namespace svx |
| //........................................................................ |
| |
| |