/**************************************************************
 *
 * 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/SlsInsertionIndicatorOverlay.hxx"

#include "SlideSorter.hxx"
#include "model/SlsPageEnumeration.hxx"
#include "view/SlideSorterView.hxx"
#include "view/SlsLayouter.hxx"
#include "view/SlsPageObjectLayouter.hxx"
#include "view/SlsTheme.hxx"
#include "cache/SlsPageCache.hxx"
#include "SlsFramePainter.hxx"
#include "SlsLayeredDevice.hxx"
#include "DrawDocShell.hxx"
#include "drawdoc.hxx"
#include "sdpage.hxx"
#include "sdmod.hxx"

#include <vcl/virdev.hxx>
#include <basegfx/range/b2drectangle.hxx>
#include <basegfx/tools/canvastools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>


namespace {


static const double gnPreviewOffsetScale = 1.0 / 8.0;



Rectangle GrowRectangle (const Rectangle& rBox, const sal_Int32 nOffset)
{
	return Rectangle (
		rBox.Left() - nOffset,
		rBox.Top() - nOffset,
		rBox.Right() + nOffset,
		rBox.Bottom() + nOffset);
}

sal_Int32 RoundToInt (const double nValue) { return sal_Int32(::rtl::math::round(nValue)); }

} // end of anonymous namespace


namespace sd { namespace slidesorter { namespace view {


//===== InsertionIndicatorOverlay =============================================

const static sal_Int32 gnShadowBorder = 3;
const static sal_Int32 gnSuperScaleFactor = 1;

InsertionIndicatorOverlay::InsertionIndicatorOverlay (SlideSorter& rSlideSorter)
	: mrSlideSorter(rSlideSorter),
	  mbIsVisible(false),
	  mnLayerIndex(2),
	  mpLayerInvalidator(),
	  maLocation(),
	  maIcon(),
	  maIconOffset(),
	  mpShadowPainter(
		new FramePainter(mrSlideSorter.GetTheme()->GetIcon(Theme::Icon_RawInsertShadow)))
{
}




InsertionIndicatorOverlay::~InsertionIndicatorOverlay (void)
{
	Hide();
}




void InsertionIndicatorOverlay::Create (const SdTransferable* pTransferable)
{
	if (pTransferable == NULL)
		return;

	::boost::shared_ptr<controller::TransferableData> pData (
		controller::TransferableData::GetFromTransferable(pTransferable));
	if ( ! pData)
		return;
	sal_Int32 nSelectionCount (0);
	if (pTransferable->HasPageBookmarks())
		nSelectionCount = pTransferable->GetPageBookmarks().Count();
	else
	{
		DrawDocShell* pDataDocShell = dynamic_cast<DrawDocShell*>(&pTransferable->GetDocShell());
		if (pDataDocShell != NULL)
		{
			SdDrawDocument* pDataDocument = pDataDocShell->GetDoc();
			if (pDataDocument != NULL)
				nSelectionCount = pDataDocument->GetSdPageCount(PK_STANDARD);
		}
	}
	Create(pData->GetRepresentatives(), nSelectionCount);
}




void InsertionIndicatorOverlay::Create (
	const ::std::vector<controller::TransferableData::Representative>& rRepresentatives,
	const sal_Int32 nSelectionCount)
{
	view::Layouter& rLayouter (mrSlideSorter.GetView().GetLayouter());
	::boost::shared_ptr<view::PageObjectLayouter> pPageObjectLayouter (
		rLayouter.GetPageObjectLayouter());
	::boost::shared_ptr<view::Theme> pTheme (mrSlideSorter.GetTheme());
	const Size aOriginalPreviewSize (pPageObjectLayouter->GetSize(
		PageObjectLayouter::Preview,
		PageObjectLayouter::WindowCoordinateSystem));

	const double nPreviewScale (0.5);
	const Size aPreviewSize (
		RoundToInt(aOriginalPreviewSize.Width()*nPreviewScale),
		RoundToInt(aOriginalPreviewSize.Height()*nPreviewScale));
	const sal_Int32 nOffset (
		RoundToInt(Min(aPreviewSize.Width(),aPreviewSize.Height()) * gnPreviewOffsetScale));

	// Determine size and offset depending on the number of previews.
	sal_Int32 nCount (rRepresentatives.size());
	if (nCount > 0)
		--nCount;
	Size aIconSize(
		aPreviewSize.Width() + 2 * gnShadowBorder + nCount*nOffset,
		aPreviewSize.Height() + 2 * gnShadowBorder + nCount*nOffset);
	maIconOffset = Point(gnShadowBorder, gnShadowBorder);

	// Create virtual devices for bitmap and mask whose bitmaps later be
	// combined to form the BitmapEx of the icon.
	VirtualDevice aContent (
		*mrSlideSorter.GetContentWindow(),
		0,
		0);
	aContent.SetOutputSizePixel(aIconSize);

	aContent.SetFillColor();
	aContent.SetLineColor(pTheme->GetColor(Theme::Color_PreviewBorder));
	const Point aOffset = PaintRepresentatives(aContent, aPreviewSize, nOffset, rRepresentatives);

	PaintPageCount(aContent, nSelectionCount, aPreviewSize, aOffset);

	maIcon = aContent.GetBitmapEx(Point(0,0), aIconSize);
	maIcon.Scale(aIconSize);
}




void InsertionIndicatorOverlay::SelectRepresentatives (
	model::PageEnumeration& rSelection,
	::std::vector<model::SharedPageDescriptor>& rDescriptors) const
{
	sal_Int32 nCount (0);
	while (rSelection.HasMoreElements())
	{
		if (nCount++ >= 3)
			break;
		rDescriptors.push_back(rSelection.GetNextElement());
	}
}




Point InsertionIndicatorOverlay::PaintRepresentatives (
	OutputDevice& rContent,
	const Size aPreviewSize,
	const sal_Int32 nOffset,
	const ::std::vector<controller::TransferableData::Representative>& rRepresentatives) const
{
	const Point aOffset (0,rRepresentatives.size()==1 ? -nOffset : 0);

	// Paint the pages.
	Point aPageOffset (0,0);
	double nTransparency (0);
	const BitmapEx aExclusionOverlay (mrSlideSorter.GetTheme()->GetIcon(Theme::Icon_HideSlideOverlay));
	for (sal_Int32 nIndex=2; nIndex>=0; --nIndex)
	{
		if (rRepresentatives.size() <= sal_uInt32(nIndex))
			continue;
		switch(nIndex)
		{
			case 0 :
				aPageOffset = Point(0, nOffset);
				nTransparency = 0.95;
				break;
			case 1:
				aPageOffset = Point(nOffset, 0);
				nTransparency = 0.85;
				break;
			case 2:
				aPageOffset = Point(2*nOffset, 2*nOffset);
				nTransparency = 0.75;
				break;
		}
		aPageOffset += aOffset;
		aPageOffset.X() += gnShadowBorder;
		aPageOffset.Y() += gnShadowBorder;

		// Paint the preview.
		Bitmap aPreview (rRepresentatives[nIndex].maBitmap);
		const Size aSuperSampleSize(
			aPreviewSize.Width()*gnSuperScaleFactor,
			aPreviewSize.Height()*gnSuperScaleFactor);
		aPreview.Scale(aPreviewSize, BMP_SCALE_FASTESTINTERPOLATE);
		rContent.DrawBitmapEx(aPageOffset, aPreview);

		// When the page is marked as excluded from the slide show then
		// paint an overlay that visualizes this.
		if (rRepresentatives[nIndex].mbIsExcluded)
		{
			const Region aSavedClipRegion (rContent.GetClipRegion());
			rContent.IntersectClipRegion(Rectangle(aPageOffset, aPreviewSize));
			// Paint bitmap tiled over the preview to mark it as excluded.
			const sal_Int32 nIconWidth (aExclusionOverlay.GetSizePixel().Width());
			const sal_Int32 nIconHeight (aExclusionOverlay.GetSizePixel().Height());
			if (nIconWidth>0 && nIconHeight>0)
			{
				for (sal_Int32 nX=0; nX<aPreviewSize.Width(); nX+=nIconWidth)
					for (sal_Int32 nY=0; nY<aPreviewSize.Height(); nY+=nIconHeight)
						rContent.DrawBitmapEx(Point(nX,nY)+aPageOffset, aExclusionOverlay);
			}
			rContent.SetClipRegion(aSavedClipRegion);
		}

		// Tone down the bitmap. The further back the darker it becomes.
		Rectangle aBox (
			aPageOffset.X(),
			aPageOffset.Y(),
			aPageOffset.X()+aPreviewSize.Width()-1,
			aPageOffset.Y()+aPreviewSize.Height()-1);
		rContent.SetFillColor(COL_BLACK);
		rContent.SetLineColor();
		rContent.DrawTransparent(
			::basegfx::B2DPolyPolygon(::basegfx::tools::createPolygonFromRect(
				::basegfx::B2DRectangle(aBox.Left(), aBox.Top(), aBox.Right()+1, aBox.Bottom()+1),
				0,
				0)),
			nTransparency);

		// Draw border around preview.
		Rectangle aBorderBox (GrowRectangle(aBox, 1));
		rContent.SetLineColor(COL_GRAY);
		rContent.SetFillColor();
		rContent.DrawRect(aBorderBox);

		// Draw shadow around preview.
		mpShadowPainter->PaintFrame(rContent, aBorderBox);
	}

	return aPageOffset;
}




void InsertionIndicatorOverlay::PaintPageCount (
	OutputDevice& rDevice,
	const sal_Int32 nSelectionCount,
	const Size aPreviewSize,
	const Point aFirstPageOffset) const
{
	// Paint the number of slides.
	::boost::shared_ptr<view::Theme> pTheme (mrSlideSorter.GetTheme());
	::boost::shared_ptr<Font> pFont(Theme::GetFont(Theme::Font_PageCount, rDevice));
	if (pFont)
	{
		::rtl::OUString sNumber (::rtl::OUString::valueOf(nSelectionCount));

		// Determine the size of the (painted) text and create a bounding
		// box that centers the text on the first preview.
		rDevice.SetFont(*pFont);
		Rectangle aTextBox;
		rDevice.GetTextBoundRect(aTextBox, sNumber);
		Point aTextOffset (aTextBox.TopLeft());
		Size aTextSize (aTextBox.GetSize());
		// Place text inside the first page preview.
		Point aTextLocation(aFirstPageOffset);
		// Center the text.
		aTextLocation += Point(
			(aPreviewSize.Width()-aTextBox.GetWidth())/2,
			(aPreviewSize.Height()-aTextBox.GetHeight())/2);
		aTextBox = Rectangle(aTextLocation, aTextSize);

		// Paint background, border and text.
		static const sal_Int32 nBorder = 5;
		rDevice.SetFillColor(pTheme->GetColor(Theme::Color_Selection));
		rDevice.SetLineColor(pTheme->GetColor(Theme::Color_Selection));
		rDevice.DrawRect(GrowRectangle(aTextBox, nBorder));

		rDevice.SetFillColor();
		rDevice.SetLineColor(pTheme->GetColor(Theme::Color_PageCountFontColor));
		rDevice.DrawRect(GrowRectangle(aTextBox, nBorder-1));

		rDevice.SetTextColor(pTheme->GetColor(Theme::Color_PageCountFontColor));
		rDevice.DrawText(aTextBox.TopLeft()-aTextOffset, sNumber);
	}
}




void InsertionIndicatorOverlay::SetLocation (const Point& rLocation)
{
	const Point aTopLeft (
		rLocation - Point(
			maIcon.GetSizePixel().Width()/2,
			maIcon.GetSizePixel().Height()/2));
	if (maLocation != aTopLeft)
	{
		const Rectangle aOldBoundingBox (GetBoundingBox());

		maLocation = aTopLeft;

		if (mpLayerInvalidator && IsVisible())
		{
			mpLayerInvalidator->Invalidate(aOldBoundingBox);
			mpLayerInvalidator->Invalidate(GetBoundingBox());
		}
	}
}




void InsertionIndicatorOverlay::Paint (
	OutputDevice& rDevice,
	const Rectangle& rRepaintArea)
{
	(void)rRepaintArea;

	if ( ! IsVisible())
		return;

	rDevice.DrawImage(maLocation, maIcon);
}




void InsertionIndicatorOverlay::SetLayerInvalidator (const SharedILayerInvalidator& rpInvalidator)
{
	mpLayerInvalidator = rpInvalidator;

	if (mbIsVisible && mpLayerInvalidator)
		mpLayerInvalidator->Invalidate(GetBoundingBox());
}




bool InsertionIndicatorOverlay::IsVisible (void) const
{
	return mbIsVisible;
}




void InsertionIndicatorOverlay::Show (void)
{
	if ( ! mbIsVisible)
	{
		mbIsVisible = true;

		::boost::shared_ptr<LayeredDevice> pLayeredDevice (
			mrSlideSorter.GetView().GetLayeredDevice());
		if (pLayeredDevice)
		{
			pLayeredDevice->RegisterPainter(shared_from_this(), mnLayerIndex);
			if (mpLayerInvalidator)
				mpLayerInvalidator->Invalidate(GetBoundingBox());
		}
	}
}




void InsertionIndicatorOverlay::Hide (void)
{
	if (mbIsVisible)
	{
		mbIsVisible = false;

		::boost::shared_ptr<LayeredDevice> pLayeredDevice (
			mrSlideSorter.GetView().GetLayeredDevice());
		if (pLayeredDevice)
		{
			if (mpLayerInvalidator)
				mpLayerInvalidator->Invalidate(GetBoundingBox());
			pLayeredDevice->RemovePainter(shared_from_this(), mnLayerIndex);
		}
	}
}




Rectangle InsertionIndicatorOverlay::GetBoundingBox (void) const
{
	return Rectangle(maLocation, maIcon.GetSizePixel());
}




Size InsertionIndicatorOverlay::GetSize (void) const
{
	return Size(
		maIcon.GetSizePixel().Width() + 10,
		maIcon.GetSizePixel().Height() + 10);
}



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

/* vim: set noet sw=4 ts=4: */