/*

  * Copyright 2002 - 2007 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: Menclose.java,v 353eda94b8dd 2009/10/14 10:04:09 max $ */

 package net.sourceforge.jeuclid.elements.presentation.general;

 import java.awt.Color;

 import java.awt.geom.Dimension2D;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.InvocationTargetException;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Stack;

 import net.sourceforge.jeuclid.LayoutContext;

 import net.sourceforge.jeuclid.context.Parameter;

 import net.sourceforge.jeuclid.elements.AbstractElementWithDelegates;

 import net.sourceforge.jeuclid.elements.JEuclidElement;

 import net.sourceforge.jeuclid.elements.presentation.AbstractContainer;

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

 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.layout.GraphicsObject;

 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 net.sourceforge.jeuclid.layout.LineObject;

 import org.apache.batik.dom.AbstractDocument;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.w3c.dom.Node;

 import org.w3c.dom.mathml.MathMLEncloseElement;

 /**

  * Class for supporting "menclose" elements.

  * 

  * @version $Revision: 353eda94b8dd $

  */

 public final class Menclose extends AbstractElementWithDelegates implements

         MathMLEncloseElement {

     /**

      * The XML element from this class.

      */

     public static final String ELEMENT = "menclose";

     /** The notation attribute. */

     public static final String ATTR_NOTATION = "notation";

     private static final String LONGDIV = "longdiv";

     /**

      * base class for all row-like notations.

      * 

      */

     private abstract static class AbstractRowLikeNotation extends

             AbstractContainer {

         /**

          * No data, so SUID is does not matter.

          */

         private static final long serialVersionUID = 1L;

         /**

          * Default constructor. Sets MathML Namespace.

          * 

          * @param qname

          *            Qualified name.

          * @param odoc

          *            Owner Document.

          */

         public AbstractRowLikeNotation(final String qname,

                 final AbstractDocument odoc) {

             super(qname, odoc);

         }

         /** {@inheritDoc} */

         @Override

         protected void layoutStageInvariant(final LayoutView view,

                 final LayoutInfo info, final LayoutStage stage,

                 final LayoutContext context) {

             final LayoutContext now = this

                     .applyLocalAttributesToContext(context);

             final Dimension2D borderLeftTop = this.getBorderLeftTop(now);

             final float borderLeft = (float) borderLeftTop.getWidth();

             if (borderLeft > 0.0f) {

                 view.getInfo((LayoutableNode) this.getFirstChild()).moveTo(

                         borderLeft, 0, stage);

             }

             ElementListSupport.fillInfoFromChildren(view, info, this, stage,

                     borderLeftTop, this.getBorderRightBottom(now));

             this.enclHook(info, stage, this.applyLocalAttributesToContext(now));

         }

         /**

          * Add left / top border to enclosed object.

          * 

          * @param now

          *            current Layout Context

          * @return Left and Top border

          */

         protected Dimension2D getBorderLeftTop(final LayoutContext now) {

             return new Dimension2DImpl(0.0f, 0.0f);

         }

         /**

          * Add right / bottom border to enclosed object.

          * 

          * @param now

          *            current Layout Context

          * @return Right and Bottom border

          */

         protected Dimension2D getBorderRightBottom(final LayoutContext now) {

             return new Dimension2DImpl(0.0f, 0.0f);

         }

         /**

          * Add Graphic objects to enclosed object.

          * 

          * @param info

          *            Layout Info

          * @param stage

          *            current Layout Stage

          * @param now

          *            current Layout Context

          */

         protected abstract void enclHook(final LayoutInfo info,

                 final LayoutStage stage, final LayoutContext now);

     }

     /**

      * Represents the US long-division notation, to support the notation

      * "longdiv".

      * 

      */

     private static final class Longdiv extends Menclose.AbstractRowLikeNotation {

         private static final long serialVersionUID = 1L;

         /**

          * Default constructor. Sets MathML Namespace.

          * 

          * @param qname

          *            Qualified name.

          * @param odoc

          *            Owner Document.

          */

         public Longdiv(final String qname, final AbstractDocument odoc) {

             super(qname, odoc);

         }

         @Override

         protected Node newNode() {

             return new Longdiv(this.nodeName, this.ownerDocument);

         }

         /** {@inheritDoc} */

         @Override

         protected Dimension2D getBorderLeftTop(final LayoutContext now) {

             final float lineSpace = GraphicsSupport.lineWidth(now) * 2;

             return new Dimension2DImpl(AttributesHelper.convertSizeToPt(

                     "0.25em", now, null)

                     + lineSpace, lineSpace);

         }

         /** {@inheritDoc} */

         @Override

         protected void enclHook(final LayoutInfo info, final LayoutStage stage,

                 final LayoutContext now) {

             final List<GraphicsObject> graphicObjects = info

                     .getGraphicObjects();

             graphicObjects.clear();

             final float lineWidth = GraphicsSupport.lineWidth(now);

             final float top = info.getAscentHeight(stage) + lineWidth;

             final Color color = (Color) now.getParameter(Parameter.MATHCOLOR);

             graphicObjects.add(new LineObject(lineWidth, -top, lineWidth, info

                     .getDescentHeight(stage), lineWidth, color));

             graphicObjects.add(new LineObject(lineWidth, -top, info

                     .getWidth(stage), -top, lineWidth, color));

         }

     }

     /**

      * Up-Diagonal Strike.

      * 

      */

     private static final class Updiagonalstrike extends

             Menclose.AbstractRowLikeNotation {

         private static final long serialVersionUID = 1L;

         /**

          * Default constructor. Sets MathML Namespace.

          * 

          * @param qname

          *            Qualified name.

          * @param odoc

          *            Owner Document.

          */

         public Updiagonalstrike(final String qname, final AbstractDocument odoc) {

             super(qname, odoc);

         }

         @Override

         protected Node newNode() {

             return new Updiagonalstrike(this.nodeName, this.ownerDocument);

         }

         /** {@inheritDoc} */

         @Override

         protected void enclHook(final LayoutInfo info, final LayoutStage stage,

                 final LayoutContext now) {

             final Color color = (Color) now.getParameter(Parameter.MATHCOLOR);

             final float lineWidth = GraphicsSupport.lineWidth(now);

             info.setGraphicsObject(new LineObject(0, info

                     .getDescentHeight(stage), info.getWidth(stage), -info

                     .getAscentHeight(stage), lineWidth, color));

         }

     }

     /**

      * Down-Diagonal Strike.

      * 

      */

     private static final class Downdiagonalstrike extends

             Menclose.AbstractRowLikeNotation {

         private static final long serialVersionUID = 1L;

         /**

          * Default constructor. Sets MathML Namespace.

          * 

          * @param qname

          *            Qualified name.

          * @param odoc

          *            Owner Document.

          */

         public Downdiagonalstrike(final String qname,

                 final AbstractDocument odoc) {

             super(qname, odoc);

         }

         @Override

         protected Node newNode() {

             return new Downdiagonalstrike(this.nodeName, this.ownerDocument);

         }

         /** {@inheritDoc} */

         @Override

         protected void enclHook(final LayoutInfo info, final LayoutStage stage,

                 final LayoutContext now) {

             final Color color = (Color) now.getParameter(Parameter.MATHCOLOR);

             final float lineWidth = GraphicsSupport.lineWidth(now);

             info.setGraphicsObject(new LineObject(0, -info

                     .getAscentHeight(stage), info.getWidth(stage), info

                     .getDescentHeight(stage), lineWidth, color));

         }

     }

     private static final class Actuarial extends

             Menclose.AbstractRowLikeNotation {

         private static final long serialVersionUID = 1L;

         /**

          * Default constructor. Sets MathML Namespace.

          * 

          * @param qname

          *            Qualified name.

          * @param odoc

          *            Owner Document.

          */

         public Actuarial(final String qname, final AbstractDocument odoc) {

             super(qname, odoc);

         }

         @Override

         protected Node newNode() {

             return new Actuarial(this.nodeName, this.ownerDocument);

         }

         /** {@inheritDoc} */

         @Override

         protected Dimension2D getBorderLeftTop(final LayoutContext now) {

             final float lineSpace = GraphicsSupport.lineWidth(now) * 2;

             return new Dimension2DImpl(0.0f, lineSpace);

         }

         /** {@inheritDoc} */

         @Override

         protected Dimension2D getBorderRightBottom(final LayoutContext now) {

             final float lineSpace = GraphicsSupport.lineWidth(now) * 2;

             return new Dimension2DImpl(lineSpace, 0.0f);

         }

         /** {@inheritDoc} */

         @Override

         protected void enclHook(final LayoutInfo info, final LayoutStage stage,

                 final LayoutContext now) {

             final List<GraphicsObject> graphicObjects = info

                     .getGraphicObjects();

             graphicObjects.clear();

             final float lineWidth = GraphicsSupport.lineWidth(now);

             final float top = info.getAscentHeight(stage) + lineWidth;

             final Color color = (Color) now.getParameter(Parameter.MATHCOLOR);

             graphicObjects.add(new LineObject(0, -top, info.getWidth(stage)

                     - lineWidth, -top, lineWidth, color));

             graphicObjects.add(new LineObject(info.getWidth(stage) - lineWidth,

                     -top, info.getWidth(stage) - lineWidth, info

                             .getDescentHeight(stage), lineWidth, color));

         }

     }

     /**

      * Logger for this class

      */

     private static final Log LOGGER = LogFactory.getLog(Menclose.class);

     private static final Map<String, Constructor<?>> IMPL_CLASSES = new HashMap<String, Constructor<?>>();;

     private static final long serialVersionUID = 1L;

     /**

      * Default constructor. Sets MathML Namespace.

      * 

      * @param qname

      *            Qualified name.

      * @param odoc

      *            Owner Document.

      */

     public Menclose(final String qname, final AbstractDocument odoc) {

         super(qname, odoc);

         this.setDefaultMathAttribute(Menclose.ATTR_NOTATION, Menclose.LONGDIV);

     }

     /** {@inheritDoc} */

     @Override

     protected Node newNode() {

         return new Menclose(this.nodeName, this.ownerDocument);

     }

     /**

      * @return notation of menclose element

      */

     public String getNotation() {

         return this.getMathAttribute(Menclose.ATTR_NOTATION);

     }

     /**

      * Sets notation for menclose element.

      * 

      * @param notation

      *            Notation

      */

     public void setNotation(final String notation) {

         this.setAttribute(Menclose.ATTR_NOTATION, notation);

     }

     /** {@inheritDoc} */

     @Override

     protected List<LayoutableNode> createDelegates() {

         final Stack<Constructor<?>> notationImpls = this.parseNotations();

         JEuclidElement lastChild = this.ensureSingleChild();

         lastChild = this.createStackOfDelegates(notationImpls, lastChild);

         return Collections.singletonList((LayoutableNode) lastChild);

     }

     private JEuclidElement createStackOfDelegates(

             final Stack<Constructor<?>> notationImpls,

             final JEuclidElement oldChild) {

         JEuclidElement lastChild = oldChild;

         while (!notationImpls.isEmpty()) {

             final Constructor<?> con = notationImpls.pop();

             try {

                 final JEuclidElement element = (JEuclidElement) con

                         .newInstance("saklsdiwet:menclosechild",

                                 this.ownerDocument);

                 element.appendChild(lastChild);

                 lastChild = element;

             } catch (final InstantiationException e) {

                 Menclose.LOGGER.warn(e);

             } catch (final IllegalAccessException e) {

                 Menclose.LOGGER.warn(e);

             } catch (final InvocationTargetException e) {

                 Menclose.LOGGER.warn(e);

             }

         }

         return lastChild;

     }

     /**

      * This is just to make sure that there is at least one delegate, and that

      * each of the standard delegates has exactly one child.

      * 

      * @return a single JEuclidElement.

      */

     private JEuclidElement ensureSingleChild() {

         final JEuclidElement lastChild;

         if (this.getMathElementCount() == 1) {

             lastChild = this.getMathElement(0);

         } else {

             lastChild = (JEuclidElement) this.ownerDocument

                     .createElement(Mrow.ELEMENT);

             for (final Node child : ElementListSupport

                     .createListOfChildren(this)) {

                 lastChild.appendChild(child);

             }

         }

         return lastChild;

     }

     private Stack<Constructor<?>> parseNotations() {

         final String[] notations = this.getNotation().split(" ");

         final Stack<Constructor<?>> notationImpls = new Stack<Constructor<?>>();

         for (final String curNotation : notations) {

             final Constructor<?> con = Menclose.IMPL_CLASSES.get(curNotation

                     .toLowerCase(Locale.ENGLISH));

             if (con == null) {

                 if (curNotation.length() > 0) {

                     Menclose.LOGGER.info("Unsupported notation for menclose: "

                             + curNotation);

                 }

             } else {

                 notationImpls.push(con);

             }

         }

         return notationImpls;

     }

     static {

         try {

             Menclose.IMPL_CLASSES.put("radical", Msqrt.class.getConstructor(

                     String.class, AbstractDocument.class));

             Menclose.IMPL_CLASSES.put(Menclose.LONGDIV, Menclose.Longdiv.class

                     .getConstructor(String.class, AbstractDocument.class));

             Menclose.IMPL_CLASSES.put("updiagonalstrike",

                     Menclose.Updiagonalstrike.class.getConstructor(

                             String.class, AbstractDocument.class));

             Menclose.IMPL_CLASSES.put("downdiagonalstrike",

                     Menclose.Downdiagonalstrike.class.getConstructor(

                             String.class, AbstractDocument.class));

             Menclose.IMPL_CLASSES.put("actuarial", Menclose.Actuarial.class

                     .getConstructor(String.class, AbstractDocument.class));

         } catch (final NoSuchMethodException e) {

             Menclose.LOGGER.fatal(e);

         }

     }

 }