ucb/source/ucp/file/filtask.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: filtask.cxx,v $
  10  * $Revision: 1.15 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_ucb.hxx"
  33 #include "filtask.hxx"
  34 #include "filglob.hxx"
  35
  36 /*********************************************************************************/
  37 /*                                                                               */
  38 /*                                 TaskHandling                                  */
  39 /*                                                                               */
  40 /*********************************************************************************/
  41
  42
  43 using namespace fileaccess;
  44 using namespace com::sun::star;
  45 using namespace com::sun::star::uno;
  46 using namespace com::sun::star::ucb;
  47
  48
  49
  50 TaskManager::TaskManager()
  51     : m_nCommandId( 0 )
  52 {
  53 }
  54
  55
  56
  57 TaskManager::~TaskManager()
  58 {
  59 }
  60
  61
  62
  63 void SAL_CALL
  64 TaskManager::startTask(
  65     sal_Int32 CommandId,
  66     const uno::Reference< XCommandEnvironment >& xCommandEnv )
  67     throw( DuplicateCommandIdentifierException )
  68 {
  69     osl::MutexGuard aGuard( m_aMutex );
  70     TaskMap::iterator it = m_aTaskMap.find( CommandId );
  71     if( it != m_aTaskMap.end() )
  72     {
  73         throw DuplicateCommandIdentifierException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
  74     }
  75     m_aTaskMap[ CommandId ] = TaskHandling( xCommandEnv );
  76 }
  77
  78
  79
  80 void SAL_CALL
  81 TaskManager::endTask( sal_Int32 CommandId,
  82                       const rtl::OUString& aUncPath,
  83                       BaseContent* pContent)
  84 {
  85     osl::MutexGuard aGuard( m_aMutex );
  86     TaskMap::iterator it = m_aTaskMap.find( CommandId );
  87     if( it == m_aTaskMap.end() )
  88         return;
  89
  90     sal_Int32 ErrorCode = it->second.getInstalledError();
  91     sal_Int32 MinorCode = it->second.getMinorErrorCode();
  92     bool isHandled = it->second.isHandled();
  93
  94     Reference< XCommandEnvironment > xComEnv = it->second.getCommandEnvironment();
  95
  96     m_aTaskMap.erase( it );
  97
  98     if( ErrorCode != TASKHANDLER_NO_ERROR )
  99         throw_handler(
 100             ErrorCode,
 101             MinorCode,
 102             xComEnv,
 103             aUncPath,
 104             pContent,
 105             isHandled);
 106 }
 107
 108
 109
 110 void SAL_CALL
 111 TaskManager::abort( sal_Int32 CommandId )
 112 {
 113     if( CommandId )
 114     {
 115         osl::MutexGuard aGuard( m_aMutex );
 116         TaskMap::iterator it = m_aTaskMap.find( CommandId );
 117         if( it == m_aTaskMap.end() )
 118             return;
 119         else
 120             it->second.abort();
 121     }
 122 }
 123
 124
 125 bool SAL_CALL TaskManager::isAborted( sal_Int32 CommandId )
 126 {
 127     osl::MutexGuard aGuard( m_aMutex );
 128     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 129     if( it == m_aTaskMap.end() || it->second.isAborted() )
 130         return false;
 131     else
 132         return true;
 133 }
 134
 135
 136 void SAL_CALL TaskManager::clearError( sal_Int32 CommandId )
 137 {
 138     osl::MutexGuard aGuard( m_aMutex );
 139     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 140     if( it != m_aTaskMap.end() )
 141         it->second.clearError();
 142 }
 143
 144
 145 void SAL_CALL TaskManager::retrieveError( sal_Int32 CommandId,
 146                                           sal_Int32 &ErrorCode,
 147                                           sal_Int32 &minorCode)
 148 {
 149     osl::MutexGuard aGuard( m_aMutex );
 150     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 151     if( it != m_aTaskMap.end() )
 152     {
 153         ErrorCode = it->second.getInstalledError();
 154         minorCode = it->second. getMinorErrorCode();
 155     }
 156 }
 157
 158
 159
 160 void SAL_CALL TaskManager::installError( sal_Int32 CommandId,
 161                                          sal_Int32 ErrorCode,
 162                                          sal_Int32 MinorCode )
 163 {
 164     osl::MutexGuard aGuard( m_aMutex );
 165     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 166     if( it != m_aTaskMap.end() )
 167         it->second.installError( ErrorCode,MinorCode );
 168 }
 169
 170
 171
 172 sal_Int32 SAL_CALL
 173 TaskManager::getCommandId( void )
 174 {
 175     osl::MutexGuard aGuard( m_aMutex );
 176     return ++m_nCommandId;
 177 }
 178
 179
 180
 181 uno::Reference< task::XInteractionHandler > SAL_CALL
 182 TaskManager::getInteractionHandler( sal_Int32 CommandId )
 183 {
 184     osl::MutexGuard aGuard( m_aMutex );
 185     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 186     if( it == m_aTaskMap.end() )
 187         return uno::Reference< task::XInteractionHandler >( 0 );
 188     else
 189         return it->second.getInteractionHandler();
 190 }
 191
 192
 193
 194 uno::Reference< XProgressHandler > SAL_CALL
 195 TaskManager::getProgressHandler( sal_Int32 CommandId )
 196 {
 197     osl::MutexGuard aGuard( m_aMutex );
 198     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 199     if( it == m_aTaskMap.end() )
 200         return uno::Reference< XProgressHandler >( 0 );
 201     else
 202         return it->second.getProgressHandler();
 203 }
 204
 205
 206 uno::Reference< XCommandEnvironment > SAL_CALL
 207 TaskManager::getCommandEnvironment( sal_Int32 CommandId )
 208 {
 209     osl::MutexGuard aGuard( m_aMutex );
 210     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 211     if( it == m_aTaskMap.end() )
 212         return uno::Reference< XCommandEnvironment >( 0 );
 213     else
 214         return it->second.getCommandEnvironment();
 215 }
 216
 217
 218 void SAL_CALL TaskManager::handleTask( sal_Int32 CommandId,
 219                                        const uno::Reference< task::XInteractionRequest >& request )
 220 {
 221     osl::MutexGuard aGuard( m_aMutex );
 222     TaskMap::iterator it = m_aTaskMap.find( CommandId );
 223     uno::Reference< task::XInteractionHandler > xInt;
 224     if( it != m_aTaskMap.end() )
 225     {
 226         xInt = it->second.getInteractionHandler();
 227         if( xInt.is() )
 228             xInt->handle( request );
 229         it->second.setHandled();
 230     }
 231 }
 232
 233
 234
 235
 236