Logo Search packages:      
Sourcecode: jaxe version File versions  Download package

boolean jaxe::Config::insertionPossible ( JaxeElement  parent,
final int  debutSelection,
final int  finSelection,
final Element  aInserer 
) [inline]

Renvoie true si on peut insérer l'élement aInsérer sous la balise parent sur la sélection définie par les positions debutSelection et finSelection.

Definition at line 1433 of file Config.java.

References chercheParentEspace(), jaxe::JaxeElement::debut, jaxe::JaxeElement::doc, jaxe::JaxeDocument::DOMdoc, jaxe::InterfaceSchema::espaceElement(), expressionEspace(), jaxe::InterfaceSchema::expressionReguliere(), getElementConf(), jaxe::JaxeDocument::getElementForNode(), getRefConf(), getSchema(), jaxe::JaxeElement::insererDOM(), LOG, jaxe::JaxeElement::noeud, jaxe::JaxeElement::nouvelElementDOM(), jaxe::JaxeElement::refElement, and jaxe::JaxeElement::regrouperTextes().

                                                                                                                                   {
        if (schema instanceof SchemaSimple)
            return(true); // on suppose que le test de sous-élément a déjà été fait
        if (schema instanceof SchemaRelaxNG) {
            if (debutSelection < parent.debut.getOffset()) {
                LOG.error("Config.insertionPossible: debutSelection < parent.debut");
                return(false);
            }
            final Element elAInserer = parent.nouvelElementDOM(parent.doc, aInserer);
            Position pos;
            try {
                pos = parent.doc.createPosition(debutSelection);
            } catch (final BadLocationException ble) {
                LOG.error("Config.insertionPossible - BadLocationException", ble);
                return(false);
            }
            parent.insererDOM(pos, elAInserer);
            final boolean insertionOK = ((SchemaRelaxNG)schema).documentValide(parent.doc.DOMdoc, true);
            try {
                parent.noeud.removeChild(elAInserer);
            } catch (final DOMException ex) {
                LOG.error("Config.insertionPossible - DOMException", ex);
            }
            parent.regrouperTextes();
            return(insertionOK);
        }
        if (autresConfigs.size() > 0) {
            final Config conf = getRefConf(aInserer);
/*
    pb: on ne peut pas tester l'ordre des éléments dans certains cas, par exemple:
    <html>
        <head>
            <xsl:if test='truc'>
                <title>xxx</title>
            </xsl:if>
            <xsl:if test='not(truc)'>
                <title>yyy</title>
            </xsl:if>
        </head>
    </html>
    Ici on autorise deux éléments title sous head alors qu'un seul est normalement autorisé.
    Par contre on peut tester les imbrications (title est autorisé sous head).
*/
            if (conf != this)
                return(true);
            
            final Config pconf = getElementConf((Element)parent.noeud);
            if (conf != pconf) {
                final Element noeudparent = chercheParentEspace((Element)parent.noeud, conf.getSchema().espaceElement(aInserer));
                if (noeudparent == null)
                    return(true);
                parent = parent.doc.getElementForNode(noeudparent);
            }
        }
        final Element refParent = parent.refElement;
        final String espaceRacine = parent.noeud.getOwnerDocument().getDocumentElement().getNamespaceURI();
        final boolean xslt = "http://www.w3.org/1999/XSL/Transform".equals(espaceRacine);
        String cettexp = expressionEspace(parent, debutSelection, finSelection, aInserer, xslt, parent.noeud.getNamespaceURI());
        if (cettexp == null)
            cettexp = "";
        //System.out.println("cettexp: " + cettexp);
        
        if (cacheInsertion == null)
            cacheInsertion = new HashMap<Element, Pattern>();
        
        // jakarta-regexp
        //RE r = (RE)cacheInsertion.get(refParent);
        // jakarta-oro
        //Pattern r = cacheInsertion.get(refParent);
        // gnu-regexp
        //RE r = (RE)cacheInsertion.get(refParent);
        // java.util.regex
        Pattern r = cacheInsertion.get(refParent);
        
        if (r == null) {
            final String expr = "^" + schema.expressionReguliere(refParent, false, false) + "$";
            // jakarta-regexp
            /*
            try {
                r = new RE(expr);
            } catch (RESyntaxException ex) {
                LOG.error("insertionPossible(JaxeElement, Position, Element) - Malformed Pattern: " + expr, ex);
                return(true);
            }
            */
            
            // jakarta-oro
            /*
            try {
                r = compiler.compile(expr);
            } catch (final MalformedPatternException ex) {
                LOG.error("insertionPossible(JaxeElement, Position, Element) - Malformed Pattern: " + expr, ex);
                return(true);
            }
            */
            
            // gnu-regexp
            /*
            try {
                r = new RE(expr);
            } catch (REException ex) {
                LOG.error("insertionPossible(JaxeElement, Position, Element) - Malformed Pattern: " + expr, ex);
                return(true);
            }
            */
            
            // java.util.regex
            try {
                r = Pattern.compile(expr);
            } catch (final PatternSyntaxException ex) {
                LOG.error("insertionPossible(JaxeElement, Position, Element) :" + expr, ex);
                return(true);
            }
            
            cacheInsertion.put(refParent, r);
        }
        
        // jakarta-regexp
        //boolean matched = r.match(cettexp);
        // jakarta-oro
        //final boolean matched = matcher.matches(cettexp, r);
        // gnu-regexp
        //boolean matched = r.isMatch(cettexp);
        // java.util.regex
        final boolean matched = r.matcher(cettexp).matches();
        return(matched);
    }


Generated by  Doxygen 1.6.0   Back to index