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