ucb/source/ucp/ext/ucpext_content.cxx

   1 /*************************************************************************
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * Copyright 2000, 2010 Oracle and/or its affiliates.
   5  *
   6  * OpenOffice.org - a multi-platform office productivity suite
   7  *
   8  * This file is part of OpenOffice.org.
   9  *
  10  * OpenOffice.org is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License version 3
  12  * only, as published by the Free Software Foundation.
  13  *
  14  * OpenOffice.org is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU Lesser General Public License version 3 for more details
  18  * (a copy is included in the LICENSE file that accompanied this code).
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * version 3 along with OpenOffice.org.  If not, see
  22  * <http://www.openoffice.org/license.html>
  23  * for a copy of the LGPLv3 License.
  24  *
  25 ************************************************************************/
  26
  27 #include "precompiled_ucb.hxx"
  28
  29 #include "ucpext_content.hxx"
  30
  31 #include "ucpext_content.hxx"
  32 #include "ucpext_provider.hxx"
  33 #include "ucpext_resultset.hxx"
  34
  35 /** === begin UNO includes === **/
  36 #include <com/sun/star/beans/PropertyAttribute.hpp>
  37 #include <com/sun/star/beans/XPropertyAccess.hpp>
  38 #include <com/sun/star/lang/IllegalAccessException.hpp>
  39 #include <com/sun/star/sdbc/XRow.hpp>
  40 #include <com/sun/star/ucb/XCommandInfo.hpp>
  41 #include <com/sun/star/ucb/XPersistentPropertySet.hpp>
  42 #include <com/sun/star/io/XOutputStream.hpp>
  43 #include <com/sun/star/io/XActiveDataSink.hpp>
  44 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  45 #include <com/sun/star/ucb/OpenMode.hpp>
  46 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
  47 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
  48 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  49 #include <com/sun/star/ucb/OpenMode.hpp>
  50 #include <com/sun/star/ucb/XDynamicResultSet.hpp>
  51 #include <com/sun/star/lang/IllegalAccessException.hpp>
  52 #include <com/sun/star/deployment/XPackageInformationProvider.hpp>
  53 /** === end UNO includes === **/
  54
  55 #include <ucbhelper/contentidentifier.hxx>
  56 #include <ucbhelper/propertyvalueset.hxx>
  57 #include <ucbhelper/cancelcommandexecution.hxx>
  58 #include <ucbhelper/content.hxx>
  59 #include <tools/diagnose_ex.h>
  60 #include <comphelper/string.hxx>
  61 #include <comphelper/componentcontext.hxx>
  62 #include <rtl/ustrbuf.hxx>
  63 #include <rtl/uri.hxx>
  64
  65 #include <algorithm>
  66
  67 //......................................................................................................................
  68 namespace ucb { namespace ucp { namespace ext
  69 {
  70 //......................................................................................................................
  71
  72     /** === begin UNO using === **/
  73     using ::com::sun::star::uno::Reference;
  74     using ::com::sun::star::uno::XInterface;
  75     using ::com::sun::star::uno::UNO_QUERY;
  76     using ::com::sun::star::uno::UNO_QUERY_THROW;
  77     using ::com::sun::star::uno::UNO_SET_THROW;
  78     using ::com::sun::star::uno::Exception;
  79     using ::com::sun::star::uno::RuntimeException;
  80     using ::com::sun::star::uno::Any;
  81     using ::com::sun::star::uno::makeAny;
  82     using ::com::sun::star::uno::Sequence;
  83     using ::com::sun::star::uno::Type;
  84     using ::com::sun::star::lang::XMultiServiceFactory;
  85     using ::com::sun::star::ucb::XContentIdentifier;
  86     using ::com::sun::star::ucb::IllegalIdentifierException;
  87     using ::com::sun::star::ucb::XContent;
  88     using ::com::sun::star::ucb::XCommandEnvironment;
  89     using ::com::sun::star::ucb::Command;
  90     using ::com::sun::star::ucb::CommandAbortedException;
  91     using ::com::sun::star::beans::Property;
  92     using ::com::sun::star::lang::IllegalArgumentException;
  93     using ::com::sun::star::beans::PropertyValue;
  94     using ::com::sun::star::ucb::OpenCommandArgument2;
  95     using ::com::sun::star::ucb::XDynamicResultSet;
  96     using ::com::sun::star::ucb::UnsupportedOpenModeException;
  97     using ::com::sun::star::io::XOutputStream;
  98     using ::com::sun::star::io::XActiveDataSink;
  99     using ::com::sun::star::io::XInputStream;
 100     using ::com::sun::star::ucb::UnsupportedDataSinkException;
 101     using ::com::sun::star::ucb::UnsupportedCommandException;
 102     using ::com::sun::star::sdbc::XRow;
 103     using ::com::sun::star::beans::XPropertySet;
 104     using ::com::sun::star::beans::PropertyChangeEvent;
 105     using ::com::sun::star::lang::IllegalAccessException;
 106     using ::com::sun::star::ucb::CommandInfo;
 107     using ::com::sun::star::deployment::XPackageInformationProvider;
 108     /** === end UNO using === **/
 109     namespace OpenMode = ::com::sun::star::ucb::OpenMode;
 110     namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
 111
 112     //==================================================================================================================
 113     //= helper
 114     //==================================================================================================================
 115     namespace
 116     {
 117         //--------------------------------------------------------------------------------------------------------------
 118         ::rtl::OUString lcl_compose( const ::rtl::OUString& i_rBaseURL, const ::rtl::OUString& i_rRelativeURL )
 119         {
 120             ENSURE_OR_RETURN( i_rBaseURL.getLength(), "illegal base URL", i_rRelativeURL );
 121
 122             ::rtl::OUStringBuffer aComposer( i_rBaseURL );
 123             if ( i_rBaseURL.getStr()[ i_rBaseURL.getLength() - 1 ] != '/' )
 124                 aComposer.append( sal_Unicode( '/' ) );
 125             aComposer.append( i_rRelativeURL );
 126             return aComposer.makeStringAndClear();
 127         }
 128
 129         //--------------------------------------------------------------------------------------------------------------
 130         struct SelectPropertyName : public ::std::unary_function< Property, ::rtl::OUString >
 131         {
 132             const ::rtl::OUString& operator()( const Property& i_rProperty ) const
 133             {
 134                 return i_rProperty.Name;
 135             }
 136         };
 137     }
 138
 139     //==================================================================================================================
 140     //= Content
 141     //==================================================================================================================
 142     //------------------------------------------------------------------------------------------------------------------
 143     Content::Content( const Reference< XMultiServiceFactory >& i_rORB, ::ucbhelper::ContentProviderImplHelper* i_pProvider,
 144                       const Reference< XContentIdentifier >& i_rIdentifier )
 145         :Content_Base( i_rORB, i_pProvider, i_rIdentifier )
 146         ,m_eExtContentType( E_UNKNOWN )
 147         ,m_aIsFolder()
 148         ,m_aContentType()
 149         ,m_sExtensionId()
 150         ,m_sPathIntoExtension()
 151     {
 152         const ::rtl::OUString sURL( getIdentifier()->getContentIdentifier() );
 153         if ( denotesRootContent( sURL ) )
 154         {
 155             m_eExtContentType = E_ROOT;
 156         }
 157         else
 158         {
 159             const ::rtl::OUString sRelativeURL( sURL.copy( ContentProvider::getRootURL().getLength() ) );
 160             const sal_Int32 nSepPos = sRelativeURL.indexOf( '/' );
 161             if ( ( nSepPos == -1 ) || ( nSepPos == sRelativeURL.getLength() - 1 ) )
 162             {
 163                 m_eExtContentType = E_EXTENSION_ROOT;
 164             }
 165             else
 166             {
 167                 m_eExtContentType = E_EXTENSION_CONTENT;
 168             }
 169         }
 170
 171         if ( m_eExtContentType != E_ROOT )
 172         {
 173             const ::rtl::OUString sRootURL = ContentProvider::getRootURL();
 174             m_sExtensionId = sURL.copy( sRootURL.getLength() );
 175
 176             const sal_Int32 nNextSep = m_sExtensionId.indexOf( '/' );
 177             if ( nNextSep > -1 )
 178             {
 179                 m_sPathIntoExtension = m_sExtensionId.copy( nNextSep + 1 );
 180                 m_sExtensionId = m_sExtensionId.copy( 0, nNextSep );
 181             }
 182             m_sExtensionId = Content::decodeIdentifier( m_sExtensionId );
 183         }
 184     }
 185
 186     //------------------------------------------------------------------------------------------------------------------
 187     Content::~Content()
 188     {
 189     }
 190
 191     //------------------------------------------------------------------------------------------------------------------
 192     ::rtl::OUString SAL_CALL Content::getImplementationName() throw( RuntimeException )
 193     {
 194         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "org.openoffice.comp.ucp.ext.Content" ) );
 195     }
 196
 197     //------------------------------------------------------------------------------------------------------------------
 198     Sequence< ::rtl::OUString > SAL_CALL Content::getSupportedServiceNames() throw( RuntimeException )
 199     {
 200         Sequence< ::rtl::OUString > aServiceNames(2);
 201         aServiceNames[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.Content" ) );
 202         aServiceNames[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.ExtensionContent" ) );
 203         return aServiceNames;
 204     }
 205
 206     //------------------------------------------------------------------------------------------------------------------
 207     ::rtl::OUString SAL_CALL Content::getContentType() throw( RuntimeException )
 208     {
 209         impl_determineContentType();
 210         return *m_aContentType;
 211     }
 212
 213     //------------------------------------------------------------------------------------------------------------------
 214     Any SAL_CALL Content::execute( const Command& aCommand, sal_Int32 /* CommandId */, const Reference< XCommandEnvironment >& i_rEvironment )
 215         throw( Exception, CommandAbortedException, RuntimeException )
 216     {
 217         Any aRet;
 218
 219         if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "getPropertyValues" ) ) )
 220         {
 221             Sequence< Property > Properties;
 222             if ( !( aCommand.Argument >>= Properties ) )
 223             {
 224                 ::ucbhelper::cancelCommandExecution( makeAny( IllegalArgumentException(
 225                     ::rtl::OUString(), *this, -1 ) ),
 226                     i_rEvironment );
 227                 // unreachable
 228             }
 229
 230             aRet <<= getPropertyValues( Properties, i_rEvironment );
 231         }
 232         else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "setPropertyValues" ) ) )
 233         {
 234             Sequence< PropertyValue > aProperties;
 235             if ( !( aCommand.Argument >>= aProperties ) )
 236             {
 237                 ::ucbhelper::cancelCommandExecution( makeAny( IllegalArgumentException(
 238                     ::rtl::OUString(), *this, -1 ) ),
 239                     i_rEvironment );
 240                 // unreachable
 241             }
 242
 243             if ( !aProperties.getLength() )
 244             {
 245                 ::ucbhelper::cancelCommandExecution( makeAny( IllegalArgumentException(
 246                     ::rtl::OUString(), *this, -1 ) ),
 247                     i_rEvironment );
 248                 // unreachable
 249             }
 250
 251             aRet <<= setPropertyValues( aProperties, i_rEvironment );
 252         }
 253         else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "getPropertySetInfo" ) ) )
 254         {
 255             // implemented by base class.
 256             aRet <<= getPropertySetInfo( i_rEvironment );
 257         }
 258         else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "getCommandInfo" ) ) )
 259         {
 260             // implemented by base class.
 261             aRet <<= getCommandInfo( i_rEvironment );
 262         }
 263         else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "open" ) ) )
 264         {
 265             OpenCommandArgument2 aOpenCommand;
 266               if ( !( aCommand.Argument >>= aOpenCommand ) )
 267             {
 268                 ::ucbhelper::cancelCommandExecution( makeAny( IllegalArgumentException(
 269                     ::rtl::OUString(), *this, -1 ) ),
 270                     i_rEvironment );
 271                 // unreachable
 272             }
 273
 274             sal_Bool bOpenFolder =
 275                 ( ( aOpenCommand.Mode == OpenMode::ALL ) ||
 276                   ( aOpenCommand.Mode == OpenMode::FOLDERS ) ||
 277                   ( aOpenCommand.Mode == OpenMode::DOCUMENTS ) );
 278
 279
 280             if ( bOpenFolder && impl_isFolder() )
 281             {
 282                 Reference< XDynamicResultSet > xSet = new ResultSet(
 283                     m_xSMgr, this, aOpenCommand, i_rEvironment );
 284                 aRet <<= xSet;
 285               }
 286
 287             if ( aOpenCommand.Sink.is() )
 288             {
 289                 const ::rtl::OUString sPhysicalContentURL( getPhysicalURL() );
 290                 ::ucbhelper::Content aRequestedContent( sPhysicalContentURL, i_rEvironment );
 291                 aRet = aRequestedContent.executeCommand( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "open" ) ), makeAny( aOpenCommand ) );
 292             }
 293         }
 294
 295         else
 296         {
 297             ::ucbhelper::cancelCommandExecution( makeAny( UnsupportedCommandException(
 298                 ::rtl::OUString(), *this ) ),
 299                 i_rEvironment );
 300             // unreachable
 301         }
 302
 303         return aRet;
 304     }
 305
 306     //------------------------------------------------------------------------------------------------------------------
 307     void SAL_CALL Content::abort( sal_Int32 ) throw( RuntimeException )
 308     {
 309     }
 310
 311     //------------------------------------------------------------------------------------------------------------------
 312     ::rtl::OUString Content::encodeIdentifier( const ::rtl::OUString& i_rIdentifier )
 313     {
 314         return ::rtl::Uri::encode( i_rIdentifier, rtl_UriCharClassRegName, rtl_UriEncodeIgnoreEscapes,
 315             RTL_TEXTENCODING_UTF8 );
 316     }
 317
 318     //------------------------------------------------------------------------------------------------------------------
 319     ::rtl::OUString Content::decodeIdentifier( const ::rtl::OUString& i_rIdentifier )
 320     {
 321         return ::rtl::Uri::decode( i_rIdentifier, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
 322     }
 323
 324     //------------------------------------------------------------------------------------------------------------------
 325     bool Content::denotesRootContent( const ::rtl::OUString& i_rContentIdentifier )
 326     {
 327         const ::rtl::OUString sRootURL( ContentProvider::getRootURL() );
 328         if ( i_rContentIdentifier == sRootURL )
 329             return true;
 330
 331         // the root URL contains only two trailing /, but we also recognize 3 of them as denoting the root URL
 332         if  (   i_rContentIdentifier.match( sRootURL )
 333             &&  ( i_rContentIdentifier.getLength() == sRootURL.getLength() + 1 )
 334             &&  ( i_rContentIdentifier[ i_rContentIdentifier.getLength() - 1 ] == '/' )
 335             )
 336             return true;
 337
 338         return false;
 339     }
 340
 341     //------------------------------------------------------------------------------------------------------------------
 342     ::rtl::OUString Content::getParentURL()
 343     {
 344         const ::rtl::OUString sRootURL( ContentProvider::getRootURL() );
 345
 346         switch ( m_eExtContentType )
 347         {
 348         case E_ROOT:
 349             // don't have a parent
 350             return sRootURL;
 351
 352         case E_EXTENSION_ROOT:
 353             // our parent is the root itself
 354             return sRootURL;
 355
 356         case E_EXTENSION_CONTENT:
 357         {
 358             const ::rtl::OUString sURL = m_xIdentifier->getContentIdentifier();
 359
 360             // cut the root URL
 361             ENSURE_OR_BREAK( sURL.match( sRootURL, 0 ), "illegal URL structure - no root" );
 362             ::rtl::OUString sRelativeURL( sURL.copy( sRootURL.getLength() ) );
 363
 364             // cut the extension ID
 365             const ::rtl::OUString sSeparatedExtensionId( encodeIdentifier( m_sExtensionId ) + ::rtl::OUString( sal_Unicode( '/' ) ) );
 366             ENSURE_OR_BREAK( sRelativeURL.match( sSeparatedExtensionId ), "illegal URL structure - no extension ID" );
 367             sRelativeURL = sRelativeURL.copy( sSeparatedExtensionId.getLength() );
 368
 369             // cut the final slash (if any)
 370             ENSURE_OR_BREAK( sRelativeURL.getLength(), "illegal URL structure - ExtensionContent should have a level below the extension ID" );
 371             if ( sRelativeURL.getStr()[ sRelativeURL.getLength() - 1 ] == '/' )
 372                 sRelativeURL = sRelativeURL.copy( 0, sRelativeURL.getLength() - 1 );
 373
 374             // remove the last segment
 375             const sal_Int32 nLastSep = sRelativeURL.lastIndexOf( '/' );
 376             sRelativeURL = sRelativeURL.copy( 0, nLastSep != -1 ? nLastSep : 0 );
 377
 378             ::rtl::OUStringBuffer aComposer;
 379             aComposer.append( sRootURL );
 380             aComposer.append( sSeparatedExtensionId );
 381             aComposer.append( sRelativeURL );
 382             return aComposer.makeStringAndClear();
 383         }
 384
 385         default:
 386             OSL_ENSURE( false, "Content::getParentURL: unhandled case!" );
 387             break;
 388         }
 389         return ::rtl::OUString();
 390     }
 391
 392     //------------------------------------------------------------------------------------------------------------------
 393     Reference< XRow > Content::getArtificialNodePropertyValues( const Reference< XMultiServiceFactory >& i_rORB,
 394         const Sequence< Property >& i_rProperties, const ::rtl::OUString& i_rTitle )
 395     {
 396         // note: empty sequence means "get values of all supported properties".
 397         ::rtl::Reference< ::ucbhelper::PropertyValueSet > xRow = new ::ucbhelper::PropertyValueSet( i_rORB );
 398
 399         const sal_Int32 nCount = i_rProperties.getLength();
 400         if ( nCount )
 401         {
 402             Reference< XPropertySet > xAdditionalPropSet;
 403
 404             const Property* pProps = i_rProperties.getConstArray();
 405             for ( sal_Int32 n = 0; n < nCount; ++n )
 406             {
 407                 const Property& rProp = pProps[ n ];
 408
 409                 // Process Core properties.
 410                 if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) )
 411                 {
 412                     xRow->appendString ( rProp, ContentProvider::getArtificialNodeContentType() );
 413                 }
 414                 else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) )
 415                 {
 416                     xRow->appendString ( rProp, i_rTitle );
 417                 }
 418                 else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) )
 419                 {
 420                     xRow->appendBoolean( rProp, sal_False );
 421                 }
 422                 else if ( rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) )
 423                 {
 424                     xRow->appendBoolean( rProp, sal_True );
 425                 }
 426                 else
 427                 {
 428                     // append empty entry.
 429                     xRow->appendVoid( rProp );
 430                 }
 431             }
 432         }
 433         else
 434         {
 435             // Append all Core Properties.
 436             xRow->appendString ( Property( ::rtl::OUString::createFromAscii( "ContentType" ),
 437                           -1,
 438                           getCppuType( static_cast< const ::rtl::OUString * >( 0 ) ),
 439                           PropertyAttribute::BOUND | PropertyAttribute::READONLY ),
 440                 ContentProvider::getArtificialNodeContentType() );
 441             xRow->appendString ( Property( ::rtl::OUString::createFromAscii( "Title" ),
 442                           -1,
 443                           getCppuType( static_cast< const ::rtl::OUString * >( 0 ) ),
 444                           PropertyAttribute::BOUND | PropertyAttribute::READONLY ),
 445                 i_rTitle );
 446             xRow->appendBoolean( Property( ::rtl::OUString::createFromAscii( "IsDocument" ),
 447                           -1,
 448                           getCppuBooleanType(),
 449                           PropertyAttribute::BOUND | PropertyAttribute::READONLY ),
 450                 sal_False );
 451             xRow->appendBoolean( Property( ::rtl::OUString::createFromAscii( "IsFolder" ),
 452                           -1,
 453                           getCppuBooleanType(),
 454                           PropertyAttribute::BOUND | PropertyAttribute::READONLY ),
 455                 sal_True );
 456         }
 457
 458         return Reference< XRow >( xRow.get() );
 459     }
 460
 461     //------------------------------------------------------------------------------------------------------------------
 462     ::rtl::OUString Content::getPhysicalURL() const
 463     {
 464         ENSURE_OR_RETURN( m_eExtContentType != E_ROOT, "illegal call", ::rtl::OUString() );
 465
 466         // create an ucb::XContent for the physical file within the deployed extension
 467         const ::comphelper::ComponentContext aContext( m_xSMgr );
 468         const Reference< XPackageInformationProvider > xPackageInfo(
 469             aContext.getSingleton( "com.sun.star.deployment.PackageInformationProvider" ), UNO_QUERY_THROW );
 470         const ::rtl::OUString sPackageLocation( xPackageInfo->getPackageLocation( m_sExtensionId ) );
 471
 472         if ( m_sPathIntoExtension.getLength() == 0 )
 473             return sPackageLocation;
 474         return lcl_compose( sPackageLocation, m_sPathIntoExtension );
 475     }
 476
 477     //------------------------------------------------------------------------------------------------------------------
 478     Reference< XRow > Content::getPropertyValues( const Sequence< Property >& i_rProperties, const Reference< XCommandEnvironment >& i_rEnv )
 479     {
 480         ::osl::Guard< ::osl::Mutex > aGuard( m_aMutex );
 481
 482         switch ( m_eExtContentType )
 483         {
 484         case E_ROOT:
 485             return getArtificialNodePropertyValues( m_xSMgr, i_rProperties, ContentProvider::getRootURL() );
 486         case E_EXTENSION_ROOT:
 487             return getArtificialNodePropertyValues( m_xSMgr, i_rProperties, m_sExtensionId );
 488         case E_EXTENSION_CONTENT:
 489         {
 490             const ::rtl::OUString sPhysicalContentURL( getPhysicalURL() );
 491             ::ucbhelper::Content aRequestedContent( sPhysicalContentURL, i_rEnv );
 492
 493             // translate the property request
 494             Sequence< ::rtl::OUString > aPropertyNames( i_rProperties.getLength() );
 495             ::std::transform(
 496                 i_rProperties.getConstArray(),
 497                 i_rProperties.getConstArray() + i_rProperties.getLength(),
 498                 aPropertyNames.getArray(),
 499                 SelectPropertyName()
 500             );
 501             const Sequence< Any > aPropertyValues = aRequestedContent.getPropertyValues( aPropertyNames );
 502             const ::rtl::Reference< ::ucbhelper::PropertyValueSet > xValueRow = new ::ucbhelper::PropertyValueSet( m_xSMgr );
 503             sal_Int32 i=0;
 504             for (   const Any* value = aPropertyValues.getConstArray();
 505                     value != aPropertyValues.getConstArray() + aPropertyValues.getLength();
 506                     ++value, ++i
 507                 )
 508             {
 509                 xValueRow->appendObject( aPropertyNames[i], *value );
 510             }
 511             return xValueRow.get();
 512         }
 513
 514         default:
 515             OSL_ENSURE( false, "Content::getPropertyValues: unhandled case!" );
 516             break;
 517         }
 518
 519         OSL_ENSURE( false, "Content::getPropertyValues: unreachable!" );
 520         return NULL;
 521     }
 522
 523     //------------------------------------------------------------------------------------------------------------------
 524     Sequence< Any > Content::setPropertyValues( const Sequence< PropertyValue >& i_rValues, const Reference< XCommandEnvironment >& /* xEnv */)
 525     {
 526         ::osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
 527
 528         Sequence< Any > aRet( i_rValues.getLength() );
 529         Sequence< PropertyChangeEvent > aChanges( i_rValues.getLength() );
 530
 531         PropertyChangeEvent aEvent;
 532         aEvent.Source         = static_cast< cppu::OWeakObject * >( this );
 533         aEvent.Further        = sal_False;
 534         aEvent.PropertyHandle = -1;
 535
 536         const PropertyValue* pValues = i_rValues.getConstArray();
 537         const sal_Int32 nCount = i_rValues.getLength();
 538
 539         for ( sal_Int32 n = 0; n < nCount; ++n, ++pValues )
 540         {
 541             // all our properties are read-only ...
 542             aRet[ n ] <<= IllegalAccessException( ::rtl::OUString::createFromAscii( "property is read-only." ), *this );
 543         }
 544
 545         return aRet;
 546     }
 547
 548     //------------------------------------------------------------------------------------------------------------------
 549     Sequence< CommandInfo > Content::getCommands( const Reference< XCommandEnvironment > & /*xEnv*/ )
 550     {
 551         sal_uInt32 nCommandCount = 5;
 552         static const CommandInfo aCommandInfoTable[] =
 553         {
 554             ///////////////////////////////////////////////////////////////
 555             // Mandatory commands
 556             ///////////////////////////////////////////////////////////////
 557             CommandInfo(
 558                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getCommandInfo" ) ),
 559                 -1,
 560                 getCppuVoidType()
 561             ),
 562             CommandInfo(
 563                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertySetInfo" ) ),
 564                 -1,
 565                 getCppuVoidType()
 566             ),
 567             CommandInfo(
 568                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertyValues" ) ),
 569                 -1,
 570                 getCppuType(
 571                     static_cast< Sequence< Property > * >( 0 ) )
 572             ),
 573             CommandInfo(
 574                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "setPropertyValues" ) ),
 575                 -1,
 576                 getCppuType(
 577                     static_cast< Sequence< PropertyValue > * >( 0 ) )
 578             )
 579             ///////////////////////////////////////////////////////////////
 580             // Optional standard commands
 581             ///////////////////////////////////////////////////////////////
 582             , CommandInfo(
 583                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "open" ) ),
 584                 -1,
 585                 getCppuType( static_cast< OpenCommandArgument2 * >( 0 ) )
 586             )
 587         };
 588
 589         return Sequence< CommandInfo >( aCommandInfoTable, nCommandCount );
 590     }
 591
 592     //------------------------------------------------------------------------------------------------------------------
 593     Sequence< Property > Content::getProperties( const Reference< XCommandEnvironment > & /*xEnv*/ )
 594     {
 595         static Property aProperties[] =
 596         {
 597             Property(
 598                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ContentType" ) ),
 599                 -1,
 600                 getCppuType( static_cast< const ::rtl::OUString * >( 0 ) ),
 601                 PropertyAttribute::BOUND | PropertyAttribute::READONLY
 602             ),
 603             Property(
 604                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsDocument" ) ),
 605                 -1,
 606                 getCppuBooleanType(),
 607                 PropertyAttribute::BOUND | PropertyAttribute::READONLY
 608             ),
 609             Property(
 610                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsFolder" ) ),
 611                 -1,
 612                 getCppuBooleanType(),
 613                 PropertyAttribute::BOUND | PropertyAttribute::READONLY
 614             ),
 615             Property(
 616                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ),
 617                 -1,
 618                 getCppuType( static_cast< const ::rtl::OUString * >( 0 ) ),
 619                 PropertyAttribute::BOUND | PropertyAttribute::READONLY
 620             )
 621         };
 622         return Sequence< Property >( aProperties, sizeof( aProperties ) / sizeof( aProperties[0] ) );
 623     }
 624
 625     //------------------------------------------------------------------------------------------------------------------
 626     bool Content::impl_isFolder()
 627     {
 628         if ( !!m_aIsFolder )
 629             return *m_aIsFolder;
 630
 631         bool bIsFolder = false;
 632         try
 633         {
 634             Sequence< Property > aProps(1);
 635             aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsFolder" ) );
 636             Reference< XRow > xRow( getPropertyValues( aProps, NULL ), UNO_SET_THROW );
 637             bIsFolder = xRow->getBoolean(1);
 638         }
 639         catch( const Exception& )
 640         {
 641             DBG_UNHANDLED_EXCEPTION();
 642         }
 643         m_aIsFolder.reset( bIsFolder );
 644         return *m_aIsFolder;
 645     }
 646
 647     //------------------------------------------------------------------------------------------------------------------
 648     void Content::impl_determineContentType()
 649     {
 650         if ( !!m_aContentType )
 651             return;
 652
 653         m_aContentType.reset( ContentProvider::getArtificialNodeContentType() );
 654         if ( m_eExtContentType == E_EXTENSION_CONTENT )
 655         {
 656             try
 657             {
 658                 Sequence< Property > aProps(1);
 659                 aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ContentType" ) );
 660                 Reference< XRow > xRow( getPropertyValues( aProps, NULL ), UNO_SET_THROW );
 661                 m_aContentType.reset( xRow->getString(1) );
 662             }
 663             catch( const Exception& )
 664             {
 665                 DBG_UNHANDLED_EXCEPTION();
 666             }
 667         }
 668     }
 669
 670 //......................................................................................................................
 671 } } }   // namespace ucp::ext
 672 //......................................................................................................................