/************************************************************** * * 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_ucb.hxx" #include #include #include #include "osl/diagnose.h" #include #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBBUTE_HPP_ #include #endif #include #include #include #include #include #include #include #include #include #include #include "filglob.hxx" #include "filid.hxx" #include "filrow.hxx" #include "bc.hxx" #include "prov.hxx" #ifndef _FILERROR_HXX_ #include "filerror.hxx" #endif #include "filinsreq.hxx" using namespace fileaccess; using namespace com::sun::star; using namespace com::sun::star::uno; using namespace com::sun::star::ucb; // PropertyListeners typedef cppu::OMultiTypeInterfaceContainerHelperVar< rtl::OUString,hashOUString,equalOUString > PropertyListeners_impl; class fileaccess::PropertyListeners : public PropertyListeners_impl { public: PropertyListeners( ::osl::Mutex& aMutex ) : PropertyListeners_impl( aMutex ) { } }; /****************************************************************************************/ /* */ /* BaseContent */ /* */ /****************************************************************************************/ //////////////////////////////////////////////////////////////////////////////// // Private Constructor for just inserted Contents BaseContent::BaseContent( shell* pMyShell, const rtl::OUString& parentName, sal_Bool bFolder ) : m_pMyShell( pMyShell ), m_xContentIdentifier( 0 ), m_aUncPath( parentName ), m_bFolder( bFolder ), m_nState( JustInserted ), m_pDisposeEventListeners( 0 ), m_pContentEventListeners( 0 ), m_pPropertySetInfoChangeListeners( 0 ), m_pPropertyListener( 0 ) { m_pMyShell->m_pProvider->acquire(); // No registering, since we have no name } //////////////////////////////////////////////////////////////////////////////// // Constructor for full featured Contents BaseContent::BaseContent( shell* pMyShell, const Reference< XContentIdentifier >& xContentIdentifier, const rtl::OUString& aUncPath ) : m_pMyShell( pMyShell ), m_xContentIdentifier( xContentIdentifier ), m_aUncPath( aUncPath ), m_bFolder( false ), m_nState( FullFeatured ), m_pDisposeEventListeners( 0 ), m_pContentEventListeners( 0 ), m_pPropertySetInfoChangeListeners( 0 ), m_pPropertyListener( 0 ) { m_pMyShell->m_pProvider->acquire(); m_pMyShell->registerNotifier( m_aUncPath,this ); m_pMyShell->insertDefaultProperties( m_aUncPath ); } BaseContent::~BaseContent( ) { if( ( m_nState & FullFeatured ) || ( m_nState & Deleted ) ) { m_pMyShell->deregisterNotifier( m_aUncPath,this ); } m_pMyShell->m_pProvider->release(); delete m_pDisposeEventListeners; delete m_pContentEventListeners; delete m_pPropertyListener; delete m_pPropertySetInfoChangeListeners; } ////////////////////////////////////////////////////////////////////////// // XInterface ////////////////////////////////////////////////////////////////////////// void SAL_CALL BaseContent::acquire( void ) throw() { OWeakObject::acquire(); } void SAL_CALL BaseContent::release( void ) throw() { OWeakObject::release(); } Any SAL_CALL BaseContent::queryInterface( const Type& rType ) throw( RuntimeException ) { Any aRet = cppu::queryInterface( rType, SAL_STATIC_CAST( lang::XComponent*, this ), SAL_STATIC_CAST( lang::XTypeProvider*, this ), SAL_STATIC_CAST( lang::XServiceInfo*, this ), SAL_STATIC_CAST( XCommandProcessor*, this ), SAL_STATIC_CAST( container::XChild*, this ), SAL_STATIC_CAST( beans::XPropertiesChangeNotifier*, this ), SAL_STATIC_CAST( beans::XPropertyContainer*, this ), SAL_STATIC_CAST( XContentCreator*,this ), SAL_STATIC_CAST( beans::XPropertySetInfoChangeNotifier*, this ), SAL_STATIC_CAST( XContent*,this) ); return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ); } ////////////////////////////////////////////////////////////////////////////////////////// // XComponent //////////////////////////////////////////////////////////////////////////////////////// void SAL_CALL BaseContent::addEventListener( const Reference< lang::XEventListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if ( ! m_pDisposeEventListeners ) m_pDisposeEventListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); m_pDisposeEventListeners->addInterface( Listener ); } void SAL_CALL BaseContent::removeEventListener( const Reference< lang::XEventListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if ( m_pDisposeEventListeners ) m_pDisposeEventListeners->removeInterface( Listener ); } void SAL_CALL BaseContent::dispose() throw( RuntimeException ) { lang::EventObject aEvt; cppu::OInterfaceContainerHelper* pDisposeEventListeners; cppu::OInterfaceContainerHelper* pContentEventListeners; cppu::OInterfaceContainerHelper* pPropertySetInfoChangeListeners; PropertyListeners* pPropertyListener; { osl::MutexGuard aGuard( m_aMutex ); aEvt.Source = static_cast< XContent* >( this ); pDisposeEventListeners = m_pDisposeEventListeners, m_pDisposeEventListeners = 0; pContentEventListeners = m_pContentEventListeners, m_pContentEventListeners = 0; pPropertySetInfoChangeListeners = m_pPropertySetInfoChangeListeners, m_pPropertySetInfoChangeListeners = 0; pPropertyListener = m_pPropertyListener, m_pPropertyListener = 0; } if ( pDisposeEventListeners && pDisposeEventListeners->getLength() ) pDisposeEventListeners->disposeAndClear( aEvt ); if ( pContentEventListeners && pContentEventListeners->getLength() ) pContentEventListeners->disposeAndClear( aEvt ); if( pPropertyListener ) pPropertyListener->disposeAndClear( aEvt ); if( pPropertySetInfoChangeListeners ) pPropertySetInfoChangeListeners->disposeAndClear( aEvt ); delete pDisposeEventListeners; delete pContentEventListeners; delete pPropertyListener; delete pPropertySetInfoChangeListeners; } ////////////////////////////////////////////////////////////////////////////////////////// // XServiceInfo ////////////////////////////////////////////////////////////////////////////////////////// rtl::OUString SAL_CALL BaseContent::getImplementationName() throw( RuntimeException) { return rtl::OUString::createFromAscii( "com.sun.star.comp.ucb.FileContent" ); } sal_Bool SAL_CALL BaseContent::supportsService( const rtl::OUString& ServiceName ) throw( RuntimeException) { if( ServiceName.compareToAscii( "com.sun.star.ucb.FileContent" ) == 0 ) return true; else return false; } Sequence< rtl::OUString > SAL_CALL BaseContent::getSupportedServiceNames() throw( RuntimeException ) { Sequence< rtl::OUString > ret( 1 ); ret[0] = rtl::OUString::createFromAscii( "com.sun.star.ucb.FileContent" ); return ret; } ////////////////////////////////////////////////////////////////////////////////////////// // XTypeProvider ////////////////////////////////////////////////////////////////////////////////////////// XTYPEPROVIDER_IMPL_10( BaseContent, lang::XComponent, lang::XTypeProvider, lang::XServiceInfo, XCommandProcessor, XContentCreator, XContent, container::XChild, beans::XPropertiesChangeNotifier, beans::XPropertyContainer, beans::XPropertySetInfoChangeNotifier ) ////////////////////////////////////////////////////////////////////////////////////////// // XCommandProcessor ////////////////////////////////////////////////////////////////////////////////////////// sal_Int32 SAL_CALL BaseContent::createCommandIdentifier( void ) throw( RuntimeException ) { return m_pMyShell->getCommandId(); } void SAL_CALL BaseContent::abort( sal_Int32 CommandId ) throw( RuntimeException ) { m_pMyShell->abort( CommandId ); } Any SAL_CALL BaseContent::execute( const Command& aCommand, sal_Int32 CommandId, const Reference< XCommandEnvironment >& Environment ) throw( Exception, CommandAbortedException, RuntimeException ) { if( ! CommandId ) // A Command with commandid zero cannot be aborted CommandId = createCommandIdentifier(); m_pMyShell->startTask( CommandId, Environment ); Any aAny; if( ! aCommand.Name.compareToAscii( "getPropertySetInfo" ) ) // No exceptions { aAny <<= getPropertySetInfo( CommandId ); } else if( ! aCommand.Name.compareToAscii( "getCommandInfo" ) ) // no exceptions { aAny <<= getCommandInfo(); } else if( ! aCommand.Name.compareToAscii( "setPropertyValues" ) ) { Sequence< beans::PropertyValue > sPropertyValues; if( ! ( aCommand.Argument >>= sPropertyValues ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT ); else aAny <<= setPropertyValues( CommandId,sPropertyValues ); // calls endTask by itself } else if( ! aCommand.Name.compareToAscii( "getPropertyValues" ) ) { Sequence< beans::Property > ListOfRequestedProperties; if( ! ( aCommand.Argument >>= ListOfRequestedProperties ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT ); else aAny <<= getPropertyValues( CommandId, ListOfRequestedProperties ); } else if( ! aCommand.Name.compareToAscii( "open" ) ) { OpenCommandArgument2 aOpenArgument; if( ! ( aCommand.Argument >>= aOpenArgument ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_OPEN_ARGUMENT ); else { Reference< XDynamicResultSet > result = open( CommandId,aOpenArgument ); if( result.is() ) aAny <<= result; } } else if( ! aCommand.Name.compareToAscii( "delete" ) ) { if( ! aCommand.Argument.has< sal_Bool >() ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_DELETE_ARGUMENT ); else deleteContent( CommandId ); } else if( ! aCommand.Name.compareToAscii( "transfer" ) ) { TransferInfo aTransferInfo; if( ! ( aCommand.Argument >>= aTransferInfo ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_TRANSFER_ARGUMENT ); else transfer( CommandId, aTransferInfo ); } else if( ! aCommand.Name.compareToAscii( "insert" ) ) { InsertCommandArgument aInsertArgument; if( ! ( aCommand.Argument >>= aInsertArgument ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_INSERT_ARGUMENT ); else insert( CommandId,aInsertArgument ); } else if( ! aCommand.Name.compareToAscii( "getCasePreservingURL" ) ) { Sequence< beans::Property > seq(1); seq[0] = beans::Property( rtl::OUString::createFromAscii("CasePreservingURL"), -1, getCppuType( static_cast< sal_Bool* >(0) ), 0 ); Reference< sdbc::XRow > xRow = getPropertyValues( CommandId,seq ); rtl::OUString CasePreservingURL = xRow->getString(1); if(!xRow->wasNull()) aAny <<= CasePreservingURL; } else if( ! aCommand.Name.compareToAscii( "createNewContent" ) ) { ucb::ContentInfo aArg; if ( !( aCommand.Argument >>= aArg ) ) m_pMyShell->installError( CommandId, TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT ); else aAny <<= createNewContent( aArg ); } else m_pMyShell->installError( CommandId, TASKHANDLER_UNSUPPORTED_COMMAND ); // This is the only function allowed to throw an exception endTask( CommandId ); return aAny; } void SAL_CALL BaseContent::addPropertiesChangeListener( const Sequence< rtl::OUString >& PropertyNames, const Reference< beans::XPropertiesChangeListener >& Listener ) throw( RuntimeException ) { if( ! Listener.is() ) return; osl::MutexGuard aGuard( m_aMutex ); if( ! m_pPropertyListener ) m_pPropertyListener = new PropertyListeners( m_aEventListenerMutex ); if( PropertyNames.getLength() == 0 ) m_pPropertyListener->addInterface( rtl::OUString(),Listener ); else { Reference< beans::XPropertySetInfo > xProp = m_pMyShell->info_p( m_aUncPath ); for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i ) if( xProp->hasPropertyByName( PropertyNames[i] ) ) m_pPropertyListener->addInterface( PropertyNames[i],Listener ); } } void SAL_CALL BaseContent::removePropertiesChangeListener( const Sequence< rtl::OUString >& PropertyNames, const Reference< beans::XPropertiesChangeListener >& Listener ) throw( RuntimeException ) { if( ! Listener.is() ) return; osl::MutexGuard aGuard( m_aMutex ); if( ! m_pPropertyListener ) return; for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i ) m_pPropertyListener->removeInterface( PropertyNames[i],Listener ); m_pPropertyListener->removeInterface( rtl::OUString(), Listener ); } ///////////////////////////////////////////////////////////////////////////////////////// // XContent ///////////////////////////////////////////////////////////////////////////////////////// Reference< ucb::XContentIdentifier > SAL_CALL BaseContent::getIdentifier() throw( RuntimeException ) { return m_xContentIdentifier; } rtl::OUString SAL_CALL BaseContent::getContentType() throw( RuntimeException ) { if( !( m_nState & Deleted ) ) { if( m_nState & JustInserted ) { if ( m_bFolder ) return m_pMyShell->FolderContentType; else return m_pMyShell->FileContentType; } else { try { // Who am I ? Sequence< beans::Property > seq(1); seq[0] = beans::Property( rtl::OUString::createFromAscii("IsDocument"), -1, getCppuType( static_cast< sal_Bool* >(0) ), 0 ); Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq ); sal_Bool IsDocument = xRow->getBoolean( 1 ); if ( !xRow->wasNull() ) { if ( IsDocument ) return m_pMyShell->FileContentType; else return m_pMyShell->FolderContentType; } else { OSL_ENSURE( false, "BaseContent::getContentType - Property value was null!" ); } } catch ( sdbc::SQLException const & ) { OSL_ENSURE( false, "BaseContent::getContentType - Caught SQLException!" ); } } } return rtl::OUString(); } void SAL_CALL BaseContent::addContentEventListener( const Reference< XContentEventListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if ( ! m_pContentEventListeners ) m_pContentEventListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); m_pContentEventListeners->addInterface( Listener ); } void SAL_CALL BaseContent::removeContentEventListener( const Reference< XContentEventListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if ( m_pContentEventListeners ) m_pContentEventListeners->removeInterface( Listener ); } //////////////////////////////////////////////////////////////////////////////// // XPropertyContainer //////////////////////////////////////////////////////////////////////////////// void SAL_CALL BaseContent::addProperty( const rtl::OUString& Name, sal_Int16 Attributes, const Any& DefaultValue ) throw( beans::PropertyExistException, beans::IllegalTypeException, lang::IllegalArgumentException, RuntimeException) { if( ( m_nState & JustInserted ) || ( m_nState & Deleted ) || Name == rtl::OUString() ) { throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); } m_pMyShell->associate( m_aUncPath,Name,DefaultValue,Attributes ); } void SAL_CALL BaseContent::removeProperty( const rtl::OUString& Name ) throw( beans::UnknownPropertyException, beans::NotRemoveableException, RuntimeException) { if( m_nState & Deleted ) throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); m_pMyShell->deassociate( m_aUncPath, Name ); } //////////////////////////////////////////////////////////////////////////////// // XContentCreator //////////////////////////////////////////////////////////////////////////////// Sequence< ContentInfo > SAL_CALL BaseContent::queryCreatableContentsInfo( void ) throw( RuntimeException ) { return m_pMyShell->queryCreatableContentsInfo(); } Reference< XContent > SAL_CALL BaseContent::createNewContent( const ContentInfo& Info ) throw( RuntimeException ) { // Check type. if ( !Info.Type.getLength() ) return Reference< XContent >(); sal_Bool bFolder = ( Info.Type.compareTo( m_pMyShell->FolderContentType ) == 0 ); if ( !bFolder ) { if ( Info.Type.compareTo( m_pMyShell->FileContentType ) != 0 ) { // Neither folder nor file to create! return Reference< XContent >(); } } // Who am I ? sal_Bool IsDocument = false; try { Sequence< beans::Property > seq(1); seq[0] = beans::Property( rtl::OUString::createFromAscii("IsDocument"), -1, getCppuType( static_cast< sal_Bool* >(0) ), 0 ); Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq ); IsDocument = xRow->getBoolean( 1 ); if ( xRow->wasNull() ) { IsDocument = false; // OSL_ENSURE( false, // "BaseContent::createNewContent - Property value was null!" ); // return Reference< XContent >(); } } catch ( sdbc::SQLException const & ) { OSL_ENSURE( false, "BaseContent::createNewContent - Caught SQLException!" ); return Reference< XContent >(); } rtl::OUString dstUncPath; if( IsDocument ) { // KSO: Why is a document a XContentCreator? This is quite unusual. dstUncPath = getParentName( m_aUncPath ); } else dstUncPath = m_aUncPath; BaseContent* p = new BaseContent( m_pMyShell, dstUncPath, bFolder ); return Reference< XContent >( p ); } //////////////////////////////////////////////////////////////////////////////// // XPropertySetInfoChangeNotifier //////////////////////////////////////////////////////////////////////////////// void SAL_CALL BaseContent::addPropertySetInfoChangeListener( const Reference< beans::XPropertySetInfoChangeListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if( ! m_pPropertySetInfoChangeListeners ) m_pPropertySetInfoChangeListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); m_pPropertySetInfoChangeListeners->addInterface( Listener ); } void SAL_CALL BaseContent::removePropertySetInfoChangeListener( const Reference< beans::XPropertySetInfoChangeListener >& Listener ) throw( RuntimeException ) { osl::MutexGuard aGuard( m_aMutex ); if( m_pPropertySetInfoChangeListeners ) m_pPropertySetInfoChangeListeners->removeInterface( Listener ); } //////////////////////////////////////////////////////////////////////////////// // XChild //////////////////////////////////////////////////////////////////////////////// Reference< XInterface > SAL_CALL BaseContent::getParent( void ) throw( RuntimeException ) { rtl::OUString ParentUnq = getParentName( m_aUncPath ); rtl::OUString ParentUrl; sal_Bool err = m_pMyShell->getUrlFromUnq( ParentUnq, ParentUrl ); if( err ) return Reference< XInterface >( 0 ); FileContentIdentifier* p = new FileContentIdentifier( m_pMyShell,ParentUnq ); Reference< XContentIdentifier > Identifier( p ); try { Reference< XContent > content = m_pMyShell->m_pProvider->queryContent( Identifier ); return Reference(content,UNO_QUERY); } catch( IllegalIdentifierException ) { return Reference< XInterface >(); } } void SAL_CALL BaseContent::setParent( const Reference< XInterface >& ) throw( lang::NoSupportException, RuntimeException) { throw lang::NoSupportException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); } ////////////////////////////////////////////////////////////////////////////////////////// // Private Methods ////////////////////////////////////////////////////////////////////////////////////////// Reference< XCommandInfo > SAL_CALL BaseContent::getCommandInfo() throw( RuntimeException ) { if( m_nState & Deleted ) return Reference< XCommandInfo >(); return m_pMyShell->info_c(); } Reference< beans::XPropertySetInfo > SAL_CALL BaseContent::getPropertySetInfo( sal_Int32 ) throw( RuntimeException ) { if( m_nState & Deleted ) return Reference< beans::XPropertySetInfo >(); return m_pMyShell->info_p( m_aUncPath ); } Reference< sdbc::XRow > SAL_CALL BaseContent::getPropertyValues( sal_Int32 nMyCommandIdentifier, const Sequence< beans::Property >& PropertySet ) throw( RuntimeException ) { sal_Int32 nProps = PropertySet.getLength(); if ( !nProps ) return Reference< sdbc::XRow >(); if( m_nState & Deleted ) { Sequence< Any > aValues( nProps ); return Reference< sdbc::XRow >( new XRow_impl( m_pMyShell, aValues ) ); } if( m_nState & JustInserted ) { Sequence< Any > aValues( nProps ); Any* pValues = aValues.getArray(); const beans::Property* pProps = PropertySet.getConstArray(); for ( sal_Int32 n = 0; n < nProps; ++n ) { const beans::Property& rProp = pProps[ n ]; Any& rValue = pValues[ n ]; if( rProp.Name.compareToAscii( "ContentType" ) == 0 ) { rValue <<= m_bFolder ? m_pMyShell->FolderContentType : m_pMyShell->FileContentType; } else if( rProp.Name.compareToAscii( "IsFolder" ) == 0 ) { rValue <<= m_bFolder; } else if( rProp.Name.compareToAscii( "IsDocument" ) == 0 ) { rValue <<= sal_Bool( !m_bFolder ); } } return Reference< sdbc::XRow >( new XRow_impl( m_pMyShell, aValues ) ); } return m_pMyShell->getv( nMyCommandIdentifier, m_aUncPath, PropertySet ); } Sequence< Any > SAL_CALL BaseContent::setPropertyValues( sal_Int32 nMyCommandIdentifier, const Sequence< beans::PropertyValue >& Values ) throw() { if( m_nState & Deleted ) { // To do return Sequence< Any >( Values.getLength() ); } const rtl::OUString Title = rtl::OUString::createFromAscii( "Title" ); // Special handling for files which have to be inserted if( m_nState & JustInserted ) { for( sal_Int32 i = 0; i < Values.getLength(); ++i ) { if( Values[i].Name == Title ) { rtl::OUString NewTitle; if( Values[i].Value >>= NewTitle ) { if ( m_nState & NameForInsertionSet ) { // User wants to set another Title before "insert". // m_aUncPath contains previous own URI. sal_Int32 nLastSlash = m_aUncPath.lastIndexOf( '/' ); bool bTrailingSlash = false; if ( nLastSlash == m_aUncPath.getLength() - 1 ) { bTrailingSlash = true; nLastSlash = m_aUncPath.lastIndexOf( '/', nLastSlash ); } OSL_ENSURE( nLastSlash != -1, "BaseContent::setPropertyValues: " "Invalid URL!" ); rtl::OUStringBuffer aBuf( m_aUncPath.copy( 0, nLastSlash + 1 ) ); if ( NewTitle.getLength() > 0 ) { aBuf.append( NewTitle ); if ( bTrailingSlash ) aBuf.append( sal_Unicode( '/' ) ); } else { m_nState &= ~NameForInsertionSet; } m_aUncPath = aBuf.makeStringAndClear(); } else { if ( NewTitle.getLength() > 0 ) { // Initial Title before "insert". // m_aUncPath contains parent's URI. if( m_aUncPath.lastIndexOf( sal_Unicode('/') ) != m_aUncPath.getLength() - 1 ) m_aUncPath += rtl::OUString::createFromAscii("/"); m_aUncPath += rtl::Uri::encode( NewTitle, rtl_UriCharClassPchar, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8 ); m_nState |= NameForInsertionSet; } } } } } return Sequence< Any >( Values.getLength() ); } else { Sequence< Any > ret = m_pMyShell->setv( m_aUncPath, // Does not handle Title Values ); // Special handling Title: Setting Title is equivalent to a renaming of the underlying file for( sal_Int32 i = 0; i < Values.getLength(); ++i ) { if( Values[i].Name != Title ) continue; // handled by setv rtl::OUString NewTitle; if( !( Values[i].Value >>= NewTitle ) ) { ret[i] <<= beans::IllegalTypeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); break; } else if( ! NewTitle.getLength() ) { ret[i] <<= lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 0 ); break; } rtl::OUString aDstName = getParentName( m_aUncPath ); if( aDstName.lastIndexOf( sal_Unicode('/') ) != aDstName.getLength() - 1 ) aDstName += rtl::OUString::createFromAscii("/"); aDstName += rtl::Uri::encode( NewTitle, rtl_UriCharClassPchar, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8 ); m_pMyShell->move( nMyCommandIdentifier, // move notifies the childs also; m_aUncPath, aDstName, NameClash::KEEP ); try { endTask( nMyCommandIdentifier ); } catch( const Exception& e ) { ret[i] <<= e; } // NameChanges come back trough a ContentEvent break; // only handling Title } // end for return ret; } } Reference< XDynamicResultSet > SAL_CALL BaseContent::open( sal_Int32 nMyCommandIdentifier, const OpenCommandArgument2& aCommandArgument ) throw() { Reference< XDynamicResultSet > retValue( 0 ); if( ( m_nState & Deleted ) ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND ); } else if( m_nState & JustInserted ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND ); } else { if( aCommandArgument.Mode == OpenMode::DOCUMENT || aCommandArgument.Mode == OpenMode::DOCUMENT_SHARE_DENY_NONE ) { Reference< io::XOutputStream > outputStream( aCommandArgument.Sink,UNO_QUERY ); if( outputStream.is() ) { m_pMyShell->page( nMyCommandIdentifier, m_aUncPath, outputStream ); } sal_Bool bLock = ( aCommandArgument.Mode != OpenMode::DOCUMENT_SHARE_DENY_NONE ); Reference< io::XActiveDataSink > activeDataSink( aCommandArgument.Sink,UNO_QUERY ); if( activeDataSink.is() ) { activeDataSink->setInputStream( m_pMyShell->open( nMyCommandIdentifier, m_aUncPath, bLock ) ); } Reference< io::XActiveDataStreamer > activeDataStreamer( aCommandArgument.Sink,UNO_QUERY ); if( activeDataStreamer.is() ) { activeDataStreamer->setStream( m_pMyShell->open_rw( nMyCommandIdentifier, m_aUncPath, bLock ) ); } } else if ( aCommandArgument.Mode == OpenMode::ALL || aCommandArgument.Mode == OpenMode::FOLDERS || aCommandArgument.Mode == OpenMode::DOCUMENTS ) { retValue = m_pMyShell->ls( nMyCommandIdentifier, m_aUncPath, aCommandArgument.Mode, aCommandArgument.Properties, aCommandArgument.SortingInfo ); } // else if( aCommandArgument.Mode == // OpenMode::DOCUMENT_SHARE_DENY_NONE || // aCommandArgument.Mode == // OpenMode::DOCUMENT_SHARE_DENY_WRITE ) // m_pMyShell->installError( nMyCommandIdentifier, // TASKHANDLING_UNSUPPORTED_OPEN_MODE, // aCommandArgument.Mode); else m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_UNSUPPORTED_OPEN_MODE, aCommandArgument.Mode); } return retValue; } void SAL_CALL BaseContent::deleteContent( sal_Int32 nMyCommandIdentifier ) throw() { if( m_nState & Deleted ) return; if( m_pMyShell->remove( nMyCommandIdentifier,m_aUncPath ) ) { osl::MutexGuard aGuard( m_aMutex ); m_nState |= Deleted; } } void SAL_CALL BaseContent::transfer( sal_Int32 nMyCommandIdentifier, const TransferInfo& aTransferInfo ) throw() { if( m_nState & Deleted ) return; if( aTransferInfo.SourceURL.compareToAscii( "file:",5 ) != 0 ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_TRANSFER_INVALIDSCHEME ); return; } rtl::OUString srcUnc; if( m_pMyShell->getUnqFromUrl( aTransferInfo.SourceURL,srcUnc ) ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_TRANSFER_INVALIDURL ); return; } rtl::OUString srcUncPath = srcUnc; // Determine the new title ! rtl::OUString NewTitle; if( aTransferInfo.NewTitle.getLength() ) NewTitle = rtl::Uri::encode( aTransferInfo.NewTitle, rtl_UriCharClassPchar, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8 ); else NewTitle = srcUncPath.copy( 1 + srcUncPath.lastIndexOf( sal_Unicode('/') ) ); // Is destination a document or a folder ? Sequence< beans::Property > seq(1); seq[0] = beans::Property( rtl::OUString::createFromAscii("IsDocument"), -1, getCppuType( static_cast< sal_Bool* >(0) ), 0 ); Reference< sdbc::XRow > xRow = getPropertyValues( nMyCommandIdentifier,seq ); sal_Bool IsDocument = xRow->getBoolean( 1 ); if( xRow->wasNull() ) { // Destination file type could not be determined m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_TRANSFER_DESTFILETYPE ); return; } rtl::OUString dstUncPath; if( IsDocument ) { // as sibling sal_Int32 lastSlash = m_aUncPath.lastIndexOf( sal_Unicode('/') ); dstUncPath = m_aUncPath.copy(0,lastSlash ); } else // as child dstUncPath = m_aUncPath; dstUncPath += ( rtl::OUString::createFromAscii( "/" ) + NewTitle ); sal_Int32 NameClash = aTransferInfo.NameClash; if( aTransferInfo.MoveData ) m_pMyShell->move( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash ); else m_pMyShell->copy( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash ); } void SAL_CALL BaseContent::insert( sal_Int32 nMyCommandIdentifier, const InsertCommandArgument& aInsertArgument ) throw() { if( m_nState & FullFeatured ) { m_pMyShell->write( nMyCommandIdentifier, m_aUncPath, aInsertArgument.ReplaceExisting, aInsertArgument.Data ); return; } if( ! ( m_nState & JustInserted ) ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND ); return; } // Inserts the content, which has the flag m_bIsFresh if ( !m_nState | !NameForInsertionSet ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_NONAMESET_INSERT_COMMAND ); return; } // Inserting a document or a file? sal_Bool bDocument = false; Sequence< beans::Property > seq(1); seq[0] = beans::Property( rtl::OUString::createFromAscii("IsDocument"), -1, getCppuType( static_cast< sal_Bool* >(0) ), 0 ); Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq ); bool contentTypeSet = true; // is set to false, if contentType not set try { bDocument = xRow->getBoolean( 1 ); if( xRow->wasNull() ) contentTypeSet = false; } catch ( sdbc::SQLException const & ) { OSL_ENSURE( false, "BaseContent::insert - Caught SQLException!" ); contentTypeSet = false; } if( ! contentTypeSet ) { m_pMyShell->installError( nMyCommandIdentifier, TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND ); return; } sal_Bool success = false; if( bDocument ) success = m_pMyShell->mkfil( nMyCommandIdentifier, m_aUncPath, aInsertArgument.ReplaceExisting, aInsertArgument.Data ); else { while( ! success ) { success = m_pMyShell->mkdir( nMyCommandIdentifier, m_aUncPath, aInsertArgument.ReplaceExisting ); if( success ) break; XInteractionRequestImpl *aRequestImpl = new XInteractionRequestImpl( rtl::Uri::decode( getTitle(m_aUncPath), rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8), (cppu::OWeakObject*)this, m_pMyShell,nMyCommandIdentifier); uno::Reference< task::XInteractionRequest > aReq( aRequestImpl ); m_pMyShell->handleTask( nMyCommandIdentifier,aReq ); if( aRequestImpl->aborted() || !aRequestImpl->newName().getLength() ) // means aborting break; // determine new uncpath m_pMyShell->clearError( nMyCommandIdentifier ); m_aUncPath = getParentName( m_aUncPath ); if( m_aUncPath.lastIndexOf( sal_Unicode('/') ) != m_aUncPath.getLength() - 1 ) m_aUncPath += rtl::OUString::createFromAscii("/"); m_aUncPath += rtl::Uri::encode( aRequestImpl->newName(), rtl_UriCharClassPchar, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8 ); } } if ( ! success ) return; FileContentIdentifier* p = new FileContentIdentifier( m_pMyShell,m_aUncPath ); m_xContentIdentifier = Reference< XContentIdentifier >( p ); m_pMyShell->registerNotifier( m_aUncPath,this ); m_pMyShell->insertDefaultProperties( m_aUncPath ); osl::MutexGuard aGuard( m_aMutex ); m_nState = FullFeatured; } void SAL_CALL BaseContent::endTask( sal_Int32 CommandId ) { // This is the only function allowed to throw an exception m_pMyShell->endTask( CommandId,m_aUncPath,this ); } ContentEventNotifier* BaseContent::cDEL( void ) { osl::MutexGuard aGuard( m_aMutex ); m_nState |= Deleted; ContentEventNotifier* p; if( m_pContentEventListeners ) p = new ContentEventNotifier( m_pMyShell, this, m_xContentIdentifier, m_pContentEventListeners->getElements() ); else p = 0; return p; } ContentEventNotifier* BaseContent::cEXC( const rtl::OUString aNewName ) { osl::MutexGuard aGuard( m_aMutex ); Reference< XContentIdentifier > xOldRef = m_xContentIdentifier; m_aUncPath = aNewName; FileContentIdentifier* pp = new FileContentIdentifier( m_pMyShell,aNewName ); m_xContentIdentifier = Reference< XContentIdentifier >( pp ); ContentEventNotifier* p = 0; if( m_pContentEventListeners ) p = new ContentEventNotifier( m_pMyShell, this, m_xContentIdentifier, xOldRef, m_pContentEventListeners->getElements() ); return p; } ContentEventNotifier* BaseContent::cCEL( void ) { osl::MutexGuard aGuard( m_aMutex ); ContentEventNotifier* p = 0; if( m_pContentEventListeners ) p = new ContentEventNotifier( m_pMyShell, this, m_xContentIdentifier, m_pContentEventListeners->getElements() ); return p; } PropertySetInfoChangeNotifier* BaseContent::cPSL( void ) { osl::MutexGuard aGuard( m_aMutex ); PropertySetInfoChangeNotifier* p = 0; if( m_pPropertySetInfoChangeListeners ) p = new PropertySetInfoChangeNotifier( m_pMyShell, this, m_xContentIdentifier, m_pPropertySetInfoChangeListeners->getElements() ); return p; } PropertyChangeNotifier* BaseContent::cPCL( void ) { osl::MutexGuard aGuard( m_aMutex ); Sequence< rtl::OUString > seqNames; if( m_pPropertyListener ) seqNames = m_pPropertyListener->getContainedTypes(); PropertyChangeNotifier* p = 0; sal_Int32 length = seqNames.getLength(); if( length ) { ListenerMap* listener = new ListenerMap(); for( sal_Int32 i = 0; i < length; ++i ) { (*listener)[seqNames[i]] = m_pPropertyListener->getContainer( seqNames[i] )->getElements(); } p = new PropertyChangeNotifier( m_pMyShell, this, m_xContentIdentifier, listener ); } return p; } rtl::OUString BaseContent::getKey( void ) { return m_aUncPath; }