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