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 : #include <rtl/uri.hxx>
21 : #include <rtl/ustrbuf.hxx>
22 : #include <osl/file.hxx>
23 :
24 : #include "osl/diagnose.h"
25 : #include <com/sun/star/ucb/OpenMode.hpp>
26 : #include <com/sun/star/beans/PropertyAttribute.hpp>
27 : #include <com/sun/star/ucb/XProgressHandler.hpp>
28 : #include <com/sun/star/task/XInteractionHandler.hpp>
29 : #include <com/sun/star/io/XActiveDataStreamer.hpp>
30 : #include <com/sun/star/io/XOutputStream.hpp>
31 : #include <com/sun/star/ucb/NumberedSortingInfo.hpp>
32 : #include <com/sun/star/io/XActiveDataSink.hpp>
33 : #include <com/sun/star/beans/PropertyChangeEvent.hpp>
34 : #include <com/sun/star/beans/PropertySetInfoChange.hpp>
35 : #include <com/sun/star/ucb/ContentAction.hpp>
36 : #include <com/sun/star/ucb/NameClash.hpp>
37 : #include <cppuhelper/supportsservice.hxx>
38 : #include "filglob.hxx"
39 : #include "filid.hxx"
40 : #include "filrow.hxx"
41 : #include "bc.hxx"
42 : #include "prov.hxx"
43 : #include "filerror.hxx"
44 : #include "filinsreq.hxx"
45 :
46 : using namespace fileaccess;
47 : using namespace com::sun::star;
48 : using namespace com::sun::star::uno;
49 : using namespace com::sun::star::ucb;
50 :
51 : #if OSL_DEBUG_LEVEL > 0
52 : #define THROW_WHERE SAL_WHERE
53 : #else
54 : #define THROW_WHERE ""
55 : #endif
56 :
57 : typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString>
58 : PropertyListeners_impl;
59 :
60 19620 : class fileaccess::PropertyListeners
61 : : public PropertyListeners_impl
62 : {
63 : public:
64 19620 : explicit PropertyListeners( ::osl::Mutex& aMutex )
65 19620 : : PropertyListeners_impl( aMutex )
66 : {
67 19620 : }
68 : };
69 :
70 :
71 : /****************************************************************************************/
72 : /* */
73 : /* BaseContent */
74 : /* */
75 : /****************************************************************************************/
76 :
77 :
78 : // Private Constructor for just inserted Contents
79 :
80 3774 : BaseContent::BaseContent( shell* pMyShell,
81 : const OUString& parentName,
82 : bool bFolder )
83 : : m_pMyShell( pMyShell ),
84 : m_xContentIdentifier( 0 ),
85 : m_aUncPath( parentName ),
86 : m_bFolder( bFolder ),
87 : m_nState( JustInserted ),
88 : m_pDisposeEventListeners( 0 ),
89 : m_pContentEventListeners( 0 ),
90 : m_pPropertySetInfoChangeListeners( 0 ),
91 3774 : m_pPropertyListener( 0 )
92 : {
93 3774 : m_pMyShell->m_pProvider->acquire();
94 : // No registering, since we have no name
95 3774 : }
96 :
97 :
98 :
99 : // Constructor for full featured Contents
100 :
101 120925 : BaseContent::BaseContent( shell* pMyShell,
102 : const Reference< XContentIdentifier >& xContentIdentifier,
103 : const OUString& aUncPath )
104 : : m_pMyShell( pMyShell ),
105 : m_xContentIdentifier( xContentIdentifier ),
106 : m_aUncPath( aUncPath ),
107 : m_bFolder( false ),
108 : m_nState( FullFeatured ),
109 : m_pDisposeEventListeners( 0 ),
110 : m_pContentEventListeners( 0 ),
111 : m_pPropertySetInfoChangeListeners( 0 ),
112 120925 : m_pPropertyListener( 0 )
113 : {
114 120925 : m_pMyShell->m_pProvider->acquire();
115 120925 : m_pMyShell->registerNotifier( m_aUncPath,this );
116 120925 : m_pMyShell->insertDefaultProperties( m_aUncPath );
117 120925 : }
118 :
119 :
120 373737 : BaseContent::~BaseContent( )
121 : {
122 124579 : if( ( m_nState & FullFeatured ) || ( m_nState & Deleted ) )
123 : {
124 123599 : m_pMyShell->deregisterNotifier( m_aUncPath,this );
125 : }
126 124579 : m_pMyShell->m_pProvider->release();
127 :
128 124579 : delete m_pDisposeEventListeners;
129 124579 : delete m_pContentEventListeners;
130 124579 : delete m_pPropertyListener;
131 124579 : delete m_pPropertySetInfoChangeListeners;
132 249158 : }
133 :
134 :
135 :
136 : // XInterface
137 :
138 :
139 : void SAL_CALL
140 1643270 : BaseContent::acquire()
141 : throw()
142 : {
143 1643270 : OWeakObject::acquire();
144 1643270 : }
145 :
146 :
147 : void SAL_CALL
148 1643078 : BaseContent::release()
149 : throw()
150 : {
151 1643078 : OWeakObject::release();
152 1643078 : }
153 :
154 :
155 : Any SAL_CALL
156 155931 : BaseContent::queryInterface( const Type& rType )
157 : throw( RuntimeException, std::exception )
158 : {
159 : Any aRet = cppu::queryInterface( rType,
160 : (static_cast< lang::XComponent* >(this)),
161 : (static_cast< lang::XTypeProvider* >(this)),
162 : (static_cast< lang::XServiceInfo* >(this)),
163 : (static_cast< XCommandProcessor* >(this)),
164 : (static_cast< container::XChild* >(this)),
165 : (static_cast< beans::XPropertiesChangeNotifier* >(this)),
166 : (static_cast< beans::XPropertyContainer* >(this)),
167 : (static_cast< XContentCreator* >(this)),
168 : (static_cast< beans::XPropertySetInfoChangeNotifier* >(this)),
169 155931 : (static_cast< XContent* >(this)) );
170 155931 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
171 : }
172 :
173 :
174 :
175 :
176 :
177 : // XComponent
178 :
179 :
180 : void SAL_CALL
181 0 : BaseContent::addEventListener( const Reference< lang::XEventListener >& Listener )
182 : throw( RuntimeException, std::exception )
183 : {
184 0 : osl::MutexGuard aGuard( m_aMutex );
185 :
186 0 : if ( ! m_pDisposeEventListeners )
187 : m_pDisposeEventListeners =
188 0 : new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
189 :
190 0 : m_pDisposeEventListeners->addInterface( Listener );
191 0 : }
192 :
193 :
194 : void SAL_CALL
195 0 : BaseContent::removeEventListener( const Reference< lang::XEventListener >& Listener )
196 : throw( RuntimeException, std::exception )
197 : {
198 0 : osl::MutexGuard aGuard( m_aMutex );
199 :
200 0 : if ( m_pDisposeEventListeners )
201 0 : m_pDisposeEventListeners->removeInterface( Listener );
202 0 : }
203 :
204 :
205 : void SAL_CALL
206 0 : BaseContent::dispose()
207 : throw( RuntimeException, std::exception )
208 : {
209 0 : lang::EventObject aEvt;
210 : cppu::OInterfaceContainerHelper* pDisposeEventListeners;
211 : cppu::OInterfaceContainerHelper* pContentEventListeners;
212 : cppu::OInterfaceContainerHelper* pPropertySetInfoChangeListeners;
213 : PropertyListeners* pPropertyListener;
214 :
215 : {
216 0 : osl::MutexGuard aGuard( m_aMutex );
217 0 : aEvt.Source = static_cast< XContent* >( this );
218 :
219 :
220 : pDisposeEventListeners =
221 0 : m_pDisposeEventListeners, m_pDisposeEventListeners = 0;
222 :
223 : pContentEventListeners =
224 0 : m_pContentEventListeners, m_pContentEventListeners = 0;
225 :
226 : pPropertySetInfoChangeListeners =
227 : m_pPropertySetInfoChangeListeners,
228 0 : m_pPropertySetInfoChangeListeners = 0;
229 :
230 : pPropertyListener =
231 0 : m_pPropertyListener, m_pPropertyListener = 0;
232 : }
233 :
234 0 : if ( pDisposeEventListeners && pDisposeEventListeners->getLength() )
235 0 : pDisposeEventListeners->disposeAndClear( aEvt );
236 :
237 0 : if ( pContentEventListeners && pContentEventListeners->getLength() )
238 0 : pContentEventListeners->disposeAndClear( aEvt );
239 :
240 0 : if( pPropertyListener )
241 0 : pPropertyListener->disposeAndClear( aEvt );
242 :
243 0 : if( pPropertySetInfoChangeListeners )
244 0 : pPropertySetInfoChangeListeners->disposeAndClear( aEvt );
245 :
246 0 : delete pDisposeEventListeners;
247 0 : delete pContentEventListeners;
248 0 : delete pPropertyListener;
249 0 : delete pPropertySetInfoChangeListeners;
250 0 : }
251 :
252 : // XServiceInfo
253 : OUString SAL_CALL
254 0 : BaseContent::getImplementationName()
255 : throw( RuntimeException, std::exception)
256 : {
257 0 : return OUString("com.sun.star.comp.ucb.FileContent");
258 : }
259 :
260 : sal_Bool SAL_CALL
261 0 : BaseContent::supportsService( const OUString& ServiceName )
262 : throw( RuntimeException, std::exception)
263 : {
264 0 : return cppu::supportsService( this, ServiceName );
265 : }
266 :
267 : Sequence< OUString > SAL_CALL
268 0 : BaseContent::getSupportedServiceNames()
269 : throw( RuntimeException, std::exception )
270 : {
271 0 : Sequence< OUString > ret( 1 );
272 0 : ret[0] = "com.sun.star.ucb.FileContent";
273 0 : return ret;
274 : }
275 :
276 : // XTypeProvider
277 0 : XTYPEPROVIDER_IMPL_10( BaseContent,
278 : lang::XComponent,
279 : lang::XTypeProvider,
280 : lang::XServiceInfo,
281 : XCommandProcessor,
282 : XContentCreator,
283 : XContent,
284 : container::XChild,
285 : beans::XPropertiesChangeNotifier,
286 : beans::XPropertyContainer,
287 : beans::XPropertySetInfoChangeNotifier )
288 :
289 :
290 :
291 : // XCommandProcessor
292 :
293 :
294 : sal_Int32 SAL_CALL
295 195041 : BaseContent::createCommandIdentifier()
296 : throw( RuntimeException, std::exception )
297 : {
298 195041 : return m_pMyShell->getCommandId();
299 : }
300 :
301 :
302 : void SAL_CALL
303 0 : BaseContent::abort( sal_Int32 CommandId )
304 : throw( RuntimeException, std::exception )
305 : {
306 0 : m_pMyShell->abort( CommandId );
307 0 : }
308 :
309 :
310 : Any SAL_CALL
311 195041 : BaseContent::execute( const Command& aCommand,
312 : sal_Int32 CommandId,
313 : const Reference< XCommandEnvironment >& Environment )
314 : throw( Exception,
315 : CommandAbortedException,
316 : RuntimeException, std::exception )
317 : {
318 195041 : if( ! CommandId )
319 : // A Command with commandid zero cannot be aborted
320 195041 : CommandId = createCommandIdentifier();
321 :
322 : m_pMyShell->startTask( CommandId,
323 195041 : Environment );
324 :
325 195041 : Any aAny;
326 :
327 195041 : if (aCommand.Name == "getPropertySetInfo") // No exceptions
328 : {
329 17668 : aAny <<= getPropertySetInfo( CommandId );
330 : }
331 177373 : else if (aCommand.Name == "getCommandInfo") // no exceptions
332 : {
333 10 : aAny <<= getCommandInfo();
334 : }
335 177363 : else if ( aCommand.Name == "setPropertyValues" )
336 : {
337 4625 : Sequence< beans::PropertyValue > sPropertyValues;
338 :
339 4625 : if( ! ( aCommand.Argument >>= sPropertyValues ) )
340 : m_pMyShell->installError( CommandId,
341 0 : TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT );
342 : else
343 4625 : aAny <<= setPropertyValues( CommandId,sPropertyValues ); // calls endTask by itself
344 : }
345 172738 : else if ( aCommand.Name == "getPropertyValues" )
346 : {
347 63891 : Sequence< beans::Property > ListOfRequestedProperties;
348 :
349 63891 : if( ! ( aCommand.Argument >>= ListOfRequestedProperties ) )
350 : m_pMyShell->installError( CommandId,
351 0 : TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT );
352 : else
353 127782 : aAny <<= getPropertyValues( CommandId,
354 127782 : ListOfRequestedProperties );
355 : }
356 108847 : else if ( aCommand.Name == "open" )
357 : {
358 89574 : OpenCommandArgument2 aOpenArgument;
359 89574 : if( ! ( aCommand.Argument >>= aOpenArgument ) )
360 : m_pMyShell->installError( CommandId,
361 0 : TASKHANDLING_WRONG_OPEN_ARGUMENT );
362 : else
363 : {
364 89574 : Reference< XDynamicResultSet > result = open( CommandId,aOpenArgument );
365 89574 : if( result.is() )
366 55829 : aAny <<= result;
367 89574 : }
368 : }
369 19273 : else if ( aCommand.Name == "delete" )
370 : {
371 2621 : if( ! aCommand.Argument.has< sal_Bool >() )
372 : m_pMyShell->installError( CommandId,
373 0 : TASKHANDLING_WRONG_DELETE_ARGUMENT );
374 : else
375 2621 : deleteContent( CommandId );
376 : }
377 16652 : else if ( aCommand.Name == "transfer" )
378 : {
379 3571 : TransferInfo aTransferInfo;
380 3571 : if( ! ( aCommand.Argument >>= aTransferInfo ) )
381 : m_pMyShell->installError( CommandId,
382 0 : TASKHANDLING_WRONG_TRANSFER_ARGUMENT );
383 : else
384 3571 : transfer( CommandId, aTransferInfo );
385 : }
386 13081 : else if ( aCommand.Name == "insert" )
387 : {
388 9250 : InsertCommandArgument aInsertArgument;
389 9250 : if( ! ( aCommand.Argument >>= aInsertArgument ) )
390 : m_pMyShell->installError( CommandId,
391 0 : TASKHANDLING_WRONG_INSERT_ARGUMENT );
392 : else
393 9250 : insert( CommandId,aInsertArgument );
394 : }
395 3831 : else if ( aCommand.Name == "getCasePreservingURL" )
396 : {
397 57 : Sequence< beans::Property > seq(1);
398 171 : seq[0] = beans::Property(
399 : OUString("CasePreservingURL"),
400 : -1,
401 57 : cppu::UnoType<sal_Bool>::get(),
402 57 : 0 );
403 114 : Reference< sdbc::XRow > xRow = getPropertyValues( CommandId,seq );
404 114 : OUString CasePreservingURL = xRow->getString(1);
405 57 : if(!xRow->wasNull())
406 114 : aAny <<= CasePreservingURL;
407 : }
408 3774 : else if ( aCommand.Name == "createNewContent" )
409 : {
410 3774 : ucb::ContentInfo aArg;
411 3774 : if ( !( aCommand.Argument >>= aArg ) )
412 : m_pMyShell->installError( CommandId,
413 0 : TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT );
414 : else
415 3774 : aAny <<= createNewContent( aArg );
416 : }
417 : else
418 : m_pMyShell->installError( CommandId,
419 0 : TASKHANDLER_UNSUPPORTED_COMMAND );
420 :
421 :
422 : // This is the only function allowed to throw an exception
423 195041 : endTask( CommandId );
424 :
425 171027 : return aAny;
426 : }
427 :
428 :
429 :
430 : void SAL_CALL
431 19620 : BaseContent::addPropertiesChangeListener(
432 : const Sequence< OUString >& PropertyNames,
433 : const Reference< beans::XPropertiesChangeListener >& Listener )
434 : throw( RuntimeException, std::exception )
435 : {
436 19620 : if( ! Listener.is() )
437 19620 : return;
438 :
439 19620 : osl::MutexGuard aGuard( m_aMutex );
440 :
441 19620 : if( ! m_pPropertyListener )
442 19620 : m_pPropertyListener = new PropertyListeners( m_aEventListenerMutex );
443 :
444 :
445 19620 : if( PropertyNames.getLength() == 0 )
446 19620 : m_pPropertyListener->addInterface( OUString(),Listener );
447 : else
448 : {
449 0 : Reference< beans::XPropertySetInfo > xProp = m_pMyShell->info_p( m_aUncPath );
450 0 : for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
451 0 : if( xProp->hasPropertyByName( PropertyNames[i] ) )
452 0 : m_pPropertyListener->addInterface( PropertyNames[i],Listener );
453 19620 : }
454 : }
455 :
456 :
457 : void SAL_CALL
458 19620 : BaseContent::removePropertiesChangeListener( const Sequence< OUString >& PropertyNames,
459 : const Reference< beans::XPropertiesChangeListener >& Listener )
460 : throw( RuntimeException, std::exception )
461 : {
462 19620 : if( ! Listener.is() )
463 0 : return;
464 :
465 19620 : osl::MutexGuard aGuard( m_aMutex );
466 :
467 19620 : if( ! m_pPropertyListener )
468 0 : return;
469 :
470 19620 : for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
471 0 : m_pPropertyListener->removeInterface( PropertyNames[i],Listener );
472 :
473 19620 : m_pPropertyListener->removeInterface( OUString(), Listener );
474 : }
475 :
476 :
477 :
478 : // XContent
479 :
480 :
481 : Reference< ucb::XContentIdentifier > SAL_CALL
482 55896 : BaseContent::getIdentifier()
483 : throw( RuntimeException, std::exception )
484 : {
485 55896 : return m_xContentIdentifier;
486 : }
487 :
488 :
489 : OUString SAL_CALL
490 0 : BaseContent::getContentType()
491 : throw( RuntimeException, std::exception )
492 : {
493 0 : if( !( m_nState & Deleted ) )
494 : {
495 0 : if( m_nState & JustInserted )
496 : {
497 0 : if ( m_bFolder )
498 0 : return m_pMyShell->FolderContentType;
499 : else
500 0 : return m_pMyShell->FileContentType;
501 : }
502 : else
503 : {
504 : try
505 : {
506 : // Who am I ?
507 0 : Sequence< beans::Property > seq(1);
508 0 : seq[0] = beans::Property( OUString("IsDocument"),
509 : -1,
510 0 : cppu::UnoType<sal_Bool>::get(),
511 0 : 0 );
512 0 : Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
513 0 : bool IsDocument = xRow->getBoolean( 1 );
514 :
515 0 : if ( !xRow->wasNull() )
516 : {
517 0 : if ( IsDocument )
518 0 : return m_pMyShell->FileContentType;
519 : else
520 0 : return m_pMyShell->FolderContentType;
521 : }
522 : else
523 : {
524 : OSL_FAIL( "BaseContent::getContentType - Property value was null!" );
525 0 : }
526 : }
527 0 : catch (const sdbc::SQLException&)
528 : {
529 : OSL_FAIL( "BaseContent::getContentType - Caught SQLException!" );
530 : }
531 : }
532 : }
533 :
534 0 : return OUString();
535 : }
536 :
537 :
538 :
539 : void SAL_CALL
540 142867 : BaseContent::addContentEventListener(
541 : const Reference< XContentEventListener >& Listener )
542 : throw( RuntimeException, std::exception )
543 : {
544 142867 : osl::MutexGuard aGuard( m_aMutex );
545 :
546 142867 : if ( ! m_pContentEventListeners )
547 : m_pContentEventListeners =
548 113509 : new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
549 :
550 :
551 142867 : m_pContentEventListeners->addInterface( Listener );
552 142867 : }
553 :
554 :
555 : void SAL_CALL
556 142750 : BaseContent::removeContentEventListener(
557 : const Reference< XContentEventListener >& Listener )
558 : throw( RuntimeException, std::exception )
559 : {
560 142750 : osl::MutexGuard aGuard( m_aMutex );
561 :
562 142750 : if ( m_pContentEventListeners )
563 142750 : m_pContentEventListeners->removeInterface( Listener );
564 142750 : }
565 :
566 :
567 :
568 :
569 : // XPropertyContainer
570 :
571 :
572 :
573 : void SAL_CALL
574 0 : BaseContent::addProperty(
575 : const OUString& Name,
576 : sal_Int16 Attributes,
577 : const Any& DefaultValue )
578 : throw( beans::PropertyExistException,
579 : beans::IllegalTypeException,
580 : lang::IllegalArgumentException,
581 : RuntimeException, std::exception)
582 : {
583 0 : if( ( m_nState & JustInserted ) || ( m_nState & Deleted ) || Name.isEmpty() )
584 : {
585 0 : throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 0 );
586 : }
587 :
588 0 : m_pMyShell->associate( m_aUncPath,Name,DefaultValue,Attributes );
589 0 : }
590 :
591 :
592 : void SAL_CALL
593 0 : BaseContent::removeProperty(
594 : const OUString& Name )
595 : throw( beans::UnknownPropertyException,
596 : beans::NotRemoveableException,
597 : RuntimeException, std::exception)
598 : {
599 :
600 0 : if( m_nState & Deleted )
601 0 : throw beans::UnknownPropertyException( THROW_WHERE );
602 :
603 0 : m_pMyShell->deassociate( m_aUncPath, Name );
604 0 : }
605 :
606 :
607 : // XContentCreator
608 :
609 :
610 : Sequence< ContentInfo > SAL_CALL
611 0 : BaseContent::queryCreatableContentsInfo(
612 : void )
613 : throw( RuntimeException, std::exception )
614 : {
615 0 : return m_pMyShell->queryCreatableContentsInfo();
616 : }
617 :
618 :
619 : Reference< XContent > SAL_CALL
620 3774 : BaseContent::createNewContent(
621 : const ContentInfo& Info )
622 : throw( RuntimeException, std::exception )
623 : {
624 : // Check type.
625 3774 : if ( Info.Type.isEmpty() )
626 0 : return Reference< XContent >();
627 :
628 3774 : bool bFolder = Info.Type == m_pMyShell->FolderContentType;
629 3774 : if ( !bFolder )
630 : {
631 6 : if ( Info.Type != m_pMyShell->FileContentType )
632 : {
633 : // Neither folder nor file to create!
634 0 : return Reference< XContent >();
635 : }
636 : }
637 :
638 : // Who am I ?
639 3774 : bool IsDocument = false;
640 :
641 : try
642 : {
643 3774 : Sequence< beans::Property > seq(1);
644 11322 : seq[0] = beans::Property( OUString("IsDocument"),
645 : -1,
646 3774 : cppu::UnoType<sal_Bool>::get(),
647 3774 : 0 );
648 7548 : Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
649 3774 : IsDocument = xRow->getBoolean( 1 );
650 :
651 3774 : if ( xRow->wasNull() )
652 : {
653 0 : IsDocument = false;
654 : // OSL_FAIL( // "BaseContent::createNewContent - Property value was null!" );
655 : // return Reference< XContent >();
656 3774 : }
657 : }
658 0 : catch (const sdbc::SQLException&)
659 : {
660 : OSL_FAIL( "BaseContent::createNewContent - Caught SQLException!" );
661 0 : return Reference< XContent >();
662 : }
663 :
664 3774 : OUString dstUncPath;
665 :
666 3774 : if( IsDocument )
667 : {
668 : // KSO: Why is a document a XContentCreator? This is quite unusual.
669 0 : dstUncPath = getParentName( m_aUncPath );
670 : }
671 : else
672 3774 : dstUncPath = m_aUncPath;
673 :
674 3774 : BaseContent* p = new BaseContent( m_pMyShell, dstUncPath, bFolder );
675 3774 : return Reference< XContent >( p );
676 : }
677 :
678 :
679 :
680 : // XPropertySetInfoChangeNotifier
681 :
682 :
683 :
684 : void SAL_CALL
685 0 : BaseContent::addPropertySetInfoChangeListener(
686 : const Reference< beans::XPropertySetInfoChangeListener >& Listener )
687 : throw( RuntimeException, std::exception )
688 : {
689 0 : osl::MutexGuard aGuard( m_aMutex );
690 0 : if( ! m_pPropertySetInfoChangeListeners )
691 0 : m_pPropertySetInfoChangeListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
692 :
693 0 : m_pPropertySetInfoChangeListeners->addInterface( Listener );
694 0 : }
695 :
696 :
697 : void SAL_CALL
698 0 : BaseContent::removePropertySetInfoChangeListener(
699 : const Reference< beans::XPropertySetInfoChangeListener >& Listener )
700 : throw( RuntimeException, std::exception )
701 : {
702 0 : osl::MutexGuard aGuard( m_aMutex );
703 :
704 0 : if( m_pPropertySetInfoChangeListeners )
705 0 : m_pPropertySetInfoChangeListeners->removeInterface( Listener );
706 0 : }
707 :
708 :
709 :
710 : // XChild
711 :
712 :
713 : Reference< XInterface > SAL_CALL
714 4 : BaseContent::getParent(
715 : void )
716 : throw( RuntimeException, std::exception )
717 : {
718 4 : OUString ParentUnq = getParentName( m_aUncPath );
719 8 : OUString ParentUrl;
720 :
721 :
722 4 : bool err = fileaccess::shell::getUrlFromUnq( ParentUnq, ParentUrl );
723 4 : if( err )
724 0 : return Reference< XInterface >( 0 );
725 :
726 4 : FileContentIdentifier* p = new FileContentIdentifier( ParentUnq );
727 8 : Reference< XContentIdentifier > Identifier( p );
728 :
729 : try
730 : {
731 4 : return Reference<XInterface>( m_pMyShell->m_pProvider->queryContent( Identifier ), UNO_QUERY );
732 : }
733 0 : catch (const IllegalIdentifierException&)
734 : {
735 0 : return Reference< XInterface >();
736 4 : }
737 : }
738 :
739 :
740 : void SAL_CALL
741 0 : BaseContent::setParent(
742 : const Reference< XInterface >& )
743 : throw( lang::NoSupportException,
744 : RuntimeException, std::exception)
745 : {
746 0 : throw lang::NoSupportException( THROW_WHERE );
747 : }
748 :
749 :
750 :
751 : // Private Methods
752 :
753 :
754 :
755 : Reference< XCommandInfo > SAL_CALL
756 10 : BaseContent::getCommandInfo()
757 : throw( RuntimeException )
758 : {
759 10 : if( m_nState & Deleted )
760 0 : return Reference< XCommandInfo >();
761 :
762 10 : return m_pMyShell->info_c();
763 : }
764 :
765 :
766 : Reference< beans::XPropertySetInfo > SAL_CALL
767 17668 : BaseContent::getPropertySetInfo(
768 : sal_Int32 )
769 : throw( RuntimeException )
770 : {
771 17668 : if( m_nState & Deleted )
772 0 : return Reference< beans::XPropertySetInfo >();
773 :
774 17668 : return m_pMyShell->info_p( m_aUncPath );
775 : }
776 :
777 :
778 :
779 :
780 : Reference< sdbc::XRow > SAL_CALL
781 75065 : BaseContent::getPropertyValues(
782 : sal_Int32 nMyCommandIdentifier,
783 : const Sequence< beans::Property >& PropertySet )
784 : throw( RuntimeException )
785 : {
786 75065 : sal_Int32 nProps = PropertySet.getLength();
787 75065 : if ( !nProps )
788 0 : return Reference< sdbc::XRow >();
789 :
790 75065 : if( m_nState & Deleted )
791 : {
792 0 : Sequence< Any > aValues( nProps );
793 0 : return Reference< sdbc::XRow >( new XRow_impl( m_pMyShell, aValues ) );
794 : }
795 :
796 75065 : if( m_nState & JustInserted )
797 : {
798 3774 : Sequence< Any > aValues( nProps );
799 3774 : Any* pValues = aValues.getArray();
800 :
801 3774 : const beans::Property* pProps = PropertySet.getConstArray();
802 :
803 7548 : for ( sal_Int32 n = 0; n < nProps; ++n )
804 : {
805 3774 : const beans::Property& rProp = pProps[ n ];
806 3774 : Any& rValue = pValues[ n ];
807 :
808 3774 : if ( rProp.Name == "ContentType" )
809 : {
810 0 : rValue <<= m_bFolder ? m_pMyShell->FolderContentType
811 0 : : m_pMyShell->FileContentType;
812 : }
813 3774 : else if ( rProp.Name == "IsFolder" )
814 : {
815 0 : rValue <<= m_bFolder;
816 : }
817 3774 : else if ( rProp.Name == "IsDocument" )
818 : {
819 3774 : rValue <<= !m_bFolder;
820 : }
821 : }
822 :
823 : return Reference< sdbc::XRow >(
824 3774 : new XRow_impl( m_pMyShell, aValues ) );
825 : }
826 :
827 : return m_pMyShell->getv( nMyCommandIdentifier,
828 : m_aUncPath,
829 71291 : PropertySet );
830 : }
831 :
832 :
833 : Sequence< Any > SAL_CALL
834 4625 : BaseContent::setPropertyValues(
835 : sal_Int32 nMyCommandIdentifier,
836 : const Sequence< beans::PropertyValue >& Values )
837 : throw()
838 : {
839 4625 : if( m_nState & Deleted )
840 : { // To do
841 0 : return Sequence< Any >( Values.getLength() );
842 : }
843 :
844 4625 : const OUString Title("Title");
845 :
846 : // Special handling for files which have to be inserted
847 4625 : if( m_nState & JustInserted )
848 : {
849 7618 : for( sal_Int32 i = 0; i < Values.getLength(); ++i )
850 : {
851 3844 : if( Values[i].Name == Title )
852 : {
853 3774 : OUString NewTitle;
854 3774 : if( Values[i].Value >>= NewTitle )
855 : {
856 3774 : if ( m_nState & NameForInsertionSet )
857 : {
858 : // User wants to set another Title before "insert".
859 : // m_aUncPath contains previous own URI.
860 :
861 0 : sal_Int32 nLastSlash = m_aUncPath.lastIndexOf( '/' );
862 0 : bool bTrailingSlash = false;
863 0 : if ( nLastSlash == m_aUncPath.getLength() - 1 )
864 : {
865 0 : bTrailingSlash = true;
866 : nLastSlash
867 0 : = m_aUncPath.lastIndexOf( '/', nLastSlash );
868 : }
869 :
870 : OSL_ENSURE( nLastSlash != -1,
871 : "BaseContent::setPropertyValues: "
872 : "Invalid URL!" );
873 :
874 : OUStringBuffer aBuf(
875 0 : m_aUncPath.copy( 0, nLastSlash + 1 ) );
876 :
877 0 : if ( !NewTitle.isEmpty() )
878 : {
879 0 : aBuf.append( NewTitle );
880 0 : if ( bTrailingSlash )
881 0 : aBuf.append( '/' );
882 : }
883 : else
884 : {
885 0 : m_nState &= ~NameForInsertionSet;
886 : }
887 :
888 0 : m_aUncPath = aBuf.makeStringAndClear();
889 : }
890 : else
891 : {
892 3774 : if ( !NewTitle.isEmpty() )
893 : {
894 : // Initial Title before "insert".
895 : // m_aUncPath contains parent's URI.
896 :
897 3774 : if( !m_aUncPath.endsWith( "/" ) )
898 3774 : m_aUncPath += "/";
899 :
900 7548 : m_aUncPath += rtl::Uri::encode( NewTitle,
901 : rtl_UriCharClassPchar,
902 : rtl_UriEncodeIgnoreEscapes,
903 3774 : RTL_TEXTENCODING_UTF8 );
904 3774 : m_nState |= NameForInsertionSet;
905 : }
906 : }
907 3774 : }
908 : }
909 : }
910 :
911 3774 : return Sequence< Any >( Values.getLength() );
912 : }
913 : else
914 : {
915 : Sequence< Any > ret = m_pMyShell->setv( m_aUncPath, // Does not handle Title
916 851 : Values );
917 :
918 : // Special handling Title: Setting Title is equivalent to a renaming of the underlying file
919 3404 : for( sal_Int32 i = 0; i < Values.getLength(); ++i )
920 : {
921 851 : if( Values[i].Name != Title )
922 851 : continue; // handled by setv
923 :
924 0 : OUString NewTitle;
925 0 : if( !( Values[i].Value >>= NewTitle ) )
926 : {
927 0 : ret[i] <<= beans::IllegalTypeException( THROW_WHERE );
928 0 : break;
929 : }
930 0 : else if( NewTitle.isEmpty() )
931 : {
932 0 : ret[i] <<= lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 0 );
933 0 : break;
934 : }
935 :
936 :
937 0 : OUString aDstName = getParentName( m_aUncPath );
938 0 : if( !aDstName.endsWith("/") )
939 0 : aDstName += "/";
940 :
941 0 : aDstName += rtl::Uri::encode( NewTitle,
942 : rtl_UriCharClassPchar,
943 : rtl_UriEncodeIgnoreEscapes,
944 0 : RTL_TEXTENCODING_UTF8 );
945 :
946 : m_pMyShell->move( nMyCommandIdentifier, // move notifies the children also;
947 : m_aUncPath,
948 : aDstName,
949 0 : NameClash::KEEP );
950 :
951 : try
952 : {
953 0 : endTask( nMyCommandIdentifier );
954 : }
955 0 : catch(const Exception& e)
956 : {
957 0 : ret[i] <<= e;
958 : }
959 :
960 : // NameChanges come back through a ContentEvent
961 0 : break; // only handling Title
962 0 : } // end for
963 :
964 851 : return ret;
965 4625 : }
966 : }
967 :
968 :
969 :
970 : Reference< XDynamicResultSet > SAL_CALL
971 89574 : BaseContent::open(
972 : sal_Int32 nMyCommandIdentifier,
973 : const OpenCommandArgument2& aCommandArgument )
974 : throw()
975 : {
976 89574 : Reference< XDynamicResultSet > retValue( 0 );
977 :
978 89574 : if( ( m_nState & Deleted ) )
979 : {
980 : m_pMyShell->installError( nMyCommandIdentifier,
981 0 : TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND );
982 : }
983 89574 : else if( m_nState & JustInserted )
984 : {
985 : m_pMyShell->installError( nMyCommandIdentifier,
986 0 : TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND );
987 : }
988 : else
989 : {
990 148635 : if( aCommandArgument.Mode == OpenMode::DOCUMENT ||
991 59061 : aCommandArgument.Mode == OpenMode::DOCUMENT_SHARE_DENY_NONE )
992 :
993 : {
994 33669 : Reference< io::XOutputStream > outputStream( aCommandArgument.Sink,UNO_QUERY );
995 33669 : if( outputStream.is() )
996 : {
997 : m_pMyShell->page( nMyCommandIdentifier,
998 : m_aUncPath,
999 0 : outputStream );
1000 : }
1001 :
1002 33669 : bool bLock = ( aCommandArgument.Mode != OpenMode::DOCUMENT_SHARE_DENY_NONE );
1003 :
1004 67338 : Reference< io::XActiveDataSink > activeDataSink( aCommandArgument.Sink,UNO_QUERY );
1005 33669 : if( activeDataSink.is() )
1006 : {
1007 9689 : activeDataSink->setInputStream( m_pMyShell->open( nMyCommandIdentifier,
1008 : m_aUncPath,
1009 9689 : bLock ) );
1010 : }
1011 :
1012 67338 : Reference< io::XActiveDataStreamer > activeDataStreamer( aCommandArgument.Sink,UNO_QUERY );
1013 33669 : if( activeDataStreamer.is() )
1014 : {
1015 23980 : activeDataStreamer->setStream( m_pMyShell->open_rw( nMyCommandIdentifier,
1016 : m_aUncPath,
1017 23980 : bLock ) );
1018 33669 : }
1019 : }
1020 57257 : else if ( aCommandArgument.Mode == OpenMode::ALL ||
1021 1814 : aCommandArgument.Mode == OpenMode::FOLDERS ||
1022 462 : aCommandArgument.Mode == OpenMode::DOCUMENTS )
1023 : {
1024 111810 : retValue = m_pMyShell->ls( nMyCommandIdentifier,
1025 : m_aUncPath,
1026 : aCommandArgument.Mode,
1027 : aCommandArgument.Properties,
1028 111810 : aCommandArgument.SortingInfo );
1029 : }
1030 : // else if( aCommandArgument.Mode ==
1031 : // OpenMode::DOCUMENT_SHARE_DENY_NONE ||
1032 : // aCommandArgument.Mode ==
1033 : // OpenMode::DOCUMENT_SHARE_DENY_WRITE )
1034 : // m_pMyShell->installError( nMyCommandIdentifier,
1035 : // TASKHANDLING_UNSUPPORTED_OPEN_MODE,
1036 : // aCommandArgument.Mode);
1037 : else
1038 : m_pMyShell->installError( nMyCommandIdentifier,
1039 : TASKHANDLING_UNSUPPORTED_OPEN_MODE,
1040 0 : aCommandArgument.Mode);
1041 : }
1042 :
1043 89574 : return retValue;
1044 : }
1045 :
1046 :
1047 :
1048 : void SAL_CALL
1049 2621 : BaseContent::deleteContent( sal_Int32 nMyCommandIdentifier )
1050 : throw()
1051 : {
1052 2621 : if( m_nState & Deleted )
1053 2621 : return;
1054 :
1055 2621 : if( m_pMyShell->remove( nMyCommandIdentifier,m_aUncPath ) )
1056 : {
1057 2348 : osl::MutexGuard aGuard( m_aMutex );
1058 2348 : m_nState |= Deleted;
1059 : }
1060 : }
1061 :
1062 :
1063 :
1064 : void SAL_CALL
1065 3571 : BaseContent::transfer( sal_Int32 nMyCommandIdentifier,
1066 : const TransferInfo& aTransferInfo )
1067 : throw()
1068 : {
1069 3571 : if( m_nState & Deleted )
1070 2 : return;
1071 :
1072 3571 : if( !aTransferInfo.SourceURL.startsWith( "file:" ) )
1073 : {
1074 : m_pMyShell->installError( nMyCommandIdentifier,
1075 2 : TASKHANDLING_TRANSFER_INVALIDSCHEME );
1076 2 : return;
1077 : }
1078 :
1079 3569 : OUString srcUnc;
1080 3569 : if( fileaccess::shell::getUnqFromUrl( aTransferInfo.SourceURL,srcUnc ) )
1081 : {
1082 : m_pMyShell->installError( nMyCommandIdentifier,
1083 0 : TASKHANDLING_TRANSFER_INVALIDURL );
1084 0 : return;
1085 : }
1086 :
1087 7138 : OUString srcUncPath = srcUnc;
1088 :
1089 : // Determine the new title !
1090 7138 : OUString NewTitle;
1091 3569 : if( !aTransferInfo.NewTitle.isEmpty() )
1092 7138 : NewTitle = rtl::Uri::encode( aTransferInfo.NewTitle,
1093 : rtl_UriCharClassPchar,
1094 : rtl_UriEncodeIgnoreEscapes,
1095 3569 : RTL_TEXTENCODING_UTF8 );
1096 : else
1097 0 : NewTitle = srcUncPath.copy( 1 + srcUncPath.lastIndexOf( '/' ) );
1098 :
1099 : // Is destination a document or a folder ?
1100 7138 : Sequence< beans::Property > seq(1);
1101 10707 : seq[0] = beans::Property( OUString("IsDocument"),
1102 : -1,
1103 3569 : cppu::UnoType<sal_Bool>::get(),
1104 3569 : 0 );
1105 7138 : Reference< sdbc::XRow > xRow = getPropertyValues( nMyCommandIdentifier,seq );
1106 3569 : bool IsDocument = xRow->getBoolean( 1 );
1107 3569 : if( xRow->wasNull() )
1108 : { // Destination file type could not be determined
1109 : m_pMyShell->installError( nMyCommandIdentifier,
1110 0 : TASKHANDLING_TRANSFER_DESTFILETYPE );
1111 0 : return;
1112 : }
1113 :
1114 7138 : OUString dstUncPath;
1115 3569 : if( IsDocument )
1116 : { // as sibling
1117 0 : sal_Int32 lastSlash = m_aUncPath.lastIndexOf( '/' );
1118 0 : dstUncPath = m_aUncPath.copy(0,lastSlash );
1119 : }
1120 : else
1121 : // as child
1122 3569 : dstUncPath = m_aUncPath;
1123 :
1124 3569 : dstUncPath += "/" + NewTitle;
1125 :
1126 3569 : sal_Int32 NameClash = aTransferInfo.NameClash;
1127 :
1128 3569 : if( aTransferInfo.MoveData )
1129 3 : m_pMyShell->move( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
1130 : else
1131 7135 : m_pMyShell->copy( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
1132 : }
1133 :
1134 :
1135 :
1136 :
1137 9250 : void SAL_CALL BaseContent::insert( sal_Int32 nMyCommandIdentifier,
1138 : const InsertCommandArgument& aInsertArgument )
1139 : throw()
1140 : {
1141 9250 : if( m_nState & FullFeatured )
1142 : {
1143 : m_pMyShell->write( nMyCommandIdentifier,
1144 : m_aUncPath,
1145 : aInsertArgument.ReplaceExisting,
1146 5476 : aInsertArgument.Data );
1147 5476 : return;
1148 : }
1149 :
1150 3774 : if( ! ( m_nState & JustInserted ) )
1151 : {
1152 : m_pMyShell->installError( nMyCommandIdentifier,
1153 0 : TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND );
1154 0 : return;
1155 : }
1156 :
1157 : // Inserts the content, which has the flag m_bIsFresh
1158 :
1159 3774 : if( ! (m_nState & NameForInsertionSet) )
1160 : {
1161 : m_pMyShell->installError( nMyCommandIdentifier,
1162 0 : TASKHANDLING_NONAMESET_INSERT_COMMAND );
1163 0 : return;
1164 : }
1165 :
1166 : // Inserting a document or a file?
1167 3774 : bool bDocument = false;
1168 :
1169 3774 : Sequence< beans::Property > seq(1);
1170 11322 : seq[0] = beans::Property( OUString("IsDocument"),
1171 : -1,
1172 3774 : cppu::UnoType<sal_Bool>::get(),
1173 3774 : 0 );
1174 :
1175 6568 : Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
1176 :
1177 3774 : bool contentTypeSet = true; // is set to false, if contentType not set
1178 : try
1179 : {
1180 3774 : bDocument = xRow->getBoolean( 1 );
1181 3774 : if( xRow->wasNull() )
1182 0 : contentTypeSet = false;
1183 :
1184 : }
1185 0 : catch (const sdbc::SQLException&)
1186 : {
1187 : OSL_FAIL( "BaseContent::insert - Caught SQLException!" );
1188 0 : contentTypeSet = false;
1189 : }
1190 :
1191 3774 : if( ! contentTypeSet )
1192 : {
1193 : m_pMyShell->installError( nMyCommandIdentifier,
1194 0 : TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND );
1195 0 : return;
1196 : }
1197 :
1198 :
1199 3774 : bool success = false;
1200 3774 : if( bDocument )
1201 : success = m_pMyShell->mkfil( nMyCommandIdentifier,
1202 : m_aUncPath,
1203 : aInsertArgument.ReplaceExisting,
1204 6 : aInsertArgument.Data );
1205 : else
1206 : {
1207 7536 : while( ! success )
1208 : {
1209 : success = m_pMyShell->mkdir( nMyCommandIdentifier,
1210 : m_aUncPath,
1211 3768 : aInsertArgument.ReplaceExisting );
1212 3768 : if( success )
1213 6556 : break;
1214 :
1215 : XInteractionRequestImpl *aRequestImpl =
1216 : new XInteractionRequestImpl(
1217 : rtl::Uri::decode(
1218 : getTitle(m_aUncPath),
1219 : rtl_UriDecodeWithCharset,
1220 : RTL_TEXTENCODING_UTF8),
1221 : static_cast<cppu::OWeakObject*>(this),
1222 980 : m_pMyShell,nMyCommandIdentifier);
1223 980 : uno::Reference< task::XInteractionRequest > aReq( aRequestImpl );
1224 :
1225 980 : m_pMyShell->handleTask( nMyCommandIdentifier,aReq );
1226 3920 : if( aRequestImpl->aborted() ||
1227 3920 : aRequestImpl->newName().isEmpty() )
1228 : // means aborting
1229 980 : break;
1230 :
1231 : // determine new uncpath
1232 0 : m_pMyShell->clearError( nMyCommandIdentifier );
1233 0 : m_aUncPath = getParentName( m_aUncPath );
1234 0 : if( !m_aUncPath.endsWith( "/" ) )
1235 0 : m_aUncPath += "/";
1236 :
1237 0 : m_aUncPath += rtl::Uri::encode( aRequestImpl->newName(),
1238 : rtl_UriCharClassPchar,
1239 : rtl_UriEncodeIgnoreEscapes,
1240 0 : RTL_TEXTENCODING_UTF8 );
1241 0 : }
1242 : }
1243 :
1244 3774 : if ( ! success )
1245 980 : return;
1246 :
1247 2794 : FileContentIdentifier* p = new FileContentIdentifier( m_aUncPath );
1248 2794 : m_xContentIdentifier = Reference< XContentIdentifier >( p );
1249 :
1250 2794 : m_pMyShell->registerNotifier( m_aUncPath,this );
1251 2794 : m_pMyShell->insertDefaultProperties( m_aUncPath );
1252 :
1253 5588 : osl::MutexGuard aGuard( m_aMutex );
1254 5588 : m_nState = FullFeatured;
1255 : }
1256 :
1257 :
1258 :
1259 195041 : void SAL_CALL BaseContent::endTask( sal_Int32 CommandId )
1260 : {
1261 : // This is the only function allowed to throw an exception
1262 195041 : m_pMyShell->endTask( CommandId,m_aUncPath,this );
1263 171027 : }
1264 :
1265 :
1266 :
1267 : ContentEventNotifier*
1268 2351 : BaseContent::cDEL()
1269 : {
1270 2351 : osl::MutexGuard aGuard( m_aMutex );
1271 :
1272 2351 : m_nState |= Deleted;
1273 :
1274 : ContentEventNotifier* p;
1275 2351 : if( m_pContentEventListeners )
1276 : p = new ContentEventNotifier( m_pMyShell,
1277 : this,
1278 : m_xContentIdentifier,
1279 2351 : m_pContentEventListeners->getElements() );
1280 : else
1281 0 : p = 0;
1282 :
1283 2351 : return p;
1284 : }
1285 :
1286 :
1287 : ContentEventNotifier*
1288 1 : BaseContent::cEXC( const OUString& aNewName )
1289 : {
1290 1 : osl::MutexGuard aGuard( m_aMutex );
1291 :
1292 2 : Reference< XContentIdentifier > xOldRef = m_xContentIdentifier;
1293 1 : m_aUncPath = aNewName;
1294 1 : FileContentIdentifier* pp = new FileContentIdentifier( aNewName );
1295 1 : m_xContentIdentifier = Reference< XContentIdentifier >( pp );
1296 :
1297 1 : ContentEventNotifier* p = 0;
1298 1 : if( m_pContentEventListeners )
1299 : p = new ContentEventNotifier( m_pMyShell,
1300 : this,
1301 : m_xContentIdentifier,
1302 : xOldRef,
1303 1 : m_pContentEventListeners->getElements() );
1304 :
1305 2 : return p;
1306 : }
1307 :
1308 :
1309 : ContentEventNotifier*
1310 11128 : BaseContent::cCEL()
1311 : {
1312 11128 : osl::MutexGuard aGuard( m_aMutex );
1313 11128 : ContentEventNotifier* p = 0;
1314 11128 : if( m_pContentEventListeners )
1315 : p = new ContentEventNotifier( m_pMyShell,
1316 : this,
1317 : m_xContentIdentifier,
1318 7553 : m_pContentEventListeners->getElements() );
1319 :
1320 11128 : return p;
1321 : }
1322 :
1323 : PropertySetInfoChangeNotifier*
1324 0 : BaseContent::cPSL()
1325 : {
1326 0 : osl::MutexGuard aGuard( m_aMutex );
1327 0 : PropertySetInfoChangeNotifier* p = 0;
1328 0 : if( m_pPropertySetInfoChangeListeners )
1329 : p = new PropertySetInfoChangeNotifier( this,
1330 : m_xContentIdentifier,
1331 0 : m_pPropertySetInfoChangeListeners->getElements() );
1332 :
1333 0 : return p;
1334 : }
1335 :
1336 :
1337 :
1338 : PropertyChangeNotifier*
1339 5 : BaseContent::cPCL()
1340 : {
1341 5 : osl::MutexGuard aGuard( m_aMutex );
1342 :
1343 5 : if (!m_pPropertyListener)
1344 5 : return NULL;
1345 :
1346 0 : Sequence< OUString > seqNames = m_pPropertyListener->getContainedTypes();
1347 :
1348 0 : PropertyChangeNotifier* p = 0;
1349 :
1350 0 : sal_Int32 length = seqNames.getLength();
1351 :
1352 0 : if( length )
1353 : {
1354 0 : ListenerMap* listener = new ListenerMap();
1355 0 : for( sal_Int32 i = 0; i < length; ++i )
1356 : {
1357 0 : cppu::OInterfaceContainerHelper* pContainer = m_pPropertyListener->getContainer(seqNames[i]);
1358 0 : if (!pContainer)
1359 0 : continue;
1360 0 : (*listener)[seqNames[i]] = pContainer->getElements();
1361 : }
1362 :
1363 : p = new PropertyChangeNotifier( this,
1364 : m_xContentIdentifier,
1365 0 : listener );
1366 : }
1367 :
1368 5 : return p;
1369 : }
1370 :
1371 :
1372 0 : OUString BaseContent::getKey()
1373 : {
1374 0 : return m_aUncPath;
1375 : }
1376 :
1377 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
