ucb/source/ucp/ext/ucpext_content.cxx

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