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