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

#include "model/SlsPageDescriptor.hxx"
#include "view/SlideSorterView.hxx"
#include "view/SlsPageObjectLayouter.hxx"
#include "view/SlsLayouter.hxx"
#include "view/SlsTheme.hxx"
#include "view/SlsButtonBar.hxx"
#include "SlsFramePainter.hxx"
#include "cache/SlsPageCache.hxx"
#include "controller/SlsProperties.hxx"
#include "Window.hxx"
#include "sdpage.hxx"
#include "sdresid.hxx"
#include <vcl/svapp.hxx>
#include <vcl/vclenum.hxx>
#include <vcl/virdev.hxx>
#include <boost/scoped_ptr.hpp>

using namespace ::drawinglayer::primitive2d;

namespace sd { namespace slidesorter { namespace view {

namespace {

sal_uInt8 Blend (
	const sal_uInt8 nValue1,
	const sal_uInt8 nValue2,
	const double nWeight)
{
	const double nValue (nValue1*(1-nWeight) + nValue2 * nWeight);
	if (nValue < 0)
		return 0;
	else if (nValue > 255)
		return 255;
	else
		return (sal_uInt8)nValue;
}

sal_uInt8 ClampColorChannel (const double nValue)
{
	if (nValue <= 0)
		return 0;
	else if (nValue >= 255)
		return 255;
	else
		return sal_uInt8(nValue);
}

sal_uInt8 CalculateColorChannel(
	const double nColor1,
	const double nColor2,
	const double nAlpha1,
	const double nAlpha2,
	const double nAlpha0)
{
	if (nAlpha0 == 0)
		return 0;

	const double nColor0 ((nAlpha1*nColor1 + nAlpha1*nAlpha2*nColor1 + nAlpha2*nColor2) / nAlpha0);
	return ClampColorChannel(255 * nColor0);
}

} // end of anonymous namespace




//===== PageObjectPainter =====================================================

PageObjectPainter::PageObjectPainter (
	const SlideSorter& rSlideSorter)
	: mrLayouter(rSlideSorter.GetView().GetLayouter()),
	  mpPageObjectLayouter(),
	  mpCache(rSlideSorter.GetView().GetPreviewCache()),
	  mpProperties(rSlideSorter.GetProperties()),
	  mpTheme(rSlideSorter.GetTheme()),
	  mpPageNumberFont(Theme::GetFont(Theme::Font_PageNumber, *rSlideSorter.GetContentWindow())),
	  mpShadowPainter(new FramePainter(mpTheme->GetIcon(Theme::Icon_RawShadow))),
	  mpFocusBorderPainter(new FramePainter(mpTheme->GetIcon(Theme::Icon_FocusBorder))),
	  maNormalBackground(),
	  maSelectionBackground(),
	  maFocusedSelectionBackground(),
	  maMouseOverBackground(),
	  maMouseOverFocusedBackground(),
	  msUnhideString(mpTheme->GetString(Theme::String_Unhide)),
	  mrButtonBar(rSlideSorter.GetView().GetButtonBar()),
	  maSize()
{
	// Replace the color (not the alpha values) in the focus border with a
	// color derived from the current selection color.
	Color aColor (mpTheme->GetColor(Theme::Color_Selection));
	sal_uInt16 nHue, nSat, nBri;
	aColor.RGBtoHSB(nHue, nSat, nBri);
	aColor = Color::HSBtoRGB(nHue, 28, 65);
	mpFocusBorderPainter->AdaptColor(aColor, true);
}




PageObjectPainter::~PageObjectPainter (void)
{
}




void PageObjectPainter::PaintPageObject (
	OutputDevice& rDevice,
	const model::SharedPageDescriptor& rpDescriptor)
{
	if (UpdatePageObjectLayouter())
	{
		// Turn off antialiasing to avoid the bitmaps from being
		// shifted by fractions of a pixel and thus show blurry edges.
		const sal_uInt16 nSavedAntialiasingMode (rDevice.GetAntialiasing());
		rDevice.SetAntialiasing(nSavedAntialiasingMode & ~ANTIALIASING_ENABLE_B2DDRAW);

		PaintBackground(rDevice, rpDescriptor);
		PaintPreview(rDevice, rpDescriptor);
		PaintPageNumber(rDevice, rpDescriptor);
		PaintTransitionEffect(rDevice, rpDescriptor);
		mrButtonBar.Paint(rDevice, rpDescriptor);

		rDevice.SetAntialiasing(nSavedAntialiasingMode);
	}
}




bool PageObjectPainter::UpdatePageObjectLayouter (void)
{
	// The page object layouter is quite volatile. It may have been replaced
	// since the last call. Update it now.
	mpPageObjectLayouter = mrLayouter.GetPageObjectLayouter();
	if ( ! mpPageObjectLayouter)
	{
		OSL_ASSERT(mpPageObjectLayouter);
		return false;
	}
	else
		return true;
}




void PageObjectPainter::NotifyResize (const bool bForce)
{
	if (bForce || ! mpPageObjectLayouter)
		InvalidateBitmaps();
	else if (UpdatePageObjectLayouter())
	{
		const Size aSize (mpPageObjectLayouter->GetSize(
				PageObjectLayouter::FocusIndicator,
				PageObjectLayouter::WindowCoordinateSystem));
		if ( maSize!=aSize)
		{
			maSize = aSize;
			InvalidateBitmaps();
		}
	}
}




void PageObjectPainter::InvalidateBitmaps (void)
{
	maNormalBackground.SetEmpty();
	maSelectionBackground.SetEmpty();
	maFocusedSelectionBackground.SetEmpty();
	maFocusedBackground.SetEmpty();
	maMouseOverBackground.SetEmpty();
	maMouseOverFocusedBackground.SetEmpty();
	maMouseOverSelectedAndFocusedBackground.SetEmpty();
}




void PageObjectPainter::SetTheme (const ::boost::shared_ptr<view::Theme>& rpTheme)
{
	mpTheme = rpTheme;
	NotifyResize(true);
}




void PageObjectPainter::PaintBackground (
	OutputDevice& rDevice,
	const model::SharedPageDescriptor& rpDescriptor)
{
	const Rectangle aBox (mpPageObjectLayouter->GetBoundingBox(
		rpDescriptor,
		PageObjectLayouter::FocusIndicator,
		PageObjectLayouter::ModelCoordinateSystem));

	const Bitmap& rBackground (GetBackgroundForState(rpDescriptor, rDevice));
	rDevice.DrawBitmap(aBox.TopLeft(), rBackground);

	// Fill the interior of the preview area with the default background
	// color of the page.
	SdPage* pPage = rpDescriptor->GetPage();
	if (pPage != NULL)
	{
		rDevice.SetFillColor(pPage->GetPageBackgroundColor(NULL));
		rDevice.SetLineColor(pPage->GetPageBackgroundColor(NULL));
		const Rectangle aPreviewBox (mpPageObjectLayouter->GetBoundingBox(
			rpDescriptor,
			PageObjectLayouter::Preview,
			PageObjectLayouter::ModelCoordinateSystem));
		rDevice.DrawRect(aPreviewBox);
	}
}




void PageObjectPainter::PaintPreview (
	OutputDevice& rDevice,
	const model::SharedPageDescriptor& rpDescriptor) const
{
	const Rectangle aBox (mpPageObjectLayouter->GetBoundingBox(
		rpDescriptor,
		PageObjectLayouter::Preview,
		PageObjectLayouter::ModelCoordinateSystem));

	if( bool(mpCache))
	{
		const SdrPage* pPage = rpDescriptor->GetPage();
		mpCache->SetPreciousFlag(pPage, true);

		const Bitmap aPreview (GetPreviewBitmap(rpDescriptor, &rDevice));
		if ( ! aPreview.IsEmpty())
		{
			if (aPreview.GetSizePixel() != aBox.GetSize())
				rDevice.DrawBitmap(aBox.TopLeft(), aBox.GetSize(), aPreview);
			else
				rDevice.DrawBitmap(aBox.TopLeft(), aPreview);
		}
	}
}




Bitmap PageObjectPainter::CreateMarkedPreview (
	const Size& rSize,
	const Bitmap& rPreview,
	const BitmapEx& rOverlay,
	const OutputDevice* pReferenceDevice) const
{
	::boost::scoped_ptr<VirtualDevice> pDevice;
	if (pReferenceDevice != NULL)
		pDevice.reset(new VirtualDevice(*pReferenceDevice));
	else
		pDevice.reset(new VirtualDevice());
	pDevice->SetOutputSizePixel(rSize);

	pDevice->DrawBitmap(Point(0,0), rSize, rPreview);

	// Paint bitmap tiled over the preview to mark it as excluded.
	const sal_Int32 nIconWidth (rOverlay.GetSizePixel().Width());
	const sal_Int32 nIconHeight (rOverlay.GetSizePixel().Height());
	if (nIconWidth>0 && nIconHeight>0)
	{
		for (sal_Int32 nX=0; nX<rSize.Width(); nX+=nIconWidth)
			for (sal_Int32 nY=0; nY<rSize.Height(); nY+=nIconHeight)
				pDevice->DrawBitmapEx(Point(nX,nY), rOverlay);
	}
	return pDevice->GetBitmap(Point(0,0), rSize);
}




Bitmap PageObjectPainter::GetPreviewBitmap (
	const model::SharedPageDescriptor& rpDescriptor,
	const OutputDevice* pReferenceDevice) const
{
	const SdrPage* pPage = rpDescriptor->GetPage();
	const bool bIsExcluded (rpDescriptor->HasState(model::PageDescriptor::ST_Excluded));

	if (bIsExcluded)
	{
		Bitmap aMarkedPreview (mpCache->GetMarkedPreviewBitmap(pPage,false));
		const Rectangle aPreviewBox (mpPageObjectLayouter->GetBoundingBox(
			rpDescriptor,
			PageObjectLayouter::Preview,
			PageObjectLayouter::ModelCoordinateSystem));
		if (aMarkedPreview.IsEmpty() || aMarkedPreview.GetSizePixel()!=aPreviewBox.GetSize())
		{
			aMarkedPreview = CreateMarkedPreview(
				aPreviewBox.GetSize(),
				mpCache->GetPreviewBitmap(pPage,true),
				mpTheme->GetIcon(Theme::Icon_HideSlideOverlay),
				pReferenceDevice);
			mpCache->SetMarkedPreviewBitmap(pPage, aMarkedPreview);
		}
		return aMarkedPreview;
	}
	else
	{
		return mpCache->GetPreviewBitmap(pPage,false);
	}
}




void PageObjectPainter::PaintPageNumber (
	OutputDevice& rDevice,
	const model::SharedPageDescriptor& rpDescriptor) const
{
	const Rectangle aBox (mpPageObjectLayouter->GetBoundingBox(
		rpDescriptor,
		PageObjectLayouter::PageNumber,
		PageObjectLayouter::ModelCoordinateSystem));

	// Determine the color of the page number.
	Color aPageNumberColor (mpTheme->GetColor(Theme::Color_PageNumberDefault));
	if (rpDescriptor->HasState(model::PageDescriptor::ST_MouseOver) ||
		rpDescriptor->HasState(model::PageDescriptor::ST_Selected))
	{
		// Page number is painted on background for hover or selection or
		// both. Each of these background colors has a predefined luminance
		// which is compatible with the PageNumberHover color.
		aPageNumberColor = Color(mpTheme->GetColor(Theme::Color_PageNumberHover));
	}
	else
	{
		const Color aBackgroundColor (mpTheme->GetColor(Theme::Color_Background));
		const sal_Int32 nBackgroundLuminance (aBackgroundColor.GetLuminance());
		// When the background color is black then this is interpreted as
		// high contrast mode and the font color is set to white.
		if (nBackgroundLuminance == 0)
			aPageNumberColor = Color(mpTheme->GetColor(Theme::Color_PageNumberHighContrast));
		else
		{
			// Compare luminance of default page number color and background
			// color. When the two are similar then use a darker
			// (preferred) or brighter font color.
			const sal_Int32 nFontLuminance (aPageNumberColor.GetLuminance());
			if (abs(nBackgroundLuminance - nFontLuminance) < 60)
			{
				if (nBackgroundLuminance > nFontLuminance-30)
					aPageNumberColor = Color(mpTheme->GetColor(Theme::Color_PageNumberBrightBackground));
				else
					aPageNumberColor = Color(mpTheme->GetColor(Theme::Color_PageNumberDarkBackground));
			}
		}
	}

	// Paint the page number.
	OSL_ASSERT(rpDescriptor->GetPage()!=NULL);
	const sal_Int32 nPageNumber ((rpDescriptor->GetPage()->GetPageNum() - 1) / 2 + 1);
	const String sPageNumber (String::CreateFromInt32(nPageNumber));
	rDevice.SetFont(*mpPageNumberFont);
	rDevice.SetTextColor(aPageNumberColor);
	rDevice.DrawText(aBox, sPageNumber, TEXT_DRAW_RIGHT | TEXT_DRAW_VCENTER);
}




void PageObjectPainter::PaintTransitionEffect (
	OutputDevice& rDevice,
	const model::SharedPageDescriptor& rpDescriptor) const
{
	const SdPage* pPage = rpDescriptor->GetPage();
	if (pPage!=NULL && pPage->getTransitionType() > 0)
	{
		const Rectangle aBox (mpPageObjectLayouter->GetBoundingBox(
			rpDescriptor,
			PageObjectLayouter::TransitionEffectIndicator,
			PageObjectLayouter::ModelCoordinateSystem));

		rDevice.DrawBitmapEx(
			aBox.TopLeft(),
			mpPageObjectLayouter->GetTransitionEffectIcon().GetBitmapEx());
	}
}




Bitmap& PageObjectPainter::GetBackgroundForState (
	const model::SharedPageDescriptor& rpDescriptor,
	const OutputDevice& rReferenceDevice)
{
	enum State { None = 0x00, Selected = 0x01, MouseOver = 0x02, Focused = 0x04 };
	const int eState =
		  (rpDescriptor->HasState(model::PageDescriptor::ST_Selected) ? Selected : None)
		| (rpDescriptor->HasState(model::PageDescriptor::ST_MouseOver) ? MouseOver : None)
		| (rpDescriptor->HasState(model::PageDescriptor::ST_Focused) ? Focused : None);

	switch (eState)
	{
		case MouseOver | Selected | Focused:
			return GetBackground(
				maMouseOverSelectedAndFocusedBackground,
				Theme::Gradient_MouseOverSelectedAndFocusedPage,
				rReferenceDevice,
				true);

		case MouseOver | Selected:
		case MouseOver:
			return GetBackground(
				maMouseOverBackground,
				Theme::Gradient_MouseOverPage,
				rReferenceDevice,
				false);

		case MouseOver | Focused:
			return GetBackground(
				maMouseOverFocusedBackground,
				Theme::Gradient_MouseOverPage,
				rReferenceDevice,
				true);

		case Selected | Focused:
			return GetBackground(
				maFocusedSelectionBackground,
				Theme::Gradient_SelectedAndFocusedPage,
				rReferenceDevice,
				true);

		case Selected:
			return GetBackground(
				maSelectionBackground,
				Theme::Gradient_SelectedPage,
				rReferenceDevice,
				false);

		case Focused:
			return GetBackground(
				maFocusedBackground,
				Theme::Gradient_FocusedPage,
				rReferenceDevice,
				true);

		case None:
		default:
			return GetBackground(
				maNormalBackground,
				Theme::Gradient_NormalPage,
				rReferenceDevice,
				false);
	}
}




Bitmap& PageObjectPainter::GetBackground(
	Bitmap& rBackground,
	Theme::GradientColorType eType,
	const OutputDevice& rReferenceDevice,
	const bool bHasFocusBorder)
{
	if (rBackground.IsEmpty())
		rBackground = CreateBackgroundBitmap(rReferenceDevice, eType, bHasFocusBorder);
	return rBackground;
}




Bitmap PageObjectPainter::CreateBackgroundBitmap(
	const OutputDevice& rReferenceDevice,
	const Theme::GradientColorType eColorType,
	const bool bHasFocusBorder) const
{
	const Size aSize (mpPageObjectLayouter->GetSize(
		PageObjectLayouter::FocusIndicator,
		PageObjectLayouter::WindowCoordinateSystem));
	const Rectangle aPageObjectBox (mpPageObjectLayouter->GetBoundingBox(
		Point(0,0),
		PageObjectLayouter::PageObject,
		PageObjectLayouter::ModelCoordinateSystem));
	VirtualDevice aBitmapDevice (rReferenceDevice);
	aBitmapDevice.SetOutputSizePixel(aSize);

	// Fill the background with the background color of the slide sorter.
	const Color aBackgroundColor (mpTheme->GetColor(Theme::Color_Background));
	aBitmapDevice.SetFillColor(aBackgroundColor);
	aBitmapDevice.SetLineColor(aBackgroundColor);
	aBitmapDevice.DrawRect(Rectangle(Point(0,0), aSize));

	// Paint the slide area with a linear gradient that starts some pixels
	// below the top and ends some pixels above the bottom.
	const Color aTopColor(mpTheme->GetGradientColor(eColorType, Theme::Fill1));
	const Color aBottomColor(mpTheme->GetGradientColor(eColorType, Theme::Fill2));
	if (aTopColor != aBottomColor)
	{
		const sal_Int32 nHeight (aPageObjectBox.GetHeight());
		const sal_Int32 nDefaultConstantSize(nHeight/4);
		const sal_Int32 nMinimalGradientSize(40);
		const sal_Int32 nY1 (
			::std::max<sal_Int32>(
				0,
				::std::min<sal_Int32>(
					nDefaultConstantSize,
					(nHeight - nMinimalGradientSize)/2)));
		const sal_Int32 nY2 (nHeight-nY1);
		const sal_Int32 nTop (aPageObjectBox.Top());
		for (sal_Int32 nY=0; nY<nHeight; ++nY)
		{
			if (nY<=nY1)
				aBitmapDevice.SetLineColor(aTopColor);
			else if (nY>=nY2)
				aBitmapDevice.SetLineColor(aBottomColor);
			else
			{
				Color aColor (aTopColor);
				aColor.Merge(aBottomColor, 255 * (nY2-nY) / (nY2-nY1));
				aBitmapDevice.SetLineColor(aColor);
			}
			aBitmapDevice.DrawLine(
				Point(aPageObjectBox.Left(), nY+nTop),
				Point(aPageObjectBox.Right(), nY+nTop));
		}
	}
	else
	{
		aBitmapDevice.SetFillColor(aTopColor);
		aBitmapDevice.DrawRect(aPageObjectBox);
	}

	// Paint the simple border and, for some backgrounds, the focus border.
	if (bHasFocusBorder)
		mpFocusBorderPainter->PaintFrame(aBitmapDevice, aPageObjectBox);
	else
		PaintBorder(aBitmapDevice, eColorType, aPageObjectBox);

	// Get bounding box of the preview around which a shadow is painted.
	// Compensate for the border around the preview.
	const Rectangle aBox (mpPageObjectLayouter->GetBoundingBox(
		Point(0,0),
		PageObjectLayouter::Preview,
		PageObjectLayouter::ModelCoordinateSystem));
	Rectangle aFrameBox (aBox.Left()-1,aBox.Top()-1,aBox.Right()+1,aBox.Bottom()+1);
	mpShadowPainter->PaintFrame(aBitmapDevice, aFrameBox);

	return aBitmapDevice.GetBitmap (Point(0,0),aSize);
}




void PageObjectPainter::PaintBorder (
	OutputDevice& rDevice,
	const Theme::GradientColorType eColorType,
	const Rectangle& rBox) const
{
	rDevice.SetFillColor();
	const sal_Int32 nBorderWidth (1);
	for (int nIndex=0; nIndex<nBorderWidth; ++nIndex)
	{
		const int nDelta (nIndex);
		rDevice.SetLineColor(mpTheme->GetGradientColor(eColorType, Theme::Border2));
		rDevice.DrawLine(
			Point(rBox.Left()-nDelta, rBox.Top()-nDelta),
			Point(rBox.Left()-nDelta, rBox.Bottom()+nDelta));
		rDevice.DrawLine(
			Point(rBox.Left()-nDelta, rBox.Bottom()+nDelta),
			Point(rBox.Right()+nDelta, rBox.Bottom()+nDelta));
		rDevice.DrawLine(
			Point(rBox.Right()+nDelta, rBox.Bottom()+nDelta),
			Point(rBox.Right()+nDelta, rBox.Top()-nDelta));

		rDevice.SetLineColor(mpTheme->GetGradientColor(eColorType, Theme::Border1));
		rDevice.DrawLine(
			Point(rBox.Left()-nDelta, rBox.Top()-nDelta),
			Point(rBox.Right()+nDelta, rBox.Top()-nDelta));
	}
}



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