* mt4j Copyright (c) 2008 - 2009 C.Ruff, Fraunhofer-Gesellschaft All rights reserved.

* 

*   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 3 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, see <http://www.gnu.org/licenses/>.

*

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

* This class can be used to load and display scalable vector graphics (svg) files.

*

* @author Christopher Ruff

*/

  private static final Logger logger = Logger.getLogger(SVGLoader.class.getName());

  static{

    logger.setLevel(Level.ERROR);

    SimpleLayout l = new SimpleLayout();

    ConsoleAppender ca = new ConsoleAppender(l);

    logger.addAppender(ca);

  }

 

  /** The svg doc. */

  private SVGDocument    svgDoc;

 

  /** The user agent. */

  private UserAgent      userAgent;

 

  /** The loader. */

  private DocumentLoader loader;

 

  /** The ctx. */

  private BridgeContext  ctx;

 

  /** The builder. */

  private GVTBuilder     builder;

 

  /** The root gn. */

  private GraphicsNode   rootGN;

 

  /** The css engine. */

  protected SVGCSSEngine cssEngine;

 

  /** The pa. */

  private PApplet pa;

 

  /** The opacity stack. */

  private Stack<Float> opacityStack;

 

  /** The default drag action. */

  private IGestureEventListener defaultDragAction;

 

  /** The default rotate action. */

  private IGestureEventListener defaultRotateAction;

 

  /** The default scale action. */

  private IGestureEventListener defaultScaleAction;

 

  /** The current local transform matrix. */

  private Matrix currentLocalTransformMatrix;

 

 

  /**

   * Instantiates a new batik svg parser.

   *

   * @param pa the pa

   */

  public SVGLoader(PApplet pa){

    this.pa = pa;

   

    opacityStack = new Stack<Float>();

   

    currentLocalTransformMatrix = new Matrix();

   

    defaultDragAction     = new DefaultDragAction();

    defaultRotateAction   = new DefaultRotateAction();

    defaultScaleAction     = new DefaultScaleAction();

  }

 

 

  /**

   * Loads a "*.svg" file, parses it, creates drawable components and returns the

   * toplevel component.

   *

   * @param filedescr the absolute path of the svg file as a string

   *

   * @return the MT base component

   *

   * the created top level component of the svg

   */

  public MTComponent loadSvg(String filedescr){

    return this.getCreatedSvgComponents(this.parseSvg(filedescr));

  }

 

 

  /**

   * Uses the batik parser to genererate an svg document from an svg file.

   * To create the components in that svg document, call <code>getCreatedSvgComponents(SVGDocument doc)</code>

   *

   * @param filedescr the filedescr

   *

   * @return the SVG document

   */

  public SVGDocument parseSvg(String filedescr){

        Document doc;

        try {

            String parser = XMLResourceDescriptor.getXMLParserClassName();

            SAXSVGDocumentFactory f = new SAXSVGDocumentFactory(parser);

           

            File file = new File(filedescr);

            if (file.exists()){

                URI localFileAsUri = file.toURI();

                String uri = localFileAsUri.toASCIIString();

                doc = f.createDocument(uri);

            }else{

              InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(filedescr);

              if (in == null){

                in = pa.getClass().getResourceAsStream(filedescr);

              }

              doc = f.createDocument(filedescr, in);

             

               /*on it (after casting it to  SVGOMDocument) to give it a

                URI of some sort.  If the document needs to be able to have relative

                reference to files on the local file system, give it a URI like

                "file:///some/where/file.svg";

                */

                //FIXME HACK! this seems to help the "org.apache.batik.bridge.BridgeException: Unable to make sense of URL for connection" error

                //occuring with windmill.svg if loading from inputstream instead of local file system file

                //FIXME but this might create errors when loading external file like images from the relative svg path?

              ((SVGDocument)doc).setDocumentURI("") ;

//                System.out.println("F: " + filedescr + " sub; " + sub);

//                svgDoc.setDocumentURI(sub+ MTApplication.separator) ;

            }

            svgDoc = (SVGDocument)doc;

        } catch (Exception ex) {

            ex.printStackTrace();

        }

         

        //Neccesary? For booting css

        try{

          userAgent = new UserAgentAdapter();

          loader    = new DocumentLoader(userAgent);

          ctx       = new BridgeContext(userAgent, loader);

          ctx.setDynamicState(BridgeContext.DYNAMIC); //TODO use static?

          builder   = new GVTBuilder();

          rootGN    = builder.build(ctx, svgDoc);

         

        }catch(Exception e){

          e.printStackTrace();

        }

        return svgDoc;

  }

 

  /**

   * Creates and returns components of the provided svg document for displaying.

   *

   * @param svgDoc the svg doc

   *

   * @return the created svg components

   */

  public MTComponent getCreatedSvgComponents(SVGDocument svgDoc){

    ArrayList<MTComponent> components = new ArrayList<MTComponent>();

    opacityStack.push(1.0f);

    traverseSVGDoc(svgDoc, components);

    opacityStack.pop();

   

    MTComponent[] comps = (MTComponent[])components.toArray(new MTComponent[components.size()]);

    //Only returning the 1st component, since this should be the top-level <svg> element and only 1!?

    return comps[0];

  }

 

 

 

  /**

   * Traverse svg doc.

   *

   * @param node the node

   * @param comps the comps

   */

  private void traverseSVGDoc(Node node, ArrayList<MTComponent> comps){

    logger.debug("Traversing: " + node.getNodeName());

   

    //Damit transformationen konsistent sind muss

    //jedes tag, da� eine transform attribut hat

    //behandelt werden!

    //Default

    currentLocalTransformMatrix = new Matrix();

   

    //If there is a TRANSFORM attribute parse that and set the

    //current transformation matrix to be used with the svg components created after

    NamedNodeMap atts = node.getAttributes();

    if (atts != null){

      for (int i = 0; i < atts.getLength(); i++) {

        Node att = atts.item(i);

        if (att.getNodeName().equals(SVG_TRANSFORM_ATTRIBUTE)){

          CustomTransformHandler transFormHandler = new CustomTransformHandler();

          TransformListParser transFormListParser = new TransformListParser();

          transFormListParser.setTransformListHandler(transFormHandler);

          transFormListParser.parse(att.getNodeValue());

          //Overwrite current default matrix if the element has its own

          //transform defined, will be used at gfx obj creation

          currentLocalTransformMatrix = transFormHandler.getResultMatrix();

        }

      }

    }

   

   

   

    //For opacity inheritance

      if (node instanceof SVGGraphicsElement){

        SVGGraphicsElement svgGfx = (SVGGraphicsElement)node;

        //Handle inherited opacity settings

        float opac = queryPrimitiveFloatValue(svgGfx, "opacity", 1f);

        opacityStack.push(opac *= opacityStack.peek().floatValue());

      }

      // if G (GROUP) element, add all children to this element

      if (  node instanceof SVGOMGElement

       || node instanceof SVGSVGElement

       || node instanceof SVGOMSVGElement

      ){

        SVGElement gElem = (SVGElement)node;

        MTComponent group = new MTComponent(pa);

        group.setName(gElem.getTagName());

//        logger.debug("Viewport " + viewPort.getNodeName());

        //Set the <g> group to composite, meaning that it will

        //be returned at picking, when one of the children gets picked

        group.setComposite(true);

        group.setLocalMatrix(currentLocalTransformMatrix);

       

        //IF its <svg> element get the transform

        //(to honor the viewBox and the width/height attributes

        if (node instanceof SVGOMSVGElement ){

          SVGOMSVGElement svgGom = ((SVGOMSVGElement)node);

          Element viewPort = svgGom.getViewportElement();

          if (viewPort != null)

            logger.debug("Viewport " + viewPort.getNodeName());

         

         

          SVGAnimatedLength widthA = svgGom.getWidth();

          SVGAnimatedLength heightA = svgGom.getHeight();

         

          SVGLength w = widthA.getBaseVal();

          float width = w.getValue();

         

          SVGLength h = heightA.getBaseVal();

          float height = h.getValue();

         

          logger.debug("-> SVG Width: " + width + " Height: " + height);

         

         

          SVGMatrix mat = svgGom.getCTM();

          /*

          logger.debug("mat: " + mat.toString());

          logger.debug(mat.getA());

          logger.debug(mat.getB());

          logger.debug(mat.getC());

          logger.debug(mat.getD());

          logger.debug(mat.getE());

          logger.debug(mat.getF());

          SVGRect bbox = svgGom.getBBox();

          logger.debug("BBOx: X:" + bbox.getX() + " Y:" + bbox.getY() + " Width:" + bbox.getWidth() + " Height:" + bbox.getHeight());

          */

         

          //Hack, because if no width/height is specified default of 1.0

          //is assumed by batik -> things may get scaled too small

          if ( !(width == 1 && height == 1) ){

            currentLocalTransformMatrix = new Matrix(mat.getA(), mat.getC(),   0, mat.getE(),

                                   mat.getB(), mat.getD(),   0, mat.getF(),

                                   0,       0,       1,       0,

                                   0,       0,       0,       1

            );

            //logger.debug("Matrix: " + currentLocalTransformMatrix);

            group.setLocalMatrix(currentLocalTransformMatrix);

          }

        }

        //Make the group pickable and manipulatable

        group.setPickable(true);

       

        group.registerInputProcessor(new DragProcessor(pa));

        group.setGestureAllowance(DragProcessor.class, true);

        group.addGestureListener(DragProcessor.class, (IGestureEventListener)defaultDragAction);

       

        group.registerInputProcessor(new RotateProcessor(pa));

        group.addGestureListener(RotateProcessor.class, defaultRotateAction);

       

        group.registerInputProcessor(new ScaleProcessor(pa));

        group.addGestureListener(ScaleProcessor.class,  defaultScaleAction);

       

        ArrayList<MTComponent> groupChildren = new ArrayList<MTComponent>();

        //Traverse the children and add them to a new arraylist

        traverseChildren(gElem, groupChildren);

       

        MTComponent[] childComps = (MTComponent[])groupChildren.toArray(new MTComponent[groupChildren.size()]);

        //Add the children to the group

        group.addChildren(childComps);

        //Add the group to the arraylist of the parent

        comps.add(group);

      }else{//If NOT GROUP

        if (node instanceof SVGGraphicsElement){

          SVGGraphicsElement svgGfxElem = (SVGGraphicsElement)node;

          //IF node isnt a group node just add it to the passed in comps arraylist

          try{

            //Create a component from the graphicsnode and add it to the parents arraylist

            MTComponent liveComponent = handleGraphicsNode(svgGfxElem);

            if (liveComponent != null){

              comps.add(liveComponent);

            }

          }catch(Exception e){

            logger.error("Error handling svg node: " + svgGfxElem.getTagName());

            e.printStackTrace();

          }

        }

        //FIXME IMPLEMENT

        if (node instanceof SVGOMTSpanElement){

          SVGOMTSpanElement tSpanElement = (SVGOMTSpanElement)node;

         

        }

        //FIXME TEST

        if (node instanceof SVGOMTextElement){

          boolean useVectorFont = false;

         

          SVGOMTextElement textElement = (SVGOMTextElement)node;

          //Get <text> position values (can be a list)

          List<Float> xValues = getSVGLengthListAsFloat(textElement.getX().getBaseVal());

          List<Float> yValues = getSVGLengthListAsFloat(textElement.getY().getBaseVal());

          String textContent = TextUtilities.getElementContent(textElement);

          textContent = textContent.replaceAll("\\n","");

          textContent = textContent.trim();

          /*

          //TODO USE?

          textElement.getTextLength();

          textElement.getRotate();

           */

          if (textElement.getSVGContext() instanceof SVGTextElementBridge){

            SVGTextElementBridge b = (SVGTextElementBridge)textElement.getSVGContext();

            GraphicsNode gr = b.createGraphicsNode(ctx, textElement);

            TextNode tNode = (TextNode)gr;

            b.buildGraphicsNode(ctx, textElement, tNode);

            List<?> textRuns = tNode.getTextRuns();

            logger.debug("Text runs: " + textRuns);

            //Get font size

            float fontSize = b.getFontSize();

            logger.debug("Text:" +  " x:" + xValues.get(0) + " y:" + yValues.get(0) + " FontSize: " + fontSize +  " Text: '" + textContent + "'");

            //Get font FILL

            Value fillOpacValue = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.FILL_OPACITY_INDEX);

            float computedfillOpac = PaintServer.convertOpacity(fillOpacValue);

            Value fillIndexValue = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.FILL_INDEX);

            Object fill = SVGLoader.getFillOrStroke(textElement, fillIndexValue, computedfillOpac, ctx);

            MTColor fillColor = new MTColor(150,150,150,255);

            if (fill instanceof java.awt.Color) {

              java.awt.Color color = (Color) fill;

              fillColor.setColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());

            }

            //Get STROKE

            // Stroke Opacity \\

            Value strokeOpacValue = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.STROKE_OPACITY_INDEX);

            float computedStrokeOpacity = PaintServer.convertOpacity(strokeOpacValue);

            // Stroke java.awt.Color \\

            Value strokeIndexValue = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.STROKE_INDEX);

            Object stroke = SVGLoader.getFillOrStroke(textElement, strokeIndexValue, computedStrokeOpacity, ctx);

            MTColor strokeColor = new MTColor(fillColor.getR(), fillColor.getG(), fillColor.getB(), fillColor.getAlpha());

            if (stroke instanceof java.awt.Color) {

              java.awt.Color color = (Color) stroke;

              strokeColor.setColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());

            }

            //Get the font family

            Value fontFamilyValue = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.FONT_FAMILY_INDEX);

            String fontFamily = "arial"; //DEFAULT

            if (fontFamilyValue instanceof ListValue) {

              ListValue listValue = (ListValue) fontFamilyValue;

              Value firstValue = listValue.item(0); //Can be a List? -> take only the first one..

              if (firstValue != null)

                fontFamily = firstValue.getStringValue();

            }

            logger.debug("Font family: " + fontFamily);

            IFont font;

            if (useVectorFont)

              //Vector font

              font = FontManager.getInstance().createFont(pa,

                  "arial.ttf", Math.round(fontSize), fillColor, strokeColor);

            else

              //Bitmap font

              font = FontManager.getInstance().createFont(pa,

                  fontFamily, Math.round(fontSize), fillColor, strokeColor);

            IFont fontToUse = font;

            IFont lastUsedFont = fontToUse;

            List<MTTextArea> textAreas = new ArrayList<MTTextArea>();

            AttributedCharacterIterator iter = tNode.getAttributedCharacterIterator();

            if (font != null && iter != null){ //To avoid not loaded fonts or if text ist empty

              for (int i = iter.getBeginIndex(); i < iter.getEndIndex(); i++) {

                char currentChar = iter.setIndex(i);

                Set<Attribute> keys = iter.getAllAttributeKeys();

                Map<Attribute, Object> charAtts = iter.getAttributes();

               

                Object baseLineShift = charAtts.get(SVGTextElementBridge.BASELINE_SHIFT);

                Object paintInfo = charAtts.get(SVGTextElementBridge.PAINT_INFO);

                Object charX = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.X);

                Object charY = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.Y);

                Object charDX = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.DX);

                Object charDY = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.DY);

                Object charRotation = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.ROTATION);

                Object gvtFont = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.GVT_FONT);

                Object gvtFonts = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.GVT_FONTS);

                Object gvtFontFamilies = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.GVT_FONT_FAMILIES);

                Object textCompoundDelimiter = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.TEXT_COMPOUND_DELIMITER);

                Object verticalOrientation = charAtts.get(GVTAttributedCharacterIterator.TextAttribute.VERTICAL_ORIENTATION);

                logger.debug("Character: "  + currentChar + " CharX:" + charX + " CharY: " + charY + " CharDX: " +  charDX + " CharDY: " + charDY +  " Font: " + gvtFont +  " Fonts: " + gvtFonts +   " FontFamilies: " + gvtFontFamilies);

                AWTGVTFont awtGvtFont = (AWTGVTFont)gvtFont;

                if (awtGvtFont != null)

                  logger.debug("CharfontSize: " + awtGvtFont.getSize());

                //FIXME REMOVE, Not working always 0,0

                SVGPoint startPosOfChar = SVGTextContentSupport.getStartPositionOfChar(textElement, i);

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

                //Get the character information - font, colors

                String newFamilyName = new String(fontFamily);

                float newFontSize = fontSize;

                MTColor newFillColor = new MTColor(fillColor);

                MTColor newStrokeColor = new MTColor(strokeColor);

                boolean charHasColorInfo = false;

                boolean charHasFontInfo = false;

                //Get chars paint info

                if (paintInfo != null && paintInfo instanceof TextPaintInfo){

                  charHasColorInfo = true;

                  TextPaintInfo texInfo = (TextPaintInfo)paintInfo;

                  if (texInfo.fillPaint instanceof java.awt.Color){

                    java.awt.Color color = (Color)texInfo.fillPaint;

                    newFillColor.setColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());

                  }

                  if (texInfo.strokePaint instanceof java.awt.Color){

                    java.awt.Color color = (Color)texInfo.strokePaint;

                    newStrokeColor.setColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());

                  }

                }

                //Get the chars font family and size

                GVTFont aGvtFont = null;

                if (gvtFonts!=null){

                  if (gvtFonts instanceof List) {

                    List<?> fonts = (List<?>) gvtFonts;

                    for (Iterator<?> iterator = fonts.iterator(); iterator.hasNext();) {

                      Object o = (Object) iterator.next();

                      if (o instanceof GVTFont) {

                        aGvtFont = (GVTFont) o;

                        //logger.debug("Char font family: " + aGvtFont.getFamilyName() + " Size:" + aGvtFont.getSize());

                      }

                    }

                  }

                }

                if (aGvtFont != null){

                  charHasFontInfo = true;

                  newFamilyName = aGvtFont.getFamilyName();

                  newFontSize = aGvtFont.getSize();

                }else{

                  logger.error("Character: " + currentChar + " has no font attached.");

                }

                if (charHasColorInfo && charHasFontInfo){

                  logger.debug("Character '" + currentChar + "'-> has font info -> load font!" +

                      " Family: " + newFamilyName +

                      " Fontsize: " + Math.round(newFontSize) +

                      " FillColor: " + newFillColor +

                      " StrokeColor: " + newStrokeColor);

                 

                  if (useVectorFont)

                    fontToUse = FontManager.getInstance().createFont(pa,

                        "arial.ttf", Math.round(newFontSize), newFillColor, newStrokeColor);

                  else

                    fontToUse = FontManager.getInstance().createFont(pa, //uses cached font if available

//                        "Arial", Math.round(fontSize),

                        newFamilyName, Math.round(newFontSize), newFillColor, newStrokeColor);

                  if (fontToUse == null){

                    fontToUse = font;

                  }

                }else{

                  fontToUse = font;

                }

                boolean fontChanged = !FontManager.isFontsAreEqual(fontToUse, lastUsedFont);

                lastUsedFont = fontToUse;

//                fontChanged = true;

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

                boolean textPositionChanged = charX != null || charY != null  || charDX != null || charDY != null;

                //TODO if we forceAnewTextarea because of font change but ther is NO NEW POSITION, we

                //have to set the textareas anchor to the lower left

                //TODO problem if we have a tspan centered and a next tspan without new position

                //-> the first tspan textarea gets centered on the position

                //but we would have to treat them (all in the same line) as 1 textarea when center positioning!

               

                //FIXME there are slight differences because we use a different SPACE character length and no font KERNING!

               

                //FIXME DO WIDHTOUT USERDATA

                //FIXME bitmap font has no top border, vector has.. why?

                //TODO -> eventuell doch in handleSvgNode machen?

                //-> statt graphicsnode /stylable node �bergeben? - SVGOMTextElement is nicht instanceof graphicsnode..

               

                // we have to check font/color etc at every character, not only at new positon because

                //pos doesent change at tspans without new posinfo

                //check if equal to last used font and if equal original text font

                if ( fontChanged || textPositionChanged         

                ){ //Make a new textarea if the text position changed or if the font changed at the current character

                  MTTextArea previousTextArea = null;

                  if (!textAreas.isEmpty()){

                    previousTextArea = textAreas.get(textAreas.size()-1);

                  }

                  float newXPos = 0;

                  float newYPos = 0 ;

                  //If there is a previous text, get its ending coordinates

                  //for the DX and DY shift info for the next text area

                  if (previousTextArea != null){

                    PositionAnchor oldAnchor = previousTextArea.getAnchor();

                    previousTextArea.setAnchor(PositionAnchor.UPPER_LEFT);

                    //Calculate last/current textposition for DX and DY use

                    //add up the last textareas start position end position(width)

                    Vector3D lastPos = previousTextArea.getPosition(TransformSpace.LOCAL);

                    lastPos.addLocal(new Vector3D(previousTextArea.getWidthXY(TransformSpace.LOCAL) - 2 * previousTextArea.getInnerPaddingLeft(),0));

                    newXPos = lastPos.x;

                    newXPos += (Float)previousTextArea.getUserData("XPos");

                    newYPos = lastPos.y;

//                    newYPos += fontToUse.getFontMaxDescent(); //FIXME WHY NEVESSARY?

                    newYPos += (Float)previousTextArea.getUserData("YPos");

                    previousTextArea.setAnchor(oldAnchor);

                  }

                  //IF absolute x or y is present overwrite the position values from the last textarea

                  if (charX != null)

                    newXPos = (Float)charX;

                  if (charY != null)

                    newYPos = (Float)charY;

                  if (charDX != null)

                    newXPos += (Float)charDX;

                  if (charDY != null)

                    newYPos += (Float)charDY;

                 

                  // Create the text area \\

                  MTTextArea t = new MTTextArea(pa, fontToUse);

                  t.setNoFill(true);

                  t.setNoStroke(true);

                  textAreas.add(t);

                  try{

                    t.setLocalMatrix(new Matrix(currentLocalTransformMatrix));

                  }catch(Exception e){

                    logger.error(e.getMessage());

                  }

                  //FIXME TEST

//                  if (previousTextArea != null && !textPositionChange){

//                  t.setAnchor(PositionAnchor.LOWER_LEFT);

//                  t.setUserData("posRelParent", new Vector3D(newXPos , newYPos - fontToUse.getFontMaxDescent() , 0));

//                  logger.debug("Character '" + currentChar + "' -> Anchor: LOWER_LEFT");

//                  }else{

                  Value v = CSSUtilities.getComputedStyle(textElement, SVGCSSEngine.TEXT_ANCHOR_INDEX);

                  //INFO: we have to move the BASELINE of the text to the svg position

                  //The textarea is usually fontmaxascent+fontmaxdescent+2*innerPadding big!

                  switch (v.getStringValue().charAt(0)) {

                  case 'e':

                    t.setAnchor(PositionAnchor.LOWER_RIGHT);

                    t.setUserData("posRelParent", new Vector3D((newXPos + t.getInnerPaddingLeft()) , newYPos - fontToUse.getFontMaxDescent()  +  t.getInnerPaddingTop() , 0));

                    logger.debug("Character '" + currentChar + "' -> Anchor: LOWER_RIGHT");

                    break;

                  case 'm': //text-anchor="middle"

                    t.setAnchor(PositionAnchor.CENTER);

//                    t.setUserData("posRelParent", new Vector3D(newXPos, newYPos - fontToUse.getFontAbsoluteHeight()*0.5f + t.getInnerPaddingTop() , 0));

//                    t.setPositionRelativeToParent(new Vector3D(newXPos, newYPos - font.getFontMaxAscent()*0.5f - font.getFontMaxDescent()*0.5f, 0)); //- font.getFontMaxAscent()*0.5f

                    logger.debug("Character '" + currentChar + "' -> Anchor: CENTER");

                    t.setUserData("posRelParent", new Vector3D((newXPos), (newYPos - fontToUse.getFontMaxDescent() + t.getInnerPaddingTop()) - t.getHeightXY(TransformSpace.LOCAL)/2f , 0));

                    break;

                  default: //text-anchor="start" //default!

                    t.setAnchor(PositionAnchor.LOWER_LEFT);

                    t.setUserData("posRelParent", new Vector3D(newXPos -t.getInnerPaddingLeft(), newYPos - fontToUse.getFontMaxDescent() + t.getInnerPaddingTop() , 0));