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