/*

  * Copyright 2002 - 2009 JEuclid, http://jeuclid.sf.net

  * 

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 /* $Id: AbstractJEuclidElement.java,v 62d8defc665e 2009/09/25 14:22:59 max $ */

 package net.sourceforge.jeuclid.elements;

 import java.awt.Color;

 import java.awt.Font;

 import java.awt.FontMetrics;

 import java.awt.Graphics2D;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import net.sourceforge.jeuclid.LayoutContext;

 import net.sourceforge.jeuclid.context.StyleAttributeLayoutContext;

 import net.sourceforge.jeuclid.elements.presentation.token.Mo;

 import net.sourceforge.jeuclid.elements.presentation.token.Mtext;

 import net.sourceforge.jeuclid.elements.support.ElementListSupport;

 import net.sourceforge.jeuclid.elements.support.GraphicsSupport;

 import net.sourceforge.jeuclid.elements.support.attributes.AttributesHelper;

 import net.sourceforge.jeuclid.elements.support.attributes.MathVariant;

 import net.sourceforge.jeuclid.elements.support.text.TextContent;

 import net.sourceforge.jeuclid.layout.LayoutInfo;

 import net.sourceforge.jeuclid.layout.LayoutStage;

 import net.sourceforge.jeuclid.layout.LayoutView;

 import net.sourceforge.jeuclid.layout.LayoutableNode;

 import org.apache.batik.dom.AbstractDocument;

 import org.apache.batik.dom.GenericElementNS;

 import org.apache.batik.dom.events.DOMMutationEvent;

 import org.w3c.dom.Attr;

 import org.w3c.dom.Node;

 import org.w3c.dom.events.Event;

 import org.w3c.dom.mathml.MathMLElement;

 import org.w3c.dom.mathml.MathMLMathElement;

 import org.w3c.dom.mathml.MathMLNodeList;

 /**

  * The basic class for all math elements. Every element class inherits from this

  * class. It provides basic functionality for drawing.

  * 

  * @version $Revision: 62d8defc665e $

  */

 // CHECKSTYLE:OFF

 public abstract class AbstractJEuclidElement extends

 // CHECKSTYLE:ON

         GenericElementNS implements JEuclidElement {

     /** Constant for mathvariant attribute. */

     public static final String ATTR_MATHVARIANT = "mathvariant";

     /** Constant for mathcolor attribute. */

     public static final String ATTR_MATHCOLOR = "mathcolor";

     /** Constant for mathsize attribute. */

     public static final String ATTR_MATHSIZE = "mathsize";

     /** Constant for fontfamily attribute. */

     public static final String ATTR_DEPRECATED_FONTFAMILY = "fontfamily";

     /** Constant for fontstyle attribute. */

     public static final String ATTR_DEPRECATED_FONTSTYLE = "fontstyle";

     /** Constant for fontweight attribute. */

     public static final String ATTR_DEPRECATED_FONTWEIGHT = "fontweight";

     /** Constant for fontsize attribute. */

     public static final String ATTR_DEPRECATED_FONTSIZE = "fontsize";

     /** Constant for color attribute. */

     public static final String ATTR_DEPRECATED_COLOR = "color";

     /** Constant for background attribute. */

     public static final String ATTR_DEPRECATED_BACKGROUND = "background";

     /** Constant for class attribute. */

     public static final String ATTR_CLASS = "class";

     /** Constant for style attribute. */

     public static final String ATTR_STYLE = "style";

     /** Constant for id attribute. */

     public static final String ATTR_ID = "id";

     /** Constant for href attribute. */

     public static final String ATTR_HREF = "xlink:href";

     /** Constant for xref attribute. */

     public static final String ATTR_XREF = "xref";

     /** The mathbackground attribute. */

     public static final String ATTR_MATHBACKGROUND = "mathbackground";

     /**

      * largest value for all trivial spaces (= spaces that can be ignored /

      * shortened).

      */

     public static final int TRIVIAL_SPACE_MAX = 0x20;

     /**

      * The URI from MathML.

      */

     public static final String URI = "http://www.w3.org/1998/Math/MathML";

     private static final float MIDDLE_SHIFT = 0.38f;

     // /**

     // * Logger for this class

     // */

     // private static final Log LOGGER = LogFactory

     // .getLog(AbstractJEuclidElement.class);

     private static final Set<String> DEPRECATED_ATTRIBUTES = new HashSet<String>();

     /**

      * Reference to the element acting as parent if there is no parent.

      */

     private JEuclidElement fakeParent;

     private final Map<String, String> defaultMathAttributes = new HashMap<String, String>();

     /**

      * Default constructor. Sets MathML Namespace.

      * 

      * @param qname

      *            Qualified name.

      * @param odoc

      *            Owner Document.

      */

     public AbstractJEuclidElement(final String qname,

             final AbstractDocument odoc) {

         super(AbstractJEuclidElement.URI, qname, odoc);

     }

     /**

      * Constructor to explicitly set the namespace.

      * 

      * @param nsUri

      *            Namespace URI.

      * @param qname

      *            Qualified name.

      * @param odoc

      *            Owner Document.

      */

     public AbstractJEuclidElement(final String nsUri, final String qname,

             final AbstractDocument odoc) {

         super(nsUri, qname, odoc);

     }

     /**

      * Gets the used font. Everything regardes font, processed by MathBase

      * object.

      * 

      * @param context

      *            LayoutContext to use.

      * @return Font Font object.

      */

     public Font getFont(final LayoutContext context) {

         final String content = this.getText();

         final char aChar;

         if (content.length() > 0) {

             aChar = content.charAt(0);

         } else {

             aChar = 'A';

         }

         return this.getMathvariantAsVariant().createFont(

                 GraphicsSupport.getFontsizeInPoint(context), aChar,

                 this.applyLocalAttributesToContext(context), true);

     }

     /** {@inheritDoc} */

     public MathVariant getMathvariantAsVariant() {

         // TODO: Support deprecated variant names

         String setMv = this.getMathAttribute(

                 AbstractJEuclidElement.ATTR_MATHVARIANT, false);

         JEuclidElement parent = this.getParent();

         while ((setMv == null) && (parent != null)) {

             // element is not set, try to inherit

             if (parent instanceof AbstractJEuclidElement) {

                 setMv = ((AbstractJEuclidElement) parent).getMathAttribute(

                         AbstractJEuclidElement.ATTR_MATHVARIANT, false);

             }

             parent = parent.getParent();

         }

         if (setMv == null) {

             setMv = this.defaultMathAttributes

                     .get(AbstractJEuclidElement.ATTR_MATHVARIANT);

         }

         MathVariant variant;

         if (setMv == null) {

             variant = MathVariant.NORMAL;

         } else {

             variant = MathVariant.stringToMathVariant(setMv);

             if (variant == null) {

                 variant = MathVariant.NORMAL;

             }

         }

         return variant;

     }

     // /**

     // * Setting size of child of the element.

     // *

     // * @param child

     // * Child element

     // * @param childpos

     // * Position of the child element

     // */

     //

     // private void setChildSize(AbstractMathElement child, int childpos) {

     //

     // float childSize = (float) Math.pow(getScriptSizeMultiplier(), child

     // .getAbsoluteScriptLevel());

     //

     // child.multipleFont(m_font, (float) Math.pow(getScriptSizeMultiplier(),

     // child.getAbsoluteScriptLevel()));

     // System.out.println(child.toString() + " "

     // + child.getAbsoluteScriptLevel() + " "

     // + getScriptSizeMultiplier() + " " + childSize);

     //

     // child.setScriptSizeMultiplier(getScriptSizeMultiplier());

     //

     // if (this instanceof MathMultiScripts) {

     // if (childpos > 0) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // } else if (this instanceof MathOver) {

     // if (childpos == 1) {

     // if (((getMathElement(0) instanceof MathOperator) && ((MathOperator)

     // getMathElement(0))

     // .getMoveableLimits())

     // || (!((MathOver) this).getAccent())) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // }

     // } else if (this instanceof MathUnder) {

     // if (childpos == 1) {

     // if (((getMathElement(0) instanceof MathOperator) && ((MathOperator)

     // getMathElement(0))

     // .getMoveableLimits())

     // || (!((MathUnder) this).getAccentUnder())) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // }

     // } else if (this instanceof MathUnderOver) {

     // if (childpos > 0) {

     // if (((getMathElement(0) instanceof MathOperator) && ((MathOperator)

     // getMathElement(0))

     // .getMoveableLimits())

     // || ((childpos == 1) && (!((MathUnderOver) this)

     // .getAccentUnder()))

     // || ((childpos == 2) && (!((MathUnderOver) this)

     // .getAccent()))) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // }

     // } else if (this instanceof MathRoot) {

     // if (childpos == 1) {

     // child.multipleFont(m_font, (float) Math.pow(

     // getScriptSizeMultiplier(), 2));

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // } else if (this instanceof MathSub) {

     // if (childpos == 1) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // } else if (this instanceof MathSup) {

     // if (childpos == 1) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // } else if (this instanceof MathSubSup) {

     // if (childpos > 0) {

     // child.multipleFont(m_font, getScriptSizeMultiplier());

     // child.setDisplayStyle(false);

     // child.setInheritSisplayStyle(false);

     // }

     // } else if (this instanceof MathStyle) {

     // // child.multipleFont(m_font, (float) Math.pow(

     // // getScriptSizeMultiplier(), ((MathStyle) this)

     // // .getScriptlevel()));

     // } else {

     // child.setFont(m_font);

     // }

     // }

     /**

      * Add a math element as a child.

      * 

      * @param child

      *            Math element object.

      */

     public final void addMathElement(final MathMLElement child) {

         if (child != null) {

             this.appendChild(child);

         }

     }

     /**

      * Gets a child from this element.

      * <p>

      * Please note, that unlike the MathML DOM model functions this function

      * uses a 0-based index.

      * 

      * @param index

      *            Index of the child (0-based).

      * @return The child MathElement object.

      */

     protected JEuclidElement getMathElement(final int index) {

         final List<Node> childList = ElementListSupport

                 .createListOfChildren(this);

         int count = 0;

         for (final Node n : childList) {

             if (n instanceof JEuclidElement) {

                 if (count == index) {

                     return (JEuclidElement) n;

                 }

                 count++;

             }

         }

         for (; count < index; count++) {

             this.appendChild(this.ownerDocument.createElement(Mtext.ELEMENT));

         }

         final JEuclidElement last = (JEuclidElement) this.ownerDocument

                 .createElement(Mtext.ELEMENT);

         this.appendChild(last);

         return last;

     }

     /**

      * Sets a specific child to the newElement, creating other subelements as

      * necessary.

      * 

      * @param index

      *            the index to set (0=the first child)

      * @param newElement

      *            new element to be set as child.

      */

     protected void setMathElement(final int index,

             final MathMLElement newElement) {

         final org.w3c.dom.NodeList childList = this.getChildNodes();

         while (childList.getLength() < index) {

             this.appendChild(this.getOwnerDocument().createTextNode(""));

         }

         if (childList.getLength() == index) {

             this.addMathElement(newElement);

         } else {

             this.replaceChild(newElement, childList.item(index));

         }

     }

     /** {@inheritDoc} */

     public int getIndexOfMathElement(final JEuclidElement element) {

         final org.w3c.dom.NodeList childList = this.getChildNodes();

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

             if (childList.item(i).equals(element)) {

                 return i;

             }

         }

         return -1;

     }

     /** {@inheritDoc} */

     public int getMathElementCount() {

         final List<Node> childList = ElementListSupport

                 .createListOfChildren(this);

         int count = 0;

         for (final Node n : childList) {

             if (n instanceof JEuclidElement) {

                 count++;

             }

         }

         return count;

     }

     /**

      * Returns the text content of this element.

      * 

      * @return Text content.

      */

     public String getText() {

         return TextContent.getText(this);

     }

     /** {@inheritDoc} */

     public void setFakeParent(final JEuclidElement parent) {

         this.fakeParent = parent;

     }

     private JEuclidNode getParentAsJEuclidNode() {

         final Node parentNode = this.getParentNode();

         final JEuclidNode theParent;

         if (parentNode instanceof JEuclidNode) {

             theParent = (JEuclidNode) parentNode;

         } else {

             theParent = null;

         }

         if (theParent == null) {

             return this.fakeParent;

         } else {

             return theParent;

         }

     }

     /** {@inheritDoc} */

     public JEuclidElement getParent() {

         final JEuclidNode parentNode = this.getParentAsJEuclidNode();

         if (parentNode instanceof JEuclidElement) {

             return (JEuclidElement) parentNode;

         } else {

             return null;

         }

     }

     /**

      * Sets value of mathvariant attribute (style of the element).

      * 

      * @param mathvariant

      *            Value of mathvariant.

      */

     public void setMathvariant(final String mathvariant) {

         this.setAttribute(AbstractJEuclidElement.ATTR_MATHVARIANT, mathvariant);

     }

     /**

      * Returns value of mathvariant attribute (style of the element).

      * 

      * @return Value of mathvariant.

      */

     public String getMathvariant() {

         return this.getMathAttribute(AbstractJEuclidElement.ATTR_MATHVARIANT);

     }

     /**

      * Gets the font metrics of the used font.

      * 

      * @return Font metrics.

      * @param context

      *            LayoutContext to use.

      * @param g

      *            Graphics2D context to use.

      */

     public FontMetrics getFontMetrics(final Graphics2D g,

             final LayoutContext context) {

         return g.getFontMetrics(this.getFont(context));

     }

     /**

      * Sets value of math color attribute.

      * 

      * @param mathcolor

      *            Color object.

      */

     public void setMathcolor(final String mathcolor) {

         this.setAttribute(AbstractJEuclidElement.ATTR_MATHCOLOR, mathcolor);

     }

     /**

      * Returns value of mathcolor attribute.

      * 

      * @return Color as string.

      */

     public String getMathcolor() {

         String color;

         color = this.getMathAttribute(AbstractJEuclidElement.ATTR_MATHCOLOR);

         if (color == null) {

             color = this

                     .getMathAttribute(AbstractJEuclidElement.ATTR_DEPRECATED_COLOR);

         }

         return color;

     }

     /**

      * Retrieve the mathsize attribute.

      * 

      * @return the mathsize attribute.

      */

     public String getMathsize() {

         String size;

         size = this.getMathAttribute(AbstractJEuclidElement.ATTR_MATHSIZE);

         if (size == null) {

             size = this

                     .getMathAttribute(AbstractJEuclidElement.ATTR_DEPRECATED_FONTSIZE);

         }

         return size;

     }

     /**

      * Sets mathsize to a new value.

      * 

      * @param mathsize

      *            value of mathsize.

      */

     public void setMathsize(final String mathsize) {

         this.setAttribute(AbstractJEuclidElement.ATTR_MATHSIZE, mathsize);

     }

     /**

      * Sets default values for math attributes. Default values are returned

      * through getMathAttribute, but not stored in the actual DOM tree. This is

      * necessary to support proper serialization.

      * 

      * @param key

      *            the attribute to set.

      * @param value

      *            value of the attribute.

      */

     protected void setDefaultMathAttribute(final String key, final String value) {

         this.defaultMathAttributes.put(key, value);

     }

     /**

      * retrieve an attribute from the MathML or default name space, returning

      * the default value if the attribute is not set.

      * 

      * @param attrName

      *            the name of the attribute

      * @return attribute value or null if not set.

      * @see #getMathAttribute(String, boolean)

      */

     protected String getMathAttribute(final String attrName) {

         return this.getMathAttribute(attrName, true);

     }

     /**

      * retrieve an attribute from the MathML or default name space.

      * 

      * @param attrName

      *            the name of the attribute

      * @param useDefault

      *            is true, the default value is used if the attribute is not

      *            set.

      * @return attribute value or null if not set.

      * @see #getMathAttribute(String)

      */

     protected String getMathAttribute(final String attrName,

             final boolean useDefault) {

         final String attrValue;

         Attr attr = this.getAttributeNodeNS(AbstractJEuclidElement.URI,

                 attrName);

         if (attr == null) {

             attr = this.getAttributeNode(attrName);

         }

         if (attr == null) {

             if (useDefault) {

                 attrValue = this.getDefaultMathAttribute(attrName);

             } else {

                 attrValue = null;

             }

         } else {

             attrValue = attr.getValue().trim();

         }

         return attrValue;

     }

     /**

      * Retrieves the previously stored default value for this attribute.

      * 

      * @param attrName

      *            name of the Attribute

      * @return value set by {@link #setDefaultMathAttribute(String, String)} or

      *         null if not set.

      */

     private String getDefaultMathAttribute(final String attrName) {

         return this.defaultMathAttributes.get(attrName);

     }

     /**

      * Returns value of mathbackground attribute.

      * 

      * @return Color as string.

      */

     public String getMathbackground() {

         String color;

         color = this

                 .getMathAttribute(AbstractJEuclidElement.ATTR_MATHBACKGROUND);

         if (color == null) {

             color = this

                     .getMathAttribute(AbstractJEuclidElement.ATTR_DEPRECATED_BACKGROUND);

         }

         return color;

     }

     /**

      * Sets the value of the machbackground attribute.

      * 

      * @param mathbackground

      *            a string to be used as background color.

      */

     public void setMathbackground(final String mathbackground) {

         this.setAttribute(AbstractJEuclidElement.ATTR_MATHBACKGROUND,

                 mathbackground);

     }

     /**

      * Returns the distance of the baseline and the middleline.

      * 

      * @return Distance baseline - middleline.

      * @param context

      *            Layout Context to use

      * @param g

      *            Graphics2D context to use.

      */

     public float getMiddleShift(final Graphics2D g, final LayoutContext context) {

         return this.getFontMetrics(g, context).getAscent()

                 * AbstractJEuclidElement.MIDDLE_SHIFT;

     }

     /** {@inheritDoc} */

     public String getClassName() {

         return this.getAttribute(AbstractJEuclidElement.ATTR_CLASS);

     }

     /** {@inheritDoc} */

     public void setClassName(final String className) {

         this.setAttribute(AbstractJEuclidElement.ATTR_CLASS, className);

     }

     /** {@inheritDoc} */

     public String getMathElementStyle() {

         return this.getAttribute(AbstractJEuclidElement.ATTR_STYLE);

     }

     /** {@inheritDoc} */

     public void setMathElementStyle(final String mathElementStyle) {

         this.setAttribute(AbstractJEuclidElement.ATTR_STYLE, mathElementStyle);

     }

     /** {@inheritDoc} */

     @Override

     public String getId() {

         return this.getAttribute(AbstractJEuclidElement.ATTR_ID);

     }

     /** {@inheritDoc} */

     public void setId(final String id) {

         this.setAttribute(AbstractJEuclidElement.ATTR_ID, id);

     }

     /** {@inheritDoc} */

     public String getXref() {

         return this.getAttribute(AbstractJEuclidElement.ATTR_XREF);

     }

     /** {@inheritDoc} */

     public void setXref(final String xref) {

         this.setAttribute(AbstractJEuclidElement.ATTR_XREF, xref);

     }

     /** {@inheritDoc} */

     public String getHref() {

         return this.getAttribute(AbstractJEuclidElement.ATTR_HREF);

     }

     /** {@inheritDoc} */

     public void setHref(final String href) {

         this.setAttribute(AbstractJEuclidElement.ATTR_HREF, href);

     }

     /** {@inheritDoc} */

     public MathMLMathElement getOwnerMathElement() {

         JEuclidElement node = this.getParent();

         while (node != null) {

             if (node instanceof MathMLMathElement) {

                 return (MathMLMathElement) node;

             }

             node = node.getParent();

         }

         return null;

     }

     /** {@inheritDoc} */

     public boolean hasChildPrescripts(final JEuclidElement child) {

         return false;

     }

     /** {@inheritDoc} */

     public boolean hasChildPostscripts(final JEuclidElement child,

             final LayoutContext context) {

         return false;

     }

     /**

      * Returns the children as a MathML NodeList.

      * 

      * @return a list of children

      */

     public MathMLNodeList getContents() {

         return (MathMLNodeList) this.getChildNodes();

     }

     /** {@inheritDoc} */

     public LayoutContext getChildLayoutContext(final int childNum,

             final LayoutContext context) {

         return this.applyLocalAttributesToContext(context);

     }

     /**

      * Retrieve the LayoutContext valid for the current node.

      * 

      * @param context

      *            external context.

      * @return the current layout context.

      */

     public LayoutContext applyLocalAttributesToContext(

             final LayoutContext context) {

         // TODO: Theoretically this only applies all to presentation token

         // elements except mspace and mglyph, and on no other elements except

         // mstyle 3.2.2

         return this.applyStyleAttributes(context);

     }

     /**

      * Apply Style attributed specified in 3.2.2 to a layout context.

      * 

      * @param applyTo

      *            the context to apply to

      * @return a context which has the style attributes changed accordingly. May

      *         be the original context if nothing has changed.

      */

     private LayoutContext applyStyleAttributes(final LayoutContext applyTo) {

         LayoutContext retVal = applyTo;

         // Variant is not inherited and therefore not part of the context.

         final String msize = this.getMathsize();

         final Color foreground;

         final String colorString = this.getMathcolor();

         if (colorString == null) {

             foreground = null;

         } else {

             foreground = AttributesHelper.stringToColor(colorString,

                     Color.BLACK);

         }

         // Background is handled differently and does not need to go into

         // context.

         if ((msize != null) || (foreground != null)) {

             retVal = new StyleAttributeLayoutContext(applyTo, msize, foreground);

         }

         return retVal;

     }

     /** {@inheritDoc} */

     public List<LayoutableNode> getChildrenToLayout() {

         final List<LayoutableNode> l = ElementListSupport

                 .createListOfLayoutChildren(this);

         return l;

     }

     /** {@inheritDoc} */

     public List<LayoutableNode> getChildrenToDraw() {

         final List<LayoutableNode> l = ElementListSupport

                 .createListOfLayoutChildren(this);

         return l;

     }

     /**

      * Layout for elements which are stage independent.

      * <p>

      * This function will layout an element which is layed out the same no

      * matter what stage it is in. This is the case for most elements.

      * <p>

      * Notable exceptions are mo and tables.

      * 

      * @param view

      *            View Object for this layout.

      * @param info

      *            An info object which will be filled during layout.

      * @param stage

      *            current layout stage.

      * @param context

      *            current LayoutContext.

      */

     protected void layoutStageInvariant(final LayoutView view,

             final LayoutInfo info, final LayoutStage stage,

             final LayoutContext context) {

         ElementListSupport.layoutSequential(view, info, this

                 .getChildrenToLayout(), stage);

     }

     /** {@inheritDoc} */

     public void layoutStage1(final LayoutView view, final LayoutInfo info,

             final LayoutStage childMinStage, final LayoutContext context) {

         this.layoutStageInvariant(view, info, LayoutStage.STAGE1, context);

         // TODO: This should be done in a better way.

         if (this.getMathbackground() == null) {

             info.setLayoutStage(childMinStage);

         } else {

             info.setLayoutStage(LayoutStage.STAGE1);

         }

     }

     /** {@inheritDoc} */

     public void layoutStage2(final LayoutView view, final LayoutInfo info,

             final LayoutContext context) {

         this.layoutStageInvariant(view, info, LayoutStage.STAGE2, context);

         // TODO: put in own function, ensure this is also called from

         // subclasses.

         final String background = this.getMathbackground();

         final Color backgroundColor = AttributesHelper.stringToColor(

                 background, null);

         ElementListSupport.addBackground(backgroundColor, info, false);

         info.setLayoutStage(LayoutStage.STAGE2);

     }

     static {

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_COLOR);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_BACKGROUND);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_FONTSIZE);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_FONTWEIGHT);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_FONTSTYLE);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES

                 .add(AbstractJEuclidElement.ATTR_DEPRECATED_FONTFAMILY);

         AbstractJEuclidElement.DEPRECATED_ATTRIBUTES.add(Mo.ATTR_MOVEABLEWRONG);

     }

     /**

      * Override this function to get notified whenever the contents of this

      * element have changed.

      */

     protected void changeHook() {

         // Override me!

     }

     /** {@inheritDoc} */

     @Override

     public boolean dispatchEvent(final Event evt) {

         if (evt instanceof DOMMutationEvent) {

             this.changeHook();

         }

         return super.dispatchEvent(evt);

     }

 }