?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / svtools / source / fsstor / fsstorage.cxx
blobdfcd5c9c1730566fc66de6e03763248223c1228e
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: fsstorage.cxx,v $
10 * $Revision: 1.11 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svtools.hxx"
33 #include <com/sun/star/beans/PropertyValue.hpp>
34 #include <com/sun/star/embed/ElementModes.hpp>
35 #include <com/sun/star/embed/XTransactedObject.hpp>
36 #include <com/sun/star/ucb/XProgressHandler.hpp>
37 #include <com/sun/star/ucb/XContentAccess.hpp>
38 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
39
40 #ifndef _COM_SUN_STAR_UCB_INTERACTIVEIODEXCEPTION_HPP_
41 #include <com/sun/star/ucb/InteractiveIOException.hpp>
42 #endif
43 #include <com/sun/star/ucb/IOErrorCode.hpp>
44 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
45 #include <com/sun/star/container/XEnumerationAccess.hpp>
46 #include <com/sun/star/container/XNamed.hpp>
47 #include <com/sun/star/util/XChangesBatch.hpp>
48 #include <com/sun/star/util/XCloneable.hpp>
49 #include <com/sun/star/lang/XUnoTunnel.hpp>
50 #include <com/sun/star/lang/XComponent.hpp>
51 #include <com/sun/star/lang/DisposedException.hpp>
52 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
53 #include <com/sun/star/io/IOException.hpp>
54 #include <com/sun/star/io/XTruncate.hpp>
55 #include <com/sun/star/sdbc/XResultSet.hpp>
56 #include <com/sun/star/sdbc/XRow.hpp>
57
58
59 #ifndef _COMPHELPER_PROCESSFACTORY_HXX
60 #include <comphelper/processfactory.hxx>
61 #endif
62 #include <comphelper/storagehelper.hxx>
63 #include <cppuhelper/typeprovider.hxx>
64 #include <cppuhelper/exc_hlp.hxx>
65
66 #include <tools/urlobj.hxx>
67 #include <unotools/ucbhelper.hxx>
68 #include <unotools/ucbstreamhelper.hxx>
69 #include <unotools/streamwrap.hxx>
70 #include <ucbhelper/fileidentifierconverter.hxx>
71 #include <ucbhelper/contentbroker.hxx>
72 #include <ucbhelper/content.hxx>
73
74 #include "fsstorage.hxx"
75 #include "oinputstreamcontainer.hxx"
76 #include "ostreamcontainer.hxx"
77
78 using namespace ::com::sun::star;
79
80 //=========================================================
81
82 // TODO: move to a standard helper
83 sal_Bool isLocalFile_Impl( ::rtl::OUString aURL )
84 {
85 ::rtl::OUString aSystemPath;
86 ::ucbhelper::ContentBroker* pBroker = ::ucbhelper::ContentBroker::get();
87 if ( !pBroker )
88 throw uno::RuntimeException();
89
90 uno::Reference< ucb::XContentProviderManager > xManager =
91 pBroker->getContentProviderManagerInterface();
92 try
93 {
94 aSystemPath = ::ucbhelper::getSystemPathFromFileURL( xManager, aURL );
95 }
96 catch ( uno::Exception& )
97 {
98 }
99
100 return ( aSystemPath.getLength() != 0 );
101 }
102
103
104 //=========================================================
105
106 struct FSStorage_Impl
107 {
108 ::rtl::OUString m_aURL;
109
110 ::ucbhelper::Content* m_pContent;
111 sal_Int32 m_nMode;
112
113 ::cppu::OInterfaceContainerHelper* m_pListenersContainer; // list of listeners
114 ::cppu::OTypeCollection* m_pTypeCollection;
115
116 uno::Reference< lang::XMultiServiceFactory > m_xFactory;
117
118
119 FSStorage_Impl( const ::rtl::OUString& aURL, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
120 : m_aURL( aURL )
121 , m_pContent( NULL )
122 , m_nMode( nMode )
123 , m_pListenersContainer( NULL )
124 , m_pTypeCollection( NULL )
125 , m_xFactory( xFactory )
126 {
127 OSL_ENSURE( m_aURL.getLength(), "The URL must not be empty" );
128 }
129
130 FSStorage_Impl( const ::ucbhelper::Content& aContent, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
131 : m_aURL( aContent.getURL() )
132 , m_pContent( new ::ucbhelper::Content( aContent ) )
133 , m_nMode( nMode )
134 , m_pListenersContainer( NULL )
135 , m_pTypeCollection( NULL )
136 , m_xFactory( xFactory )
137 {
138 OSL_ENSURE( m_aURL.getLength(), "The URL must not be empty" );
139 }
140
141 ~FSStorage_Impl();
142 };
143
144 //=========================================================
145
146 FSStorage_Impl::~FSStorage_Impl()
147 {
148 if ( m_pListenersContainer )
149 delete m_pListenersContainer;
150 if ( m_pTypeCollection )
151 delete m_pTypeCollection;
152 if ( m_pContent )
153 delete m_pContent;
154 }
155
156 //=====================================================
157 // FSStorage implementation
158 //=====================================================
159
160 //-----------------------------------------------
161 FSStorage::FSStorage( const ::ucbhelper::Content& aContent,
162 sal_Int32 nMode,
163 uno::Sequence< beans::PropertyValue >,
164 uno::Reference< lang::XMultiServiceFactory > xFactory )
165 : m_pImpl( new FSStorage_Impl( aContent, nMode, xFactory ) )
166 {
167 // TODO: use properties
168 if ( !xFactory.is() )
169 throw uno::RuntimeException();
170
171 GetContent();
172 }
173
174 //-----------------------------------------------
175 FSStorage::~FSStorage()
176 {
177 {
178 ::osl::MutexGuard aGuard( m_aMutex );
179 m_refCount++; // to call dispose
180 try {
181 dispose();
182 }
183 catch( uno::RuntimeException& )
184 {}
185 }
186 }
187
188 //-----------------------------------------------
189 sal_Bool FSStorage::MakeFolderNoUI( const String& rFolder, sal_Bool )
190 {
191 INetURLObject aURL( rFolder );
192 ::rtl::OUString aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
193 aURL.removeSegment();
194 ::ucbhelper::Content aParent;
195 ::ucbhelper::Content aResultContent;
196
197 if ( ::ucbhelper::Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ),
198 uno::Reference< ucb::XCommandEnvironment >(),
199 aParent ) )
200 return ::utl::UCBContentHelper::MakeFolder( aParent, aTitle, aResultContent, sal_False );
201
202 return sal_False;
203 }
204
205 //-----------------------------------------------
206 ::ucbhelper::Content* FSStorage::GetContent()
207 {
208 ::osl::MutexGuard aGuard( m_aMutex );
209 if ( !m_pImpl->m_pContent )
210 {
211 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
212
213 try
214 {
215 m_pImpl->m_pContent = new ::ucbhelper::Content( m_pImpl->m_aURL, xDummyEnv );
216 }
217 catch( uno::Exception& )
218 {
219 }
220 }
221
222 return m_pImpl->m_pContent;
223 }
224
225 //-----------------------------------------------
226 void FSStorage::CopyStreamToSubStream( const ::rtl::OUString& aSourceURL,
227 const uno::Reference< embed::XStorage >& xDest,
228 const ::rtl::OUString& aNewEntryName )
229 {
230 if ( !xDest.is() )
231 throw uno::RuntimeException();
232
233 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
234 ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv );
235 uno::Reference< io::XInputStream > xSourceInput = aSourceContent.openStream();
236
237 if ( !xSourceInput.is() )
238 throw io::IOException(); // TODO: error handling
239
240 uno::Reference< io::XStream > xSubStream = xDest->openStreamElement(
241 aNewEntryName,
242 embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
243 if ( !xSubStream.is() )
244 throw uno::RuntimeException();
245
246 uno::Reference< io::XOutputStream > xDestOutput = xSubStream->getOutputStream();
247 if ( !xDestOutput.is() )
248 throw uno::RuntimeException();
249
250 ::comphelper::OStorageHelper::CopyInputToOutput( xSourceInput, xDestOutput );
251 xDestOutput->closeOutput();
252 }
253
254 //-----------------------------------------------
255 void FSStorage::CopyContentToStorage_Impl( ::ucbhelper::Content* pContent, const uno::Reference< embed::XStorage >& xDest )
256 {
257 if ( !pContent )
258 throw uno::RuntimeException();
259
260 // get list of contents of the Content
261 // create cursor for access to children
262 uno::Sequence< ::rtl::OUString > aProps( 2 );
263 ::rtl::OUString* pProps = aProps.getArray();
264 pProps[0] = ::rtl::OUString::createFromAscii( "TargetURL" );
265 pProps[1] = ::rtl::OUString::createFromAscii( "IsFolder" );
266 ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
267
268 try
269 {
270 uno::Reference< sdbc::XResultSet > xResultSet = pContent->createCursor( aProps, eInclude );
271 uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
272 uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
273 if ( xResultSet.is() )
274 {
275 // go through the list: insert files as streams, insert folders as substorages using recursion
276 while ( xResultSet->next() )
277 {
278 ::rtl::OUString aSourceURL( xRow->getString( 1 ) );
279 sal_Bool bIsFolder( xRow->getBoolean(2) );
280
281 // TODO/LATER: not sure whether the entry name must be encoded
282 ::rtl::OUString aNewEntryName( INetURLObject( aSourceURL ).getName( INetURLObject::LAST_SEGMENT,
283 true,
284 INetURLObject::NO_DECODE ) );
285 if ( bIsFolder )
286 {
287 uno::Reference< embed::XStorage > xSubStorage = xDest->openStorageElement( aNewEntryName,
288 embed::ElementModes::READWRITE );
289 if ( !xSubStorage.is() )
290 throw uno::RuntimeException();
291
292 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
293 ::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv );
294 CopyContentToStorage_Impl( &aSourceContent, xSubStorage );
295 }
296 else
297 {
298 CopyStreamToSubStream( aSourceURL, xDest, aNewEntryName );
299 }
300 }
301 }
302
303 uno::Reference< embed::XTransactedObject > xTransact( xDest, uno::UNO_QUERY );
304 if ( xTransact.is() )
305 xTransact->commit();
306 }
307 catch( ucb::InteractiveIOException& r )
308 {
309 if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
310 OSL_ENSURE( sal_False, "The folder does not exist!\n" );
311 else
312 throw;
313 }
314 }
315
316 //____________________________________________________________________________________________________
317 // XInterface
318 //____________________________________________________________________________________________________
319
320 //-----------------------------------------------
321 uno::Any SAL_CALL FSStorage::queryInterface( const uno::Type& rType )
322 throw( uno::RuntimeException )
323 {
324 uno::Any aReturn;
325 aReturn <<= ::cppu::queryInterface
326 ( rType
327 , static_cast<lang::XTypeProvider*> ( this )
328 , static_cast<embed::XStorage*> ( this )
329 , static_cast<embed::XHierarchicalStorageAccess*> ( this )
330 , static_cast<container::XNameAccess*> ( this )
331 , static_cast<container::XElementAccess*> ( this )
332 , static_cast<lang::XComponent*> ( this )
333 , static_cast<beans::XPropertySet*> ( this ) );
334
335 if ( aReturn.hasValue() == sal_True )
336 return aReturn ;
337
338 return OWeakObject::queryInterface( rType );
339 }
340
341 //-----------------------------------------------
342 void SAL_CALL FSStorage::acquire() throw()
343 {
344 OWeakObject::acquire();
345 }
346
347 //-----------------------------------------------
348 void SAL_CALL FSStorage::release() throw()
349 {
350 OWeakObject::release();
351 }
352
353 //____________________________________________________________________________________________________
354 // XTypeProvider
355 //____________________________________________________________________________________________________
356
357 //-----------------------------------------------
358 uno::Sequence< uno::Type > SAL_CALL FSStorage::getTypes()
359 throw( uno::RuntimeException )
360 {
361 if ( m_pImpl->m_pTypeCollection == NULL )
362 {
363 ::osl::MutexGuard aGuard( m_aMutex );
364
365 if ( m_pImpl->m_pTypeCollection == NULL )
366 {
367 m_pImpl->m_pTypeCollection = new ::cppu::OTypeCollection
368 ( ::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
369 , ::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
370 , ::getCppuType( ( const uno::Reference< embed::XHierarchicalStorageAccess >* )NULL )
371 , ::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
372 }
373 }
374
375 return m_pImpl->m_pTypeCollection->getTypes() ;
376 }
377
378 //-----------------------------------------------
379 uno::Sequence< sal_Int8 > SAL_CALL FSStorage::getImplementationId()
380 throw( uno::RuntimeException )
381 {
382 static ::cppu::OImplementationId* pID = NULL ;
383
384 if ( pID == NULL )
385 {
386 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;
387
388 if ( pID == NULL )
389 {
390 static ::cppu::OImplementationId aID( sal_False ) ;
391 pID = &aID ;
392 }
393 }
394
395 return pID->getImplementationId() ;
396
397 }
398
399 //____________________________________________________________________________________________________
400 // XStorage
401 //____________________________________________________________________________________________________
402
403 //-----------------------------------------------
404 void SAL_CALL FSStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
405 throw ( embed::InvalidStorageException,
406 io::IOException,
407 lang::IllegalArgumentException,
408 embed::StorageWrappedTargetException,
409 uno::RuntimeException )
410 {
411 ::osl::MutexGuard aGuard( m_aMutex );
412
413 if ( !m_pImpl )
414 throw lang::DisposedException();
415
416 if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
417 throw lang::IllegalArgumentException(); // TODO:
418
419 if ( !GetContent() )
420 throw io::IOException(); // TODO: error handling
421
422 try
423 {
424 CopyContentToStorage_Impl( GetContent(), xDest );
425 }
426 catch( embed::InvalidStorageException& )
427 {
428 throw;
429 }
430 catch( lang::IllegalArgumentException& )
431 {
432 throw;
433 }
434 catch( embed::StorageWrappedTargetException& )
435 {
436 throw;
437 }
438 catch( io::IOException& )
439 {
440 throw;
441 }
442 catch( uno::RuntimeException& )
443 {
444 throw;
445 }
446 catch( uno::Exception& )
447 {
448 uno::Any aCaught( ::cppu::getCaughtException() );
449 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
450 uno::Reference< io::XInputStream >(),
451 aCaught );
452 }
453 }
454
455 //-----------------------------------------------
456 uno::Reference< io::XStream > SAL_CALL FSStorage::openStreamElement(
457 const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode )
458 throw ( embed::InvalidStorageException,
459 lang::IllegalArgumentException,
460 packages::WrongPasswordException,
461 io::IOException,
462 embed::StorageWrappedTargetException,
463 uno::RuntimeException )
464 {
465 ::osl::MutexGuard aGuard( m_aMutex );
466
467 if ( !m_pImpl )
468 throw lang::DisposedException();
469
470 if ( !GetContent() )
471 throw io::IOException(); // TODO: error handling
472
473 // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
474 INetURLObject aFileURL( m_pImpl->m_aURL );
475 aFileURL.Append( aStreamName );
476
477 if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
478 throw io::IOException();
479
480 if ( ( nOpenMode & embed::ElementModes::NOCREATE )
481 && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
482 throw io::IOException(); // TODO:
483
484 uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
485 uno::Reference< io::XStream > xResult;
486 try
487 {
488 if ( nOpenMode & embed::ElementModes::WRITE )
489 {
490 if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
491 {
492 uno::Reference< ucb::XSimpleFileAccess > xSimpleFileAccess(
493 m_pImpl->m_xFactory->createInstance(
494 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
495 uno::UNO_QUERY_THROW );
496 xResult = xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
497 }
498 else
499 {
500 // TODO: test whether it really works for http and fwp
501 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
502 STREAM_STD_WRITE );
503 if ( pStream )
504 {
505 if ( !pStream->GetError() )
506 xResult = uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
507 else
508 delete pStream;
509 }
510 }
511
512 if ( !xResult.is() )
513 throw io::IOException();
514
515 if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
516 {
517 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
518 xTrunc->truncate();
519 }
520 }
521 else
522 {
523 if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
524 || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
525 throw io::IOException(); // TODO: access denied
526
527 ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
528 uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
529 xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
530 }
531 }
532 catch( embed::InvalidStorageException& )
533 {
534 throw;
535 }
536 catch( lang::IllegalArgumentException& )
537 {
538 throw;
539 }
540 catch( packages::WrongPasswordException& )
541 {
542 throw;
543 }
544 catch( embed::StorageWrappedTargetException& )
545 {
546 throw;
547 }
548 catch( io::IOException& )
549 {
550 throw;
551 }
552 catch( uno::RuntimeException& )
553 {
554 throw;
555 }
556 catch( uno::Exception& )
557 {
558 uno::Any aCaught( ::cppu::getCaughtException() );
559 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
560 uno::Reference< io::XInputStream >(),
561 aCaught );
562 }
563
564 return xResult;
565 }
566
567 //-----------------------------------------------
568 uno::Reference< io::XStream > SAL_CALL FSStorage::openEncryptedStreamElement(
569 const ::rtl::OUString&, sal_Int32, const ::rtl::OUString& )
570 throw ( embed::InvalidStorageException,
571 lang::IllegalArgumentException,
572 packages::NoEncryptionException,
573 packages::WrongPasswordException,
574 io::IOException,
575 embed::StorageWrappedTargetException,
576 uno::RuntimeException )
577 {
578 throw packages::NoEncryptionException();
579 }
580
581 //-----------------------------------------------
582 uno::Reference< embed::XStorage > SAL_CALL FSStorage::openStorageElement(
583 const ::rtl::OUString& aStorName, sal_Int32 nStorageMode )
584 throw ( embed::InvalidStorageException,
585 lang::IllegalArgumentException,
586 io::IOException,
587 embed::StorageWrappedTargetException,
588 uno::RuntimeException )
589 {
590 ::osl::MutexGuard aGuard( m_aMutex );
591
592 if ( !m_pImpl )
593 throw lang::DisposedException();
594
595 if ( !GetContent() )
596 throw io::IOException(); // TODO: error handling
597
598 if ( ( nStorageMode & embed::ElementModes::WRITE )
599 && !( m_pImpl->m_nMode & embed::ElementModes::WRITE ) )
600 throw io::IOException(); // TODO: error handling
601
602 // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
603 INetURLObject aFolderURL( m_pImpl->m_aURL );
604 aFolderURL.Append( aStorName );
605
606 sal_Bool bFolderExists = ::utl::UCBContentHelper::IsFolder( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
607 if ( !bFolderExists && ::utl::UCBContentHelper::IsDocument( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
608 throw io::IOException(); // TODO:
609
610 if ( ( nStorageMode & embed::ElementModes::NOCREATE ) && !bFolderExists )
611 throw io::IOException(); // TODO:
612
613 uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
614 uno::Reference< embed::XStorage > xResult;
615 try
616 {
617 if ( nStorageMode & embed::ElementModes::WRITE )
618 {
619 if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) && bFolderExists )
620 {
621 ::utl::UCBContentHelper::Kill( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
622 bFolderExists =
623 MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), sal_True ); // TODO: not atomar :(
624 }
625 else if ( !bFolderExists )
626 {
627 bFolderExists =
628 MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), sal_True ); // TODO: not atomar :(
629 }
630 }
631 else if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
632 throw io::IOException(); // TODO: access denied
633
634 if ( !bFolderExists )
635 throw io::IOException(); // there is no such folder
636
637 ::ucbhelper::Content aResultContent( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
638 xResult = uno::Reference< embed::XStorage >(
639 static_cast< OWeakObject* >( new FSStorage( aResultContent,
640 nStorageMode,
641 uno::Sequence< beans::PropertyValue >(),
642 m_pImpl->m_xFactory ) ),
643 uno::UNO_QUERY );
644 }
645 catch( embed::InvalidStorageException& )
646 {
647 throw;
648 }
649 catch( lang::IllegalArgumentException& )
650 {
651 throw;
652 }
653 catch( embed::StorageWrappedTargetException& )
654 {
655 throw;
656 }
657 catch( io::IOException& )
658 {
659 throw;
660 }
661 catch( uno::RuntimeException& )
662 {
663 throw;
664 }
665 catch( uno::Exception& )
666 {
667 uno::Any aCaught( ::cppu::getCaughtException() );
668 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
669 uno::Reference< io::XInputStream >(),
670 aCaught );
671 }
672
673 return xResult;
674 }
675
676 //-----------------------------------------------
677 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneStreamElement( const ::rtl::OUString& aStreamName )
678 throw ( embed::InvalidStorageException,
679 lang::IllegalArgumentException,
680 packages::WrongPasswordException,
681 io::IOException,
682 embed::StorageWrappedTargetException,
683 uno::RuntimeException )
684 {
685 ::osl::MutexGuard aGuard( m_aMutex );
686
687 if ( !m_pImpl )
688 throw lang::DisposedException();
689
690 if ( !GetContent() )
691 throw io::IOException(); // TODO: error handling
692
693 // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
694 INetURLObject aFileURL( m_pImpl->m_aURL );
695 aFileURL.Append( aStreamName );
696
697 uno::Reference < io::XStream > xTempResult;
698 try
699 {
700 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
701 ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
702 uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
703
704 xTempResult = uno::Reference < io::XStream >(
705 m_pImpl->m_xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ),
706 uno::UNO_QUERY_THROW );
707 uno::Reference < io::XOutputStream > xTempOut = xTempResult->getOutputStream();
708 uno::Reference < io::XInputStream > xTempIn = xTempResult->getInputStream();
709
710 if ( !xTempOut.is() || !xTempIn.is() )
711 throw io::IOException();
712
713 ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
714 xTempOut->closeOutput();
715 }
716 catch( embed::InvalidStorageException& )
717 {
718 throw;
719 }
720 catch( lang::IllegalArgumentException& )
721 {
722 throw;
723 }
724 catch( packages::WrongPasswordException& )
725 {
726 throw;
727 }
728 catch( io::IOException& )
729 {
730 throw;
731 }
732 catch( embed::StorageWrappedTargetException& )
733 {
734 throw;
735 }
736 catch( uno::RuntimeException& )
737 {
738 throw;
739 }
740 catch( uno::Exception& )
741 {
742 uno::Any aCaught( ::cppu::getCaughtException() );
743 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
744 uno::Reference< io::XInputStream >(),
745 aCaught );
746 }
747
748 return xTempResult;
749 }
750
751 //-----------------------------------------------
752 uno::Reference< io::XStream > SAL_CALL FSStorage::cloneEncryptedStreamElement(
753 const ::rtl::OUString&,
754 const ::rtl::OUString& )
755 throw ( embed::InvalidStorageException,
756 lang::IllegalArgumentException,
757 packages::NoEncryptionException,
758 packages::WrongPasswordException,
759 io::IOException,
760 embed::StorageWrappedTargetException,
761 uno::RuntimeException )
762 {
763 throw packages::NoEncryptionException();
764 }
765
766 //-----------------------------------------------
767 void SAL_CALL FSStorage::copyLastCommitTo(
768 const uno::Reference< embed::XStorage >& xTargetStorage )
769 throw ( embed::InvalidStorageException,
770 lang::IllegalArgumentException,
771 io::IOException,
772 embed::StorageWrappedTargetException,
773 uno::RuntimeException )
774 {
775 copyToStorage( xTargetStorage );
776 }
777
778 //-----------------------------------------------
779 void SAL_CALL FSStorage::copyStorageElementLastCommitTo(
780 const ::rtl::OUString& aStorName,
781 const uno::Reference< embed::XStorage >& xTargetStorage )
782 throw ( embed::InvalidStorageException,
783 lang::IllegalArgumentException,
784 io::IOException,
785 embed::StorageWrappedTargetException,
786 uno::RuntimeException )
787 {
788 ::osl::MutexGuard aGuard( m_aMutex );
789
790 if ( !m_pImpl )
791 throw lang::DisposedException();
792
793 uno::Reference< embed::XStorage > xSourceStor( openStorageElement( aStorName, embed::ElementModes::READ ),
794 uno::UNO_QUERY_THROW );
795 xSourceStor->copyToStorage( xTargetStorage );
796 }
797
798 //-----------------------------------------------
799 sal_Bool SAL_CALL FSStorage::isStreamElement( const ::rtl::OUString& aElementName )
800 throw ( embed::InvalidStorageException,
801 lang::IllegalArgumentException,
802 container::NoSuchElementException,
803 uno::RuntimeException )
804 {
805 ::osl::MutexGuard aGuard( m_aMutex );
806
807 if ( !m_pImpl )
808 throw lang::DisposedException();
809
810 if ( !GetContent() )
811 throw embed::InvalidStorageException(); // TODO: error handling
812
813 INetURLObject aURL( m_pImpl->m_aURL );
814 aURL.Append( aElementName );
815
816 return !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
817 }
818
819 //-----------------------------------------------
820 sal_Bool SAL_CALL FSStorage::isStorageElement( const ::rtl::OUString& aElementName )
821 throw ( embed::InvalidStorageException,
822 lang::IllegalArgumentException,
823 container::NoSuchElementException,
824 uno::RuntimeException )
825 {
826 ::osl::MutexGuard aGuard( m_aMutex );
827
828 if ( !m_pImpl )
829 throw lang::DisposedException();
830
831 if ( !GetContent() )
832 throw embed::InvalidStorageException(); // TODO: error handling
833
834 INetURLObject aURL( m_pImpl->m_aURL );
835 aURL.Append( aElementName );
836
837 return ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
838 }
839
840 //-----------------------------------------------
841 void SAL_CALL FSStorage::removeElement( const ::rtl::OUString& aElementName )
842 throw ( embed::InvalidStorageException,
843 lang::IllegalArgumentException,
844 container::NoSuchElementException,
845 io::IOException,
846 embed::StorageWrappedTargetException,
847 uno::RuntimeException )
848 {
849 ::osl::MutexGuard aGuard( m_aMutex );
850
851 if ( !m_pImpl )
852 throw lang::DisposedException();
853
854 if ( !GetContent() )
855 throw io::IOException(); // TODO: error handling
856
857 INetURLObject aURL( m_pImpl->m_aURL );
858 aURL.Append( aElementName );
859
860 if ( !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
861 && !::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
862 throw container::NoSuchElementException(); // TODO:
863
864 ::utl::UCBContentHelper::Kill( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
865 }
866
867 //-----------------------------------------------
868 void SAL_CALL FSStorage::renameElement( const ::rtl::OUString& aElementName, const ::rtl::OUString& aNewName )
869 throw ( embed::InvalidStorageException,
870 lang::IllegalArgumentException,
871 container::NoSuchElementException,
872 container::ElementExistException,
873 io::IOException,
874 embed::StorageWrappedTargetException,
875 uno::RuntimeException )
876 {
877 ::osl::MutexGuard aGuard( m_aMutex );
878
879 if ( !m_pImpl )
880 throw lang::DisposedException();
881
882 if ( !GetContent() )
883 throw io::IOException(); // TODO: error handling
884
885 INetURLObject aOldURL( m_pImpl->m_aURL );
886 aOldURL.Append( aElementName );
887
888 INetURLObject aNewURL( m_pImpl->m_aURL );
889 aNewURL.Append( aNewName );
890
891 if ( !::utl::UCBContentHelper::IsFolder( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) )
892 && !::utl::UCBContentHelper::IsDocument( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
893 throw container::NoSuchElementException(); // TODO:
894
895 if ( ::utl::UCBContentHelper::IsFolder( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) )
896 || ::utl::UCBContentHelper::IsDocument( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
897 throw container::ElementExistException(); // TODO:
898
899 try
900 {
901 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
902 ::ucbhelper::Content aSourceContent( aOldURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
903
904 if ( !GetContent()->transferContent( aSourceContent,
905 ::ucbhelper::InsertOperation_MOVE,
906 aNewName,
907 ucb::NameClash::ERROR ) )
908 throw io::IOException(); // TODO: error handling
909 }
910 catch( embed::InvalidStorageException& )
911 {
912 throw;
913 }
914 catch( lang::IllegalArgumentException& )
915 {
916 throw;
917 }
918 catch( container::NoSuchElementException& )
919 {
920 throw;
921 }
922 catch( container::ElementExistException& )
923 {
924 throw;
925 }
926 catch( io::IOException& )
927 {
928 throw;
929 }
930 catch( embed::StorageWrappedTargetException& )
931 {
932 throw;
933 }
934 catch( uno::RuntimeException& )
935 {
936 throw;
937 }
938 catch( uno::Exception& )
939 {
940 uno::Any aCaught( ::cppu::getCaughtException() );
941 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
942 uno::Reference< io::XInputStream >(),
943 aCaught );
944 }
945 }
946
947 //-----------------------------------------------
948 void SAL_CALL FSStorage::copyElementTo( const ::rtl::OUString& aElementName,
949 const uno::Reference< embed::XStorage >& xDest,
950 const ::rtl::OUString& aNewName )
951 throw ( embed::InvalidStorageException,
952 lang::IllegalArgumentException,
953 container::NoSuchElementException,
954 container::ElementExistException,
955 io::IOException,
956 embed::StorageWrappedTargetException,
957 uno::RuntimeException )
958 {
959 ::osl::MutexGuard aGuard( m_aMutex );
960
961 if ( !m_pImpl )
962 throw lang::DisposedException();
963
964 if ( !xDest.is() )
965 throw uno::RuntimeException();
966
967 if ( !GetContent() )
968 throw io::IOException(); // TODO: error handling
969
970 INetURLObject aOwnURL( m_pImpl->m_aURL );
971 aOwnURL.Append( aElementName );
972
973 if ( xDest->hasByName( aNewName ) )
974 throw container::ElementExistException(); // TODO:
975
976 try
977 {
978 uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
979 if ( ::utl::UCBContentHelper::IsFolder( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
980 {
981 ::ucbhelper::Content aSourceContent( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
982 uno::Reference< embed::XStorage > xDestSubStor(
983 xDest->openStorageElement( aNewName, embed::ElementModes::READWRITE ),
984 uno::UNO_QUERY_THROW );
985
986 CopyContentToStorage_Impl( &aSourceContent, xDestSubStor );
987 }
988 else if ( ::utl::UCBContentHelper::IsDocument( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
989 {
990 CopyStreamToSubStream( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDest, aNewName );
991 }
992 else
993 throw container::NoSuchElementException(); // TODO:
994 }
995 catch( embed::InvalidStorageException& )
996 {
997 throw;
998 }
999 catch( lang::IllegalArgumentException& )
1000 {
1001 throw;
1002 }
1003 catch( container::NoSuchElementException& )
1004 {
1005 throw;
1006 }
1007 catch( container::ElementExistException& )
1008 {
1009 throw;
1010 }
1011 catch( embed::StorageWrappedTargetException& )
1012 {
1013 throw;
1014 }
1015 catch( io::IOException& )
1016 {
1017 throw;
1018 }
1019 catch( uno::RuntimeException& )
1020 {
1021 throw;
1022 }
1023 catch( uno::Exception& )
1024 {
1025 uno::Any aCaught( ::cppu::getCaughtException() );
1026 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
1027 uno::Reference< io::XInputStream >(),
1028 aCaught );
1029 }
1030 }
1031
1032 //-----------------------------------------------
1033 void SAL_CALL FSStorage::moveElementTo( const ::rtl::OUString& aElementName,
1034 const uno::Reference< embed::XStorage >& xDest,
1035 const ::rtl::OUString& aNewName )
1036 throw ( embed::InvalidStorageException,
1037 lang::IllegalArgumentException,
1038 container::NoSuchElementException,
1039 container::ElementExistException,
1040 io::IOException,
1041 embed::StorageWrappedTargetException,
1042 uno::RuntimeException )
1043 {
1044 ::osl::MutexGuard aGuard( m_aMutex );
1045 copyElementTo( aElementName, xDest, aNewName );
1046
1047 INetURLObject aOwnURL( m_pImpl->m_aURL );
1048 aOwnURL.Append( aElementName );
1049 if ( !::utl::UCBContentHelper::Kill( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1050 throw io::IOException(); // TODO: error handling
1051 }
1052
1053 //____________________________________________________________________________________________________
1054 // XNameAccess
1055 //____________________________________________________________________________________________________
1056
1057 //-----------------------------------------------
1058 uno::Any SAL_CALL FSStorage::getByName( const ::rtl::OUString& aName )
1059 throw ( container::NoSuchElementException,
1060 lang::WrappedTargetException,
1061 uno::RuntimeException )
1062 {
1063 ::osl::MutexGuard aGuard( m_aMutex );
1064
1065 if ( !m_pImpl )
1066 throw lang::DisposedException();
1067
1068 if ( !GetContent() )
1069 throw io::IOException(); // TODO: error handling
1070
1071 if ( !aName.getLength() )
1072 throw lang::IllegalArgumentException();
1073
1074 INetURLObject aURL( m_pImpl->m_aURL );
1075 aURL.Append( aName );
1076
1077 uno::Any aResult;
1078 try
1079 {
1080 if ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1081 {
1082 aResult <<= openStorageElement( aName, embed::ElementModes::READ );
1083 }
1084 else if ( ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1085 {
1086 aResult <<= openStreamElement( aName, embed::ElementModes::READ );
1087 }
1088 else
1089 throw container::NoSuchElementException(); // TODO:
1090 }
1091 catch( container::NoSuchElementException& )
1092 {
1093 throw;
1094 }
1095 catch( lang::WrappedTargetException& )
1096 {
1097 throw;
1098 }
1099 catch( uno::RuntimeException& )
1100 {
1101 throw;
1102 }
1103 catch ( uno::Exception& )
1104 {
1105 uno::Any aCaught( ::cppu::getCaughtException() );
1106 throw lang::WrappedTargetException( ::rtl::OUString::createFromAscii( "Can not open element!\n" ),
1107 uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1108 uno::UNO_QUERY ),
1109 aCaught );
1110 }
1111
1112 return aResult;
1113 }
1114
1115
1116 //-----------------------------------------------
1117 uno::Sequence< ::rtl::OUString > SAL_CALL FSStorage::getElementNames()
1118 throw ( uno::RuntimeException )
1119 {
1120 ::osl::MutexGuard aGuard( m_aMutex );
1121
1122 if ( !m_pImpl )
1123 throw lang::DisposedException();
1124
1125 if ( !GetContent() )
1126 throw io::IOException(); // TODO: error handling
1127
1128 uno::Sequence< ::rtl::OUString > aProps( 1 );
1129 ::rtl::OUString* pProps = aProps.getArray();
1130 pProps[0] = ::rtl::OUString::createFromAscii( "Title" );
1131 ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1132
1133 uno::Sequence< ::rtl::OUString > aResult;
1134 sal_Int32 nSize = 0;
1135
1136 try
1137 {
1138 uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1139 uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
1140 uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
1141 if ( xResultSet.is() )
1142 {
1143 // go through the list
1144 while ( xResultSet->next() )
1145 {
1146 ::rtl::OUString aName( xRow->getString( 1 ) );
1147 aResult.realloc( ++nSize );
1148 aResult[nSize-1] = aName;
1149 }
1150 }
1151 }
1152 catch( ucb::InteractiveIOException& r )
1153 {
1154 if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
1155 OSL_ENSURE( sal_False, "The folder does not exist!\n" );
1156 else
1157 {
1158 uno::Any aCaught( ::cppu::getCaughtException() );
1159 throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
1160 uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1161 uno::UNO_QUERY ),
1162 aCaught );
1163 }
1164 }
1165 catch( uno::RuntimeException& )
1166 {
1167 throw;
1168 }
1169 catch ( uno::Exception& )
1170 {
1171 uno::Any aCaught( ::cppu::getCaughtException() );
1172 throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
1173 uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1174 uno::UNO_QUERY ),
1175 aCaught );
1176 }
1177
1178 return aResult;
1179 }
1180
1181
1182 //-----------------------------------------------
1183 sal_Bool SAL_CALL FSStorage::hasByName( const ::rtl::OUString& aName )
1184 throw ( uno::RuntimeException )
1185 {
1186 ::osl::MutexGuard aGuard( m_aMutex );
1187
1188 if ( !m_pImpl )
1189 throw lang::DisposedException();
1190
1191 try
1192 {
1193 if ( !GetContent() )
1194 throw io::IOException(); // TODO: error handling
1195
1196 if ( !aName.getLength() )
1197 throw lang::IllegalArgumentException();
1198 }
1199 catch( uno::RuntimeException& )
1200 {
1201 throw;
1202 }
1203 catch ( uno::Exception& )
1204 {
1205 uno::Any aCaught( ::cppu::getCaughtException() );
1206 throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
1207 uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( this ),
1208 uno::UNO_QUERY ),
1209 aCaught );
1210 }
1211
1212 INetURLObject aURL( m_pImpl->m_aURL );
1213 aURL.Append( aName );
1214
1215 return ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
1216 || ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
1217 }
1218
1219 //-----------------------------------------------
1220 uno::Type SAL_CALL FSStorage::getElementType()
1221 throw ( uno::RuntimeException )
1222 {
1223 ::osl::MutexGuard aGuard( m_aMutex );
1224
1225 if ( !m_pImpl )
1226 throw lang::DisposedException();
1227
1228 // it is a multitype container
1229 return uno::Type();
1230 }
1231
1232 //-----------------------------------------------
1233 sal_Bool SAL_CALL FSStorage::hasElements()
1234 throw ( uno::RuntimeException )
1235 {
1236 ::osl::MutexGuard aGuard( m_aMutex );
1237
1238 if ( !m_pImpl )
1239 throw lang::DisposedException();
1240
1241 if ( !GetContent() )
1242 throw io::IOException(); // TODO: error handling
1243
1244 uno::Sequence< ::rtl::OUString > aProps( 1 );
1245 aProps[0] = ::rtl::OUString::createFromAscii( "TargetURL" );
1246 ::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;
1247
1248 try
1249 {
1250 uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
1251 return ( xResultSet.is() && xResultSet->next() );
1252 }
1253 catch( uno::Exception& )
1254 {
1255 throw uno::RuntimeException();
1256 }
1257 }
1258
1259
1260 //____________________________________________________________________________________________________
1261 // XDisposable
1262 //____________________________________________________________________________________________________
1263
1264 //-----------------------------------------------
1265 void SAL_CALL FSStorage::dispose()
1266 throw ( uno::RuntimeException )
1267 {
1268 ::osl::MutexGuard aGuard( m_aMutex );
1269
1270 if ( !m_pImpl )
1271 throw lang::DisposedException();
1272
1273 if ( m_pImpl->m_pListenersContainer )
1274 {
1275 lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
1276 m_pImpl->m_pListenersContainer->disposeAndClear( aSource );
1277 }
1278
1279 delete m_pImpl;
1280 m_pImpl = NULL;
1281 }
1282
1283 //-----------------------------------------------
1284 void SAL_CALL FSStorage::addEventListener(
1285 const uno::Reference< lang::XEventListener >& xListener )
1286 throw ( uno::RuntimeException )
1287 {
1288 ::osl::MutexGuard aGuard( m_aMutex );
1289
1290 if ( !m_pImpl )
1291 throw lang::DisposedException();
1292
1293 if ( !m_pImpl->m_pListenersContainer )
1294 m_pImpl->m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
1295
1296 m_pImpl->m_pListenersContainer->addInterface( xListener );
1297 }
1298
1299 //-----------------------------------------------
1300 void SAL_CALL FSStorage::removeEventListener(
1301 const uno::Reference< lang::XEventListener >& xListener )
1302 throw ( uno::RuntimeException )
1303 {
1304 ::osl::MutexGuard aGuard( m_aMutex );
1305
1306 if ( !m_pImpl )
1307 throw lang::DisposedException();
1308
1309 if ( m_pImpl->m_pListenersContainer )
1310 m_pImpl->m_pListenersContainer->removeInterface( xListener );
1311 }
1312
1313 //____________________________________________________________________________________________________
1314 // XPropertySet
1315 //____________________________________________________________________________________________________
1316
1317 //-----------------------------------------------
1318 uno::Reference< beans::XPropertySetInfo > SAL_CALL FSStorage::getPropertySetInfo()
1319 throw ( uno::RuntimeException )
1320 {
1321 ::osl::MutexGuard aGuard( m_aMutex );
1322
1323 if ( !m_pImpl )
1324 throw lang::DisposedException();
1325
1326 //TODO:
1327 return uno::Reference< beans::XPropertySetInfo >();
1328 }
1329
1330
1331 //-----------------------------------------------
1332 void SAL_CALL FSStorage::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& )
1333 throw ( beans::UnknownPropertyException,
1334 beans::PropertyVetoException,
1335 lang::IllegalArgumentException,
1336 lang::WrappedTargetException,
1337 uno::RuntimeException )
1338 {
1339 ::osl::MutexGuard aGuard( m_aMutex );
1340
1341 if ( !m_pImpl )
1342 throw lang::DisposedException();
1343
1344 if ( aPropertyName.equalsAscii( "URL" ) || aPropertyName.equalsAscii( "OpenMode" ) )
1345 throw beans::PropertyVetoException(); // TODO
1346 else
1347 throw beans::UnknownPropertyException(); // TODO
1348 }
1349
1350
1351 //-----------------------------------------------
1352 uno::Any SAL_CALL FSStorage::getPropertyValue( const ::rtl::OUString& aPropertyName )
1353 throw ( beans::UnknownPropertyException,
1354 lang::WrappedTargetException,
1355 uno::RuntimeException )
1356 {
1357 ::osl::MutexGuard aGuard( m_aMutex );
1358
1359 if ( !m_pImpl )
1360 throw lang::DisposedException();
1361
1362 if ( aPropertyName.equalsAscii( "URL" ) )
1363 return uno::makeAny( m_pImpl->m_aURL );
1364 else if ( aPropertyName.equalsAscii( "OpenMode" ) )
1365 return uno::makeAny( m_pImpl->m_nMode );
1366
1367 throw beans::UnknownPropertyException(); // TODO
1368 }
1369
1370
1371 //-----------------------------------------------
1372 void SAL_CALL FSStorage::addPropertyChangeListener(
1373 const ::rtl::OUString& /*aPropertyName*/,
1374 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
1375 throw ( beans::UnknownPropertyException,
1376 lang::WrappedTargetException,
1377 uno::RuntimeException )
1378 {
1379 ::osl::MutexGuard aGuard( m_aMutex );
1380
1381 if ( !m_pImpl )
1382 throw lang::DisposedException();
1383
1384 //TODO:
1385 }
1386
1387
1388 //-----------------------------------------------
1389 void SAL_CALL FSStorage::removePropertyChangeListener(
1390 const ::rtl::OUString& /*aPropertyName*/,
1391 const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
1392 throw ( beans::UnknownPropertyException,
1393 lang::WrappedTargetException,
1394 uno::RuntimeException )
1395 {
1396 ::osl::MutexGuard aGuard( m_aMutex );
1397
1398 if ( !m_pImpl )
1399 throw lang::DisposedException();
1400
1401 //TODO:
1402 }
1403
1404
1405 //-----------------------------------------------
1406 void SAL_CALL FSStorage::addVetoableChangeListener(
1407 const ::rtl::OUString& /*PropertyName*/,
1408 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1409 throw ( beans::UnknownPropertyException,
1410 lang::WrappedTargetException,
1411 uno::RuntimeException )
1412 {
1413 ::osl::MutexGuard aGuard( m_aMutex );
1414
1415 if ( !m_pImpl )
1416 throw lang::DisposedException();
1417
1418 //TODO:
1419 }
1420
1421
1422 //-----------------------------------------------
1423 void SAL_CALL FSStorage::removeVetoableChangeListener(
1424 const ::rtl::OUString& /*PropertyName*/,
1425 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
1426 throw ( beans::UnknownPropertyException,
1427 lang::WrappedTargetException,
1428 uno::RuntimeException )
1429 {
1430 ::osl::MutexGuard aGuard( m_aMutex );
1431
1432 if ( !m_pImpl )
1433 throw lang::DisposedException();
1434
1435 //TODO:
1436 }
1437
1438 //____________________________________________________________________________________________________
1439 // XHierarchicalStorageAccess
1440 //____________________________________________________________________________________________________
1441 //-----------------------------------------------
1442 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openStreamElementByHierarchicalName( const ::rtl::OUString& sStreamPath, ::sal_Int32 nOpenMode )
1443 throw ( embed::InvalidStorageException,
1444 lang::IllegalArgumentException,
1445 packages::WrongPasswordException,
1446 io::IOException,
1447 embed::StorageWrappedTargetException,
1448 uno::RuntimeException )
1449 {
1450 ::osl::MutexGuard aGuard( m_aMutex );
1451
1452 if ( !m_pImpl )
1453 throw lang::DisposedException();
1454
1455 if ( sStreamPath.toChar() == '/' )
1456 throw lang::IllegalArgumentException();
1457
1458 if ( !GetContent() )
1459 throw io::IOException(); // TODO: error handling
1460
1461 INetURLObject aBaseURL( m_pImpl->m_aURL );
1462 if ( !aBaseURL.setFinalSlash() )
1463 throw uno::RuntimeException();
1464
1465 INetURLObject aFileURL = INetURLObject::GetAbsURL(
1466 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1467 sStreamPath );
1468
1469 if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1470 throw io::IOException();
1471
1472 if ( ( nOpenMode & embed::ElementModes::NOCREATE )
1473 && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1474 throw io::IOException(); // TODO:
1475
1476 uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
1477 uno::Reference< io::XStream > xResult;
1478 try
1479 {
1480 if ( nOpenMode & embed::ElementModes::WRITE )
1481 {
1482 if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1483 {
1484 uno::Reference< ucb::XSimpleFileAccess > xSimpleFileAccess(
1485 m_pImpl->m_xFactory->createInstance(
1486 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
1487 uno::UNO_QUERY_THROW );
1488 uno::Reference< io::XStream > xStream =
1489 xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
1490
1491 xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1492 }
1493 else
1494 {
1495 // TODO: test whether it really works for http and fwp
1496 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
1497 STREAM_STD_WRITE );
1498 if ( pStream )
1499 {
1500 if ( !pStream->GetError() )
1501 {
1502 uno::Reference< io::XStream > xStream =
1503 uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
1504 xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
1505 }
1506 else
1507 delete pStream;
1508 }
1509 }
1510
1511 if ( !xResult.is() )
1512 throw io::IOException();
1513
1514 if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
1515 {
1516 uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
1517 xTrunc->truncate();
1518 }
1519 }
1520 else
1521 {
1522 if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
1523 || !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1524 throw io::IOException(); // TODO: access denied
1525
1526 ::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
1527 uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
1528 xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
1529 }
1530 }
1531 catch( embed::InvalidStorageException& )
1532 {
1533 throw;
1534 }
1535 catch( lang::IllegalArgumentException& )
1536 {
1537 throw;
1538 }
1539 catch( packages::WrongPasswordException& )
1540 {
1541 throw;
1542 }
1543 catch( embed::StorageWrappedTargetException& )
1544 {
1545 throw;
1546 }
1547 catch( io::IOException& )
1548 {
1549 throw;
1550 }
1551 catch( uno::RuntimeException& )
1552 {
1553 throw;
1554 }
1555 catch( uno::Exception& )
1556 {
1557 uno::Any aCaught( ::cppu::getCaughtException() );
1558 throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
1559 uno::Reference< io::XInputStream >(),
1560 aCaught );
1561 }
1562
1563 return uno::Reference< embed::XExtendedStorageStream >( xResult, uno::UNO_QUERY_THROW );
1564 }
1565
1566 //-----------------------------------------------
1567 uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openEncryptedStreamElementByHierarchicalName( const ::rtl::OUString& /*sStreamName*/, ::sal_Int32 /*nOpenMode*/, const ::rtl::OUString& /*sPassword*/ )
1568 throw ( embed::InvalidStorageException,
1569 lang::IllegalArgumentException,
1570 packages::NoEncryptionException,
1571 packages::WrongPasswordException,
1572 io::IOException,
1573 embed::StorageWrappedTargetException,
1574 uno::RuntimeException )
1575 {
1576 throw packages::NoEncryptionException();
1577 }
1578
1579 //-----------------------------------------------
1580 void SAL_CALL FSStorage::removeStreamElementByHierarchicalName( const ::rtl::OUString& sStreamPath )
1581 throw ( embed::InvalidStorageException,
1582 lang::IllegalArgumentException,
1583 container::NoSuchElementException,
1584 io::IOException,
1585 embed::StorageWrappedTargetException,
1586 uno::RuntimeException )
1587 {
1588 ::osl::MutexGuard aGuard( m_aMutex );
1589
1590 if ( !m_pImpl )
1591 throw lang::DisposedException();
1592
1593 if ( !GetContent() )
1594 throw io::IOException(); // TODO: error handling
1595
1596 // TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
1597 INetURLObject aBaseURL( m_pImpl->m_aURL );
1598 if ( !aBaseURL.setFinalSlash() )
1599 throw uno::RuntimeException();
1600
1601 INetURLObject aFileURL = INetURLObject::GetAbsURL(
1602 aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
1603 sStreamPath );
1604
1605 if ( !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1606 {
1607 if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1608 throw lang::IllegalArgumentException();
1609 else
1610 throw container::NoSuchElementException(); // TODO:
1611 }
1612
1613 if ( !::utl::UCBContentHelper::Kill( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
1614 throw io::IOException(); // TODO: error handling
1615 }
1616
1617
vba interoperability for OOo