path: root/app/bin/svgformat.c

/** \file svgformat.c
* Formatting of SVG commands and parameters.
*/

/*  XTrkCad - Model Railroad CAD
*  Copyright (C)2021 Martin Fischer
*
*  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#define _USE_MATH_DEFINES
#include <math.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>

#include "dynstring.h"
#include "mxml.h"
#include "include/svgformat.h"
#include "include/utlist.h"
#include "common.h"

#define SVGDPIFACTOR 90.0					/**< the assumed resolution of the svg, 90 is what Inkscape uses */
#define ROUND2PIXEL( value ) ((int)floor(value * SVGDPIFACTOR + 0.5))

typedef struct sCssStyle {
	DynString name;
	DynString style;
	struct sCssStyle *next;
} sCssStyle;

static sCssStyle *styleCache = NULL;
static unsigned cacheCount;

static char *lineStyleCSS[] = {				/**< The css class names for line styles */
	NULL,										// no style needed for solid line
	"linedash",
	"linedot",
	"linedashdot",
	"linedashdot",
	"linecenter",
	"linephantom"
};

#define LINESTYLECLASSES \
    ".linedash{ stroke-dasharray: 25px 15px; } \n" \
    ".linedot{ stroke-dasharray: 5px 10px; } \n" \
    ".linedashdot{ stroke-dasharray: 25px 10px 5px 10px; } \n" \
    ".linedashdotdot{ stroke-dasharray: 25px 10px 5px 10px 5px 10px; } \n" \
    ".linecenter{ stroke-dasharray: 40px 15px 25px 15px; } \n" \
    ".linephantom{ stroke-dasharray: 40px 15px 25px 15px 25px 15px; } \n"


/**
 * Initialize style cache. Memory is allocated and the default style added
 */

static void
SvgInitStyleCache(void)
{
	sCssStyle *style;

	style = malloc(sizeof(sCssStyle));
	DynStringMalloc(&(style->name), 2);
	DynStringCatCStr(&(style->name), "*");

	DynStringMalloc(&(style->style), 16);
	DynStringCatCStr(&(style->style), "stroke-width:1; stroke:#000000; fill:none;");
	LL_APPEND(styleCache, style);

	cacheCount = 1;
}

static int
CompareStyle(sCssStyle *a, sCssStyle *b)
{
	return (strcmp(DynStringToCStr(&(a->style)), DynStringToCStr(&(b->style))));
}

/**
 * Add style to cache. If an identical style definition can be found in the
 * cache, the class name is returned.
 * If no previous definition is in the cache, a new one is contructed and
 * stored in the cache. The new class name is returned
 *
 * \param [in] styleDef style definition.
 *
 * \returns Null if default style can be used, else the class name
 */

static char *
SvgAddStyleToCache(DynString *styleDef)
{
	sCssStyle *style;
	sCssStyle *result;

	style = malloc(sizeof(sCssStyle));
	style->style = *styleDef;

	LL_SEARCH(styleCache, result, style, CompareStyle);
	if (result) {
		if (!strcmp(DynStringToCStr(&(result->name)), "*")) {
			return (NULL);
		} else {
			return (DynStringToCStr(&(result->name)) + 1);
		}
	} else {
		DynString className;
		DynStringMalloc(&className, 16);
		DynStringPrintf(&className, ".xtc%u", cacheCount++);
		style->name = className;
		LL_APPEND(styleCache, style);
		return (DynStringToCStr(&className) + 1);		//skip leading dot in class name
	}
}

/**
 * destroy style cache freeing all memory allocated
 */

static void
SvgDestroyStyleCache(void)
{
	sCssStyle *style;
	sCssStyle *tmp;

	LL_FOREACH_SAFE(styleCache, style, tmp) {
		DynStringFree(&(style->name));
		DynStringFree(&(style->style));
		free(style);
	}

	styleCache = NULL;
}

/**
 * Svg create style, add to the cache and the associated CSS class name to the element
 *
 * \param element	SVG element
 * \param colorRGB	RGB value
 * \param width     line width
 * \param fill		true to fill
 */

static void
SvgCreateStyle(mxml_node_t *element, unsigned long colorRGB, double width,
               bool fill, unsigned lineStyle)
{
	DynString style;
	char color[10];
	char *className = NULL;
	char *classLineStyle = NULL;

	CHECK(lineStyle < 7);

	sprintf(color, "#%2.2x%2.2x%2.2x", ((unsigned int)colorRGB >> 16) & 0xFF,
	        ((unsigned int)colorRGB >> 8) & 0xFF, (unsigned int)colorRGB & 0xFF);

	DynStringMalloc(&style, 32);

	DynStringPrintf(&style,
	                "stroke-width:%d; stroke:%s; fill:%s;",
	                (int)(width + 0.5),
	                color,
	                (fill ? color: "none"));

	className = SvgAddStyleToCache(&style);
	classLineStyle = lineStyleCSS[lineStyle];

	if (className && classLineStyle) {
		mxmlElementSetAttrf(element, "class", "%s %s", className, classLineStyle);
	} else {
		if (className || classLineStyle) {
			mxmlElementSetAttr(element, "class", (className? className:classLineStyle));
		} else {
			// strict default, nothing to add
		}
	}
}

/**
 * add real unit, ie. units that are specified in pixels. Rounding is performed
 *
 * \param [in,out] node  If non-null, the node.
 * \param [in,out] name  If non-null, the name.
 * \param 		   value the dimension in pixels
 */

static void
SvgAddRealUnit(mxml_node_t *node, char *name, double value)
{
	mxmlElementSetAttrf(node, name, "%d", (int)(value+0.5));
}

/**
* Format a dimension and add to XML node as an attribute.
* A fictional value for the resolution is assumed. As final
* rendering is done by the client, this is not really relevant.
*
* \PARAM [in, out]	node	the XML node
* \PARAM [in]		name	name of attribute
* \param [in]		value	size
*/

static void
SvgAddCoordinate(mxml_node_t *node, char *name, double value)
{
	mxmlElementSetAttrf(node, name, "%d", ROUND2PIXEL(value));
}

/**
 * Svg line command
 * \param [in] svg		 the svg parent.
 * \param 	   x0		 The x coordinate 0.
 * \param 	   y0		 The y coordinate 0.
 * \param 	   x1		 The first x value.
 * \param 	   y1		 The first y value.
 * \param 	   w		 A wDrawWidth to process.
 * \param 	   c		 RGB color definition.
 * \param 	   lineStyle line style.
 */

void
SvgLineCommand(SVGParent *svg, double x0,
               double y0, double x1, double y1, double w, long c, unsigned lineStyle)
{
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(svg, "line");

	// line end points
	SvgAddCoordinate(xmlData, "x1", x0);
	SvgAddCoordinate(xmlData, "y1", y0);
	SvgAddCoordinate(xmlData, "x2", x1);
	SvgAddCoordinate(xmlData, "y2", y1);

	SvgCreateStyle(xmlData, c, w, false, lineStyle);
}

/**
 * Svg rectangle command
 *
 * \param [in]    svg	   If non-null, the svg.
 * \param 		   x0	   The x coordinate 0.
 * \param 		   y0	   The y coordinate 0.
 * \param 		   x1	   The first x value.
 * \param 		   y1	   The first y value.
 * \param 		   color   The color.
 * \param 		   fill		Specifies the fill options.
 */

void
SvgRectCommand(SVGParent *svg, double x0, double y0, double x1, double y1,
               int color, unsigned lineStyle)
{
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(svg, "rect");

	// line end points
	SvgAddCoordinate(xmlData, "x1", x0);
	SvgAddCoordinate(xmlData, "y1", y0);
	SvgAddCoordinate(xmlData, "x2", x1);
	SvgAddCoordinate(xmlData, "y2", y1);

	SvgCreateStyle(xmlData, color, 1, false, lineStyle);

}

/**
 * Svg polygon line command
 *
 * \param [in] svg		 If non-null, the svg.
 * \param 	   cnt		 Number of point.
 * \param [in] points    If non-null, the points.
 * \param 	   color	 The line and fill color.
 * \param 	   width	 The line width.
 * \param 	   lineStyle The line style.
 * \param 	   fill		 True to fill.
 */

void
SvgPolyLineCommand(SVGParent *svg, int cnt, double *points, int color,
                   double width, bool fill, unsigned lineStyle)
{
	mxml_node_t *xmlData;
	DynString pointList;
	DynString pos;

	DynStringMalloc(&pointList, 64);
	DynStringMalloc(&pos, 20);


	for (int i = 0; i < cnt; i++) {
		DynStringPrintf(&pos,
		                "%d,%d ",
		                (int)floor(points[i * 2] * SVGDPIFACTOR + 0.5),
		                (int)floor(points[ i * 2 + 1] * SVGDPIFACTOR + 0.5));

		DynStringCatStr(&pointList, &pos);
		DynStringClear(&pos);
	}

	xmlData = mxmlNewElement(svg, "polyline");
	mxmlElementSetAttr(xmlData, "points", DynStringToCStr(&pointList));

	SvgCreateStyle(xmlData, color, width, fill, lineStyle);

	DynStringFree(&pos);
	DynStringFree(&pointList);
}

/**
 * Format a complete CIRCLE command
 *
 * \param [in]     svg		 OUT buffer for the completed command.
 * \param 		   x		 x position of center.
 * \param 		   y		 y position of center point.
 * \param 		   r		 radius.
 * \param 		   w		 width
 * \param 		   c		 color
 * \param 		   lineStyle The line style.
 * \param 		   fill		 True to fill.
 */

void
SvgCircleCommand(SVGParent *svg, double x,
                 double y, double r, double w, long c, bool fill, unsigned lineStyle)
{
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(svg, "circle");

	// line end points
	SvgAddCoordinate(xmlData, "cx", x);
	SvgAddCoordinate(xmlData, "cy", y);

	SvgAddCoordinate(xmlData, "r", r);

	SvgCreateStyle(xmlData, c, w, fill, lineStyle);

}

/**
 * Polar to cartesian
 *
 * \param 		cx	  x coordinate of center.
 * \param 		cy	  y coordinate of center
 * \param 		radius radius.
 * \param 		angle  angle.
 * \param [out] px	  resulting x coordinate
 * \param [out] py	  resulting y coordinate
 */

static void
PolarToCartesian(double cx, double cy, double radius, double angle, double *px,
                 double *py)
{
	double angleInRadians = ((angle) * M_PI) / 180.0;

	*px = cx + (radius * cos(angleInRadians));
	*py = cy + (radius * sin(angleInRadians));
}

/**
 * Format an arc as a SVG path See
 * https://stackoverflow.com/questions/5736398/how-to-calculate-the-svg-path-for-an-arc-of-a-circle
 *
 * \param [in]     svg		 the svg document.
 * \param 		   x		 y IN center point.
 * \param 		   y		 The y coordinate.
 * \param 		   r		 IN radius.
 * \param 		   a0		 IN starting angle.
 * \param 		   a1		 IN ending angle.
 * \param 		   center    IN draw center mark if true.
 * \param 		   w		 line width.
 * \param 		   c		 line color.
 * \param 		   lineStyle line style.
 */

void
SvgArcCommand(SVGParent *svg, double x, double y,
              double r, double a0, double a1, bool center, double w, long c,
              unsigned lineStyle)
{
	double startX;
	double startY;
	double endX;
	double endY;
	char largeArcFlag = (a1 - a0 <= 180 ? '0' : '1');
	DynString pathArc;
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(svg, "path");

	PolarToCartesian(x, y, r, a0+a1-90, &startX, &startY);
	PolarToCartesian(x, y, r, a0-90, &endX, &endY);

	DynStringMalloc(&pathArc, 64);
	DynStringPrintf(&pathArc,
	                "M %d %d A %d %d 0 %c 0 %d %d",
	                ROUND2PIXEL(startX),
	                ROUND2PIXEL(startY),
	                ROUND2PIXEL(r),
	                ROUND2PIXEL(r),
	                largeArcFlag,
	                ROUND2PIXEL(endX),
	                ROUND2PIXEL(endY));

	mxmlElementSetAttr(xmlData, "d", DynStringToCStr(&pathArc));

	DynStringFree(&pathArc);

	SvgCreateStyle(xmlData, c, w, false, lineStyle);
}

/**
 *  Create SVG text command
 *
 * \param [in] svg  If non-null, the svg.
 * \param 		   x    The x coordinate.
 * \param 		   y    The y coordinate.
 * \param 		   size The fontsize.
 * \param 		   c    the text color
 * \param [in]	   text text in UTF-8 format
 */

void
SvgTextCommand(SVGParent *svg, double x,
               double y, double size, long c, char *text)
{
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(svg, "text");
	// starting point
	SvgAddCoordinate(xmlData, "x", x);
	SvgAddCoordinate(xmlData, "y", y);

	SvgCreateStyle(xmlData, c, 1, 1, 0);

	SvgAddRealUnit(xmlData, "font-size", size);

	mxmlNewText(xmlData, false, text);
}

/**
 * Add title to SVG document
 *
 * \param [in] svg   svg
 * \param [in] title If non-null, the title.
 */

void
SvgAddTitle(SVGParent *svg, char *title)
{
	mxml_node_t *titleNode;
	if (title) {
		titleNode = mxmlNewElement(MXML_NO_PARENT, "title");
		mxmlNewText(titleNode, false, title);

		mxmlAdd(svg, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT, titleNode);
	}
}

/**
 * Add CSS style definitions to the SVG file. CSS definitions are
 * created from the options of the drawing commands. As a final step
 * in creation of the SVG file, these definitions have to be added.
 * For compatibility reasons the styles have to be defined before
 * first use.
 *
 * \param [in] svg the svg.
 */

void
SvgAddCSSStyle(SVGParent *svg)
{
	mxml_node_t *cssNode;
	DynString cssDefs;
	DynString tmp;
	sCssStyle *style;

	cssNode = mxmlNewElement(MXML_NO_PARENT, "style");
	mxmlElementSetAttr(cssNode, "type", "text/css");

	DynStringMalloc(&cssDefs, 64);
	DynStringMalloc(&tmp, 64);
	LL_FOREACH(styleCache, style) {
		DynStringPrintf(&tmp, "%s { %s }\n",
		                DynStringToCStr(&(style->name)),
		                DynStringToCStr(&(style->style)));

		DynStringCatStr(&cssDefs, &tmp);
	}

	DynStringCatCStr(&cssDefs, LINESTYLECLASSES);
	mxmlNewCDATA(cssNode, DynStringToCStr(&cssDefs));

	mxmlAdd(svg, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT, cssNode);
	DynStringFree(&tmp);
	DynStringFree(&cssDefs);
}

/**
 * Svg create document
 *
 * \returns An XMLDocument.
 */

SVGDocument *
SvgCreateDocument()
{
	SvgInitStyleCache();

	return ((SVGDocument *)mxmlNewXML("1.0"));
}

/**
 * Svg destroy document freeing the memory used by the XML tree
 *
 * \param [in] xml the XML document
 */

void
SvgDestroyDocument(SVGDocument *xml)
{
	mxmlDelete((mxml_node_t *)xml);

	SvgDestroyStyleCache();
}

/**
 * Create the complete prologue for a SVG file.
 *
 * \param [in]     parent	  the document handle.
 * \param [in]     id		  If non-null, the identifier.
 * \param 		   layerCount IN count of defined layers.
 * \param 		   x0		  y0 IN minimum (left bottom) position.
 * \param 		   y0		  y1 IN maximum (top right) position.
 * \param 		   x1		  The first x value.
 * \param 		   y1		  The first y value.
 *
 * \returns Null if it fails, else a pointer to a SVGParent.
 */

SVGParent *
SvgPrologue(SVGDocument *parent, char *id, int layerCount, double x0, double y0,
            double x1,
            double y1)
{
	mxml_node_t *xmlData;

	xmlData = mxmlNewElement(parent,
	                         "!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\""
	                         " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\"");
	xmlData = mxmlNewElement(parent, "svg");
	mxmlElementSetAttr(xmlData, "xmlns", "http://www.w3.org/2000/svg");

	if (id) {
		mxmlElementSetAttr(xmlData, "id", id);
	}
	SvgAddCoordinate(xmlData, "x", x0);
	SvgAddCoordinate(xmlData, "y", y0);
	SvgAddCoordinate(xmlData, "width", x1);
	SvgAddCoordinate(xmlData, "height", y1);

	return ((SVGParent *)xmlData);
}

/**
 * Add formatting to the resulting document by adding whitespace
 *
 * \param  node to be formatted
 * \param  see minixml docu, position in XML tag
 *
 * \returns Null if it no character to add, else a pointer to the additional chars.
 */

const char *
whitespace_cb(mxml_node_t *node, int where)
{
	const char *element;

	/*
	 * We can conditionally break to a new line before or after
	 * any element.  These are just common HTML elements...
	 */

	element = mxmlGetElement(node);

	if (!strcmp(element, "svg") ||
	    !strncmp(element, "!DOCTYPE", strlen("!DOCTYPE"))) {
		/*
		 * Newlines before open and after close...
		 */

		if (where == MXML_WS_BEFORE_OPEN ||
		    where == MXML_WS_BEFORE_CLOSE) {
			return ("\n");
		}
	} else {
		if (!strcmp(element, "line") ||
		    !strcmp(element, "circle") ||
		    !strcmp(element, "path") ||
		    !strcmp(element, "polyline")) {
			if (where == MXML_WS_BEFORE_OPEN ||
			    where == MXML_WS_AFTER_CLOSE) {
				return ("\n\t");
			}
		} else {
			if (!strcmp(element, "style") ||
			    !strcmp(element, "title") ||
			    !strcmp(element, "text")) {
				if (where == MXML_WS_BEFORE_OPEN) {
					return ("\n\t");
				} else {
					if (where == MXML_WS_AFTER_OPEN) {
						return ("\n\t\t");
					} else {
						if (where == MXML_WS_AFTER_CLOSE) {
							return ("");
						} else {
							return ("\n\t");
						}
					}
				}

			}
		}
	}

	/*
	 * Otherwise return NULL for no added whitespace...
	 */

	return (NULL);
}

/**
 * Svg save file
 *
 * \param [in] svg	    the svg document.
 * \param [in] filename filename of the file.
 *
 * \returns True if it succeeds, false if it fails.
 */

bool
SvgSaveFile(SVGDocument *svg, char *filename)
{
	FILE *svgF;

	svgF = fopen(filename, "w");
	if (svgF) {
		mxmlSetWrapMargin(0);
		mxmlSaveFile(svg, svgF, whitespace_cb);
		fclose(svgF);

		return (true);
	}
	return (false);
}