/*
 * Copyright 2014-2015, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 */

#ifndef ALPHA_MASK_H
#define ALPHA_MASK_H

#include <Referenceable.h>
#include <locks.h>

#include "agg_clipped_alpha_mask.h"
#include "ServerPicture.h"

#include "DrawState.h"
#include "drawing/Painter/defines.h"
#include "IntRect.h"


class BShape;
class ServerBitmap;
class ServerPicture;
class shape_data;
class UtilityBitmap;


// #pragma mark - AlphaMask


class AlphaMask : public BReferenceable {
public:
								AlphaMask(AlphaMask* previousMask,
									bool inverse);
								AlphaMask(AlphaMask* previousMask,
									AlphaMask* other);
								AlphaMask(uint8 backgroundOpacity);
	virtual						~AlphaMask();

			IntPoint			SetCanvasGeometry(IntPoint origin,
									IntRect bounds);

			scanline_unpacked_masked_type* Scanline()
								{ return &fScanline; }

			agg::clipped_alpha_mask* Mask()
								{ return &fMask; }

			size_t				BitmapSize() const;

			bool				IsInverted() const
								{ return fInverse; }

			bool				IsClipped() const
								{ return fClippedToCanvas; }

			uint8				OutsideOpacity() const
								{ return fOutsideOpacity; }

protected:
			ServerBitmap*		_CreateTemporaryBitmap(BRect bounds) const;
			void				_Generate();
			void				_SetNoClipping();
			const IntRect&		_PreviousMaskBounds() const;
	virtual	void				_AddToCache() = 0;
			void				_SetOutsideOpacity();

private:
	virtual	ServerBitmap*		_RenderSource(const IntRect& canvasBounds) = 0;
 	virtual	IntPoint			_Offset() = 0;

			void				_AttachMaskToBuffer();

protected:
			BReference<AlphaMask> fPreviousMask;
			IntRect				fBounds;
			bool				fClippedToCanvas;
			recursive_lock		fLock;

private:
	friend class AlphaMaskCache;

			IntPoint			fCanvasOrigin;
			IntRect				fCanvasBounds;
			const bool			fInverse;
			uint8				fBackgroundOpacity;
			uint8				fOutsideOpacity;

			int32				fNextMaskCount;
			bool				fInCache;
			uint32				fIndirectCacheReferences;
									// number of times this mask has been
									// seen as "previous mask" of another
									// one in the cache, without being
									// in the cache itself

			BReference<UtilityBitmap> fBits;
			agg::rendering_buffer fBuffer;
			agg::clipped_alpha_mask fMask;
			scanline_unpacked_masked_type fScanline;
};


class UniformAlphaMask : public AlphaMask {
public:
								UniformAlphaMask(uint8 opacity);

private:
	virtual	ServerBitmap*		_RenderSource(const IntRect& canvasBounds);
	virtual	IntPoint			_Offset();
	virtual void				_AddToCache();
};


// #pragma mark - VectorAlphaMask


template<class VectorMaskType>
class VectorAlphaMask : public AlphaMask {
public:
								VectorAlphaMask(AlphaMask* previousMask,
									BPoint where, bool inverse);
								VectorAlphaMask(AlphaMask* previousMask,
									VectorAlphaMask* other);

private:
	virtual	ServerBitmap*		_RenderSource(const IntRect& canvasBounds);
	virtual	IntPoint			_Offset();

protected:
			BPoint				fWhere;
};


// #pragma mark - PictureAlphaMask


class PictureAlphaMask : public VectorAlphaMask<PictureAlphaMask> {
public:
								PictureAlphaMask(AlphaMask* previousMask,
									ServerPicture* picture,
									const DrawState& drawState, BPoint where,
									bool inverse);
	virtual						~PictureAlphaMask();

			void				DrawVectors(Canvas* canvas);
			BRect				DetermineBoundingBox() const;
			const DrawState&	GetDrawState() const;

private:
	virtual void				_AddToCache();

private:
			BReference<ServerPicture> fPicture;
			ObjectDeleter<DrawState> fDrawState;
};


// #pragma mark - ShapeAlphaMask


class ShapeAlphaMask : public VectorAlphaMask<ShapeAlphaMask> {
private:
								ShapeAlphaMask(AlphaMask* previousMask,
									const shape_data& shape,
									BPoint where, bool inverse);
								ShapeAlphaMask(AlphaMask* previousMask,
									ShapeAlphaMask* other);

public:
	virtual						~ShapeAlphaMask();

	static	ShapeAlphaMask*		Create(AlphaMask* previousMask,
									const shape_data& shape,
									BPoint where, bool inverse);

			void				DrawVectors(Canvas* canvas);
			BRect				DetermineBoundingBox() const;
			const DrawState&	GetDrawState() const;

private:
	virtual void				_AddToCache();

private:
	friend class AlphaMaskCache;

			BReference<shape_data> fShape;
			BRect				fShapeBounds;
	static	DrawState*			fDrawState;
};


#endif // ALPHA_MASK_H