haiku.git

/*
 * Copyright 2007, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Maxim Shemanarev <mcseemagg@yahoo.com>
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Andrej Spielmann, <andrej.spielmann@seh.ox.ac.uk>
 */

//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.4
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mcseem@antigrain.com
//			mcseemagg@yahoo.com
//			http://www.antigrain.com
//----------------------------------------------------------------------------

#ifndef FONT_ENGINE_H
#define FONT_ENGINE_H

#include <SupportDefs.h>

#include <ft2build.h>
#include FT_FREETYPE_H

#include <agg_scanline_storage_aa.h>
#include <agg_scanline_storage_bin.h>
#include <agg_scanline_u.h>
#include <agg_scanline_bin.h>
#include <agg_path_storage_integer.h>
#include <agg_rasterizer_scanline_aa.h>
#include <agg_conv_curve.h>
#include <agg_trans_affine.h>

#include "agg_scanline_storage_subpix.h"
#include "agg_scanline_u_subpix.h"
#include "agg_scanline_u_subpix_avrg_filtering.h"

#include "GlobalSubpixelSettings.h"


enum glyph_rendering {
	glyph_ren_native_mono,
	glyph_ren_native_gray8,
	glyph_ren_outline,
	glyph_ren_subpix
};


enum glyph_data_type {
	glyph_data_invalid	= 0,
	glyph_data_mono		= 1,
	glyph_data_gray8	= 2,
	glyph_data_outline	= 3,
	glyph_data_subpix   = 4
};


class FontEngine {
 public:
	typedef agg::serialized_scanlines_adaptor_subpix<uint8>	SubpixAdapter;
	typedef agg::serialized_scanlines_adaptor_aa<uint8>		Gray8Adapter;
	typedef agg::serialized_scanlines_adaptor_bin			MonoAdapter;
	typedef agg::scanline_storage_aa8						ScanlineStorageAA;
	typedef agg::scanline_storage_subpix8					ScanlineStorageSubpix;
	typedef agg::scanline_storage_bin						ScanlineStorageBin;
	typedef agg::serialized_integer_path_adaptor<int32, 6>	PathAdapter;

								FontEngine();
	virtual						~FontEngine();

			bool				Init(const char* fontFilePath,
									unsigned face_index, double size,
									FT_Encoding char_map,
									glyph_rendering ren_type,
									bool hinting,
									const void* fontFileBuffer = NULL,
									const long fontFileBufferSize = 0);

			int					LastError() const
									{ return fLastError; }
			unsigned			CountFaces() const;
			bool				Hinting() const
									{ return fHinting; }


			uint32				GlyphIndexForGlyphCode(uint32 glyphCode) const;
			bool				PrepareGlyph(uint32 glyphIndex);

			uint32				DataSize() const
									{ return fDataSize; }
			glyph_data_type		DataType() const
									{ return fDataType; }
			const agg::rect_i&	Bounds() const
									{ return fBounds; }
			double				AdvanceX() const
									{ return fAdvanceX; }
			double				AdvanceY() const
									{ return fAdvanceY; }
			double				PreciseAdvanceX() const
									{ return fPreciseAdvanceX; }
			double				PreciseAdvanceY() const
									{ return fPreciseAdvanceY; }
			double				InsetLeft() const
									{ return fInsetLeft; }
			double				InsetRight() const
									{ return fInsetRight; }

			void				WriteGlyphTo(uint8* data) const;


			bool				GetKerning(uint32 first, uint32 second,
									double* x, double* y);

 private:
			// disallowed stuff:
								FontEngine(const FontEngine&);
			const FontEngine&	operator=(const FontEngine&);

			int					fLastError;
			bool				fLibraryInitialized;
			FT_Library			fLibrary;	// handle to library
			FT_Face				fFace;	  // FreeType font face handle

			glyph_rendering		fGlyphRendering;
			bool				fHinting;

			// members needed to generate individual glyphs according
			// to glyph rendering type
			uint32				fDataSize;
			glyph_data_type		fDataType;
			agg::rect_i			fBounds;
			double				fAdvanceX;
			double				fAdvanceY;
			double				fPreciseAdvanceX;
			double				fPreciseAdvanceY;
			double				fInsetLeft;
			double				fInsetRight;

			// these members are for caching memory allocations
			// when rendering glyphs
	typedef agg::path_storage_integer<int32, 6>		PathStorageType;
	typedef agg::conv_curve<PathStorageType>		CurveConverterType;

			PathStorageType		fPath;
			CurveConverterType	fCurves;
			agg::scanline_u8	fScanlineAA;
			agg::scanline_bin	fScanlineBin;
#ifdef AVERAGE_BASED_SUBPIXEL_FILTERING
			agg::scanline_u8_subpix_avrg_filtering fScanlineSubpix;
#else
			agg::scanline_u8_subpix fScanlineSubpix;
#endif

			ScanlineStorageAA	fScanlineStorageAA;
			ScanlineStorageBin	fScanlineStorageBin;
			ScanlineStorageSubpix fScanlineStorageSubpix;
};


#endif // FONT_ENGINE_H