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