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 "sal/config.h"
21 :
22 : #include <cassert>
23 :
24 : #include <osl/diagnose.h>
25 : #include <osl/mutex.hxx>
26 : #include <salhelper/simplereferenceobject.hxx>
27 : #include <cppuhelper/weak.hxx>
28 :
29 : #include <cppuhelper/implbase1.hxx>
30 : #include <com/sun/star/ucb/CheckinArgument.hpp>
31 : #include <com/sun/star/ucb/ContentCreationError.hpp>
32 : #include <com/sun/star/ucb/XCommandEnvironment.hpp>
33 : #include <com/sun/star/ucb/XCommandInfo.hpp>
34 : #include <com/sun/star/ucb/XCommandProcessor.hpp>
35 : #include <com/sun/star/ucb/Command.hpp>
36 : #include <com/sun/star/ucb/CommandInfo.hpp>
37 : #include <com/sun/star/ucb/ContentAction.hpp>
38 : #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
39 : #include <com/sun/star/ucb/InsertCommandArgument.hpp>
40 : #include <com/sun/star/ucb/GlobalTransferCommandArgument2.hpp>
41 : #include <com/sun/star/ucb/NameClash.hpp>
42 : #include <com/sun/star/ucb/OpenMode.hpp>
43 : #include <com/sun/star/ucb/XContentCreator.hpp>
44 : #include <com/sun/star/ucb/XContentEventListener.hpp>
45 : #include <com/sun/star/ucb/XContentIdentifierFactory.hpp>
46 : #include <com/sun/star/ucb/XContentProvider.hpp>
47 : #include <com/sun/star/ucb/XContentProviderManager.hpp>
48 : #include <com/sun/star/ucb/XDynamicResultSet.hpp>
49 : #include <com/sun/star/ucb/SortedDynamicResultSetFactory.hpp>
50 : #include <com/sun/star/ucb/UniversalContentBroker.hpp>
51 : #include <com/sun/star/ucb/XUniversalContentBroker.hpp>
52 : #include <com/sun/star/beans/XPropertySetInfo.hpp>
53 : #include <com/sun/star/beans/Property.hpp>
54 : #include <com/sun/star/beans/PropertyValue.hpp>
55 : #include <com/sun/star/sdbc/XResultSet.hpp>
56 : #include <com/sun/star/sdbc/XRow.hpp>
57 : #include <com/sun/star/lang/IllegalArgumentException.hpp>
58 : #include <com/sun/star/beans/UnknownPropertyException.hpp>
59 : #include <ucbhelper/macros.hxx>
60 : #include <ucbhelper/content.hxx>
61 : #include <ucbhelper/activedatasink.hxx>
62 : #include <ucbhelper/activedatastreamer.hxx>
63 : #include <ucbhelper/interactionrequest.hxx>
64 : #include <ucbhelper/cancelcommandexecution.hxx>
65 :
66 : using namespace com::sun::star::container;
67 : using namespace com::sun::star::beans;
68 : using namespace com::sun::star::io;
69 : using namespace com::sun::star::lang;
70 : using namespace com::sun::star::sdbc;
71 : using namespace com::sun::star::task;
72 : using namespace com::sun::star::ucb;
73 : using namespace com::sun::star::uno;
74 :
75 : namespace ucbhelper
76 : {
77 :
78 39 : class EmptyInputStream : public ::cppu::WeakImplHelper1< XInputStream >
79 : {
80 : public:
81 : virtual sal_Int32 SAL_CALL readBytes(
82 : Sequence< sal_Int8 > & data, sal_Int32 nBytesToRead )
83 : throw (IOException, RuntimeException);
84 : virtual sal_Int32 SAL_CALL readSomeBytes(
85 : Sequence< sal_Int8 > & data, sal_Int32 nMaxBytesToRead )
86 : throw (IOException, RuntimeException);
87 : virtual void SAL_CALL skipBytes( sal_Int32 nBytesToSkip )
88 : throw (IOException, RuntimeException);
89 : virtual sal_Int32 SAL_CALL available()
90 : throw (IOException, RuntimeException);
91 : virtual void SAL_CALL closeInput()
92 : throw (IOException, RuntimeException);
93 : };
94 :
95 0 : sal_Int32 EmptyInputStream::readBytes(
96 : Sequence< sal_Int8 > & data, sal_Int32 )
97 : throw (IOException, RuntimeException)
98 : {
99 0 : data.realloc( 0 );
100 0 : return 0;
101 : }
102 :
103 0 : sal_Int32 EmptyInputStream::readSomeBytes(
104 : Sequence< sal_Int8 > & data, sal_Int32 )
105 : throw (IOException, RuntimeException)
106 : {
107 0 : data.realloc( 0 );
108 0 : return 0;
109 : }
110 :
111 0 : void EmptyInputStream::skipBytes( sal_Int32 )
112 : throw (IOException, RuntimeException)
113 : {
114 0 : }
115 :
116 0 : sal_Int32 EmptyInputStream::available()
117 : throw (IOException, RuntimeException)
118 : {
119 0 : return 0;
120 : }
121 :
122 0 : void EmptyInputStream::closeInput()
123 : throw (IOException, RuntimeException)
124 : {
125 0 : }
126 :
127 :
128 : //=========================================================================
129 : //=========================================================================
130 : //
131 : // class ContentEventListener_Impl.
132 : //
133 : //=========================================================================
134 : //=========================================================================
135 :
136 15016 : class ContentEventListener_Impl : public cppu::OWeakObject,
137 : public XContentEventListener
138 : {
139 : Content_Impl& m_rContent;
140 :
141 : public:
142 7734 : ContentEventListener_Impl( Content_Impl& rContent )
143 7734 : : m_rContent( rContent ) {}
144 :
145 : // XInterface
146 : XINTERFACE_DECL()
147 :
148 : // XContentEventListener
149 : virtual void SAL_CALL contentEvent( const ContentEvent& evt )
150 : throw( RuntimeException );
151 :
152 : // XEventListener ( base of XContentEventListener )
153 : virtual void SAL_CALL disposing( const EventObject& Source )
154 : throw( RuntimeException );
155 : };
156 :
157 : //=========================================================================
158 : //=========================================================================
159 : //
160 : // class Content_Impl.
161 : //
162 : //=========================================================================
163 : //=========================================================================
164 :
165 : class Content_Impl : public salhelper::SimpleReferenceObject
166 : {
167 : friend class ContentEventListener_Impl;
168 :
169 : mutable rtl::OUString m_aURL;
170 : Reference< XComponentContext > m_xCtx;
171 : Reference< XContent > m_xContent;
172 : Reference< XCommandProcessor > m_xCommandProcessor;
173 : Reference< XCommandEnvironment > m_xEnv;
174 : Reference< XContentEventListener > m_xContentEventListener;
175 : mutable osl::Mutex m_aMutex;
176 : sal_Int32 m_nCommandId;
177 :
178 : private:
179 : void reinit( const Reference< XContent >& xContent );
180 : void disposing(const EventObject& Source);
181 :
182 : public:
183 2511 : Content_Impl() : m_nCommandId( 0 ) {};
184 : Content_Impl( const Reference< XComponentContext >& rCtx,
185 : const Reference< XContent >& rContent,
186 : const Reference< XCommandEnvironment >& rEnv );
187 :
188 : virtual ~Content_Impl();
189 :
190 : const rtl::OUString& getURL() const;
191 : Reference< XContent > getContent();
192 : Reference< XCommandProcessor > getCommandProcessor();
193 : sal_Int32 getCommandId();
194 296 : Reference< XComponentContext > getComponentContext()
195 296 : { assert(m_xCtx.is()); return m_xCtx; }
196 :
197 : Any executeCommand( const Command& rCommand );
198 :
199 : inline const Reference< XCommandEnvironment >& getEnvironment() const;
200 : inline void setEnvironment(
201 : const Reference< XCommandEnvironment >& xNewEnv );
202 :
203 : void inserted();
204 : };
205 :
206 : //=========================================================================
207 : // Helpers.
208 : //=========================================================================
209 :
210 495 : static void ensureContentProviderForURL( const Reference< XUniversalContentBroker >& rBroker,
211 : const rtl::OUString & rURL )
212 : throw ( ContentCreationException, RuntimeException )
213 : {
214 : Reference< XContentProvider > xProv
215 495 : = rBroker->queryContentProvider( rURL );
216 495 : if ( !xProv.is() )
217 : {
218 : throw ContentCreationException(
219 : "No Content Provider available for URL: " + rURL,
220 : Reference< XInterface >(),
221 493 : ContentCreationError_NO_CONTENT_PROVIDER );
222 495 : }
223 2 : }
224 :
225 : //=========================================================================
226 6280 : static Reference< XContentIdentifier > getContentIdentifier(
227 : const Reference< XUniversalContentBroker > & rBroker,
228 : const rtl::OUString & rURL,
229 : bool bThrow )
230 : throw ( ContentCreationException, RuntimeException )
231 : {
232 : Reference< XContentIdentifier > xId
233 6280 : = rBroker->createContentIdentifier( rURL );
234 :
235 6280 : if ( xId.is() )
236 6280 : return xId;
237 :
238 0 : if ( bThrow )
239 : {
240 0 : ensureContentProviderForURL( rBroker, rURL );
241 :
242 : throw ContentCreationException(
243 : "Unable to create Content Identifier!",
244 : Reference< XInterface >(),
245 0 : ContentCreationError_IDENTIFIER_CREATION_FAILED );
246 : }
247 :
248 0 : return Reference< XContentIdentifier >();
249 : }
250 :
251 : //=========================================================================
252 6280 : static Reference< XContent > getContent(
253 : const Reference< XUniversalContentBroker > & rBroker,
254 : const Reference< XContentIdentifier > & xId,
255 : bool bThrow )
256 : throw ( ContentCreationException, RuntimeException )
257 : {
258 6280 : Reference< XContent > xContent;
259 6280 : rtl::OUString msg;
260 : try
261 : {
262 6280 : xContent = rBroker->queryContent( xId );
263 : }
264 0 : catch ( IllegalIdentifierException const & e )
265 : {
266 0 : msg = e.Message;
267 : // handled below.
268 : }
269 :
270 6280 : if ( xContent.is() )
271 5773 : return xContent;
272 :
273 507 : if ( bThrow )
274 : {
275 988 : ensureContentProviderForURL( rBroker, xId->getContentIdentifier() );
276 :
277 : throw ContentCreationException(
278 : "Unable to create Content! " + msg,
279 : Reference< XInterface >(),
280 2 : ContentCreationError_CONTENT_CREATION_FAILED );
281 : }
282 :
283 507 : return Reference< XContent >();
284 : }
285 :
286 : //=========================================================================
287 : //=========================================================================
288 : //
289 : // Content Implementation.
290 : //
291 : //=========================================================================
292 : //=========================================================================
293 :
294 2511 : Content::Content()
295 2511 : : m_xImpl( new Content_Impl )
296 : {
297 2511 : }
298 :
299 : //=========================================================================
300 6007 : Content::Content( const rtl::OUString& rURL,
301 : const Reference< XCommandEnvironment >& rEnv,
302 : const Reference< XComponentContext >& rCtx )
303 6502 : throw ( ContentCreationException, RuntimeException )
304 : {
305 : Reference< XUniversalContentBroker > pBroker(
306 6007 : UniversalContentBroker::create( rCtx ) );
307 :
308 : Reference< XContentIdentifier > xId
309 6007 : = getContentIdentifier( pBroker, rURL, true );
310 :
311 6007 : Reference< XContent > xContent = getContent( pBroker, xId, true );
312 :
313 5512 : m_xImpl = new Content_Impl( rCtx, xContent, rEnv );
314 5512 : }
315 :
316 : //=========================================================================
317 1961 : Content::Content( const Reference< XContent >& rContent,
318 : const Reference< XCommandEnvironment >& rEnv,
319 : const Reference< XComponentContext >& rCtx )
320 1961 : throw ( ContentCreationException, RuntimeException )
321 : {
322 1961 : m_xImpl = new Content_Impl( rCtx, rContent, rEnv );
323 1961 : }
324 :
325 : //=========================================================================
326 113 : Content::Content( const Content& rOther )
327 : {
328 113 : m_xImpl = rOther.m_xImpl;
329 113 : }
330 :
331 : //=========================================================================
332 : // static
333 273 : sal_Bool Content::create( const rtl::OUString& rURL,
334 : const Reference< XCommandEnvironment >& rEnv,
335 : const Reference< XComponentContext >& rCtx,
336 : Content& rContent )
337 : {
338 : Reference< XUniversalContentBroker > pBroker(
339 273 : UniversalContentBroker::create( rCtx ) );
340 :
341 : Reference< XContentIdentifier > xId
342 273 : = getContentIdentifier( pBroker, rURL, false );
343 273 : if ( !xId.is() )
344 0 : return sal_False;
345 :
346 273 : Reference< XContent > xContent = getContent( pBroker, xId, false );
347 273 : if ( !xContent.is() )
348 12 : return sal_False;
349 :
350 : rContent.m_xImpl
351 261 : = new Content_Impl( rCtx, xContent, rEnv );
352 :
353 261 : return sal_True;
354 : }
355 :
356 : //=========================================================================
357 9836 : Content::~Content()
358 : {
359 9836 : }
360 :
361 : //=========================================================================
362 1795 : Content& Content::operator=( const Content& rOther )
363 : {
364 1795 : m_xImpl = rOther.m_xImpl;
365 1795 : return *this;
366 : }
367 :
368 : //=========================================================================
369 6542 : Reference< XContent > Content::get() const
370 : {
371 6542 : return m_xImpl->getContent();
372 : }
373 :
374 : //=========================================================================
375 686 : const rtl::OUString& Content::getURL() const
376 : {
377 686 : return m_xImpl->getURL();
378 : }
379 :
380 : //=========================================================================
381 0 : const Reference< XCommandEnvironment >& Content::getCommandEnvironment() const
382 : {
383 0 : return m_xImpl->getEnvironment();
384 : }
385 :
386 : //=========================================================================
387 0 : void Content::setCommandEnvironment(
388 : const Reference< XCommandEnvironment >& xNewEnv )
389 : {
390 0 : m_xImpl->setEnvironment( xNewEnv );
391 0 : }
392 :
393 : //=========================================================================
394 0 : Reference< XCommandInfo > Content::getCommands()
395 : throw( CommandAbortedException, RuntimeException, Exception )
396 : {
397 0 : Command aCommand;
398 0 : aCommand.Name = rtl::OUString("getCommandInfo");
399 0 : aCommand.Handle = -1; // n/a
400 0 : aCommand.Argument = Any();
401 :
402 0 : Any aResult = m_xImpl->executeCommand( aCommand );
403 :
404 0 : Reference< XCommandInfo > xInfo;
405 0 : aResult >>= xInfo;
406 0 : return xInfo;
407 : }
408 :
409 : //=========================================================================
410 1132 : Reference< XPropertySetInfo > Content::getProperties()
411 : throw( CommandAbortedException, RuntimeException, Exception )
412 : {
413 1132 : Command aCommand;
414 1132 : aCommand.Name = rtl::OUString("getPropertySetInfo");
415 1132 : aCommand.Handle = -1; // n/a
416 1132 : aCommand.Argument = Any();
417 :
418 1132 : Any aResult = m_xImpl->executeCommand( aCommand );
419 :
420 1132 : Reference< XPropertySetInfo > xInfo;
421 1132 : aResult >>= xInfo;
422 1132 : return xInfo;
423 : }
424 :
425 : //=========================================================================
426 3029 : Any Content::getPropertyValue( const rtl::OUString& rPropertyName )
427 : throw( CommandAbortedException, RuntimeException, Exception )
428 : {
429 3029 : Sequence< rtl::OUString > aNames( 1 );
430 3029 : aNames.getArray()[ 0 ] = rPropertyName;
431 :
432 3029 : Sequence< Any > aRet = getPropertyValues( aNames );
433 1812 : return aRet.getConstArray()[ 0 ];
434 : }
435 :
436 : //=========================================================================
437 35 : Any Content::setPropertyValue( const rtl::OUString& rName,
438 : const Any& rValue )
439 : throw( CommandAbortedException, RuntimeException, Exception )
440 : {
441 35 : Sequence< rtl::OUString > aNames( 1 );
442 35 : aNames.getArray()[ 0 ] = rName;
443 :
444 35 : Sequence< Any > aValues( 1 );
445 35 : aValues.getArray()[ 0 ] = rValue;
446 :
447 35 : Sequence< Any > aErrors = setPropertyValues( aNames, aValues );
448 35 : return aErrors.getConstArray()[ 0 ];
449 : }
450 :
451 : //=========================================================================
452 3029 : Sequence< Any > Content::getPropertyValues(
453 : const Sequence< rtl::OUString >& rPropertyNames )
454 : throw( CommandAbortedException, RuntimeException, Exception )
455 : {
456 3029 : Reference< XRow > xRow = getPropertyValuesInterface( rPropertyNames );
457 :
458 1812 : sal_Int32 nCount = rPropertyNames.getLength();
459 1812 : Sequence< Any > aValues( nCount );
460 :
461 1812 : if ( xRow.is() )
462 : {
463 1812 : Any* pValues = aValues.getArray();
464 :
465 3624 : for ( sal_Int32 n = 0; n < nCount; ++n )
466 1812 : pValues[ n ] = xRow->getObject( n + 1, Reference< XNameAccess >() );
467 : }
468 :
469 1812 : return aValues;
470 : }
471 :
472 : //=========================================================================
473 3029 : Reference< XRow > Content::getPropertyValuesInterface(
474 : const Sequence< rtl::OUString >& rPropertyNames )
475 : throw( CommandAbortedException, RuntimeException, Exception )
476 : {
477 3029 : sal_Int32 nCount = rPropertyNames.getLength();
478 3029 : Sequence< Property > aProps( nCount );
479 3029 : Property* pProps = aProps.getArray();
480 :
481 3029 : const rtl::OUString* pNames = rPropertyNames.getConstArray();
482 :
483 6058 : for ( sal_Int32 n = 0; n< nCount; ++n )
484 : {
485 3029 : Property& rProp = pProps[ n ];
486 :
487 3029 : rProp.Name = pNames[ n ];
488 3029 : rProp.Handle = -1; // n/a
489 : // rProp.Type =
490 : // rProp.Attributes = ;
491 : }
492 :
493 3029 : Command aCommand;
494 3029 : aCommand.Name = rtl::OUString("getPropertyValues");
495 3029 : aCommand.Handle = -1; // n/a
496 3029 : aCommand.Argument <<= aProps;
497 :
498 3029 : Any aResult = m_xImpl->executeCommand( aCommand );
499 :
500 1812 : Reference< XRow > xRow;
501 1812 : aResult >>= xRow;
502 1812 : return xRow;
503 : }
504 :
505 : //=========================================================================
506 48 : Sequence< Any > Content::setPropertyValues(
507 : const Sequence< rtl::OUString >& rPropertyNames,
508 : const Sequence< Any >& rValues )
509 : throw( CommandAbortedException, RuntimeException, Exception )
510 : {
511 48 : if ( rPropertyNames.getLength() != rValues.getLength() )
512 : {
513 : ucbhelper::cancelCommandExecution(
514 : makeAny( IllegalArgumentException(
515 : rtl::OUString(
516 : "Length of property names sequence and value "
517 : "sequence are unequal!" ),
518 : get(),
519 0 : -1 ) ),
520 0 : m_xImpl->getEnvironment() );
521 : // Unreachable
522 : }
523 :
524 48 : sal_Int32 nCount = rValues.getLength();
525 48 : Sequence< PropertyValue > aProps( nCount );
526 48 : PropertyValue* pProps = aProps.getArray();
527 :
528 48 : const rtl::OUString* pNames = rPropertyNames.getConstArray();
529 48 : const Any* pValues = rValues.getConstArray();
530 :
531 96 : for ( sal_Int32 n = 0; n< nCount; ++n )
532 : {
533 48 : PropertyValue& rProp = pProps[ n ];
534 :
535 48 : rProp.Name = pNames[ n ];
536 48 : rProp.Handle = -1; // n/a
537 48 : rProp.Value = pValues[ n ];
538 : // rProp.State = ;
539 : }
540 :
541 48 : Command aCommand;
542 48 : aCommand.Name = rtl::OUString("setPropertyValues");
543 48 : aCommand.Handle = -1; // n/a
544 48 : aCommand.Argument <<= aProps;
545 :
546 48 : Any aResult = m_xImpl->executeCommand( aCommand );
547 :
548 48 : Sequence< Any > aErrors;
549 48 : aResult >>= aErrors;
550 48 : return aErrors;
551 : }
552 :
553 : //=========================================================================
554 1819 : Any Content::executeCommand( const rtl::OUString& rCommandName,
555 : const Any& rCommandArgument )
556 : throw( CommandAbortedException, RuntimeException, Exception )
557 : {
558 1819 : Command aCommand;
559 1819 : aCommand.Name = rCommandName;
560 1819 : aCommand.Handle = -1; // n/a
561 1819 : aCommand.Argument = rCommandArgument;
562 :
563 1819 : return m_xImpl->executeCommand( aCommand );
564 : }
565 :
566 : //=========================================================================
567 3331 : Any Content::createCursorAny( const Sequence< rtl::OUString >& rPropertyNames,
568 : ResultSetInclude eMode )
569 : throw( CommandAbortedException, RuntimeException, Exception )
570 : {
571 3331 : sal_Int32 nCount = rPropertyNames.getLength();
572 3331 : Sequence< Property > aProps( nCount );
573 3331 : Property* pProps = aProps.getArray();
574 3331 : const rtl::OUString* pNames = rPropertyNames.getConstArray();
575 6657 : for ( sal_Int32 n = 0; n < nCount; ++n )
576 : {
577 3326 : Property& rProp = pProps[ n ];
578 3326 : rProp.Name = pNames[ n ];
579 3326 : rProp.Handle = -1; // n/a
580 : }
581 :
582 3331 : OpenCommandArgument2 aArg;
583 : aArg.Mode = ( eMode == INCLUDE_FOLDERS_ONLY )
584 : ? OpenMode::FOLDERS
585 : : ( eMode == INCLUDE_DOCUMENTS_ONLY )
586 3331 : ? OpenMode::DOCUMENTS : OpenMode::ALL;
587 3331 : aArg.Priority = 0; // unused
588 3331 : aArg.Sink = Reference< XInterface >(); // unused
589 3331 : aArg.Properties = aProps;
590 :
591 3331 : Command aCommand;
592 3331 : aCommand.Name = rtl::OUString("open");
593 3331 : aCommand.Handle = -1; // n/a
594 3331 : aCommand.Argument <<= aArg;
595 :
596 3336 : return m_xImpl->executeCommand( aCommand );
597 : }
598 :
599 : //=========================================================================
600 3331 : Reference< XResultSet > Content::createCursor(
601 : const Sequence< rtl::OUString >& rPropertyNames,
602 : ResultSetInclude eMode )
603 : throw( CommandAbortedException, RuntimeException, Exception )
604 : {
605 3331 : Any aCursorAny = createCursorAny( rPropertyNames, eMode );
606 :
607 3326 : Reference< XDynamicResultSet > xDynSet;
608 3326 : Reference< XResultSet > aResult;
609 :
610 3326 : aCursorAny >>= xDynSet;
611 3326 : if ( xDynSet.is() )
612 3326 : aResult = xDynSet->getStaticResultSet();
613 :
614 : OSL_ENSURE( aResult.is(), "Content::createCursor - no cursor!" );
615 :
616 3326 : if ( !aResult.is() )
617 : {
618 : // Former, the open command directly returned a XResultSet.
619 0 : aCursorAny >>= aResult;
620 :
621 : OSL_ENSURE( !aResult.is(),
622 : "Content::createCursor - open-Command must "
623 : "return a Reference< XDynnamicResultSet >!" );
624 : }
625 :
626 3326 : return aResult;
627 : }
628 :
629 : //=========================================================================
630 0 : Reference< XDynamicResultSet > Content::createDynamicCursor(
631 : const Sequence< rtl::OUString >& rPropertyNames,
632 : ResultSetInclude eMode )
633 : throw( CommandAbortedException, RuntimeException, Exception )
634 : {
635 0 : Reference< XDynamicResultSet > aResult;
636 0 : createCursorAny( rPropertyNames, eMode ) >>= aResult;
637 :
638 : OSL_ENSURE( aResult.is(), "Content::createDynamicCursor - no cursor!" );
639 :
640 0 : return aResult;
641 : }
642 :
643 : //=========================================================================
644 0 : Reference< XResultSet > Content::createSortedCursor(
645 : const Sequence< rtl::OUString >& rPropertyNames,
646 : const Sequence< NumberedSortingInfo >& rSortInfo,
647 : Reference< XAnyCompareFactory > rAnyCompareFactory,
648 : ResultSetInclude eMode )
649 : throw( CommandAbortedException, RuntimeException, Exception )
650 : {
651 0 : Reference< XResultSet > aResult;
652 0 : Reference< XDynamicResultSet > aDynSet;
653 :
654 0 : Any aCursorAny = createCursorAny( rPropertyNames, eMode );
655 :
656 0 : aCursorAny >>= aDynSet;
657 :
658 0 : if( aDynSet.is() )
659 : {
660 0 : Reference< XDynamicResultSet > aDynResult;
661 :
662 0 : if( m_xImpl->getComponentContext().is() )
663 : {
664 : Reference< XSortedDynamicResultSetFactory > aSortFactory =
665 0 : SortedDynamicResultSetFactory::create( m_xImpl->getComponentContext());
666 :
667 0 : aDynResult = aSortFactory->createSortedDynamicResultSet( aDynSet,
668 : rSortInfo,
669 0 : rAnyCompareFactory );
670 : }
671 :
672 : OSL_ENSURE( aDynResult.is(), "Content::createSortedCursor - no sorted cursor!\n" );
673 :
674 0 : if( aDynResult.is() )
675 0 : aResult = aDynResult->getStaticResultSet();
676 : else
677 0 : aResult = aDynSet->getStaticResultSet();
678 : }
679 :
680 : OSL_ENSURE( aResult.is(), "Content::createSortedCursor - no cursor!" );
681 :
682 0 : if ( !aResult.is() )
683 : {
684 : // Former, the open command directly returned a XResultSet.
685 0 : aCursorAny >>= aResult;
686 :
687 : OSL_ENSURE( !aResult.is(),
688 : "Content::createCursor - open-Command must "
689 : "return a Reference< XDynnamicResultSet >!" );
690 : }
691 :
692 0 : return aResult;
693 : }
694 :
695 : //=========================================================================
696 151 : Reference< XInputStream > Content::openStream()
697 : throw( CommandAbortedException, RuntimeException, Exception )
698 : {
699 151 : if ( !isDocument() )
700 0 : return Reference< XInputStream >();
701 :
702 138 : Reference< XActiveDataSink > xSink = new ActiveDataSink;
703 :
704 138 : OpenCommandArgument2 aArg;
705 138 : aArg.Mode = OpenMode::DOCUMENT;
706 138 : aArg.Priority = 0; // unused
707 138 : aArg.Sink = xSink;
708 138 : aArg.Properties = Sequence< Property >( 0 ); // unused
709 :
710 138 : Command aCommand;
711 138 : aCommand.Name = rtl::OUString("open");
712 138 : aCommand.Handle = -1; // n/a
713 138 : aCommand.Argument <<= aArg;
714 :
715 138 : m_xImpl->executeCommand( aCommand );
716 :
717 138 : return xSink->getInputStream();
718 : }
719 :
720 : //=========================================================================
721 188 : Reference< XInputStream > Content::openStreamNoLock()
722 : throw( CommandAbortedException, RuntimeException, Exception )
723 : {
724 188 : if ( !isDocument() )
725 0 : return Reference< XInputStream >();
726 :
727 182 : Reference< XActiveDataSink > xSink = new ActiveDataSink;
728 :
729 182 : OpenCommandArgument2 aArg;
730 182 : aArg.Mode = OpenMode::DOCUMENT_SHARE_DENY_NONE;
731 182 : aArg.Priority = 0; // unused
732 182 : aArg.Sink = xSink;
733 182 : aArg.Properties = Sequence< Property >( 0 ); // unused
734 :
735 182 : Command aCommand;
736 182 : aCommand.Name = rtl::OUString("open");
737 182 : aCommand.Handle = -1; // n/a
738 182 : aCommand.Argument <<= aArg;
739 :
740 182 : m_xImpl->executeCommand( aCommand );
741 :
742 182 : return xSink->getInputStream();
743 : }
744 :
745 : //=========================================================================
746 253 : Reference< XStream > Content::openWriteableStream()
747 : throw( CommandAbortedException, RuntimeException, Exception )
748 : {
749 253 : if ( !isDocument() )
750 0 : return Reference< XStream >();
751 :
752 249 : Reference< XActiveDataStreamer > xStreamer = new ActiveDataStreamer;
753 :
754 249 : OpenCommandArgument2 aArg;
755 249 : aArg.Mode = OpenMode::DOCUMENT;
756 249 : aArg.Priority = 0; // unused
757 249 : aArg.Sink = xStreamer;
758 249 : aArg.Properties = Sequence< Property >( 0 ); // unused
759 :
760 249 : Command aCommand;
761 249 : aCommand.Name = rtl::OUString("open");
762 249 : aCommand.Handle = -1; // n/a
763 249 : aCommand.Argument <<= aArg;
764 :
765 249 : m_xImpl->executeCommand( aCommand );
766 :
767 249 : return xStreamer->getStream();
768 : }
769 :
770 : //=========================================================================
771 1 : Reference< XStream > Content::openWriteableStreamNoLock()
772 : throw( CommandAbortedException, RuntimeException, Exception )
773 : {
774 1 : if ( !isDocument() )
775 0 : return Reference< XStream >();
776 :
777 0 : Reference< XActiveDataStreamer > xStreamer = new ActiveDataStreamer;
778 :
779 0 : OpenCommandArgument2 aArg;
780 0 : aArg.Mode = OpenMode::DOCUMENT_SHARE_DENY_NONE;
781 0 : aArg.Priority = 0; // unused
782 0 : aArg.Sink = xStreamer;
783 0 : aArg.Properties = Sequence< Property >( 0 ); // unused
784 :
785 0 : Command aCommand;
786 0 : aCommand.Name = rtl::OUString("open");
787 0 : aCommand.Handle = -1; // n/a
788 0 : aCommand.Argument <<= aArg;
789 :
790 0 : m_xImpl->executeCommand( aCommand );
791 :
792 0 : return xStreamer->getStream();
793 : }
794 :
795 : //=========================================================================
796 96 : sal_Bool Content::openStream( const Reference< XActiveDataSink >& rSink )
797 : throw( CommandAbortedException, RuntimeException, Exception )
798 : {
799 96 : if ( !isDocument() )
800 0 : return sal_False;
801 :
802 6 : OpenCommandArgument2 aArg;
803 6 : aArg.Mode = OpenMode::DOCUMENT;
804 6 : aArg.Priority = 0; // unused
805 6 : aArg.Sink = rSink;
806 6 : aArg.Properties = Sequence< Property >( 0 ); // unused
807 :
808 6 : Command aCommand;
809 6 : aCommand.Name = rtl::OUString("open");
810 6 : aCommand.Handle = -1; // n/a
811 6 : aCommand.Argument <<= aArg;
812 :
813 6 : m_xImpl->executeCommand( aCommand );
814 :
815 6 : return sal_True;
816 : }
817 :
818 : //=========================================================================
819 0 : sal_Bool Content::openStream( const Reference< XOutputStream >& rStream )
820 : throw( CommandAbortedException, RuntimeException, Exception )
821 : {
822 0 : if ( !isDocument() )
823 0 : return sal_False;
824 :
825 0 : OpenCommandArgument2 aArg;
826 0 : aArg.Mode = OpenMode::DOCUMENT;
827 0 : aArg.Priority = 0; // unused
828 0 : aArg.Sink = rStream;
829 0 : aArg.Properties = Sequence< Property >( 0 ); // unused
830 :
831 0 : Command aCommand;
832 0 : aCommand.Name = rtl::OUString("open");
833 0 : aCommand.Handle = -1; // n/a
834 0 : aCommand.Argument <<= aArg;
835 :
836 0 : m_xImpl->executeCommand( aCommand );
837 :
838 0 : return sal_True;
839 : }
840 :
841 : //=========================================================================
842 30 : void Content::writeStream( const Reference< XInputStream >& rStream,
843 : sal_Bool bReplaceExisting )
844 : throw( CommandAbortedException, RuntimeException, Exception )
845 : {
846 30 : InsertCommandArgument aArg;
847 30 : aArg.Data = rStream.is() ? rStream : new EmptyInputStream;
848 30 : aArg.ReplaceExisting = bReplaceExisting;
849 :
850 30 : Command aCommand;
851 30 : aCommand.Name = rtl::OUString("insert");
852 30 : aCommand.Handle = -1; // n/a
853 30 : aCommand.Argument <<= aArg;
854 :
855 30 : m_xImpl->executeCommand( aCommand );
856 :
857 30 : m_xImpl->inserted();
858 30 : }
859 :
860 : //=========================================================================
861 13 : Sequence< ContentInfo > Content::queryCreatableContentsInfo()
862 : throw( CommandAbortedException, RuntimeException, Exception )
863 : {
864 : // First, try it using "CreatableContentsInfo" property -> the "new" way.
865 13 : Sequence< ContentInfo > aInfo;
866 26 : if ( getPropertyValue(
867 : rtl::OUString("CreatableContentsInfo") )
868 26 : >>= aInfo )
869 : return aInfo;
870 :
871 : // Second, try it using XContentCreator interface -> the "old" way (not
872 : // providing the chance to supply an XCommandEnvironment.
873 0 : Reference< XContentCreator > xCreator( m_xImpl->getContent(), UNO_QUERY );
874 0 : if ( xCreator.is() )
875 0 : aInfo = xCreator->queryCreatableContentsInfo();
876 :
877 0 : return aInfo;
878 : }
879 :
880 : //=========================================================================
881 13 : sal_Bool Content::insertNewContent( const rtl::OUString& rContentType,
882 : const Sequence< rtl::OUString >&
883 : rPropertyNames,
884 : const Sequence< Any >& rPropertyValues,
885 : Content& rNewContent )
886 : throw( CommandAbortedException, RuntimeException, Exception )
887 : {
888 : return insertNewContent( rContentType,
889 : rPropertyNames,
890 : rPropertyValues,
891 13 : new EmptyInputStream,
892 33 : rNewContent );
893 : }
894 :
895 : //=========================================================================
896 13 : sal_Bool Content::insertNewContent( const rtl::OUString& rContentType,
897 : const Sequence< rtl::OUString >&
898 : rPropertyNames,
899 : const Sequence< Any >& rPropertyValues,
900 : const Reference< XInputStream >& rData,
901 : Content& rNewContent )
902 : throw( CommandAbortedException, RuntimeException, Exception )
903 : {
904 13 : if ( rContentType.isEmpty() )
905 0 : return sal_False;
906 :
907 : // First, try it using "createNewContent" command -> the "new" way.
908 13 : ContentInfo aInfo;
909 13 : aInfo.Type = rContentType;
910 13 : aInfo.Attributes = 0;
911 :
912 13 : Command aCommand;
913 13 : aCommand.Name = rtl::OUString("createNewContent");
914 13 : aCommand.Handle = -1; // n/a
915 13 : aCommand.Argument <<= aInfo;
916 :
917 13 : Reference< XContent > xNew;
918 : try
919 : {
920 13 : m_xImpl->executeCommand( aCommand ) >>= xNew;
921 : }
922 0 : catch ( RuntimeException const & )
923 : {
924 0 : throw;
925 : }
926 0 : catch ( Exception const & )
927 : {
928 : }
929 :
930 13 : if ( !xNew.is() )
931 : {
932 : // Second, try it using XContentCreator interface -> the "old"
933 : // way (not providing the chance to supply an XCommandEnvironment.
934 0 : Reference< XContentCreator > xCreator( m_xImpl->getContent(), UNO_QUERY );
935 :
936 0 : if ( !xCreator.is() )
937 0 : return sal_False;
938 :
939 0 : xNew = xCreator->createNewContent( aInfo );
940 :
941 0 : if ( !xNew.is() )
942 0 : return sal_False;
943 : }
944 :
945 : Content aNewContent(
946 13 : xNew, m_xImpl->getEnvironment(), m_xImpl->getComponentContext() );
947 13 : aNewContent.setPropertyValues( rPropertyNames, rPropertyValues );
948 : aNewContent.executeCommand( rtl::OUString("insert"),
949 : makeAny(
950 : InsertCommandArgument(
951 13 : rData.is() ? rData : new EmptyInputStream,
952 33 : sal_False /* ReplaceExisting */ ) ) );
953 6 : aNewContent.m_xImpl->inserted();
954 :
955 6 : rNewContent = aNewContent;
956 13 : return sal_True;
957 : }
958 :
959 : //=========================================================================
960 283 : sal_Bool Content::transferContent( const Content& rSourceContent,
961 : InsertOperation eOperation,
962 : const rtl::OUString & rTitle,
963 : const sal_Int32 nNameClashAction,
964 : const rtl::OUString & rMimeType,
965 : bool bMajorVersion,
966 : const rtl::OUString & rVersionComment,
967 : rtl::OUString* pResultURL )
968 : throw( CommandAbortedException, RuntimeException, Exception )
969 : {
970 : Reference< XUniversalContentBroker > pBroker(
971 283 : UniversalContentBroker::create( m_xImpl->getComponentContext() ) );
972 :
973 : // Execute command "globalTransfer" at UCB.
974 :
975 283 : TransferCommandOperation eTransOp = TransferCommandOperation();
976 283 : rtl::OUString sCommand( "globalTransfer" );
977 283 : bool bCheckIn = false;
978 283 : switch ( eOperation )
979 : {
980 : case InsertOperation_COPY:
981 283 : eTransOp = TransferCommandOperation_COPY;
982 283 : break;
983 :
984 : case InsertOperation_MOVE:
985 0 : eTransOp = TransferCommandOperation_MOVE;
986 0 : break;
987 :
988 : case InsertOperation_LINK:
989 0 : eTransOp = TransferCommandOperation_LINK;
990 0 : break;
991 :
992 : case InsertOperation_CHECKIN:
993 0 : eTransOp = TransferCommandOperation_COPY;
994 0 : sCommand = rtl::OUString( "checkin" );
995 0 : bCheckIn = true;
996 0 : break;
997 :
998 : default:
999 : ucbhelper::cancelCommandExecution(
1000 : makeAny( IllegalArgumentException(
1001 : rtl::OUString(
1002 : "Unknown transfer operation!" ),
1003 : get(),
1004 0 : -1 ) ),
1005 0 : m_xImpl->getEnvironment() );
1006 : // Unreachable
1007 : }
1008 283 : Command aCommand;
1009 283 : aCommand.Name = sCommand;
1010 283 : aCommand.Handle = -1; // n/a
1011 :
1012 283 : if ( !bCheckIn )
1013 : {
1014 : GlobalTransferCommandArgument2 aTransferArg(
1015 : eTransOp,
1016 283 : rSourceContent.getURL(), // SourceURL
1017 283 : getURL(), // TargetFolderURL,
1018 : rTitle,
1019 : nNameClashAction,
1020 283 : rMimeType );
1021 283 : aCommand.Argument <<= aTransferArg;
1022 : }
1023 : else
1024 : {
1025 : CheckinArgument aCheckinArg( bMajorVersion, rVersionComment,
1026 0 : rSourceContent.getURL(), getURL(), rTitle, rMimeType );
1027 0 : aCommand.Argument <<= aCheckinArg;
1028 : }
1029 :
1030 283 : Any aRet = pBroker->execute( aCommand, 0, m_xImpl->getEnvironment() );
1031 253 : if ( pResultURL != NULL )
1032 0 : aRet >>= *pResultURL;
1033 283 : return sal_True;
1034 : }
1035 :
1036 : //=========================================================================
1037 1196 : sal_Bool Content::isFolder()
1038 : throw( CommandAbortedException, RuntimeException, Exception )
1039 : {
1040 1196 : sal_Bool bFolder = sal_False;
1041 272 : if ( getPropertyValue( rtl::OUString("IsFolder") )
1042 2392 : >>= bFolder )
1043 136 : return bFolder;
1044 :
1045 : ucbhelper::cancelCommandExecution(
1046 : makeAny( UnknownPropertyException(
1047 : rtl::OUString(
1048 : "Unable to retreive value of property 'IsFolder'!" ),
1049 0 : get() ) ),
1050 0 : m_xImpl->getEnvironment() );
1051 :
1052 : // Unreachable - cancelCommandExecution always throws an exception.
1053 : // But some compilers complain...
1054 0 : return sal_False;
1055 : }
1056 :
1057 : //=========================================================================
1058 993 : sal_Bool Content::isDocument()
1059 : throw( CommandAbortedException, RuntimeException, Exception )
1060 : {
1061 993 : sal_Bool bDoc = sal_False;
1062 1684 : if ( getPropertyValue( rtl::OUString("IsDocument") )
1063 1986 : >>= bDoc )
1064 842 : return bDoc;
1065 :
1066 : ucbhelper::cancelCommandExecution(
1067 : makeAny( UnknownPropertyException(
1068 : rtl::OUString(
1069 : "Unable to retreive value of property 'IsDocument'!" ),
1070 0 : get() ) ),
1071 0 : m_xImpl->getEnvironment() );
1072 :
1073 : // Unreachable - cancelCommandExecution always throws an exception,
1074 : // But some compilers complain...
1075 0 : return sal_False;
1076 : }
1077 :
1078 : //=========================================================================
1079 : //=========================================================================
1080 : //
1081 : // Content_Impl Implementation.
1082 : //
1083 : //=========================================================================
1084 : //=========================================================================
1085 :
1086 7734 : Content_Impl::Content_Impl( const Reference< XComponentContext >& rCtx,
1087 : const Reference< XContent >& rContent,
1088 : const Reference< XCommandEnvironment >& rEnv )
1089 : : m_xCtx( rCtx ),
1090 : m_xContent( rContent ),
1091 : m_xEnv( rEnv ),
1092 7734 : m_nCommandId( 0 )
1093 : {
1094 : assert(rCtx.is());
1095 7734 : if ( m_xContent.is() )
1096 : {
1097 7734 : m_xContentEventListener = new ContentEventListener_Impl( *this );
1098 7734 : m_xContent->addContentEventListener( m_xContentEventListener );
1099 :
1100 : #if OSL_DEBUG_LEVEL > 1
1101 : // Only done on demand in product version for performance reasons,
1102 : // but a nice debug helper.
1103 : getURL();
1104 : #endif
1105 : }
1106 7734 : }
1107 :
1108 : //=========================================================================
1109 46 : void Content_Impl::reinit( const Reference< XContent >& xContent )
1110 : {
1111 46 : osl::MutexGuard aGuard( m_aMutex );
1112 :
1113 46 : m_xCommandProcessor = 0;
1114 46 : m_nCommandId = 0;
1115 :
1116 : // #92581# - Don't reset m_aURL!!!
1117 :
1118 46 : if ( m_xContent.is() )
1119 : {
1120 : try
1121 : {
1122 46 : m_xContent->removeContentEventListener( m_xContentEventListener );
1123 : }
1124 0 : catch ( RuntimeException const & )
1125 : {
1126 : }
1127 : }
1128 :
1129 46 : if ( xContent.is() )
1130 : {
1131 0 : m_xContent = xContent;
1132 0 : m_xContent->addContentEventListener( m_xContentEventListener );
1133 :
1134 : #if OSL_DEBUG_LEVEL > 1
1135 : // Only done on demand in product version for performance reasons,
1136 : // but a nice debug helper.
1137 : getURL();
1138 : #endif
1139 : }
1140 : else
1141 : {
1142 : // We need m_xContent's URL in order to be able to create the
1143 : // content object again if demanded ( --> Content_Impl::getContent() )
1144 46 : getURL();
1145 :
1146 46 : m_xContent = 0;
1147 46 : }
1148 46 : }
1149 :
1150 : //=========================================================================
1151 : // virtual
1152 29952 : Content_Impl::~Content_Impl()
1153 : {
1154 9984 : if ( m_xContent.is() )
1155 : {
1156 : try
1157 : {
1158 7462 : m_xContent->removeContentEventListener( m_xContentEventListener );
1159 : }
1160 0 : catch ( RuntimeException const & )
1161 : {
1162 : }
1163 : }
1164 19968 : }
1165 :
1166 : //=========================================================================
1167 0 : void Content_Impl::disposing( const EventObject& Source )
1168 : {
1169 0 : Reference<XContent> xContent;
1170 :
1171 : {
1172 0 : osl::MutexGuard aGuard( m_aMutex );
1173 0 : if(Source.Source != m_xContent)
1174 0 : return;
1175 :
1176 0 : xContent = m_xContent;
1177 :
1178 0 : m_nCommandId = 0;
1179 0 : m_aURL = rtl::OUString();
1180 0 : m_xCommandProcessor = 0;
1181 0 : m_xContent = 0;
1182 : }
1183 :
1184 0 : if ( xContent.is() )
1185 : {
1186 : try
1187 : {
1188 0 : xContent->removeContentEventListener( m_xContentEventListener );
1189 : }
1190 0 : catch ( RuntimeException const & )
1191 : {
1192 : }
1193 0 : }
1194 : }
1195 :
1196 : //=========================================================================
1197 732 : const rtl::OUString& Content_Impl::getURL() const
1198 : {
1199 732 : if ( m_aURL.isEmpty() && m_xContent.is() )
1200 : {
1201 702 : osl::MutexGuard aGuard( m_aMutex );
1202 :
1203 702 : if ( m_aURL.isEmpty() && m_xContent.is() )
1204 : {
1205 702 : Reference< XContentIdentifier > xId = m_xContent->getIdentifier();
1206 702 : if ( xId.is() )
1207 702 : m_aURL = xId->getContentIdentifier();
1208 702 : }
1209 : }
1210 :
1211 732 : return m_aURL;
1212 : }
1213 :
1214 : //=========================================================================
1215 12140 : Reference< XContent > Content_Impl::getContent()
1216 : {
1217 12140 : if ( !m_xContent.is() && !m_aURL.isEmpty() )
1218 : {
1219 0 : osl::MutexGuard aGuard( m_aMutex );
1220 :
1221 0 : if ( !m_xContent.is() && !m_aURL.isEmpty() )
1222 : {
1223 : Reference< XUniversalContentBroker > pBroker(
1224 0 : UniversalContentBroker::create( getComponentContext() ) );
1225 :
1226 : OSL_ENSURE( pBroker->queryContentProviders().getLength(),
1227 : "Content Broker not configured (no providers)!" );
1228 :
1229 : Reference< XContentIdentifier > xId
1230 0 : = pBroker->createContentIdentifier( m_aURL );
1231 :
1232 : OSL_ENSURE( xId.is(), "No Content Identifier!" );
1233 :
1234 0 : if ( xId.is() )
1235 : {
1236 : try
1237 : {
1238 0 : m_xContent = pBroker->queryContent( xId );
1239 : }
1240 0 : catch ( IllegalIdentifierException const & )
1241 : {
1242 : }
1243 :
1244 0 : if ( m_xContent.is() )
1245 0 : m_xContent->addContentEventListener(
1246 0 : m_xContentEventListener );
1247 0 : }
1248 0 : }
1249 : }
1250 :
1251 12140 : return m_xContent;
1252 : }
1253 :
1254 : //=========================================================================
1255 15575 : Reference< XCommandProcessor > Content_Impl::getCommandProcessor()
1256 : {
1257 15575 : if ( !m_xCommandProcessor.is() )
1258 : {
1259 5598 : osl::MutexGuard aGuard( m_aMutex );
1260 :
1261 5598 : if ( !m_xCommandProcessor.is() )
1262 : m_xCommandProcessor
1263 5598 : = Reference< XCommandProcessor >( getContent(), UNO_QUERY );
1264 : }
1265 :
1266 15575 : return m_xCommandProcessor;
1267 : }
1268 :
1269 : //=========================================================================
1270 9977 : sal_Int32 Content_Impl::getCommandId()
1271 : {
1272 9977 : if ( m_nCommandId == 0 )
1273 : {
1274 5598 : osl::MutexGuard aGuard( m_aMutex );
1275 :
1276 5598 : if ( m_nCommandId == 0 )
1277 : {
1278 5598 : Reference< XCommandProcessor > xProc = getCommandProcessor();
1279 5598 : if ( xProc.is() )
1280 5598 : m_nCommandId = xProc->createCommandIdentifier();
1281 5598 : }
1282 : }
1283 :
1284 9977 : return m_nCommandId;
1285 : }
1286 :
1287 : //=========================================================================
1288 9977 : Any Content_Impl::executeCommand( const Command& rCommand )
1289 : {
1290 9977 : Reference< XCommandProcessor > xProc = getCommandProcessor();
1291 9977 : if ( !xProc.is() )
1292 0 : return Any();
1293 :
1294 : // Execute command
1295 9977 : return xProc->execute( rCommand, getCommandId(), m_xEnv );
1296 : }
1297 :
1298 : //=========================================================================
1299 : inline const Reference< XCommandEnvironment >&
1300 296 : Content_Impl::getEnvironment() const
1301 : {
1302 296 : return m_xEnv;
1303 : }
1304 :
1305 : //=========================================================================
1306 0 : inline void Content_Impl::setEnvironment(
1307 : const Reference< XCommandEnvironment >& xNewEnv )
1308 : {
1309 0 : osl::MutexGuard aGuard( m_aMutex );
1310 0 : m_xEnv = xNewEnv;
1311 0 : }
1312 :
1313 : //=========================================================================
1314 36 : void Content_Impl::inserted()
1315 : {
1316 : // URL might have changed during 'insert' => recalculate in next getURL()
1317 36 : osl::MutexGuard aGuard( m_aMutex );
1318 36 : m_aURL = ::rtl::OUString();
1319 36 : }
1320 :
1321 : //=========================================================================
1322 : //=========================================================================
1323 : //
1324 : // ContentEventListener_Impl Implementation.
1325 : //
1326 : //=========================================================================
1327 : //=========================================================================
1328 :
1329 : //=========================================================================
1330 : //
1331 : // XInterface methods.
1332 : //
1333 : //=========================================================================
1334 :
1335 55071 : XINTERFACE_IMPL_2( ContentEventListener_Impl,
1336 : XContentEventListener,
1337 : XEventListener ); /* base of XContentEventListener */
1338 :
1339 : //=========================================================================
1340 : //
1341 : // XContentEventListener methods.
1342 : //
1343 : //=========================================================================
1344 :
1345 : // virtual
1346 315 : void SAL_CALL ContentEventListener_Impl::contentEvent( const ContentEvent& evt )
1347 : throw( RuntimeException )
1348 : {
1349 315 : if ( evt.Source == m_rContent.m_xContent )
1350 : {
1351 315 : switch ( evt.Action )
1352 : {
1353 : case ContentAction::DELETED:
1354 46 : m_rContent.reinit( Reference< XContent >() );
1355 46 : break;
1356 :
1357 : case ContentAction::EXCHANGED:
1358 0 : m_rContent.reinit( evt.Content );
1359 0 : break;
1360 :
1361 : default:
1362 269 : break;
1363 : }
1364 : }
1365 315 : }
1366 :
1367 : //=========================================================================
1368 : //
1369 : // XEventListenr methods.
1370 : //
1371 : //=========================================================================
1372 :
1373 : // virtual
1374 0 : void SAL_CALL ContentEventListener_Impl::disposing( const EventObject& Source )
1375 : throw( RuntimeException )
1376 : {
1377 0 : m_rContent.disposing(Source);
1378 0 : }
1379 :
1380 : } /* namespace ucbhelper */
1381 :
1382 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
