WebSVN – public – Diff – /sportwatcher/trunk/src/render.cpp

 #include <QLabel>
 #include <QString>
 #include <QXmlReader>
 #include <QDir>
 #include <QColor>
+#include <QImage>
 #include <KStandardDirs>
 #include <KConfig>
 #include <KLocale>
 #include <KMessageBox>
 #include <KGlobalSettings>
 #include <KConfigGroup>
+#include <KIconLoader>
 #include "config.h"
 #include "render.h"
 #include <iostream>
 #define ATT_MAXDISTANCE		312
 #define ATT_PLACEMENT		313
 #define ATT_ALLOWOVERLAP	314
 #define ATT_STATUS		315
 #define ATT_SRS			316
+#define ATT_DX			317
 #define FIRST_CON		100
 #define LAST_CON		111
 #define FIRST_FLD		200
 #define LAST_FLD		205
 #define FIRST_ATT		300
-#define LAST_ATT		316
+#define LAST_ATT		317
 using std::cout;
 using std::cerr;
 using std::clog;
 using std::endl;
 	{ CON_TEXTSYMBOLIZER,		in_textsymbolizer,	QString("TextSymbolizer") },
 	{ CON_POLYGONPATTERNSYMBOLIZER,	in_polygonpatternsymbolizer,	QString("PolygonPatternSymbolizer") },
 	{ CON_LAYER,			in_layer,		QString("Layer") },
 	{ CON_DATASOURCE,		in_datasource,		QString("Datasource") },
 	{ CON_SHIELDSYMBOLIZER,		in_shieldsymbolizer,	QString("ShieldSymbolizer") },
+	{ CON_LINEPATTERNSYMBOLIZER,	in_linepatternsymbolizer, QString("LinePatternSymbolizer") },
 	// Fields
 	{ FLD_FILTER,			in_rule,		QString("Filter") },
 	{ FLD_CSSPARAMETER,		in_symbolizer,		QString("CSSParameter") },
 	{ FLD_MINSCALE,			in_rule,		QString("MinScaleDenominator") },
 	{ FLD_MAXSCALE,			in_rule,		QString("MaxScaleDenominator") },
 	{ ATT_TYPE,			in_symbolizer,		QString("type") },
 	{ ATT_WIDTH,			in_symbolizer,		QString("width") },
 	{ ATT_HEIGHT,			in_symbolizer,		QString("height") },
 	{ ATT_SIZE,			in_symbolizer,		QString("size") },
 	{ ATT_FACENAME,			in_symbolizer,		QString("face_name") },
+	{ ATT_DX,			in_symbolizer,		QString("dx") },
 	{ ATT_DY,			in_symbolizer,		QString("dy") },
 	{ ATT_HALORADIUS,		in_symbolizer,		QString("halo_radius") },
 	{ ATT_WRAPWIDTH,		in_symbolizer,		QString("wrap_width") },
 	{ ATT_MINDISTANCE,		in_symbolizer,		QString("min_distance") },
 	{ ATT_MAXDISTANCE,		in_symbolizer,		QString("max_distance") },
 	TextSymbolizer = 0;
 	PointSymbolizer = 0;
 	PolygonPatternSymbolizer = 0;
 	ShieldSymbolizer = 0;
 	LinePatternSymbolizer = 0;
+	_lx = _ly = 180.0;
+	_rx = _ry = -180.0;
 	// This is true, when a XML file was parsed successfully
 	ControlSet = false;
 	// Read settings from config file
 	KConfig cfg (QString("sportwatcher.rc"), KConfig::SimpleConfig);
 SRender::~SRender()
+{
 	startDocument();	// Clean everything
 	ControlSet = false;
+	if (!OutBuf.isEmpty())
+	   unlink (OutBuf.toAscii().data());
+}
 bool SRender::startDocument()
+{
 	m.remove_all();		// delete styles and layers from map
 	      Lay = akt;
+	   }
+	}
 	Lay = firstLayer = lastLayer = 0;
+	Rule = 0;
+	LineSymbolizer = 0;
+	PolygonSymbolizer = 0;
+	TextSymbolizer = 0;
+	PointSymbolizer = 0;
+	PolygonPatternSymbolizer = 0;
+	ShieldSymbolizer = 0;
+	LinePatternSymbolizer = 0;
+	_lx = _ly = 180.0;
+	_rx = _ry = -180.0;
+	ControlSet = false;
+	XmlLine = 1;
 	Container = in_root;
 	return true;
+}
 /*
 		 case CON_MAP:
 		    Container = in_map;
 		    if (ControlSet)	// Must be false here!
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: There is another MAP! Only one map information is allowed!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: There is another MAP! Only one map information is allowed!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    if ((index = att.index(QString("bgcolor"))) != -1)
+		    {
+		    color col;
 		       MapPars.bgcolor = colorToUInt(att.value(index));
+		       col.set_bgr(MapPars.bgcolor);
+		       m.set_background(col);
+		    }
 		    if ((index = att.index(QString("buffer_size"))) != -1)
+		    {
 		       MapPars.buf_size = att.value(index).toInt();
+		       m.set_buffer_size(MapPars.buf_size);
+		    }
 		    if ((index = att.index(QString("srs"))) != -1)
+		    {
 		       MapPars.srs = att.value(index);
-cout << "<Map bgcolor=" << MapPars.bgcolor << " buffer_size=" << MapPars.buf_size << " srs=" << MapPars.srs.toAscii().data() << ">" << endl;
+		       m.set_srs(MapPars.srs.toAscii().data());
+		    }
 		 break;
 		 case CON_STYLE:
 		    Container = in_style;
 		    if ((index = att.index(QString("name"))) != -1)
 		       Style->name = att.value(index);
 		    else
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open STYLE without a name!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open STYLE without a name!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
-cout << "   <Style name=" << Style->name.toAscii().data() << ">" << endl;
 		 break;
 		 case CON_RULE:
 		    Container = in_rule;
 		    if (!Style)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open RULE outside of a STYLE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open RULE outside of a STYLE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    Rule = getLastRule (Style->rule);
 		    else
+		    {
 		       Rule->next = allocRule();
 		       Rule = Rule->next;
+		    }
-cout << "      <Rule>" << endl;
 		 break;
 		 case CON_LAYER:
 		    Container = in_layer;
 		    if ((index = att.index(QString("status"))) != -1)
 		       Lay->status = getBool(att.value(index));
 		    if ((index = att.index(QString("srs"))) != -1)
 		       Lay->srs = att.value(index);
+		    if ((index = att.index(QString("minzoom"))) != -1)
+		       Lay->minzoom = att.value(index).toDouble();
+		    if ((index = att.index(QString("maxzoom"))) != -1)
-cout << "   <Layer name=" << Lay->name.toAscii().data() << " status=" << Lay->status << " srs=" << Lay->srs.toAscii().data() << ">" << endl;
+		       Lay->maxzoom = att.value(index).toDouble();
 		 break;
 		 case CON_DATASOURCE:
 		    Container = in_datasource;
 		 break;
 		 case CON_POINTSYMBOLIZER:
 		    Container = in_pointsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open POINTSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open POINTSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    PointSymbolizer = getLastPointSymbolizer(Rule->PointSymbolizer);
 		       if (att.value(index).toLower() == QString("true"))
 			  PointSymbolizer->allow_overlap = true;
 		       else
 			  PointSymbolizer->allow_overlap = false;
+		    }
-cout << "         <Pointsymbolizer file=" << PointSymbolizer->file.toAscii().data() << " ... >" << endl;
 		 break;
 		 break;
 		 case CON_LINESYMBOLIZER:
 		    Container = in_linesymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open LINESYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open LINESYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    LineSymbolizer = getLastLineSymbolizer(Rule->LineSymbolizer);
 		    else
+		    {
 		       LineSymbolizer->next = allocLineSymbolizer();
 		       LineSymbolizer = LineSymbolizer->next;
+		    }
-cout << "         <Linesymbolizer>" << endl;
 		 break;
 		 case CON_POLYGONSYMBOLIZER:
 		    Container = in_polygonsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open POLYGONSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open POLYGONSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    PolygonSymbolizer = getLastPolygonSymbolizer(Rule->PolygonSymbolizer);
 		    else
+		    {
 		       PolygonSymbolizer->next = allocPolygonSymbolizer();
 		       PolygonSymbolizer = PolygonSymbolizer->next;
+		    }
-cout << "         <Polygonsymbolizer>" << endl;
 		 break;
 		 case CON_TEXTSYMBOLIZER:
 		    Container = in_textsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open TEXTSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open TEXTSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    TextSymbolizer = getLastTextSymbolizer(Rule->TextSymbolizer);
 		       TextSymbolizer->halo_radius = att.value(index).toDouble();
 		    if ((index = att.index(QString("wrap_width"))) != -1)
 		       TextSymbolizer->wrap_width = att.value(index).toDouble();
+		    if ((index = att.index(QString("dx"))) != -1)
+		       TextSymbolizer->dx = att.value(index).toDouble();
 		    if ((index = att.index(QString("dy"))) != -1)
 		       TextSymbolizer->dy = att.value(index).toDouble();
 		    if ((index = att.index(QString("max_distance"))) != -1)
 		       TextSymbolizer->maxdistance = att.value(index).toDouble();
 		    if ((index = att.index(QString("min_distance"))) != -1)
 		       TextSymbolizer->mindistance = att.value(index).toDouble();
-cout << "         <Textsymbolizer name=" << TextSymbolizer->name.toAscii().data() << " ... >" << endl;
 		 break;
 		 case CON_POLYGONPATTERNSYMBOLIZER:
 		    Container = in_polygonpatternsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open POLYGONPATTERNSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open POLYGONPATTERNSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    PolygonPatternSymbolizer = getLastPolygonPatternSymbolizer(Rule->PolygonPatternSymbolizer);
 		    if ((index = att.index(QString("height"))) != -1)
 		       PolygonPatternSymbolizer->height = att.value(index).toDouble();
 		    if ((index = att.index(QString("allow_overlap"))) != -1)
 		       PolygonPatternSymbolizer->allow_overlap = getBool(att.value(index));
-cout << "         <Polygonpatternsymbolizer file=" << PolygonPatternSymbolizer->file.toAscii().data() << " ... >" << endl;
 		 break;
 		 case CON_SHIELDSYMBOLIZER:
 		    Container = in_shieldsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open SHIELDSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open SHIELDSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    ShieldSymbolizer = getLastShieldSymbolizer(Rule->ShieldSymbolizer);
 		       ShieldSymbolizer->width = att.value(index).toDouble();
 		    if ((index = att.index(QString("height"))) != -1)
 		       ShieldSymbolizer->height = att.value(index).toDouble();
+		    if ((index = att.index(QString("dx"))) != -1)
+		       ShieldSymbolizer->dx = att.value(index).toDouble();
+		    if ((index = att.index(QString("dy"))) != -1)
+		       ShieldSymbolizer->dy = att.value(index).toDouble();
 		    if ((index = att.index(QString("min_distance"))) != -1)
 		       ShieldSymbolizer->mindistance = att.value(index).toDouble();
 		    if ((index = att.index(QString("max_distance"))) != -1)
 		       ShieldSymbolizer->maxdistance = att.value(index).toDouble();
-cout << "         <Shieldsymbolizer name=" << ShieldSymbolizer->name.toAscii().data() << " ... >" << endl;
 		 break;
 		 case CON_LINEPATTERNSYMBOLIZER:
 		    Container = in_linepatternsymbolizer;
 		    if (!Rule)
+		    {
-		       KMessageBox::error(0, i18n("Error parsing %1: Open LINEPATTERNSYMBOLIZER outside of a RULE!").arg(XmlPath));
+		       KMessageBox::error(0, i18n("Error parsing %1, line %2: Open LINEPATTERNSYMBOLIZER outside of a RULE!").arg(XmlPath).arg(XmlLine));
 		       return false;
+		    }
 		    LinePatternSymbolizer = getLastLinePatternSymbolizer(Rule->LinePatternSymbolizer);
 		    if ((index = att.index(QString("width"))) != -1)
 		       LinePatternSymbolizer->width = att.value(index).toDouble();
 		    if ((index = att.index(QString("height"))) != -1)
 		       LinePatternSymbolizer->height = att.value(index).toDouble();
-cout << "         <Linepatternsymbolizer file=" << LinePatternSymbolizer->file.toAscii().data() << " ... >" << endl;
 		 break;
+	      }
+	   }
 	   i++;
 			  else if (att.value(index).toLower() == QString("stroke-dasharray"))
 			     Names = stroke_dasharray;
+		       }
 		       else
+		       {
-			  KMessageBox::error(0, i18n("Error parsing %1: Required attribute NAME is missing in CSSPARAMETER inside LINESYMBOLIZER!").arg(XmlPath));
+			  KMessageBox::error(0, i18n("Error parsing %1, line %2: Required attribute NAME is missing in CSSPARAMETER inside LINESYMBOLIZER!").arg(XmlPath).arg(XmlLine));
 			  return false;
+		       }
+		    }
 		 break;
 			  else if (att.value(index).toLower() == QString("fill-opacity"))
 			     Names = fill_opacity;
+		       }
 		       else
+		       {
-			  KMessageBox::error(0, i18n("Error parsing %1: Required attribute NAME is missing in CSSPARAMETER inside POLYGONSYMBOLIZER!").arg(XmlPath));
+			  KMessageBox::error(0, i18n("Error parsing %1, line %2: Required attribute NAME is missing in CSSPARAMETER inside POLYGONSYMBOLIZER!").arg(XmlPath).arg(XmlLine));
 			  return false;
+		       }
+		    }
 		 break;
 			  else if (att.value(index).toLower() == QString("extent"))
 			     Names = extent;
+		       }
 		       else
+		       {
-			  KMessageBox::error(0, i18n("Error parsing %1: Required attribute NAME is missing in PARAMETER inside DATASOURCE!").arg(XmlPath));
+			  KMessageBox::error(0, i18n("Error parsing %1, line %2: Required attribute NAME is missing in PARAMETER inside DATASOURCE!").arg(XmlPath).arg(XmlLine));
 			  return false;
+		       }
+		    }
 		 break;
 	      p["estimate_extent"] = (Lay->Datasource.estimate_extent) ? "true" : "false";
 	      p["extent"] = QString("%1,%2,%3,%4").arg(Lay->Datasource.ext_lx).arg(Lay->Datasource.ext_ly).arg(Lay->Datasource.ext_rx).arg(Lay->Datasource.ext_ry).toAscii().data();
+	   }
 	   else
+	   {
-	      cerr << "Warning: Layer with no source! Ingnoring!" << endl;
+	      cerr << "Warning file " << XmlPath.toAscii().data() << ", line " << XmlLine << ": Layer with no source! Ingnoring!" << endl;
 	      return true;
+	   }
 	   Layer lyr(Lay->name.toAscii().data());
+	   lyr.set_title(Lay->name.toAscii().data());
 	   lyr.set_datasource(datasource_cache::instance()->create(p));
+	   if (Lay->minzoom > 0.0)
-	   lyr.setActive(Lay->status);
+	      lyr.setMinZoom(Lay->minzoom);
+	   if (Lay->maxzoom > 0.0)
+	      lyr.setMaxZoom(Lay->maxzoom);
 	   if (!Lay->srs.isEmpty())
 	      lyr.set_srs(Lay->srs.toAscii().constData());
 	   // Add the styles
 	   for (int i = 0; i < Lay->Styles.size(); i++)
+	   {
+	      if (findStyle (Lay->Styles.at(i)) != 0)
-	      lyr.add_style(Lay->Styles.at(i).toAscii().constData());
+		 lyr.add_style(Lay->Styles.at(i).toAscii().constData());
+	      else
+		 cerr << "Warning file " << XmlPath.toAscii().data() << ", line " << XmlLine << ": Style \"" << Lay->Styles.at(i).toAscii().data() << "\" does not exist!" << endl;
+	   }
+	   lyr.setActive(Lay->status);
 	   m.addLayer(lyr);
+	   Envelope <double>le(lyr.envelope());
+	   setMaxExtent(le.minx(), le.miny(), le.maxx(), le.maxy());
+	}
 	else if (qName.toLower() == QString("map"))
+	{
-	color col;
 	   Container = in_root;
-	   col.set_bgr(MapPars.bgcolor);
-	   m.set_background(col);
-	   m.set_buffer_size(MapPars.buf_size);
 	   ControlSet = true;
+	}
-	else if (qName.toLower() == QString("pointsymbol") ||
+	else if (qName.toLower() == QString("pointsymbolizer"))
-		 qName.toLower() == QString("linesymbol") ||
-		 qName.toLower() == QString("polygonsymbol") ||
-		 qName.toLower() == QString("textsymbol") ||
-		 qName.toLower() == QString("polygonpatternsymbol") ||
-		 qName.toLower() == QString("shieldsymbol") ||
-		 qName.toLower() == QString("linepatternsymbol") ||
-		 qName.toLower() == QString("filter") ||
-		 qName.toLower() == QString("maxscaledenominator") ||
-		 qName.toLower() == QString("minscaledenominator"))
+	{
 	   Container = in_rule;
-	else if (qName.toLower() == QString("rule"))
+	   if (!Rule || !PointSymbolizer)
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of POINTSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
-	   Container = in_style;
+	      return false;
+	   }
+	   if (PointSymbolizer->file.length() == 0 || PointSymbolizer->width == 0 || PointSymbolizer->height == 0)
+	   {
+	      cerr << "Warning file " << XmlPath.toAscii().data() << ", line " << XmlLine << ": Empty POINTSYMBOLIZER!" << endl;
+	      point_symbolizer psym;
+	      Rule->rl.append(psym);
+	   }
+	   else
+	   {
+	      point_symbolizer ps(PointSymbolizer->file.toAscii().data(), getTypeText(PointSymbolizer->type), PointSymbolizer->width, PointSymbolizer->height);
+	      ps.set_allow_overlap (PointSymbolizer->allow_overlap);
+	      Rule->rl.append(ps);
+	   }
+	}
-	else if (qName.toLower() == QString("style"))
+	else if (qName.toLower() == QString("linesymbolizer"))
+	{
-	   Container = in_map;
+	   Container = in_rule;
-	   feature_type_style style;
-	   if (Style->rule)
+	   if (!Rule || !LineSymbolizer)
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of LINESYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
-	      rule_type rule;
+	      return false;
-	      Rule = Style->rule;
+	   }
-	      while (Rule)
+	   stroke st;
-	      {
+	   color col;
-		 if (Rule->minscale >= 0.0)
-		    rule.set_min_scale(Rule->minscale);
+	   col.set_bgr(LineSymbolizer->stroke);
-		 if (Rule->maxscale >= 0.0)
-		    rule.set_max_scale(Rule->maxscale);
+	   st.set_color (col);
-		 if (!Rule->filter.isEmpty())
+	   if (LineSymbolizer->stroke_width != 0.0)
-		    rule.set_filter(create_filter(Rule->filter.toAscii().data()));
+	      st.set_width (LineSymbolizer->stroke_width);
-		 LineSymbolizer = Rule->LineSymbolizer;
+	   if (!LineSymbolizer->stroke_linejoin.isEmpty())
+	   {
+	      if (LineSymbolizer->stroke_linejoin.toLower() == QString("miter"))
+		 st.set_line_join (mapnik::MITER_JOIN);
+	      else if (LineSymbolizer->stroke_linejoin.toLower() == QString("miter_revert") ||
+			 LineSymbolizer->stroke_linejoin.toLower() == QString("miter-revert"))
+		 st.set_line_join (mapnik::MITER_REVERT_JOIN);
+	      else if (LineSymbolizer->stroke_linejoin.toLower() == QString("round"))
+		 st.set_line_join (mapnik::ROUND_JOIN);
+	      else if (LineSymbolizer->stroke_linejoin.toLower() == QString("bevel"))
+		 st.set_line_join (mapnik::BEVEL_JOIN);
+	      else
+		 cerr << "Error parsing " << XmlPath.toAscii().data() << ", line " << XmlLine << ": Unknown >>line_join<< \"" << LineSymbolizer->stroke_linejoin.toAscii().data() << "\" --> ignoring!" << endl;
+	   }
-		 while (LineSymbolizer)
+	   if (!LineSymbolizer->stroke_linecap.isEmpty())
-		 {
+	   {
+	      if (LineSymbolizer->stroke_linecap.toLower() == QString("butt"))
-		    stroke st;
+		st.set_line_cap (mapnik::BUTT_CAP);
+	      else if (LineSymbolizer->stroke_linecap.toLower() == QString("square"))
-		    color col;
+		st.set_line_cap (mapnik::SQUARE_CAP);
+	      else if (LineSymbolizer->stroke_linecap.toLower() == QString("round"))
-		    col.set_bgr(LineSymbolizer->stroke);
+		st.set_line_cap (mapnik::ROUND_CAP);
+	      else
+		 cerr << "Error parsing " << XmlPath.toAscii().data() << ", line " << XmlLine << ": Unknown >>line_cap<< \"" << LineSymbolizer->stroke_linecap.toAscii().data() << "\" --> ignoring!" << endl;
+	   }
-		    st.set_color (col);
+	   if (LineSymbolizer->stroke_dasharray[0] > 0 || LineSymbolizer->stroke_dasharray[1] > 0)
-		    st.set_width (LineSymbolizer->stroke_width);
+	      st.add_dash(LineSymbolizer->stroke_dasharray[0], LineSymbolizer->stroke_dasharray[1]);
-		    if (!LineSymbolizer->stroke_linejoin.isEmpty())
+	   if (LineSymbolizer->stroke_opacity != 0)
-		    {
-		       if (LineSymbolizer->stroke_linejoin.toLower() == QString("miter"))
-			   st.set_line_join (mapnik::MITER_JOIN);
-		       else if (LineSymbolizer->stroke_linejoin.toLower() == QString("miter_revert") ||
-			        LineSymbolizer->stroke_linejoin.toLower() == QString("miter-revert"))
-			   st.set_line_join (mapnik::MITER_REVERT_JOIN);
-		       else if (LineSymbolizer->stroke_linejoin.toLower() == QString("round"))
-			   st.set_line_join (mapnik::ROUND_JOIN);
-		       else if (LineSymbolizer->stroke_linejoin.toLower() == QString("bevel"))
-			   st.set_line_join (mapnik::BEVEL_JOIN);
-		       else
-		       {
-			   cerr << "Error parsing " << XmlPath.toAscii().data() << ": Unknown >>line_join<< \"" << LineSymbolizer->stroke_linejoin.toAscii().data() << "\" --> ignoring!" << endl;
-			   LineSymbolizer = LineSymbolizer->next;
+	      st.set_opacity(LineSymbolizer->stroke_opacity);
-			   continue;
-		       }
-		    }
-		    if (!LineSymbolizer->stroke_linecap.isEmpty())
+	   Rule->rl.append(line_symbolizer(st));
-		    {
+	}
-		       if (LineSymbolizer->stroke_linecap.toLower() == QString("butt"))
-			  st.set_line_cap (mapnik::BUTT_CAP);
-		       else if (LineSymbolizer->stroke_linecap.toLower() == QString("square"))
+	else if (qName.toLower() == QString("polygonsymbolizer"))
-			  st.set_line_cap (mapnik::SQUARE_CAP);
-		       else if (LineSymbolizer->stroke_linecap.toLower() == QString("round"))
-			  st.set_line_cap (mapnik::ROUND_CAP);
-		       else
-		       {
+	{
-			   cerr << "Error parsing " << XmlPath.toAscii().data() << ": Unknown >>line_cap<< \"" << LineSymbolizer->stroke_linecap.toAscii().data() << "\" --> ignoring!" << endl;
-			   LineSymbolizer = LineSymbolizer->next;
-			   continue;
+	   Container = in_rule;
-		       }
-		    }
-		    st.add_dash(LineSymbolizer->stroke_dasharray[0], LineSymbolizer->stroke_dasharray[1]);
-		    st.set_opacity(LineSymbolizer->stroke_opacity);
+	   if (!Rule || !PolygonSymbolizer)
+	   {
-		    rule.append(line_symbolizer(st));
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of POLYGONSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
-		    LineSymbolizer = LineSymbolizer->next;
+	      return false;
-		 }
+	   }
+	   color col;
-		 PointSymbolizer = Rule->PointSymbolizer;
+	   col.set_bgr(PolygonSymbolizer->fill);
-		 while (PointSymbolizer)
+	   polygon_symbolizer ps(col);
-		 {
-		    if (PointSymbolizer->file.length() == 0 || PointSymbolizer->width == 0 || PointSymbolizer->height == 0)
-		    {
-		       cerr << "Warning parsing " << XmlPath.toAscii().data() << ": Ignoring empty POINTSYMBOLIZER!" << endl;
-		       break;
-		    }
-		    point_symbolizer ps(PointSymbolizer->file.toAscii().data(), getTypeText(PointSymbolizer->type), PointSymbolizer->width, PointSymbolizer->height);
-		    ps.set_allow_overlap (PointSymbolizer->allow_overlap);
+	   if (PolygonSymbolizer->fill_opacity > 0.0)
-		    rule.append(ps);
-		    PointSymbolizer = PointSymbolizer->next;
+	      ps.set_opacity(PolygonSymbolizer->fill_opacity);
-		 }
+	   Rule->rl.append(ps);
+	}
-		 PolygonSymbolizer = Rule->PolygonSymbolizer;
+	else if (qName.toLower() == QString("textsymbolizer"))
+	{
+	   Container = in_rule;
-		 while (PolygonSymbolizer)
+	   if (!Rule || !TextSymbolizer)
-		 {
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of TEXTSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
-		    color col;
+	      return false;
-		    col.set_bgr(PolygonSymbolizer->fill);
+	   }
-		    polygon_symbolizer ps(col);
+	   color col;
-		    ps.set_opacity(PolygonSymbolizer->fill_opacity);
+	   col.set_bgr(TextSymbolizer->fill);
-		    rule.append(ps);
-		    PolygonSymbolizer = PolygonSymbolizer->next;
-		 }
-		 TextSymbolizer = Rule->TextSymbolizer;
+	   text_symbolizer ts(TextSymbolizer->name.toAscii().data(), TextSymbolizer->face_name.toAscii().data(), TextSymbolizer->size, col);
-		 while (TextSymbolizer)
+	   if (TextSymbolizer->halo_radius != 0.0)
-		 {
-		    color col;
-		    col.set_bgr(TextSymbolizer->fill);
+	      ts.set_halo_radius((unsigned int)TextSymbolizer->halo_radius);
-		    text_symbolizer ts(TextSymbolizer->name.toAscii().data(), TextSymbolizer->face_name.toAscii().data(), TextSymbolizer->size, col);
-		    ts.set_halo_radius((unsigned int)TextSymbolizer->halo_radius);
+	   if (TextSymbolizer->wrap_width != 0.0)
-		    ts.set_wrap_width((unsigned int)TextSymbolizer->wrap_width);
+	      ts.set_wrap_width((unsigned int)TextSymbolizer->wrap_width);
-		    ts.set_max_char_angle_delta(TextSymbolizer->dy);
-		    ts.set_displacement(TextSymbolizer->mindistance, TextSymbolizer->maxdistance);
-		    rule.append(ts);
-		    TextSymbolizer = TextSymbolizer->next;
-		 }
-		 PolygonPatternSymbolizer = Rule->PolygonPatternSymbolizer;
+	   if (TextSymbolizer->mindistance != 0)
+	      ts.set_label_spacing(TextSymbolizer->mindistance);
-		 while (PolygonPatternSymbolizer)
-		 {
-		    // FIXME: The file name must be variable and KDE like!!
+	   if (TextSymbolizer->dx != 0 || TextSymbolizer->dy != 0)
-		    rule.append(polygon_pattern_symbolizer(PolygonPatternSymbolizer->file.toAscii().data(),
-							getTypeText(PolygonPatternSymbolizer->type),
+	      ts.set_displacement(TextSymbolizer->dx, TextSymbolizer->dy);
-							PolygonPatternSymbolizer->width,
-							PolygonPatternSymbolizer->height));
+	   Rule->rl.append(ts);
+	}
-		    PolygonPatternSymbolizer = PolygonPatternSymbolizer->next;
+	else if (qName.toLower() == QString("polygonpatternsymbolizer"))
-		 }
+	{
+	   Container = in_rule;
-		 ShieldSymbolizer = Rule->ShieldSymbolizer;
+	   if (!Rule || !PolygonPatternSymbolizer)
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Endin of POLYGONPATTERNSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
+	      return false;
+	   }
-		 while (ShieldSymbolizer)
-		 {
-		    color col;
-		    col.set_bgr(ShieldSymbolizer->fill);
-		    // FIXME: The file name must be variable and KDE like!!
-		    shield_symbolizer ss(ShieldSymbolizer->name.toAscii().data(),
+	   Rule->rl.append(polygon_pattern_symbolizer(findIcon(PolygonPatternSymbolizer->file).toAscii().data(),
-					ShieldSymbolizer->face_name.toAscii().data(),
-					ShieldSymbolizer->size, col,
+						getTypeText(PolygonPatternSymbolizer->type),
-					ShieldSymbolizer->file.toAscii().data(),
-					getTypeText(ShieldSymbolizer->type),
+						PolygonPatternSymbolizer->width,
-					ShieldSymbolizer->width, ShieldSymbolizer->height);
+						PolygonPatternSymbolizer->height));
-		    ss.set_label_placement((ShieldSymbolizer->placement.toLower() == QString("point")) ? mapnik::POINT_PLACEMENT : mapnik::LINE_PLACEMENT);
-		    ss.set_displacement(ShieldSymbolizer->mindistance, ShieldSymbolizer->maxdistance);
+	   PolygonPatternSymbolizer = PolygonPatternSymbolizer->next;
-		    rule.append(ss);
+	}
-		    ShieldSymbolizer = ShieldSymbolizer->next;
+	else if (qName.toLower() == QString("shieldsymbolizer"))
-		 }
+	{
+	   Container = in_rule;
-		 LinePatternSymbolizer = Rule->LinePatternSymbolizer;
+	   if (!Rule || !ShieldSymbolizer)
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of SHIELDSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
+	      return false;
+	   }
+	   color col;
-		 while (LinePatternSymbolizer)
+	   col.set_bgr(ShieldSymbolizer->fill);
-		 {
-		    // FIXME: The file name must be variable and KDE like!!
+	   shield_symbolizer ss(ShieldSymbolizer->name.toAscii().data(),
-		    rule.append(line_pattern_symbolizer(LinePatternSymbolizer->file.toAscii().data(),
+				ShieldSymbolizer->face_name.toAscii().data(),
-							getTypeText(LinePatternSymbolizer->type),
+				ShieldSymbolizer->size, col,
+				findIcon(ShieldSymbolizer->file).toAscii().data(),
-							LinePatternSymbolizer->width,
+				getTypeText(ShieldSymbolizer->type),
-							LinePatternSymbolizer->height));
+				ShieldSymbolizer->width, ShieldSymbolizer->height);
-		    LinePatternSymbolizer = LinePatternSymbolizer->next;
+	   if (!ShieldSymbolizer->placement.isEmpty())
+	      ss.set_label_placement((ShieldSymbolizer->placement.toLower() == QString("point")) ? mapnik::POINT_PLACEMENT : mapnik::LINE_PLACEMENT);
-		 }
+	   if (ShieldSymbolizer->dx != 0 || ShieldSymbolizer->dy != 0)
+	      ss.set_displacement(ShieldSymbolizer->dx, ShieldSymbolizer->dy);
+	   if (ShieldSymbolizer->mindistance != 0)
+	      ss.set_label_spacing(ShieldSymbolizer->mindistance);
+	   Rule->rl.append(ss);
+	}
+	else if (qName.toLower() == QString("linepatternsymbolizer"))
+	{
+	   Container = in_rule;
+	   if (!Rule || !LinePatternSymbolizer)
+	   {
+	      KMessageBox::error(0, i18n("Error parsing %1, line %2: Ending of LINEPATTERNSYMBOLIZER without start, or outside of a RULE detected!").arg(XmlPath).arg(XmlLine));
+	      return false;
+	   }
+	   Rule->rl.append(line_pattern_symbolizer(findIcon(LinePatternSymbolizer->file).toAscii().data(),
+						getTypeText(LinePatternSymbolizer->type),
+						LinePatternSymbolizer->width,
+						LinePatternSymbolizer->height));
+	}
+	else if (qName.toLower() == QString("filter") ||
+		 qName.toLower() == QString("maxscaledenominator") ||
+		 qName.toLower() == QString("minscaledenominator"))
+	   Container = in_rule;
+	else if (qName.toLower() == QString("rule"))
+	   Container = in_style;
+	else if (qName.toLower() == QString("style"))
+	{
+	   Container = in_map;
+	   feature_type_style style;
+	   if (Style->rule)
+	   {
+	      Rule = Style->rule;
+	      while (Rule)
+	      {
-		 style.add_rule(rule);
+		 style.add_rule(Rule->rl);
 		 Rule = Rule->next;
+	      }
+	   }
 	   // Add style to map
 /*
  * The reader calls this function when it has parsed a chunk of character data
  * - either normal character data or character data inside a CDATA section.
  */
-bool SRender::characters (const QString& ch)
+bool SRender::characters (const QString& chraw)
+{
+	QString ch = chraw.trimmed();
+	if (ch.length() == 0)
+	   return true;
-	if (ch.length() == 0 || ch.at(0) == QChar('\n'))
+	if (ch.at(0) == QChar('\n'))
+	{
+	   XmlLine++;
 	   return true;
+	}
 	if (Container == in_rule && Rule)
+	{
 	   if (Field == FLD_FILTER)
+	   {
 	      Rule->filter = ch;
+	      if (!Rule->filter.isEmpty())
+		 Rule->rl.set_filter(create_filter(Rule->filter.toAscii().data()));
+	      else
+		 cerr << "Warning in file " << XmlPath.toAscii().data() << " at line " << XmlLine << ": Ignoring empty filter!" << endl;
+	   }
 	   else if (Field == FLD_MAXSCALE)
+	   {
 	      Rule->maxscale = ch.toDouble();
+	      Rule->rl.set_max_scale(Rule->maxscale);
+	   }
 	   else if (Field == FLD_MINSCALE)
+	   {
 	      Rule->minscale = ch.toDouble();
+	      Rule->rl.set_min_scale(Rule->minscale);
+	   }
+	}
 	else if (Container == in_linesymbolizer && LineSymbolizer)
+	{
 	   if (Field == FLD_CSSPARAMETER)
+	   {
 	      QStringList list;
 		 list = arr.split(",", QString::SkipEmptyParts);
 		 for (pos = 0; pos < list.size() && pos < 10; pos++)
-		 {
 		    LineSymbolizer->stroke_dasharray[pos] = list.at(pos).toDouble();
-		    pos++;
-		 }
 		 LineSymbolizer->stroke_anz = pos;
+	      }
+	   }
+	}
 	   if (Field == FLD_PARAMETER)
+	   {
 	      if (Names == type)
 		 Lay->Datasource.type = ch;
 	      else if (Names == file)
+	      {
+	      QFileInfo qf(ch);
+	      QString hv0;
+		 hv0 = shapePath;
+		 if (hv0.right(1) != QString("/"))
+		    hv0 += "/";
+		 hv0 += qf.fileName();
+		 qf.setFile (hv0 + ".shp");
+		 if (!qf.exists())
+		 {
+		    KMessageBox::error(0, i18n("The shape file \"%1\" at line %2 does not exist!").arg(hv0+".shp").arg(XmlLine));
+		    return false;
+		 }
-		 Lay->Datasource.file = ch;
+		 Lay->Datasource.file = hv0;
+	      }
 	      else if (Names == host)
 		 Lay->Datasource.host = ch;
 	      else if (Names == user)
 		 Lay->Datasource.user = ch;
 	      else if (Names == dbname)
 	      else if (Names == extent)
+	      {
 		 QString arr = ch;
 		 QStringList list;
 		 list = arr.split(",");
+		 if (list.size() >= 1)
-		 Lay->Datasource.ext_lx = list.at(0).toDouble();
+		    Lay->Datasource.ext_lx = list.at(0).toDouble();
+		 if (list.size() >= 2)
-		 Lay->Datasource.ext_ly = list.at(1).toDouble();
+		    Lay->Datasource.ext_ly = list.at(1).toDouble();
+		 if (list.size() >= 3)
-		 Lay->Datasource.ext_rx = list.at(2).toDouble();
+		    Lay->Datasource.ext_rx = list.at(2).toDouble();
+		 if (list.size() >= 4)
-		 Lay->Datasource.ext_ry = list.at(3).toDouble();
+		    Lay->Datasource.ext_ry = list.at(3).toDouble();
+	      }
+	   }
+	}
 	return true;
 	return false;
+}
 bool SRender::getMap (double lx, double ly, double rx, double ry)
+{
-int width, height, pid;
+int width, height;
 QXmlSimpleReader reader;
 QString hv0;
 QFile file(XmlPath);
+double plx, ply, prx, pry;
+	OutBuf.clear();
+	hv0 = pluginPath;
+	if (hv0.right(1) != QString("/"))
+	   hv0 += "/";
-	hv0 = pluginPath + "/";
 	datasource_cache::instance()->register_datasources(hv0.toAscii().data());
+	hv0 = fontPath;
+	if (hv0.right(1) != QString("/"))
+	   hv0 += "/";
-	hv0 = fontPath + "/DejaVuSans.ttf";
+	hv0 += "DejaVuSans.ttf";
 	freetype_engine::register_font(hv0.toAscii().data());
 	width = label->width();
 	height = label->height();
 	m.setWidth(width);
 	m.setHeight(height);
+//	load_map(m, XmlPath.toAscii().data());
 	if (!ControlSet)	// Initialize the map?
+	{
 	   QXmlInputSource source (&file);
 	   reader.setContentHandler (this);
 	   reader.parse (source);
+	}
+	save_map(m, "/home/andreas/.sportwatcher/spw.xml");
+//	save_map(m, "/home/andreas/.sportwatcher/spw1.xml");
+	plx = lx;
+	ply = ly;
+	prx = rx;
+	pry = ry;
+	projection pj(m.srs());
+	if (pj.is_geographic())
+	{
+	   pj.inverse(plx, ply);
+	   pj.inverse(prx, pry);
+cout << "Geographic! Inverse projection." << endl;
+	}
+	else
+	{
+//	   pj.forward(plx, ply);
+//	   pj.forward(prx, pry);
+cout << "NOT geographic!" << endl;
+	}
+for (unsigned i = 0; i < m.layerCount(); i++)
+{
+   bool vis = m.getLayer(i).isVisible(m.scale_denominator());
+   cout << "Layer " << i << ": " << m.getLayer(i).name();
+   cout << ", Visible: " << vis;
+   Envelope <double>e(m.getLayer(i).envelope());
+   cout << ", Extent: " << e.minx() << ", " << e.miny() << ", " << e.maxx() << ", " << e.maxy() << endl;
+}
 	// First we use Mapnik to create the map
+	m.zoomToBox(Envelope<double>(plx, ply, prx, pry));
+Envelope <double>e(m.getCurrentExtent());
-cout << lx << ", " << ly << ", " << rx << ", " << ry << endl;
+cout << std::setprecision(16) << "Parameter envelope: " << lx << ", " << ly << ", " << rx << ", " << ry << endl;
-//cout << DEG2RAD(lx) << ", " << DEG2RAD(ly) << ", " << DEG2RAD(rx) << ", " << DEG2RAD(ry) << endl;
+cout << std::setprecision(16) << "Converted envelope: " << plx << ", " << ply << ", " << prx << ", " << pry << endl;
+cout << std::setprecision(16) << "Current extent:     " << e.minx() << ", " << e.miny() << ", " << e.maxx() << ", " << e.maxy() << endl;
-	m.zoomToBox(Envelope<double>(lx, ly, rx, ry));
+cout << "SRS: " << m.srs() << endl;
+cout << std::setprecision(16) << "Scale: " << m.scale() << ", scale denominator: " << m.scale_denominator() << endl;
+cout << "width=" << m.getWidth() << ", height=" << m.getHeight() << endl;
 	Image32 buf(m.getWidth(), m.getHeight());
 	agg_renderer<Image32> ren(m, buf);
 	ren.apply();
+	// Put the image into a Qt object
+	QImage image((uchar*)buf.raw_data(), m.getWidth(), m.getHeight(), QImage::Format_ARGB32);
+	label->setPixmap(QPixmap::fromImage(image.rgbSwapped()));
 	// Create a unique file name
-	pid = getpid();
+//	pid = getpid();
-	hv0.sprintf("/var/tmp/SportWatcher_%d", pid);
+//	OutBuf.sprintf("/var/tmp/SportWatcher_%d.png", pid);
-	save_to_file<ImageData32>(buf.data(), hv0.toAscii().data(), "png");
+//	save_to_file<ImageData32>(buf.data(), OutBuf.toAscii().data(), "png");
-	// Now we move the image into a QPixmap
-	QPixmap pm;
-	pm.load(hv0);
-	unlink(hv0.toAscii().data());	// delete the temporary file
-	label->setPixmap(pm);
 	return true;
+}
+void SRender::setMaxExtent(double lx, double ly, double rx, double ry)
+{
+	if (lx > 0 && _lx > lx)
+	   _lx = lx;
+	if (lx < 0 && _lx < lx)
+	   _lx = lx;
+	if (ly > 0 && _ly > ly)
+	   _ly = ly;
+	if (ly < 0 && _ly < ly)
+	   _ly = ly;
+	if (rx > 0 && _rx < rx)
+	   _rx = rx;
+	if (rx < 0 && _rx > rx)
+	   _rx = rx;
+	if (ry > 0 && _ry < ry)
+	   _ry = ry;
+	if (ry < 0 && _ry > ry)
+	   _ry = ry;
+}
+QString SRender::findIcon(QString ic)
+{
+QString ptf, icon;
+QFileInfo fi(ic);
+	icon = fi.fileName();
+	ptf = KStandardDirs::locate("data", QString("sportwatcher/icons/%1").arg(icon));
+	if (ptf.length() < icon.length())
+	{
+	   KMessageBox::error(0, i18n("The icon %1 was not found!").arg(icon));
+	   ptf.clear();
+	}
+	return ptf;
+}
 RULE *SRender::getLastRule(RULE *first)
+{
 RULE *akt = first;
 	while (akt)
 unsigned SRender::colorToUInt(QString col)
+{
 QColor qc(col);
-	return (qc.red() * 65536) + (qc.green() * 256) + qc.blue();
+	return (qc.blue() * 65536) + (qc.green() * 256) + qc.red();
+}
 STYLE *SRender::allocStyle()
+{
 STYLE *St = new STYLE;
 LAYER *La = new LAYER;
 	La->name.clear();	// The unique name
 	La->status = false;	// Is it active?
 	La->srs.clear();	// Projection
+	La->minzoom = 0.0;
+	La->maxzoom = 0.0;
 	La->Datasource.type.clear();
 	La->Datasource.file.clear();
 	La->Datasource.host.clear();
 	La->Datasource.user.clear();
 	La->Datasource.dbname.clear();
 SHIELDSYMBOLIZER *ss = new SHIELDSYMBOLIZER;
 	ss->name.clear();
 	ss->face_name.clear();
 	ss->size = 0.0;
-	ss->fill = 0;		// Color
+	ss->fill = 0;			// Color
 	ss->placement.clear();
 	ss->file.clear();
 	ss->type = type_png;		// enum TYPES
 	ss->width = 0.0;
 	ss->height = 0.0;
+	ss->dx = 0.0;
+	ss->dy = 0.0;
 	ss->mindistance = 0.0;
 	ss->maxdistance = 0.0;
 	ss->next = 0;
 	return ss;
+}
 	ts->face_name.clear();
 	ts->size = 0;
 	ts->fill = 0;			// Color
 	ts->halo_radius = 0;
 	ts->wrap_width = 0;
+	ts->dx = 0.0;
 	ts->dy = 0.0;
 	ts->mindistance = 0.0;
 	ts->maxdistance = 0.0;
 	ts->next = 0;
 	return ts;

Subversion Repositories public

(root)/sportwatcher/trunk/src/render.cpp – Rev 274 → 275