?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fdo#74697 Add Bluez 5 support for impress remote.
[LibreOffice.git] / ucb / source / ucp / package / pkgcontent.cxx
blobd19cccb956e10aa1fffc3c6e0ee298c4e2e01011
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 /**************************************************************************
22 TODO
23 **************************************************************************
24 *************************************************************************/
25 #include <osl/diagnose.h>
26
27 #include "osl/doublecheckedlocking.h"
28 #include <rtl/ustring.h>
29 #include <rtl/ustring.hxx>
30 #include <com/sun/star/beans/PropertyAttribute.hpp>
31 #include <com/sun/star/beans/PropertyState.hpp>
32 #include <com/sun/star/beans/PropertyValue.hpp>
33 #include <com/sun/star/beans/XPropertyAccess.hpp>
34 #include <com/sun/star/container/XEnumerationAccess.hpp>
35 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
36 #include <com/sun/star/container/XNameContainer.hpp>
37 #include <com/sun/star/container/XNamed.hpp>
38 #include <com/sun/star/io/XActiveDataSink.hpp>
39 #include <com/sun/star/io/XInputStream.hpp>
40 #include <com/sun/star/io/XOutputStream.hpp>
41 #include <com/sun/star/lang/IllegalAccessException.hpp>
42 #include <com/sun/star/sdbc/XRow.hpp>
43 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
44 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
45 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
46 #include <com/sun/star/ucb/MissingInputStreamException.hpp>
47 #include <com/sun/star/ucb/NameClash.hpp>
48 #include <com/sun/star/ucb/NameClashException.hpp>
49 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
50 #include <com/sun/star/ucb/OpenMode.hpp>
51 #include <com/sun/star/ucb/TransferInfo.hpp>
52 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
53 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
54 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
55 #include <com/sun/star/ucb/XCommandInfo.hpp>
56 #include <com/sun/star/ucb/XPersistentPropertySet.hpp>
57 #include <com/sun/star/util/XChangesBatch.hpp>
58 #include <com/sun/star/uno/Any.hxx>
59 #include <com/sun/star/uno/Sequence.hxx>
60 #include <comphelper/processfactory.hxx>
61 #include <ucbhelper/contentidentifier.hxx>
62 #include <ucbhelper/propertyvalueset.hxx>
63 #include <ucbhelper/cancelcommandexecution.hxx>
64 #include "pkgcontent.hxx"
65 #include "pkgprovider.hxx"
66 #include "pkgresultset.hxx"
67
68 #include "../inc/urihelper.hxx"
69
70 using namespace com::sun::star;
71 using namespace package_ucp;
72
73 #define NONE_MODIFIED sal_uInt32( 0x00 )
74 #define MEDIATYPE_MODIFIED sal_uInt32( 0x01 )
75 #define COMPRESSED_MODIFIED sal_uInt32( 0x02 )
76 #define ENCRYPTED_MODIFIED sal_uInt32( 0x04 )
77 #define ENCRYPTIONKEY_MODIFIED sal_uInt32( 0x08 )
78
79 //=========================================================================
80 //=========================================================================
81 //
82 // ContentProperties Implementation.
83 //
84 //=========================================================================
85 //=========================================================================
86
87 ContentProperties::ContentProperties( const OUString& rContentType )
88 : aContentType( rContentType ),
89 nSize( 0 ),
90 bCompressed( sal_True ),
91 bEncrypted( sal_False ),
92 bHasEncryptedEntries( sal_False )
93 {
94 bIsFolder = rContentType == PACKAGE_FOLDER_CONTENT_TYPE || rContentType == PACKAGE_ZIP_FOLDER_CONTENT_TYPE;
95 bIsDocument = !bIsFolder;
96
97 OSL_ENSURE( bIsFolder || rContentType == PACKAGE_STREAM_CONTENT_TYPE || rContentType == PACKAGE_ZIP_STREAM_CONTENT_TYPE,
98 "ContentProperties::ContentProperties - Unknown type!" );
99 }
100
101 //=========================================================================
102
103 uno::Sequence< ucb::ContentInfo >
104 ContentProperties::getCreatableContentsInfo( PackageUri const & rUri ) const
105 {
106 if ( bIsFolder )
107 {
108 uno::Sequence< beans::Property > aProps( 1 );
109 aProps.getArray()[ 0 ] = beans::Property(
110 OUString("Title"),
111 -1,
112 getCppuType( static_cast< const OUString * >( 0 ) ),
113 beans::PropertyAttribute::BOUND );
114
115 uno::Sequence< ucb::ContentInfo > aSeq( 2 );
116
117 // Folder.
118 aSeq.getArray()[ 0 ].Type
119 = Content::getContentType( rUri.getScheme(), sal_True );
120 aSeq.getArray()[ 0 ].Attributes
121 = ucb::ContentInfoAttribute::KIND_FOLDER;
122 aSeq.getArray()[ 0 ].Properties = aProps;
123
124 // Stream.
125 aSeq.getArray()[ 1 ].Type
126 = Content::getContentType( rUri.getScheme(), sal_False );
127 aSeq.getArray()[ 1 ].Attributes
128 = ucb::ContentInfoAttribute::INSERT_WITH_INPUTSTREAM
129 | ucb::ContentInfoAttribute::KIND_DOCUMENT;
130 aSeq.getArray()[ 1 ].Properties = aProps;
131
132 return aSeq;
133 }
134 else
135 {
136 return uno::Sequence< ucb::ContentInfo >( 0 );
137 }
138 }
139
140 //=========================================================================
141 //=========================================================================
142 //
143 // Content Implementation.
144 //
145 //=========================================================================
146 //=========================================================================
147
148 // static ( "virtual" ctor )
149 Content* Content::create(
150 const uno::Reference< uno::XComponentContext >& rxContext,
151 ContentProvider* pProvider,
152 const uno::Reference< ucb::XContentIdentifier >& Identifier )
153 {
154 OUString aURL = Identifier->getContentIdentifier();
155 PackageUri aURI( aURL );
156 ContentProperties aProps;
157 uno::Reference< container::XHierarchicalNameAccess > xPackage;
158
159 if ( loadData( pProvider, aURI, aProps, xPackage ) )
160 {
161 // resource exists
162
163 sal_Int32 nLastSlash = aURL.lastIndexOf( '/' );
164 if ( ( nLastSlash + 1 ) == aURL.getLength() )
165 {
166 // Client explicitly requested a folder!
167 if ( !aProps.bIsFolder )
168 return 0;
169 }
170
171 uno::Reference< ucb::XContentIdentifier > xId
172 = new ::ucbhelper::ContentIdentifier( aURI.getUri() );
173 return new Content( rxContext, pProvider, xId, xPackage, aURI, aProps );
174 }
175 else
176 {
177 // resource doesn't exist
178
179 sal_Bool bFolder = sal_False;
180
181 // Guess type according to URI.
182 sal_Int32 nLastSlash = aURL.lastIndexOf( '/' );
183 if ( ( nLastSlash + 1 ) == aURL.getLength() )
184 bFolder = sal_True;
185
186 uno::Reference< ucb::XContentIdentifier > xId
187 = new ::ucbhelper::ContentIdentifier( aURI.getUri() );
188
189 ucb::ContentInfo aInfo;
190 if ( bFolder || aURI.isRootFolder() )
191 aInfo.Type = getContentType( aURI.getScheme(), sal_True );
192 else
193 aInfo.Type = getContentType( aURI.getScheme(), sal_False );
194
195 return new Content( rxContext, pProvider, xId, xPackage, aURI, aInfo );
196 }
197 }
198
199 //=========================================================================
200 // static ( "virtual" ctor )
201 Content* Content::create(
202 const uno::Reference< uno::XComponentContext >& rxContext,
203 ContentProvider* pProvider,
204 const uno::Reference< ucb::XContentIdentifier >& Identifier,
205 const ucb::ContentInfo& Info )
206 {
207 if ( Info.Type.isEmpty() )
208 return 0;
209
210 PackageUri aURI( Identifier->getContentIdentifier() );
211
212 if ( !Info.Type.equalsIgnoreAsciiCase(
213 getContentType( aURI.getScheme(), sal_True ) ) &&
214 !Info.Type.equalsIgnoreAsciiCase(
215 getContentType( aURI.getScheme(), sal_False ) ) )
216 return 0;
217
218 uno::Reference< container::XHierarchicalNameAccess > xPackage;
219
220 xPackage = pProvider->createPackage( aURI.getPackage(), aURI.getParam() );
221
222 uno::Reference< ucb::XContentIdentifier > xId
223 = new ::ucbhelper::ContentIdentifier( aURI.getUri() );
224 return new Content( rxContext, pProvider, xId, xPackage, aURI, Info );
225 }
226
227 //=========================================================================
228 // static
229 OUString Content::getContentType(
230 const OUString& aScheme, sal_Bool bFolder )
231 {
232 return ( OUString("application/")
233 + aScheme
234 + ( bFolder
235 ? OUString("-folder")
236 : OUString("-stream") ) );
237 }
238
239 //=========================================================================
240 Content::Content(
241 const uno::Reference< uno::XComponentContext >& rxContext,
242 ContentProvider* pProvider,
243 const uno::Reference< ucb::XContentIdentifier >& Identifier,
244 const uno::Reference< container::XHierarchicalNameAccess > & Package,
245 const PackageUri& rUri,
246 const ContentProperties& rProps )
247 : ContentImplHelper( rxContext, pProvider, Identifier ),
248 m_aUri( rUri ),
249 m_aProps( rProps ),
250 m_eState( PERSISTENT ),
251 m_xPackage( Package ),
252 m_pProvider( pProvider ),
253 m_nModifiedProps( NONE_MODIFIED )
254 {
255 }
256
257 //=========================================================================
258 Content::Content(
259 const uno::Reference< uno::XComponentContext >& rxContext,
260 ContentProvider* pProvider,
261 const uno::Reference< ucb::XContentIdentifier >& Identifier,
262 const uno::Reference< container::XHierarchicalNameAccess > & Package,
263 const PackageUri& rUri,
264 const ucb::ContentInfo& Info )
265 : ContentImplHelper( rxContext, pProvider, Identifier ),
266 m_aUri( rUri ),
267 m_aProps( Info.Type ),
268 m_eState( TRANSIENT ),
269 m_xPackage( Package ),
270 m_pProvider( pProvider ),
271 m_nModifiedProps( NONE_MODIFIED )
272 {
273 }
274
275 //=========================================================================
276 // virtual
277 Content::~Content()
278 {
279 }
280
281 //=========================================================================
282 //
283 // XInterface methods.
284 //
285 //=========================================================================
286
287 // virtual
288 void SAL_CALL Content::acquire()
289 throw( )
290 {
291 ContentImplHelper::acquire();
292 }
293
294 //=========================================================================
295 // virtual
296 void SAL_CALL Content::release()
297 throw( )
298 {
299 ContentImplHelper::release();
300 }
301
302 //=========================================================================
303 // virtual
304 uno::Any SAL_CALL Content::queryInterface( const uno::Type & rType )
305 throw ( uno::RuntimeException )
306 {
307 uno::Any aRet;
308
309 if ( isFolder() )
310 aRet = cppu::queryInterface(
311 rType, static_cast< ucb::XContentCreator * >( this ) );
312
313 return aRet.hasValue() ? aRet : ContentImplHelper::queryInterface( rType );
314 }
315
316 //=========================================================================
317 //
318 // XTypeProvider methods.
319 //
320 //=========================================================================
321
322 XTYPEPROVIDER_COMMON_IMPL( Content );
323
324 //=========================================================================
325 // virtual
326 uno::Sequence< uno::Type > SAL_CALL Content::getTypes()
327 throw( uno::RuntimeException )
328 {
329 cppu::OTypeCollection * pCollection = 0;
330
331 if ( isFolder() )
332 {
333 static cppu::OTypeCollection* pFolderTypes = 0;
334
335 pCollection = pFolderTypes;
336 if ( !pCollection )
337 {
338 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
339
340 pCollection = pFolderTypes;
341 if ( !pCollection )
342 {
343 static cppu::OTypeCollection aCollection(
344 CPPU_TYPE_REF( lang::XTypeProvider ),
345 CPPU_TYPE_REF( lang::XServiceInfo ),
346 CPPU_TYPE_REF( lang::XComponent ),
347 CPPU_TYPE_REF( ucb::XContent ),
348 CPPU_TYPE_REF( ucb::XCommandProcessor ),
349 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
350 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
351 CPPU_TYPE_REF( beans::XPropertyContainer ),
352 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
353 CPPU_TYPE_REF( container::XChild ),
354 CPPU_TYPE_REF( ucb::XContentCreator ) ); // !!
355 pCollection = &aCollection;
356 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
357 pFolderTypes = pCollection;
358 }
359 }
360 else {
361 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
362 }
363 }
364 else
365 {
366 static cppu::OTypeCollection* pDocumentTypes = 0;
367
368 pCollection = pDocumentTypes;
369 if ( !pCollection )
370 {
371 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
372
373 pCollection = pDocumentTypes;
374 if ( !pCollection )
375 {
376 static cppu::OTypeCollection aCollection(
377 CPPU_TYPE_REF( lang::XTypeProvider ),
378 CPPU_TYPE_REF( lang::XServiceInfo ),
379 CPPU_TYPE_REF( lang::XComponent ),
380 CPPU_TYPE_REF( ucb::XContent ),
381 CPPU_TYPE_REF( ucb::XCommandProcessor ),
382 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
383 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
384 CPPU_TYPE_REF( beans::XPropertyContainer ),
385 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
386 CPPU_TYPE_REF( container::XChild ) );
387 pCollection = &aCollection;
388 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
389 pDocumentTypes = pCollection;
390 }
391 }
392 else {
393 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
394 }
395 }
396
397 return (*pCollection).getTypes();
398 }
399
400 //=========================================================================
401 //
402 // XServiceInfo methods.
403 //
404 //=========================================================================
405
406 // virtual
407 OUString SAL_CALL Content::getImplementationName()
408 throw( uno::RuntimeException )
409 {
410 return OUString( "com.sun.star.comp.ucb.PackageContent" );
411 }
412
413 //=========================================================================
414 // virtual
415 uno::Sequence< OUString > SAL_CALL Content::getSupportedServiceNames()
416 throw( uno::RuntimeException )
417 {
418 uno::Sequence< OUString > aSNS( 1 );
419 if ( isFolder() )
420 aSNS.getArray()[ 0 ] = OUString( PACKAGE_FOLDER_CONTENT_SERVICE_NAME );
421 else
422 aSNS.getArray()[ 0 ] = OUString( PACKAGE_STREAM_CONTENT_SERVICE_NAME );
423
424 return aSNS;
425 }
426
427 //=========================================================================
428 //
429 // XContent methods.
430 //
431 //=========================================================================
432
433 // virtual
434 OUString SAL_CALL Content::getContentType()
435 throw( uno::RuntimeException )
436 {
437 return m_aProps.aContentType;
438 }
439
440 //=========================================================================
441 //
442 // XCommandProcessor methods.
443 //
444 //=========================================================================
445
446 // virtual
447 uno::Any SAL_CALL Content::execute(
448 const ucb::Command& aCommand,
449 sal_Int32 /*CommandId*/,
450 const uno::Reference< ucb::XCommandEnvironment >& Environment )
451 throw( uno::Exception,
452 ucb::CommandAbortedException,
453 uno::RuntimeException )
454 {
455 uno::Any aRet;
456
457 if ( aCommand.Name == "getPropertyValues" )
458 {
459 //////////////////////////////////////////////////////////////////
460 // getPropertyValues
461 //////////////////////////////////////////////////////////////////
462
463 uno::Sequence< beans::Property > Properties;
464 if ( !( aCommand.Argument >>= Properties ) )
465 {
466 ucbhelper::cancelCommandExecution(
467 uno::makeAny( lang::IllegalArgumentException(
468 OUString( "Wrong argument type!" ),
469 static_cast< cppu::OWeakObject * >( this ),
470 -1 ) ),
471 Environment );
472 // Unreachable
473 }
474
475 aRet <<= getPropertyValues( Properties );
476 }
477 else if ( aCommand.Name == "setPropertyValues" )
478 {
479 //////////////////////////////////////////////////////////////////
480 // setPropertyValues
481 //////////////////////////////////////////////////////////////////
482
483 uno::Sequence< beans::PropertyValue > aProperties;
484 if ( !( aCommand.Argument >>= aProperties ) )
485 {
486 ucbhelper::cancelCommandExecution(
487 uno::makeAny( lang::IllegalArgumentException(
488 OUString( "Wrong argument type!" ),
489 static_cast< cppu::OWeakObject * >( this ),
490 -1 ) ),
491 Environment );
492 // Unreachable
493 }
494
495 if ( !aProperties.getLength() )
496 {
497 ucbhelper::cancelCommandExecution(
498 uno::makeAny( lang::IllegalArgumentException(
499 OUString( "No properties!" ),
500 static_cast< cppu::OWeakObject * >( this ),
501 -1 ) ),
502 Environment );
503 // Unreachable
504 }
505
506 aRet <<= setPropertyValues( aProperties, Environment );
507 }
508 else if ( aCommand.Name == "getPropertySetInfo" )
509 {
510 //////////////////////////////////////////////////////////////////
511 // getPropertySetInfo
512 //////////////////////////////////////////////////////////////////
513
514 // Note: Implemented by base class.
515 aRet <<= getPropertySetInfo( Environment );
516 }
517 else if ( aCommand.Name == "getCommandInfo" )
518 {
519 //////////////////////////////////////////////////////////////////
520 // getCommandInfo
521 //////////////////////////////////////////////////////////////////
522
523 // Note: Implemented by base class.
524 aRet <<= getCommandInfo( Environment );
525 }
526 else if ( aCommand.Name == "open" )
527 {
528 //////////////////////////////////////////////////////////////////
529 // open
530 //////////////////////////////////////////////////////////////////
531
532 ucb::OpenCommandArgument2 aOpenCommand;
533 if ( !( aCommand.Argument >>= aOpenCommand ) )
534 {
535 ucbhelper::cancelCommandExecution(
536 uno::makeAny( lang::IllegalArgumentException(
537 OUString( "Wrong argument type!" ),
538 static_cast< cppu::OWeakObject * >( this ),
539 -1 ) ),
540 Environment );
541 // Unreachable
542 }
543
544 aRet = open( aOpenCommand, Environment );
545 }
546 else if ( !m_aUri.isRootFolder() && aCommand.Name == "insert" )
547 {
548 //////////////////////////////////////////////////////////////////
549 // insert
550 //////////////////////////////////////////////////////////////////
551
552 ucb::InsertCommandArgument aArg;
553 if ( !( aCommand.Argument >>= aArg ) )
554 {
555 ucbhelper::cancelCommandExecution(
556 uno::makeAny( lang::IllegalArgumentException(
557 OUString( "Wrong argument type!" ),
558 static_cast< cppu::OWeakObject * >( this ),
559 -1 ) ),
560 Environment );
561 // Unreachable
562 }
563
564 sal_Int32 nNameClash = aArg.ReplaceExisting
565 ? ucb::NameClash::OVERWRITE
566 : ucb::NameClash::ERROR;
567 insert( aArg.Data, nNameClash, Environment );
568 }
569 else if ( !m_aUri.isRootFolder() && aCommand.Name == "delete" )
570 {
571 //////////////////////////////////////////////////////////////////
572 // delete
573 //////////////////////////////////////////////////////////////////
574
575 sal_Bool bDeletePhysical = sal_False;
576 aCommand.Argument >>= bDeletePhysical;
577 destroy( bDeletePhysical, Environment );
578
579 // Remove own and all children's persistent data.
580 if ( !removeData() )
581 {
582 uno::Any aProps
583 = uno::makeAny(
584 beans::PropertyValue(
585 OUString( "Uri"),
586 -1,
587 uno::makeAny(m_xIdentifier->
588 getContentIdentifier()),
589 beans::PropertyState_DIRECT_VALUE));
590 ucbhelper::cancelCommandExecution(
591 ucb::IOErrorCode_CANT_WRITE,
592 uno::Sequence< uno::Any >(&aProps, 1),
593 Environment,
594 OUString( "Cannot remove persistent data!" ),
595 this );
596 // Unreachable
597 }
598
599 // Remove own and all children's Additional Core Properties.
600 removeAdditionalPropertySet( sal_True );
601 }
602 else if ( aCommand.Name == "transfer" )
603 {
604 //////////////////////////////////////////////////////////////////
605 // transfer
606 // ( Not available at stream objects )
607 //////////////////////////////////////////////////////////////////
608
609 ucb::TransferInfo aInfo;
610 if ( !( aCommand.Argument >>= aInfo ) )
611 {
612 ucbhelper::cancelCommandExecution(
613 uno::makeAny( lang::IllegalArgumentException(
614 OUString( "Wrong argument type!" ),
615 static_cast< cppu::OWeakObject * >( this ),
616 -1 ) ),
617 Environment );
618 // Unreachable
619 }
620
621 transfer( aInfo, Environment );
622 }
623 else if ( aCommand.Name == "createNewContent" && isFolder() )
624 {
625 //////////////////////////////////////////////////////////////////
626 // createNewContent
627 // ( Not available at stream objects )
628 //////////////////////////////////////////////////////////////////
629
630 ucb::ContentInfo aInfo;
631 if ( !( aCommand.Argument >>= aInfo ) )
632 {
633 OSL_FAIL( "Wrong argument type!" );
634 ucbhelper::cancelCommandExecution(
635 uno::makeAny( lang::IllegalArgumentException(
636 OUString( "Wrong argument type!" ),
637 static_cast< cppu::OWeakObject * >( this ),
638 -1 ) ),
639 Environment );
640 // Unreachable
641 }
642
643 aRet <<= createNewContent( aInfo );
644 }
645 else if ( aCommand.Name == "flush" )
646 {
647 //////////////////////////////////////////////////////////////////
648 // flush
649 // ( Not available at stream objects )
650 //////////////////////////////////////////////////////////////////
651
652 if( !flushData() )
653 {
654 uno::Any aProps
655 = uno::makeAny(
656 beans::PropertyValue(
657 OUString( "Uri"),
658 -1,
659 uno::makeAny(m_xIdentifier->
660 getContentIdentifier()),
661 beans::PropertyState_DIRECT_VALUE));
662 ucbhelper::cancelCommandExecution(
663 ucb::IOErrorCode_CANT_WRITE,
664 uno::Sequence< uno::Any >(&aProps, 1),
665 Environment,
666 OUString( "Cannot write file to disk!" ),
667 this );
668 // Unreachable
669 }
670 }
671 else
672 {
673 //////////////////////////////////////////////////////////////////
674 // Unsupported command
675 //////////////////////////////////////////////////////////////////
676
677 ucbhelper::cancelCommandExecution(
678 uno::makeAny( ucb::UnsupportedCommandException(
679 OUString(),
680 static_cast< cppu::OWeakObject * >( this ) ) ),
681 Environment );
682 // Unreachable
683 }
684
685 return aRet;
686 }
687
688 //=========================================================================
689 // virtual
690 void SAL_CALL Content::abort( sal_Int32 /*CommandId*/ )
691 throw( uno::RuntimeException )
692 {
693 // @@@ Implement logic to abort running commands, if this makes
694 // sense for your content.
695 }
696
697 //=========================================================================
698 //
699 // XContentCreator methods.
700 //
701 //=========================================================================
702
703 // virtual
704 uno::Sequence< ucb::ContentInfo > SAL_CALL
705 Content::queryCreatableContentsInfo()
706 throw( uno::RuntimeException )
707 {
708 return m_aProps.getCreatableContentsInfo( m_aUri );
709 }
710
711 //=========================================================================
712 // virtual
713 uno::Reference< ucb::XContent > SAL_CALL
714 Content::createNewContent( const ucb::ContentInfo& Info )
715 throw( uno::RuntimeException )
716 {
717 if ( isFolder() )
718 {
719 osl::Guard< osl::Mutex > aGuard( m_aMutex );
720
721 if ( Info.Type.isEmpty() )
722 return uno::Reference< ucb::XContent >();
723
724 if ( !Info.Type.equalsIgnoreAsciiCase(
725 getContentType( m_aUri.getScheme(), sal_True ) ) &&
726 !Info.Type.equalsIgnoreAsciiCase(
727 getContentType( m_aUri.getScheme(), sal_False ) ) )
728 return uno::Reference< ucb::XContent >();
729
730 OUString aURL = m_aUri.getUri();
731 aURL += OUString("/");
732
733 if ( Info.Type.equalsIgnoreAsciiCase(
734 getContentType( m_aUri.getScheme(), sal_True ) ) )
735 aURL += OUString("New_Folder");
736 else
737 aURL += OUString("New_Stream");
738
739 uno::Reference< ucb::XContentIdentifier > xId(
740 new ::ucbhelper::ContentIdentifier( aURL ) );
741
742 return create( m_xContext, m_pProvider, xId, Info );
743 }
744 else
745 {
746 OSL_FAIL( "createNewContent called on non-folder object!" );
747 return uno::Reference< ucb::XContent >();
748 }
749 }
750
751 //=========================================================================
752 //
753 // Non-interface methods.
754 //
755 //=========================================================================
756
757 // virtual
758 OUString Content::getParentURL()
759 {
760 return m_aUri.getParentUri();
761 }
762
763 //=========================================================================
764 // static
765 uno::Reference< sdbc::XRow > Content::getPropertyValues(
766 const uno::Reference< uno::XComponentContext >& rxContext,
767 const uno::Sequence< beans::Property >& rProperties,
768 ContentProvider* pProvider,
769 const OUString& rContentId )
770 {
771 ContentProperties aData;
772 uno::Reference< container::XHierarchicalNameAccess > xPackage;
773 if ( loadData( pProvider, PackageUri( rContentId ), aData, xPackage ) )
774 {
775 return getPropertyValues( rxContext,
776 rProperties,
777 aData,
778 rtl::Reference<
779 ::ucbhelper::ContentProviderImplHelper >(
780 pProvider ),
781 rContentId );
782 }
783 else
784 {
785 rtl::Reference< ::ucbhelper::PropertyValueSet > xRow
786 = new ::ucbhelper::PropertyValueSet( rxContext );
787
788 sal_Int32 nCount = rProperties.getLength();
789 if ( nCount )
790 {
791 const beans::Property* pProps = rProperties.getConstArray();
792 for ( sal_Int32 n = 0; n < nCount; ++n )
793 xRow->appendVoid( pProps[ n ] );
794 }
795
796 return uno::Reference< sdbc::XRow >( xRow.get() );
797 }
798 }
799
800 //=========================================================================
801 // static
802 uno::Reference< sdbc::XRow > Content::getPropertyValues(
803 const uno::Reference< uno::XComponentContext >& rxContext,
804 const uno::Sequence< beans::Property >& rProperties,
805 const ContentProperties& rData,
806 const rtl::Reference< ::ucbhelper::ContentProviderImplHelper >&
807 rProvider,
808 const OUString& rContentId )
809 {
810 // Note: Empty sequence means "get values of all supported properties".
811
812 rtl::Reference< ::ucbhelper::PropertyValueSet > xRow
813 = new ::ucbhelper::PropertyValueSet( rxContext );
814
815 sal_Int32 nCount = rProperties.getLength();
816 if ( nCount )
817 {
818 uno::Reference< beans::XPropertySet > xAdditionalPropSet;
819 sal_Bool bTriedToGetAdditonalPropSet = sal_False;
820
821 const beans::Property* pProps = rProperties.getConstArray();
822 for ( sal_Int32 n = 0; n < nCount; ++n )
823 {
824 const beans::Property& rProp = pProps[ n ];
825
826 // Process Core properties.
827
828 if ( rProp.Name == "ContentType" )
829 {
830 xRow->appendString ( rProp, rData.aContentType );
831 }
832 else if ( rProp.Name == "Title" )
833 {
834 xRow->appendString ( rProp, rData.aTitle );
835 }
836 else if ( rProp.Name == "IsDocument" )
837 {
838 xRow->appendBoolean( rProp, rData.bIsDocument );
839 }
840 else if ( rProp.Name == "IsFolder" )
841 {
842 xRow->appendBoolean( rProp, rData.bIsFolder );
843 }
844 else if ( rProp.Name == "CreatableContentsInfo" )
845 {
846 xRow->appendObject(
847 rProp, uno::makeAny(
848 rData.getCreatableContentsInfo(
849 PackageUri( rContentId ) ) ) );
850 }
851 else if ( rProp.Name == "MediaType" )
852 {
853 xRow->appendString ( rProp, rData.aMediaType );
854 }
855 else if ( rProp.Name == "Size" )
856 {
857 // Property only available for streams.
858 if ( rData.bIsDocument )
859 xRow->appendLong( rProp, rData.nSize );
860 else
861 xRow->appendVoid( rProp );
862 }
863 else if ( rProp.Name == "Compressed" )
864 {
865 // Property only available for streams.
866 if ( rData.bIsDocument )
867 xRow->appendBoolean( rProp, rData.bCompressed );
868 else
869 xRow->appendVoid( rProp );
870 }
871 else if ( rProp.Name == "Encrypted" )
872 {
873 // Property only available for streams.
874 if ( rData.bIsDocument )
875 xRow->appendBoolean( rProp, rData.bEncrypted );
876 else
877 xRow->appendVoid( rProp );
878 }
879 else if ( rProp.Name == "HasEncryptedEntries" )
880 {
881 // Property only available for root folder.
882 PackageUri aURI( rContentId );
883 if ( aURI.isRootFolder() )
884 xRow->appendBoolean( rProp, rData.bHasEncryptedEntries );
885 else
886 xRow->appendVoid( rProp );
887 }
888 else
889 {
890 // Not a Core Property! Maybe it's an Additional Core Property?!
891
892 if ( !bTriedToGetAdditonalPropSet && !xAdditionalPropSet.is() )
893 {
894 xAdditionalPropSet
895 = uno::Reference< beans::XPropertySet >(
896 rProvider->getAdditionalPropertySet( rContentId,
897 sal_False ),
898 uno::UNO_QUERY );
899 bTriedToGetAdditonalPropSet = sal_True;
900 }
901
902 if ( xAdditionalPropSet.is() )
903 {
904 if ( !xRow->appendPropertySetValue(
905 xAdditionalPropSet,
906 rProp ) )
907 {
908 // Append empty entry.
909 xRow->appendVoid( rProp );
910 }
911 }
912 else
913 {
914 // Append empty entry.
915 xRow->appendVoid( rProp );
916 }
917 }
918 }
919 }
920 else
921 {
922 // Append all Core Properties.
923 xRow->appendString (
924 beans::Property(
925 OUString("ContentType"),
926 -1,
927 getCppuType( static_cast< const OUString * >( 0 ) ),
928 beans::PropertyAttribute::BOUND
929 | beans::PropertyAttribute::READONLY ),
930 rData.aContentType );
931 xRow->appendString(
932 beans::Property(
933 OUString("Title"),
934 -1,
935 getCppuType( static_cast< const OUString * >( 0 ) ),
936 beans::PropertyAttribute::BOUND ),
937 rData.aTitle );
938 xRow->appendBoolean(
939 beans::Property(
940 OUString("IsDocument"),
941 -1,
942 getCppuBooleanType(),
943 beans::PropertyAttribute::BOUND
944 | beans::PropertyAttribute::READONLY ),
945 rData.bIsDocument );
946 xRow->appendBoolean(
947 beans::Property(
948 OUString("IsFolder"),
949 -1,
950 getCppuBooleanType(),
951 beans::PropertyAttribute::BOUND
952 | beans::PropertyAttribute::READONLY ),
953 rData.bIsFolder );
954 xRow->appendObject(
955 beans::Property(
956 OUString("CreatableContentsInfo"),
957 -1,
958 getCppuType( static_cast<
959 const uno::Sequence< ucb::ContentInfo > * >( 0 ) ),
960 beans::PropertyAttribute::BOUND
961 | beans::PropertyAttribute::READONLY ),
962 uno::makeAny(
963 rData.getCreatableContentsInfo( PackageUri( rContentId ) ) ) );
964 xRow->appendString(
965 beans::Property(
966 OUString("MediaType"),
967 -1,
968 getCppuType( static_cast< const OUString * >( 0 ) ),
969 beans::PropertyAttribute::BOUND ),
970 rData.aMediaType );
971
972 // Properties only available for streams.
973 if ( rData.bIsDocument )
974 {
975 xRow->appendLong(
976 beans::Property(
977 OUString("Size"),
978 -1,
979 getCppuType( static_cast< const sal_Int64 * >( 0 ) ),
980 beans::PropertyAttribute::BOUND
981 | beans::PropertyAttribute::READONLY ),
982 rData.nSize );
983
984 xRow->appendBoolean(
985 beans::Property(
986 OUString("Compressed"),
987 -1,
988 getCppuBooleanType(),
989 beans::PropertyAttribute::BOUND ),
990 rData.bCompressed );
991
992 xRow->appendBoolean(
993 beans::Property(
994 OUString("Encrypted"),
995 -1,
996 getCppuBooleanType(),
997 beans::PropertyAttribute::BOUND ),
998 rData.bEncrypted );
999 }
1000
1001 // Properties only available for root folder.
1002 PackageUri aURI( rContentId );
1003 if ( aURI.isRootFolder() )
1004 {
1005 xRow->appendBoolean(
1006 beans::Property(
1007 OUString("HasEncryptedEntries"),
1008 -1,
1009 getCppuBooleanType(),
1010 beans::PropertyAttribute::BOUND
1011 | beans::PropertyAttribute::READONLY ),
1012 rData.bHasEncryptedEntries );
1013 }
1014
1015 // Append all Additional Core Properties.
1016
1017 uno::Reference< beans::XPropertySet > xSet(
1018 rProvider->getAdditionalPropertySet( rContentId, sal_False ),
1019 uno::UNO_QUERY );
1020 xRow->appendPropertySet( xSet );
1021 }
1022
1023 return uno::Reference< sdbc::XRow >( xRow.get() );
1024 }
1025
1026 //=========================================================================
1027 uno::Reference< sdbc::XRow > Content::getPropertyValues(
1028 const uno::Sequence< beans::Property >& rProperties )
1029 {
1030 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1031 return getPropertyValues( m_xContext,
1032 rProperties,
1033 m_aProps,
1034 rtl::Reference<
1035 ::ucbhelper::ContentProviderImplHelper >(
1036 m_xProvider.get() ),
1037 m_xIdentifier->getContentIdentifier() );
1038 }
1039
1040 //=========================================================================
1041 uno::Sequence< uno::Any > Content::setPropertyValues(
1042 const uno::Sequence< beans::PropertyValue >& rValues,
1043 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1044 throw( uno::Exception )
1045 {
1046 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1047
1048 uno::Sequence< uno::Any > aRet( rValues.getLength() );
1049 uno::Sequence< beans::PropertyChangeEvent > aChanges( rValues.getLength() );
1050 sal_Int32 nChanged = 0;
1051
1052 beans::PropertyChangeEvent aEvent;
1053 aEvent.Source = static_cast< cppu::OWeakObject * >( this );
1054 aEvent.Further = sal_False;
1055 // aEvent.PropertyName =
1056 aEvent.PropertyHandle = -1;
1057 // aEvent.OldValue =
1058 // aEvent.NewValue =
1059
1060 const beans::PropertyValue* pValues = rValues.getConstArray();
1061 sal_Int32 nCount = rValues.getLength();
1062
1063 uno::Reference< ucb::XPersistentPropertySet > xAdditionalPropSet;
1064 sal_Bool bTriedToGetAdditonalPropSet = sal_False;
1065 sal_Bool bExchange = sal_False;
1066 sal_Bool bStore = sal_False;
1067 OUString aNewTitle;
1068 sal_Int32 nTitlePos = -1;
1069
1070 for ( sal_Int32 n = 0; n < nCount; ++n )
1071 {
1072 const beans::PropertyValue& rValue = pValues[ n ];
1073
1074 if ( rValue.Name == "ContentType" )
1075 {
1076 // Read-only property!
1077 aRet[ n ] <<= lang::IllegalAccessException(
1078 OUString(
1079 "Property is read-only!" ),
1080 static_cast< cppu::OWeakObject * >( this ) );
1081 }
1082 else if ( rValue.Name == "IsDocument" )
1083 {
1084 // Read-only property!
1085 aRet[ n ] <<= lang::IllegalAccessException(
1086 OUString(
1087 "Property is read-only!" ),
1088 static_cast< cppu::OWeakObject * >( this ) );
1089 }
1090 else if ( rValue.Name == "IsFolder" )
1091 {
1092 // Read-only property!
1093 aRet[ n ] <<= lang::IllegalAccessException(
1094 OUString(
1095 "Property is read-only!" ),
1096 static_cast< cppu::OWeakObject * >( this ) );
1097 }
1098 else if ( rValue.Name == "CreatableContentsInfo" )
1099 {
1100 // Read-only property!
1101 aRet[ n ] <<= lang::IllegalAccessException(
1102 OUString(
1103 "Property is read-only!" ),
1104 static_cast< cppu::OWeakObject * >( this ) );
1105 }
1106 else if ( rValue.Name == "Title" )
1107 {
1108 if ( m_aUri.isRootFolder() )
1109 {
1110 // Read-only property!
1111 aRet[ n ] <<= lang::IllegalAccessException(
1112 OUString(
1113 "Property is read-only!" ),
1114 static_cast< cppu::OWeakObject * >( this ) );
1115 }
1116 else
1117 {
1118 OUString aNewValue;
1119 if ( rValue.Value >>= aNewValue )
1120 {
1121 // No empty titles!
1122 if ( !aNewValue.isEmpty() )
1123 {
1124 if ( aNewValue != m_aProps.aTitle )
1125 {
1126 // modified title -> modified URL -> exchange !
1127 if ( m_eState == PERSISTENT )
1128 bExchange = sal_True;
1129
1130 // new value will be set later...
1131 aNewTitle = aNewValue;
1132
1133 // remember position within sequence of values
1134 // (for error handling).
1135 nTitlePos = n;
1136 }
1137 }
1138 else
1139 {
1140 aRet[ n ] <<=
1141 lang::IllegalArgumentException(
1142 OUString(
1143 "Empty title not allowed!" ),
1144 static_cast< cppu::OWeakObject * >( this ),
1145 -1 );
1146 }
1147 }
1148 else
1149 {
1150 aRet[ n ] <<=
1151 beans::IllegalTypeException(
1152 OUString(
1153 "Property value has wrong type!" ),
1154 static_cast< cppu::OWeakObject * >( this ) );
1155 }
1156 }
1157 }
1158 else if ( rValue.Name == "MediaType" )
1159 {
1160 OUString aNewValue;
1161 if ( rValue.Value >>= aNewValue )
1162 {
1163 if ( aNewValue != m_aProps.aMediaType )
1164 {
1165 aEvent.PropertyName = rValue.Name;
1166 aEvent.OldValue = uno::makeAny( m_aProps.aMediaType );
1167 aEvent.NewValue = uno::makeAny( aNewValue );
1168
1169 m_aProps.aMediaType = aNewValue;
1170 nChanged++;
1171 bStore = sal_True;
1172 m_nModifiedProps |= MEDIATYPE_MODIFIED;
1173 }
1174 }
1175 else
1176 {
1177 aRet[ n ] <<= beans::IllegalTypeException(
1178 OUString(
1179 "Property value has wrong type!" ),
1180 static_cast< cppu::OWeakObject * >( this ) );
1181 }
1182 }
1183 else if ( rValue.Name == "Size" )
1184 {
1185 // Read-only property!
1186 aRet[ n ] <<= lang::IllegalAccessException(
1187 OUString(
1188 "Property is read-only!" ),
1189 static_cast< cppu::OWeakObject * >( this ) );
1190 }
1191 else if ( rValue.Name == "Compressed" )
1192 {
1193 // Property only available for streams.
1194 if ( m_aProps.bIsDocument )
1195 {
1196 sal_Bool bNewValue;
1197 if ( rValue.Value >>= bNewValue )
1198 {
1199 if ( bNewValue != m_aProps.bCompressed )
1200 {
1201 aEvent.PropertyName = rValue.Name;
1202 aEvent.OldValue = uno::makeAny( m_aProps.bCompressed );
1203 aEvent.NewValue = uno::makeAny( bNewValue );
1204
1205 m_aProps.bCompressed = bNewValue;
1206 nChanged++;
1207 bStore = sal_True;
1208 m_nModifiedProps |= COMPRESSED_MODIFIED;
1209 }
1210 }
1211 else
1212 {
1213 aRet[ n ] <<= beans::IllegalTypeException(
1214 OUString(
1215 "Property value has wrong type!" ),
1216 static_cast< cppu::OWeakObject * >( this ) );
1217 }
1218 }
1219 else
1220 {
1221 aRet[ n ] <<= beans::UnknownPropertyException(
1222 OUString(
1223 "Compressed only supported by streams!" ),
1224 static_cast< cppu::OWeakObject * >( this ) );
1225 }
1226 }
1227 else if ( rValue.Name == "Encrypted" )
1228 {
1229 // Property only available for streams.
1230 if ( m_aProps.bIsDocument )
1231 {
1232 sal_Bool bNewValue;
1233 if ( rValue.Value >>= bNewValue )
1234 {
1235 if ( bNewValue != m_aProps.bEncrypted )
1236 {
1237 aEvent.PropertyName = rValue.Name;
1238 aEvent.OldValue = uno::makeAny( m_aProps.bEncrypted );
1239 aEvent.NewValue = uno::makeAny( bNewValue );
1240
1241 m_aProps.bEncrypted = bNewValue;
1242 nChanged++;
1243 bStore = sal_True;
1244 m_nModifiedProps |= ENCRYPTED_MODIFIED;
1245 }
1246 }
1247 else
1248 {
1249 aRet[ n ] <<= beans::IllegalTypeException(
1250 OUString(
1251 "Property value has wrong type!" ),
1252 static_cast< cppu::OWeakObject * >( this ) );
1253 }
1254 }
1255 else
1256 {
1257 aRet[ n ] <<= beans::UnknownPropertyException(
1258 OUString(
1259 "Encrypted only supported by streams!" ),
1260 static_cast< cppu::OWeakObject * >( this ) );
1261 }
1262 }
1263 else if ( rValue.Name == "HasEncryptedEntries" )
1264 {
1265 // Read-only property!
1266 aRet[ n ] <<= lang::IllegalAccessException(
1267 OUString(
1268 "Property is read-only!" ),
1269 static_cast< cppu::OWeakObject * >( this ) );
1270 }
1271 else if ( rValue.Name == "EncryptionKey" )
1272 {
1273 // @@@ This is a temporary solution. In the future submitting
1274 // the key should be done using an interaction handler!
1275
1276 // Write-Only property. Only supported by root folder and streams
1277 // (all non-root folders of a package have the same encryption key).
1278 if ( m_aUri.isRootFolder() || m_aProps.bIsDocument )
1279 {
1280 uno::Sequence < sal_Int8 > aNewValue;
1281 if ( rValue.Value >>= aNewValue )
1282 {
1283 if ( aNewValue != m_aProps.aEncryptionKey )
1284 {
1285 aEvent.PropertyName = rValue.Name;
1286 aEvent.OldValue = uno::makeAny(
1287 m_aProps.aEncryptionKey );
1288 aEvent.NewValue = uno::makeAny( aNewValue );
1289
1290 m_aProps.aEncryptionKey = aNewValue;
1291 nChanged++;
1292 bStore = sal_True;
1293 m_nModifiedProps |= ENCRYPTIONKEY_MODIFIED;
1294 }
1295 }
1296 else
1297 {
1298 aRet[ n ] <<= beans::IllegalTypeException(
1299 OUString(
1300 "Property value has wrong type!" ),
1301 static_cast< cppu::OWeakObject * >( this ) );
1302 }
1303 }
1304 else
1305 {
1306 aRet[ n ] <<= beans::UnknownPropertyException(
1307 OUString(
1308 "EncryptionKey not supported by non-root folder!" ),
1309 static_cast< cppu::OWeakObject * >( this ) );
1310 }
1311 }
1312 else
1313 {
1314 // Not a Core Property! Maybe it's an Additional Core Property?!
1315
1316 if ( !bTriedToGetAdditonalPropSet && !xAdditionalPropSet.is() )
1317 {
1318 xAdditionalPropSet = getAdditionalPropertySet( sal_False );
1319 bTriedToGetAdditonalPropSet = sal_True;
1320 }
1321
1322 if ( xAdditionalPropSet.is() )
1323 {
1324 try
1325 {
1326 uno::Any aOldValue
1327 = xAdditionalPropSet->getPropertyValue( rValue.Name );
1328 if ( aOldValue != rValue.Value )
1329 {
1330 xAdditionalPropSet->setPropertyValue(
1331 rValue.Name, rValue.Value );
1332
1333 aEvent.PropertyName = rValue.Name;
1334 aEvent.OldValue = aOldValue;
1335 aEvent.NewValue = rValue.Value;
1336
1337 aChanges.getArray()[ nChanged ] = aEvent;
1338 nChanged++;
1339 }
1340 }
1341 catch ( beans::UnknownPropertyException const & e )
1342 {
1343 aRet[ n ] <<= e;
1344 }
1345 catch ( lang::WrappedTargetException const & e )
1346 {
1347 aRet[ n ] <<= e;
1348 }
1349 catch ( beans::PropertyVetoException const & e )
1350 {
1351 aRet[ n ] <<= e;
1352 }
1353 catch ( lang::IllegalArgumentException const & e )
1354 {
1355 aRet[ n ] <<= e;
1356 }
1357 }
1358 else
1359 {
1360 aRet[ n ] <<= uno::Exception(
1361 OUString(
1362 "No property set for storing the value!" ),
1363 static_cast< cppu::OWeakObject * >( this ) );
1364 }
1365 }
1366 }
1367
1368 if ( bExchange )
1369 {
1370 uno::Reference< ucb::XContentIdentifier > xOldId = m_xIdentifier;
1371
1372 // Assemble new content identifier...
1373 OUString aNewURL = m_aUri.getParentUri();
1374 aNewURL += OUString("/");
1375 aNewURL += ::ucb_impl::urihelper::encodeSegment( aNewTitle );
1376 uno::Reference< ucb::XContentIdentifier > xNewId
1377 = new ::ucbhelper::ContentIdentifier( aNewURL );
1378
1379 aGuard.clear();
1380 if ( exchangeIdentity( xNewId ) )
1381 {
1382 // Adapt persistent data.
1383 renameData( xOldId, xNewId );
1384
1385 // Adapt Additional Core Properties.
1386 renameAdditionalPropertySet( xOldId->getContentIdentifier(),
1387 xNewId->getContentIdentifier(),
1388 sal_True );
1389 }
1390 else
1391 {
1392 // Do not set new title!
1393 aNewTitle = OUString();
1394
1395 // Set error .
1396 aRet[ nTitlePos ] <<= uno::Exception(
1397 OUString("Exchange failed!"),
1398 static_cast< cppu::OWeakObject * >( this ) );
1399 }
1400 }
1401
1402 if ( !aNewTitle.isEmpty() )
1403 {
1404 aEvent.PropertyName = OUString("Title");
1405 aEvent.OldValue = uno::makeAny( m_aProps.aTitle );
1406 aEvent.NewValue = uno::makeAny( aNewTitle );
1407
1408 m_aProps.aTitle = aNewTitle;
1409
1410 aChanges.getArray()[ nChanged ] = aEvent;
1411 nChanged++;
1412 }
1413
1414 if ( nChanged > 0 )
1415 {
1416 // Save changes, if content was already made persistent.
1417 if ( ( m_nModifiedProps & ENCRYPTIONKEY_MODIFIED ) ||
1418 ( bStore && ( m_eState == PERSISTENT ) ) )
1419 {
1420 if ( !storeData( uno::Reference< io::XInputStream >() ) )
1421 {
1422 uno::Any aProps
1423 = uno::makeAny(
1424 beans::PropertyValue(
1425 OUString(
1426 "Uri"),
1427 -1,
1428 uno::makeAny(m_xIdentifier->
1429 getContentIdentifier()),
1430 beans::PropertyState_DIRECT_VALUE));
1431 ucbhelper::cancelCommandExecution(
1432 ucb::IOErrorCode_CANT_WRITE,
1433 uno::Sequence< uno::Any >(&aProps, 1),
1434 xEnv,
1435 OUString(
1436 "Cannot store persistent data!" ),
1437 this );
1438 // Unreachable
1439 }
1440 }
1441
1442 aGuard.clear();
1443 aChanges.realloc( nChanged );
1444 notifyPropertiesChange( aChanges );
1445 }
1446
1447 return aRet;
1448 }
1449
1450 //=========================================================================
1451 uno::Any Content::open(
1452 const ucb::OpenCommandArgument2& rArg,
1453 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1454 throw( uno::Exception )
1455 {
1456 if ( rArg.Mode == ucb::OpenMode::ALL ||
1457 rArg.Mode == ucb::OpenMode::FOLDERS ||
1458 rArg.Mode == ucb::OpenMode::DOCUMENTS )
1459 {
1460 //////////////////////////////////////////////////////////////////
1461 // open command for a folder content
1462 //////////////////////////////////////////////////////////////////
1463
1464 uno::Reference< ucb::XDynamicResultSet > xSet
1465 = new DynamicResultSet( m_xContext, this, rArg, xEnv );
1466 return uno::makeAny( xSet );
1467 }
1468 else
1469 {
1470 //////////////////////////////////////////////////////////////////
1471 // open command for a document content
1472 //////////////////////////////////////////////////////////////////
1473
1474 if ( ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) ||
1475 ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE ) )
1476 {
1477 // Currently(?) unsupported.
1478 ucbhelper::cancelCommandExecution(
1479 uno::makeAny( ucb::UnsupportedOpenModeException(
1480 OUString(),
1481 static_cast< cppu::OWeakObject * >( this ),
1482 sal_Int16( rArg.Mode ) ) ),
1483 xEnv );
1484 // Unreachable
1485 }
1486
1487 uno::Reference< io::XOutputStream > xOut( rArg.Sink, uno::UNO_QUERY );
1488 if ( xOut.is() )
1489 {
1490 // PUSH: write data into xOut
1491
1492 uno::Reference< io::XInputStream > xIn = getInputStream();
1493 if ( !xIn.is() )
1494 {
1495 // No interaction if we are not persistent!
1496 uno::Any aProps
1497 = uno::makeAny(
1498 beans::PropertyValue(
1499 OUString(
1500 "Uri"),
1501 -1,
1502 uno::makeAny(m_xIdentifier->
1503 getContentIdentifier()),
1504 beans::PropertyState_DIRECT_VALUE));
1505 ucbhelper::cancelCommandExecution(
1506 ucb::IOErrorCode_CANT_READ,
1507 uno::Sequence< uno::Any >(&aProps, 1),
1508 m_eState == PERSISTENT
1509 ? xEnv
1510 : uno::Reference< ucb::XCommandEnvironment >(),
1511 OUString("Got no data stream!"),
1512 this );
1513 // Unreachable
1514 }
1515
1516 try
1517 {
1518 uno::Sequence< sal_Int8 > aBuffer;
1519 sal_Int32 nRead = xIn->readSomeBytes( aBuffer, 65536 );
1520
1521 while ( nRead > 0 )
1522 {
1523 aBuffer.realloc( nRead );
1524 xOut->writeBytes( aBuffer );
1525 aBuffer.realloc( 0 );
1526 nRead = xIn->readSomeBytes( aBuffer, 65536 );
1527 }
1528
1529 xOut->closeOutput();
1530 }
1531 catch ( io::NotConnectedException const & )
1532 {
1533 // closeOutput, readSomeBytes, writeBytes
1534 }
1535 catch ( io::BufferSizeExceededException const & )
1536 {
1537 // closeOutput, readSomeBytes, writeBytes
1538 }
1539 catch ( io::IOException const & )
1540 {
1541 // closeOutput, readSomeBytes, writeBytes
1542 }
1543 }
1544 else
1545 {
1546 uno::Reference< io::XActiveDataSink > xDataSink(
1547 rArg.Sink, uno::UNO_QUERY );
1548 if ( xDataSink.is() )
1549 {
1550 // PULL: wait for client read
1551
1552 uno::Reference< io::XInputStream > xIn = getInputStream();
1553 if ( !xIn.is() )
1554 {
1555 // No interaction if we are not persistent!
1556 uno::Any aProps
1557 = uno::makeAny(
1558 beans::PropertyValue(
1559 OUString( "Uri"),
1560 -1,
1561 uno::makeAny(m_xIdentifier->
1562 getContentIdentifier()),
1563 beans::PropertyState_DIRECT_VALUE));
1564 ucbhelper::cancelCommandExecution(
1565 ucb::IOErrorCode_CANT_READ,
1566 uno::Sequence< uno::Any >(&aProps, 1),
1567 m_eState == PERSISTENT
1568 ? xEnv
1569 : uno::Reference<
1570 ucb::XCommandEnvironment >(),
1571 OUString( "Got no data stream!" ),
1572 this );
1573 // Unreachable
1574 }
1575
1576 // Done.
1577 xDataSink->setInputStream( xIn );
1578 }
1579 else
1580 {
1581 // Note: aOpenCommand.Sink may contain an XStream
1582 // implementation. Support for this type of
1583 // sink is optional...
1584 ucbhelper::cancelCommandExecution(
1585 uno::makeAny(
1586 ucb::UnsupportedDataSinkException(
1587 OUString(),
1588 static_cast< cppu::OWeakObject * >( this ),
1589 rArg.Sink ) ),
1590 xEnv );
1591 // Unreachable
1592 }
1593 }
1594 }
1595
1596 return uno::Any();
1597 }
1598
1599 //=========================================================================
1600 void Content::insert(
1601 const uno::Reference< io::XInputStream >& xStream,
1602 sal_Int32 nNameClashResolve,
1603 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1604 throw( uno::Exception )
1605 {
1606 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1607
1608 // Check, if all required properties were set.
1609 if ( isFolder() )
1610 {
1611 // Required: Title
1612
1613 if ( m_aProps.aTitle.isEmpty() )
1614 m_aProps.aTitle = m_aUri.getName();
1615 }
1616 else
1617 {
1618 // Required: rArg.Data
1619
1620 if ( !xStream.is() )
1621 {
1622 ucbhelper::cancelCommandExecution(
1623 uno::makeAny( ucb::MissingInputStreamException(
1624 OUString(),
1625 static_cast< cppu::OWeakObject * >( this ) ) ),
1626 xEnv );
1627 // Unreachable
1628 }
1629
1630 // Required: Title
1631
1632 if ( m_aProps.aTitle.isEmpty() )
1633 m_aProps.aTitle = m_aUri.getName();
1634 }
1635
1636 OUString aNewURL = m_aUri.getParentUri();
1637 if (1 + aNewURL.lastIndexOf('/') != aNewURL.getLength())
1638 aNewURL += OUString("/");
1639 aNewURL += ::ucb_impl::urihelper::encodeSegment( m_aProps.aTitle );
1640 PackageUri aNewUri( aNewURL );
1641
1642 // Handle possible name clash...
1643 switch ( nNameClashResolve )
1644 {
1645 // fail.
1646 case ucb::NameClash::ERROR:
1647 if ( hasData( aNewUri ) )
1648 {
1649 ucbhelper::cancelCommandExecution(
1650 uno::makeAny( ucb::NameClashException(
1651 OUString(),
1652 static_cast< cppu::OWeakObject * >( this ),
1653 task::InteractionClassification_ERROR,
1654 m_aProps.aTitle ) ),
1655 xEnv );
1656 // Unreachable
1657 }
1658 break;
1659
1660 // replace (possibly) existing object.
1661 case ucb::NameClash::OVERWRITE:
1662 break;
1663
1664 // "invent" a new valid title.
1665 case ucb::NameClash::RENAME:
1666 if ( hasData( aNewUri ) )
1667 {
1668 sal_Int32 nTry = 0;
1669
1670 do
1671 {
1672 OUString aNew = aNewUri.getUri();
1673 aNew += OUString("_");
1674 aNew += OUString::valueOf( ++nTry );
1675 aNewUri.setUri( aNew );
1676 }
1677 while ( hasData( aNewUri ) && ( nTry < 1000 ) );
1678
1679 if ( nTry == 1000 )
1680 {
1681 ucbhelper::cancelCommandExecution(
1682 uno::makeAny(
1683 ucb::UnsupportedNameClashException(
1684 OUString( "Unable to resolve name clash!" ),
1685 static_cast< cppu::OWeakObject * >( this ),
1686 nNameClashResolve ) ),
1687 xEnv );
1688 // Unreachable
1689 }
1690 else
1691 {
1692 m_aProps.aTitle += OUString("_");
1693 m_aProps.aTitle += OUString::valueOf( nTry );
1694 }
1695 }
1696 break;
1697
1698 case ucb::NameClash::KEEP: // deprecated
1699 case ucb::NameClash::ASK:
1700 default:
1701 if ( hasData( aNewUri ) )
1702 {
1703 ucbhelper::cancelCommandExecution(
1704 uno::makeAny(
1705 ucb::UnsupportedNameClashException(
1706 OUString(),
1707 static_cast< cppu::OWeakObject * >( this ),
1708 nNameClashResolve ) ),
1709 xEnv );
1710 // Unreachable
1711 }
1712 break;
1713 }
1714
1715 // Identifier changed?
1716 sal_Bool bNewId = ( m_aUri.getUri() != aNewUri.getUri() );
1717
1718 if ( bNewId )
1719 {
1720 m_xIdentifier = new ::ucbhelper::ContentIdentifier( aNewURL );
1721 m_aUri = aNewUri;
1722 }
1723
1724 if ( !storeData( xStream ) )
1725 {
1726 uno::Any aProps
1727 = uno::makeAny(beans::PropertyValue(
1728 OUString( "Uri"),
1729 -1,
1730 uno::makeAny(m_xIdentifier->
1731 getContentIdentifier()),
1732 beans::PropertyState_DIRECT_VALUE));
1733 ucbhelper::cancelCommandExecution(
1734 ucb::IOErrorCode_CANT_WRITE,
1735 uno::Sequence< uno::Any >(&aProps, 1),
1736 xEnv,
1737 OUString("Cannot store persistent data!"),
1738 this );
1739 // Unreachable
1740 }
1741
1742 m_eState = PERSISTENT;
1743
1744 if ( bNewId )
1745 {
1746 // Take over correct default values from underlying packager...
1747 uno::Reference< container::XHierarchicalNameAccess > xXHierarchicalNameAccess;
1748 loadData( m_pProvider,
1749 m_aUri,
1750 m_aProps,
1751 xXHierarchicalNameAccess );
1752
1753 aGuard.clear();
1754 inserted();
1755 }
1756 }
1757
1758 //=========================================================================
1759 void Content::destroy(
1760 sal_Bool bDeletePhysical,
1761 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1762 throw( uno::Exception )
1763 {
1764 // @@@ take care about bDeletePhysical -> trashcan support
1765
1766 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1767
1768 uno::Reference< ucb::XContent > xThis = this;
1769
1770 // Persistent?
1771 if ( m_eState != PERSISTENT )
1772 {
1773 ucbhelper::cancelCommandExecution(
1774 uno::makeAny( ucb::UnsupportedCommandException(
1775 OUString( "Not persistent!" ),
1776 static_cast< cppu::OWeakObject * >( this ) ) ),
1777 xEnv );
1778 // Unreachable
1779 }
1780
1781 m_eState = DEAD;
1782
1783 aGuard.clear();
1784 deleted();
1785
1786 if ( isFolder() )
1787 {
1788 // Process instanciated children...
1789
1790 ContentRefList aChildren;
1791 queryChildren( aChildren );
1792
1793 ContentRefList::const_iterator it = aChildren.begin();
1794 ContentRefList::const_iterator end = aChildren.end();
1795
1796 while ( it != end )
1797 {
1798 (*it)->destroy( bDeletePhysical, xEnv );
1799 ++it;
1800 }
1801 }
1802 }
1803
1804 //=========================================================================
1805 void Content::transfer(
1806 const ucb::TransferInfo& rInfo,
1807 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1808 throw( uno::Exception )
1809 {
1810 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1811
1812 // Persistent?
1813 if ( m_eState != PERSISTENT )
1814 {
1815 ucbhelper::cancelCommandExecution(
1816 uno::makeAny( ucb::UnsupportedCommandException(
1817 OUString( "Not persistent!" ),
1818 static_cast< cppu::OWeakObject * >( this ) ) ),
1819 xEnv );
1820 // Unreachable
1821 }
1822
1823 // Is source a package content?
1824 if ( ( rInfo.SourceURL.isEmpty() ) ||
1825 ( rInfo.SourceURL.compareTo(
1826 m_aUri.getUri(), PACKAGE_URL_SCHEME_LENGTH + 3 ) != 0 ) )
1827 {
1828 ucbhelper::cancelCommandExecution(
1829 uno::makeAny( ucb::InteractiveBadTransferURLException(
1830 OUString(),
1831 static_cast< cppu::OWeakObject * >( this ) ) ),
1832 xEnv );
1833 // Unreachable
1834 }
1835
1836 // Is source not a parent of me / not me?
1837 OUString aId = m_aUri.getParentUri();
1838 aId += OUString("/");
1839
1840 if ( rInfo.SourceURL.getLength() <= aId.getLength() )
1841 {
1842 if ( aId.compareTo(
1843 rInfo.SourceURL, rInfo.SourceURL.getLength() ) == 0 )
1844 {
1845 uno::Any aProps
1846 = uno::makeAny(beans::PropertyValue(
1847 OUString( "Uri"),
1848 -1,
1849 uno::makeAny(rInfo.SourceURL),
1850 beans::PropertyState_DIRECT_VALUE));
1851 ucbhelper::cancelCommandExecution(
1852 ucb::IOErrorCode_RECURSIVE,
1853 uno::Sequence< uno::Any >(&aProps, 1),
1854 xEnv,
1855 OUString( "Target is equal to or is a child of source!" ),
1856 this );
1857 // Unreachable
1858 }
1859 }
1860
1861 //////////////////////////////////////////////////////////////////////
1862 // 0) Obtain content object for source.
1863 //////////////////////////////////////////////////////////////////////
1864
1865 uno::Reference< ucb::XContentIdentifier > xId
1866 = new ::ucbhelper::ContentIdentifier( rInfo.SourceURL );
1867
1868 // Note: The static cast is okay here, because its sure that
1869 // m_xProvider is always the PackageContentProvider.
1870 rtl::Reference< Content > xSource;
1871
1872 try
1873 {
1874 xSource = static_cast< Content * >(
1875 m_xProvider->queryContent( xId ).get() );
1876 }
1877 catch ( ucb::IllegalIdentifierException const & )
1878 {
1879 // queryContent
1880 }
1881
1882 if ( !xSource.is() )
1883 {
1884 uno::Any aProps
1885 = uno::makeAny(beans::PropertyValue(
1886 OUString( "Uri"),
1887 -1,
1888 uno::makeAny(xId->getContentIdentifier()),
1889 beans::PropertyState_DIRECT_VALUE));
1890 ucbhelper::cancelCommandExecution(
1891 ucb::IOErrorCode_CANT_READ,
1892 uno::Sequence< uno::Any >(&aProps, 1),
1893 xEnv,
1894 OUString( "Cannot instanciate source object!" ),
1895 this );
1896 // Unreachable
1897 }
1898
1899 //////////////////////////////////////////////////////////////////////
1900 // 1) Create new child content.
1901 //////////////////////////////////////////////////////////////////////
1902
1903 OUString aType = xSource->isFolder()
1904 ? getContentType( m_aUri.getScheme(), sal_True )
1905 : getContentType( m_aUri.getScheme(), sal_False );
1906 ucb::ContentInfo aContentInfo;
1907 aContentInfo.Type = aType;
1908 aContentInfo.Attributes = 0;
1909
1910 // Note: The static cast is okay here, because its sure that
1911 // createNewContent always creates a Content.
1912 rtl::Reference< Content > xTarget
1913 = static_cast< Content * >( createNewContent( aContentInfo ).get() );
1914 if ( !xTarget.is() )
1915 {
1916 uno::Any aProps
1917 = uno::makeAny(beans::PropertyValue(
1918 OUString( "Folder"),
1919 -1,
1920 uno::makeAny(aId),
1921 beans::PropertyState_DIRECT_VALUE));
1922 ucbhelper::cancelCommandExecution(
1923 ucb::IOErrorCode_CANT_CREATE,
1924 uno::Sequence< uno::Any >(&aProps, 1),
1925 xEnv,
1926 OUString( "XContentCreator::createNewContent failed!" ),
1927 this );
1928 // Unreachable
1929 }
1930
1931 //////////////////////////////////////////////////////////////////////
1932 // 2) Copy data from source content to child content.
1933 //////////////////////////////////////////////////////////////////////
1934
1935 uno::Sequence< beans::Property > aSourceProps
1936 = xSource->getPropertySetInfo( xEnv )->getProperties();
1937 sal_Int32 nCount = aSourceProps.getLength();
1938
1939 if ( nCount )
1940 {
1941 sal_Bool bHadTitle = rInfo.NewTitle.isEmpty();
1942
1943 // Get all source values.
1944 uno::Reference< sdbc::XRow > xRow
1945 = xSource->getPropertyValues( aSourceProps );
1946
1947 uno::Sequence< beans::PropertyValue > aValues( nCount );
1948 beans::PropertyValue* pValues = aValues.getArray();
1949
1950 const beans::Property* pProps = aSourceProps.getConstArray();
1951 for ( sal_Int32 n = 0; n < nCount; ++n )
1952 {
1953 const beans::Property& rProp = pProps[ n ];
1954 beans::PropertyValue& rValue = pValues[ n ];
1955
1956 rValue.Name = rProp.Name;
1957 rValue.Handle = rProp.Handle;
1958
1959 if ( !bHadTitle && rProp.Name == "Title" )
1960 {
1961 // Set new title instead of original.
1962 bHadTitle = sal_True;
1963 rValue.Value <<= rInfo.NewTitle;
1964 }
1965 else
1966 rValue.Value
1967 = xRow->getObject( n + 1,
1968 uno::Reference<
1969 container::XNameAccess >() );
1970
1971 rValue.State = beans::PropertyState_DIRECT_VALUE;
1972
1973 if ( rProp.Attributes & beans::PropertyAttribute::REMOVABLE )
1974 {
1975 // Add Additional Core Property.
1976 try
1977 {
1978 xTarget->addProperty( rProp.Name,
1979 rProp.Attributes,
1980 rValue.Value );
1981 }
1982 catch ( beans::PropertyExistException const & )
1983 {
1984 }
1985 catch ( beans::IllegalTypeException const & )
1986 {
1987 }
1988 catch ( lang::IllegalArgumentException const & )
1989 {
1990 }
1991 }
1992 }
1993
1994 // Set target values.
1995 xTarget->setPropertyValues( aValues, xEnv );
1996 }
1997
1998 //////////////////////////////////////////////////////////////////////
1999 // 3) Commit (insert) child.
2000 //////////////////////////////////////////////////////////////////////
2001
2002 xTarget->insert( xSource->getInputStream(), rInfo.NameClash, xEnv );
2003
2004 //////////////////////////////////////////////////////////////////////
2005 // 4) Transfer (copy) children of source.
2006 //////////////////////////////////////////////////////////////////////
2007
2008 if ( xSource->isFolder() )
2009 {
2010 uno::Reference< container::XEnumeration > xIter
2011 = xSource->getIterator();
2012 if ( xIter.is() )
2013 {
2014 while ( xIter->hasMoreElements() )
2015 {
2016 try
2017 {
2018 uno::Reference< container::XNamed > xNamed;
2019 xIter->nextElement() >>= xNamed;
2020
2021 if ( !xNamed.is() )
2022 {
2023 OSL_FAIL( "Content::transfer - Got no XNamed!" );
2024 break;
2025 }
2026
2027 OUString aName = xNamed->getName();
2028
2029 if ( aName.isEmpty() )
2030 {
2031 OSL_FAIL( "Content::transfer - Empty name!" );
2032 break;
2033 }
2034
2035 OUString aChildId = xId->getContentIdentifier();
2036 if ( ( aChildId.lastIndexOf( '/' ) + 1 )
2037 != aChildId.getLength() )
2038 aChildId += OUString("/");
2039
2040 aChildId += ::ucb_impl::urihelper::encodeSegment( aName );
2041
2042 ucb::TransferInfo aInfo;
2043 aInfo.MoveData = sal_False;
2044 aInfo.NewTitle = OUString();
2045 aInfo.SourceURL = aChildId;
2046 aInfo.NameClash = rInfo.NameClash;
2047
2048 // Transfer child to target.
2049 xTarget->transfer( aInfo, xEnv );
2050 }
2051 catch ( container::NoSuchElementException const & )
2052 {
2053 }
2054 catch ( lang::WrappedTargetException const & )
2055 {
2056 }
2057 }
2058 }
2059 }
2060
2061 //////////////////////////////////////////////////////////////////////
2062 // 5) Destroy source ( when moving only ) .
2063 //////////////////////////////////////////////////////////////////////
2064
2065 if ( rInfo.MoveData )
2066 {
2067 xSource->destroy( sal_True, xEnv );
2068
2069 // Remove all persistent data of source and its children.
2070 if ( !xSource->removeData() )
2071 {
2072 uno::Any aProps
2073 = uno::makeAny(
2074 beans::PropertyValue(
2075 OUString( "Uri"),
2076 -1,
2077 uno::makeAny(
2078 xSource->m_xIdentifier->
2079 getContentIdentifier()),
2080 beans::PropertyState_DIRECT_VALUE));
2081 ucbhelper::cancelCommandExecution(
2082 ucb::IOErrorCode_CANT_WRITE,
2083 uno::Sequence< uno::Any >(&aProps, 1),
2084 xEnv,
2085 OUString( "Cannot remove persistent data of source object!" ),
2086 this );
2087 // Unreachable
2088 }
2089
2090 // Remove own and all children's Additional Core Properties.
2091 xSource->removeAdditionalPropertySet( sal_True );
2092 }
2093 }
2094
2095 //=========================================================================
2096 sal_Bool Content::exchangeIdentity(
2097 const uno::Reference< ucb::XContentIdentifier >& xNewId )
2098 {
2099 if ( !xNewId.is() )
2100 return sal_False;
2101
2102 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
2103
2104 uno::Reference< ucb::XContent > xThis = this;
2105
2106 // Already persistent?
2107 if ( m_eState != PERSISTENT )
2108 {
2109 OSL_FAIL( "Content::exchangeIdentity - Not persistent!" );
2110 return sal_False;
2111 }
2112
2113 // Exchange own identitity.
2114
2115 // Fail, if a content with given id already exists.
2116 PackageUri aNewUri( xNewId->getContentIdentifier() );
2117 if ( !hasData( aNewUri ) )
2118 {
2119 OUString aOldURL = m_xIdentifier->getContentIdentifier();
2120
2121 aGuard.clear();
2122 if ( exchange( xNewId ) )
2123 {
2124 m_aUri = aNewUri;
2125 if ( isFolder() )
2126 {
2127 // Process instanciated children...
2128
2129 ContentRefList aChildren;
2130 queryChildren( aChildren );
2131
2132 ContentRefList::const_iterator it = aChildren.begin();
2133 ContentRefList::const_iterator end = aChildren.end();
2134
2135 while ( it != end )
2136 {
2137 ContentRef xChild = (*it);
2138
2139 // Create new content identifier for the child...
2140 uno::Reference< ucb::XContentIdentifier > xOldChildId
2141 = xChild->getIdentifier();
2142 OUString aOldChildURL
2143 = xOldChildId->getContentIdentifier();
2144 OUString aNewChildURL
2145 = aOldChildURL.replaceAt(
2146 0,
2147 aOldURL.getLength(),
2148 xNewId->getContentIdentifier() );
2149 uno::Reference< ucb::XContentIdentifier > xNewChildId
2150 = new ::ucbhelper::ContentIdentifier( aNewChildURL );
2151
2152 if ( !xChild->exchangeIdentity( xNewChildId ) )
2153 return sal_False;
2154
2155 ++it;
2156 }
2157 }
2158 return sal_True;
2159 }
2160 }
2161
2162 OSL_FAIL( "Content::exchangeIdentity - Panic! Cannot exchange identity!" );
2163 return sal_False;
2164 }
2165
2166 //=========================================================================
2167 void Content::queryChildren( ContentRefList& rChildren )
2168 {
2169 // Obtain a list with a snapshot of all currently instanciated contents
2170 // from provider and extract the contents which are direct children
2171 // of this content.
2172
2173 ::ucbhelper::ContentRefList aAllContents;
2174 m_xProvider->queryExistingContents( aAllContents );
2175
2176 OUString aURL = m_xIdentifier->getContentIdentifier();
2177
2178 OSL_ENSURE( aURL.lastIndexOf( '/' ) != ( aURL.getLength() - 1 ),
2179 "Content::queryChildren - Invalid URL!" );
2180
2181 aURL += OUString("/");
2182
2183 sal_Int32 nLen = aURL.getLength();
2184
2185 ::ucbhelper::ContentRefList::const_iterator it = aAllContents.begin();
2186 ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end();
2187
2188 while ( it != end )
2189 {
2190 ::ucbhelper::ContentImplHelperRef xChild = (*it);
2191 OUString aChildURL
2192 = xChild->getIdentifier()->getContentIdentifier();
2193
2194 // Is aURL a prefix of aChildURL?
2195 if ( ( aChildURL.getLength() > nLen ) &&
2196 ( aChildURL.compareTo( aURL, nLen ) == 0 ) )
2197 {
2198 if ( aChildURL.indexOf( '/', nLen ) == -1 )
2199 {
2200 // No further slashes. It's a child!
2201 rChildren.push_back(
2202 ContentRef(
2203 static_cast< Content * >( xChild.get() ) ) );
2204 }
2205 }
2206 ++it;
2207 }
2208 }
2209
2210 //=========================================================================
2211 uno::Reference< container::XHierarchicalNameAccess > Content::getPackage(
2212 const PackageUri& rURI )
2213 {
2214 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2215
2216 uno::Reference< container::XHierarchicalNameAccess > xPackage;
2217 if ( rURI.getPackage() == m_aUri.getPackage() )
2218 {
2219 if ( !m_xPackage.is() )
2220 m_xPackage = m_pProvider->createPackage( m_aUri.getPackage(), m_aUri.getParam() );
2221
2222 return m_xPackage;
2223 }
2224
2225 return m_pProvider->createPackage( rURI.getPackage(), rURI.getParam() );
2226 }
2227
2228 //=========================================================================
2229 uno::Reference< container::XHierarchicalNameAccess > Content::getPackage()
2230 {
2231 return getPackage( m_aUri );
2232 }
2233
2234 //=========================================================================
2235 // static
2236 sal_Bool Content::hasData(
2237 ContentProvider* pProvider,
2238 const PackageUri& rURI,
2239 uno::Reference< container::XHierarchicalNameAccess > & rxPackage )
2240 {
2241 rxPackage = pProvider->createPackage( rURI.getPackage(), rURI.getParam() );
2242 if ( !rxPackage.is() )
2243 return sal_False;
2244
2245 return rxPackage->hasByHierarchicalName( rURI.getPath() );
2246 }
2247
2248 //=========================================================================
2249 sal_Bool Content::hasData( const PackageUri& rURI )
2250 {
2251 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2252
2253 uno::Reference< container::XHierarchicalNameAccess > xPackage;
2254 if ( rURI.getPackage() == m_aUri.getPackage() )
2255 {
2256 xPackage = getPackage();
2257 if ( !xPackage.is() )
2258 return sal_False;
2259
2260 return xPackage->hasByHierarchicalName( rURI.getPath() );
2261 }
2262
2263 return hasData( m_pProvider, rURI, xPackage );
2264 }
2265
2266 //=========================================================================
2267 //static
2268 sal_Bool Content::loadData(
2269 ContentProvider* pProvider,
2270 const PackageUri& rURI,
2271 ContentProperties& rProps,
2272 uno::Reference< container::XHierarchicalNameAccess > & rxPackage )
2273 {
2274 rxPackage = pProvider->createPackage( rURI.getPackage(), rURI.getParam() );
2275 if ( !rxPackage.is() )
2276 return sal_False;
2277
2278 if ( rURI.isRootFolder() )
2279 {
2280 // Properties available only from package
2281 uno::Reference< beans::XPropertySet > xPackagePropSet(
2282 rxPackage, uno::UNO_QUERY );
2283
2284 OSL_ENSURE( xPackagePropSet.is(),
2285 "Content::loadData - "
2286 "Got no XPropertySet interface from package!" );
2287
2288 if ( xPackagePropSet.is() )
2289 {
2290 // HasEncryptedEntries ( only avalibale at root folder )
2291 try
2292 {
2293 uno::Any aHasEncryptedEntries
2294 = xPackagePropSet->getPropertyValue(
2295 OUString( "HasEncryptedEntries" ) );
2296 if ( !( aHasEncryptedEntries >>= rProps.bHasEncryptedEntries ) )
2297 {
2298 OSL_FAIL( "Content::loadData - "
2299 "Got no HasEncryptedEntries value!" );
2300 return sal_False;
2301 }
2302 }
2303 catch ( beans::UnknownPropertyException const & )
2304 {
2305 OSL_FAIL( "Content::loadData - "
2306 "Got no HasEncryptedEntries value!" );
2307 return sal_False;
2308 }
2309 catch ( lang::WrappedTargetException const & )
2310 {
2311 OSL_FAIL( "Content::loadData - "
2312 "Got no HasEncryptedEntries value!" );
2313 return sal_False;
2314 }
2315 }
2316 }
2317
2318 if ( !rxPackage->hasByHierarchicalName( rURI.getPath() ) )
2319 return sal_False;
2320
2321 try
2322 {
2323 uno::Any aEntry = rxPackage->getByHierarchicalName( rURI.getPath() );
2324 if ( aEntry.hasValue() )
2325 {
2326 uno::Reference< beans::XPropertySet > xPropSet;
2327 aEntry >>= xPropSet;
2328
2329 if ( !xPropSet.is() )
2330 {
2331 OSL_FAIL( "Content::loadData - Got no XPropertySet interface!" );
2332 return sal_False;
2333 }
2334
2335 // Title
2336 rProps.aTitle = rURI.getName();
2337
2338 // MediaType
2339 try
2340 {
2341 uno::Any aMediaType
2342 = xPropSet->getPropertyValue(
2343 OUString("MediaType") );
2344 if ( !( aMediaType >>= rProps.aMediaType ) )
2345 {
2346 OSL_FAIL( "Content::loadData - Got no MediaType value!" );
2347 return sal_False;
2348 }
2349 }
2350 catch ( beans::UnknownPropertyException const & )
2351 {
2352 OSL_FAIL( "Content::loadData - Got no MediaType value!" );
2353 return sal_False;
2354 }
2355 catch ( lang::WrappedTargetException const & )
2356 {
2357 OSL_FAIL( "Content::loadData - Got no MediaType value!" );
2358 return sal_False;
2359 }
2360
2361 uno::Reference< container::XEnumerationAccess > xEnumAccess;
2362 aEntry >>= xEnumAccess;
2363
2364 // ContentType / IsFolder / IsDocument
2365 if ( xEnumAccess.is() )
2366 {
2367 // folder
2368 rProps.aContentType = getContentType( rURI.getScheme(), sal_True );
2369 rProps.bIsDocument = sal_False;
2370 rProps.bIsFolder = sal_True;
2371 }
2372 else
2373 {
2374 // stream
2375 rProps.aContentType = getContentType( rURI.getScheme(), sal_False );
2376 rProps.bIsDocument = sal_True;
2377 rProps.bIsFolder = sal_False;
2378 }
2379
2380 if ( rProps.bIsDocument )
2381 {
2382 // Size ( only available for streams )
2383 try
2384 {
2385 uno::Any aSize
2386 = xPropSet->getPropertyValue(
2387 OUString("Size") );
2388 if ( !( aSize >>= rProps.nSize ) )
2389 {
2390 OSL_FAIL( "Content::loadData - Got no Size value!" );
2391 return sal_False;
2392 }
2393 }
2394 catch ( beans::UnknownPropertyException const & )
2395 {
2396 OSL_FAIL( "Content::loadData - Got no Size value!" );
2397 return sal_False;
2398 }
2399 catch ( lang::WrappedTargetException const & )
2400 {
2401 OSL_FAIL( "Content::loadData - Got no Size value!" );
2402 return sal_False;
2403 }
2404
2405 // Compressed ( only available for streams )
2406 try
2407 {
2408 uno::Any aCompressed
2409 = xPropSet->getPropertyValue(
2410 OUString("Compressed") );
2411 if ( !( aCompressed >>= rProps.bCompressed ) )
2412 {
2413 OSL_FAIL( "Content::loadData - Got no Compressed value!" );
2414 return sal_False;
2415 }
2416 }
2417 catch ( beans::UnknownPropertyException const & )
2418 {
2419 OSL_FAIL( "Content::loadData - Got no Compressed value!" );
2420 return sal_False;
2421 }
2422 catch ( lang::WrappedTargetException const & )
2423 {
2424 OSL_FAIL( "Content::loadData - Got no Compressed value!" );
2425 return sal_False;
2426 }
2427
2428 // Encrypted ( only available for streams )
2429 try
2430 {
2431 uno::Any aEncrypted
2432 = xPropSet->getPropertyValue(
2433 OUString("Encrypted") );
2434 if ( !( aEncrypted >>= rProps.bEncrypted ) )
2435 {
2436 OSL_FAIL( "Content::loadData - Got no Encrypted value!" );
2437 return sal_False;
2438 }
2439 }
2440 catch ( beans::UnknownPropertyException const & )
2441 {
2442 OSL_FAIL( "Content::loadData - Got no Encrypted value!" );
2443 return sal_False;
2444 }
2445 catch ( lang::WrappedTargetException const & )
2446 {
2447 OSL_FAIL( "Content::loadData - Got no Encrypted value!" );
2448 return sal_False;
2449 }
2450 }
2451 return sal_True;
2452 }
2453 }
2454 catch ( container::NoSuchElementException const & )
2455 {
2456 // getByHierarchicalName
2457 }
2458
2459 return sal_False;
2460 }
2461
2462 //=========================================================================
2463 sal_Bool Content::renameData(
2464 const uno::Reference< ucb::XContentIdentifier >& xOldId,
2465 const uno::Reference< ucb::XContentIdentifier >& xNewId )
2466 {
2467 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2468
2469 PackageUri aURI( xOldId->getContentIdentifier() );
2470 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage(
2471 aURI );
2472 if ( !xNA.is() )
2473 return sal_False;
2474
2475 if ( !xNA->hasByHierarchicalName( aURI.getPath() ) )
2476 return sal_False;
2477
2478 try
2479 {
2480 uno::Any aEntry = xNA->getByHierarchicalName( aURI.getPath() );
2481 uno::Reference< container::XNamed > xNamed;
2482 aEntry >>= xNamed;
2483
2484 if ( !xNamed.is() )
2485 {
2486 OSL_FAIL( "Content::renameData - Got no XNamed interface!" );
2487 return sal_False;
2488 }
2489
2490 PackageUri aNewURI( xNewId->getContentIdentifier() );
2491
2492 // No success indicator!? No return value / exceptions specified.
2493 xNamed->setName( aNewURI.getName() );
2494
2495 return sal_True;
2496 }
2497 catch ( container::NoSuchElementException const & )
2498 {
2499 // getByHierarchicalName
2500 }
2501
2502 return sal_False;
2503 }
2504
2505 //=========================================================================
2506 sal_Bool Content::storeData( const uno::Reference< io::XInputStream >& xStream )
2507 {
2508 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2509
2510 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage();
2511 if ( !xNA.is() )
2512 return sal_False;
2513
2514 uno::Reference< beans::XPropertySet > xPackagePropSet(
2515 xNA, uno::UNO_QUERY );
2516 OSL_ENSURE( xPackagePropSet.is(),
2517 "Content::storeData - "
2518 "Got no XPropertySet interface from package!" );
2519
2520 if ( !xPackagePropSet.is() )
2521 return sal_False;
2522
2523 if ( m_nModifiedProps & ENCRYPTIONKEY_MODIFIED )
2524 {
2525 if ( m_aUri.isRootFolder() )
2526 {
2527 // Property available only from package and from streams (see below)
2528 try
2529 {
2530 xPackagePropSet->setPropertyValue(
2531 OUString("EncryptionKey"),
2532 uno::makeAny( m_aProps.aEncryptionKey ) );
2533 m_nModifiedProps &= ~ENCRYPTIONKEY_MODIFIED;
2534 }
2535 catch ( beans::UnknownPropertyException const & )
2536 {
2537 // setPropertyValue
2538 }
2539 catch ( beans::PropertyVetoException const & )
2540 {
2541 // setPropertyValue
2542 }
2543 catch ( lang::IllegalArgumentException const & )
2544 {
2545 // setPropertyValue
2546 }
2547 catch ( lang::WrappedTargetException const & )
2548 {
2549 // setPropertyValue
2550 }
2551 }
2552 }
2553
2554 if ( !xNA->hasByHierarchicalName( m_aUri.getPath() ) )
2555 {
2556 // if ( !bCreate )
2557 // return sal_True;
2558
2559 try
2560 {
2561 // Create new resource...
2562 uno::Reference< lang::XSingleServiceFactory > xFac(
2563 xNA, uno::UNO_QUERY );
2564 if ( !xFac.is() )
2565 {
2566 OSL_FAIL( "Content::storeData - "
2567 "Got no XSingleServiceFactory interface!" );
2568 return sal_False;
2569 }
2570
2571 uno::Sequence< uno::Any > aArgs( 1 );
2572 aArgs[ 0 ] <<= isFolder();
2573
2574 uno::Reference< uno::XInterface > xNew
2575 = xFac->createInstanceWithArguments( aArgs );
2576
2577 if ( !xNew.is() )
2578 {
2579 OSL_FAIL( "Content::storeData - createInstance failed!" );
2580 return sal_False;
2581 }
2582
2583 PackageUri aParentUri( getParentURL() );
2584 uno::Any aEntry
2585 = xNA->getByHierarchicalName( aParentUri.getPath() );
2586 uno::Reference< container::XNameContainer > xParentContainer;
2587 aEntry >>= xParentContainer;
2588
2589 if ( !xParentContainer.is() )
2590 {
2591 OSL_FAIL( "Content::storeData - "
2592 "Got no XNameContainer interface!" );
2593 return sal_False;
2594 }
2595
2596 xParentContainer->insertByName( m_aProps.aTitle,
2597 uno::makeAny( xNew ) );
2598 }
2599 catch ( lang::IllegalArgumentException const & )
2600 {
2601 // insertByName
2602 OSL_FAIL( "Content::storeData - insertByName failed!" );
2603 return sal_False;
2604 }
2605 catch ( uno::RuntimeException const & )
2606 {
2607 throw;
2608 }
2609 catch ( container::ElementExistException const & )
2610 {
2611 // insertByName
2612 OSL_FAIL( "Content::storeData - insertByName failed!" );
2613 return sal_False;
2614 }
2615 catch ( lang::WrappedTargetException const & )
2616 {
2617 // insertByName
2618 OSL_FAIL( "Content::storeData - insertByName failed!" );
2619 return sal_False;
2620 }
2621 catch ( container::NoSuchElementException const & )
2622 {
2623 // getByHierarchicalName
2624 OSL_FAIL( "Content::storeData - getByHierarchicalName failed!" );
2625 return sal_False;
2626 }
2627 catch ( uno::Exception const & )
2628 {
2629 // createInstanceWithArguments
2630 OSL_FAIL( "Content::storeData - Error!" );
2631 return sal_False;
2632 }
2633 }
2634
2635 if ( !xNA->hasByHierarchicalName( m_aUri.getPath() ) )
2636 return sal_False;
2637
2638 try
2639 {
2640 uno::Reference< beans::XPropertySet > xPropSet;
2641 xNA->getByHierarchicalName( m_aUri.getPath() ) >>= xPropSet;
2642
2643 if ( !xPropSet.is() )
2644 {
2645 OSL_FAIL( "Content::storeData - Got no XPropertySet interface!" );
2646 return sal_False;
2647 }
2648
2649 //////////////////////////////////////////////////////////////////
2650 // Store property values...
2651 //////////////////////////////////////////////////////////////////
2652
2653 if ( m_nModifiedProps & MEDIATYPE_MODIFIED )
2654 {
2655 xPropSet->setPropertyValue(
2656 OUString("MediaType"),
2657 uno::makeAny( m_aProps.aMediaType ) );
2658 m_nModifiedProps &= ~MEDIATYPE_MODIFIED;
2659 }
2660
2661 if ( m_nModifiedProps & COMPRESSED_MODIFIED )
2662 {
2663 if ( !isFolder() )
2664 xPropSet->setPropertyValue(
2665 OUString("Compressed"),
2666 uno::makeAny( m_aProps.bCompressed ) );
2667
2668 m_nModifiedProps &= ~COMPRESSED_MODIFIED;
2669 }
2670
2671 if ( m_nModifiedProps & ENCRYPTED_MODIFIED )
2672 {
2673 if ( !isFolder() )
2674 xPropSet->setPropertyValue(
2675 OUString("Encrypted"),
2676 uno::makeAny( m_aProps.bEncrypted ) );
2677
2678 m_nModifiedProps &= ~ENCRYPTED_MODIFIED;
2679 }
2680
2681 if ( m_nModifiedProps & ENCRYPTIONKEY_MODIFIED )
2682 {
2683 if ( !isFolder() )
2684 xPropSet->setPropertyValue(
2685 OUString("EncryptionKey"),
2686 uno::makeAny( m_aProps.aEncryptionKey ) );
2687
2688 m_nModifiedProps &= ~ENCRYPTIONKEY_MODIFIED;
2689 }
2690
2691 //////////////////////////////////////////////////////////////////
2692 // Store data stream...
2693 //////////////////////////////////////////////////////////////////
2694
2695 if ( xStream.is() && !isFolder() )
2696 {
2697 uno::Reference< io::XActiveDataSink > xSink(
2698 xPropSet, uno::UNO_QUERY );
2699
2700 if ( !xSink.is() )
2701 {
2702 OSL_FAIL( "Content::storeData - "
2703 "Got no XActiveDataSink interface!" );
2704 return sal_False;
2705 }
2706
2707 xSink->setInputStream( xStream );
2708 }
2709
2710 return sal_True;
2711 }
2712 catch ( container::NoSuchElementException const & )
2713 {
2714 // getByHierarchicalName
2715 }
2716 catch ( beans::UnknownPropertyException const & )
2717 {
2718 // setPropertyValue
2719 }
2720 catch ( beans::PropertyVetoException const & )
2721 {
2722 // setPropertyValue
2723 }
2724 catch ( lang::IllegalArgumentException const & )
2725 {
2726 // setPropertyValue
2727 }
2728 catch ( lang::WrappedTargetException const & )
2729 {
2730 // setPropertyValue
2731 }
2732
2733 OSL_FAIL( "Content::storeData - Error!" );
2734 return sal_False;
2735 }
2736
2737 //=========================================================================
2738 sal_Bool Content::removeData()
2739 {
2740 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2741
2742 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage();
2743 if ( !xNA.is() )
2744 return sal_False;
2745
2746 PackageUri aParentUri( getParentURL() );
2747 if ( !xNA->hasByHierarchicalName( aParentUri.getPath() ) )
2748 return sal_False;
2749
2750 try
2751 {
2752 uno::Any aEntry = xNA->getByHierarchicalName( aParentUri.getPath() );
2753 uno::Reference< container::XNameContainer > xContainer;
2754 aEntry >>= xContainer;
2755
2756 if ( !xContainer.is() )
2757 {
2758 OSL_FAIL( "Content::removeData - "
2759 "Got no XNameContainer interface!" );
2760 return sal_False;
2761 }
2762
2763 xContainer->removeByName( m_aUri.getName() );
2764 return sal_True;
2765 }
2766 catch ( container::NoSuchElementException const & )
2767 {
2768 // getByHierarchicalName, removeByName
2769 }
2770 catch ( lang::WrappedTargetException const & )
2771 {
2772 // removeByName
2773 }
2774
2775 OSL_FAIL( "Content::removeData - Error!" );
2776 return sal_False;
2777 }
2778
2779 //=========================================================================
2780 sal_Bool Content::flushData()
2781 {
2782 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2783
2784 // Note: XChangesBatch is only implemented by the package itself, not
2785 // by the single entries. Maybe this has to change...
2786
2787 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage();
2788 if ( !xNA.is() )
2789 return sal_False;
2790
2791 uno::Reference< util::XChangesBatch > xBatch( xNA, uno::UNO_QUERY );
2792 if ( !xBatch.is() )
2793 {
2794 OSL_FAIL( "Content::flushData - Got no XChangesBatch interface!" );
2795 return sal_False;
2796 }
2797
2798 try
2799 {
2800 xBatch->commitChanges();
2801 return sal_True;
2802 }
2803 catch ( lang::WrappedTargetException const & )
2804 {
2805 }
2806
2807 OSL_FAIL( "Content::flushData - Error!" );
2808 return sal_False;
2809 }
2810
2811 //=========================================================================
2812 uno::Reference< io::XInputStream > Content::getInputStream()
2813 {
2814 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2815
2816 uno::Reference< io::XInputStream > xStream;
2817 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage();
2818 if ( !xNA.is() )
2819 return xStream;
2820
2821 if ( !xNA->hasByHierarchicalName( m_aUri.getPath() ) )
2822 return xStream;
2823
2824 try
2825 {
2826 uno::Any aEntry = xNA->getByHierarchicalName( m_aUri.getPath() );
2827 uno::Reference< io::XActiveDataSink > xSink;
2828 aEntry >>= xSink;
2829
2830 if ( !xSink.is() )
2831 {
2832 OSL_FAIL( "Content::getInputStream - "
2833 "Got no XActiveDataSink interface!" );
2834 return xStream;
2835 }
2836
2837 xStream = xSink->getInputStream();
2838
2839 OSL_ENSURE( xStream.is(),
2840 "Content::getInputStream - Got no stream!" );
2841 }
2842 catch ( container::NoSuchElementException const & )
2843 {
2844 // getByHierarchicalName
2845 }
2846
2847 return xStream;
2848 }
2849
2850 //=========================================================================
2851 uno::Reference< container::XEnumeration > Content::getIterator()
2852 {
2853 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2854
2855 uno::Reference< container::XEnumeration > xIter;
2856 uno::Reference< container::XHierarchicalNameAccess > xNA = getPackage();
2857 if ( !xNA.is() )
2858 return xIter;
2859
2860 if ( !xNA->hasByHierarchicalName( m_aUri.getPath() ) )
2861 return xIter;
2862
2863 try
2864 {
2865 uno::Any aEntry = xNA->getByHierarchicalName( m_aUri.getPath() );
2866 uno::Reference< container::XEnumerationAccess > xIterFac;
2867 aEntry >>= xIterFac;
2868
2869 if ( !xIterFac.is() )
2870 {
2871 OSL_FAIL( "Content::getIterator - "
2872 "Got no XEnumerationAccess interface!" );
2873 return xIter;
2874 }
2875
2876 xIter = xIterFac->createEnumeration();
2877
2878 OSL_ENSURE( xIter.is(),
2879 "Content::getIterator - Got no iterator!" );
2880 }
2881 catch ( container::NoSuchElementException const & )
2882 {
2883 // getByHierarchicalName
2884 }
2885
2886 return xIter;
2887 }
2888
2889 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE