dbaccess/source/core/dataaccess/ContentHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ContentHelper.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_dbaccess.hxx"
  33 #ifndef DBA_CONTENTHELPER_HXX
  34 #include "ContentHelper.hxx"
  35 #endif
  36 #ifndef _UCBHELPER_CANCELCOMMANDEXECUTION_HXX_
  37 #include <ucbhelper/cancelcommandexecution.hxx>
  38 #endif
  39 #ifndef _COMPHELPER_PROPERTY_HXX_
  40 #include <comphelper/property.hxx>
  41 #endif
  42 #ifndef _COM_SUN_STAR_UCB_UNSUPPORTEDCOMMANDEXCEPTION_HPP_
  43 #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
  44 #endif
  45 #ifndef _COM_SUN_STAR_LANG_ILLEGALARGUMENTEXCEPTION_HPP_
  46 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  47 #endif
  48 #ifndef _COM_SUN_STAR_LANG_ILLEGALACCESSEXCEPTION_HPP_
  49 #include <com/sun/star/lang/IllegalAccessException.hpp>
  50 #endif
  51 #ifndef _COM_SUN_STAR_IO_XOUTPUTSTREAM_HPP_
  52 #include <com/sun/star/io/XOutputStream.hpp>
  53 #endif
  54 #ifndef _COM_SUN_STAR_IO_XACTIVEDATASINK_HPP_
  55 #include <com/sun/star/io/XActiveDataSink.hpp>
  56 #endif
  57 #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
  58 #include <com/sun/star/beans/PropertyAttribute.hpp>
  59 #endif
  60 #ifndef _UCBHELPER_PROPERTYVALUESET_HXX
  61 #include <ucbhelper/propertyvalueset.hxx>
  62 #endif
  63 #ifndef _UCBHELPER_CONTENTIDENTIFIER_HXX
  64 #include <ucbhelper/contentidentifier.hxx>
  65 #endif
  66 #ifndef DBA_UCPRESULTSET_HXX
  67 #include "myucp_resultset.hxx"
  68 #endif
  69 #ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_
  70 #include <com/sun/star/container/XNameContainer.hpp>
  71 #endif
  72 #ifndef DBACORE_SDBCORETOOLS_HXX
  73 #include "sdbcoretools.hxx"
  74 #endif
  75 #ifndef DBACCESS_SHARED_DBASTRINGS_HRC
  76 #include "dbastrings.hrc"
  77 #endif
  78 #ifndef _TOOLS_DEBUG_HXX
  79 #include <tools/debug.hxx>
  80 #endif
  81
  82
  83 namespace dbaccess
  84 {
  85 using namespace ::com::sun::star::uno;
  86 using namespace ::com::sun::star::ucb;
  87 using namespace ::com::sun::star::beans;
  88 using namespace ::com::sun::star::lang;
  89 using namespace ::com::sun::star::sdbc;
  90 using namespace ::com::sun::star::io;
  91 using namespace ::com::sun::star::util;
  92 using namespace ::com::sun::star::embed;
  93 using namespace ::com::sun::star::container;
  94 using namespace ::comphelper;
  95 using namespace ::cppu;
  96
  97 // -----------------------------------------------------------------------------
  98 DBG_NAME(OContentHelper_Impl)
  99 OContentHelper_Impl::OContentHelper_Impl()
 100 {
 101     DBG_CTOR(OContentHelper_Impl,NULL);
 102 }
 103 // -----------------------------------------------------------------------------
 104 OContentHelper_Impl::~OContentHelper_Impl()
 105 {
 106     DBG_DTOR(OContentHelper_Impl,NULL);
 107 }
 108 // -----------------------------------------------------------------------------
 109
 110 OContentHelper::OContentHelper(const Reference< XMultiServiceFactory >& _xORB
 111                                ,const Reference< XInterface >&  _xParentContainer
 112                                ,const TContentPtr& _pImpl)
 113     : OContentHelper_COMPBASE(m_aMutex)
 114     ,m_aContentListeners(m_aMutex)
 115     ,m_aPropertyChangeListeners(m_aMutex)
 116     ,m_xParentContainer(_xParentContainer)
 117     ,m_aContext( _xORB )
 118     ,m_aErrorHelper( m_aContext )
 119     ,m_pImpl(_pImpl)
 120     ,m_nCommandId(0)
 121 {
 122 }
 123 //--------------------------------------------------------------------------
 124 void SAL_CALL OContentHelper::disposing()
 125 {
 126     ::osl::MutexGuard aGuard(m_aMutex);
 127
 128     // say our listeners goobye
 129     EventObject aEvt(*this);
 130     m_aContentListeners.disposeAndClear(aEvt);
 131
 132     m_xParentContainer = NULL;
 133 }
 134 // -----------------------------------------------------------------------------
 135 IMPLEMENT_SERVICE_INFO1(OContentHelper,"com.sun.star.comp.sdb.Content","com.sun.star.ucb.Content");
 136 IMPLEMENT_IMPLEMENTATION_ID(OContentHelper)
 137 // -----------------------------------------------------------------------------
 138 // XContent
 139 Reference< XContentIdentifier > SAL_CALL OContentHelper::getIdentifier(  ) throw (RuntimeException)
 140 {
 141     ::osl::MutexGuard aGuard(m_aMutex);
 142     ::rtl::OUStringBuffer aIdentifier;
 143     aIdentifier.appendAscii( "private:" );
 144     aIdentifier.append( impl_getHierarchicalName( true ) );
 145     return new ::ucbhelper::ContentIdentifier( m_aContext.getLegacyServiceFactory(), aIdentifier.makeStringAndClear() );
 146 }
 147 // -----------------------------------------------------------------------------
 148 ::rtl::OUString OContentHelper::impl_getHierarchicalName( bool _includingRootContainer ) const
 149 {
 150     ::rtl::OUStringBuffer aHierarchicalName( m_pImpl->m_aProps.aTitle );
 151     Reference< XInterface > xParent = m_xParentContainer;
 152     while( xParent.is() )
 153     {
 154         Reference<XPropertySet> xProp( xParent, UNO_QUERY );
 155         Reference< XChild > xChild( xParent, UNO_QUERY );
 156         xParent.set( xChild.is() ? xChild->getParent() : Reference< XInterface >(), UNO_QUERY );
 157         if ( xProp.is() && xParent.is() )
 158         {
 159             ::rtl::OUString sName;
 160             xProp->getPropertyValue( PROPERTY_NAME ) >>= sName;
 161
 162             ::rtl::OUString sPrevious = aHierarchicalName.makeStringAndClear();
 163             aHierarchicalName.append( sName );
 164             aHierarchicalName.append( sal_Unicode( '/' ) );
 165             aHierarchicalName.append( sPrevious );
 166         }
 167     }
 168     ::rtl::OUString sHierarchicalName( aHierarchicalName.makeStringAndClear() );
 169     if ( !_includingRootContainer )
 170         sHierarchicalName = sHierarchicalName.copy( sHierarchicalName.indexOf( '/' ) + 1 );
 171     return sHierarchicalName;
 172 }
 173
 174 // -----------------------------------------------------------------------------
 175 ::rtl::OUString SAL_CALL OContentHelper::getContentType() throw (RuntimeException)
 176 {
 177     ::osl::MutexGuard aGuard(m_aMutex);
 178
 179     if ( !m_pImpl->m_aProps.aContentType )
 180     {   // content type not yet retrieved
 181         m_pImpl->m_aProps.aContentType.reset( determineContentType() );
 182     }
 183
 184     return *m_pImpl->m_aProps.aContentType;
 185 }
 186 // -----------------------------------------------------------------------------
 187 void SAL_CALL OContentHelper::addContentEventListener( const Reference< XContentEventListener >& _rxListener ) throw (RuntimeException)
 188 {
 189     ::osl::MutexGuard aGuard(m_aMutex);
 190     if ( _rxListener.is() )
 191         m_aContentListeners.addInterface(_rxListener);
 192 }
 193 // -----------------------------------------------------------------------------
 194 void SAL_CALL OContentHelper::removeContentEventListener( const Reference< XContentEventListener >& _rxListener ) throw (RuntimeException)
 195 {
 196     ::osl::MutexGuard aGuard(m_aMutex);
 197     if (_rxListener.is())
 198         m_aContentListeners.removeInterface(_rxListener);
 199 }
 200 // -----------------------------------------------------------------------------
 201
 202 // XCommandProcessor
 203 sal_Int32 SAL_CALL OContentHelper::createCommandIdentifier(  ) throw (RuntimeException)
 204 {
 205     ::osl::MutexGuard aGuard(m_aMutex);
 206     // Just increase counter on every call to generate an identifier.
 207     return ++m_nCommandId;
 208 }
 209 // -----------------------------------------------------------------------------
 210 Any SAL_CALL OContentHelper::execute( const Command& aCommand, sal_Int32 /*CommandId*/, const Reference< XCommandEnvironment >& Environment ) throw (Exception, CommandAbortedException, RuntimeException)
 211 {
 212     Any aRet;
 213     if ( aCommand.Name.compareToAscii( "getPropertyValues" ) == 0 )
 214     {
 215         //////////////////////////////////////////////////////////////////
 216         // getPropertyValues
 217         //////////////////////////////////////////////////////////////////
 218
 219         Sequence< Property > Properties;
 220         if ( !( aCommand.Argument >>= Properties ) )
 221         {
 222             OSL_ENSURE( sal_False, "Wrong argument type!" );
 223             ucbhelper::cancelCommandExecution(
 224                 makeAny( IllegalArgumentException(
 225                                     rtl::OUString(),
 226                                     static_cast< cppu::OWeakObject * >( this ),
 227                                     -1 ) ),
 228                 Environment );
 229             // Unreachable
 230         }
 231         aRet <<= getPropertyValues( Properties);
 232     }
 233     else if ( aCommand.Name.compareToAscii( "setPropertyValues" ) == 0 )
 234     {
 235         //////////////////////////////////////////////////////////////////
 236         // setPropertyValues
 237         //////////////////////////////////////////////////////////////////
 238
 239         Sequence< PropertyValue > aProperties;
 240         if ( !( aCommand.Argument >>= aProperties ) )
 241         {
 242             OSL_ENSURE( sal_False, "Wrong argument type!" );
 243             ucbhelper::cancelCommandExecution(
 244                 makeAny( IllegalArgumentException(
 245                                     rtl::OUString(),
 246                                     static_cast< cppu::OWeakObject * >( this ),
 247                                     -1 ) ),
 248                 Environment );
 249             // Unreachable
 250         }
 251
 252         if ( !aProperties.getLength() )
 253         {
 254             OSL_ENSURE( sal_False, "No properties!" );
 255             ucbhelper::cancelCommandExecution(
 256                 makeAny( IllegalArgumentException(
 257                                     rtl::OUString(),
 258                                     static_cast< cppu::OWeakObject * >( this ),
 259                                     -1 ) ),
 260                 Environment );
 261             // Unreachable
 262         }
 263
 264         aRet <<= setPropertyValues( aProperties, Environment );
 265     }
 266     else if ( aCommand.Name.compareToAscii( "getPropertySetInfo" ) == 0 )
 267     {
 268         //////////////////////////////////////////////////////////////////
 269         // getPropertySetInfo
 270         //////////////////////////////////////////////////////////////////
 271
 272         Reference<XPropertySet> xProp(*this,UNO_QUERY);
 273         if ( xProp.is() )
 274             aRet <<= xProp->getPropertySetInfo();
 275         //      aRet <<= getPropertySetInfo(); // TODO
 276     }
 277     else
 278     {
 279         //////////////////////////////////////////////////////////////////
 280         // Unsupported command
 281         //////////////////////////////////////////////////////////////////
 282
 283         OSL_ENSURE( sal_False, "Content::execute - unsupported command!" );
 284
 285         ucbhelper::cancelCommandExecution(
 286             makeAny( UnsupportedCommandException(
 287                             rtl::OUString(),
 288                             static_cast< cppu::OWeakObject * >( this ) ) ),
 289             Environment );
 290         // Unreachable
 291     }
 292
 293     return aRet;
 294 }
 295 // -----------------------------------------------------------------------------
 296 void SAL_CALL OContentHelper::abort( sal_Int32 /*CommandId*/ ) throw (RuntimeException)
 297 {
 298 }
 299 // -----------------------------------------------------------------------------
 300
 301 // XPropertiesChangeNotifier
 302 void SAL_CALL OContentHelper::addPropertiesChangeListener( const Sequence< ::rtl::OUString >& PropertyNames, const Reference< XPropertiesChangeListener >& Listener ) throw (RuntimeException)
 303 {
 304     ::osl::MutexGuard aGuard(m_aMutex);
 305     sal_Int32 nCount = PropertyNames.getLength();
 306     if ( !nCount )
 307     {
 308         // Note: An empty sequence means a listener for "all" properties.
 309         m_aPropertyChangeListeners.addInterface(::rtl::OUString(), Listener );
 310     }
 311     else
 312     {
 313         const ::rtl::OUString* pSeq = PropertyNames.getConstArray();
 314
 315         for ( sal_Int32 n = 0; n < nCount; ++n )
 316         {
 317             const ::rtl::OUString& rName = pSeq[ n ];
 318             if ( rName.getLength() )
 319                 m_aPropertyChangeListeners.addInterface(rName, Listener );
 320         }
 321     }
 322 }
 323 // -----------------------------------------------------------------------------
 324 void SAL_CALL OContentHelper::removePropertiesChangeListener( const Sequence< ::rtl::OUString >& PropertyNames, const Reference< XPropertiesChangeListener >& Listener ) throw (RuntimeException)
 325 {
 326     ::osl::MutexGuard aGuard(m_aMutex);
 327     sal_Int32 nCount = PropertyNames.getLength();
 328     if ( !nCount )
 329     {
 330         // Note: An empty sequence means a listener for "all" properties.
 331         m_aPropertyChangeListeners.removeInterface( ::rtl::OUString(), Listener );
 332     }
 333     else
 334     {
 335         const ::rtl::OUString* pSeq = PropertyNames.getConstArray();
 336
 337         for ( sal_Int32 n = 0; n < nCount; ++n )
 338         {
 339             const ::rtl::OUString& rName = pSeq[ n ];
 340             if ( rName.getLength() )
 341                 m_aPropertyChangeListeners.removeInterface( rName, Listener );
 342         }
 343     }
 344 }
 345 // -----------------------------------------------------------------------------
 346
 347 // XPropertyContainer
 348 void SAL_CALL OContentHelper::addProperty( const ::rtl::OUString& /*Name*/, sal_Int16 /*Attributes*/, const Any& /*DefaultValue*/ ) throw (PropertyExistException, IllegalTypeException, IllegalArgumentException, RuntimeException)
 349 {
 350     DBG_ERROR( "OContentHelper::addProperty: not implemented!" );
 351 }
 352 // -----------------------------------------------------------------------------
 353 void SAL_CALL OContentHelper::removeProperty( const ::rtl::OUString& /*Name*/ ) throw (UnknownPropertyException, NotRemoveableException, RuntimeException)
 354 {
 355     DBG_ERROR( "OContentHelper::removeProperty: not implemented!" );
 356 }
 357 // -----------------------------------------------------------------------------
 358 // XInitialization
 359 void SAL_CALL OContentHelper::initialize( const Sequence< Any >& _aArguments ) throw(Exception, RuntimeException)
 360 {
 361     const Any* pBegin = _aArguments.getConstArray();
 362     const Any* pEnd = pBegin + _aArguments.getLength();
 363     PropertyValue aValue;;
 364     for(;pBegin != pEnd;++pBegin)
 365     {
 366         *pBegin >>= aValue;
 367         if ( aValue.Name.equalsAscii("Parent") )
 368         {
 369             m_xParentContainer.set(aValue.Value,UNO_QUERY);
 370         }
 371         else if ( aValue.Name.equalsAscii(PROPERTY_NAME) )
 372         {
 373             aValue.Value >>= m_pImpl->m_aProps.aTitle;
 374         }
 375         else if ( aValue.Name.equalsAscii(PROPERTY_PERSISTENT_NAME) )
 376         {
 377             aValue.Value >>= m_pImpl->m_aProps.sPersistentName;
 378         }
 379     }
 380 }
 381 // -----------------------------------------------------------------------------
 382 Sequence< Any > OContentHelper::setPropertyValues(const Sequence< PropertyValue >& rValues,const Reference< XCommandEnvironment >& /*xEnv*/ )
 383 {
 384     osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
 385
 386     Sequence< Any > aRet( rValues.getLength() );
 387     Sequence< PropertyChangeEvent > aChanges( rValues.getLength() );
 388     sal_Int32 nChanged = 0;
 389
 390     PropertyChangeEvent aEvent;
 391     aEvent.Source         = static_cast< cppu::OWeakObject * >( this );
 392     aEvent.Further                = sal_False;
 393     aEvent.PropertyHandle = -1;
 394
 395     const PropertyValue* pValues = rValues.getConstArray();
 396     sal_Int32 nCount = rValues.getLength();
 397
 398     for ( sal_Int32 n = 0; n < nCount; ++n )
 399     {
 400         const PropertyValue& rValue = pValues[ n ];
 401
 402         if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) )
 403         {
 404             // Read-only property!
 405             aRet[ n ] <<= IllegalAccessException(
 406                             rtl::OUString::createFromAscii(
 407                                 "Property is read-only!" ),
 408                             static_cast< cppu::OWeakObject * >( this ) );
 409         }
 410         else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) )
 411         {
 412             // Read-only property!
 413             aRet[ n ] <<= IllegalAccessException(
 414                             rtl::OUString::createFromAscii(
 415                                 "Property is read-only!" ),
 416                             static_cast< cppu::OWeakObject * >( this ) );
 417         }
 418         else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) )
 419         {
 420             // Read-only property!
 421             aRet[ n ] <<= IllegalAccessException(
 422                             rtl::OUString::createFromAscii(
 423                                 "Property is read-only!" ),
 424                             static_cast< cppu::OWeakObject * >( this ) );
 425         }
 426         else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) )
 427         {
 428             rtl::OUString aNewValue;
 429             if ( rValue.Value >>= aNewValue )
 430             {
 431                 if ( aNewValue != m_pImpl->m_aProps.aTitle )
 432                 {
 433                     aEvent.PropertyName = rValue.Name;
 434                     aEvent.OldValue     = makeAny( m_pImpl->m_aProps.aTitle );
 435
 436                     try
 437                     {
 438                         impl_rename_throw( aNewValue ,false);
 439                         OSL_ENSURE( m_pImpl->m_aProps.aTitle == aNewValue, "OContentHelper::setPropertyValues('Title'): rename did not work!" );
 440
 441                         aEvent.NewValue     = makeAny( aNewValue );
 442                         aChanges.getArray()[ nChanged ] = aEvent;
 443                         nChanged++;
 444                     }
 445                     catch( const Exception& )
 446                     {
 447                         OSL_ENSURE( sal_False, "OContentHelper::setPropertyValues('Title'): caught an exception while renaming!" );
 448                     }
 449                 }
 450                 else
 451                 {
 452                     // Old value equals new value. No error!
 453                 }
 454             }
 455             else
 456             {
 457                 aRet[ n ] <<= IllegalTypeException(
 458                                 rtl::OUString::createFromAscii(
 459                                     "Property value has wrong type!" ),
 460                                 static_cast< cppu::OWeakObject * >( this ) );
 461             }
 462         }
 463
 464         // @@@ Process other properties supported directly.
 465 #if 0
 466         else if ( rValue.Name.equalsAsciiL(
 467                         RTL_CONSTASCII_STRINGPARAM( "xxxxxx" ) ) )
 468         {
 469         }
 470 #endif
 471         else
 472         {
 473             aRet[ n ] <<= Exception(
 474                             rtl::OUString::createFromAscii(
 475                                 "No property set for storing the value!" ),
 476                             static_cast< cppu::OWeakObject * >( this ) );
 477         }
 478     }
 479
 480     if ( nChanged > 0 )
 481     {
 482         // @@@ Save changes.
 483 //              storeData();
 484
 485         notifyDataSourceModified();
 486         aGuard.clear();
 487         aChanges.realloc( nChanged );
 488         notifyPropertiesChange( aChanges );
 489     }
 490
 491     return aRet;
 492 }
 493 // -----------------------------------------------------------------------------
 494 //=========================================================================
 495 // static
 496 Reference< XRow > OContentHelper::getPropertyValues( const Sequence< Property >& rProperties)
 497 {
 498     // Note: Empty sequence means "get values of all supported properties".
 499
 500     rtl::Reference< ::ucbhelper::PropertyValueSet > xRow = new ::ucbhelper::PropertyValueSet( m_aContext.getLegacyServiceFactory() );
 501
 502     sal_Int32 nCount = rProperties.getLength();
 503     if ( nCount )
 504     {
 505         const Property* pProps = rProperties.getConstArray();
 506         for ( sal_Int32 n = 0; n < nCount; ++n )
 507         {
 508             const Property& rProp = pProps[ n ];
 509
 510             // Process Core properties.
 511
 512             if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) )
 513             {
 514                 xRow->appendString ( rProp, getContentType() );
 515             }
 516             else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) )
 517             {
 518                 xRow->appendString ( rProp, m_pImpl->m_aProps.aTitle );
 519             }
 520             else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) )
 521             {
 522                 xRow->appendBoolean( rProp, m_pImpl->m_aProps.bIsDocument );
 523             }
 524             else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) )
 525             {
 526                 xRow->appendBoolean( rProp, m_pImpl->m_aProps.bIsFolder );
 527             }
 528             else
 529                 xRow->appendVoid(rProp);
 530
 531             // @@@ Process other properties supported directly.
 532 #if 0
 533             else if ( rProp.Name.equalsAsciiL(
 534                     RTL_CONSTASCII_STRINGPARAM( "xxxxxx" ) ) )
 535             {
 536             }
 537 #endif
 538         }
 539     }
 540     else
 541     {
 542         // Append all Core Properties.
 543         xRow->appendString (
 544             Property( rtl::OUString::createFromAscii( "ContentType" ),
 545                       -1,
 546                       getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
 547                       PropertyAttribute::BOUND
 548                         | PropertyAttribute::READONLY ),
 549             getContentType() );
 550         xRow->appendString (
 551             Property( rtl::OUString::createFromAscii( "Title" ),
 552                       -1,
 553                       getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
 554                       PropertyAttribute::BOUND ),
 555             m_pImpl->m_aProps.aTitle );
 556         xRow->appendBoolean(
 557             Property( rtl::OUString::createFromAscii( "IsDocument" ),
 558                       -1,
 559                       getCppuBooleanType(),
 560                       PropertyAttribute::BOUND
 561                         | PropertyAttribute::READONLY ),
 562             m_pImpl->m_aProps.bIsDocument );
 563         xRow->appendBoolean(
 564             Property( rtl::OUString::createFromAscii( "IsFolder" ),
 565                       -1,
 566                       getCppuBooleanType(),
 567                       PropertyAttribute::BOUND
 568                         | PropertyAttribute::READONLY ),
 569             m_pImpl->m_aProps.bIsFolder );
 570
 571         // @@@ Append other properties supported directly.
 572     }
 573
 574     return Reference< XRow >( xRow.get() );
 575 }
 576 // -----------------------------------------------------------------------------
 577 // -----------------------------------------------------------------------------
 578 void OContentHelper::notifyPropertiesChange( const Sequence< PropertyChangeEvent >& evt ) const
 579 {
 580
 581     sal_Int32 nCount = evt.getLength();
 582     if ( nCount )
 583     {
 584         // First, notify listeners interested in changes of every property.
 585         OInterfaceContainerHelper* pAllPropsContainer = m_aPropertyChangeListeners.getContainer( ::rtl::OUString() );
 586         if ( pAllPropsContainer )
 587         {
 588             OInterfaceIteratorHelper aIter( *pAllPropsContainer );
 589             while ( aIter.hasMoreElements() )
 590             {
 591                 // Propagate event.
 592                 Reference< XPropertiesChangeListener > xListener( aIter.next(), UNO_QUERY );
 593                 if ( xListener.is() )
 594                     xListener->propertiesChange( evt );
 595             }
 596         }
 597
 598         typedef Sequence< PropertyChangeEvent > PropertyEventSequence;
 599         typedef ::std::map< XPropertiesChangeListener*, PropertyEventSequence* > PropertiesEventListenerMap;
 600         PropertiesEventListenerMap aListeners;
 601
 602
 603         const PropertyChangeEvent* propertyChangeEvent = evt.getConstArray();
 604
 605         for ( sal_Int32 n = 0; n < nCount; ++n, ++propertyChangeEvent )
 606         {
 607             const PropertyChangeEvent& rEvent = *propertyChangeEvent;
 608             const ::rtl::OUString& rName = rEvent.PropertyName;
 609
 610             OInterfaceContainerHelper* pPropsContainer = m_aPropertyChangeListeners.getContainer( rName );
 611             if ( pPropsContainer )
 612             {
 613                 OInterfaceIteratorHelper aIter( *pPropsContainer );
 614                 while ( aIter.hasMoreElements() )
 615                 {
 616                     PropertyEventSequence* propertyEvents = NULL;
 617
 618                     XPropertiesChangeListener* pListener = static_cast< XPropertiesChangeListener * >( aIter.next() );
 619                     PropertiesEventListenerMap::iterator it = aListeners.find( pListener );
 620                     if ( it == aListeners.end() )
 621                     {
 622                         // Not in map - create and insert new entry.
 623                         propertyEvents = new PropertyEventSequence( nCount );
 624                         aListeners[ pListener ] = propertyEvents;
 625                     }
 626                     else
 627                         propertyEvents = (*it).second;
 628
 629                     if ( propertyEvents )
 630                         (*propertyEvents)[n] = rEvent;
 631                 }
 632             }
 633         }
 634
 635         // Notify listeners.
 636         PropertiesEventListenerMap::iterator it = aListeners.begin();
 637         while ( !aListeners.empty() )
 638         {
 639             XPropertiesChangeListener* pListener =
 640                     static_cast< XPropertiesChangeListener * >( (*it).first );
 641             PropertyEventSequence* pSeq = (*it).second;
 642
 643             // Remove current element.
 644             aListeners.erase( it );
 645
 646             // Propagate event.
 647             pListener->propertiesChange( *pSeq );
 648
 649             delete pSeq;
 650
 651             it = aListeners.begin();
 652         }
 653     }
 654 }
 655 // -----------------------------------------------------------------------------
 656 // com::sun::star::lang::XUnoTunnel
 657 //------------------------------------------------------------------
 658 sal_Int64 OContentHelper::getSomething( const Sequence< sal_Int8 > & rId ) throw (RuntimeException)
 659 {
 660     if (rId.getLength() == 16 && 0 == rtl_compareMemory(getUnoTunnelImplementationId().getConstArray(),  rId.getConstArray(), 16 ) )
 661         return reinterpret_cast<sal_Int64>(this);
 662
 663     return 0;
 664 }
 665
 666 // -----------------------------------------------------------------------------
 667 OContentHelper* OContentHelper::getImplementation( const Reference< XInterface >& _rxComponent )
 668 {
 669     OContentHelper* pContent( NULL );
 670
 671     Reference< XUnoTunnel > xUnoTunnel( _rxComponent, UNO_QUERY );
 672     if ( xUnoTunnel.is() )
 673         pContent = reinterpret_cast< OContentHelper* >( xUnoTunnel->getSomething( getUnoTunnelImplementationId() ) );
 674
 675     return pContent;
 676 }
 677
 678 // -----------------------------------------------------------------------------
 679 Reference< XInterface > SAL_CALL OContentHelper::getParent(  ) throw (RuntimeException)
 680 {
 681     ::osl::MutexGuard aGuard(m_aMutex);
 682     return m_xParentContainer;
 683 }
 684 // -----------------------------------------------------------------------------
 685 void SAL_CALL OContentHelper::setParent( const Reference< XInterface >& _xParent ) throw (NoSupportException, RuntimeException)
 686 {
 687     ::osl::MutexGuard aGuard(m_aMutex);
 688     m_xParentContainer = _xParent;
 689 }
 690
 691 // -----------------------------------------------------------------------------
 692 void OContentHelper::impl_rename_throw(const ::rtl::OUString& _sNewName,bool _bNotify )
 693 {
 694     osl::ClearableGuard< osl::Mutex > aGuard(m_aMutex);
 695     if ( _sNewName.equals( m_pImpl->m_aProps.aTitle ) )
 696         return;
 697     try
 698     {
 699         Sequence< PropertyChangeEvent > aChanges( 1 );
 700
 701         aChanges[0].Source          = static_cast< cppu::OWeakObject * >( this );
 702         aChanges[0].Further         = sal_False;
 703         aChanges[0].PropertyName    = PROPERTY_NAME;
 704         aChanges[0].PropertyHandle  = PROPERTY_ID_NAME;
 705         aChanges[0].OldValue        <<= m_pImpl->m_aProps.aTitle;
 706         aChanges[0].NewValue        <<= _sNewName;
 707
 708         aGuard.clear();
 709
 710         m_pImpl->m_aProps.aTitle = _sNewName;
 711         if ( _bNotify )
 712             notifyPropertiesChange( aChanges );
 713         notifyDataSourceModified();
 714     }
 715     catch(const PropertyVetoException&)
 716     {
 717         throw ElementExistException(_sNewName,*this);
 718     }
 719 }
 720 // -----------------------------------------------------------------------------
 721 void SAL_CALL OContentHelper::rename( const ::rtl::OUString& newName ) throw (SQLException, ElementExistException, RuntimeException)
 722 {
 723
 724     impl_rename_throw(newName);
 725     //Reference<XNameContainer> xNameCont(m_xParentContainer,UNO_QUERY);
 726     //if ( xNameCont.is() )
 727     //{
 728     //  if ( xNameCont->hasByName(newName) )
 729     //          throw ElementExistException(newName,*this);
 730
 731     //  try
 732     //  {
 733     //          if ( xNameCont->hasByName(m_pImpl->m_aProps.aTitle) )
 734     //                  xNameCont->removeByName(m_pImpl->m_aProps.aTitle);
 735
 736     //          m_pImpl->m_aProps.aTitle = newName;
 737     //          xNameCont->insertByName(m_pImpl->m_aProps.aTitle,makeAny(Reference<XContent>(*this,UNO_QUERY)));
 738     //          notifyDataSourceModified();
 739     //  }
 740     //  catch(IllegalArgumentException)
 741     //  {
 742     //          throw SQLException();
 743     //  }
 744     //  catch(NoSuchElementException)
 745     //  {
 746     //          throw SQLException();
 747     //  }
 748     //  catch(WrappedTargetException)
 749     //  {
 750     //          throw SQLException();
 751     //  }
 752     //}
 753     //else
 754     //  m_pImpl->m_aProps.aTitle = newName;
 755
 756 }
 757 // -----------------------------------------------------------------------------
 758 void OContentHelper::notifyDataSourceModified()
 759 {
 760     ::dbaccess::notifyDataSourceModified(m_xParentContainer,sal_True);
 761 }
 762 //........................................................................
 763 }       // namespace dbaccess
 764 //........................................................................
 765