namespace framework

{

: ThreadHelpBase ( &Application::GetSolarMutex() )

, m_xTargetFrame ( xFrame )

, m_pFormats ( new DataFlavorExVector )

{

DropTargetListener::~DropTargetListener()

{

delete m_pFormats;

m_pFormats = NULL;

}

void SAL_CALL DropTargetListener::disposing( const css::lang::EventObject& ) throw( css::uno::RuntimeException )

{

}

// -----------------------------------------------------------------------------

/* SAFE { */

ReadGuard aReadLock(m_aLock);

css::uno::Reference< css::frame::XFrame > xTargetFrame( m_xTargetFrame.get(), css::uno::UNO_QUERY );

aReadLock.unlock();

/* } SAFE */

if (xTargetFrame.is() && xParser.is())

@descr We need a valid uno service manager to create or instanciate new services.

All other information to create frames or tasks come in on right interface methods.

points to the valid uno service manager

*//*-*****************************************************************************************************/

: ThreadHelpBase( )

{

}

*//*-*****************************************************************************************************/

TaskCreator::~TaskCreator()

{

}

/*-****************************************************************************************************//**

{

/* SAFE { */

ReadGuard aReadLock( m_aLock );

aReadLock.unlock();

/* } SAFE */

)

{

::comphelper::ConfigurationHelper::readDirectKey(

"org.openoffice.Office.TabBrowse",

"TaskCreatorService",

"ImplementationName",

}

xCreator = css::uno::Reference< css::lang::XSingleServiceFactory >(

}

catch(const css::uno::Exception&)

{}

// library then these class here ... Why we should not be able to create it ?

if ( ! xCreator.is())

xCreator = css::uno::Reference< css::lang::XSingleServiceFactory >(

css::uno::Sequence< css::uno::Any > lArgs(5);

css::beans::NamedValue aArg ;

aArg.Name = OUString(ARGUMENT_PARENTFRAME);

lArgs[0] <<= aArg;

aArg.Name = OUString(ARGUMENT_CREATETOPWINDOW);

css::frame::XDispatch )

//-----------------------------------------------

: ThreadHelpBase (&Application::GetSolarMutex() )

, ::cppu::OWeakObject( )

, m_aAsyncCallback (LINK( this, CloseDispatcher, impl_asyncCallback))

, m_lStatusListener (m_aLock.getShareableOslMutex() )

, m_pSysWindow(NULL)

// BTW: Make some copies, which are needed later ...

EOperation eOperation = m_eOperation;

css::uno::Reference< css::frame::XFrame > xCloseFrame (m_xCloseFrame.get(), css::uno::UNO_QUERY);

css::uno::Reference< css::frame::XDispatchResultListener > xListener = m_xResultListener;

// Analyze the environment a first time.

// If we found some special cases, we can

// make some decisions erliar!

FrameListAnalyzer aCheck1(xDesktop, xCloseFrame, FrameListAnalyzer::E_HELP | FrameListAnalyzer::E_BACKINGCOMPONENT);

// a) If the curent frame (where the close dispatch was requested for) does not have

{

// SAFE -> ----------------------------------

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE ----------------------------------

FrameListAnalyzer aCheck(xDesktop, xFrame, FrameListAnalyzer::E_ALL);

sal_Int32 c = aCheck.m_lModelFrames.getLength();

{

// SAFE -> ----------------------------------

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE ----------------------------------

css::uno::Reference< css::awt::XWindow > xContainerWindow = xFrame->getContainerWindow();

css::uno::Reference< css::frame::XController > xStartModule = css::frame::StartModule::createWithParentWindow(

// Attention: You MUST(!) call setComponent() before you call attachFrame().

css::uno::Reference< css::awt::XWindow > xBackingWin(xStartModule, css::uno::UNO_QUERY);

{

// SAFE -> ----------------------------------

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE ----------------------------------

return xDesktop->terminate();

}

DIRECT_INTERFACE(css::frame::XDispatchInformationProvider))

//_________________________________________________________________________________________________________________

: ThreadHelpBase(&Application::GetSolarMutex())

, m_xFrame (xFrame )

{

}

{

// SAFE -> ----------------------------------

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE ----------------------------------

if (!xFrame.is())

return css::uno::Sequence< css::uno::Reference< css::frame::XDispatchInformationProvider > >();

css::uno::Reference< css::uno::XInterface > xCloser(static_cast< css::frame::XDispatch* >(pCloser), css::uno::UNO_QUERY);

css::uno::Reference< css::frame::XDispatchInformationProvider > xCloseDispatch(xCloser , css::uno::UNO_QUERY);

css::uno::Reference< css::frame::XDispatchInformationProvider > xController (xFrame->getController() , css::uno::UNO_QUERY);

css::uno::Sequence< css::uno::Reference< css::frame::XDispatchInformationProvider > > lProvider(3);

lProvider[0] = xController ;

lProvider[1] = xCloseDispatch;

@seealso using at owner

reference to servicemanager to create new services.

@param xFrame

reference to our owner frame.

*/

const css::uno::Reference< css::frame::XFrame >& xFrame )

// Init baseclasses first

: ThreadHelpBase( &Application::GetSolarMutex() )

, OWeakObject ( )

// Init member

, m_xFrame ( xFrame )

{

}

try

{

xHandler = css::uno::Reference< css::frame::XDispatchProvider >(

css::uno::UNO_QUERY);

}

catch(const css::uno::Exception&) {}

/* SAFE { */

ReadGuard aReadLock( m_aLock );

aReadLock.unlock();

/* } SAFE */

WriteGuard aWriteLock( m_aLock );

if ( ! m_xMenuDispatcher.is() )

{

m_xMenuDispatcher = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

xDispatchHelper = m_xMenuDispatcher;

case E_CREATEDISPATCHER :

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

break;

css::uno::Reference< css::frame::XFrame > xDesktop( xOwner, css::uno::UNO_QUERY );

if (xDesktop.is())

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

}

css::uno::Reference< css::frame::XFrame > xDesktop( xOwner, css::uno::UNO_QUERY );

if (xDesktop.is())

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

}

case E_SELFDISPATCHER :

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

break;

case E_CLOSEDISPATCHER :

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

break;

case E_STARTMODULEDISPATCHER :

{

xDispatchHelper = css::uno::Reference< css::frame::XDispatch >( static_cast< ::cppu::OWeakObject* >(pDispatcher), css::uno::UNO_QUERY );

}

break;

namespace framework{

const OUString sTargetName ,

sal_Int32 nSearchFlags)

: ThreadHelpBase( )

, m_xOwnerFrame (xOwnerFrame )

, m_sTarget (sTargetName )

, m_nSearchFlags(nSearchFlags)

{

}

LoadDispatcher::~LoadDispatcher()

{

}

void SAL_CALL LoadDispatcher::dispatchWithNotification(const css::util::URL& aURL ,

namespace framework{

//-----------------------------------------------

const css::uno::Reference< css::frame::XFrame >& xFrame)

: ThreadHelpBase( )

, m_xFrame (xFrame )

, m_xWindow (xFrame->getContainerWindow())

{

WindowCommandDispatch::~WindowCommandDispatch()

{

impl_stopListening();

}

//-----------------------------------------------

// SYNCHRONIZED ->

ReadGuard aReadLock(m_aLock);

css::uno::Reference< css::frame::XDispatchProvider > xProvider(m_xFrame.get(), css::uno::UNO_QUERY_THROW);

aReadLock.unlock();

// <- SYNCHRONIZED

if ( ! xProvider.is())

return;

css::util::URL aCommand;

aCommand.Complete = sCommand;

xParser->parseStrict(aCommand);

//-----------------------------------------------------------------------------

TransactionManager* pExternalTransactionManager ,

sal_Bool bReleaseLockOnCall )

, m_lVetoChangeListener (pExternalLock->getShareableOslMutex())

, m_bReleaseLockOnCall (bReleaseLockOnCall )

, m_rLock (*pExternalLock )

//*****************************************************************************************************************

// constructor

//*****************************************************************************************************************

FrameContainer* pFrameContainer )

// Init baseclasses first

: ThreadHelpBase ( &Application::GetSolarMutex() )

// Init member

, m_xOwner ( xOwner )

, m_pFrameContainer ( pFrameContainer )

, m_bRecursiveSearchProtection( sal_False )

{

// Safe impossible cases

// Method is not defined for ALL incoming parameters!

}

//*****************************************************************************************************************

// An instance of this class can only work with valid initialization.

// We share the mutex with ouer owner class, need a valid factory to instanciate new services and

// use the access to ouer owner for some operations.

FrameContainer* pFrameContainer )

{

// Set default return value.

sal_Bool bOK = sal_True;

// Check parameter.

if (

( &xOwner == NULL ) ||

( xOwner.is() == sal_False ) ||

( pFrameContainer == NULL )

)

private:

/** @short can be used to create own needed services on demand. */

/** @short TODO document me */

css::uno::WeakReference< css::frame::XFrame > m_xOwnerFrame;

That means: It can be used to load any further requested content into tzhe here(!)

specified target frame.

will be used to create own needed services on demand.

@param xOwnerFrame

@param nSearchFlags

used in case sTargetFrame isnt a special one.

*/

const OUString sTargetName ,

sal_Int32 nSearchFlags);

private:

/// can be used to create own needed services on demand.

/// knows the frame, where we dispatch our commands as weak reference

css::uno::WeakReference< css::frame::XFrame > m_xFrame;

Means: 1 MACDispatch object is bound to 1 Frame/Window pair in which context

the detected commands will be executed.

will be used to create own needed services on demand.

@param xFrame

used as for new detected commands.

*/

const css::uno::Reference< css::frame::XFrame >& xFrame);

//_______________________________________

/** @short reference to an uno service manager, which must be used

to created on needed services on demand.

*/

/** @short points to the frame, which uses this LoadEnv object

and must be used to start target search there.

/** @short initialize a new instance of this load environment.

reference to an uno service manager, which can be used internaly

to create on needed services on demand.

@throw A RuntimeException in case any internal process indicates, that

the whole runtime cant be used any longer.

*/

throw(LoadEnvException, css::uno::RuntimeException);

/** @short deinitialize an instance of this class in the right way.

~LoadEnv();

static css::uno::Reference< css::lang::XComponent > loadComponentFromURL(const css::uno::Reference< css::frame::XComponentLoader >& xLoader,

const OUString& sURL ,

const OUString& sTarget,

sal_Int32 nFlags ,

};

throw(LoadEnvException, css::uno::RuntimeException)

: ThreadHelpBase( )

, m_pQuietInteraction( 0 )

{

}

css::uno::Reference< css::lang::XComponent > LoadEnv::loadComponentFromURL(const css::uno::Reference< css::frame::XComponentLoader >& xLoader,

const OUString& sURL ,

const OUString& sTarget,

sal_Int32 nFlags ,

try

{

aEnv.initializeLoading(sURL,

lArgs,

// parse it - because some following code require that

m_aURL.Complete = sURL;

xParser->parseStrict(m_aURL);

// BTW: Split URL and JumpMark ...

( m_lMediaDescriptor.getUnpackedValueOrDefault( ::comphelper::MediaDescriptor::PROP_PREVIEW(), sal_False ) == sal_False );

initializeUIDefaults(

m_lMediaDescriptor,

bUIMode,

&m_pQuietInteraction

// we can't use as an in/out parameter here. Copy it before and dont forget to

// update structure afterwards again!

css::uno::Sequence< css::beans::PropertyValue > lDescriptor = m_lMediaDescriptor.getAsConstPropertyValueList();

aReadLock.unlock();

// <- SAFE

return;

}

if (xDetect.is())

sType = xDetect->queryTypeByDescriptor(lDescriptor, sal_True); /*TODO should deep detection be able for enable/disable it from outside? */

sal_Bool bIsOwnTemplate = sal_False;

if (!sFilter.isEmpty())

{

try

{

::comphelper::SequenceAsHashMap lFilterProps(xFilterCont->getByName(sFilter));

css::util::URL aURL = m_aURL;

// get necessary container to query for a handler object

css::uno::Reference< css::container::XContainerQuery > xQuery (xFactory , css::uno::UNO_QUERY);

aReadLock.unlock();

{

// SAFE ->

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE

try

{

css::uno::Any aVal = ::comphelper::ConfigurationHelper::readDirectKey(

OUString("org.openoffice.Office.Common/"),

OUString("Misc"),

OUString("MaxOpenDocuments"),

aVal >>= nMaxOpenDocuments;

css::uno::Reference< css::frame::XFramesSupplier > xDesktop(

css::uno::UNO_QUERY_THROW);

FrameListAnalyzer aAnalyzer(xDesktop,

{

try

{

}

catch(const css::uno::RuntimeException&)

{ throw; }

throw LoadEnvException(LoadEnvException::ID_INVALID_MEDIADESCRIPTOR);

// try to locate any interested frame loader

css::uno::Reference< css::container::XContainerQuery > xQuery (xLoaderFactory , css::uno::UNO_QUERY);

aReadLock.unlock();

// SAFE ->

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE

css::util::URL aCmd;

aCmd.Complete = OUString(".uno:JumpToMark");

xParser->parseStrict(aCmd);

css::uno::Reference< css::frame::XDispatch > xDispatcher = xProvider->queryDispatch(aCmd, SPECIALTARGET_SELF, 0);

// otherwise - iterate through the tasks of the desktop container

// to find out, which of them might contains the requested document

css::uno::Reference< css::container::XIndexAccess > xTaskList(xSupplier->getFrames() , css::uno::UNO_QUERY);

if (!xTaskList.is())

if (m_lMediaDescriptor.getUnpackedValueOrDefault(::comphelper::MediaDescriptor::PROP_HIDDEN(), sal_False) == sal_True)

return css::uno::Reference< css::frame::XFrame >();

FrameListAnalyzer aTasksAnalyzer(xSupplier, css::uno::Reference< css::frame::XFrame >(), FrameListAnalyzer::E_BACKINGCOMPONENT);

if (aTasksAnalyzer.m_xBackingComponent.is())

{

{

// SAFE -> ----------------------------------

ReadGuard aReadLock(m_aLock);

aReadLock.unlock();

// <- SAFE ----------------------------------

{

css::uno::Any const a =

::comphelper::ConfigurationHelper::readDirectKey(

OUString("org.openoffice.Office.Common/View"),

OUString("NewDocumentHandling"),

OUString("ForceFocusAndToFront"),

if (sFilter.isEmpty())

return;

aReadLock.unlock();

// <- SAFE

{

// retrieve the module name from the filter configuration

css::uno::Reference< css::container::XNameAccess > xFilterCfg(

css::uno::UNO_QUERY_THROW);

::comphelper::SequenceAsHashMap lProps (xFilterCfg->getByName(sFilter));

OUString sModule = lProps.getUnpackedValueOrDefault(FILTER_PROPNAME_DOCUMENTSERVICE, OUString());

// get access to the configuration of this office module

css::uno::Reference< css::container::XNameAccess > xModuleCfg(::comphelper::ConfigurationHelper::openConfig(

PACKAGE_SETUP_MODULES,

::comphelper::ConfigurationHelper::E_READONLY),

css::uno::UNO_QUERY_THROW);

m_xFrame = xFrame;

// establish drag&drop mode

m_xDropTargetListener = css::uno::Reference< css::datatransfer::dnd::XDropTargetListener >(static_cast< ::cppu::OWeakObject* >(pDropListener), css::uno::UNO_QUERY);

css::uno::Reference< css::awt::XToolkit2 > xToolkit = css::awt::Toolkit::create( comphelper::getComponentContext(m_xSMGR) );

// We hold member as reference ... not as pointer too!

// Attention: We share our frame container with this helper. Container is threadsafe himself ... So I think we can do that.

// But look on dispose() for right order of deinitialization.

m_xFramesHelper = css::uno::Reference< css::frame::XFrames >( static_cast< ::cppu::OWeakObject* >(pFramesHelper), css::uno::UNO_QUERY );

//-------------------------------------------------------------------------------------------------------------

// Initialize a new dispatchhelper-object to handle dispatches.

// We use these helper as slave for our interceptor helper ... not directly!

// But he is event listener on THIS instance!

css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( static_cast< ::cppu::OWeakObject* >(pDispatchHelper), css::uno::UNO_QUERY );

//-------------------------------------------------------------------------------------------------------------

aReadLock.unlock();

RTL_LOGFILE_PRODUCT_CONTEXT( aLog2, "PERFORMANCE - Desktop::loadComponentFromURL()" );

}

/*-************************************************************************************************************//**

//-----------------------------------------------------------------------------------------------------

if ( sTargetFrameName==SPECIALTARGET_BLANK )

{

xTarget = aCreator.createTask(sTargetFrameName,sal_False);

}

(nSearchFlags & css::frame::FrameSearchFlag::CREATE)

)

{

xTarget = aCreator.createTask(sTargetFrameName,sal_False);

}

}

css::frame::XTitleChangeBroadcaster

)

::cppu::OWeakObject ,

"com.sun.star.frame.Frame" ,

OUString("com.sun.star.comp.framework.Frame")

// Initialize a new dispatchhelper-object to handle dispatches.

// We use these helper as slave for our interceptor helper ... not directly!

// But he is event listener on THIS instance!

css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( static_cast< ::cppu::OWeakObject* >(pDispatchHelper), css::uno::UNO_QUERY );

//-------------------------------------------------------------------------------------------------------------

m_xDispatchInfoHelper = css::uno::Reference< css::frame::XDispatchInformationProvider >( static_cast< ::cppu::OWeakObject* >(pInfoHelper), css::uno::UNO_QUERY );

//-------------------------------------------------------------------------------------------------------------

// We hold member as reference ... not as pointer too!

// Attention: We share our frame container with this helper. Container is threadsafe himself ... So I think we can do that.

// But look on dispose() for right order of deinitialization.

m_xFramesHelper = css::uno::Reference< css::frame::XFrames >( static_cast< ::cppu::OWeakObject* >(pFramesHelper), css::uno::UNO_QUERY );

//-------------------------------------------------------------------------------------------------------------

// Initialize a the drop target listener.

// We hold member as reference ... not as pointer too!

m_xDropTargetListener = css::uno::Reference< css::datatransfer::dnd::XDropTargetListener >( static_cast< ::cppu::OWeakObject* >(pDropListener), css::uno::UNO_QUERY );

// Safe impossible cases

//-------------------------------------------------------------------------------------------------------------

// Create an initial layout manager

// Create layout manager and connect it to the newly created frame

//-------------------------------------------------------------------------------------------------------------

// set information about all supported properties at the base class helper PropertySetHelper

@seealso method DEFINE_INIT_SERVICE()

@return -

@onerror ASSERT in debug version or nothing in relaese version.

*//*-*****************************************************************************************************/

: ThreadHelpBase ( &Application::GetSolarMutex() )

, TransactionBase ( )

&m_aTransactionManager,

sal_False) // sal_False => dont release shared mutex on calling us!

, ::cppu::OWeakObject ( )

// init member

, m_aListenerContainer ( m_aLock.getShareableOslMutex() )

, m_xParent ( )

, m_xContainerWindow ( )

, m_aChildFrameContainer ( )

{

// Check incoming parameter to avoid against wrong initialization.

/* Please have a look on "@attentions" of description before! */

}

ReadGuard aReadLock(m_aLock);

css::uno::Reference< css::frame::XComponentLoader > xThis(static_cast< css::frame::XComponentLoader* >(this), css::uno::UNO_QUERY);

aReadLock.unlock();

}

/*-****************************************************************************************************//**

if (pWindow && pWindow->IsVisible())

m_bIsHidden = sal_False;

// Release lock ... because we call some impl methods, which are threadsafe by himself.

// If we hold this lock - we will produce our own deadlock!

// create progress helper

css::uno::Reference< css::frame::XFrame > xThis (static_cast< css::frame::XFrame* >(this) , css::uno::UNO_QUERY_THROW);

css::uno::Reference< css::task::XStatusIndicatorFactory > xIndicatorFactory =

// SAFE -> ----------------------------------

aWriteLock.lock();

impl_enablePropertySet();

// Initialize title functionality

m_xTitleHelper = css::uno::Reference< css::frame::XTitle >(static_cast< ::cppu::OWeakObject* >(pTitleHelper), css::uno::UNO_QUERY_THROW);

pTitleHelper->setOwner(xThis);

}

/* SAFE { */

ReadGuard aReadLock( m_aLock );

css::uno::Reference< css::frame::XFrame > xParent ( m_xParent, css::uno::UNO_QUERY );

sal_Bool bIsTopFrame = m_bIsFrameTop;

sal_Bool bIsTopWindow = WindowHelper::isTopWindow(m_xContainerWindow);

aReadLock.unlock();

//-----------------------------------------------------------------------------------------------------

if ( sTargetFrameName==SPECIALTARGET_BLANK )

{

xTarget = aCreator.createTask(sTargetFrameName,sal_False);

}

(nSearchFlags & css::frame::FrameSearchFlag::CREATE)

)

{

xTarget = aCreator.createTask(sTargetFrameName,sal_False);

}

}

// Release some other references.

// This calls should be easy ... I hope it :-)

m_xDispatchHelper.clear();

m_xDropTargetListener.clear();

m_xDispatchRecorderSupplier.clear();

m_xLayoutManager.clear();

/* SAFE */

ReadGuard aReadLock( m_aLock );

aReadLock.unlock();

/* SAFE */

css::util::URL aURL;

aURL.Complete = DECLARE_ASCII(".uno:CloseFrame");

xParser->parseStrict(aURL);

css::uno::Reference< css::frame::XDispatch > xCloser = queryDispatch(aURL, SPECIALTARGET_SELF, 0);

/* SAFE { */

ReadGuard aReadLock(m_aLock);

css::uno::Reference< css::frame::XDesktop > xDesktopCheck( m_xParent, css::uno::UNO_QUERY );

m_bIsHidden = sal_False;

aReadLock.unlock();

/* } SAFE */

if (bMustBeTriggered)

{

css::uno::Reference< css::task::XJobExecutor > xExecutor

xExecutor->trigger( DECLARE_ASCII("onFirstVisibleTask") );

}

}

// Make snapshot of necessary member!

ReadGuard aReadLock( m_aLock );

css::uno::Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow ;

css::uno::Reference< css::datatransfer::dnd::XDropTargetListener > xDragDropListener = m_xDropTargetListener;

css::uno::Reference< css::awt::XWindowListener > xWindowListener ( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );

css::uno::Reference< css::awt::XFocusListener > xFocusListener ( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );

{

xTopWindow->addTopWindowListener( xTopWindowListener );

css::uno::Reference< css::datatransfer::dnd::XDropTarget > xDropTarget = xToolkit->getDropTarget( xContainerWindow );

if( xDropTarget.is() == sal_True )

{

// Make snapshot of necessary member!

ReadGuard aReadLock( m_aLock );

css::uno::Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow ;

css::uno::Reference< css::datatransfer::dnd::XDropTargetListener > xDragDropListener = m_xDropTargetListener;

css::uno::Reference< css::awt::XWindowListener > xWindowListener ( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );

css::uno::Reference< css::awt::XFocusListener > xFocusListener ( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );

{

xTopWindow->removeTopWindowListener( xTopWindowListener );

css::uno::Reference< css::datatransfer::dnd::XDropTarget > xDropTarget = xToolkit->getDropTarget( xContainerWindow );

if( xDropTarget.is() == sal_True )

{

//*****************************************************************************************************************

// We don't accept null pointer or references!

{

return (

);

}

// baseclasses and then members. And we need the mutex for other baseclasses !!!

: ThreadHelpBase ( &Application::GetSolarMutex() )

, TransactionBase ( )

&m_aTransactionManager ,

sal_False ) // sal_False => dont release shared mutex on calling us!

, OWeakObject ( )