slidesorter/view/SlideSorterView.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.
 *
 *************************************************************/


#include "precompiled_sd.hxx"

#include "view/SlideSorterView.hxx"

#include "ViewShellBase.hxx"
#include "SlideSorter.hxx"
#include "SlideSorterViewShell.hxx"
#include "ViewShell.hxx"
#include "SlsViewCacheContext.hxx"
#include "SlsLayeredDevice.hxx"
#include "view/SlsLayouter.hxx"
#include "view/SlsPageObjectLayouter.hxx"
#include "view/SlsPageObjectPainter.hxx"
#include "view/SlsILayerPainter.hxx"
#include "view/SlsButtonBar.hxx"
#include "view/SlsToolTip.hxx"
#include "controller/SlideSorterController.hxx"
#include "controller/SlsProperties.hxx"
#include "controller/SlsClipboard.hxx"
#include "model/SlideSorterModel.hxx"
#include "model/SlsPageEnumerationProvider.hxx"
#include "model/SlsPageDescriptor.hxx"
#include "cache/SlsPageCache.hxx"
#include "cache/SlsPageCacheManager.hxx"
#include "cache/SlsCacheContext.hxx"
#include "taskpane/SlideSorterCacheDisplay.hxx"
#include "DrawDocShell.hxx"
#include "PaneDockingWindow.hxx"

#include "drawdoc.hxx"
#include "sdpage.hxx"
#include "Window.hxx"
#include "sdresid.hxx"
#include "glob.hrc"

#include <svl/itempool.hxx>
#include <svx/svdpagv.hxx>
#include <svx/svdopage.hxx>
#include <svx/xlndsit.hxx>
#include <svx/xlnclit.hxx>
#include <vcl/svapp.hxx>
#include <vcl/scrbar.hxx>
#include <tools/poly.hxx>
#include <vcl/lineinfo.hxx>
#include <algorithm>
#include <svx/sdrpagewindow.hxx>
#include <svl/itempool.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <canvas/elapsedtime.hxx>

//#define DEBUG_TIMING
#include <svl/itempool.hxx>
#ifdef DEBUG_TIMING
#include <vector>
#endif
#include <boost/foreach.hpp>


using namespace std;
using namespace ::sd::slidesorter::model;
using namespace ::drawinglayer::primitive2d;


namespace sd { namespace slidesorter { namespace view {

namespace {
	/** Wrapper around the SlideSorterView that supports the IPainter
		interface and that allows the LayeredDevice to hold the
		SlideSorterView (held as scoped_ptr by the SlideSorter) as
		shared_ptr.
	*/
	class Painter : public ILayerPainter
	{
	public:
		Painter (SlideSorterView& rView) : mrView(rView) {}
		virtual ~Painter (void) {}

		virtual void Paint (OutputDevice& rDevice, const Rectangle& rRepaintArea)
		{
			mrView.Paint(rDevice,rRepaintArea);
		}

		virtual void SetLayerInvalidator (const SharedILayerInvalidator&) {}

	private:
		SlideSorterView& mrView;
	};
}


class BackgroundPainter
	: public ILayerPainter,
	  public ::boost::noncopyable
{
public:
	BackgroundPainter (const Color aBackgroundColor) : maBackgroundColor(aBackgroundColor) {}
	virtual ~BackgroundPainter (void) {}

	virtual void Paint (OutputDevice& rDevice, const Rectangle& rRepaintArea)
	{
		rDevice.SetFillColor(maBackgroundColor);
		rDevice.SetLineColor();
		rDevice.DrawRect(rRepaintArea);
	}

	virtual void SetLayerInvalidator (const SharedILayerInvalidator&) {}

	void SetColor (const Color aColor) { maBackgroundColor = aColor; }

private:
	Color maBackgroundColor;
};


TYPEINIT1(SlideSorterView, ::sd::View);

SlideSorterView::SlideSorterView (SlideSorter& rSlideSorter)
	: ::sd::View (
		  rSlideSorter.GetModel().GetDocument(),
		  rSlideSorter.GetContentWindow().get(),
		  rSlideSorter.GetViewShell()),
	  mrSlideSorter(rSlideSorter),
	  mrModel(rSlideSorter.GetModel()),
	  mbIsDisposed(false),
	  mpLayouter (new Layouter(rSlideSorter.GetContentWindow(), rSlideSorter.GetTheme())),
	  mbPageObjectVisibilitiesValid (false),
	  mpPreviewCache(),
	  mpLayeredDevice(new LayeredDevice(rSlideSorter.GetContentWindow())),
	  maVisiblePageRange(-1,-1),
	  mbModelChangedWhileModifyEnabled(true),
	  maPreviewSize(0,0),
	  mbPreciousFlagUpdatePending(true),
	  meOrientation(Layouter::GRID),
	  mpProperties(rSlideSorter.GetProperties()),
	  mpPageUnderMouse(),
	  mnButtonUnderMouse(-1),
	  mpPageObjectPainter(),
	  mpSelectionPainter(),
	  mpBackgroundPainter(
		new BackgroundPainter(mrSlideSorter.GetTheme()->GetColor(Theme::Color_Background))),
	  mpButtonBar(new ButtonBar(mrSlideSorter)),
	  mpToolTip(new ToolTip(mrSlideSorter)),
	  mbIsRearrangePending(true),
	  maVisibilityChangeListeners()
{
	// Hide the page that contains the page objects.
	SetPageVisible (sal_False);

	// Register the background painter on level 1 to avoid the creation of a
	// background buffer.
	mpLayeredDevice->RegisterPainter(mpBackgroundPainter, 1);

	// Wrap a shared_ptr-held-wrapper around this view and register it as
	// painter at the layered device. There is no explicit destruction: in
	// the SlideSorterView destructor the layered device is destroyed and
	// with it the only reference to the wrapper which therefore is also
	// destroyed.
	SharedILayerPainter pPainter (new Painter(*this));

	// The painter is placed on level 1 to avoid buffering. This should be
	// a little faster during animations because the previews are painted
	// directly into the window, not via the buffer.
	mpLayeredDevice->RegisterPainter(pPainter, 1);
}


SlideSorterView::~SlideSorterView (void)
{
	if ( ! mbIsDisposed)
	{
		OSL_ASSERT(mbIsDisposed);
		Dispose();
	}
}


void SlideSorterView::Init (void)
{
	HandleModelChange();
}


void SlideSorterView::Dispose (void)
{
	mpSelectionPainter.reset();

	mpLayeredDevice->Dispose();
	mpPreviewCache.reset();

	SetPageUnderMouse(SharedPageDescriptor(),false);

	// Hide the page to avoid problems in the view when deleting
	// visualized objects
	HideSdrPage();

	// Deletion of the objects and the page will be done in SdrModel
	// destructor (as long as objects and pages are added)

	OSL_ASSERT(mpLayeredDevice.unique());
	mpLayeredDevice.reset();

	mbIsDisposed = true;
}


sal_Int32 SlideSorterView::GetPageIndexAtPoint (const Point& rWindowPosition) const
{
	sal_Int32 nIndex (-1);

	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		nIndex = mpLayouter->GetIndexAtPoint(pWindow->PixelToLogic(rWindowPosition), false, false);

		// Clip the page index against the page count.
		if (nIndex >= mrModel.GetPageCount())
			nIndex = -1;
	}

	return nIndex;
}


Layouter& SlideSorterView::GetLayouter (void)
{
	return *mpLayouter.get();
}


void SlideSorterView::ModelHasChanged (void)
{
	// Ignore this call. Rely on hints sent by the model to get informed of
	// model changes.
}


void SlideSorterView::LocalModelHasChanged(void)
{
	mbModelChangedWhileModifyEnabled = false;

	// First call our base class.
	View::ModelHasChanged ();
}


void SlideSorterView::PreModelChange (void)
{
	// Reset the slide under the mouse. It will be re-set in PostModelChange().
	SetPageUnderMouse(SharedPageDescriptor());
}


void SlideSorterView::PostModelChange (void)
{
	// In PreModelChange() the page objects have been released. Here we
	// create new ones.
	::osl::MutexGuard aGuard (mrModel.GetMutex());

	model::PageEnumeration aPageEnumeration (
		model::PageEnumerationProvider::CreateAllPagesEnumeration(mrModel));

	// The new page objects have to be scaled and positioned.
	RequestRearrange();
	RequestRepaint();
}


/** At the moment for every model change all page objects are destroyed and
	re-created again. This can be optimized by accepting hints that
	describe the type of change so that existing page objects can be
	reused.
*/
void SlideSorterView::HandleModelChange (void)
{
	PreModelChange ();
	PostModelChange();
}


void SlideSorterView::HandleDrawModeChange (void)
{
	// Replace the preview cache with a new and empty one. The
	// PreviewRenderer that is used by the cache is replaced by this as
	// well.
	mpPreviewCache.reset();
	GetPreviewCache()->InvalidateCache(true);

	RequestRepaint();
}


void SlideSorterView::HandleDataChangeEvent (void)
{
	GetPageObjectPainter()->SetTheme(mrSlideSorter.GetTheme());

	// Update the color used by the background painter.
	::boost::shared_ptr<BackgroundPainter> pPainter (
		::boost::dynamic_pointer_cast<BackgroundPainter>(mpBackgroundPainter));
	if (pPainter)
		pPainter->SetColor(mrSlideSorter.GetTheme()->GetColor(Theme::Color_Background));

	if (mpButtonBar)
		mpButtonBar->HandleDataChangeEvent();

	RequestRepaint();
}


void SlideSorterView::Resize (void)
{
	UpdateOrientation();

	mpLayeredDevice->Resize();
	RequestRearrange();
}


void SlideSorterView::RequestRearrange (void)
{
	mbIsRearrangePending = true;
	Rearrange();
}


void SlideSorterView::Rearrange (void)
{
	if ( ! mbIsRearrangePending)
		return;
	if (mrModel.GetPageCount() <= 0)
		return;

	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if ( ! pWindow)
		return;
	const Size aWindowSize (pWindow->GetSizePixel());
	if (aWindowSize.Width()<=0 || aWindowSize.Height()<=0)
		return;

	const bool bRearrangeSuccess (
		mpLayouter->Rearrange (
			meOrientation,
			aWindowSize,
			mrModel.GetPageDescriptor(0)->GetPage()->GetSize(),
			mrModel.GetPageCount()));
	if (bRearrangeSuccess)
	{
		mbIsRearrangePending = false;
		Layout();
		UpdatePageUnderMouse(false);
		//		RequestRepaint();
	}
}


void SlideSorterView::UpdateOrientation (void)
{
	// The layout of slides depends on whether the slide sorter is
	// displayed in the center or the side pane.
	if (mrSlideSorter.GetViewShell()->IsMainViewShell())
		SetOrientation(Layouter::GRID);
	else
	{
		// Get access to the docking window.
		::Window* pWindow = mrSlideSorter.GetContentWindow().get();
		PaneDockingWindow* pDockingWindow = NULL;
		while (pWindow!=NULL && pDockingWindow==NULL)
		{
			pDockingWindow = dynamic_cast<PaneDockingWindow*>(pWindow);
			pWindow = pWindow->GetParent();
		}

		if (pDockingWindow != NULL)
		{
			const long nScrollBarSize (
				Application::GetSettings().GetStyleSettings().GetScrollBarSize());
			switch (pDockingWindow->GetOrientation())
			{
				case PaneDockingWindow::HorizontalOrientation:
					if (SetOrientation(Layouter::HORIZONTAL))
					{
						const Range aRange (mpLayouter->GetValidVerticalSizeRange());
						pDockingWindow->SetValidSizeRange(Range(
							aRange.Min() + nScrollBarSize,
							aRange.Max() + nScrollBarSize));
					}
					break;

				case PaneDockingWindow::VerticalOrientation:
					if (SetOrientation(Layouter::VERTICAL))
					{
						const Range aRange (mpLayouter->GetValidHorizontalSizeRange());
						pDockingWindow->SetValidSizeRange(Range(
							aRange.Min() + nScrollBarSize,
							aRange.Max() + nScrollBarSize));
					}
					break;

				case PaneDockingWindow::UnknownOrientation:
					if (SetOrientation(Layouter::GRID))
					{
						const sal_Int32 nAdditionalSize (10);
						pDockingWindow->SetMinOutputSizePixel(Size(
							mpLayouter->GetValidHorizontalSizeRange().Min()
								+ nScrollBarSize
								+ nAdditionalSize,
							mpLayouter->GetValidVerticalSizeRange().Min()
								+ nScrollBarSize
								+ nAdditionalSize));
					}
					return;
			}
		}
		else
		{
			// We are not placed in a docking window. One possible reason
			// is that the slide sorter is temporarily into a cache and was
			// reparented to a non-docking window.
			SetOrientation(Layouter::GRID);
		}
	}
}


void SlideSorterView::Layout ()
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		// Set the model area, i.e. the smallest rectangle that includes all
		// page objects.
		const Rectangle aViewBox (mpLayouter->GetTotalBoundingBox());
		pWindow->SetViewOrigin (aViewBox.TopLeft());
		pWindow->SetViewSize (aViewBox.GetSize());

		::boost::shared_ptr<PageObjectLayouter> pPageObjectLayouter(
			mpLayouter->GetPageObjectLayouter());
		if (pPageObjectLayouter)
		{
			const Size aNewPreviewSize (mpLayouter->GetPageObjectLayouter()->GetSize(
				PageObjectLayouter::Preview,
				PageObjectLayouter::WindowCoordinateSystem));
			if (maPreviewSize != aNewPreviewSize && GetPreviewCache())
			{
				mpPreviewCache->ChangeSize(aNewPreviewSize, true);
				maPreviewSize = aNewPreviewSize;
			}
		}

		// Iterate over all page objects and place them relative to the
		// containing page.
		model::PageEnumeration aPageEnumeration (
			model::PageEnumerationProvider::CreateAllPagesEnumeration(mrModel));
		while (aPageEnumeration.HasMoreElements())
		{
			model::SharedPageDescriptor pDescriptor (aPageEnumeration.GetNextElement());
			pDescriptor->SetBoundingBox(mpLayouter->GetPageObjectBox(pDescriptor->GetPageIndex()));
		}

		GetPageObjectPainter()->NotifyResize();
	}

	InvalidatePageObjectVisibilities ();
}


void SlideSorterView::InvalidatePageObjectVisibilities (void)
{
	mbPageObjectVisibilitiesValid = false;
}


void SlideSorterView::DeterminePageObjectVisibilities (void)
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		// Set this flag to true here so that an invalidate during the
		// visibility calculation can correctly invalidate it again.
		mbPageObjectVisibilitiesValid = true;

		Rectangle aViewArea (pWindow->PixelToLogic(Rectangle(Point(0,0),pWindow->GetSizePixel())));
		const Range aRange (mpLayouter->GetRangeOfVisiblePageObjects(aViewArea));
		const Range aUnion(
			::std::min(maVisiblePageRange.Min(), aRange.Min()),
			::std::max(maVisiblePageRange.Max(), aRange.Max()));

		// For page objects that just dropped off the visible area we
		// decrease the priority of pending requests for preview bitmaps.
		if (maVisiblePageRange != aRange)
			mbPreciousFlagUpdatePending |= true;

		model::SharedPageDescriptor pDescriptor;
		for (int nIndex=aUnion.Min(); nIndex<=aUnion.Max(); nIndex++)
		{
			pDescriptor = mrModel.GetPageDescriptor(nIndex);
			if (pDescriptor.get() != NULL)
				SetState(
					pDescriptor,
					PageDescriptor::ST_Visible,
					aRange.IsInside(nIndex));
		}

		// Broadcast a change of the set of visible page objects.
		if (maVisiblePageRange != aRange)
		{
			maVisiblePageRange = aRange;

			// Tell the listeners that the visibility of some objects has
			// changed.
			::std::vector<Link>& aChangeListeners (maVisibilityChangeListeners);
			for (::std::vector<Link>::const_iterator
					  iLink(aChangeListeners.begin()),
					  iEnd(aChangeListeners.end());
				 iLink!=iEnd;
				 ++iLink)
			{
				iLink->Call(NULL);
			}
		}


		// Restore the mouse over state.
		UpdatePageUnderMouse(true);
	}
}


void SlideSorterView::UpdatePreciousFlags (void)
{
	if (mbPreciousFlagUpdatePending)
	{
		mbPreciousFlagUpdatePending = false;

		model::SharedPageDescriptor pDescriptor;
		::boost::shared_ptr<cache::PageCache> pCache = GetPreviewCache();
		sal_Int32 nPageCount (mrModel.GetPageCount());

		for (int nIndex=0; nIndex<=nPageCount; ++nIndex)
		{
			pDescriptor = mrModel.GetPageDescriptor(nIndex);
			if (pDescriptor.get() != NULL)
			{
				pCache->SetPreciousFlag(
					pDescriptor->GetPage(),
					maVisiblePageRange.IsInside(nIndex));
				SSCD_SET_VISIBILITY(mrModel.GetDocument(), nIndex,
					maVisiblePageRange.IsInside(nIndex));
			}
			else
			{
				// At least one cache entry can not be updated. Remember to
				// repeat the whole updating later and leave the loop now.
				mbPreciousFlagUpdatePending = true;
				break;
			}
		}
	}
}


bool SlideSorterView::SetOrientation (const Layouter::Orientation eOrientation)
{
	if (meOrientation != eOrientation)
	{
		meOrientation = eOrientation;
		return true;
	}
	else
		return false;
}


Layouter::Orientation SlideSorterView::GetOrientation (void) const
{
	return meOrientation;
}


void SlideSorterView::RequestRepaint (void)
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		mpLayeredDevice->InvalidateAllLayers(
			Rectangle(
				pWindow->PixelToLogic(Point(0,0)),
				pWindow->PixelToLogic(pWindow->GetSizePixel())));
		pWindow->Invalidate();
	}
}


void SlideSorterView::RequestRepaint (const model::SharedPageDescriptor& rpDescriptor)
{
	if (rpDescriptor)
		RequestRepaint(rpDescriptor->GetBoundingBox());
}


void SlideSorterView::RequestRepaint (const Rectangle& rRepaintBox)
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		mpLayeredDevice->InvalidateAllLayers(rRepaintBox);
		pWindow->Invalidate(rRepaintBox);
	}
}


void SlideSorterView::RequestRepaint (const Region& rRepaintRegion)
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow)
	{
		mpLayeredDevice->InvalidateAllLayers(rRepaintRegion);
		pWindow->Invalidate(rRepaintRegion);
	}
}


Rectangle SlideSorterView::GetModelArea (void)
{
	return mpLayouter->GetTotalBoundingBox();
}


#ifdef DEBUG_TIMING
static ::canvas::tools::ElapsedTime gaTimer;
static const size_t gFrameTimeCount (10);
static size_t gFrameTimeIndex (0);
static ::std::vector<double> gFrameTimes (gFrameTimeCount, 0);
static double gFrameTimeSum (0);
static const Rectangle gFrameTimeBox (10,10,150,20);
static double gnLastFrameStart = 0;
#endif

void SlideSorterView::CompleteRedraw (
	OutputDevice* pDevice,
	const Region& rPaintArea,
	sdr::contact::ViewObjectContactRedirector* pRedirector)
{
	(void)pRedirector;
#ifdef DEBUG_TIMING
	const double nStartTime (gaTimer.getElapsedTime());
	OSL_TRACE("SlideSorterView::CompleteRedraw start at %f, %s",
		nStartTime,
		mnLockRedrawSmph ? "locked" : "");
#endif

	if (pDevice == NULL || pDevice!=mrSlideSorter.GetContentWindow().get())
		return;

	// The parent implementation of CompleteRedraw is called only when
	// painting is locked. We do all the painting ourself. When painting
	// is locked the parent implementation keeps track of the repaint
	// requests and later, when painting is unlocked, calls CompleteRedraw
	// for all missed repaints.

	if (mnLockRedrawSmph == 0)
	{
		mrSlideSorter.GetContentWindow()->IncrementLockCount();
		if (mpLayeredDevice->HandleMapModeChange())
			DeterminePageObjectVisibilities();
		mpLayeredDevice->Repaint(rPaintArea);
		mrSlideSorter.GetContentWindow()->DecrementLockCount();
	}
	else
	{
		maRedrawRegion.Union(rPaintArea);
	}

#ifdef DEBUG_TIMING
	const double nEndTime (gaTimer.getElapsedTime());
	OSL_TRACE("SlideSorterView::CompleteRedraw end at %f after %fms", nEndTime, (nEndTime-nStartTime)*1000);
	gFrameTimeSum -= gFrameTimes[gFrameTimeIndex];
	gFrameTimes[gFrameTimeIndex] = nStartTime - gnLastFrameStart;
	gnLastFrameStart = nStartTime;
	gFrameTimeSum += gFrameTimes[gFrameTimeIndex];
	gFrameTimeIndex = (gFrameTimeIndex+1) % gFrameTimeCount;


	mrSlideSorter.GetContentWindow()->SetFillColor(COL_BLUE);
	mrSlideSorter.GetContentWindow()->DrawRect(gFrameTimeBox);
	mrSlideSorter.GetContentWindow()->SetTextColor(COL_WHITE);
	mrSlideSorter.GetContentWindow()->DrawText(
		gFrameTimeBox,
		::rtl::OUString::valueOf(1 / (gFrameTimeSum / gFrameTimeCount)),
		TEXT_DRAW_RIGHT | TEXT_DRAW_VCENTER);
	//	mrSlideSorter.GetContentWindow()->Invalidate(gFrameTimeBox);
#endif
}


void SlideSorterView::Paint (
	OutputDevice& rDevice,
	const Rectangle& rRepaintArea)
{
	if ( ! mpPageObjectPainter)
		if ( ! GetPageObjectPainter())
			return;

	// Update the page visibilities when they have been invalidated.
	if ( ! mbPageObjectVisibilitiesValid)
		DeterminePageObjectVisibilities();

	if (mbPreciousFlagUpdatePending)
		UpdatePreciousFlags();

	if (mbIsRearrangePending)
		Rearrange();

	// Paint all page objects that are fully or partially inside the
	// repaint region.
	const Range aRange (mpLayouter->GetRangeOfVisiblePageObjects(rRepaintArea));
	for (sal_Int32 nIndex=aRange.Min(); nIndex<=aRange.Max(); ++nIndex)
	{
		model::SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(nIndex));
		if (!pDescriptor || ! pDescriptor->HasState(PageDescriptor::ST_Visible))
			continue;

		mpPageObjectPainter->PaintPageObject(rDevice, pDescriptor);
	}
}


void SlideSorterView::ConfigurationChanged (
	utl::ConfigurationBroadcaster* pBroadcaster,
	sal_uInt32 nHint)
{
	// Some changes of the configuration (some of the colors for example)
	// may affect the previews. Throw away the old ones and create new ones.
	cache::PageCacheManager::Instance()->InvalidateAllCaches();

	::sd::View::ConfigurationChanged(pBroadcaster, nHint);
	RequestRepaint();

}


::boost::shared_ptr<cache::PageCache> SlideSorterView::GetPreviewCache (void)
{
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow && mpPreviewCache.get() == NULL)
	{
		mpPreviewCache.reset(
			new cache::PageCache(
				mpLayouter->GetPageObjectSize(),
				false,
				cache::SharedCacheContext(new ViewCacheContext(mrSlideSorter))));
	}

	return mpPreviewCache;
}


Pair SlideSorterView::GetVisiblePageRange (void)
{
	if ( ! mbPageObjectVisibilitiesValid)
		DeterminePageObjectVisibilities();
	return maVisiblePageRange;
}


void SlideSorterView::AddVisibilityChangeListener (const Link& rListener)
{
	if (::std::find (
		maVisibilityChangeListeners.begin(),
		maVisibilityChangeListeners.end(),
		rListener) == maVisibilityChangeListeners.end())
	{
		maVisibilityChangeListeners.push_back(rListener);
	}
}


void SlideSorterView::RemoveVisibilityChangeListener(const Link&rListener)
{
	maVisibilityChangeListeners.erase (
		::std::find (
			maVisibilityChangeListeners.begin(),
			maVisibilityChangeListeners.end(),
			rListener));
}


ButtonBar& SlideSorterView::GetButtonBar (void) const
{
	OSL_ASSERT(mpButtonBar);
	return *mpButtonBar;
}


ToolTip& SlideSorterView::GetToolTip (void) const
{
	OSL_ASSERT(mpToolTip);
	return *mpToolTip;
}


void SlideSorterView::DragFinished (sal_Int8 nDropAction)
{
	mrSlideSorter.GetController().GetClipboard().DragFinished(nDropAction);

	View::DragFinished(nDropAction);
}


void SlideSorterView::Notify (SfxBroadcaster& rBroadcaster, const SfxHint& rHint)
{
	::sd::DrawDocShell* pDocShell = mrModel.GetDocument()->GetDocSh();
	if (pDocShell!=NULL && pDocShell->IsEnableSetModified())
		mbModelChangedWhileModifyEnabled = true;

	::sd::View::Notify(rBroadcaster, rHint);
}


void SlideSorterView::UpdatePageUnderMouse (bool bAnimate)
{
	::boost::shared_ptr<ScrollBar> pVScrollBar (mrSlideSorter.GetVerticalScrollBar());
	::boost::shared_ptr<ScrollBar> pHScrollBar (mrSlideSorter.GetHorizontalScrollBar());
	if ((pVScrollBar && pVScrollBar->IsVisible() && pVScrollBar->IsTracking())
		|| (pHScrollBar && pHScrollBar->IsVisible() && pHScrollBar->IsTracking()))
	{
		// One of the scroll bars is tracking mouse movement. Do not
		// highlight the slide under the mouse in this case.
		SetPageUnderMouse(SharedPageDescriptor(),false);
		return;
	}

	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	if (pWindow && pWindow->IsVisible() && ! pWindow->IsMouseCaptured())
	{
		const Window::PointerState aPointerState (pWindow->GetPointerState());
		const Rectangle aWindowBox (pWindow->GetPosPixel(), pWindow->GetSizePixel());
		if (aWindowBox.IsInside(aPointerState.maPos))
		{
			UpdatePageUnderMouse (
				aPointerState.maPos,
				(aPointerState.mnState & MOUSE_LEFT)!=0,
				bAnimate);
			return;
		}
	}

	SetPageUnderMouse(SharedPageDescriptor(),false);
}


void SlideSorterView::UpdatePageUnderMouse (
	const Point& rMousePosition,
	const bool bIsMouseButtonDown,
	const bool bAnimate)
{
	UpdatePageUnderMouse(
		mrSlideSorter.GetController().GetPageAt(rMousePosition),
		rMousePosition,
		bIsMouseButtonDown,
		bAnimate);
}


void SlideSorterView::UpdatePageUnderMouse (
	const model::SharedPageDescriptor& rpDescriptor,
	const Point& rMousePosition,
	const bool bIsMouseButtonDown,
	const bool bAnimate)
{
	// Update the page under the mouse.
	SetPageUnderMouse(rpDescriptor, bAnimate);

	// Tell the button bar about the new mouse position.
	SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
	const Point aMouseModelPosition (pWindow->PixelToLogic(rMousePosition));

	::boost::shared_ptr<ViewShell> pMainViewShell (mrSlideSorter.GetViewShellBase()->GetMainViewShell());
	if (pMainViewShell
		&& pMainViewShell->GetShellType()!=ViewShell::ST_DRAW)
	{
		const bool bIsMouseOverButtonBar (GetButtonBar().IsMouseOverBar());
		GetButtonBar().ProcessMouseMotionEvent(rpDescriptor, aMouseModelPosition, bIsMouseButtonDown);
		// Set the help text of the slide when the mouse was moved from the
		// button bar back over the preview.
		if (rpDescriptor
			&& GetButtonBar().IsMouseOverBar() != bIsMouseOverButtonBar
			&& bIsMouseOverButtonBar)
		{
			mpToolTip->ShowDefaultHelpText();
		}
	}
}


void SlideSorterView::SetPageUnderMouse (
	const model::SharedPageDescriptor& rpDescriptor,
	const bool bAnimate)
{
	if (mpPageUnderMouse != rpDescriptor)
	{
		if (mpPageUnderMouse)
			SetState(mpPageUnderMouse, PageDescriptor::ST_MouseOver, false, bAnimate);

		mpPageUnderMouse = rpDescriptor;

		if (mpPageUnderMouse)
			SetState(mpPageUnderMouse, PageDescriptor::ST_MouseOver, true, bAnimate);

		// Change the quick help text to display the name of the page under
		// the mouse.
		mpToolTip->SetPage(rpDescriptor);
	}
}


bool SlideSorterView::SetState (
	const model::SharedPageDescriptor& rpDescriptor,
	const PageDescriptor::State eState,
	const bool bStateValue,
	const bool bAnimate)
{
	model::SharedPageDescriptor pDescriptor (rpDescriptor);
	if ( ! pDescriptor)
		return false;

	const bool bModified (pDescriptor->SetState(eState, bStateValue));
	if ( ! bModified)
		return false;

	// When the page object is not visible (i.e. not on the screen then
	// nothing has to be painted.
	if (pDescriptor->HasState(PageDescriptor::ST_Visible))
	{
		// For most states a change of that state leads to visible
		// difference and we have to request a repaint.
		if (eState != PageDescriptor::ST_WasSelected)
			RequestRepaint(pDescriptor);
	}

	::boost::shared_ptr<ViewShell> pMainViewShell(mrSlideSorter.GetViewShellBase()->GetMainViewShell());
	if (pMainViewShell
		&& pMainViewShell->GetShellType()!=ViewShell::ST_DRAW)
	{
		// Fade in or out the buttons.
		if (eState == PageDescriptor::ST_MouseOver)
		{
			if (bStateValue)
				GetButtonBar().RequestFadeIn(rpDescriptor, bAnimate);
			else
				GetButtonBar().RequestFadeOut(rpDescriptor, bAnimate);
		}
	}

	return bModified;
}


::boost::shared_ptr<PageObjectPainter> SlideSorterView::GetPageObjectPainter (void)
{
	if ( ! mpPageObjectPainter)
		mpPageObjectPainter.reset(new PageObjectPainter(mrSlideSorter));
	return mpPageObjectPainter;
}


::boost::shared_ptr<LayeredDevice> SlideSorterView::GetLayeredDevice (void) const
{
	return mpLayeredDevice;
}


//===== SlideSorterView::DrawLock =============================================

SlideSorterView::DrawLock::DrawLock (
	view::SlideSorterView& rView,
	const SharedSdWindow& rpWindow)
	: mrView(rView),
	  mpWindow(rpWindow)
{
	if (mrView.mnLockRedrawSmph == 0)
		mrView.maRedrawRegion.SetEmpty();
	++mrView.mnLockRedrawSmph;
}


SlideSorterView::DrawLock::DrawLock (SlideSorter& rSlideSorter)
	: mrView(rSlideSorter.GetView()),
	  mpWindow(rSlideSorter.GetContentWindow())
{
	if (mrView.mnLockRedrawSmph == 0)
		mrView.maRedrawRegion.SetEmpty();
	++mrView.mnLockRedrawSmph;
}


SlideSorterView::DrawLock::~DrawLock (void)
{
	OSL_ASSERT(mrView.mnLockRedrawSmph>0);
	--mrView.mnLockRedrawSmph;
	if (mrView.mnLockRedrawSmph == 0)
		if (mpWindow)
		{
			mpWindow->Invalidate(mrView.maRedrawRegion);
			mpWindow->Update();
		}
}


void SlideSorterView::DrawLock::Dispose (void)
{
	mpWindow.reset();
}


} } } // end of namespace ::sd::slidesorter::view