Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.openoffice.spreadsheet;

import org.openconcerto.openoffice.ODDocument;

import org.openconcerto.openoffice.OOXML;

import org.openconcerto.openoffice.XMLFormatVersion;

import org.openconcerto.openoffice.text.Heading;

import org.openconcerto.openoffice.text.Paragraph;

import org.openconcerto.openoffice.text.Span;

import org.openconcerto.openoffice.text.TextNode;

import org.openconcerto.openoffice.text.TextNodeDesc;

import org.openconcerto.xml.JDOMUtils;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.jdom.Content;

import org.jdom.Element;

import org.jdom.Text;

import org.jdom.filter.ElementFilter;

import org.jdom.filter.Filter;

// this represent a list of lines separated by Sep, e.g. :

// foo Sep.ANY bar Sep.LINE baz Sep.PARAGRAPH

public final class Lines {

    // remove all text:span (keeping their content) from elem

    static private final void flattenSpans(final Element elem, final XMLFormatVersion vers) {

        final ElementFilter filter = TextNodeDesc.get(Span.class).getFilter(vers);

        int i = 0;

        int size = elem.getContentSize();

        while (i < size) {

            final Content c = elem.getContent(i);

            if (filter.matches(c)) {

                elem.addContent(i, ((Element) c).removeContent());

                c.detach();

                size = elem.getContentSize();

            } else {

                i++;

            }

        }

    }

    // newline or line separator or paragraph separator

    static private final Pattern SEP_PATTERN = Pattern.compile("(\r?\n)|\f|" + TextNode.VERTICAL_TAB_CHAR + "|\\p{Zl}|\\p{Zp}");

    static private enum Sep {

        // allow to re-use exiting lines (be it a line-break or a new paragraph)

        ANY,

        // explicit line-break

        LINE,

        // explicit new paragraph

        PARAGRAPH

    }

    static private final Sep getSep(final String s, final boolean onlyP) {

        final int codePoint = s.codePointAt(0);

        final Sep res;

        if (codePoint == '\n' || codePoint == '\r') {

            res = Sep.ANY;

        } else if (codePoint == TextNode.VERTICAL_TAB_CHAR) {

            res = Sep.LINE;

        } else if (codePoint == '\f') {

            res = Sep.PARAGRAPH;

        } else {

            final int cat = Character.getType(codePoint);

            if (cat == Character.PARAGRAPH_SEPARATOR) {

                res = Sep.PARAGRAPH;

            } else if (cat == Character.LINE_SEPARATOR) {

                res = Sep.LINE;

            } else {

                throw new IllegalArgumentException("Unknown codePoint " + codePoint);

            }

        }

        return onlyP ? Sep.PARAGRAPH : res;

    }

    private final ODDocument doc;

    private final OOXML xml;

    private final LinkedList<String> lines;

    private final LinkedList<Sep> separators;

    public Lines(final ODDocument doc, final String text) {

        super();

        this.doc = doc;

        this.xml = doc.getFormatVersion().getXML();

        this.lines = new LinkedList<String>();

        this.separators = new LinkedList<Sep>();

        this.parse(text, isCalc());

    }

    private final boolean isCalc() {

        return this.doc instanceof SpreadSheet;

    }

    // building

    private void parse(final String value, final boolean onlyP) {

        final Matcher matcher = SEP_PATTERN.matcher(value);

        int i = 0;

        while (matcher.find()) {

            this.add(value.substring(i, matcher.start()), getSep(matcher.group(), onlyP));

            i = matcher.end();

        }

        this.addLast(value.substring(i));

    }

    private void add(final String s, final Sep sep) {

        if (sep == null)

            throw new NullPointerException("Null separator");

        addLine(s);

        this.separators.add(sep);

    }

    private final void addLine(final String s) {

        if (s == null)

            throw new NullPointerException("Null string");

        this.lines.add(s);

    }

    private void addLast(final String s) {

        this.addLine(s);

        checkLineFirst(true, "Size mismatch");

    }

    // checking

    private void checkLineFirst(final boolean b, final String msg) {

        if (!checkLineFirst(b, false))

            throw new IllegalArgumentException(msg);

    }

    public final boolean checkLineFirst(final boolean b) {

        return checkLineFirst(b, true);

    }

    public final boolean checkLineFirst(final boolean b, final boolean allowEmpty) {

        final int linesSize = this.lines.size();

        final int sepSize = this.separators.size();

        if (linesSize == 0 && sepSize == 0)

            return allowEmpty;

        final boolean lineFirst;

        if (linesSize == sepSize + 1)

            lineFirst = true;

        else if (linesSize == sepSize)

            lineFirst = false;

        else

            throw new IllegalArgumentException("Size problem");

        return lineFirst == b;

    }

    // consuming

    public Sep peekSep() {

        return this.separators.peekFirst();

    }

    public String peekLine() {

        return this.lines.peekFirst();

    }

    public boolean allConsumed() {

        return peekLine() == null;

    }

    public List<Content> consume() {

        return this.consume(false);

    }

    public List<Content> consume(final boolean noSep) {

        if (!noSep) {

            this.separators.removeFirst();

        } else {

            checkLineFirst(true, "Already separator first");

        }

        final String res = this.lines.removeFirst();

        return this.xml.encodeWSasList(res);

    }

    public void consumeSep() {

        checkLineFirst(false, "Not separator first");

        this.separators.removeFirst();

    }

    // TODO add Integer startLine and Integer endLine parameters to only replace a subset of the

    // current text (null could mean after the end and negative could use TextNode.getLinesCount()).

    // This would allow to easily change the content of a text document.

    public final void setText(final Element elem, final boolean textMode) {

        if (this.doc.getPackage().getXMLFile(elem.getDocument()) == null)

            throw new IllegalArgumentException("Element not in document");

        final boolean isCalc = this.isCalc();

        final XMLFormatVersion vers = this.xml.getFormatVersion();

        if (!this.checkLineFirst(true))

            throw new IllegalStateException("Lines invalid");

        final Element tabElem = this.xml.getTab();

        final Element newLineElem = this.xml.getLineBreak();

        final Element spacesElem = this.xml.createSpaces(1);

        final Filter noNLTextFilter = new Filter() {

            @Override

            public boolean matches(Object obj) {

                if (obj instanceof Element) {

                    final Element elem = (Element) obj;

                    return JDOMUtils.equals(elem, tabElem) || JDOMUtils.equals(elem, spacesElem);

                } else {

                    return obj instanceof Text;

                }

            }

        };

        final Filter nlFilter = new ElementFilter(newLineElem.getName(), newLineElem.getNamespace());

        // reuse text:p to keep style

        final Filter pFilter = TextNodeDesc.get(Paragraph.class).getFilter(vers).or(TextNodeDesc.get(Heading.class).getFilter(vers));

        @SuppressWarnings("unchecked")

        final Iterator<Element> pChildren = new ArrayList<Element>(elem.getContent(pFilter)).iterator();

        while (pChildren.hasNext() && !this.allConsumed()) {

            final Element pElem = pChildren.next();

            // to keep it simple remove all text:span except if there's one for the whole text :

            // allow cells in spreadsheet to keep their character style.

            final Element wholeSpan = TextNode.getWholeSpan(pElem, vers, textMode);

            final Element wholeText = wholeSpan == null ? pElem : wholeSpan;

            flattenSpans(wholeText, vers);

            int j = 0;

            int size = wholeText.getContentSize();

            while (j < size) {

                final Content c = wholeText.getContent(j);

                if (noNLTextFilter.matches(c)) {

                    // remove current text

                    c.detach();

                    size--;

                } else if (nlFilter.matches(c)) {

                    // re-use line-break if allowed

                    if (this.peekSep() == Sep.LINE || this.peekSep() == Sep.ANY) {

                        // add before line-break

                        wholeText.addContent(j, this.consume());

                        size++;

                        // jump after line-break

                        j += 2;

                    } else {

                        // if not allowed (or we're at the last line) remove line-break

                        c.detach();

                        size--;

                    }

                } else {

                    // content that doesn't encode text

                    j++;

                }

            }

            // since we only consumed in the above loop when there was a next separator

            assert !this.allConsumed();

            wholeText.addContent(this.consume(true));

            // *** ATTN sep first

            assert this.checkLineFirst(false);

            // create requested new lines

            while (this.peekSep() == Sep.LINE) {

                wholeText.addContent((Content) newLineElem.clone());

                wholeText.addContent(this.consume());

            }

            // avoid creating paragraphs

            if (!isCalc && !this.allConsumed() && !pChildren.hasNext()) {

                while (this.peekSep() == Sep.LINE || this.peekSep() == Sep.ANY) {

                    wholeText.addContent((Content) newLineElem.clone());

                    wholeText.addContent(this.consume());

                }

            }

            assert this.peekSep() != Sep.LINE;

            if (!this.allConsumed()) {

                this.consumeSep();

            }

            // *** ATTN string first

            assert this.checkLineFirst(true);

        }

        assert this.checkLineFirst(true);

        // remove extra paragraphs

        while (pChildren.hasNext()) {

            pChildren.next().detach();

        }

        // create needed paragraphs

        Element pElem = null;

        while (!this.allConsumed()) {

            final boolean firstLoop = pElem == null;

            // except for the first loop (still string first) there's always a separator if

            // there's a line

            assert firstLoop || this.peekSep() != null;

            if (firstLoop || this.peekSep() == Sep.PARAGRAPH) {

                pElem = Paragraph.createEmpty(vers);

                // switch to sep first in the first loop

                pElem.setContent(this.consume(firstLoop));

                elem.addContent(pElem);

            } else {

                pElem.addContent((Content) newLineElem.clone());

                pElem.addContent(this.consume());

            }

        }

    }

}