LCOV - code coverage report
Current view: top level - ucb/source/ucp/file - bc.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 312 510 61.2 %
Date: 2015-06-13 12:38:46 Functions: 31 49 63.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <rtl/uri.hxx>
      21             : #include <rtl/ustrbuf.hxx>
      22             : #include <osl/file.hxx>
      23             : 
      24             : #include "osl/diagnose.h"
      25             : #include <com/sun/star/ucb/OpenMode.hpp>
      26             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      27             : #include <com/sun/star/ucb/XProgressHandler.hpp>
      28             : #include <com/sun/star/task/XInteractionHandler.hpp>
      29             : #include <com/sun/star/io/XActiveDataStreamer.hpp>
      30             : #include <com/sun/star/io/XOutputStream.hpp>
      31             : #include <com/sun/star/ucb/NumberedSortingInfo.hpp>
      32             : #include <com/sun/star/io/XActiveDataSink.hpp>
      33             : #include <com/sun/star/beans/PropertyChangeEvent.hpp>
      34             : #include <com/sun/star/beans/PropertySetInfoChange.hpp>
      35             : #include <com/sun/star/ucb/ContentAction.hpp>
      36             : #include <com/sun/star/ucb/NameClash.hpp>
      37             : #include <cppuhelper/supportsservice.hxx>
      38             : #include "filglob.hxx"
      39             : #include "filid.hxx"
      40             : #include "filrow.hxx"
      41             : #include "bc.hxx"
      42             : #include "prov.hxx"
      43             : #include "filerror.hxx"
      44             : #include "filinsreq.hxx"
      45             : 
      46             : using namespace fileaccess;
      47             : using namespace com::sun::star;
      48             : using namespace com::sun::star::uno;
      49             : using namespace com::sun::star::ucb;
      50             : 
      51             : #if OSL_DEBUG_LEVEL > 0
      52             : #define THROW_WHERE SAL_WHERE
      53             : #else
      54             : #define THROW_WHERE ""
      55             : #endif
      56             : 
      57             : typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString>
      58             :     PropertyListeners_impl;
      59             : 
      60       19620 : class fileaccess::PropertyListeners
      61             :     : public PropertyListeners_impl
      62             : {
      63             : public:
      64       19620 :     explicit PropertyListeners( ::osl::Mutex& aMutex )
      65       19620 :         : PropertyListeners_impl( aMutex )
      66             :     {
      67       19620 :     }
      68             : };
      69             : 
      70             : 
      71             : /****************************************************************************************/
      72             : /*                                                                                      */
      73             : /*                    BaseContent                                                       */
      74             : /*                                                                                      */
      75             : /****************************************************************************************/
      76             : 
      77             : 
      78             : // Private Constructor for just inserted Contents
      79             : 
      80        3774 : BaseContent::BaseContent( shell* pMyShell,
      81             :                           const OUString& parentName,
      82             :                           bool bFolder )
      83             :     : m_pMyShell( pMyShell ),
      84             :       m_xContentIdentifier( 0 ),
      85             :       m_aUncPath( parentName ),
      86             :       m_bFolder( bFolder ),
      87             :       m_nState( JustInserted ),
      88             :       m_pDisposeEventListeners( 0 ),
      89             :       m_pContentEventListeners( 0 ),
      90             :       m_pPropertySetInfoChangeListeners( 0 ),
      91        3774 :       m_pPropertyListener( 0 )
      92             : {
      93        3774 :     m_pMyShell->m_pProvider->acquire();
      94             :     // No registering, since we have no name
      95        3774 : }
      96             : 
      97             : 
      98             : 
      99             : // Constructor for full featured Contents
     100             : 
     101      120925 : BaseContent::BaseContent( shell* pMyShell,
     102             :                           const Reference< XContentIdentifier >& xContentIdentifier,
     103             :                           const OUString& aUncPath )
     104             :     : m_pMyShell( pMyShell ),
     105             :       m_xContentIdentifier( xContentIdentifier ),
     106             :       m_aUncPath( aUncPath ),
     107             :       m_bFolder( false ),
     108             :       m_nState( FullFeatured ),
     109             :       m_pDisposeEventListeners( 0 ),
     110             :       m_pContentEventListeners( 0 ),
     111             :       m_pPropertySetInfoChangeListeners( 0 ),
     112      120925 :       m_pPropertyListener( 0 )
     113             : {
     114      120925 :     m_pMyShell->m_pProvider->acquire();
     115      120925 :     m_pMyShell->registerNotifier( m_aUncPath,this );
     116      120925 :     m_pMyShell->insertDefaultProperties( m_aUncPath );
     117      120925 : }
     118             : 
     119             : 
     120      373737 : BaseContent::~BaseContent( )
     121             : {
     122      124579 :     if( ( m_nState & FullFeatured ) || ( m_nState & Deleted ) )
     123             :     {
     124      123599 :         m_pMyShell->deregisterNotifier( m_aUncPath,this );
     125             :     }
     126      124579 :     m_pMyShell->m_pProvider->release();
     127             : 
     128      124579 :     delete m_pDisposeEventListeners;
     129      124579 :     delete m_pContentEventListeners;
     130      124579 :     delete m_pPropertyListener;
     131      124579 :     delete m_pPropertySetInfoChangeListeners;
     132      249158 : }
     133             : 
     134             : 
     135             : 
     136             : // XInterface
     137             : 
     138             : 
     139             : void SAL_CALL
     140     1643270 : BaseContent::acquire()
     141             :     throw()
     142             : {
     143     1643270 :     OWeakObject::acquire();
     144     1643270 : }
     145             : 
     146             : 
     147             : void SAL_CALL
     148     1643078 : BaseContent::release()
     149             :     throw()
     150             : {
     151     1643078 :     OWeakObject::release();
     152     1643078 : }
     153             : 
     154             : 
     155             : Any SAL_CALL
     156      155931 : BaseContent::queryInterface( const Type& rType )
     157             :     throw( RuntimeException, std::exception )
     158             : {
     159             :     Any aRet = cppu::queryInterface( rType,
     160             :                                      (static_cast< lang::XComponent* >(this)),
     161             :                                      (static_cast< lang::XTypeProvider* >(this)),
     162             :                                      (static_cast< lang::XServiceInfo* >(this)),
     163             :                                      (static_cast< XCommandProcessor* >(this)),
     164             :                                      (static_cast< container::XChild* >(this)),
     165             :                                      (static_cast< beans::XPropertiesChangeNotifier* >(this)),
     166             :                                      (static_cast< beans::XPropertyContainer* >(this)),
     167             :                                      (static_cast< XContentCreator* >(this)),
     168             :                                      (static_cast< beans::XPropertySetInfoChangeNotifier* >(this)),
     169      155931 :                                      (static_cast< XContent* >(this)) );
     170      155931 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     171             : }
     172             : 
     173             : 
     174             : 
     175             : 
     176             : 
     177             : // XComponent
     178             : 
     179             : 
     180             : void SAL_CALL
     181           0 : BaseContent::addEventListener( const Reference< lang::XEventListener >& Listener )
     182             :     throw( RuntimeException, std::exception )
     183             : {
     184           0 :     osl::MutexGuard aGuard( m_aMutex );
     185             : 
     186           0 :     if ( ! m_pDisposeEventListeners )
     187             :         m_pDisposeEventListeners =
     188           0 :             new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
     189             : 
     190           0 :     m_pDisposeEventListeners->addInterface( Listener );
     191           0 : }
     192             : 
     193             : 
     194             : void SAL_CALL
     195           0 : BaseContent::removeEventListener( const Reference< lang::XEventListener >& Listener )
     196             :     throw( RuntimeException, std::exception )
     197             : {
     198           0 :     osl::MutexGuard aGuard( m_aMutex );
     199             : 
     200           0 :     if ( m_pDisposeEventListeners )
     201           0 :         m_pDisposeEventListeners->removeInterface( Listener );
     202           0 : }
     203             : 
     204             : 
     205             : void SAL_CALL
     206           0 : BaseContent::dispose()
     207             :     throw( RuntimeException, std::exception )
     208             : {
     209           0 :     lang::EventObject aEvt;
     210             :     cppu::OInterfaceContainerHelper* pDisposeEventListeners;
     211             :     cppu::OInterfaceContainerHelper* pContentEventListeners;
     212             :     cppu::OInterfaceContainerHelper* pPropertySetInfoChangeListeners;
     213             :     PropertyListeners* pPropertyListener;
     214             : 
     215             :     {
     216           0 :         osl::MutexGuard aGuard( m_aMutex );
     217           0 :         aEvt.Source = static_cast< XContent* >( this );
     218             : 
     219             : 
     220             :         pDisposeEventListeners =
     221           0 :             m_pDisposeEventListeners, m_pDisposeEventListeners = 0;
     222             : 
     223             :         pContentEventListeners =
     224           0 :             m_pContentEventListeners, m_pContentEventListeners = 0;
     225             : 
     226             :         pPropertySetInfoChangeListeners =
     227             :             m_pPropertySetInfoChangeListeners,
     228           0 :             m_pPropertySetInfoChangeListeners = 0;
     229             : 
     230             :         pPropertyListener =
     231           0 :             m_pPropertyListener, m_pPropertyListener = 0;
     232             :     }
     233             : 
     234           0 :     if ( pDisposeEventListeners && pDisposeEventListeners->getLength() )
     235           0 :         pDisposeEventListeners->disposeAndClear( aEvt );
     236             : 
     237           0 :     if ( pContentEventListeners && pContentEventListeners->getLength() )
     238           0 :         pContentEventListeners->disposeAndClear( aEvt );
     239             : 
     240           0 :     if( pPropertyListener )
     241           0 :         pPropertyListener->disposeAndClear( aEvt );
     242             : 
     243           0 :     if( pPropertySetInfoChangeListeners )
     244           0 :         pPropertySetInfoChangeListeners->disposeAndClear( aEvt );
     245             : 
     246           0 :     delete pDisposeEventListeners;
     247           0 :     delete pContentEventListeners;
     248           0 :     delete pPropertyListener;
     249           0 :     delete pPropertySetInfoChangeListeners;
     250           0 : }
     251             : 
     252             : //  XServiceInfo
     253             : OUString SAL_CALL
     254           0 : BaseContent::getImplementationName()
     255             :     throw( RuntimeException, std::exception)
     256             : {
     257           0 :     return OUString("com.sun.star.comp.ucb.FileContent");
     258             : }
     259             : 
     260             : sal_Bool SAL_CALL
     261           0 : BaseContent::supportsService( const OUString& ServiceName )
     262             :     throw( RuntimeException, std::exception)
     263             : {
     264           0 :     return cppu::supportsService( this, ServiceName );
     265             : }
     266             : 
     267             : Sequence< OUString > SAL_CALL
     268           0 : BaseContent::getSupportedServiceNames()
     269             :     throw( RuntimeException, std::exception )
     270             : {
     271           0 :     Sequence< OUString > ret( 1 );
     272           0 :     ret[0] = "com.sun.star.ucb.FileContent";
     273           0 :     return ret;
     274             : }
     275             : 
     276             : //  XTypeProvider
     277           0 : XTYPEPROVIDER_IMPL_10( BaseContent,
     278             :                        lang::XComponent,
     279             :                        lang::XTypeProvider,
     280             :                        lang::XServiceInfo,
     281             :                        XCommandProcessor,
     282             :                        XContentCreator,
     283             :                        XContent,
     284             :                        container::XChild,
     285             :                        beans::XPropertiesChangeNotifier,
     286             :                        beans::XPropertyContainer,
     287             :                        beans::XPropertySetInfoChangeNotifier )
     288             : 
     289             : 
     290             : 
     291             : //  XCommandProcessor
     292             : 
     293             : 
     294             : sal_Int32 SAL_CALL
     295      195041 : BaseContent::createCommandIdentifier()
     296             :     throw( RuntimeException, std::exception )
     297             : {
     298      195041 :     return m_pMyShell->getCommandId();
     299             : }
     300             : 
     301             : 
     302             : void SAL_CALL
     303           0 : BaseContent::abort( sal_Int32 CommandId )
     304             :     throw( RuntimeException, std::exception )
     305             : {
     306           0 :     m_pMyShell->abort( CommandId );
     307           0 : }
     308             : 
     309             : 
     310             : Any SAL_CALL
     311      195041 : BaseContent::execute( const Command& aCommand,
     312             :                       sal_Int32 CommandId,
     313             :                       const Reference< XCommandEnvironment >& Environment )
     314             :     throw( Exception,
     315             :            CommandAbortedException,
     316             :            RuntimeException, std::exception )
     317             : {
     318      195041 :     if( ! CommandId )
     319             :         // A Command with commandid zero cannot be aborted
     320      195041 :         CommandId = createCommandIdentifier();
     321             : 
     322             :     m_pMyShell->startTask( CommandId,
     323      195041 :                            Environment );
     324             : 
     325      195041 :     Any aAny;
     326             : 
     327      195041 :     if (aCommand.Name == "getPropertySetInfo")  // No exceptions
     328             :     {
     329       17668 :         aAny <<= getPropertySetInfo( CommandId );
     330             :     }
     331      177373 :     else if (aCommand.Name == "getCommandInfo")  // no exceptions
     332             :     {
     333          10 :         aAny <<= getCommandInfo();
     334             :     }
     335      177363 :     else if ( aCommand.Name == "setPropertyValues" )
     336             :     {
     337        4625 :         Sequence< beans::PropertyValue > sPropertyValues;
     338             : 
     339        4625 :         if( ! ( aCommand.Argument >>= sPropertyValues ) )
     340             :             m_pMyShell->installError( CommandId,
     341           0 :                                       TASKHANDLING_WRONG_SETPROPERTYVALUES_ARGUMENT );
     342             :         else
     343        4625 :             aAny <<= setPropertyValues( CommandId,sPropertyValues );  // calls endTask by itself
     344             :     }
     345      172738 :     else if ( aCommand.Name == "getPropertyValues" )
     346             :     {
     347       63891 :         Sequence< beans::Property > ListOfRequestedProperties;
     348             : 
     349       63891 :         if( ! ( aCommand.Argument >>= ListOfRequestedProperties ) )
     350             :             m_pMyShell->installError( CommandId,
     351           0 :                                       TASKHANDLING_WRONG_GETPROPERTYVALUES_ARGUMENT );
     352             :         else
     353      127782 :             aAny <<= getPropertyValues( CommandId,
     354      127782 :                                         ListOfRequestedProperties );
     355             :     }
     356      108847 :     else if ( aCommand.Name == "open" )
     357             :     {
     358       89574 :         OpenCommandArgument2 aOpenArgument;
     359       89574 :         if( ! ( aCommand.Argument >>= aOpenArgument ) )
     360             :             m_pMyShell->installError( CommandId,
     361           0 :                                       TASKHANDLING_WRONG_OPEN_ARGUMENT );
     362             :         else
     363             :         {
     364       89574 :             Reference< XDynamicResultSet > result = open( CommandId,aOpenArgument );
     365       89574 :             if( result.is() )
     366       55829 :                 aAny <<= result;
     367       89574 :         }
     368             :     }
     369       19273 :     else if ( aCommand.Name == "delete" )
     370             :     {
     371        2621 :         if( ! aCommand.Argument.has< sal_Bool >() )
     372             :             m_pMyShell->installError( CommandId,
     373           0 :                                       TASKHANDLING_WRONG_DELETE_ARGUMENT );
     374             :         else
     375        2621 :             deleteContent( CommandId );
     376             :     }
     377       16652 :     else if ( aCommand.Name == "transfer" )
     378             :     {
     379        3571 :         TransferInfo aTransferInfo;
     380        3571 :         if( ! ( aCommand.Argument >>= aTransferInfo ) )
     381             :             m_pMyShell->installError( CommandId,
     382           0 :                                       TASKHANDLING_WRONG_TRANSFER_ARGUMENT );
     383             :         else
     384        3571 :             transfer( CommandId, aTransferInfo );
     385             :     }
     386       13081 :     else if ( aCommand.Name == "insert" )
     387             :     {
     388        9250 :         InsertCommandArgument aInsertArgument;
     389        9250 :         if( ! ( aCommand.Argument >>= aInsertArgument ) )
     390             :             m_pMyShell->installError( CommandId,
     391           0 :                                       TASKHANDLING_WRONG_INSERT_ARGUMENT );
     392             :         else
     393        9250 :             insert( CommandId,aInsertArgument );
     394             :     }
     395        3831 :     else if ( aCommand.Name == "getCasePreservingURL" )
     396             :     {
     397          57 :         Sequence< beans::Property > seq(1);
     398         171 :         seq[0] = beans::Property(
     399             :             OUString("CasePreservingURL"),
     400             :             -1,
     401          57 :             cppu::UnoType<sal_Bool>::get(),
     402          57 :             0 );
     403         114 :         Reference< sdbc::XRow > xRow = getPropertyValues( CommandId,seq );
     404         114 :         OUString CasePreservingURL = xRow->getString(1);
     405          57 :         if(!xRow->wasNull())
     406         114 :             aAny <<= CasePreservingURL;
     407             :     }
     408        3774 :     else if ( aCommand.Name == "createNewContent" )
     409             :     {
     410        3774 :         ucb::ContentInfo aArg;
     411        3774 :         if ( !( aCommand.Argument >>= aArg ) )
     412             :             m_pMyShell->installError( CommandId,
     413           0 :                                       TASKHANDLING_WRONG_CREATENEWCONTENT_ARGUMENT );
     414             :         else
     415        3774 :             aAny <<= createNewContent( aArg );
     416             :     }
     417             :     else
     418             :         m_pMyShell->installError( CommandId,
     419           0 :                                   TASKHANDLER_UNSUPPORTED_COMMAND );
     420             : 
     421             : 
     422             :     // This is the only function allowed to throw an exception
     423      195041 :     endTask( CommandId );
     424             : 
     425      171027 :     return aAny;
     426             : }
     427             : 
     428             : 
     429             : 
     430             : void SAL_CALL
     431       19620 : BaseContent::addPropertiesChangeListener(
     432             :     const Sequence< OUString >& PropertyNames,
     433             :     const Reference< beans::XPropertiesChangeListener >& Listener )
     434             :     throw( RuntimeException, std::exception )
     435             : {
     436       19620 :     if( ! Listener.is() )
     437       19620 :         return;
     438             : 
     439       19620 :     osl::MutexGuard aGuard( m_aMutex );
     440             : 
     441       19620 :     if( ! m_pPropertyListener )
     442       19620 :         m_pPropertyListener = new PropertyListeners( m_aEventListenerMutex );
     443             : 
     444             : 
     445       19620 :     if( PropertyNames.getLength() == 0 )
     446       19620 :         m_pPropertyListener->addInterface( OUString(),Listener );
     447             :     else
     448             :     {
     449           0 :         Reference< beans::XPropertySetInfo > xProp = m_pMyShell->info_p( m_aUncPath );
     450           0 :         for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
     451           0 :             if( xProp->hasPropertyByName( PropertyNames[i] ) )
     452           0 :                 m_pPropertyListener->addInterface( PropertyNames[i],Listener );
     453       19620 :     }
     454             : }
     455             : 
     456             : 
     457             : void SAL_CALL
     458       19620 : BaseContent::removePropertiesChangeListener( const Sequence< OUString >& PropertyNames,
     459             :                                              const Reference< beans::XPropertiesChangeListener >& Listener )
     460             :     throw( RuntimeException, std::exception )
     461             : {
     462       19620 :     if( ! Listener.is() )
     463           0 :         return;
     464             : 
     465       19620 :     osl::MutexGuard aGuard( m_aMutex );
     466             : 
     467       19620 :     if( ! m_pPropertyListener )
     468           0 :         return;
     469             : 
     470       19620 :     for( sal_Int32 i = 0; i < PropertyNames.getLength(); ++i )
     471           0 :         m_pPropertyListener->removeInterface( PropertyNames[i],Listener );
     472             : 
     473       19620 :     m_pPropertyListener->removeInterface( OUString(), Listener );
     474             : }
     475             : 
     476             : 
     477             : 
     478             : // XContent
     479             : 
     480             : 
     481             : Reference< ucb::XContentIdentifier > SAL_CALL
     482       55896 : BaseContent::getIdentifier()
     483             :     throw( RuntimeException, std::exception )
     484             : {
     485       55896 :     return m_xContentIdentifier;
     486             : }
     487             : 
     488             : 
     489             : OUString SAL_CALL
     490           0 : BaseContent::getContentType()
     491             :     throw( RuntimeException, std::exception )
     492             : {
     493           0 :     if( !( m_nState & Deleted ) )
     494             :     {
     495           0 :         if( m_nState & JustInserted )
     496             :         {
     497           0 :             if ( m_bFolder )
     498           0 :                 return m_pMyShell->FolderContentType;
     499             :             else
     500           0 :                 return m_pMyShell->FileContentType;
     501             :         }
     502             :         else
     503             :         {
     504             :             try
     505             :             {
     506             :                 // Who am I ?
     507           0 :                 Sequence< beans::Property > seq(1);
     508           0 :                 seq[0] = beans::Property( OUString("IsDocument"),
     509             :                                           -1,
     510           0 :                                           cppu::UnoType<sal_Bool>::get(),
     511           0 :                                           0 );
     512           0 :                 Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
     513           0 :                 bool IsDocument = xRow->getBoolean( 1 );
     514             : 
     515           0 :                 if ( !xRow->wasNull() )
     516             :                 {
     517           0 :                     if ( IsDocument )
     518           0 :                         return m_pMyShell->FileContentType;
     519             :                     else
     520           0 :                         return m_pMyShell->FolderContentType;
     521             :                 }
     522             :                 else
     523             :                 {
     524             :                     OSL_FAIL( "BaseContent::getContentType - Property value was null!" );
     525           0 :                 }
     526             :             }
     527           0 :             catch (const sdbc::SQLException&)
     528             :             {
     529             :                 OSL_FAIL( "BaseContent::getContentType - Caught SQLException!" );
     530             :             }
     531             :         }
     532             :     }
     533             : 
     534           0 :     return OUString();
     535             : }
     536             : 
     537             : 
     538             : 
     539             : void SAL_CALL
     540      142867 : BaseContent::addContentEventListener(
     541             :     const Reference< XContentEventListener >& Listener )
     542             :     throw( RuntimeException, std::exception )
     543             : {
     544      142867 :     osl::MutexGuard aGuard( m_aMutex );
     545             : 
     546      142867 :     if ( ! m_pContentEventListeners )
     547             :         m_pContentEventListeners =
     548      113509 :             new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
     549             : 
     550             : 
     551      142867 :     m_pContentEventListeners->addInterface( Listener );
     552      142867 : }
     553             : 
     554             : 
     555             : void SAL_CALL
     556      142750 : BaseContent::removeContentEventListener(
     557             :     const Reference< XContentEventListener >& Listener )
     558             :     throw( RuntimeException, std::exception )
     559             : {
     560      142750 :     osl::MutexGuard aGuard( m_aMutex );
     561             : 
     562      142750 :     if ( m_pContentEventListeners )
     563      142750 :         m_pContentEventListeners->removeInterface( Listener );
     564      142750 : }
     565             : 
     566             : 
     567             : 
     568             : 
     569             : // XPropertyContainer
     570             : 
     571             : 
     572             : 
     573             : void SAL_CALL
     574           0 : BaseContent::addProperty(
     575             :     const OUString& Name,
     576             :     sal_Int16 Attributes,
     577             :     const Any& DefaultValue )
     578             :     throw( beans::PropertyExistException,
     579             :            beans::IllegalTypeException,
     580             :            lang::IllegalArgumentException,
     581             :            RuntimeException, std::exception)
     582             : {
     583           0 :     if( ( m_nState & JustInserted ) || ( m_nState & Deleted ) || Name.isEmpty() )
     584             :     {
     585           0 :         throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 0 );
     586             :     }
     587             : 
     588           0 :     m_pMyShell->associate( m_aUncPath,Name,DefaultValue,Attributes );
     589           0 : }
     590             : 
     591             : 
     592             : void SAL_CALL
     593           0 : BaseContent::removeProperty(
     594             :     const OUString& Name )
     595             :     throw( beans::UnknownPropertyException,
     596             :            beans::NotRemoveableException,
     597             :            RuntimeException, std::exception)
     598             : {
     599             : 
     600           0 :     if( m_nState & Deleted )
     601           0 :         throw beans::UnknownPropertyException( THROW_WHERE );
     602             : 
     603           0 :     m_pMyShell->deassociate( m_aUncPath, Name );
     604           0 : }
     605             : 
     606             : 
     607             : // XContentCreator
     608             : 
     609             : 
     610             : Sequence< ContentInfo > SAL_CALL
     611           0 : BaseContent::queryCreatableContentsInfo(
     612             :     void )
     613             :     throw( RuntimeException, std::exception )
     614             : {
     615           0 :     return m_pMyShell->queryCreatableContentsInfo();
     616             : }
     617             : 
     618             : 
     619             : Reference< XContent > SAL_CALL
     620        3774 : BaseContent::createNewContent(
     621             :     const ContentInfo& Info )
     622             :     throw( RuntimeException, std::exception )
     623             : {
     624             :     // Check type.
     625        3774 :     if ( Info.Type.isEmpty() )
     626           0 :         return Reference< XContent >();
     627             : 
     628        3774 :     bool bFolder = Info.Type == m_pMyShell->FolderContentType;
     629        3774 :     if ( !bFolder )
     630             :     {
     631           6 :         if ( Info.Type != m_pMyShell->FileContentType )
     632             :         {
     633             :             // Neither folder nor file to create!
     634           0 :             return Reference< XContent >();
     635             :         }
     636             :     }
     637             : 
     638             :     // Who am I ?
     639        3774 :     bool IsDocument = false;
     640             : 
     641             :     try
     642             :     {
     643        3774 :         Sequence< beans::Property > seq(1);
     644       11322 :         seq[0] = beans::Property( OUString("IsDocument"),
     645             :                                   -1,
     646        3774 :                                   cppu::UnoType<sal_Bool>::get(),
     647        3774 :                                   0 );
     648        7548 :         Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
     649        3774 :         IsDocument = xRow->getBoolean( 1 );
     650             : 
     651        3774 :         if ( xRow->wasNull() )
     652             :         {
     653           0 :             IsDocument = false;
     654             : //              OSL_FAIL( //                          "BaseContent::createNewContent - Property value was null!" );
     655             : //              return Reference< XContent >();
     656        3774 :         }
     657             :     }
     658           0 :     catch (const sdbc::SQLException&)
     659             :     {
     660             :         OSL_FAIL( "BaseContent::createNewContent - Caught SQLException!" );
     661           0 :         return Reference< XContent >();
     662             :     }
     663             : 
     664        3774 :     OUString dstUncPath;
     665             : 
     666        3774 :     if( IsDocument )
     667             :     {
     668             :         // KSO: Why is a document a XContentCreator? This is quite unusual.
     669           0 :         dstUncPath = getParentName( m_aUncPath );
     670             :     }
     671             :     else
     672        3774 :         dstUncPath = m_aUncPath;
     673             : 
     674        3774 :     BaseContent* p = new BaseContent( m_pMyShell, dstUncPath, bFolder );
     675        3774 :     return Reference< XContent >( p );
     676             : }
     677             : 
     678             : 
     679             : 
     680             : // XPropertySetInfoChangeNotifier
     681             : 
     682             : 
     683             : 
     684             : void SAL_CALL
     685           0 : BaseContent::addPropertySetInfoChangeListener(
     686             :     const Reference< beans::XPropertySetInfoChangeListener >& Listener )
     687             :     throw( RuntimeException, std::exception )
     688             : {
     689           0 :     osl::MutexGuard aGuard( m_aMutex );
     690           0 :     if( ! m_pPropertySetInfoChangeListeners )
     691           0 :         m_pPropertySetInfoChangeListeners = new cppu::OInterfaceContainerHelper( m_aEventListenerMutex );
     692             : 
     693           0 :     m_pPropertySetInfoChangeListeners->addInterface( Listener );
     694           0 : }
     695             : 
     696             : 
     697             : void SAL_CALL
     698           0 : BaseContent::removePropertySetInfoChangeListener(
     699             :     const Reference< beans::XPropertySetInfoChangeListener >& Listener )
     700             :     throw( RuntimeException, std::exception )
     701             : {
     702           0 :     osl::MutexGuard aGuard( m_aMutex );
     703             : 
     704           0 :     if( m_pPropertySetInfoChangeListeners )
     705           0 :         m_pPropertySetInfoChangeListeners->removeInterface( Listener );
     706           0 : }
     707             : 
     708             : 
     709             : 
     710             : // XChild
     711             : 
     712             : 
     713             : Reference< XInterface > SAL_CALL
     714           4 : BaseContent::getParent(
     715             :     void )
     716             :     throw( RuntimeException, std::exception )
     717             : {
     718           4 :     OUString ParentUnq = getParentName( m_aUncPath );
     719           8 :     OUString ParentUrl;
     720             : 
     721             : 
     722           4 :     bool err = fileaccess::shell::getUrlFromUnq( ParentUnq, ParentUrl );
     723           4 :     if( err )
     724           0 :         return Reference< XInterface >( 0 );
     725             : 
     726           4 :     FileContentIdentifier* p = new FileContentIdentifier( ParentUnq );
     727           8 :     Reference< XContentIdentifier > Identifier( p );
     728             : 
     729             :     try
     730             :     {
     731           4 :         return Reference<XInterface>( m_pMyShell->m_pProvider->queryContent( Identifier ), UNO_QUERY );
     732             :     }
     733           0 :     catch (const IllegalIdentifierException&)
     734             :     {
     735           0 :         return Reference< XInterface >();
     736           4 :     }
     737             : }
     738             : 
     739             : 
     740             : void SAL_CALL
     741           0 : BaseContent::setParent(
     742             :     const Reference< XInterface >& )
     743             :     throw( lang::NoSupportException,
     744             :            RuntimeException, std::exception)
     745             : {
     746           0 :     throw lang::NoSupportException( THROW_WHERE );
     747             : }
     748             : 
     749             : 
     750             : 
     751             : // Private Methods
     752             : 
     753             : 
     754             : 
     755             : Reference< XCommandInfo > SAL_CALL
     756          10 : BaseContent::getCommandInfo()
     757             :     throw( RuntimeException )
     758             : {
     759          10 :     if( m_nState & Deleted )
     760           0 :         return Reference< XCommandInfo >();
     761             : 
     762          10 :     return m_pMyShell->info_c();
     763             : }
     764             : 
     765             : 
     766             : Reference< beans::XPropertySetInfo > SAL_CALL
     767       17668 : BaseContent::getPropertySetInfo(
     768             :     sal_Int32 )
     769             :     throw( RuntimeException )
     770             : {
     771       17668 :     if( m_nState & Deleted )
     772           0 :         return Reference< beans::XPropertySetInfo >();
     773             : 
     774       17668 :     return m_pMyShell->info_p( m_aUncPath );
     775             : }
     776             : 
     777             : 
     778             : 
     779             : 
     780             : Reference< sdbc::XRow > SAL_CALL
     781       75065 : BaseContent::getPropertyValues(
     782             :     sal_Int32 nMyCommandIdentifier,
     783             :     const Sequence< beans::Property >& PropertySet )
     784             :     throw( RuntimeException )
     785             : {
     786       75065 :     sal_Int32 nProps = PropertySet.getLength();
     787       75065 :     if ( !nProps )
     788           0 :         return Reference< sdbc::XRow >();
     789             : 
     790       75065 :     if( m_nState & Deleted )
     791             :     {
     792           0 :         Sequence< Any > aValues( nProps );
     793           0 :         return Reference< sdbc::XRow >( new XRow_impl( m_pMyShell, aValues ) );
     794             :     }
     795             : 
     796       75065 :     if( m_nState & JustInserted )
     797             :     {
     798        3774 :         Sequence< Any > aValues( nProps );
     799        3774 :         Any* pValues = aValues.getArray();
     800             : 
     801        3774 :         const beans::Property* pProps = PropertySet.getConstArray();
     802             : 
     803        7548 :         for ( sal_Int32 n = 0; n < nProps; ++n )
     804             :         {
     805        3774 :             const beans::Property& rProp = pProps[ n ];
     806        3774 :             Any& rValue = pValues[ n ];
     807             : 
     808        3774 :             if ( rProp.Name == "ContentType" )
     809             :             {
     810           0 :                 rValue <<= m_bFolder ? m_pMyShell->FolderContentType
     811           0 :                     : m_pMyShell->FileContentType;
     812             :             }
     813        3774 :             else if ( rProp.Name == "IsFolder" )
     814             :             {
     815           0 :                 rValue <<= m_bFolder;
     816             :             }
     817        3774 :             else if ( rProp.Name == "IsDocument" )
     818             :             {
     819        3774 :                 rValue <<= !m_bFolder;
     820             :             }
     821             :         }
     822             : 
     823             :         return Reference< sdbc::XRow >(
     824        3774 :             new XRow_impl( m_pMyShell, aValues ) );
     825             :     }
     826             : 
     827             :     return m_pMyShell->getv( nMyCommandIdentifier,
     828             :                              m_aUncPath,
     829       71291 :                              PropertySet );
     830             : }
     831             : 
     832             : 
     833             : Sequence< Any > SAL_CALL
     834        4625 : BaseContent::setPropertyValues(
     835             :     sal_Int32 nMyCommandIdentifier,
     836             :     const Sequence< beans::PropertyValue >& Values )
     837             :     throw()
     838             : {
     839        4625 :     if( m_nState & Deleted )
     840             :     {   //  To do
     841           0 :         return Sequence< Any >( Values.getLength() );
     842             :     }
     843             : 
     844        4625 :     const OUString Title("Title");
     845             : 
     846             :     // Special handling for files which have to be inserted
     847        4625 :     if( m_nState & JustInserted )
     848             :     {
     849        7618 :         for( sal_Int32 i = 0; i < Values.getLength(); ++i )
     850             :         {
     851        3844 :             if( Values[i].Name == Title )
     852             :             {
     853        3774 :                 OUString NewTitle;
     854        3774 :                 if( Values[i].Value >>= NewTitle )
     855             :                 {
     856        3774 :                     if ( m_nState & NameForInsertionSet )
     857             :                     {
     858             :                         // User wants to set another Title before "insert".
     859             :                         // m_aUncPath contains previous own URI.
     860             : 
     861           0 :                         sal_Int32 nLastSlash = m_aUncPath.lastIndexOf( '/' );
     862           0 :                         bool bTrailingSlash = false;
     863           0 :                         if ( nLastSlash == m_aUncPath.getLength() - 1 )
     864             :                         {
     865           0 :                             bTrailingSlash = true;
     866             :                             nLastSlash
     867           0 :                                 = m_aUncPath.lastIndexOf( '/', nLastSlash );
     868             :                         }
     869             : 
     870             :                         OSL_ENSURE( nLastSlash != -1,
     871             :                                     "BaseContent::setPropertyValues: "
     872             :                                     "Invalid URL!" );
     873             : 
     874             :                         OUStringBuffer aBuf(
     875           0 :                             m_aUncPath.copy( 0, nLastSlash + 1 ) );
     876             : 
     877           0 :                         if ( !NewTitle.isEmpty() )
     878             :                         {
     879           0 :                             aBuf.append( NewTitle );
     880           0 :                             if ( bTrailingSlash )
     881           0 :                                 aBuf.append( '/' );
     882             :                         }
     883             :                         else
     884             :                         {
     885           0 :                             m_nState &= ~NameForInsertionSet;
     886             :                         }
     887             : 
     888           0 :                         m_aUncPath = aBuf.makeStringAndClear();
     889             :                     }
     890             :                     else
     891             :                     {
     892        3774 :                         if ( !NewTitle.isEmpty() )
     893             :                         {
     894             :                             // Initial Title before "insert".
     895             :                             // m_aUncPath contains parent's URI.
     896             : 
     897        3774 :                             if( !m_aUncPath.endsWith( "/" ) )
     898        3774 :                                 m_aUncPath += "/";
     899             : 
     900        7548 :                             m_aUncPath += rtl::Uri::encode( NewTitle,
     901             :                                                             rtl_UriCharClassPchar,
     902             :                                                             rtl_UriEncodeIgnoreEscapes,
     903        3774 :                                                             RTL_TEXTENCODING_UTF8 );
     904        3774 :                             m_nState |= NameForInsertionSet;
     905             :                         }
     906             :                     }
     907        3774 :                 }
     908             :             }
     909             :         }
     910             : 
     911        3774 :         return Sequence< Any >( Values.getLength() );
     912             :     }
     913             :     else
     914             :     {
     915             :         Sequence< Any > ret = m_pMyShell->setv( m_aUncPath,  // Does not handle Title
     916         851 :                                                 Values );
     917             : 
     918             :         // Special handling Title: Setting Title is equivalent to a renaming of the underlying file
     919        3404 :         for( sal_Int32 i = 0; i < Values.getLength(); ++i )
     920             :         {
     921         851 :             if( Values[i].Name != Title )
     922         851 :                 continue;                  // handled by setv
     923             : 
     924           0 :             OUString NewTitle;
     925           0 :             if( !( Values[i].Value >>= NewTitle ) )
     926             :             {
     927           0 :                 ret[i] <<= beans::IllegalTypeException( THROW_WHERE );
     928           0 :                 break;
     929             :             }
     930           0 :             else if( NewTitle.isEmpty() )
     931             :             {
     932           0 :                 ret[i] <<= lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 0 );
     933           0 :                 break;
     934             :             }
     935             : 
     936             : 
     937           0 :             OUString aDstName = getParentName( m_aUncPath );
     938           0 :             if( !aDstName.endsWith("/") )
     939           0 :                 aDstName += "/";
     940             : 
     941           0 :             aDstName += rtl::Uri::encode( NewTitle,
     942             :                                           rtl_UriCharClassPchar,
     943             :                                           rtl_UriEncodeIgnoreEscapes,
     944           0 :                                           RTL_TEXTENCODING_UTF8 );
     945             : 
     946             :             m_pMyShell->move( nMyCommandIdentifier,     // move notifies the children also;
     947             :                               m_aUncPath,
     948             :                               aDstName,
     949           0 :                               NameClash::KEEP );
     950             : 
     951             :             try
     952             :             {
     953           0 :                 endTask( nMyCommandIdentifier );
     954             :             }
     955           0 :             catch(const Exception& e)
     956             :             {
     957           0 :                 ret[i] <<= e;
     958             :             }
     959             : 
     960             :             // NameChanges come back through a ContentEvent
     961           0 :             break; // only handling Title
     962           0 :         } // end for
     963             : 
     964         851 :         return ret;
     965        4625 :     }
     966             : }
     967             : 
     968             : 
     969             : 
     970             : Reference< XDynamicResultSet > SAL_CALL
     971       89574 : BaseContent::open(
     972             :     sal_Int32 nMyCommandIdentifier,
     973             :     const OpenCommandArgument2& aCommandArgument )
     974             :     throw()
     975             : {
     976       89574 :     Reference< XDynamicResultSet > retValue( 0 );
     977             : 
     978       89574 :     if( ( m_nState & Deleted ) )
     979             :     {
     980             :         m_pMyShell->installError( nMyCommandIdentifier,
     981           0 :                                   TASKHANDLING_DELETED_STATE_IN_OPEN_COMMAND );
     982             :     }
     983       89574 :     else if( m_nState & JustInserted )
     984             :     {
     985             :         m_pMyShell->installError( nMyCommandIdentifier,
     986           0 :                                   TASKHANDLING_INSERTED_STATE_IN_OPEN_COMMAND );
     987             :     }
     988             :     else
     989             :     {
     990      148635 :         if( aCommandArgument.Mode == OpenMode::DOCUMENT ||
     991       59061 :             aCommandArgument.Mode == OpenMode::DOCUMENT_SHARE_DENY_NONE )
     992             : 
     993             :         {
     994       33669 :             Reference< io::XOutputStream > outputStream( aCommandArgument.Sink,UNO_QUERY );
     995       33669 :             if( outputStream.is() )
     996             :             {
     997             :                 m_pMyShell->page( nMyCommandIdentifier,
     998             :                                   m_aUncPath,
     999           0 :                                   outputStream );
    1000             :             }
    1001             : 
    1002       33669 :             bool bLock = ( aCommandArgument.Mode != OpenMode::DOCUMENT_SHARE_DENY_NONE );
    1003             : 
    1004       67338 :             Reference< io::XActiveDataSink > activeDataSink( aCommandArgument.Sink,UNO_QUERY );
    1005       33669 :             if( activeDataSink.is() )
    1006             :             {
    1007        9689 :                 activeDataSink->setInputStream( m_pMyShell->open( nMyCommandIdentifier,
    1008             :                                                                   m_aUncPath,
    1009        9689 :                                                                   bLock ) );
    1010             :             }
    1011             : 
    1012       67338 :             Reference< io::XActiveDataStreamer > activeDataStreamer( aCommandArgument.Sink,UNO_QUERY );
    1013       33669 :             if( activeDataStreamer.is() )
    1014             :             {
    1015       23980 :                 activeDataStreamer->setStream( m_pMyShell->open_rw( nMyCommandIdentifier,
    1016             :                                                                     m_aUncPath,
    1017       23980 :                                                                     bLock ) );
    1018       33669 :             }
    1019             :         }
    1020       57257 :         else if ( aCommandArgument.Mode == OpenMode::ALL        ||
    1021        1814 :                   aCommandArgument.Mode == OpenMode::FOLDERS    ||
    1022         462 :                   aCommandArgument.Mode == OpenMode::DOCUMENTS )
    1023             :         {
    1024      111810 :             retValue = m_pMyShell->ls( nMyCommandIdentifier,
    1025             :                                        m_aUncPath,
    1026             :                                        aCommandArgument.Mode,
    1027             :                                        aCommandArgument.Properties,
    1028      111810 :                                        aCommandArgument.SortingInfo );
    1029             :         }
    1030             : //          else if(  aCommandArgument.Mode ==
    1031             : //                    OpenMode::DOCUMENT_SHARE_DENY_NONE  ||
    1032             : //                    aCommandArgument.Mode ==
    1033             : //                    OpenMode::DOCUMENT_SHARE_DENY_WRITE )
    1034             : //              m_pMyShell->installError( nMyCommandIdentifier,
    1035             : //                                        TASKHANDLING_UNSUPPORTED_OPEN_MODE,
    1036             : //                                        aCommandArgument.Mode);
    1037             :         else
    1038             :             m_pMyShell->installError( nMyCommandIdentifier,
    1039             :                                       TASKHANDLING_UNSUPPORTED_OPEN_MODE,
    1040           0 :                                       aCommandArgument.Mode);
    1041             :     }
    1042             : 
    1043       89574 :     return retValue;
    1044             : }
    1045             : 
    1046             : 
    1047             : 
    1048             : void SAL_CALL
    1049        2621 : BaseContent::deleteContent( sal_Int32 nMyCommandIdentifier )
    1050             :     throw()
    1051             : {
    1052        2621 :     if( m_nState & Deleted )
    1053        2621 :         return;
    1054             : 
    1055        2621 :     if( m_pMyShell->remove( nMyCommandIdentifier,m_aUncPath ) )
    1056             :     {
    1057        2348 :         osl::MutexGuard aGuard( m_aMutex );
    1058        2348 :         m_nState |= Deleted;
    1059             :     }
    1060             : }
    1061             : 
    1062             : 
    1063             : 
    1064             : void SAL_CALL
    1065        3571 : BaseContent::transfer( sal_Int32 nMyCommandIdentifier,
    1066             :                        const TransferInfo& aTransferInfo )
    1067             :     throw()
    1068             : {
    1069        3571 :     if( m_nState & Deleted )
    1070           2 :         return;
    1071             : 
    1072        3571 :     if( !aTransferInfo.SourceURL.startsWith( "file:" ) )
    1073             :     {
    1074             :         m_pMyShell->installError( nMyCommandIdentifier,
    1075           2 :                                   TASKHANDLING_TRANSFER_INVALIDSCHEME );
    1076           2 :         return;
    1077             :     }
    1078             : 
    1079        3569 :     OUString srcUnc;
    1080        3569 :     if( fileaccess::shell::getUnqFromUrl( aTransferInfo.SourceURL,srcUnc ) )
    1081             :     {
    1082             :         m_pMyShell->installError( nMyCommandIdentifier,
    1083           0 :                                   TASKHANDLING_TRANSFER_INVALIDURL );
    1084           0 :         return;
    1085             :     }
    1086             : 
    1087        7138 :     OUString srcUncPath = srcUnc;
    1088             : 
    1089             :     // Determine the new title !
    1090        7138 :     OUString NewTitle;
    1091        3569 :     if( !aTransferInfo.NewTitle.isEmpty() )
    1092        7138 :         NewTitle = rtl::Uri::encode( aTransferInfo.NewTitle,
    1093             :                                      rtl_UriCharClassPchar,
    1094             :                                      rtl_UriEncodeIgnoreEscapes,
    1095        3569 :                                      RTL_TEXTENCODING_UTF8 );
    1096             :     else
    1097           0 :         NewTitle = srcUncPath.copy( 1 + srcUncPath.lastIndexOf( '/' ) );
    1098             : 
    1099             :     // Is destination a document or a folder ?
    1100        7138 :     Sequence< beans::Property > seq(1);
    1101       10707 :     seq[0] = beans::Property( OUString("IsDocument"),
    1102             :                               -1,
    1103        3569 :                               cppu::UnoType<sal_Bool>::get(),
    1104        3569 :                               0 );
    1105        7138 :     Reference< sdbc::XRow > xRow = getPropertyValues( nMyCommandIdentifier,seq );
    1106        3569 :     bool IsDocument = xRow->getBoolean( 1 );
    1107        3569 :     if( xRow->wasNull() )
    1108             :     {   // Destination file type could not be determined
    1109             :         m_pMyShell->installError( nMyCommandIdentifier,
    1110           0 :                                   TASKHANDLING_TRANSFER_DESTFILETYPE );
    1111           0 :         return;
    1112             :     }
    1113             : 
    1114        7138 :     OUString dstUncPath;
    1115        3569 :     if( IsDocument )
    1116             :     {   // as sibling
    1117           0 :         sal_Int32 lastSlash = m_aUncPath.lastIndexOf( '/' );
    1118           0 :         dstUncPath = m_aUncPath.copy(0,lastSlash );
    1119             :     }
    1120             :     else
    1121             :         // as child
    1122        3569 :         dstUncPath = m_aUncPath;
    1123             : 
    1124        3569 :     dstUncPath += "/" + NewTitle;
    1125             : 
    1126        3569 :     sal_Int32 NameClash = aTransferInfo.NameClash;
    1127             : 
    1128        3569 :     if( aTransferInfo.MoveData )
    1129           3 :         m_pMyShell->move( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
    1130             :     else
    1131        7135 :         m_pMyShell->copy( nMyCommandIdentifier,srcUncPath,dstUncPath,NameClash );
    1132             : }
    1133             : 
    1134             : 
    1135             : 
    1136             : 
    1137        9250 : void SAL_CALL BaseContent::insert( sal_Int32 nMyCommandIdentifier,
    1138             :                                    const InsertCommandArgument& aInsertArgument )
    1139             :     throw()
    1140             : {
    1141        9250 :     if( m_nState & FullFeatured )
    1142             :     {
    1143             :         m_pMyShell->write( nMyCommandIdentifier,
    1144             :                            m_aUncPath,
    1145             :                            aInsertArgument.ReplaceExisting,
    1146        5476 :                            aInsertArgument.Data );
    1147        5476 :         return;
    1148             :     }
    1149             : 
    1150        3774 :     if( ! ( m_nState & JustInserted ) )
    1151             :     {
    1152             :         m_pMyShell->installError( nMyCommandIdentifier,
    1153           0 :                                   TASKHANDLING_NOFRESHINSERT_IN_INSERT_COMMAND );
    1154           0 :         return;
    1155             :     }
    1156             : 
    1157             :     // Inserts the content, which has the flag m_bIsFresh
    1158             : 
    1159        3774 :     if( ! (m_nState & NameForInsertionSet) )
    1160             :     {
    1161             :         m_pMyShell->installError( nMyCommandIdentifier,
    1162           0 :                                   TASKHANDLING_NONAMESET_INSERT_COMMAND );
    1163           0 :         return;
    1164             :     }
    1165             : 
    1166             :     // Inserting a document or a file?
    1167        3774 :     bool bDocument = false;
    1168             : 
    1169        3774 :     Sequence< beans::Property > seq(1);
    1170       11322 :     seq[0] = beans::Property( OUString("IsDocument"),
    1171             :                               -1,
    1172        3774 :                               cppu::UnoType<sal_Bool>::get(),
    1173        3774 :                               0 );
    1174             : 
    1175        6568 :     Reference< sdbc::XRow > xRow = getPropertyValues( -1,seq );
    1176             : 
    1177        3774 :     bool contentTypeSet = true;  // is set to false, if contentType not set
    1178             :     try
    1179             :     {
    1180        3774 :         bDocument = xRow->getBoolean( 1 );
    1181        3774 :         if( xRow->wasNull() )
    1182           0 :             contentTypeSet = false;
    1183             : 
    1184             :     }
    1185           0 :     catch (const sdbc::SQLException&)
    1186             :     {
    1187             :         OSL_FAIL( "BaseContent::insert - Caught SQLException!" );
    1188           0 :         contentTypeSet = false;
    1189             :     }
    1190             : 
    1191        3774 :     if( ! contentTypeSet )
    1192             :     {
    1193             :         m_pMyShell->installError( nMyCommandIdentifier,
    1194           0 :                                   TASKHANDLING_NOCONTENTTYPE_INSERT_COMMAND );
    1195           0 :         return;
    1196             :     }
    1197             : 
    1198             : 
    1199        3774 :     bool success = false;
    1200        3774 :     if( bDocument )
    1201             :         success = m_pMyShell->mkfil( nMyCommandIdentifier,
    1202             :                                      m_aUncPath,
    1203             :                                      aInsertArgument.ReplaceExisting,
    1204           6 :                                      aInsertArgument.Data );
    1205             :     else
    1206             :     {
    1207        7536 :         while( ! success )
    1208             :         {
    1209             :             success = m_pMyShell->mkdir( nMyCommandIdentifier,
    1210             :                                          m_aUncPath,
    1211        3768 :                                          aInsertArgument.ReplaceExisting );
    1212        3768 :             if( success )
    1213        6556 :                 break;
    1214             : 
    1215             :             XInteractionRequestImpl *aRequestImpl =
    1216             :                 new XInteractionRequestImpl(
    1217             :                     rtl::Uri::decode(
    1218             :                         getTitle(m_aUncPath),
    1219             :                         rtl_UriDecodeWithCharset,
    1220             :                         RTL_TEXTENCODING_UTF8),
    1221             :                     static_cast<cppu::OWeakObject*>(this),
    1222         980 :                     m_pMyShell,nMyCommandIdentifier);
    1223         980 :             uno::Reference< task::XInteractionRequest > aReq( aRequestImpl );
    1224             : 
    1225         980 :             m_pMyShell->handleTask( nMyCommandIdentifier,aReq );
    1226        3920 :             if(  aRequestImpl->aborted() ||
    1227        3920 :                  aRequestImpl->newName().isEmpty() )
    1228             :                 // means aborting
    1229         980 :                 break;
    1230             : 
    1231             :             // determine new uncpath
    1232           0 :             m_pMyShell->clearError( nMyCommandIdentifier );
    1233           0 :             m_aUncPath = getParentName( m_aUncPath );
    1234           0 :             if( !m_aUncPath.endsWith( "/" ) )
    1235           0 :                 m_aUncPath += "/";
    1236             : 
    1237           0 :             m_aUncPath += rtl::Uri::encode( aRequestImpl->newName(),
    1238             :                                             rtl_UriCharClassPchar,
    1239             :                                             rtl_UriEncodeIgnoreEscapes,
    1240           0 :                                             RTL_TEXTENCODING_UTF8 );
    1241           0 :         }
    1242             :     }
    1243             : 
    1244        3774 :     if ( ! success )
    1245         980 :         return;
    1246             : 
    1247        2794 :     FileContentIdentifier* p = new FileContentIdentifier( m_aUncPath );
    1248        2794 :     m_xContentIdentifier = Reference< XContentIdentifier >( p );
    1249             : 
    1250        2794 :     m_pMyShell->registerNotifier( m_aUncPath,this );
    1251        2794 :     m_pMyShell->insertDefaultProperties( m_aUncPath );
    1252             : 
    1253        5588 :     osl::MutexGuard aGuard( m_aMutex );
    1254        5588 :     m_nState = FullFeatured;
    1255             : }
    1256             : 
    1257             : 
    1258             : 
    1259      195041 : void SAL_CALL BaseContent::endTask( sal_Int32 CommandId )
    1260             : {
    1261             :     // This is the only function allowed to throw an exception
    1262      195041 :     m_pMyShell->endTask( CommandId,m_aUncPath,this );
    1263      171027 : }
    1264             : 
    1265             : 
    1266             : 
    1267             : ContentEventNotifier*
    1268        2351 : BaseContent::cDEL()
    1269             : {
    1270        2351 :     osl::MutexGuard aGuard( m_aMutex );
    1271             : 
    1272        2351 :     m_nState |= Deleted;
    1273             : 
    1274             :     ContentEventNotifier* p;
    1275        2351 :     if( m_pContentEventListeners )
    1276             :         p = new ContentEventNotifier( m_pMyShell,
    1277             :                                       this,
    1278             :                                       m_xContentIdentifier,
    1279        2351 :                                       m_pContentEventListeners->getElements() );
    1280             :     else
    1281           0 :         p = 0;
    1282             : 
    1283        2351 :     return p;
    1284             : }
    1285             : 
    1286             : 
    1287             : ContentEventNotifier*
    1288           1 : BaseContent::cEXC( const OUString& aNewName )
    1289             : {
    1290           1 :     osl::MutexGuard aGuard( m_aMutex );
    1291             : 
    1292           2 :     Reference< XContentIdentifier > xOldRef = m_xContentIdentifier;
    1293           1 :     m_aUncPath = aNewName;
    1294           1 :     FileContentIdentifier* pp = new FileContentIdentifier( aNewName );
    1295           1 :     m_xContentIdentifier = Reference< XContentIdentifier >( pp );
    1296             : 
    1297           1 :     ContentEventNotifier* p = 0;
    1298           1 :     if( m_pContentEventListeners )
    1299             :         p = new ContentEventNotifier( m_pMyShell,
    1300             :                                       this,
    1301             :                                       m_xContentIdentifier,
    1302             :                                       xOldRef,
    1303           1 :                                       m_pContentEventListeners->getElements() );
    1304             : 
    1305           2 :     return p;
    1306             : }
    1307             : 
    1308             : 
    1309             : ContentEventNotifier*
    1310       11128 : BaseContent::cCEL()
    1311             : {
    1312       11128 :     osl::MutexGuard aGuard( m_aMutex );
    1313       11128 :     ContentEventNotifier* p = 0;
    1314       11128 :     if( m_pContentEventListeners )
    1315             :         p = new ContentEventNotifier( m_pMyShell,
    1316             :                                       this,
    1317             :                                       m_xContentIdentifier,
    1318        7553 :                                       m_pContentEventListeners->getElements() );
    1319             : 
    1320       11128 :     return p;
    1321             : }
    1322             : 
    1323             : PropertySetInfoChangeNotifier*
    1324           0 : BaseContent::cPSL()
    1325             : {
    1326           0 :     osl::MutexGuard aGuard( m_aMutex );
    1327           0 :     PropertySetInfoChangeNotifier* p = 0;
    1328           0 :     if( m_pPropertySetInfoChangeListeners  )
    1329             :         p = new PropertySetInfoChangeNotifier( this,
    1330             :                                                m_xContentIdentifier,
    1331           0 :                                                m_pPropertySetInfoChangeListeners->getElements() );
    1332             : 
    1333           0 :     return p;
    1334             : }
    1335             : 
    1336             : 
    1337             : 
    1338             : PropertyChangeNotifier*
    1339           5 : BaseContent::cPCL()
    1340             : {
    1341           5 :     osl::MutexGuard aGuard( m_aMutex );
    1342             : 
    1343           5 :     if (!m_pPropertyListener)
    1344           5 :         return NULL;
    1345             : 
    1346           0 :     Sequence< OUString > seqNames = m_pPropertyListener->getContainedTypes();
    1347             : 
    1348           0 :     PropertyChangeNotifier* p = 0;
    1349             : 
    1350           0 :     sal_Int32 length = seqNames.getLength();
    1351             : 
    1352           0 :     if( length )
    1353             :     {
    1354           0 :         ListenerMap* listener = new ListenerMap();
    1355           0 :         for( sal_Int32 i = 0; i < length; ++i )
    1356             :         {
    1357           0 :             cppu::OInterfaceContainerHelper* pContainer = m_pPropertyListener->getContainer(seqNames[i]);
    1358           0 :             if (!pContainer)
    1359           0 :                 continue;
    1360           0 :             (*listener)[seqNames[i]] = pContainer->getElements();
    1361             :         }
    1362             : 
    1363             :         p = new PropertyChangeNotifier( this,
    1364             :                                         m_xContentIdentifier,
    1365           0 :                                         listener );
    1366             :     }
    1367             : 
    1368           5 :     return p;
    1369             : }
    1370             : 
    1371             : 
    1372           0 : OUString BaseContent::getKey()
    1373             : {
    1374           0 :     return m_aUncPath;
    1375             : }
    1376             : 
    1377             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11