/* -*- mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: t -*- */
/* AbiWord
 * Copyright (C) 2004-6 Tomas Frydrych <dr.tomas@yahoo.co.uk>
 * Copyright (C) 2009 Hubert Figuiere
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
 * 02111-1307, USA.
 */

#ifndef GR_UNIX_PANGOGRAPHICS_H
#define GR_UNIX_PANGOGRAPHICS_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <vector>

#include "ut_types.h"
#include "ut_color.h"
#include "ut_string_class.h"
#include "gr_RenderInfo.h"

#include <cairo.h>
#include <pango/pango.h>

// we do not want this to be a plugin for now
#define GR_UNIXPANGO_BUILTIN

#ifndef GR_UNIXPANGO_BUILTIN
#define PLUGIN_NAME "Cairo Pango graphics"
#endif

/************************************************************************/
/************************************************************************/

class GR_PangoRenderInfo;
class GR_CairoGraphics;
class XAP_Frame;

class GR_CairoPatternImpl
	: public UT_ColorPatImpl
{
public:
	GR_CairoPatternImpl(const char * fileName);
	// don't take ownership
	GR_CairoPatternImpl(cairo_surface_t * surf);
	GR_CairoPatternImpl(const GR_CairoPatternImpl &);
	virtual ~GR_CairoPatternImpl();
    virtual UT_ColorPatImpl * clone() const;
	cairo_pattern_t *getPattern() const
		{
			return m_pattern;
		}
private:
	GR_CairoPatternImpl & operator=(const GR_CairoPatternImpl &);
	cairo_pattern_t *m_pattern;
};


class GR_CairoVectorImage 
	: public GR_VectorImage
{
public:
	virtual void cairoSetSource(cairo_t *) = 0;
};

/** An abstract Cairo image */
class GR_CairoRasterImage
	: public GR_RasterImage
{
public:
	virtual GR_Image * createImageSegment(GR_Graphics * pG,const UT_Rect & rec);
	virtual void cairoSetSource(cairo_t *) = 0;
protected:
	// called by createImageSegment()
	virtual GR_CairoRasterImage *makeSubimage(const std::string & n,
											  UT_sint32 x, UT_sint32 y,
											  UT_sint32 w, UT_sint32 h) const = 0;
};

class ABI_EXPORT GR_PangoFont : public GR_Font
{

  public:
	GR_PangoFont(const char * pDesc, double dSize,
					 GR_CairoGraphics * pG,
					 const char * pLang,
					 bool bGuiFont = false);
	
	virtual ~GR_PangoFont();

	/*!
		Measure the unremapped char to be put into the cache.
		That means measuring it for a font size of 120
	 */
	virtual UT_sint32 measureUnremappedCharForCache(UT_UCS4Char cChar) const;
	virtual bool      doesGlyphExist(UT_UCS4Char g);
	virtual bool      glyphBox(UT_UCS4Char g, UT_Rect & rec, GR_Graphics * pG);
	PangoFont *       getPangoFont() const {return m_pf;}
	PangoFont *       getPangoLayoutFont() const {return m_pLayoutF;}

	void              reloadFont(GR_CairoGraphics * pG);
	double            getPointSize() const {return m_dPointSize;}
	UT_uint32         getZoom() const {return m_iZoom;}
	bool              isGuiFont () const {return m_bGuiFont;}
	const UT_String & getDescription() const {return m_sDesc;}

	virtual const char* getFamily() const;
	const PangoFontDescription * getPangoDescription() const {return m_pfdLay;}

	// ascent/descent in layout units
	UT_uint32         getAscent() const {return m_iAscent;}
	UT_uint32         getDescent() const {return m_iDescent;}

	PangoCoverage *   getPangoCoverage() const;
	PangoLanguage *   getPangoLanguage() const {return m_pPLang;}
	void              setLanguage(const char * pLang);
  private:
	UT_String              m_sDesc;
	UT_String              m_sLayoutDesc;
	double                 m_dPointSize;
	UT_uint32              m_iZoom;
	PangoFont *            m_pf;
	bool                   m_bGuiFont;
	mutable PangoCoverage *m_pCover;
	PangoFontDescription * m_pfdDev;
	PangoFontDescription * m_pfdLay;
	PangoLanguage *        m_pPLang;

	UT_uint32              m_iAscent;
	UT_uint32              m_iDescent;
	PangoFont *            m_pLayoutF;
};

class GR_PangoRenderInfo;


class ABI_EXPORT GR_CairoAllocInfo 
	: public GR_AllocInfo
{
public:
	GR_CairoAllocInfo(bool bPreview, bool bPrinter, bool double_buffered)
		: m_bPreview(bPreview),
		  m_bPrinter(bPrinter),
		  m_double_buffered(double_buffered)
	{
	}
	virtual GR_GraphicsId getType() const {return GRID_UNIX;}
	virtual bool isPrinterGraphics() const {return m_bPrinter;}
	virtual cairo_t *createCairo() = 0;

	bool            m_bPreview;
	bool            m_bPrinter;
	bool m_double_buffered;
};


class ABI_EXPORT GR_CairoGraphics : public GR_Graphics
{
	friend class GR_UnixImage;

	// all constructors are protected; instances must be created via
	// GR_GraphicsFactory
public:
	virtual ~GR_CairoGraphics();

	virtual GR_Capability  getCapability() {return GRCAP_SCREEN_ONLY;}

	virtual UT_sint32      measureUnRemappedChar(const UT_UCSChar c, UT_uint32 * height = 0);
	
	virtual void		   drawChars(const UT_UCSChar* pChars,
									 int iCharOffset, int iLength,
									 UT_sint32 xoff, UT_sint32 yoff,
									 int * pCharWidth);
                    
	virtual void           drawGlyph(UT_uint32 glyph_idx,
									 UT_sint32 xoff, UT_sint32 yoff);

	virtual UT_uint32      measureString(const UT_UCSChar* s, int iOffset,
										 int num,  UT_GrowBufElement* pWidths, UT_uint32 * height = 0);
	
	virtual GR_Font*	   getDefaultFont(UT_String& fontFamily,
										  const char * pszLang);
	
	virtual void           setFont(const GR_Font *);
	virtual void           clearFont(void) {m_pPFont = NULL;} 

	virtual void           setZoomPercentage(UT_uint32 iZoom);
	
	///////////////////////////////////////////////////////////////////
	// complex script processing
	//
	virtual bool itemize(UT_TextIterator & text, GR_Itemization & I);
	virtual bool shape(GR_ShapingInfo & si, GR_RenderInfo *& ri);
	virtual void prepareToRenderChars(GR_RenderInfo & ri);
	virtual void renderChars(GR_RenderInfo & ri);
	virtual void measureRenderedCharWidths(GR_RenderInfo & ri);
	virtual void appendRenderedCharsToBuff(GR_RenderInfo & ri, UT_GrowBuf & buf) const;
	virtual bool canBreak(GR_RenderInfo & ri, UT_sint32 &iNext, bool bAfter);

	virtual bool needsSpecialCaretPositioning(GR_RenderInfo & ri);
	virtual UT_uint32 adjustCaretPosition(GR_RenderInfo & ri, bool bForward);
	virtual void adjustDeletePosition(GR_RenderInfo & ri);
	virtual bool nativeBreakInfoForRightEdge() {return false;}
	
	virtual UT_sint32 resetJustification(GR_RenderInfo & ri, bool bPermanent);
	virtual UT_sint32 countJustificationPoints(const GR_RenderInfo & ri) const;
	virtual void      justify(GR_RenderInfo & ri);

	virtual UT_uint32 XYToPosition(const GR_RenderInfo & ri, UT_sint32 x, UT_sint32 y) const;
	virtual void      positionToXY(const GR_RenderInfo & ri,
								   UT_sint32& x, UT_sint32& y,
								   UT_sint32& x2, UT_sint32& y2,
								   UT_sint32& height, bool& bDirection) const;
	virtual UT_sint32 getTextWidth(GR_RenderInfo & ri);

	virtual const UT_VersionInfo & getVersion() const {return s_Version;}

	virtual void setColor(const UT_RGBColor& clr);
	virtual void getColor(UT_RGBColor &clr);
	
	PangoFontMap * getFontMap() const {return m_pFontMap;}
	PangoContext * getContext() const {return m_pContext;}
	PangoFontMap * getLayoutFontMap() const {return m_pLayoutFontMap;}
	PangoContext * getLayoutContext() const {return m_pLayoutContext;}

	virtual UT_uint32 getFontAscent();
	virtual UT_uint32 getFontDescent();
	virtual UT_uint32 getFontHeight();

	virtual UT_uint32 getFontAscent(const GR_Font *);
	virtual UT_uint32 getFontDescent(const GR_Font *);
	virtual UT_uint32 getFontHeight(const GR_Font *);

	virtual void		fillRect(GR_Color3D c,
								 UT_sint32 x, UT_sint32 y,
								 UT_sint32 w, UT_sint32 h);
	virtual void		fillRect(GR_Color3D c, UT_Rect &r);   
	virtual void		polygon(UT_RGBColor& c,UT_Point *pts,UT_uint32 nPoints);
	virtual void		clearArea(UT_sint32, UT_sint32, UT_sint32, UT_sint32);  
	virtual void		drawImage(GR_Image* pImg, UT_sint32 xDest, UT_sint32 yDest);
	virtual void		xorLine(UT_sint32, UT_sint32, UT_sint32, UT_sint32);
	virtual void		polyLine(UT_Point * pts, UT_uint32 nPoints);
	virtual void		fillRect(const UT_RGBColor& c,
								 UT_sint32 x, UT_sint32 y,
								 UT_sint32 w, UT_sint32 h);
	virtual void		invertRect(const UT_Rect* pRect);
	virtual void		drawLine(UT_sint32, UT_sint32, UT_sint32, UT_sint32);

	bool isDingbat(void) const {return m_bIsDingbat;}
	bool isSymbol(void) const {return m_bIsSymbol;};
	
	void resetFontMapResolution(void);

	virtual GR_Font* _findFont(const char* pszFontFamily,
							   const char* pszFontStyle,
							   const char* pszFontVariant,
							   const char* pszFontWeight,
							   const char* pszFontStretch,
							   const char* pszFontSize,
							   const char* pszLang);
	
	virtual void getCoverage(UT_NumberVector& coverage);
	virtual void setLineWidth(UT_sint32);
	virtual void setClipRect(const UT_Rect* pRect);
	virtual UT_uint32 getDeviceResolution(void) const;
	double    getResolutionRatio(void) const { return 1.0;}

	static  const std::vector<std::string> &       getAllFontNames(void);
	static  UT_uint32                         getAllFontCount();
	virtual GR_Font * getDefaultFont(GR_Font::FontFamilyEnum f = GR_Font::FF_Roman,
									 const char * pszLang = NULL);

	int dtpu(int d) const;
	int ptdu(int p) const;
	int ptlu(int p) const;
	int ptlunz(int p) const;
	int ltpu(int l) const;
	int ltpunz(int l) const;
	int pftlu(int pf) const;

	virtual bool		queryProperties(GR_Graphics::Properties gp) const;
//	virtual GR_Image*	createNewImage(const char* pszName,
//									   const UT_ByteBuf* pBB,
//									   UT_sint32 iDisplayWidth,
//									   UT_sint32 iDisplayHeight,
//									   GR_Image::GRType =GR_Image::GRT_Raster);
 
  	virtual bool		startPrint(void);
	virtual bool		endPrint(void);
	virtual bool		startPage(const char * szPageLabel,
								  UT_uint32 pageNumber,
								  bool bPortrait,
								  UT_uint32 iWidth, UT_uint32 iHeight);

	virtual void		setColorSpace(GR_Graphics::ColorSpace c);
	virtual GR_Graphics::ColorSpace getColorSpace(void) const;
	
	// virtual void		setCursor(GR_Graphics::Cursor c);
	virtual GR_Graphics::Cursor getCursor(void) const;

	virtual void		setColor3D(GR_Color3D c);
	virtual bool		getColor3D(GR_Color3D name, UT_RGBColor &color);

	// virtual void		scroll(UT_sint32, UT_sint32);
	// virtual void		scroll(UT_sint32 x_dest, UT_sint32 y_dest,
	//						   UT_sint32 x_src, UT_sint32 y_src,
	//						   UT_sint32 width, UT_sint32 height);

	virtual void	    	saveRectangle(UT_Rect & r, UT_uint32 iIndx);
	virtual void	    	restoreRectangle(UT_uint32 iIndx);
	// virtual GR_Image *  genImageFromRectangle(const UT_Rect & r);

	virtual void setLineProperties(double inWidth, 
					 GR_Graphics::JoinStyle inJoinStyle = JOIN_MITER,
					 GR_Graphics::CapStyle inCapStyle   = CAP_BUTT,
					 GR_Graphics::LineStyle inLineStyle = LINE_SOLID);
	cairo_t* getCairo ();
	void setCairo(cairo_t *cr);

	static UT_uint32 getDefaultDeviceResolution();

  protected:
	// setup the graphics properties like color and clip if they have been set
	void _setProps();
	virtual void		_resetClip(void);

	// this is called to get the surface out of what is drawning.
	static cairo_surface_t * _getCairoSurfaceFromContext(cairo_t *cr, 
												const cairo_rectangle_t & rect);
	static void _setSource(cairo_t *, const UT_RGBColor &);

	// all instances have to be created via GR_GraphicsFactory; see gr_Graphics.h
	GR_CairoGraphics(cairo_t *cr, UT_uint32 iDeviceResolution);
	GR_CairoGraphics();
	inline bool _scriptBreak(GR_PangoRenderInfo &ri);

	void _scaleCharacterMetrics(GR_PangoRenderInfo & RI);
	void _scaleJustification(GR_PangoRenderInfo & RI);

	inline UT_uint32 _measureExtent (PangoGlyphString * pg,
									 PangoFont * pf,
									 UT_BidiCharType iDir,
									 const char * pUtf8,
									 int * & pLogOffsets,
									 UT_sint32 & iStart,
									 UT_sint32 & iEnd);
	
	inline int * _calculateLogicalOffsets (PangoGlyphString * pGlyphs,
										   UT_BidiCharType iVisDir,
										   const char * pUtf8);

	void         _setIsSymbol(bool b) {m_bIsSymbol = b;}
	void         _setIsDingbat(bool b) {m_bIsDingbat = b;}

	PangoFont *  _adjustedPangoFont (GR_PangoFont * pFont, PangoFont * pf);
	PangoFont *  _adjustedLayoutPangoFont (GR_PangoFont * pFont, PangoFont * pf);
 
	double            _tdudX(UT_sint32 layoutUnits) const;
	double            _tdudY(UT_sint32 layoutUnits) const;
 	
	PangoFontMap *    m_pFontMap;
	PangoContext *    m_pContext;
	PangoFontMap *    m_pLayoutFontMap;
	PangoContext *    m_pLayoutContext;
	GR_PangoFont* m_pPFont;
	GR_PangoFont* m_pPFontGUI;

	// adjusted device front caching
	PangoFont *       m_pAdjustedPangoFont;
	PangoFontDescription* m_pAdjustedPangoFontDescription;
	UT_sint32         m_iAdjustedPangoFontSize;
		
	// adjusted layout font caching
	PangoFont *       m_pAdjustedLayoutPangoFont;
	PangoFontDescription* m_pAdjustedLayoutPangoFontDescription;
	UT_sint32         m_iAdjustedLayoutPangoFontSize;
	
	UT_uint32         m_iDeviceResolution;

	cairo_t	*         m_cr;
	
	GR_Graphics::Cursor	    m_cursor;
	GR_Graphics::ColorSpace	m_cs;

	UT_RGBColor		m_3dColors[COUNT_3D_COLORS];

	UT_RGBColor		m_curColor;
	bool            m_curColorDirty;
	bool            m_clipRectDirty;
	double                 m_lineWidth;
	GR_Graphics::JoinStyle m_joinStyle;
	GR_Graphics::CapStyle  m_capStyle;
	GR_Graphics::LineStyle m_lineStyle;
	bool            m_linePropsDirty;
	bool                    m_bIsSymbol;       
	bool                    m_bIsDingbat;
	UT_sint32               m_iPrevX1;
	UT_sint32               m_iPrevX2;
	UT_sint32               m_iPrevY1;
	UT_sint32               m_iPrevY2;
	UT_uint32               m_iPrevRect;
	UT_sint32               m_iXORCount;
	
	/** init the cairo context once created */
	void _initCairo();

	// Double buffering implementation
	void _DeviceContext_SwitchToBuffer();
	void _DeviceContext_SwitchToScreen();

	// Suspend / resume drawing
	void _DeviceContext_SuspendDrawing();
	void _DeviceContext_ResumeDrawing();
	
	// save / restore rectangle vectors
	std::vector<UT_Rect*> m_vSaveRect;
	std::vector<cairo_surface_t*> m_vSaveRectBuf;

private:
	static UT_uint32 s_iInstanceCount;
	static UT_VersionInfo s_Version;
	static int s_iMaxScript;
	/** common private init for pango called from the constructor */
	void _initPango();
};


#endif
