diff options
Diffstat (limited to '')
| -rw-r--r-- | framework/source/jobs/job.cxx | 833 |
1 files changed, 833 insertions, 0 deletions
diff --git a/framework/source/jobs/job.cxx b/framework/source/jobs/job.cxx new file mode 100644 index 000000000..9f85f8452 --- /dev/null +++ b/framework/source/jobs/job.cxx @@ -0,0 +1,833 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <jobs/job.hxx> +#include <jobs/jobresult.hxx> + +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/TerminationVetoException.hpp> +#include <com/sun/star/task/XJob.hpp> +#include <com/sun/star/task/XAsyncJob.hpp> +#include <com/sun/star/util/CloseVetoException.hpp> +#include <com/sun/star/util/XCloseBroadcaster.hpp> +#include <com/sun/star/util/XCloseable.hpp> +#include <com/sun/star/lang/DisposedException.hpp> + +#include <comphelper/sequence.hxx> +#include <sal/log.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/svapp.hxx> + +namespace framework{ + +/** + @short standard ctor + @descr It initialize this new instance. But it set some generic parameters here only. + Specialized information (e.g. the alias or service name ofthis job) will be set + later using the method setJobData(). + + @param xContext + reference to the uno service manager + + @param xFrame + reference to the frame, in which environment we run + (May be null!) +*/ +Job::Job( /*IN*/ const css::uno::Reference< css::uno::XComponentContext >& xContext , + /*IN*/ const css::uno::Reference< css::frame::XFrame >& xFrame ) + : m_aJobCfg (xContext ) + , m_xContext (xContext ) + , m_xFrame (xFrame ) + , m_bListenOnDesktop (false ) + , m_bListenOnFrame (false ) + , m_bListenOnModel (false ) + , m_bPendingCloseFrame (false ) + , m_bPendingCloseModel (false ) + , m_eRunState (E_NEW ) +{ +} + +/** + @short standard ctor + @descr It initialize this new instance. But it set some generic parameters here only. + Specialized information (e.g. the alias or service name ofthis job) will be set + later using the method setJobData(). + + @param xContext + reference to the uno service manager + + @param xModel + reference to the model, in which environment we run + (May be null!) +*/ +Job::Job( /*IN*/ const css::uno::Reference< css::uno::XComponentContext >& xContext , + /*IN*/ const css::uno::Reference< css::frame::XModel >& xModel ) + : m_aJobCfg (xContext ) + , m_xContext (xContext ) + , m_xModel (xModel ) + , m_bListenOnDesktop (false ) + , m_bListenOnFrame (false ) + , m_bListenOnModel (false ) + , m_bPendingCloseFrame (false ) + , m_bPendingCloseModel (false ) + , m_eRunState (E_NEW ) +{ +} + +/** + @short superfluous! + @descr Releasing of memory and reference must be done inside die() call. + Otherwise it's a bug. +*/ +Job::~Job() +{ +} + +/** + @short set (or delete) a listener for sending dispatch result events + @descr Because this object is used in a wrapped mode ... the original listener + for such events can't be registered here directly. Because the + listener expect to get the original object given as source of the event. + That's why we get this source here too, to fake(!) it at sending time! + + @param xListener + the original listener for dispatch result events + + @param xSourceFake + our user, which got the registration request for this listener +*/ +void Job::setDispatchResultFake( /*IN*/ const css::uno::Reference< css::frame::XDispatchResultListener >& xListener , + /*IN*/ const css::uno::Reference< css::uno::XInterface >& xSourceFake ) +{ + SolarMutexGuard g; + + // reject dangerous calls + if (m_eRunState != E_NEW) + { + SAL_INFO("fwk", "Job::setJobData(): job may still running or already finished"); + return; + } + + m_xResultListener = xListener; + m_xResultSourceFake = xSourceFake; +} + +void Job::setJobData( const JobData& aData ) +{ + SolarMutexGuard g; + + // reject dangerous calls + if (m_eRunState != E_NEW) + { + SAL_INFO("fwk", "Job::setJobData(): job may still running or already finished"); + return; + } + + m_aJobCfg = aData; +} + +/** + @short runs the job + @descr It doesn't matter, if the job is an asynchronous or + synchronous one. This method returns only if it was finished + or cancelled. + + @param lDynamicArgs + optional arguments for job execution + In case the represented job is a configured one (which uses static + arguments too) all information will be merged! +*/ +void Job::execute( /*IN*/ const css::uno::Sequence< css::beans::NamedValue >& lDynamicArgs ) +{ + /* SAFE { */ + SolarMutexResettableGuard aWriteLock; + + // reject dangerous calls + if (m_eRunState != E_NEW) + { + SAL_INFO("fwk", "Job::execute(): job may still running or already finished"); + return; + } + + // create the environment and mark this job as running ... + m_eRunState = E_RUNNING; + impl_startListening(); + + css::uno::Reference< css::task::XAsyncJob > xAJob; + css::uno::Reference< css::task::XJob > xSJob; + css::uno::Sequence< css::beans::NamedValue > lJobArgs = impl_generateJobArgs(lDynamicArgs); + + // It's necessary to hold us self alive! + // Otherwise we might die by ref count ... + css::uno::Reference< css::task::XJobListener > xThis(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + + try + { + // create the job + // We must check for the supported interface on demand! + // But we prefer the synchronous one ... + m_xJob = m_xContext->getServiceManager()->createInstanceWithContext(m_aJobCfg.getService(), m_xContext); + xSJob.set(m_xJob, css::uno::UNO_QUERY); + if (!xSJob.is()) + xAJob.set(m_xJob, css::uno::UNO_QUERY); + + // execute it asynchronous + if (xAJob.is()) + { + m_aAsyncWait.reset(); + aWriteLock.clear(); + /* } SAFE */ + xAJob->executeAsync(lJobArgs, xThis); + // wait for finishing this job - so this method + // does the same for synchronous and asynchronous jobs! + m_aAsyncWait.wait(); + aWriteLock.reset(); + /* SAFE { */ + // Note: Result handling was already done inside the callback! + } + // execute it synchron + else if (xSJob.is()) + { + aWriteLock.clear(); + /* } SAFE */ + css::uno::Any aResult = xSJob->execute(lJobArgs); + aWriteLock.reset(); + /* SAFE { */ + impl_reactForJobResult(aResult); + } + } + #if OSL_DEBUG_LEVEL > 0 + catch(const css::uno::Exception&) + { + TOOLS_INFO_EXCEPTION("fwk", "Job::execute(): Got exception during job execution"); + } + #else + catch(const css::uno::Exception&) + {} + #endif + + // deinitialize the environment and mark this job as finished... + // but don't overwrite any information about STOPPED or might DISPOSED jobs! + impl_stopListening(); + if (m_eRunState == E_RUNNING) + m_eRunState = E_STOPPED_OR_FINISHED; + + // If we got a close request from our frame or model... + // but we disagreed with that by throwing a veto exception... + // and got the ownership... + // we have to close the resource frame or model now - + // and to disable ourself! + if (m_bPendingCloseFrame) + { + m_bPendingCloseFrame = false; + css::uno::Reference< css::util::XCloseable > xClose(m_xFrame, css::uno::UNO_QUERY); + if (xClose.is()) + { + try + { + xClose->close(true); + } + catch(const css::util::CloseVetoException&) {} + } + } + + if (m_bPendingCloseModel) + { + m_bPendingCloseModel = false; + css::uno::Reference< css::util::XCloseable > xClose(m_xModel, css::uno::UNO_QUERY); + if (xClose.is()) + { + try + { + xClose->close(true); + } + catch(const css::util::CloseVetoException&) {} + } + } + + aWriteLock.clear(); + /* SAFE { */ + + // release this instance ... + die(); +} + +/** + @short kill this job + @descr It doesn't matter if this request is called from inside or + from outside. We release our internal structures and stop + every activity. After doing so - this instance will not be + usable any longer! Of course we try to handle further requests + carefully. Maybe someone else holds a reference to us ... +*/ +void Job::die() +{ + SolarMutexGuard g; + + impl_stopListening(); + + if (m_eRunState != E_DISPOSED) + { + try + { + css::uno::Reference< css::lang::XComponent > xDispose(m_xJob, css::uno::UNO_QUERY); + if (xDispose.is()) + { + xDispose->dispose(); + m_eRunState = E_DISPOSED; + } + } + catch(const css::lang::DisposedException&) + { + m_eRunState = E_DISPOSED; + } + } + + m_xJob.clear(); + m_xFrame.clear(); + m_xModel.clear(); + m_xDesktop.clear(); + m_xResultListener.clear(); + m_xResultSourceFake.clear(); + m_bPendingCloseFrame = false; + m_bPendingCloseModel = false; +} + +/** + @short generates list of arguments for job execute + @descr There exist a set of information, which can be needed by a job. + a) it's static configuration data (Equals for all jobs. ) + b) it's specific configuration data (Different for every job.) + c) some environment values (e.g. the frame, for which this job was started) + d) any other dynamic data (e.g. parameters of a dispatch() request) + We collect all this information and generate one list which include all others. + + @param lDynamicArgs + list of dynamic arguments (given by a corresponding dispatch() call) + Can be empty too. + + @return A list which includes all mentioned sub lists. +*/ +css::uno::Sequence< css::beans::NamedValue > Job::impl_generateJobArgs( /*IN*/ const css::uno::Sequence< css::beans::NamedValue >& lDynamicArgs ) +{ + css::uno::Sequence< css::beans::NamedValue > lAllArgs; + + /* SAFE { */ + SolarMutexClearableGuard aReadLock; + + // the real structure of the returned list depends from the environment of this job! + JobData::EMode eMode = m_aJobCfg.getMode(); + + // Create list of environment variables. This list must be part of the + // returned structure every time... but some of its members are optional! + css::uno::Sequence< css::beans::NamedValue > lEnvArgs(1); + lEnvArgs[0].Name = "EnvType"; + lEnvArgs[0].Value <<= m_aJobCfg.getEnvironmentDescriptor(); + + if (m_xFrame.is()) + { + sal_Int32 c = lEnvArgs.getLength(); + lEnvArgs.realloc(c+1); + lEnvArgs[c].Name = "Frame"; + lEnvArgs[c].Value <<= m_xFrame; + } + if (m_xModel.is()) + { + sal_Int32 c = lEnvArgs.getLength(); + lEnvArgs.realloc(c+1); + lEnvArgs[c].Name = "Model"; + lEnvArgs[c].Value <<= m_xModel; + } + if (eMode==JobData::E_EVENT) + { + sal_Int32 c = lEnvArgs.getLength(); + lEnvArgs.realloc(c+1); + lEnvArgs[c].Name = "EventName"; + lEnvArgs[c].Value <<= m_aJobCfg.getEvent(); + } + + // get the configuration data from the job data container ... if possible + // Means: if this job has any configuration data. Note: only really + // filled lists will be set to the return structure at the end of this method. + css::uno::Sequence< css::beans::NamedValue > lConfigArgs; + std::vector< css::beans::NamedValue > lJobConfigArgs; + if (eMode==JobData::E_ALIAS || eMode==JobData::E_EVENT) + { + lConfigArgs = m_aJobCfg.getConfig(); + lJobConfigArgs = m_aJobCfg.getJobConfig(); + } + + aReadLock.clear(); + /* } SAFE */ + + // Add all valid (not empty) lists to the return list + if (lConfigArgs.hasElements()) + { + sal_Int32 nLength = lAllArgs.getLength(); + lAllArgs.realloc(nLength+1); + lAllArgs[nLength].Name = "Config"; + lAllArgs[nLength].Value <<= lConfigArgs; + } + if (!lJobConfigArgs.empty()) + { + sal_Int32 nLength = lAllArgs.getLength(); + lAllArgs.realloc(nLength+1); + lAllArgs[nLength].Name = "JobConfig"; + lAllArgs[nLength].Value <<= comphelper::containerToSequence(lJobConfigArgs); + } + if (lEnvArgs.hasElements()) + { + sal_Int32 nLength = lAllArgs.getLength(); + lAllArgs.realloc(nLength+1); + lAllArgs[nLength].Name = "Environment"; + lAllArgs[nLength].Value <<= lEnvArgs; + } + if (lDynamicArgs.hasElements()) + { + sal_Int32 nLength = lAllArgs.getLength(); + lAllArgs.realloc(nLength+1); + lAllArgs[nLength].Name = "DynamicData"; + lAllArgs[nLength].Value <<= lDynamicArgs; + } + + return lAllArgs; +} + +/** + @short analyze the given job result and change the job configuration + @descr Note: Some results can be handled only, if this job has a valid configuration! + For "not configured jobs" (means pure services) they can be ignored. + But these cases are handled by our JobData member. We can call it every time. + It does the right things automatically. E.g. if the job has no configuration ... + it does nothing during setJobConfig()! + + @param aResult + the job result for analyzing +*/ +void Job::impl_reactForJobResult( /*IN*/ const css::uno::Any& aResult ) +{ + SolarMutexGuard g; + + // analyze the result set ... + JobResult aAnalyzedResult(aResult); + + // some of the following operations will be supported for different environments + // or different type of jobs only. + JobData::EEnvironment eEnvironment = m_aJobCfg.getEnvironment(); + + // write back the job specific configuration data ... + // If the environment allow it and if this job has a configuration! + if ( + (m_aJobCfg.hasConfig() ) && + (aAnalyzedResult.existPart(JobResult::E_ARGUMENTS)) + ) + { + m_aJobCfg.setJobConfig(aAnalyzedResult.getArguments()); + } + + // disable a job for further executions. + // Note: this option is available inside the environment EXECUTOR only + if ( +// (eEnvironment == JobData::E_EXECUTION ) && + (m_aJobCfg.hasConfig() ) && + (aAnalyzedResult.existPart(JobResult::E_DEACTIVATE)) + ) + { + m_aJobCfg.disableJob(); + } + + // notify any interested listener with the may given result state. + // Note: this option is available inside the environment DISPATCH only + if ( + (eEnvironment == JobData::E_DISPATCH ) && + (m_xResultListener.is() ) && + (aAnalyzedResult.existPart(JobResult::E_DISPATCHRESULT)) + ) + { + // Attention: Because the listener expect that the original object send this event ... + // and we nor the job are the right ones ... + // our user has set itself before. So we can fake this source address! + css::frame::DispatchResultEvent aEvent = aAnalyzedResult.getDispatchResult(); + aEvent.Source = m_xResultSourceFake; + m_xResultListener->dispatchFinished(aEvent); + } +} + +/** + @short starts listening for office shutdown and closing of our + given target frame (if it's a valid reference) + @descr We will register ourself as terminate listener + at the global desktop instance. That will hold us + alive and additional we get the information, if the + office wish to shutdown. If then an internal job + is running we will have the chance to suppress that + by throwing a veto exception. If our internal wrapped + job finished his work, we can release this listener + connection. + + Further we are listener for closing of the (possible valid) + given frame. We must be sure, that this resource won't be gone + if our internal job is still running. +*/ +void Job::impl_startListening() +{ + SolarMutexGuard g; + + // listening for office shutdown + if (!m_xDesktop.is() && !m_bListenOnDesktop) + { + try + { + m_xDesktop = css::frame::Desktop::create( m_xContext ); + css::uno::Reference< css::frame::XTerminateListener > xThis(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + m_xDesktop->addTerminateListener(xThis); + m_bListenOnDesktop = true; + } + catch(const css::uno::Exception&) + { + m_xDesktop.clear(); + } + } + + // listening for frame closing + if (m_xFrame.is() && !m_bListenOnFrame) + { + try + { + css::uno::Reference< css::util::XCloseBroadcaster > xCloseable(m_xFrame , css::uno::UNO_QUERY); + css::uno::Reference< css::util::XCloseListener > xThis (static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + if (xCloseable.is()) + { + xCloseable->addCloseListener(xThis); + m_bListenOnFrame = true; + } + } + catch(const css::uno::Exception&) + { + m_bListenOnFrame = false; + } + } + + // listening for model closing + if (!(m_xModel.is() && !m_bListenOnModel)) + return; + + try + { + css::uno::Reference< css::util::XCloseBroadcaster > xCloseable(m_xModel , css::uno::UNO_QUERY); + css::uno::Reference< css::util::XCloseListener > xThis (static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + if (xCloseable.is()) + { + xCloseable->addCloseListener(xThis); + m_bListenOnModel = true; + } + } + catch(const css::uno::Exception&) + { + m_bListenOnModel = false; + } +} + +/** + @short release listener connection for office shutdown + @descr see description of impl_startListening() +*/ +void Job::impl_stopListening() +{ + SolarMutexGuard g; + + // stop listening for office shutdown + if (m_xDesktop.is() && m_bListenOnDesktop) + { + try + { + css::uno::Reference< css::frame::XTerminateListener > xThis(static_cast< ::cppu::OWeakObject* >(this) , css::uno::UNO_QUERY); + m_xDesktop->removeTerminateListener(xThis); + m_xDesktop.clear(); + m_bListenOnDesktop = false; + } + catch(const css::uno::Exception&) + { + } + } + + // stop listening for frame closing + if (m_xFrame.is() && m_bListenOnFrame) + { + try + { + css::uno::Reference< css::util::XCloseBroadcaster > xCloseable(m_xFrame , css::uno::UNO_QUERY); + css::uno::Reference< css::util::XCloseListener > xThis (static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + if (xCloseable.is()) + { + xCloseable->removeCloseListener(xThis); + m_bListenOnFrame = false; + } + } + catch(const css::uno::Exception&) + { + } + } + + // stop listening for model closing + if (!(m_xModel.is() && m_bListenOnModel)) + return; + + try + { + css::uno::Reference< css::util::XCloseBroadcaster > xCloseable(m_xModel , css::uno::UNO_QUERY); + css::uno::Reference< css::util::XCloseListener > xThis (static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + if (xCloseable.is()) + { + xCloseable->removeCloseListener(xThis); + m_bListenOnModel = false; + } + } + catch(const css::uno::Exception&) + { + } +} + +/** + @short callback from any asynchronous executed job + + @descr Our execute() method waits for this callback. + We have to react for the possible results here, + to kill the running job and disable the blocked condition + so execute() can be finished too. + + @param xJob + the job, which was running and inform us now + + @param aResult + its results +*/ +void SAL_CALL Job::jobFinished( /*IN*/ const css::uno::Reference< css::task::XAsyncJob >& xJob , + /*IN*/ const css::uno::Any& aResult ) +{ + SolarMutexGuard g; + + // It's necessary to check this. + // May this job was cancelled by any other reason + // some milliseconds before. :-) + if (m_xJob.is() && m_xJob==xJob) + { + // react for his results + // (means enable/disable it for further requests + // or save arguments or notify listener ...) + impl_reactForJobResult(aResult); + + // Let the job die! + m_xJob.clear(); + } + + // And let the start method "execute()" finishing it's job. + // But do it every time. So any outside blocking code can finish + // his work too. + m_aAsyncWait.set(); +} + +/** + @short prevent internal wrapped job against office termination + @descr This event is broadcasted by the desktop instance and ask for an office termination. + If the internal wrapped job is still in progress, we disagree with that by throwing the + right veto exception. If not - we agree. But then we must be aware, that another event + notifyTermination() can follow. Then we have no chance to do the same. Then we have to + accept that and stop our work instandly. + + @param aEvent + describes the broadcaster and must be the desktop instance + + @throw TerminateVetoException + if our internal wrapped job is still running. + */ +void SAL_CALL Job::queryTermination( /*IN*/ const css::lang::EventObject& ) +{ + SolarMutexGuard g; + + // Otherwise try to close() it + css::uno::Reference< css::util::XCloseable > xClose(m_xJob, css::uno::UNO_QUERY); + if (xClose.is()) + { + try + { + xClose->close(false); + m_eRunState = E_STOPPED_OR_FINISHED; + } + catch(const css::util::CloseVetoException&) {} + } + + if (m_eRunState != E_STOPPED_OR_FINISHED) + { + css::uno::Reference< css::uno::XInterface > xThis(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + throw css::frame::TerminationVetoException("job still in progress", xThis); + } +} + +/** + @short inform us about office termination + @descr Instead of the method queryTermination(), here is no chance to disagree with that. + We have to accept it and cancel all current processes inside. + It can occur only, if job was not already started if queryTermination() was called here. + Then we had not thrown a veto exception. But now we must agree with this situation and break + all our internal processes. It's not a good idea to mark this instance as non startable any longer + inside queryTermination() if no job was running too. Because that would disable this job and may + the office does not really shutdown, because another listener has thrown the suitable exception. + + @param aEvent + describes the broadcaster and must be the desktop instance + */ +void SAL_CALL Job::notifyTermination( /*IN*/ const css::lang::EventObject& ) +{ + die(); + // Do nothing else here. Our internal resources was released ... +} + +/** + @short prevent internal wrapped job against frame closing + @descr This event is broadcasted by the frame instance and ask for closing. + If the internal wrapped job is still in progress, we disagree with that by throwing the + right veto exception. If not - we agree. But then we must be aware, that another event + notifyClosing() can follow. Then we have no chance to do the same. Then we have to + accept that and stop our work instandly. + + @param aEvent + describes the broadcaster and must be the frame instance + + @param bGetsOwnership + If it's set to <sal_True> and we throw the right veto exception, we have to close this frame later + if our internal processes will be finished. If it's set to <FALSE/> we can ignore it. + + @throw CloseVetoException + if our internal wrapped job is still running. + */ +void SAL_CALL Job::queryClosing( const css::lang::EventObject& aEvent , + sal_Bool bGetsOwnership ) +{ + SolarMutexGuard g; + + // do nothing, if no internal job is still running ... + // The frame or model can be closed then successfully. + if (m_eRunState != E_RUNNING) + return; + + // try close() first at the job. + // The job can agree or disagree with this request. + css::uno::Reference< css::util::XCloseable > xClose(m_xJob, css::uno::UNO_QUERY); + if (xClose.is()) + { + xClose->close(bGetsOwnership); + // Here we can say: "this job was stopped successfully". Because + // no veto exception was thrown! + m_eRunState = E_STOPPED_OR_FINISHED; + return; + } + + // try dispose() then + // Here the job has no chance for a veto. + // But we must be aware of an "already disposed exception"... + try + { + css::uno::Reference< css::lang::XComponent > xDispose(m_xJob, css::uno::UNO_QUERY); + if (xDispose.is()) + { + xDispose->dispose(); + m_eRunState = E_DISPOSED; + } + } + catch(const css::lang::DisposedException&) + { + // the job was already disposed by any other mechanism !? + // But it's not interesting for us. For us this job is stopped now. + m_eRunState = E_DISPOSED; + } + + if (m_eRunState != E_DISPOSED) + { + // analyze event source - to find out, which resource called queryClosing() at this + // job wrapper. We must bind a "pending close" request to this resource. + // Closing of the corresponding resource will be done if our internal job finish it's work. + m_bPendingCloseFrame = (m_xFrame.is() && aEvent.Source == m_xFrame); + m_bPendingCloseModel = (m_xModel.is() && aEvent.Source == m_xModel); + + // throw suitable veto exception - because the internal job could not be cancelled. + css::uno::Reference< css::uno::XInterface > xThis(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY); + throw css::util::CloseVetoException("job still in progress", xThis); + } + + // No veto ... + // But don't call die() here or free our internal member. + // This must be done inside notifyClosing() only. Otherwise the + // might stopped job has no chance to return its results or + // call us back. We must give him the chance to finish it's work successfully. +} + +/** + @short inform us about frame closing + @descr Instead of the method queryClosing(), here is no chance to disagree with that. + We have to accept it and cancel all current processes inside. + + @param aEvent + describes the broadcaster and must be the frame or model instance we know + */ +void SAL_CALL Job::notifyClosing( const css::lang::EventObject& ) +{ + die(); + // Do nothing else here. Our internal resources was released ... +} + +/** + @short shouldn't be called normally + @descr But it doesn't matter, who called it. We have to kill our internal + running processes hardly. + + @param aEvent + describe the broadcaster +*/ +void SAL_CALL Job::disposing( const css::lang::EventObject& aEvent ) +{ + /* SAFE { */ + { + SolarMutexGuard aWriteLock; + + if (m_xDesktop.is() && aEvent.Source == m_xDesktop) + { + m_xDesktop.clear(); + m_bListenOnDesktop = false; + } + else if (m_xFrame.is() && aEvent.Source == m_xFrame) + { + m_xFrame.clear(); + m_bListenOnFrame = false; + } + else if (m_xModel.is() && aEvent.Source == m_xModel) + { + m_xModel.clear(); + m_bListenOnModel = false; + } + } + /* } SAFE */ + + die(); + // Do nothing else here. Our internal resources was released ... +} + +} // namespace framework + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |