#include "TextSymbol.h"
#include"clsCrSurf.h"
#include"clsXML.h"
#include"clsUtil.h"
#include"clsMalloc.h"
#include "clsJson.h"
#include "clsPtree.h"
#include <math.h>
namespace DmapCore_30
{
	TextSymbol::TextSymbol()
	{
		m_pCrExtents = new cairo_text_extents_t();
		m_sFont = "Sans";
		m_dXdis = 0;
		m_dYdis = 0;
		m_bBackGround = false;
		m_bGlowing = false;      //发光
		m_bShadow = false; // 阴影
		m_iAntialiasing = false;  //防走样
		m_iSlant = 0;         //斜体
		m_iWeight = 0;          //加粗
		m_iFontSize = 10;       //字体大小
		m_iFontColor = 0xff000000;        //字体颜色 默认黑色
		r_font = 0; g_font = 0; b_font = 0; a_font = 1;
		m_iBGColor = 0xffffff00;          //背景颜色,默认白色
		r_bg = 1; g_bg = 1; b_bg = 0; a_bg = 1;
		m_iGlowingColor = 0xffff3333;     //发光色  默认(1,0.2,0.2,1)(rgba);
		r_glowing = 1; g_glowing = 0.2; b_glowing = 0.2; a_glowing = 1;
		m_iShadowColor = 0xff0000ff;      //阴影色  默认蓝色
		r_shadow = 0; g_shadow = 0; b_shadow = 1; a_shadow = 1;
	}


	TextSymbol::~TextSymbol()
	{
		if (m_pCrExtents)
			delete m_pCrExtents;
	}
	bool TextSymbol::AddRef()
	{
		m_iN++;
		return true;
	}
	bool TextSymbol::Release()
	{
		m_iN--;
		if (m_iN < 0)
			return false;
		if (!m_iN)
			delete this;
		return true;
	}

	int TextSymbol::RendererType()
	{
		return dmapTextSymbol;
	}

	bool TextSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, bool drawSimpleData, char* pFlag)
	{
		return true;
	}
	bool  TextSymbol::DrawData(clsCrSurf* pClsCS, DataCollection* data, int dataIndex, char* pFlag)
	{
		return true;
	}

	bool TextSymbol::Parse(boost::property_tree::ptree &pt, AppendBuffer *f)
	{
		clsXML clsX(f, "TEXTSYMBOL");
		clsXML::XMLAttrParse(pt, f, &m_sFont, "font");
		clsXML::XMLAttrParse(pt, f, &m_iFontSize, "fontsize");
		clsXML::XMLAttrParseColor(pt, f, &m_iFontColor, "fontcolor", "fonttransparency");
		clsXML::XMLAttrParse(pt, f, &m_dXdis, "x_dis");
		clsXML::XMLAttrParse(pt, f, &m_dYdis, "y_dis");
		clsXML::ParseEnum("antialiasing", pt, f, &m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
		clsXML::ParseEnum("slant", pt, f, &m_iSlant, "normal", "italic", "oblique");
		clsXML::ParseEnum("weight", pt, f, &m_iWeight, "normal", "bold");

		clsXML::XMLAttrParse(pt, f, &m_bBackGround, "background");
		if (m_bBackGround)
			clsXML::XMLAttrParseColor(pt, f, &m_iBGColor, "bgcolor", "bgtransparency");
		clsXML::XMLAttrParse(pt, f, &m_bGlowing, "glowing");
		if (m_bGlowing)
			clsXML::XMLAttrParseColor(pt, f, &m_iGlowingColor, "glowingcolor", "glowingtransparency");
		clsXML::XMLAttrParse(pt, f, &m_bShadow, "shadow");
		if (m_bShadow)
			clsXML::XMLAttrParseColor(pt, f, &m_iShadowColor, "shadowcolor", "shadowtransparency");
		//if (pt)
		{
			this->SetFontColor(m_iFontColor);
			this->SetBGColor(m_iBGColor);
			this->SetShadowColor(m_iShadowColor);
			this->SetGlowingColor(m_iGlowingColor);
		}
		return true;
	}

	bool TextSymbol::ParsePtree( boost::property_tree::ptree &pt)
	{
		boost::property_tree::ptree ptRenderer;
		//sprintf(resultbuff, R"("TEXTSYMBOL":{"antialiasing":"antialias_default",)");
		clsPtree::PtreeAttrParse("font", ptRenderer, this->m_sFont);
		clsPtree::PtreeAttrParse("fontsize", ptRenderer, this->m_iFontSize);
		//
		clsPtree::PtreeAttrParseColor("fontcolor", "fonttransparency", ptRenderer, m_iFontColor);
		clsPtree::PtreeAttrParse("x_dis", ptRenderer, this->m_dXdis);
		clsPtree::PtreeAttrParse("y_dis", ptRenderer, this->m_dYdis);
		//clsPtree::ParseEnum("antialiasing", ptRenderer, m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
		clsPtree::ParseEnum("slant", ptRenderer, m_iSlant,"normal", "italic", "oblique");
		clsPtree::ParseEnum("weight", ptRenderer, m_iWeight, "normal", "bold");
		clsPtree::PtreeAttrParse("background", ptRenderer, m_bBackGround);
		if (m_bBackGround)
			clsPtree::PtreeAttrParseColor("bgcolor", "bgtransparency", ptRenderer, m_iBGColor);
		
		clsPtree::PtreeAttrParse("glowing", ptRenderer, m_bGlowing);
		if (m_bGlowing)
		 	clsPtree::PtreeAttrParseColor("glowingcolor", "glowingtransparency", ptRenderer, m_iGlowingColor);
		

		clsPtree::PtreeAttrParse("shadow", ptRenderer, m_bShadow);
		if (m_bShadow)
		 	clsPtree::PtreeAttrParseColor("shadowcolor", "shadowtransparency", ptRenderer, m_iShadowColor);

		pt.add_child("TEXTSYMBOL",ptRenderer);
		return true;
	}

   void  TextSymbol::ToJson(AppendBuffer *ab)
   {
	   char buff[300] = {0};
	   char resultbuff[5000] ={0};
		sprintf(resultbuff, R"("TEXTSYMBOL":{"antialiasing":"antialias_default",)");
		clsJson::JsonAttrParse("font", resultbuff, buff, this->m_sFont);
		clsJson::JsonAttrParse("fontsize", resultbuff, buff, this->m_iFontSize);
		clsJson::JsonAttrParseColor("fontcolor", "fonttransparency", resultbuff, buff, m_iFontColor);
		clsJson::JsonAttrParse("x_dis", resultbuff, buff, this->m_dXdis);
		clsJson::JsonAttrParse("y_dis", resultbuff, buff, this->m_dYdis);
		//clsJson::ParseEnum("antialiasing", resultbuff, buff, m_iAntialiasing, "antialias_default", "antialias_none", "antialias_gray", "antialias_subpixel", "antialias_fase", "antialias_good", "antialias_best", "true", "false");
		clsJson::ParseEnum("slant", resultbuff, buff, m_iSlant,"normal", "italic", "oblique");
		clsJson::ParseEnum("weight", resultbuff, buff, m_iWeight, "normal", "bold");
		clsJson::JsonAttrParse("background", resultbuff, buff, m_bBackGround);
		if (m_bBackGround)
			clsJson::JsonAttrParseColor("bgcolor", "bgtransparency", resultbuff, buff, m_iBGColor);
		
		clsJson::JsonAttrParse("glowing", resultbuff, buff, m_bGlowing);
		if (m_bGlowing)
		 	clsJson::JsonAttrParseColor("glowingcolor", "glowingtransparency", resultbuff, buff, m_iGlowingColor);
		

		clsJson::JsonAttrParse("shadow", resultbuff, buff, m_bShadow);
		if (m_bShadow)
		 	clsJson::JsonAttrParseColor("shadowcolor", "shadowtransparency", resultbuff, buff, m_iShadowColor);

		clsJson::JsonAttrEnd(resultbuff);
		ab->AppendString(resultbuff);
   }


	const char* TextSymbol::GetFont()
	{
		return m_sFont.c_str();
	}
	bool   TextSymbol::SetFont(const char* sFont)
	{
		m_sFont = sFont;
		return true;
	}
	double TextSymbol::GetXdis()
	{
		return m_dXdis;
	}
	bool   TextSymbol::SetXdis(double dXdis)
	{
		m_dXdis = dXdis;
		return true;
	}
	double TextSymbol::GetYdis()
	{
		return m_dYdis;
	}
	bool   TextSymbol::SetYdis(double dYdis)
	{
		m_dYdis = dYdis;
		return true;
	}

	bool   TextSymbol::GetBackGround()
	{
		return m_bBackGround;
	}
	bool   TextSymbol::SetBackGround(bool bBackGround)
	{
		m_bBackGround = bBackGround;
		return  true;
	}
	bool   TextSymbol::GetGlowing()
	{
		return m_bGlowing;
	}
	bool   TextSymbol::SetGlowing(bool bGlowing)
	{
		m_bGlowing = bGlowing;
		return true;
	}
	bool   TextSymbol::GetShadow()
	{
		return m_bShadow;
	}
	bool   TextSymbol::SetShadow(bool bShadow)
	{
		m_bShadow = bShadow;
		return true;
	}
	int    TextSymbol::GetAntialiasing()
	{
		return m_iAntialiasing;
	}
	bool   TextSymbol::SetAntialiasing(int iAntialiasing)
	{
		m_iAntialiasing = iAntialiasing;
		return true;
	}

	int    TextSymbol::GetFontSize()
	{
		return m_iFontSize;
	}
	bool   TextSymbol::SetFontSize(int iFontSize)
	{
		m_iFontSize = iFontSize;
		return true;
	}
	int   TextSymbol::GetSlant()
	{
		return m_iSlant;
	}
	bool   TextSymbol::SetSlant(int  iSlant)
	{
		m_iSlant = iSlant;
		return true;
	}
	int   TextSymbol::GetWeight()
	{
		return m_iWeight;
	}
	bool   TextSymbol::SetWeight(int iWeight)
	{
		m_iWeight = iWeight;
		return true;
	}
	unsigned int    TextSymbol::GetFontColor()
	{
		return m_iFontColor;
	}
	bool   TextSymbol::SetFontColor(unsigned int iColor)
	{
		m_iFontColor = iColor;
		clsUtil::ToCairoColor(iColor, r_font, g_font, b_font, a_font);
		return true;
	}
	unsigned int    TextSymbol::GetBGColor()
	{
		return m_iBGColor;
	}
	bool   TextSymbol::SetBGColor(unsigned int iColor)
	{
		m_iBGColor = iColor;
		clsUtil::ToCairoColor(iColor, r_bg, g_bg, b_bg, a_bg);
		return true;
	}
	unsigned int    TextSymbol::GetGlowingColor()
	{
		return m_iGlowingColor;
	}
	bool   TextSymbol::SetGlowingColor(unsigned int iColor)
	{
		m_iGlowingColor = iColor;
		clsUtil::ToCairoColor(iColor, r_glowing, g_glowing, b_glowing, a_glowing);
		return true;
	}
	unsigned int    TextSymbol::GetShadowColor()
	{
		return m_iShadowColor;
	}
	bool   TextSymbol::SetShadowColor(unsigned int iColor)
	{
		m_iShadowColor = iColor;
		clsUtil::ToCairoColor(iColor, r_shadow, g_shadow, b_shadow, a_shadow);
		return true;
	}


	bool TextSymbol::SetCairo(clsCrSurf* pClsCS)
	{
		cairo_t* cr = pClsCS->m_pCr;

		clsMalloc clsM;
		const char* utf8 = m_sFont.c_str();

		/*bool flag = clsUtil::ConvertEncGB18030_UTF8(ss, clsM);
		if (!flag)
			return false;

		char* utf8 = clsM.mem;*/
		cairo_select_font_face(cr, utf8, (cairo_font_slant_t)m_iSlant, (cairo_font_weight_t)m_iWeight);
		cairo_set_font_size(cr, m_iFontSize);

		return true;
	}


	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8)
	{
		x += m_dXdis;
		y += m_dYdis;
		cairo_t* cr = pClsCS->m_pCr;
		//cairo_font_options_set_antialias(cfo, CAIRO_ANTIALIAS_GRAY);
		cairo_text_extents(cr, sUTF8, m_pCrExtents);
		int iX = (int)x;                          int iY = (int)y;
		int iTextW = (int)(m_pCrExtents->x_advance);  int iTextH = (int)(m_pCrExtents->height);
		//int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;

		/*
		文字避让部分
		*/

		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		int xFrom = iX / gridsize;
		int xTo = (iX + iTextW) / gridsize;
		int yTo = iY / gridsize;
		int yFrom = (iY - iTextH) / gridsize;

		char * pFlag = pClsCS->m_pFlag;
		int iFlagW = pClsCS->m_iFlagW;
		int iFlagH = pClsCS->m_iFlagH;
		/*if (xFrom < 0 || yFrom < 0 || xTo >= iFlagW || yTo >= iFlagH)
			return false;*/

		if (xTo < 0 || xFrom >= iFlagW || yFrom >= iFlagH || yTo < 0)return true;
		if (xFrom < 0)xFrom = 0;
		if (xTo >= iFlagW)xTo = iFlagW - 1;
		if (yFrom < 0)yFrom = 0;
		if (yTo >= iFlagH)yTo = iFlagH - 1;

		/*if (xTo < 0)xTo = 0;
		if (xFrom >= iFlagW)xFrom = iFlagW - 1;
		if (yTo < 0)yTo = 0;
		if (yFrom >= iFlagH)yFrom = iFlagH - 1;*/


		/*
		if (xFrom < 0)xFrom = 0;
		if (xTo > iFlagW) xTo = iFlagW;
		if (xFrom > xTo)
		{
		xFrom = xFrom;
		}
		if (yFrom < 0)yFrom = 0;
		if (yTo > iFlagH) yTo = iFlagH;
		*/

		char *pFlagThis = pFlag + yFrom*iFlagW;
		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
		{
			char *pFlagThisNow = pFlagThis + xFrom;
			for (int j = xFrom; j <= xTo; j++, pFlagThisNow++)
			{
				if (*pFlagThisNow)return false;
				//if (pFlag[iFlagW*i + j])	return false;
			}
		}
		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


		/*
		如果有背景,绘制背景
		*/
		if (m_bBackGround)
		{
			cairo_new_path(cr);
			cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);
			cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
			cairo_fill(cr);
		}

		/*
		绘制发光
		*/
		if (m_bGlowing)
		{
			int iGlowingSize = 2;
			cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
			for (int i = -GlowingSize; i <= GlowingSize; i++)
			{
				for (int j = -GlowingSize; j <= GlowingSize; j++)
				{
					cairo_move_to(cr, x + i, y + j);
					cairo_show_text(cr, sUTF8);
				}
			}
		}

		/*
		绘制阴影
		*/
		if (m_bShadow)
		{
			cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
			if (m_bGlowing)
				cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
			else
				cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
			cairo_show_text(cr, sUTF8);
		}


		cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
		cairo_move_to(cr, x, y); cairo_show_text(cr, sUTF8);


		/*
		标记避让
		*/
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		pFlagThis = pFlag + yFrom*iFlagW;
		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
		{
			memset(pFlagThis + xFrom, 1, (xTo - xFrom + 1));
		}

		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		return true;
	}


	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8, int xp, int yp)
	{
		x += m_dXdis*xp;
		y += m_dYdis*yp;
		cairo_t* cr = pClsCS->m_pCr;

		cairo_text_extents(cr, sUTF8, m_pCrExtents);
		int iX = (int)x;                          int iY = (int)y;
		int iTextW = (int)(m_pCrExtents->x_advance);  int iTextH = (int)(m_pCrExtents->height);
		//int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;

		/*
		文字避让部分
		*/

		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		int xFrom = iX / gridsize;
		int xTo = (iX + iTextW) / gridsize;
		int yTo = iY / gridsize;
		int yFrom = (iY - iTextH) / gridsize;

		char * pFlag = pClsCS->m_pFlag;
		int iFlagW = pClsCS->m_iFlagW;
		int iFlagH = pClsCS->m_iFlagH;
		/*if (xFrom < 0 || yFrom < 0 || xTo >= iFlagW || yTo >= iFlagH)
		return false;*/

		if (xTo < 0 || xFrom >= iFlagW || yFrom >= iFlagH || yTo < 0)return true;
		if (xFrom < 0)xFrom = 0;
		if (xTo >= iFlagW)xTo = iFlagW - 1;
		if (yFrom < 0)yFrom = 0;
		if (yTo >= iFlagH)yTo = iFlagH - 1;

		/*if (xTo < 0)xTo = 0;
		if (xFrom >= iFlagW)xFrom = iFlagW - 1;
		if (yTo < 0)yTo = 0;
		if (yFrom >= iFlagH)yFrom = iFlagH - 1;*/


		/*
		if (xFrom < 0)xFrom = 0;
		if (xTo > iFlagW) xTo = iFlagW;
		if (xFrom > xTo)
		{
		xFrom = xFrom;
		}
		if (yFrom < 0)yFrom = 0;
		if (yTo > iFlagH) yTo = iFlagH;
		*/

		char *pFlagThis = pFlag + yFrom*iFlagW;
		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
		{
			char *pFlagThisNow = pFlagThis + xFrom;
			for (int j = xFrom; j <= xTo; j++, pFlagThisNow++)
			{
				if (*pFlagThisNow)return false;
				//if (pFlag[iFlagW*i + j])	return false;
			}
		}
		//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


		/*
		如果有背景,绘制背景
		*/
		if (m_bBackGround)
		{
			cairo_new_path(cr);
			cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);
			cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
			cairo_fill(cr);
		}

		/*
		绘制发光
		*/
		if (m_bGlowing)
		{
			int iGlowingSize = 2;
			cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
			for (int i = -GlowingSize; i <= GlowingSize; i++)
			{
				for (int j = -GlowingSize; j <= GlowingSize; j++)
				{
					cairo_move_to(cr, x + i, y + j);
					cairo_show_text(cr, sUTF8);
				}
			}
		}

		/*
		绘制阴影
		*/
		if (m_bShadow)
		{
			cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
			if (m_bGlowing)
				cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
			else
				cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
			cairo_show_text(cr, sUTF8);
		}


		cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
		cairo_move_to(cr, x, y); cairo_show_text(cr, sUTF8);


		/*
		标记避让
		*/
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		pFlagThis = pFlag + yFrom*iFlagW;
		for (int i = yFrom; i <= yTo; i++, pFlagThis += iFlagW)
		{
			memset(pFlagThis + xFrom, 1, (xTo - xFrom + 1));
		}

		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		return true;
	}

	

	bool TextSymbol::DrawAText(clsCrSurf* pClsCS, double x, double y, char* sUTF8, double dAngle)
	{
		x += m_dXdis;
		y += m_dYdis;
		//顺时针
		if (dAngle == 0)
			return this->DrawAText(pClsCS, x, y, sUTF8);

		cairo_t* cr = pClsCS->m_pCr;
	
		cairo_text_extents(cr, sUTF8, m_pCrExtents);
		int iX = (int)x;                          int iY = (int)y;
		int iTextW = (int)(m_pCrExtents->x_advance);  int iTextH = (int)(m_pCrExtents->height);
		int surf_w = pClsCS->m_iW;                int surf_h = pClsCS->m_iH;



		/*
		检查文字避让
		*/
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		假设对图片上任意点(x,y)，绕一个坐标点(rx0,ry0)逆时针旋转a角度后的新的坐标设为(x0, y0)，有公式：
		x0= (x - rx0)*cos(a) - (y - ry0)*sin(a) + rx0 ;
		y0= (x - rx0)*sin(a) + (y - ry0)*cos(a) + ry0 ;
		*/
		int xFrom = iX / gridsize;
		int xTo = (iX + iTextW) / gridsize;
		int yTo = iY / gridsize;
		int yFrom = (iY - iTextH) / gridsize;

		char * pFlag = pClsCS->m_pFlag;
		int iFlagW = pClsCS->m_iFlagW;
		int iFlagH = pClsCS->m_iFlagH;

		if (xFrom < 0)xFrom = 0;
		if (xTo >= iFlagW) xTo = iFlagW - 1;
		if (yFrom < 0)yFrom = 0;
		if (yTo >= iFlagH) yTo = iFlagH - 1;

	
		//选择其实不对
		for (int i = yFrom; i <= yTo; i++)
		{
			for (int j = xFrom; j <= xTo; j++)
			{
				double x_this = j*gridsize;
				double y_this = i*gridsize;
				double x_this_ = (x_this - x)*std::cos(dAngle) - (y_this - y)*std::sin(dAngle) + x;
				double y_this_ = (x_this - x)*std::sin(dAngle) + (y_this - y)*std::cos(dAngle) + y;
				if (x_this_ == x_this_ && y_this_ == y_this_)
				{
					int iXThis = ((int)(x_this_)) / gridsize;
					int iYThis = ((int)(y_this_)) / gridsize;

					if (iYThis*iFlagW + iXThis<0 || pFlag[iYThis*iFlagW + iXThis])
						return false;
				}
				else
				{
					return true;
				}
			}
		}
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




		{
			/*
			如果有背景,绘制背景
			*/
			if (m_bBackGround)
			{
				cairo_new_path(cr);
				cairo_move_to(cr, x, y);
				cairo_rotate(cr, dAngle);
				//cairo_rectangle(cr, x, y - iTextH, iTextW, iTextH);

				{
					cairo_rel_line_to(cr, iTextW, 0);
					cairo_rel_line_to(cr, 0, -iTextH);
					cairo_rel_line_to(cr, -iTextW, 0);
					cairo_close_path(cr);
				}
				cairo_rotate(cr, -dAngle);
				cairo_set_source_rgba(cr, r_bg, g_bg, b_bg, a_bg);
				cairo_fill(cr);
			}

			/*
			绘制发光
			*/
			if (m_bGlowing)
			{
				int iGlowingSize = 2;
				cairo_set_source_rgba(cr, r_glowing, g_glowing, b_glowing, a_glowing);
				for (int i = -GlowingSize; i <= GlowingSize; i++)
				{
					for (int j = -GlowingSize; j <= GlowingSize; j++)
					{
						cairo_move_to(cr, x + i, y + j);
						cairo_rotate(cr, dAngle);
						cairo_show_text(cr, sUTF8);
						cairo_rotate(cr, -dAngle);
					}
				}
			}

			/*
			绘制阴影
			*/
			if (m_bShadow)
			{
				int iShadowSize = 2;
				cairo_set_source_rgba(cr, r_shadow, g_shadow, b_shadow, a_shadow);
				if (m_bGlowing)
					cairo_move_to(cr, x + ShadowSize + GlowingSize, y + ShadowSize + GlowingSize);
				else
					cairo_move_to(cr, x + ShadowSize, y + ShadowSize);
				cairo_rotate(cr, dAngle); cairo_show_text(cr, sUTF8); cairo_rotate(cr, -dAngle);
			}


			cairo_set_source_rgba(cr, r_font, g_font, b_font, a_font);
			cairo_move_to(cr, x, y);
			cairo_rotate(cr, dAngle);
			cairo_show_text(cr, sUTF8);
			cairo_rotate(cr, -dAngle);

			/*cairo_set_source_rgba(cr, 1, 0.2, 0.2, 1);
			cairo_set_line_width(cr, 1);
			cairo_move_to(cr, x, y);
			cairo_rotate(cr, dAngle);
			cairo_rel_line_to(cr, iTextW,0);
			cairo_rel_line_to(cr, 0, -iTextH);
			cairo_rel_line_to(cr, -iTextW, 0);
			cairo_close_path(cr);
			cairo_stroke(cr);
			cairo_rotate(cr, -dAngle);*/
		}

		/*
		处理文字避让
		*/
		for (int i = yFrom; i <= yTo; i++)
		{
			for (int j = xFrom; j <= xTo; j++)
			{
				double x_this = j*gridsize;
				double y_this = i*gridsize;
				double x_this_ = (x_this - x)*cos(dAngle) - (y_this - y)*sin(dAngle) + x;
				double y_this_ = (x_this - x)*sin(dAngle) + (y_this - y)*cos(dAngle) + y;
				int iXThis = ((int)(x_this_)) / gridsize;
				int iYThis = ((int)(y_this_)) / gridsize;

				pFlag[iYThis*iFlagW + iXThis] = 1;
			}
		}

		return true;
	}

	bool TextSymbol::DrawLegend(clsCrSurf* pClsCS, shared_ptr<legendParamater> pLegendParamater,int layerType, char* pFlag)
	{
		
		return false;
	}

}