ui/view/ViewShellManager.cxx

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"

#include "ViewShellManager.hxx"
#include "ViewShell.hxx"
#include "ViewShellBase.hxx"
#include "Window.hxx"
#include "DrawDocShell.hxx"
#include "FormShellManager.hxx"

#include <sfx2/dispatch.hxx>
#include <svx/svxids.hrc>
#include <svx/fmshell.hxx>

#include <hash_map>

#undef VERBOSE
//#define VERBOSE 2

namespace sd {

namespace {

/** The ShellDescriptor class is used to shells together with their ids and
	the factory that was used to create the shell.

	The shell pointer may be NULL. In that case the shell is created on
	demand by a factory.

	The factory pointer may be NULL. In that case the shell pointer is
	given to the ViewShellManager.

	Shell pointer and factory pointer can but should not be NULL at the same
	time.
*/
class ShellDescriptor {
public:
	SfxShell* mpShell;
	ShellId mnId;
	ViewShellManager::SharedShellFactory mpFactory;
	bool mbIsListenerAddedToWindow;

	ShellDescriptor ();
	ShellDescriptor (SfxShell* pShell, ShellId nId);
	ShellDescriptor (const ShellDescriptor& rDescriptor);
	ShellDescriptor& operator= (const ShellDescriptor& rDescriptor);
	bool IsMainViewShell (void) const;
	::Window* GetWindow (void) const;
};


/** This functor can be used to search for a shell in an STL container when the
	shell pointer is given.
*/
class IsShell : public ::std::unary_function<ShellDescriptor,bool>
{
public:
	IsShell (const SfxShell* pShell) : mpShell(pShell) {}
	bool operator() (const ShellDescriptor& rDescriptor)
	{ return rDescriptor.mpShell == mpShell; }
private:
	const SfxShell* mpShell;
};


/** This functor can be used to search for a shell in an STL container when the
	id of the shell is given.
*/
class IsId : public ::std::unary_function<ShellDescriptor,bool>
{
public:
	IsId (ShellId nId) : mnId(nId) {}
	bool operator() (const ShellDescriptor& rDescriptor)
	{ return rDescriptor.mnId == mnId; }
private:
	ShellId mnId;
};

} // end of anonymous namespace


class ViewShellManager::Implementation
{
public:
	Implementation (
		ViewShellManager& rManager,
		ViewShellBase& rBase);
	~Implementation (void);

	void AddShellFactory (
		const SfxShell* pViewShell,
		const SharedShellFactory& rpFactory);
	void RemoveShellFactory (
		const SfxShell* pViewShell,
		const SharedShellFactory& rpFactory);
	void ActivateViewShell (
		ViewShell* pViewShell);
	void DeactivateViewShell (const ViewShell& rShell);
	void ActivateShell (SfxShell& rShell);
	void DeactivateShell (const SfxShell& rShell);
	void ActivateShell (const ShellDescriptor& rDescriptor);
	void SetFormShell (const ViewShell* pViewShell, FmFormShell* pFormShell, bool bAbove);
	void ActivateSubShell (const SfxShell& rParentShell, ShellId nId);
	void DeactivateSubShell (const SfxShell& rParentShell, ShellId nId);
	void MoveSubShellToTop (const SfxShell& rParentShell, ShellId nId);
	void MoveToTop (const SfxShell& rParentShell);
	SfxShell* GetShell (ShellId nId) const;
	SfxShell* GetTopShell (void) const;
	void Shutdown (void);
	void InvalidateAllSubShells (const SfxShell* pParentShell);

	/** Remove all shells from the SFX stack above and including the given
		shell.
	*/
	void TakeShellsFromStack (const SfxShell* pShell);

	class UpdateLock
	{
	public:
		UpdateLock (Implementation& rImpl) : mrImpl(rImpl) {mrImpl.LockUpdate();}
		~UpdateLock (void) {mrImpl.UnlockUpdate();};
	private:
		Implementation& mrImpl;
	};


	/** Prevent updates of the shell stack. While the sub shell manager is
		locked it will update its internal data structures but not alter the
		shell stack. Use this method when there are several modifications
		to the shell stack to prevent multiple rebuilds of the shell stack
		and resulting broadcasts.
	*/
	void LockUpdate (void);

	/** Allow updates of the shell stack. This method has to be called the
		same number of times as LockUpdate() to really allow a rebuild of
		the shell stack.
	*/
	void UnlockUpdate (void);

private:
	ViewShellBase& mrBase;
	mutable ::osl::Mutex maMutex;

	class ShellHash{public: size_t operator()(const SfxShell* p) const { return (size_t)p;} };
	typedef ::std::hash_multimap<const SfxShell*,SharedShellFactory,ShellHash>
		FactoryList;
	FactoryList maShellFactories;

	/** List of the active view shells. In order to create gather all shells
		to put on the shell stack each view shell in this list is asked for
		its sub-shells (typically toolbars).
	*/
	typedef ::std::list<ShellDescriptor> ActiveShellList;
	ActiveShellList maActiveViewShells;

	typedef ::std::list<ShellDescriptor> SubShellSubList;
	typedef ::std::hash_map<const SfxShell*,SubShellSubList,ShellHash> SubShellList;
	SubShellList maActiveSubShells;

	/** In this member we remember what shells we have pushed on the shell
		stack.
	*/
	typedef ::std::vector<SfxShell*> ShellStack;

	int mnUpdateLockCount;

	/** When this flag is set then the main view shell is always kept at the
		top of the shell stack.
	*/
	bool mbKeepMainViewShellOnTop;

	/** The UpdateShellStack() method can be called recursively. This flag
		is used to communicate between different levels of invocation: if
		the stack has been updated in an inner call the outer call can (has
		to) stop and return immediately.
	*/
	bool mbShellStackIsUpToDate;

	SfxShell* mpFormShell;
	const ViewShell* mpFormShellParent;
	bool mbFormShellAboveParent;

	SfxShell* mpTopShell;

	void GatherActiveShells (ShellStack& rShellList);

	void UpdateShellStack (void);

	void CreateShells (void);

	/** This method rebuilds the stack of shells that are stacked upon the
		view shell base.
	*/
	void CreateTargetStack (ShellStack& rStack) const;

	DECL_LINK(WindowEventHandler, VclWindowEvent*);

#ifdef VERBOSE
	void DumpShellStack (const ShellStack& rStack);
	void DumpSfxShellStack (void);
#endif

	/** To be called before a shell is taken from the SFX shell stack. This
		method deactivates an active text editing to avoid problems with
		undo managers.
		Afterwards the Deactivate() of the shell is called.
	*/
	void Deactivate (SfxShell* pShell);

	ShellDescriptor CreateSubShell (
		SfxShell* pShell,
		ShellId nShellId,
		::Window* pParentWindow,
		FrameView* pFrameView);
	void DestroyViewShell (ShellDescriptor& rDescriptor);
	void DestroySubShell (
		const SfxShell& rViewShell,
		const ShellDescriptor& rDescriptor);
};


//===== ViewShellManager ======================================================

ViewShellManager::ViewShellManager (ViewShellBase& rBase)
	: mpImpl(new Implementation(*this,rBase)),
	  mbValid(true)
{
}


ViewShellManager::~ViewShellManager (void)
{
}


void ViewShellManager::AddSubShellFactory (
	ViewShell* pViewShell,
	const SharedShellFactory& rpFactory)
{
	if (mbValid)
		mpImpl->AddShellFactory(pViewShell, rpFactory);
}


void ViewShellManager::RemoveSubShellFactory (
	ViewShell* pViewShell,
	const SharedShellFactory& rpFactory)
{
	if (mbValid)
		mpImpl->RemoveShellFactory(pViewShell, rpFactory);
}


void ViewShellManager::ActivateViewShell (ViewShell* pViewShell)
{
	if (mbValid)
		return mpImpl->ActivateViewShell(pViewShell);
}


void ViewShellManager::DeactivateViewShell (const ViewShell* pShell)
{
	if (mbValid && pShell!=NULL)
		mpImpl->DeactivateViewShell(*pShell);
}


void ViewShellManager::MoveSubShellToTop (
	const ViewShell& rParentShell,
	ShellId nId)
{
	if (mbValid)
		mpImpl->MoveSubShellToTop(rParentShell, nId);
}


void ViewShellManager::SetFormShell (
	const ViewShell* pParentShell,
	FmFormShell* pFormShell,
	bool bAbove)
{
	if (mbValid)
		mpImpl->SetFormShell(pParentShell,pFormShell,bAbove);
}


void ViewShellManager::ActivateSubShell (const ViewShell& rViewShell, ShellId nId)
{
	if (mbValid)
		mpImpl->ActivateSubShell(rViewShell,nId);
}


void ViewShellManager::DeactivateSubShell (const ViewShell& rViewShell, ShellId nId)
{
	if (mbValid)
		mpImpl->DeactivateSubShell(rViewShell,nId);
}


void ViewShellManager::InvalidateAllSubShells (ViewShell* pViewShell)
{
	if (mbValid)
		mpImpl->InvalidateAllSubShells(pViewShell);
}


void ViewShellManager::ActivateShell (SfxShell* pShell)
{
	if (mbValid && pShell!=NULL)
		mpImpl->ActivateShell(*pShell);
}


void ViewShellManager::DeactivateShell (const SfxShell* pShell)
{
	if (mbValid && pShell!=NULL)
		mpImpl->DeactivateShell(*pShell);
}


void ViewShellManager::MoveToTop (const ViewShell& rParentShell)
{
	if (mbValid)
		mpImpl->MoveToTop(rParentShell);
}


SfxShell* ViewShellManager::GetShell (ShellId nId) const
{
	if (mbValid)
		return mpImpl->GetShell(nId);
	else
		return NULL;
}


SfxShell* ViewShellManager::GetTopShell (void) const
{
	if (mbValid)
		return mpImpl->GetTopShell();
	else
		return NULL;
}


void ViewShellManager::Shutdown (void)
{
	if (mbValid)
	{
		mpImpl->Shutdown();
		mbValid = false;
	}
}


void ViewShellManager::LockUpdate (void)
{
	mpImpl->LockUpdate();
}


void ViewShellManager::UnlockUpdate (void)
{
	mpImpl->UnlockUpdate();
}


//===== ViewShellManager::Implementation ======================================

ViewShellManager::Implementation::Implementation (
	ViewShellManager& rManager,
	ViewShellBase& rBase)
	: mrBase(rBase),
	  maMutex(),
	  maShellFactories(),
	  maActiveViewShells(),
	  mnUpdateLockCount(0),
	  mbKeepMainViewShellOnTop(false),
	  mbShellStackIsUpToDate(true),
	  mpFormShell(NULL),
	  mpFormShellParent(NULL),
	  mbFormShellAboveParent(true),
	  mpTopShell(NULL)
{
	(void)rManager;
}


ViewShellManager::Implementation::~Implementation (void)
{
	Shutdown();
}


void ViewShellManager::Implementation::AddShellFactory (
	const SfxShell* pViewShell,
	const SharedShellFactory& rpFactory)
{
	bool bAlreadyAdded (false);

	// Check that the given factory has not already been added.
	::std::pair<FactoryList::iterator,FactoryList::iterator> aRange(
		maShellFactories.equal_range(pViewShell));
	for (FactoryList::const_iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory)
		if (iFactory->second == rpFactory)
		{
			bAlreadyAdded = true;
			break;
		}

	// Add the factory if it is not already present.
	if ( ! bAlreadyAdded)
		maShellFactories.insert(FactoryList::value_type(pViewShell, rpFactory));
}


void ViewShellManager::Implementation::RemoveShellFactory (
	const SfxShell* pViewShell,
	const SharedShellFactory& rpFactory)
{
	::std::pair<FactoryList::iterator,FactoryList::iterator> aRange(
		maShellFactories.equal_range(pViewShell));
	for (FactoryList::iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory)
		if (iFactory->second == rpFactory)
		{
			maShellFactories.erase(iFactory);
			break;
		}
}


void ViewShellManager::Implementation::ActivateViewShell (ViewShell* pViewShell)
{
	::osl::MutexGuard aGuard (maMutex);

	ShellDescriptor aResult;
	aResult.mpShell = pViewShell;

	// Register as window listener so that the shells of the current
	// window can be moved to the top of the shell stack.
	if (aResult.mpShell != NULL)
	{
		::Window* pWindow = aResult.GetWindow();
		if (pWindow != NULL)
		{
			pWindow->AddEventListener(
				LINK(this, ViewShellManager::Implementation, WindowEventHandler));
			aResult.mbIsListenerAddedToWindow = true;
		}
		else
		{
			DBG_ASSERT(false,
				"ViewShellManager::ActivateViewShell: "
				"new view shell has no active window");
		}
	}

	ActivateShell(aResult);
}


void ViewShellManager::Implementation::DeactivateViewShell (const ViewShell& rShell)
{
	::osl::MutexGuard aGuard (maMutex);

	ActiveShellList::iterator iShell (::std::find_if (
		maActiveViewShells.begin(),
		maActiveViewShells.end(),
		IsShell(&rShell)));
	if (iShell != maActiveViewShells.end())
	{
		UpdateLock aLocker (*this);

		ShellDescriptor aDescriptor(*iShell);
		mrBase.GetDocShell()->Disconnect(dynamic_cast<ViewShell*>(aDescriptor.mpShell));
		maActiveViewShells.erase(iShell);
		TakeShellsFromStack(aDescriptor.mpShell);

		// Deactivate sub shells.
		SubShellList::iterator iList (maActiveSubShells.find(&rShell));
		if (iList != maActiveSubShells.end())
		{
			SubShellSubList& rList (iList->second);
			while ( ! rList.empty())
				DeactivateSubShell(rShell, rList.front().mnId);
		}

		DestroyViewShell(aDescriptor);
	}
}


void ViewShellManager::Implementation::ActivateShell (SfxShell& rShell)
{
	::osl::MutexGuard aGuard (maMutex);

	// Create a new shell or recycle on in the cache.
	ShellDescriptor aDescriptor;
	aDescriptor.mpShell = &rShell;

	ActivateShell(aDescriptor);
}


void ViewShellManager::Implementation::ActivateShell (const ShellDescriptor& rDescriptor)
{
	// Put shell on top of the active view shells.
	if (rDescriptor.mpShell != NULL)
	{
		// Determine where to put the view shell on the stack. By default
		// it is put on top of the stack. When the view shell of the center
		// pane is to be kept top most and the new view shell is not
		// displayed in the center pane then it is inserted at the position
		// one below the top.
		ActiveShellList::iterator iInsertPosition (maActiveViewShells.begin());
		if (iInsertPosition != maActiveViewShells.end()
			&& mbKeepMainViewShellOnTop
			&& ! rDescriptor.IsMainViewShell()
			&& iInsertPosition->IsMainViewShell())
		{
			++iInsertPosition;
		}
		maActiveViewShells.insert(
			iInsertPosition,
			rDescriptor);
	}
}


void ViewShellManager::Implementation::DeactivateShell (const SfxShell& rShell)
{
	::osl::MutexGuard aGuard (maMutex);

	ActiveShellList::iterator iShell (::std::find_if (
		maActiveViewShells.begin(),
		maActiveViewShells.end(),
		IsShell(&rShell)));
	if (iShell != maActiveViewShells.end())
	{
		UpdateLock aLocker (*this);

		ShellDescriptor aDescriptor(*iShell);
		mrBase.GetDocShell()->Disconnect(dynamic_cast<ViewShell*>(aDescriptor.mpShell));
		maActiveViewShells.erase(iShell);
		TakeShellsFromStack(aDescriptor.mpShell);

		// Deactivate sub shells.
		SubShellList::iterator iList (maActiveSubShells.find(&rShell));
		if (iList != maActiveSubShells.end())
		{
			SubShellSubList& rList (iList->second);
			while ( ! rList.empty())
				DeactivateSubShell(rShell, rList.front().mnId);
		}

		DestroyViewShell(aDescriptor);
	}
}


void ViewShellManager::Implementation::ActivateSubShell (
	const SfxShell& rParentShell,
	ShellId nId)
{
	::osl::MutexGuard aGuard (maMutex);

	do
	{
		// Check that the given view shell is active.
		ActiveShellList::iterator iShell (::std::find_if (
			maActiveViewShells.begin(),
			maActiveViewShells.end(),
			IsShell(&rParentShell)));
		if (iShell == maActiveViewShells.end())
			break;

		// Create the sub shell list if it does not yet exist.
		SubShellList::iterator iList (maActiveSubShells.find(&rParentShell));
		if (iList == maActiveSubShells.end())
			iList = maActiveSubShells.insert(
				SubShellList::value_type(&rParentShell,SubShellSubList())).first;

		// Do not activate an object bar that is already active. Requesting
		// this is not exactly an error but may be an indication of one.
		SubShellSubList& rList (iList->second);
		if (::std::find_if(rList.begin(),rList.end(), IsId(nId)) != rList.end())
			break;

		// Add just the id of the sub shell. The actual shell is created
		// later in CreateShells().
		UpdateLock aLock (*this);
		rList.push_back(ShellDescriptor(NULL, nId));
	}
	while (false);
}


void ViewShellManager::Implementation::DeactivateSubShell (
	const SfxShell& rParentShell,
	ShellId nId)
{
	::osl::MutexGuard aGuard (maMutex);

	do
	{
		// Check that the given view shell is active.
		SubShellList::iterator iList (maActiveSubShells.find(&rParentShell));
		if (iList == maActiveSubShells.end())
			break;

		// Look up the sub shell.
		SubShellSubList& rList (iList->second);
		SubShellSubList::iterator iShell (
			::std::find_if(rList.begin(),rList.end(), IsId(nId)));
		if (iShell == rList.end())
			break;
		SfxShell* pShell = iShell->mpShell;
		if (pShell == NULL)
			break;

		UpdateLock aLock (*this);

		ShellDescriptor aDescriptor(*iShell);
		// Remove the sub shell from both the internal structure as well as the
		// SFX shell stack above and including the sub shell.
		rList.erase(iShell);
		TakeShellsFromStack(pShell);

		DestroySubShell(rParentShell, aDescriptor);
	}
	while (false);
}


void ViewShellManager::Implementation::MoveSubShellToTop (
	const SfxShell& rParentShell,
	ShellId nId)
{
	SubShellList::iterator iList (maActiveSubShells.find(&rParentShell));
	if (iList != maActiveSubShells.end())
	{
		// Look up the sub shell.
		SubShellSubList& rList (iList->second);
		SubShellSubList::iterator iShell (
			::std::find_if(rList.begin(),rList.end(), IsId(nId)));
		if (iShell!=rList.end() && iShell!=rList.begin())
		{
			SubShellSubList::value_type aEntry (*iShell);
			rList.erase(iShell);
			rList.push_front(aEntry);
		}
	}
	else
	{
		// Ignore this call when there are no sub shells for the given
		// parent shell. We could remember the sub shell to move to the top
		// but we do not. Do call this method at a later time instead.
	}
}


void ViewShellManager::Implementation::MoveToTop (const SfxShell& rShell)
{
	::osl::MutexGuard aGuard (maMutex);

	// Check that we have access to a dispatcher. If not, then we are
	// (probably) called while the view shell is still being created or
	// initialized. Without dispatcher we can not rebuild the shell stack
	// to move the requested shell to the top. So return right away instead
	// of making a mess without being able to clean up afterwards.
	if (mrBase.GetDispatcher() == NULL)
		return;

	ActiveShellList::iterator iShell (::std::find_if (
		maActiveViewShells.begin(),
		maActiveViewShells.end(),
		IsShell(&rShell)));
	bool bMove = true;
	if (iShell != maActiveViewShells.end())
	{
		// Is the shell already at the top of the stack? We have to keep
		// the case in mind that mbKeepMainViewShellOnTop is true. Shells
		// that are not the main view shell are placed on the second-to-top
		// position in this case.
			if (iShell == maActiveViewShells.begin()
			&& (iShell->IsMainViewShell() || ! mbKeepMainViewShellOnTop))
		{
			// The shell is at the top position and is either a) the main
			// view shell or b) another shell but the main view shell is not
			// kept at the top position. We do not have to move the shell.
			bMove = false;
		}
		else if (iShell == ++maActiveViewShells.begin()
			&& ! iShell->IsMainViewShell()
			&& mbKeepMainViewShellOnTop)
		{
			// The shell is a the second-to-top position, not the main view
			// shell and the main view shell is kept at the top position.
			// Therefore we do not have to move the shell.
			bMove = false;
		}
	}
	else
	{
		// The shell is not on the stack. Therefore it can not be moved.
		// We could insert it but we don't. Use ActivateViewShell() for
		// that.
		bMove = false;
	}

	// When the shell is not at the right position it is removed from the
	// internal list of shells and inserted at the correct position.
	if (bMove)
	{
		UpdateLock aLock (*this);

		ShellDescriptor aDescriptor(*iShell);

		TakeShellsFromStack(&rShell);
		maActiveViewShells.erase(iShell);

		// Find out whether to insert at the top or one below.
		ActiveShellList::iterator aInsertPosition (maActiveViewShells.begin());
		if (mbKeepMainViewShellOnTop && ! aDescriptor.IsMainViewShell())
		{
			if (maActiveViewShells.back().IsMainViewShell())
				aInsertPosition++;
		}

		maActiveViewShells.insert(aInsertPosition, aDescriptor);
	}
}


SfxShell* ViewShellManager::Implementation::GetShell (ShellId nId) const
{
	::osl::MutexGuard aGuard (maMutex);

	SfxShell* pShell = NULL;

	// First search the active view shells.
	ActiveShellList::const_iterator iShell (
		::std::find_if (
		maActiveViewShells.begin(),
		maActiveViewShells.end(),
		IsId(nId)));
	if (iShell != maActiveViewShells.end())
		pShell = iShell->mpShell;
	else
	{
		// Now search the active sub shells of every active view shell.
		SubShellList::const_iterator iList;
		for (iList=maActiveSubShells.begin(); iList!=maActiveSubShells.end(); ++iList)
		{
			const SubShellSubList& rList (iList->second);
			SubShellSubList::const_iterator iSubShell(
				::std::find_if(rList.begin(),rList.end(), IsId(nId)));
			if (iSubShell != rList.end())
			{
				pShell = iSubShell->mpShell;
				break;
			}
		}
	}

	return pShell;
}


SfxShell* ViewShellManager::Implementation::GetTopShell (void) const
{
	OSL_ASSERT(mpTopShell == mrBase.GetSubShell(0));
	return mpTopShell;
}


void ViewShellManager::Implementation::LockUpdate (void)
{
	mnUpdateLockCount++;
}


void ViewShellManager::Implementation::UnlockUpdate (void)
{
	::osl::MutexGuard aGuard (maMutex);

	mnUpdateLockCount--;
	if (mnUpdateLockCount < 0)
	{
		// This should not happen.
		OSL_ASSERT (mnUpdateLockCount>=0);
		mnUpdateLockCount = 0;
	}
	if (mnUpdateLockCount == 0)
		UpdateShellStack();
}


/** Update the SFX shell stack (the portion that is visible to us) so that
	it matches the internal shell stack. This is done in six steps:
	1. Create the missing view shells and sub shells.
	2. Set up the internal shell stack.
	3. Get the SFX shell stack.
	4. Find the lowest shell in which the two stacks differ.
	5. Remove all shells above and including that shell from the SFX stack.
	6. Push all shells of the internal stack on the SFX shell stack that are
	not already present on the later.
*/
void ViewShellManager::Implementation::UpdateShellStack (void)
{
	::osl::MutexGuard aGuard (maMutex);

	// Remember the undo manager from the top-most shell on the stack.
	SfxShell* pTopMostShell = mrBase.GetSubShell(0);
	::svl::IUndoManager* pUndoManager = (pTopMostShell!=NULL)
		? pTopMostShell->GetUndoManager()
		: NULL;

	// 1. Create the missing shells.
	CreateShells();


	// 2. Create the internal target stack.
	ShellStack aTargetStack;
	CreateTargetStack(aTargetStack);


	// 3. Get SFX shell stack.
	ShellStack aSfxShellStack;
	sal_uInt16 nIndex (0);
	while (mrBase.GetSubShell(nIndex)!=NULL)
		++nIndex;
	aSfxShellStack.reserve(nIndex);
	while (nIndex-- > 0)
		aSfxShellStack.push_back(mrBase.GetSubShell(nIndex));


#ifdef VERBOSE
	OSL_TRACE("Current SFX Stack\r");
	DumpShellStack(aSfxShellStack);
	OSL_TRACE("Target Stack\r");
	DumpShellStack(aTargetStack);
#endif


	// 4. Find the lowest shell in which the two stacks differ.
	ShellStack::const_iterator iSfxShell (aSfxShellStack.begin());
	ShellStack::iterator iTargetShell (aTargetStack.begin());
	while (iSfxShell != aSfxShellStack.end()
		&& iTargetShell!=aTargetStack.end()
		&& (*iSfxShell)==(*iTargetShell))
	{
		++iSfxShell;
		++iTargetShell;
	}


	// 5. Remove all shells above and including the differing shell from the
	// SFX stack starting with the shell on top of the stack.
	while (iSfxShell != aSfxShellStack.end())
	{
		SfxShell* pShell = aSfxShellStack.back();
		aSfxShellStack.pop_back();
#ifdef VERBOSE
		OSL_TRACE("removing shell %p from stack\r", pShell);
#endif
		mrBase.RemoveSubShell(pShell);
	}


	// 6. Push shells from the given stack onto the SFX stack.
	mbShellStackIsUpToDate = false;
	while (iTargetShell != aTargetStack.end())
	{
#ifdef VERBOSE
		OSL_TRACE("pushing shell %p on stack\r", *iTargetShell);
#endif
		mrBase.AddSubShell(**iTargetShell);
		++iTargetShell;

		// The pushing of the shell on to the shell stack may have lead to
		// another invocation of this method. In this case we have to abort
		// pushing shells on the stack and return immediately.
		if (mbShellStackIsUpToDate)
			break;
	}
	if (mrBase.GetDispatcher() != NULL)
		mrBase.GetDispatcher()->Flush();

	// Update the pointer to the top-most shell and set its undo manager
	// to the one of the previous top-most shell.
	mpTopShell = mrBase.GetSubShell(0);
	if (mpTopShell!=NULL && pUndoManager!=NULL && mpTopShell->GetUndoManager()==NULL)
		mpTopShell->SetUndoManager(pUndoManager);

	// Finally tell an invocation of this method on a higher level that it can (has
	// to) abort and return immediately.
	mbShellStackIsUpToDate = true;

#ifdef VERBOSE
	OSL_TRACE("New current stack\r");
	DumpSfxShellStack();
#endif
}


void ViewShellManager::Implementation::TakeShellsFromStack (const SfxShell* pShell)
{
	::osl::MutexGuard aGuard (maMutex);

	// Remember the undo manager from the top-most shell on the stack.
	SfxShell* pTopMostShell = mrBase.GetSubShell(0);
	::svl::IUndoManager* pUndoManager = (pTopMostShell!=NULL)
		? pTopMostShell->GetUndoManager()
		: NULL;

#ifdef VERBOSE
	OSL_TRACE("TakeShellsFromStack(%p)\r", pShell);
	DumpSfxShellStack();
#endif

	// 0.Make sure that the given shell is on the stack. This is a
	// preparation for the following assertion.
	for (sal_uInt16 nIndex=0; true; nIndex++)
	{
		SfxShell* pShellOnStack = mrBase.GetSubShell(nIndex);
		if (pShellOnStack == NULL)
		{
			// Set pShell to NULL to indicate the following code that the
			// shell is not on the stack.
			pShell = NULL;
			break;
		}
		else if (pShellOnStack == pShell)
			break;
	}

	if (pShell != NULL)
	{
		// 1. Deactivate our shells on the stack before they are removed so
		// that during the Deactivation() calls the stack is still intact.
		for (sal_uInt16 nIndex=0; true; nIndex++)
		{
			SfxShell* pShellOnStack = mrBase.GetSubShell(nIndex);
			Deactivate(pShellOnStack);
			if (pShellOnStack == pShell)
				break;
		}

		// 2. Remove the shells from the stack.
		while (true)
		{
			SfxShell* pShellOnStack = mrBase.GetSubShell(0);
#ifdef VERBOSE
			OSL_TRACE("removing shell %p from stack\r", pShellOnStack);
#endif
			mrBase.RemoveSubShell(pShellOnStack);
			if (pShellOnStack == pShell)
				break;
		}

		// 3. Update the stack.
		if (mrBase.GetDispatcher() != NULL)
			mrBase.GetDispatcher()->Flush();

		// Update the pointer to the top-most shell and set its undo manager
		// to the one of the previous top-most shell.
		mpTopShell = mrBase.GetSubShell(0);
		if (mpTopShell!=NULL && pUndoManager!=NULL && mpTopShell->GetUndoManager()==NULL)
			mpTopShell->SetUndoManager(pUndoManager);
	}

#ifdef VERBOSE
	OSL_TRACE("Sfx shell stack is:\r");
	DumpSfxShellStack();
#endif
}


void ViewShellManager::Implementation::CreateShells (void)
{
	::osl::MutexGuard aGuard (maMutex);

	// Iterate over all view shells.
	ShellStack aShellStack;
	ActiveShellList::reverse_iterator iShell;
	for (iShell=maActiveViewShells.rbegin(); iShell!=maActiveViewShells.rend(); ++iShell)
	{
		// Get the list of associated sub shells.
		SubShellList::iterator iList (maActiveSubShells.find(iShell->mpShell));
		if (iList != maActiveSubShells.end())
		{
			SubShellSubList& rList (iList->second);

			// Iterate over all sub shells of the current view shell.
			SubShellSubList::iterator iSubShell;
			for (iSubShell=rList.begin(); iSubShell!=rList.end(); ++iSubShell)
			{
				if (iSubShell->mpShell == NULL)
				{
					*iSubShell = CreateSubShell(iShell->mpShell,iSubShell->mnId,NULL,NULL);
				}
			}
		}
	}
}


void ViewShellManager::Implementation::CreateTargetStack (ShellStack& rStack) const
{
	// Create a local stack of the shells that are to push on the shell
	// stack. We can thus safely create the required shells while still
	// having a valid shell stack.
	for (ActiveShellList::const_reverse_iterator iViewShell (maActiveViewShells.rbegin());
		 iViewShell != maActiveViewShells.rend();
		 ++iViewShell)
	{
		// Possibly place the form shell below the current view shell.
		if ( ! mbFormShellAboveParent
			&& mpFormShell!=NULL
			&& iViewShell->mpShell==mpFormShellParent)
		{
			rStack.push_back(mpFormShell);
		}

		// Put the view shell itself on the local stack.
		rStack.push_back (iViewShell->mpShell);

		// Possibly place the form shell above the current view shell.
		if (mbFormShellAboveParent
			&& mpFormShell!=NULL
			&& iViewShell->mpShell==mpFormShellParent)
		{
			rStack.push_back(mpFormShell);
		}

		// Add all other sub shells.
		SubShellList::const_iterator iList (maActiveSubShells.find(iViewShell->mpShell));
		if (iList != maActiveSubShells.end())
		{
			const SubShellSubList& rList (iList->second);
			SubShellSubList::const_reverse_iterator iSubShell;
			for (iSubShell=rList.rbegin(); iSubShell!=rList.rend(); ++iSubShell)
				if (iSubShell->mpShell != mpFormShell)
					rStack.push_back(iSubShell->mpShell);
		}
	}
}


IMPL_LINK(ViewShellManager::Implementation, WindowEventHandler, VclWindowEvent*, pEvent)
{
	if (pEvent != NULL)
	{
		::Window* pEventWindow
			= static_cast<VclWindowEvent*>(pEvent)->GetWindow();

		switch (pEvent->GetId())
		{
			case VCLEVENT_WINDOW_GETFOCUS:
			{
				for (ActiveShellList::iterator aI(maActiveViewShells.begin());
					 aI!=maActiveViewShells.end();
					 aI++)
				{
					if (pEventWindow == static_cast< ::Window*>(aI->GetWindow()))
					{
						MoveToTop(*aI->mpShell);
						break;
					}
				}
			}
			break;

			case VCLEVENT_WINDOW_LOSEFOCUS:
				break;

			case VCLEVENT_OBJECT_DYING:
				// Remember that we do not have to remove the window
				// listener for this window.
				for (ActiveShellList::iterator
						iShell(maActiveViewShells.begin()),
						iEnd(maActiveViewShells.end());
					iShell!=iEnd;
					++iShell)
				{
					if (iShell->GetWindow() == pEventWindow)
					{
						iShell->mbIsListenerAddedToWindow = false;
						break;
					}
				}
				break;
		}
	}
	return sal_True;
}


ShellDescriptor ViewShellManager::Implementation::CreateSubShell (
	SfxShell* pParentShell,
	ShellId nShellId,
	::Window* pParentWindow,
	FrameView* pFrameView)
{
	::osl::MutexGuard aGuard (maMutex);
	ShellDescriptor aResult;

	// Look up the factories for the parent shell.
	::std::pair<FactoryList::iterator,FactoryList::iterator> aRange(
		maShellFactories.equal_range(pParentShell));

	// Try all factories to create the shell.
	for (FactoryList::const_iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory)
	{
		SharedShellFactory pFactory = iFactory->second;
		if( bool(pFactory))
			aResult.mpShell = pFactory->CreateShell(nShellId, pParentWindow, pFrameView);

		// Exit the loop when the shell has been successfully created.
		if (aResult.mpShell != NULL)
		{
			aResult.mpFactory = pFactory;
			aResult.mnId = nShellId;
			break;
		}
	}

	return aResult;
}


void ViewShellManager::Implementation::DestroyViewShell (
	ShellDescriptor& rDescriptor)
{
	OSL_ASSERT(rDescriptor.mpShell != NULL);

	if (rDescriptor.mbIsListenerAddedToWindow)
	{
		rDescriptor.mbIsListenerAddedToWindow = false;
		::Window* pWindow = rDescriptor.GetWindow();
		if (pWindow != NULL)
		{
			pWindow->RemoveEventListener(
				LINK(this, ViewShellManager::Implementation, WindowEventHandler));
		}
	}

	// Destroy the sub shell factories.
	::std::pair<FactoryList::iterator,FactoryList::iterator> aRange(
		maShellFactories.equal_range(rDescriptor.mpShell));
	if (aRange.first != maShellFactories.end())
		maShellFactories.erase(aRange.first, aRange.second);

	// Release the shell.
	if (rDescriptor.mpFactory.get() != NULL)
		rDescriptor.mpFactory->ReleaseShell(rDescriptor.mpShell);
}


void ViewShellManager::Implementation::DestroySubShell (
	const SfxShell& rParentShell,
	const ShellDescriptor& rDescriptor)
{
	(void)rParentShell;
	OSL_ASSERT(rDescriptor.mpFactory.get() != NULL);
	rDescriptor.mpFactory->ReleaseShell(rDescriptor.mpShell);
}


void ViewShellManager::Implementation::InvalidateAllSubShells (const SfxShell* pParentShell)
{
	::osl::MutexGuard aGuard (maMutex);

	SubShellList::iterator iList (maActiveSubShells.find(pParentShell));
	if (iList != maActiveSubShells.end())
	{
		SubShellSubList& rList (iList->second);
		SubShellSubList::iterator iShell;
		for (iShell=rList.begin(); iShell!=rList.end(); ++iShell)
			if (iShell->mpShell != NULL)
				iShell->mpShell->Invalidate();
	}
}


void ViewShellManager::Implementation::Shutdown (void)
{
	::osl::MutexGuard aGuard (maMutex);

	// Take stacked shells from stack.
	if ( ! maActiveViewShells.empty())
	{
		UpdateLock aLock (*this);


		while ( ! maActiveViewShells.empty())
		{
			SfxShell* pShell = maActiveViewShells.front().mpShell;
			if (pShell != NULL)
			{
				ViewShell* pViewShell = dynamic_cast<ViewShell*>(pShell);
				if (pViewShell != NULL)
					DeactivateViewShell(*pViewShell);
				else
					DeactivateShell(*pShell);
			}
			else
			{
				DBG_ASSERT(false,
					"ViewShellManager::Implementation::Shutdown(): empty active shell descriptor");
				maActiveViewShells.pop_front();
			}
		}
	}
	mrBase.RemoveSubShell (NULL);

	maShellFactories.clear();
}


#ifdef VERBOSE
void ViewShellManager::Implementation::DumpShellStack (const ShellStack& rStack)
{
	ShellStack::const_reverse_iterator iEntry;
	for (iEntry=rStack.rbegin(); iEntry!=rStack.rend(); ++iEntry)
		if (*iEntry != NULL)
			OSL_TRACE ("    %p : %s\r",
				*iEntry,
				::rtl::OUStringToOString((*iEntry)->GetName(),RTL_TEXTENCODING_UTF8).getStr());
		else
			OSL_TRACE("     null\r");
}


void ViewShellManager::Implementation::DumpSfxShellStack (void)
{
	ShellStack aSfxShellStack;
	sal_uInt16 nIndex (0);
	while (mrBase.GetSubShell(nIndex)!=NULL)
		++nIndex;
	aSfxShellStack.reserve(nIndex);
	while (nIndex-- > 0)
		aSfxShellStack.push_back(mrBase.GetSubShell(nIndex));
	DumpShellStack(aSfxShellStack);
}
#endif


void ViewShellManager::Implementation::Deactivate (SfxShell* pShell)
{
	OSL_ASSERT(pShell!=NULL);

	// We have to end a text edit for view shells that are to be taken from
	// the shell stack.
	ViewShell* pViewShell = dynamic_cast<ViewShell*>(pShell);
	if (pViewShell != NULL)
	{
		sd::View* pView = pViewShell->GetView();
		if (pView!=NULL && pView->IsTextEdit())
		{
			pView->SdrEndTextEdit();
			pView->UnmarkAll();
			pViewShell->GetViewFrame()->GetDispatcher()->Execute(
				SID_OBJECT_SELECT,
				SFX_CALLMODE_ASYNCHRON);
		}
	}

	// Now we can deactivate the shell.
	pShell->Deactivate(sal_True);
}


void ViewShellManager::Implementation::SetFormShell (
	const ViewShell* pFormShellParent,
	FmFormShell* pFormShell,
	bool bFormShellAboveParent)
{
	::osl::MutexGuard aGuard (maMutex);

	mpFormShellParent = pFormShellParent;
	mpFormShell = pFormShell;
	mbFormShellAboveParent = bFormShellAboveParent;
}


namespace {

ShellDescriptor::ShellDescriptor (void)
	: mpShell(NULL),
	  mnId(0),
	  mpFactory(),
	  mbIsListenerAddedToWindow(false)
{
}


ShellDescriptor::ShellDescriptor (
	SfxShell* pShell,
	ShellId nId)
	: mpShell(pShell),
	  mnId(nId),
	  mpFactory(),
	  mbIsListenerAddedToWindow(false)
{
}


ShellDescriptor::ShellDescriptor (const ShellDescriptor& rDescriptor)
	: mpShell(rDescriptor.mpShell),
	  mnId(rDescriptor.mnId),
	  mpFactory(rDescriptor.mpFactory),
	  mbIsListenerAddedToWindow(rDescriptor.mbIsListenerAddedToWindow)
{
}


ShellDescriptor& ShellDescriptor::operator= (const ShellDescriptor& rDescriptor)
{
	if (this != &rDescriptor)
	{
		mpShell = rDescriptor.mpShell;
		mnId = rDescriptor.mnId;
		mpFactory = rDescriptor.mpFactory;
		mbIsListenerAddedToWindow = rDescriptor.mbIsListenerAddedToWindow;
	}
	return *this;
}


bool ShellDescriptor::IsMainViewShell (void) const
{
	ViewShell* pViewShell = dynamic_cast<ViewShell*>(mpShell);
	if (pViewShell != NULL)
		return pViewShell->IsMainViewShell();
	else
		return false;
}


::Window* ShellDescriptor::GetWindow (void) const
{
	ViewShell* pViewShell = dynamic_cast<ViewShell*>(mpShell);
	if (pViewShell != NULL)
		return pViewShell->GetActiveWindow();
	else
		return NULL;
}


} // end of anonymous namespace

} // end of namespace sd