haiku.git

// Painter.h

#ifndef PAINTER_H
#define PAINTER_H

#include <Font.h>
#include <Rect.h>
#include <FontServer.h>
#include <ServerFont.h>

#include "defines.h"
#include "forwarding_pixfmt.h"

#include "RGBColor.h"

class AGGTextRenderer;
class BBitmap;
class BRegion;
class DrawData;
class PatternHandler;
class RenderingBuffer;
class ServerBitmap;
class ServerFont;

class Painter {
 public:
								Painter();
	virtual						~Painter();

								// frame buffer stuff
			void				AttachToBuffer(RenderingBuffer* buffer);
			void				DetachFromBuffer();

			void				ConstrainClipping(const BRegion& region);
			void				SetDrawData(const DrawData* data);

								// object settings
			void				SetHighColor(const rgb_color& color);
	inline	void				SetHighColor(uint8 r, uint8 g, uint8 b, uint8 a = 255);
	inline	void				SetHighColor(const RGBColor& color)
									{ SetHighColor(color.GetColor32()); }
			void				SetLowColor(const rgb_color& color);
	inline	void				SetLowColor(uint8 r, uint8 g, uint8 b, uint8 a = 255);
	inline	void				SetLowColor(const RGBColor& color)
									{ SetLowColor(color.GetColor32()); }

			void				SetScale(float scale);
			void				SetPenSize(float size);
			void				SetOrigin(const BPoint& origin);
			void				SetDrawingMode(drawing_mode mode);
			void				SetBlendingMode(source_alpha alphaSrcMode,
												alpha_function alphaFncMode);
			void				SetPenLocation(const BPoint& location);
			void				SetFont(const BFont& font);
			void				SetFont(const ServerFont& font);

								// BView API compatibility (for easier testing)
			void				Sync() {}
	inline	void				MovePenTo(const BPoint& location)
									{ SetPenLocation(location); }
	inline	void				SetFont(const BFont* font)
									{ if (font) SetFont(*font); }

								// painting functions

								// lines
			BRect				StrokeLine(		BPoint a,
												BPoint b,
												const pattern& p = B_SOLID_HIGH);

			BRect				StrokeLine(		BPoint b,
												const pattern& p = B_SOLID_HIGH);

			// return true if the line was either vertical or horizontal
			// draws a solid one pixel wide line of color c, no blending
			bool				StraightLine(	BPoint a,
												BPoint b,
												const rgb_color& c) const;

								// triangles
			void				StrokeTriangle(	BPoint pt1,
												BPoint pt2,
												BPoint pt3,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillTriangle(	BPoint pt1,
												BPoint pt2,
												BPoint pt3,
												const pattern& p = B_SOLID_HIGH) const;

								// polygons
			void				StrokePolygon(	const BPoint* ptArray,
												int32 numPts,
											    bool  closed = true,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillPolygon(	const BPoint* ptArray,
												int32 numPts,
											    bool  closed = true,
												const pattern& p = B_SOLID_HIGH) const;

								// bezier curves
			void				StrokeBezier(	const BPoint* controlPoints,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillBezier(		const BPoint* controlPoints,
												const pattern& p = B_SOLID_HIGH) const;
	
								// shapes
			void				StrokeShape(	/*const */BShape* shape,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillShape(		/*const */BShape* shape,
												const pattern& p = B_SOLID_HIGH) const;


								// rects
			BRect				StrokeRect(		const BRect& r,
												const pattern& p = B_SOLID_HIGH) const;

			// strokes a one pixel wide solid rect, no blending
			void				StrokeRect(		const BRect& r,
												const rgb_color& c) const;

			BRect				FillRect(		const BRect& r,
												const pattern& p = B_SOLID_HIGH) const;

			// fills a solid rect with color c, no blending
			void				FillRect(		const BRect& r,
												const rgb_color& c) const;

								// round rects
			void				StrokeRoundRect(const BRect& r,
												float xRadius,
												float yRadius,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillRoundRect(	const BRect& r,
												float xRadius,
												float yRadius,
												const pattern& p = B_SOLID_HIGH) const;

								// ellipses
			void				StrokeEllipse(	BPoint center,
												float xRadius,
												float yRadius,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillEllipse(	BPoint center,
												float xRadius,
												float yRadius,
												const pattern& p = B_SOLID_HIGH) const;

								// arcs
			void				StrokeArc(		BPoint center,
												float xRadius,
												float yRadius,
												float angle,
												float span,
												const pattern& p = B_SOLID_HIGH) const;

			void				FillArc(		BPoint center,
												float xRadius,
												float yRadius,
												float angle,
												float span,
												const pattern& p = B_SOLID_HIGH) const;

								// strings
			BRect				DrawChar(		char aChar);

			BRect				DrawChar(		char aChar,
												BPoint baseLine);

			BRect				DrawString(		const char* utf8String,
												uint32 length,
												const escapement_delta* delta = NULL);

			BRect				DrawString(		const char* utf8String,
												uint32 length,
												BPoint baseLine,
												const escapement_delta* delta = NULL);

			BRect				DrawString(		const char* utf8String,
												const escapement_delta* delta = NULL);

			BRect				DrawString(		const char* utf8String,
												BPoint baseLine,
												const escapement_delta* delta = NULL);

								// bitmaps
			void				DrawBitmap(		const BBitmap* bitmap,
												BRect bitmapRect,
												BRect viewRect) const;

			void				DrawBitmap(		const ServerBitmap* bitmap,
												BRect bitmapRect,
												BRect viewRect) const;

								// some convenience stuff
			void				FillRegion(		const BRegion* region,
												const pattern& p = B_SOLID_HIGH) const;

			void				InvertRect(		const BRect& r) const;

			BRect				BoundingBox(	const char* utf8String,
												uint32 length,
												const BPoint& baseLine) const;

	inline	BRect				ClipRect(const BRect& rect) const
									{ return _Clipped(rect); }

 private:
			void				_MakeEmpty();

			void				_Transform(BPoint* point,
										   bool centerOffset = true) const;
			BPoint				_Transform(const BPoint& point,
										   bool centerOffset = true) const;
			void				_Transform(float* width) const;
			float				_Transform(const float& width) const;
			void				_Transform(BRect* rect) const;
			BRect				_Transform(const BRect& rect) const;
			BRect				_Clipped(const BRect& rect) const;

			void				_RebuildClipping();

			void				_UpdateFont();
			void				_UpdateLineWidth();

								// drawing functions stroke/fill
			void				_DrawTriangle(	BPoint pt1,
												BPoint pt2,
												BPoint pt3,
												const pattern& p,
												bool fill) const;
			void				_DrawEllipse(	BPoint center,
												float xRadius,
												float yRadius,
												const pattern& p,
												bool fill) const;
			void				_DrawShape(		/*const */BShape* shape,
												const pattern& p,
												bool fill) const;
			void				_DrawPolygon(	const BPoint* ptArray,
												int32 numPts,
											    bool  closed,
												const pattern& p,
												bool fill) const;

			void				_DrawBitmap(	const agg::rendering_buffer& srcBuffer,
												color_space format,
												BRect actualBitmapRect,
												BRect bitmapRect,
												BRect viewRect) const;
			void				_DrawBitmap32(	const agg::rendering_buffer& srcBuffer,
												BRect actualBitmapRect,
												BRect bitmapRect,
												BRect viewRect) const;

			void				_InvertRect32(BRect r) const;


			template<class VertexSource>
			BRect				_BoundingBox(VertexSource& path) const;

			template<class VertexSource>
			BRect				_StrokePath(VertexSource& path,
											const pattern& p) const;
			template<class VertexSource>
			BRect				_FillPath(VertexSource& path,

										  const pattern& p) const;

			void				_SetPattern(const pattern& p) const;
			void				_SetRendererColor(const rgb_color& color) const;

	agg::rendering_buffer*		fBuffer;

	// AGG rendering and rasterization classes
	pixfmt*						fPixelFormat;
	renderer_base*				fBaseRenderer;

	outline_renderer_type*		fOutlineRenderer;
	outline_rasterizer_type*	fOutlineRasterizer;

	scanline_type*				fScanline;
	rasterizer_type*			fRasterizer;
	renderer_type*				fRenderer;

	font_renderer_solid_type*	fFontRendererSolid;
	font_renderer_bin_type*		fFontRendererBin;

	agg::line_profile_aa		fLineProfile;

	// for internal coordinate rounding/transformation,
	// does not concern rendering
	bool						fSubpixelPrecise;

	float						fScale;
	float						fPenSize;
	BPoint						fOrigin;
	BRegion*					fClippingRegion; // NULL indicates no clipping at all
	drawing_mode				fDrawingMode;
	source_alpha				fAlphaSrcMode;
	alpha_function				fAlphaFncMode;
	BPoint						fPenLocation;
	PatternHandler*				fPatternHandler;

	ServerFont					fFont;
	// a class handling rendering and caching of glyphs
	// it is setup to load from a specific Freetype supported
	// font file, it uses the FontManager to locate a file
	// by Family and Style
	AGGTextRenderer*			fTextRenderer;
	uint32						fLastFamilyAndStyle;
};

// SetHighColor
inline void
Painter::SetHighColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	rgb_color color;
	color.red = r;
	color.green = g;
	color.blue = b;
	color.alpha = a;
	SetHighColor(color);
}

// SetLowColor
inline void
Painter::SetLowColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
	rgb_color color;
	color.red = r;
	color.green = g;
	color.blue = b;
	color.alpha = a;
	SetLowColor(color);
}


#endif // PAINTER_H