/************************************************************** * * 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_unotools.hxx" #include "unotools/ucbhelper.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "unotools/localfilehelper.hxx" using namespace ucbhelper; using namespace com::sun::star; using namespace com::sun::star::beans; using namespace com::sun::star::container; using namespace com::sun::star::lang; using namespace com::sun::star::sdbc; using namespace com::sun::star::task; using namespace com::sun::star::uno; using namespace com::sun::star::ucb; using namespace rtl; using namespace comphelper; using namespace osl; DECLARE_LIST( StringList_Impl, OUString* ) #define CONVERT_DATETIME( aUnoDT, aToolsDT ) \ aToolsDT = DateTime( Date( aUnoDT.Day, aUnoDT.Month, aUnoDT.Year ), \ Time( aUnoDT.Hours, aUnoDT.Minutes, aUnoDT.Seconds, aUnoDT.HundredthSeconds ) ); namespace utl { sal_Bool UCBContentHelper::Transfer_Impl( const String& rSource, const String& rDest, sal_Bool bMoveData, sal_Int32 nNameClash ) { sal_Bool bRet = sal_True, bKillSource = sal_False; INetURLObject aSourceObj( rSource ); DBG_ASSERT( aSourceObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); INetURLObject aDestObj( rDest ); DBG_ASSERT( aDestObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); if ( bMoveData && aSourceObj.GetProtocol() != aDestObj.GetProtocol() ) { bMoveData = sal_False; bKillSource = sal_True; } String aName = aDestObj.getName(); aDestObj.removeSegment(); aDestObj.setFinalSlash(); try { Content aDestPath( aDestObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); uno::Reference< ::com::sun::star::ucb::XCommandInfo > xInfo = aDestPath.getCommands(); OUString aTransferName = OUString::createFromAscii( "transfer" ); if ( xInfo->hasCommandByName( aTransferName ) ) { aDestPath.executeCommand( aTransferName, makeAny( ::com::sun::star::ucb::TransferInfo( bMoveData, aSourceObj.GetMainURL( INetURLObject::NO_DECODE ), aName, nNameClash ) ) ); } else { DBG_ERRORFILE( "transfer command not available" ); } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { bRet = sal_False; } catch( ::com::sun::star::uno::Exception& ) { bRet = sal_False; } if ( bKillSource ) UCBContentHelper::Kill( rSource ); return bRet; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::IsDocument( const String& rContent ) { sal_Bool bRet = sal_False; INetURLObject aObj( rContent ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); bRet = aCnt.isDocument(); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { DBG_WARNING( "CommandAbortedException" ); } catch( ::com::sun::star::ucb::IllegalIdentifierException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ContentCreationException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ::com::sun::star::uno::Exception& ) { DBG_WARNING( "Any other exception" ); } return bRet; } // ----------------------------------------------------------------------- Any UCBContentHelper::GetProperty( const String& rContent, const ::rtl::OUString& rName ) { INetURLObject aObj( rContent ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); return aCnt.getPropertyValue( rName ); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { DBG_WARNING( "CommandAbortedException" ); } catch( ::com::sun::star::ucb::IllegalIdentifierException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ContentCreationException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ::com::sun::star::uno::Exception& ) { DBG_WARNING( "Any other exception" ); } return Any(); } sal_Bool UCBContentHelper::IsFolder( const String& rContent ) { sal_Bool bRet = sal_False; INetURLObject aObj( rContent ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); bRet = aCnt.isFolder(); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { DBG_WARNING( "CommandAbortedException" ); } catch( ::com::sun::star::ucb::IllegalIdentifierException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ContentCreationException& ) { DBG_WARNING( "IllegalIdentifierException" ); } catch( ::com::sun::star::uno::Exception& ) { DBG_WARNING( "Any other exception" ); } return bRet; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::GetTitle( const String& rContent, String& rTitle ) { sal_Bool bRet = sal_False; INetURLObject aObj( rContent ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); OUString aTemp; if ( aCnt.getPropertyValue( OUString::createFromAscii( "Title" ) ) >>= aTemp ) { rTitle = String( aTemp ); bRet = sal_True; } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } return bRet; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::Kill( const String& rContent ) { sal_Bool bRet = sal_True; INetURLObject aDeleteObj( rContent ); DBG_ASSERT( aDeleteObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aDeleteObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); aCnt.executeCommand( OUString::createFromAscii( "delete" ), makeAny( sal_Bool( sal_True ) ) ); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { DBG_WARNING( "CommandAbortedException" ); bRet = sal_False; } catch( ::com::sun::star::uno::Exception& ) { DBG_WARNING( "Any other exception" ); bRet = sal_False; } return bRet; } // ----------------------------------------------------------------------- Sequence < OUString > UCBContentHelper::GetFolderContents( const String& rFolder, sal_Bool bFolder, sal_Bool bSorted ) { StringList_Impl* pFiles = NULL; INetURLObject aFolderObj( rFolder ); DBG_ASSERT( aFolderObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aFolderObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); uno::Reference< XResultSet > xResultSet; Sequence< OUString > aProps( bSorted ? 2 : 1 ); OUString* pProps = aProps.getArray(); pProps[0] = OUString::createFromAscii( "Title" ); if ( bSorted ) pProps[1] = OUString::createFromAscii( "IsFolder" ); try { ResultSetInclude eInclude = bFolder ? INCLUDE_FOLDERS_AND_DOCUMENTS : INCLUDE_DOCUMENTS_ONLY; if ( !bSorted ) { xResultSet = aCnt.createCursor( aProps, eInclude ); } else { uno::Reference< com::sun::star::ucb::XDynamicResultSet > xDynResultSet; xDynResultSet = aCnt.createDynamicCursor( aProps, eInclude ); uno::Reference < com::sun::star::ucb::XAnyCompareFactory > xFactory; uno::Reference < XMultiServiceFactory > xMgr = getProcessServiceFactory(); uno::Reference < com::sun::star::ucb::XSortedDynamicResultSetFactory > xSRSFac( xMgr->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.ucb.SortedDynamicResultSetFactory") ), UNO_QUERY ); Sequence< com::sun::star::ucb::NumberedSortingInfo > aSortInfo( 2 ); com::sun::star::ucb::NumberedSortingInfo* pInfo = aSortInfo.getArray(); pInfo[ 0 ].ColumnIndex = 2; pInfo[ 0 ].Ascending = sal_False; pInfo[ 1 ].ColumnIndex = 1; pInfo[ 1 ].Ascending = sal_True; uno::Reference< com::sun::star::ucb::XDynamicResultSet > xDynamicResultSet; xDynamicResultSet = xSRSFac->createSortedDynamicResultSet( xDynResultSet, aSortInfo, xFactory ); if ( xDynamicResultSet.is() ) { xResultSet = xDynamicResultSet->getStaticResultSet(); } } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { // folder not exists? } catch( ::com::sun::star::uno::Exception& ) { } if ( xResultSet.is() ) { pFiles = new StringList_Impl; uno::Reference< com::sun::star::ucb::XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); try { while ( xResultSet->next() ) { OUString aId = xContentAccess->queryContentIdentifierString(); OUString* pFile = new OUString( aId ); pFiles->Insert( pFile, LIST_APPEND ); } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } } } catch( ::com::sun::star::uno::Exception& ) { } if ( pFiles ) { sal_uLong nCount = pFiles->Count(); Sequence < OUString > aRet( nCount ); OUString* pRet = aRet.getArray(); for ( sal_uLong i = 0; i < nCount; ++i ) { OUString* pFile = pFiles->GetObject(i); pRet[i] = *( pFile ); delete pFile; } delete pFiles; return aRet; } else return Sequence < OUString > (); } // ----------------------------------------------------------------------- Sequence < OUString > UCBContentHelper::GetResultSet( const String& rURL ) { StringList_Impl* pList = NULL; try { Content aCnt( rURL, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() ); uno::Reference< XResultSet > xResultSet; uno::Reference< com::sun::star::ucb::XDynamicResultSet > xDynResultSet; Sequence< OUString > aProps(3); OUString* pProps = aProps.getArray(); pProps[0] = OUString::createFromAscii( "Title" ); pProps[1] = OUString::createFromAscii( "ContentType" ); // TODO: can be optimized, property never used: pProps[2] = OUString::createFromAscii( "IsFolder" ); try { xDynResultSet = aCnt.createDynamicCursor( aProps, INCLUDE_FOLDERS_AND_DOCUMENTS ); if ( xDynResultSet.is() ) xResultSet = xDynResultSet->getStaticResultSet(); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } if ( xResultSet.is() ) { pList = new StringList_Impl; uno::Reference< com::sun::star::sdbc::XRow > xRow( xResultSet, UNO_QUERY ); uno::Reference< com::sun::star::ucb::XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); try { while ( xResultSet->next() ) { String aTitle( xRow->getString(1) ); String aType( xRow->getString(2) ); String aRow = aTitle; aRow += '\t'; aRow += aType; aRow += '\t'; aRow += String( xContentAccess->queryContentIdentifierString() ); OUString* pRow = new OUString( aRow ); pList->Insert( pRow, LIST_APPEND ); } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } } } catch( ::com::sun::star::uno::Exception& ) { } if ( pList ) { sal_uLong nCount = pList->Count(); Sequence < OUString > aRet( nCount ); OUString* pRet = aRet.getArray(); for ( sal_uLong i = 0; i < nCount; ++i ) { OUString* pEntry = pList->GetObject(i); pRet[i] = *( pEntry ); delete pEntry; } delete pList; return aRet; } else return Sequence < OUString > (); } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::CopyTo( const String& rSource, const String& rDest ) { return Transfer_Impl( rSource, rDest, sal_False, NameClash::ERROR ); } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::MoveTo( const String& rSource, const String& rDest, sal_Int32 nNameClash ) { return Transfer_Impl( rSource, rDest, sal_True, nNameClash ); } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::CanMakeFolder( const String& rFolder ) { try { Content aCnt( rFolder, uno::Reference< XCommandEnvironment > () ); Sequence< ContentInfo > aInfo = aCnt.queryCreatableContentsInfo(); sal_Int32 nCount = aInfo.getLength(); if ( nCount == 0 ) return sal_False; for ( sal_Int32 i = 0; i < nCount; ++i ) { // Simply look for the first KIND_FOLDER... const ContentInfo & rCurr = aInfo[i]; if ( rCurr.Attributes & ContentInfoAttribute::KIND_FOLDER ) return sal_True; } } catch( ::com::sun::star::ucb::CommandAbortedException& ) {} catch( RuntimeException& ) {} catch( Exception& ) {} return sal_False; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::MakeFolder( const String& rFolder, sal_Bool bNewOnly ) { INetURLObject aURL( rFolder ); DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); String aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ); aURL.removeSegment(); Content aCnt; Content aNew; uno::Reference< XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory(); uno::Reference< XInteractionHandler > xInteractionHandler = uno::Reference< XInteractionHandler > ( xFactory->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uui.InteractionHandler") ) ), UNO_QUERY ); if ( Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ), new CommandEnvironment( xInteractionHandler, uno::Reference< XProgressHandler >() ), aCnt ) ) return MakeFolder( aCnt, aTitle, aNew, bNewOnly ); else return sal_False; } sal_Bool UCBContentHelper::MakeFolder( Content& aCnt, const String& aTitle, Content& rNew, sal_Bool bNewOnly ) { sal_Bool bAlreadyExists = sal_False; try { Sequence< ContentInfo > aInfo = aCnt.queryCreatableContentsInfo(); sal_Int32 nCount = aInfo.getLength(); if ( nCount == 0 ) return sal_False; for ( sal_Int32 i = 0; i < nCount; ++i ) { // Simply look for the first KIND_FOLDER... const ContentInfo & rCurr = aInfo[i]; if ( rCurr.Attributes & ContentInfoAttribute::KIND_FOLDER ) { // Make sure the only required bootstrap property is "Title", const Sequence< Property > & rProps = rCurr.Properties; if ( rProps.getLength() != 1 ) continue; if ( !rProps[ 0 ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) ) continue; Sequence aNames(1); OUString* pNames = aNames.getArray(); pNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ); Sequence aValues(1); Any* pValues = aValues.getArray(); pValues[0] = makeAny( OUString( aTitle ) ); if ( !aCnt.insertNewContent( rCurr.Type, aNames, aValues, rNew ) ) continue; return sal_True; } } } catch ( InteractiveIOException& r ) { if ( r.Code == IOErrorCode_ALREADY_EXISTING ) { bAlreadyExists = sal_True; } } catch ( NameClashException& ) { bAlreadyExists = sal_True; } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( RuntimeException& ) { } catch( Exception& ) { } if( bAlreadyExists && !bNewOnly ) { INetURLObject aObj( aCnt.getURL() ); aObj.Append( aTitle ); rNew = Content( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference < XCommandEnvironment >() ); return sal_True; } return sal_False; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::HasParentFolder( const String& rFolder ) { sal_Bool bRet = sal_False; try { Content aCnt( rFolder, uno::Reference< XCommandEnvironment > () ); uno::Reference< XChild > xChild( aCnt.get(), UNO_QUERY ); if ( xChild.is() ) { uno::Reference< XContent > xParent( xChild->getParent(), UNO_QUERY ); if ( xParent.is() ) { String aParentURL = String( xParent->getIdentifier()->getContentIdentifier() ); bRet = ( aParentURL.Len() > 0 && aParentURL != rFolder ); } } } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } return bRet; } // ----------------------------------------------------------------------- sal_uLong UCBContentHelper::GetSize( const String& rContent ) { sal_uLong nSize = 0; sal_Int64 nTemp = 0; INetURLObject aObj( rContent ); DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); aCnt.getPropertyValue( OUString::createFromAscii( "Size" ) ) >>= nTemp; } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } nSize = (sal_uInt32)nTemp; return nSize; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::IsYounger( const String& rIsYoung, const String& rIsOlder ) { DateTime aYoungDate, aOlderDate; INetURLObject aYoungObj( rIsYoung ); DBG_ASSERT( aYoungObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); INetURLObject aOlderObj( rIsOlder ); DBG_ASSERT( aOlderObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" ); try { uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > aCmdEnv; Content aYoung( aYoungObj.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv ); ::com::sun::star::util::DateTime aTempYoungDate; aYoung.getPropertyValue( OUString::createFromAscii( "DateModified" ) ) >>= aTempYoungDate; CONVERT_DATETIME( aTempYoungDate, aYoungDate ); Content aOlder( aOlderObj.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv ); ::com::sun::star::util::DateTime aTempOlderDate; aOlder.getPropertyValue( OUString::createFromAscii( "DateModified" ) ) >>= aTempOlderDate; CONVERT_DATETIME( aTempOlderDate, aOlderDate ); } catch( ::com::sun::star::ucb::CommandAbortedException& ) { } catch( ::com::sun::star::uno::Exception& ) { } return ( aYoungDate > aOlderDate ); } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::Find( const String& rFolder, const String& rName, String& rFile, sal_Bool bAllowWildCards ) { sal_Bool bWild = bAllowWildCards && ( rName.Search( '*' ) != STRING_NOTFOUND || rName.Search( '?' ) != STRING_NOTFOUND ); sal_Bool bRet = sal_False; // get a list of URLs for all children of rFolder Sequence< ::rtl::OUString > aFiles = GetFolderContents( rFolder, sal_False ); const ::rtl::OUString* pFiles = aFiles.getConstArray(); sal_uInt32 i, nCount = aFiles.getLength(); for ( i = 0; i < nCount; ++i ) { // get the last name of the URLs and compare it with rName INetURLObject aFileObject( pFiles[i] ); String aFile = aFileObject.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ).toAsciiLowerCase(); if ( (bWild && WildCard( rName ).Matches( aFile )) || aFile == rName ) { // names match rFile = aFileObject.GetMainURL( INetURLObject::NO_DECODE ); bRet = sal_True; break; } } return bRet; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::Exists( const String& rURL ) { String sObjectPhysicalName; sal_Bool bIsLocalFile = ::utl::LocalFileHelper::ConvertURLToPhysicalName( rURL, sObjectPhysicalName ); // try to create a directory entry for the URL given if ( bIsLocalFile ) { ::rtl::OUString sIn( sObjectPhysicalName ), sOut; if ( osl_File_E_None == osl_getFileURLFromSystemPath( sIn.pData, &sOut.pData ) ) { // #106526 osl_getDirectoryItem is an existence check // no further osl_getFileStatus call necessary DirectoryItem aItem; return (FileBase::E_None == DirectoryItem::get(sOut, aItem)); } return sal_False; } // divide URL into folder and name part sal_Bool bRet = sal_False; INetURLObject aObj( rURL ); ::rtl::OUString aFileName = aObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ).toAsciiLowerCase(); aObj.removeSegment(); aObj.removeFinalSlash(); // get a list of URLs for all children of rFolder Sequence< ::rtl::OUString > aFiles = GetFolderContents( aObj.GetMainURL( INetURLObject::NO_DECODE ), sal_True, sal_False ); const ::rtl::OUString* pFiles = aFiles.getConstArray(); sal_uInt32 i, nCount = aFiles.getLength(); for ( i = 0; i < nCount; ++i ) { // get the last name of the URLs and compare it with rName INetURLObject aFileObject( pFiles[i] ); ::rtl::OUString aFile = aFileObject.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ).toAsciiLowerCase(); if ( aFile == aFileName ) { // names match bRet = sal_True; break; } } return bRet; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::FindInPath( const String& rPath, const String& rName, String& rFile, char cDelim, sal_Bool bAllowWildCards ) { // extract the single folder names from the path variable and try to find the file in one of these folders sal_uInt16 nTokenCount = rPath.GetTokenCount( cDelim ); for ( sal_uInt16 nToken = 0; nToken < nTokenCount; ++nToken ) { String aPath = rPath.GetToken( nToken, cDelim ); if ( Find( aPath, rName, rFile, bAllowWildCards ) ) return sal_True; } return sal_False; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::IsSubPath( const ::rtl::OUString& rPath, const ::rtl::OUString& rSubfolderCandidate, const uno::Reference< ::com::sun::star::ucb::XContentProvider >& xProv ) { sal_Bool bResult = sal_False; uno::Reference< ::com::sun::star::ucb::XContentProvider > xContentProvider = xProv; // the comparing is done in the following way: // - first compare in case sensitive way // - if name are different try a fallback comparing inf case insensitive way // - if the last comparing succeeded get casepreserving normalized names for the files and compare them // ( the second step is required because retrieving of the normalized names might be very expensive in some cases ) INetURLObject aCandidate( rSubfolderCandidate ); INetURLObject aCandidateLowCase( rSubfolderCandidate.toAsciiLowerCase() ); // will be used for case insensitive comparing INetURLObject aParentFolder( rPath ); INetURLObject aParentFolderLowCase( rPath.toAsciiLowerCase() ); // will be used for case insensitive comparing if ( aCandidate.GetProtocol() == aParentFolder.GetProtocol() ) { if ( !xContentProvider.is() ) { ::ucbhelper::ContentBroker* pBroker = NULL; if ( aCandidate.GetProtocol() == INET_PROT_FILE ) { pBroker = ::ucbhelper::ContentBroker::get(); if ( pBroker ) xContentProvider = pBroker->getContentProviderInterface(); } } INetURLObject aLastTmpObj; do { if ( aParentFolder == aCandidate ) { // if case sensitive comparing succeeded there is no need for additional checks bResult = sal_True; } else if ( xContentProvider.is() && aParentFolderLowCase == aCandidateLowCase ) { // the comparing was done using caseinsensitive way // the case sensitive comparing have failed already // the normalized urls must be retrieved try { uno::Reference< ::com::sun::star::ucb::XContent > xSecCont = xContentProvider->queryContent( uno::Reference< ::com::sun::star::ucb::XContentIdentifierFactory >( xContentProvider, ::com::sun::star::uno::UNO_QUERY_THROW )->createContentIdentifier( aParentFolder.GetMainURL( INetURLObject::NO_DECODE ) ) ); uno::Reference< ::com::sun::star::ucb::XContent > xLocCont = xContentProvider->queryContent( uno::Reference< ::com::sun::star::ucb::XContentIdentifierFactory >( xContentProvider, ::com::sun::star::uno::UNO_QUERY_THROW )->createContentIdentifier( aCandidate.GetMainURL( INetURLObject::NO_DECODE ) ) ); if ( !xSecCont.is() || !xLocCont.is() ) throw ::com::sun::star::uno::RuntimeException(); ::rtl::OUString aSecNormStr; ::rtl::OUString aLocNormStr; bResult = ( ( uno::Reference< ::com::sun::star::ucb::XCommandProcessor >( xSecCont, ::com::sun::star::uno::UNO_QUERY_THROW )->execute( ::com::sun::star::ucb::Command( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getCasePreservingURL" ) ), -1, ::com::sun::star::uno::Any() ), 0, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() ) >>= aSecNormStr ) && ( uno::Reference< ::com::sun::star::ucb::XCommandProcessor >( xLocCont, ::com::sun::star::uno::UNO_QUERY_THROW )->execute( ::com::sun::star::ucb::Command( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getCasePreservingURL" ) ), -1, ::com::sun::star::uno::Any() ), 0, uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() ) >>= aLocNormStr ) && aLocNormStr.equals( aSecNormStr ) ); } catch( ::com::sun::star::uno::Exception& ) {} } // INetURLObject::removeSegment sometimes return true without exchanging URL, // for example in case of "file:///" aLastTmpObj = aCandidate; } while( aCandidate.removeSegment() && aCandidateLowCase.removeSegment() && aCandidate != aLastTmpObj && !bResult ); } return bResult; } // ----------------------------------------------------------------------- sal_Bool UCBContentHelper::EqualURLs( const ::rtl::OUString& aFirstURL, const ::rtl::OUString& aSecondURL ) { sal_Bool bResult = sal_False; if ( aFirstURL.getLength() && aSecondURL.getLength() ) { INetURLObject aFirst( aFirstURL ); INetURLObject aSecond( aSecondURL ); if ( aFirst.GetProtocol() != INET_PROT_NOT_VALID && aSecond.GetProtocol() != INET_PROT_NOT_VALID ) { try { ::ucbhelper::ContentBroker* pBroker = ::ucbhelper::ContentBroker::get(); if ( !pBroker ) throw uno::RuntimeException(); uno::Reference< ::com::sun::star::ucb::XContentIdentifierFactory > xIdFac = pBroker->getContentIdentifierFactoryInterface(); if ( !xIdFac.is() ) throw uno::RuntimeException(); uno::Reference< ::com::sun::star::ucb::XContentIdentifier > xIdFirst = xIdFac->createContentIdentifier( aFirst.GetMainURL( INetURLObject::NO_DECODE ) ); uno::Reference< ::com::sun::star::ucb::XContentIdentifier > xIdSecond = xIdFac->createContentIdentifier( aSecond.GetMainURL( INetURLObject::NO_DECODE ) ); if ( xIdFirst.is() && xIdSecond.is() ) { uno::Reference< ::com::sun::star::ucb::XContentProvider > xProvider = pBroker->getContentProviderInterface(); if ( !xProvider.is() ) throw uno::RuntimeException(); bResult = !xProvider->compareContentIds( xIdFirst, xIdSecond ); } } catch( uno::Exception& ) { OSL_ENSURE( sal_False, "Can't compare URL's, treat as different!\n" ); } } } return bResult; } } // namespace utl