Attachment #127236 for bug #217163

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 217163
Collapse All | Expand All




<apidef name="csl.api">Common Scripting Language API</apidef>
</apidefs>
<changes>
    <change id="DeleteWordHandler">
        <api name="csl.api"/>
        <summary>Add DeleteWordHandler</summary>
        <version major="2" minor="34"/>
        <date day="13" month="11" year="2012"/>
        <author login="mkristofic"/>
        <compatibility addition="yes" deletion="no" modification="no" binary="compatible" source="compatible" deprecation="yes"/>
        <description>
            <p>
                Add DeleteWordHandler to replace KeystrokeHandler in future. KeystrokeHandler is deprecated since clients can use TypingHooks from editor.lib2
            </p>
        </description>
        <class package="org.netbeans.modules.csl.api" name="DeleteWordHandler"/>
        <issue number="217163"/>
    </change>
    <change id="LanguageRegistration.useMultiview">
        <api name="csl.api"/>
        <summary>Add useMultiview to @LanguageRegistration</summary>

Lines 40-46 Link Here

(-)a/csl.api/nbproject/project.properties (-1 / +1 lines)
40	# Version 2 license, then the option applies only if the new code is	40	# Version 2 license, then the option applies only if the new code is
41	# made subject to such option by the copyright holder.	41	# made subject to such option by the copyright holder.
42		42
43	spec.version.base=2.33.0	43	spec.version.base=2.34.0
44	is.autoload=true	44	is.autoload=true
45	javac.source=1.6	45	javac.source=1.6
46		46





package org.netbeans.modules.csl.api;

import java.util.Collection;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Utilities;
import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
import org.openide.ErrorManager;

/**

        if (offset == doc.getLength()) {
            return -1;
        }
        Collection<? extends DeleteWordHandler> deleteWordHandlers = MimeLookup.getLookup(UiUtils.getMimePath(doc, offset)).lookupAll(DeleteWordHandler.class);
        if (!deleteWordHandlers.isEmpty()) {
            for (DeleteWordHandler dw :deleteWordHandlers) {
                int nextOffset = dw.getNextWordOffset(doc, offset);
                if (nextOffset != -1) {
                    return nextOffset;
                }
            }
        }
         
        KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);
        if (bc != null) {
            int nextOffset = bc.getNextWordOffset(doc, offset, false);


        final Document doc = textComponent.getDocument();
        
        Collection<? extends DeleteWordHandler> deleteWordHandlers = MimeLookup.getLookup(UiUtils.getMimePath(doc, offset)).lookupAll(DeleteWordHandler.class);
        if (!deleteWordHandlers.isEmpty()) {
            for (DeleteWordHandler dw :deleteWordHandlers) {
                int nextOffset = dw.getPreviousWordOffset(doc, offset);
                if (nextOffset != -1) {
                    return nextOffset;
                }
            }
        }
        
        KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);
        if (bc != null) {
            int nextOffset = bc.getNextWordOffset(




import javax.swing.text.JTextComponent;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.modules.csl.core.CslDeletedTextInterceptor;
import org.netbeans.modules.csl.spi.ParserResult;
import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;


/**
 * Interface that a plugin can implement to assist with Delete word.
 * editing.
 *
 * @author Tor Norbye
 */
public interface DeleteWordHandler {
    /**
     * Compute the next word position, if any. Can be used to implement
     * camel case motion etc.
     * 
     * @param doc The document to move in
     * @param caretOffset The caret position corresponding to the current word
     * @return The next word boundary offset in the given direction, or -1 if this
     *   implementation doesn't want to compute word boundaries (the default will be used)
     *
     * Return true if the character was already inserted (and the IDE
     * should not further insert anything)
     *
     * XXX Fix javadoc.
     */
    @CheckForNull
    int getNextWordOffset(Document doc, int caretOffset);

    /** @todo Rip out the boolean return value? What does it mean? */
    boolean afterCharInserted(@NonNull Document doc, int caretOffset, @NonNull JTextComponent target, char ch)
        throws BadLocationException;

    /**
     * (Based on KeystrokeHandler class in NetBeans' java editor support)
     *
     * Hook called after a character *ch* was backspace-deleted from
     * *doc*. The function possibly removes bracket or quote pair if
     * appropriate.
     * @todo Document why both caretOffset and caret is passed in!
     * Return the new offset, or -1
     */

    /** @todo Split into before and after? */
    public boolean charBackspaced(@NonNull Document doc, int caretOffset, @NonNull JTextComponent target, char ch)
        throws BadLocationException;

    /**
     * A line break is being called. Return -1 to do nothing.
     * If you want to modify the document first, you can do that, and then
     * return the new offset to assign the caret to AFTER the newline has been
     * inserted.
     *
     * @todo rip out return value
     * @todo Document why both caretOffset and caret is passed in!
     */
    int beforeBreak(@NonNull Document doc, int caretOffset, @NonNull JTextComponent target)
        throws BadLocationException;

    /**
     * Compute a range matching the caret position. If no eligible range
     * is found, return {@link OffsetRange#NONE}.
     */
    @NonNull
    OffsetRange findMatching(@NonNull Document doc, int caretOffset);
    
    /**
     * Compute set of selection ranges for the given parse tree (around the given offset),
     * in leaf-to-root order.
     */
    @NonNull
    List<OffsetRange> findLogicalRanges(@NonNull ParserResult info, int caretOffset);
    
    /**
     * Compute the previous word position, if any. Can be used to implement

     * 
     * @param doc The document to move in
     * @param caretOffset The caret position corresponding to the current word
     * @return The previous word boundary offset in the given direction, or -1 if this
     * @return The next word boundary offset in the given direction, or -1 if this
     *   implementation doesn't want to compute word boundaries (the default will be used)
     */
    @CheckForNull
    int getPreviousWordOffset(Document doc, int caretOffset);
}

Lines 49-61 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/api/KeystrokeHandler.java (-1 / +4 lines)
49	import javax.swing.text.JTextComponent;	49	import javax.swing.text.JTextComponent;
50	import org.netbeans.api.annotations.common.CheckForNull;	50	import org.netbeans.api.annotations.common.CheckForNull;
51	import org.netbeans.api.annotations.common.NonNull;	51	import org.netbeans.api.annotations.common.NonNull;
		52	import org.netbeans.api.editor.mimelookup.MimePath;
		53	import org.netbeans.modules.csl.core.CslDeletedTextInterceptor;
52	import org.netbeans.modules.csl.spi.ParserResult;	54	import org.netbeans.modules.csl.spi.ParserResult;
		55	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
53		56
54		57
55	/**	58	/**
56	* Interface that a plugin can implement to assist with bracket completion during	59	* Interface that a plugin can implement to assist with bracket completion during
57	* editing.	60	* editing.
58	*	61	* @deprecated Use Typing Hooks instead, for details see <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a> and csL DeleteWordHandler.
59	* @author Tor Norbye	62	* @author Tor Norbye
60	*/	63	*/
61	public interface KeystrokeHandler {	64	public interface KeystrokeHandler {




import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.lexer.TokenHierarchy;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.api.progress.ProgressUtils;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.modules.csl.api.DeclarationFinder.DeclarationLocation;
import org.netbeans.modules.csl.core.Language;
import org.netbeans.modules.csl.core.LanguageRegistry;

            }
            return result[0] != null ? result[0] : DeclarationLocation.NONE;
        }
    
    static MimePath getMimePath(final Document doc, final int offset) {
        final MimePath[] mimePathR = new MimePath[1];
        doc.render(new Runnable() {
            @Override
            public void run() {
                List<TokenSequence<?>> seqs = TokenHierarchy.get(doc).embeddedTokenSequences(offset, true);
                TokenSequence<?> seq = seqs.isEmpty() ? null : seqs.get(seqs.size() - 1);
                seq = seq == null ? TokenHierarchy.get(doc).tokenSequence() : seq;
                mimePathR[0] = seq == null ? MimePath.parse(DocumentUtilities.getMimeType(doc)) : MimePath.parse(seq.languagePath().mimePath());
            }
        });
        return mimePathR[0];
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.core;

import javax.swing.text.BadLocationException;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.editor.mimelookup.MimeRegistrations;
import org.netbeans.modules.csl.api.KeystrokeHandler;
import org.netbeans.modules.csl.api.UiUtils;
import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;

public class CslDeletedTextInterceptor implements DeletedTextInterceptor {

    @Override
    public boolean beforeRemove(Context context) throws BadLocationException {
        return false;
    }

    @Override
    public void remove(Context context) throws BadLocationException {
    }

    @Override
    public void afterRemove(Context context) throws BadLocationException {
        if (CslEditorKit.completionSettingEnabled()) {
            KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(context.getDocument(), context.getOffset());
            if (bracketCompletion != null) {
                bracketCompletion.charBackspaced(context.getDocument(), context.getComponent().getCaretPosition(), context.getComponent(), context.getText().charAt(0));
            }
        }
    }

    @Override
    public void cancelled(Context context) {
    }

    @MimeRegistrations(value = {
        @MimeRegistration(mimeType = "", service = DeletedTextInterceptor.Factory.class)})
    public static class Factory implements DeletedTextInterceptor.Factory {

        @Override
        public DeletedTextInterceptor createDeletedTextInterceptor(MimePath mimePath) {
            return new CslDeletedTextInterceptor();
        }
    }
    
}




import javax.swing.JMenuItem;
import javax.swing.KeyStroke;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.JTextComponent;
import javax.swing.text.Keymap;
import javax.swing.text.TextAction;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.editor.mimelookup.MimeRegistrations;
import org.netbeans.editor.BaseAction;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.BaseKit;

import org.netbeans.modules.csl.api.CslActions;
import org.netbeans.modules.csl.api.DeleteToNextCamelCasePosition;
import org.netbeans.modules.csl.api.DeleteToPreviousCamelCasePosition;
import org.netbeans.modules.csl.api.GoToDeclarationAction;
import org.netbeans.modules.csl.api.InstantRenameAction;
import org.netbeans.modules.csl.api.KeystrokeHandler;
import org.netbeans.modules.csl.api.NextCamelCasePosition;

import org.netbeans.modules.csl.api.UiUtils;
import org.netbeans.modules.csl.api.GoToMarkOccurrencesAction;
import org.netbeans.modules.editor.NbEditorKit;
import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor.Context;
import org.netbeans.spi.editor.typinghooks.TypedBreakInterceptor;
import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor;
import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor.MutableContext;
import org.openide.awt.Mnemonics;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

/**

        Action[] superActions = super.createActions();
        Language language = LanguageRegistry.getInstance().getLanguageByMimeType(mimeType);
        ArrayList<Action> actions = new ArrayList<Action>(30);

        actions.add(new GsfDefaultKeyTypedAction());
        actions.add(new GsfInsertBreakAction());
        actions.add(new GsfDeleteCharAction(deletePrevCharAction, false));
        
        // The php needs to handle special cases of toggle comment. There has to be 
        // registered ToggleBlockCommentAction in PHP that handles these special cases,

    /**
     * Returns true if bracket completion is enabled in options.
     */
    static boolean completionSettingEnabled() {
        //return ((Boolean)Settings.getValue(GsfEditorKit.class, JavaSettingsNames.PAIR_CHARACTERS_COMPLETION)).booleanValue();
        return true;
    }
    
    private final class GsfDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {
        private JTextComponent currentTarget;
        private String replacedText = null;

        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            currentTarget = target;
            super.actionPerformed(evt, target);
            currentTarget = null;
        }

        @Override
        protected void insertString(BaseDocument doc, int dotPos, Caret caret, String str,
            boolean overwrite) throws BadLocationException {
            if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                if (bracketCompletion != null) {
                    // TODO - check if we're in a comment etc. and if so, do nothing
                    boolean handled =
                        bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget,
                            str.charAt(0));

                    if (!handled) {
                        super.insertString(doc, dotPos, caret, str, overwrite);
                        handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget,
                                str.charAt(0));
                    }

                    return;
                }
            }

            super.insertString(doc, dotPos, caret, str, overwrite);
        }

        @Override
        protected void replaceSelection(JTextComponent target, int dotPos, Caret caret,
            String str, boolean overwrite) throws BadLocationException {
            if (str.equals("")) {
                return;
            }
            char insertedChar = str.charAt(0);
            Document document = target.getDocument();

            if (document instanceof BaseDocument) {
                BaseDocument doc = (BaseDocument)document;

                if (completionSettingEnabled()) {
                    KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                    if (bracketCompletion != null) {
                        try {
                            int caretPosition = caret.getDot();

                            boolean handled =
                                bracketCompletion.beforeCharInserted(doc, caretPosition,
                                    target, insertedChar);

                            int p0 = Math.min(caret.getDot(), caret.getMark());
                            int p1 = Math.max(caret.getDot(), caret.getMark());

                            if (p0 != p1) {
                                doc.remove(p0, p1 - p0);
                            }

                            if (!handled) {
                                if ((str != null) && (str.length() > 0)) {
                                    doc.insertString(p0, str, null);
                                }

                                bracketCompletion.afterCharInserted(doc, caret.getDot() - 1,
                                    target, insertedChar);
                            }
                        } catch (BadLocationException e) {
                            e.printStackTrace();
                        }

                        return;
                    }
                }
            }

            super.replaceSelection(target, dotPos, caret, str, overwrite);
        }
    }

    private final class GsfInsertBreakAction extends InsertBreakAction {
        static final long serialVersionUID = -1506173310438326380L;

        @Override
        protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
            if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, caret.getDot());

                if (bracketCompletion != null) {
                    try {
                        int newOffset = bracketCompletion.beforeBreak(doc, caret.getDot(), target);

                        if (newOffset >= 0) {
                            return new Integer(newOffset);
                        }
                    } catch (BadLocationException ble) {
                        Exceptions.printStackTrace(ble);
                    }
                }
            }

            // return Boolean.TRUE;
            return null;
        }

        @Override
        protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret,
            Object cookie) {
            if (completionSettingEnabled()) {
                if (cookie != null) {
                    if (cookie instanceof Integer) {
                        // integer
                        int dotPos = ((Integer)cookie).intValue();
                        if (dotPos != -1) {
                            caret.setDot(dotPos);
                        } else {
                            int nowDotPos = caret.getDot();
                            caret.setDot(nowDotPos + 1);
                        }
                    }
                }
            }
        }
    }

    private final class GsfDeleteCharAction extends ExtDeleteCharAction {
        private JTextComponent currentTarget;

        public GsfDeleteCharAction(String nm, boolean nextChar) {
            super(nm, nextChar);
        }

        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            currentTarget = target;
            super.actionPerformed(evt, target);
            currentTarget = null;
        }

        @Override
        protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch)
            throws BadLocationException {
            if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                if (bracketCompletion != null) {
                    boolean success = bracketCompletion.charBackspaced(doc, dotPos, currentTarget, ch);
                    return;
                }
            }
            super.charBackspaced(doc, dotPos, caret, ch);
        }
    }

    private final class GenericGenerateGoToPopupAction extends NbGenerateGoToPopupAction {
        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {

            return jm;
        }
    }


}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.core;

import javax.swing.text.BadLocationException;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.editor.mimelookup.MimeRegistrations;
import org.netbeans.modules.csl.api.KeystrokeHandler;
import org.netbeans.modules.csl.api.UiUtils;
import org.netbeans.spi.editor.typinghooks.TypedBreakInterceptor;

public class CslTypedBreakInterceptor implements TypedBreakInterceptor {

    private int caretPosition = -1;

    @Override
    public boolean beforeInsert(Context context) throws BadLocationException {
        return false;
    }

    @Override
    public void insert(MutableContext context) throws BadLocationException {
        if (CslEditorKit.completionSettingEnabled()) {
            KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(context.getDocument(), context.getCaretOffset());
            if (bracketCompletion != null) {
                int newOffset = bracketCompletion.beforeBreak(context.getDocument(), context.getCaretOffset(), context.getComponent());
                if (newOffset >= 0) {
                    caretPosition = newOffset;
                }
            }
        }
    }

    @Override
    public void afterInsert(Context context) throws BadLocationException {
        if (CslEditorKit.completionSettingEnabled()) {
            if (caretPosition != -1) {
                context.getComponent().getCaret().setDot(caretPosition);
                caretPosition = -1;
            }
        }
    }

    @Override
    public void cancelled(Context context) {
    }

    @MimeRegistrations(value = {
        @MimeRegistration(mimeType = "", service = TypedBreakInterceptor.Factory.class)})
    public static class Factory implements TypedBreakInterceptor.Factory {

        @Override
        public TypedBreakInterceptor createTypedBreakInterceptor(MimePath mimePath) {
            return new CslTypedBreakInterceptor();
        }
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.core;

import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.editor.mimelookup.MimeRegistrations;
import org.netbeans.modules.csl.api.KeystrokeHandler;
import org.netbeans.modules.csl.api.UiUtils;
import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor;

public class CslTypedTextInterceptor implements TypedTextInterceptor {

    private boolean handled = true;

    @Override
    public boolean beforeInsert(Context context) throws BadLocationException {
        return false;
    }

    @Override
    public void insert(MutableContext context) throws BadLocationException {
        if (CslEditorKit.completionSettingEnabled()) {
            Document doc = context.getDocument();
            int dotPos = context.getOffset();
            KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
            if (bracketCompletion != null) {
                JTextComponent currentTarget = context.getComponent();
                String str = context.getText();
                // TODO - check if we're in a comment etc. and if so, do nothing
                handled = bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget, str.charAt(0));
                if (handled) {
                    context.setText("", 0);
                }
            }
        }
    }

    @Override
    public void afterInsert(Context context) throws BadLocationException {
        if (CslEditorKit.completionSettingEnabled()) {
            if (!handled) {
                Document doc = context.getDocument();
                int dotPos = context.getOffset();
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
                if (bracketCompletion != null) {
                    JTextComponent currentTarget = context.getComponent();
                    String str = context.getText();
                    bracketCompletion.afterCharInserted(doc, dotPos, currentTarget, str.charAt(0));
                }
                handled = true;
            } else {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(context.getDocument(), context.getOffset());
                if (bracketCompletion != null) {
                    context.getComponent().getCaret().setDot(context.getComponent().getCaret().getDot() + 1);
                }
            }
        }
    }

    @Override
    public void cancelled(Context context) {
    }

    @MimeRegistrations(value = {
        @MimeRegistration(mimeType = "", service = TypedTextInterceptor.Factory.class)})
    public static class Factory implements TypedTextInterceptor.Factory {

        @Override
        public TypedTextInterceptor createTypedTextInterceptor(MimePath mimePath) {
            return new CslTypedTextInterceptor();
        }
    }
}

Lines 252-258 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/core/Language.java (-2 / +1 lines)
252	} else if (language instanceof DefaultLanguageConfig) {	252	} else if (language instanceof DefaultLanguageConfig) {
253	languageConfig = (DefaultLanguageConfig)language;	253	languageConfig = (DefaultLanguageConfig)language;
254	}	254	}
255	}	255	}
256	return language;	256	return language;
257	}	257	}
258		258
Lines 782-786 Link Here
782	void setOverridingMethodsFile(FileObject fo) {	782	void setOverridingMethodsFile(FileObject fo) {
783	this.overridingMethodsFile = fo;	783	this.overridingMethodsFile = fo;
784	}	784	}
785
786	}	785	}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.csl.editor;

import java.awt.EventQueue;
import java.awt.event.KeyEvent;
import javax.swing.JEditorPane;
import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import junit.framework.TestCase;
import org.netbeans.api.lexer.Language;
import org.netbeans.lib.editor.util.CharSequenceUtilities;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.MIMEResolver;
import org.openide.util.lookup.ServiceProvider;

/**
 * Test brackets completion - unlike the original test this one
 * emulates real typing and tests the resulting state of the document.
 */
public class TypingCompletion {
    public static final class Context {
        
        private JEditorPane pane;

        public Context(final EditorKit kit, final Language language, final String mimetype, final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        pane = new JEditorPane();
                        pane.setEditorKit(kit);
                        Document doc = pane.getDocument();
                        // Required by Java's default key typed
                        doc.putProperty(Language.class, language);
                        doc.putProperty("mimeType", mimetype);
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        pane.setText(text);
                        pane.setCaretPosition((caretOffset != -1) ? caretOffset : doc.getLength());
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
        
        public JEditorPane pane() {
            return pane;
        }

        public Document document() {
            return pane.getDocument();
        }
        
        public void typeChar(final char ch) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        KeyEvent keyEvent;
                        switch (ch) {
                            case '\n':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_ENTER, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Enter
                                break;
                            case '\b':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_BACK_SPACE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of BackSpace
                                break;
                            case '\f':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Delete
                                break;
                            default:
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_TYPED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_UNDEFINED, ch);
                        }
                        SwingUtilities.processKeyBindings(keyEvent);
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }

        public void typeText(String text) {
            for (int i = 0; i < text.length(); i++) {
                typeChar(text.charAt(i));
            }
        }

        public void assertDocumentTextEquals(final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        try {
                            // Use debug text to prefix special chars for easier readability
                            text = CharSequenceUtilities.debugText(text);
                            String docText = document().getText(0, document().getLength());
                            docText = CharSequenceUtilities.debugText(docText);
                            if (!text.equals(docText)) {
                                int diffIndex = 0;
                                int minLen = Math.min(docText.length(), text.length());
                                while (diffIndex < minLen) {
                                    if (text.charAt(diffIndex) != docText.charAt(diffIndex)) {
                                        break;
                                    }
                                    diffIndex++;
                                }
                                TestCase.fail("Invalid document text - diff at index " + diffIndex +
                                        "\nExpected: \"" + text +
                                        "\"\n  Actual: \"" + docText + "\""
                                );
                            }
                        } catch (BadLocationException e) {
                            throw new IllegalStateException(e);
                        }
                        if (caretOffset != -1) {
                            TestCase.assertEquals("Invalid caret offset", caretOffset, pane.getCaretPosition());
                        }
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
    }

    @ServiceProvider(service=MIMEResolver.class)
    public static final class MIMEResolverImpl extends MIMEResolver {

        public MIMEResolverImpl() {
            super("text/x-nbeditor-keybindingsettings");
        }

        @Override public String findMIMEType(FileObject fo) {
            return fo.getPath().contains("Keybindings") ? "text/x-nbeditor-keybindingsettings" : null;
        }
    }
}




        c.setTransferHandler(new HtmlTransferHandler());
    }
    
    protected DeleteCharAction createDeletePrevAction() {
        return new HtmlDeleteCharAction(deletePrevCharAction, false);
    }
    
    protected ExtDefaultKeyTypedAction createDefaultKeyTypedAction() {
        return new HtmlDefaultKeyTypedAction();
    }

    protected InsertBreakAction createInsertBreakAction() {
        return new HtmlInsertBreakAction();
    }
    
    @Override
    protected Action[] createActions() {
        Action[] HtmlActions = new Action[]{
            createInsertBreakAction(),
            createDefaultKeyTypedAction(),
            createDeletePrevAction(),
            new HtmlDeleteCharAction(deleteNextCharAction, true),
            CslActions.createSelectCodeElementAction(true),
            CslActions.createSelectCodeElementAction(false),
            CslActions.createInstantRenameAction(),

        }
    }


    public class HtmlInsertBreakAction extends InsertBreakAction {

        static final long serialVersionUID = -1506173310438326380L;

        @Override
        protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
            if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, caret.getDot());

                if (bracketCompletion != null) {
                    try {
                        int newOffset = bracketCompletion.beforeBreak(doc, caret.getDot(), target);

                        if (newOffset >= 0) {
                            return new Integer(newOffset);
                        }
                    } catch (BadLocationException ble) {
                        Exceptions.printStackTrace(ble);
                    }
                }
            }

            // return Boolean.TRUE;
            return null;
        }

        @Override
        protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret,
                Object cookie) {
            if (completionSettingEnabled()) {
                if (cookie != null) {
                    if (cookie instanceof Integer) {
                        // integer
                        int dotPos = ((Integer) cookie).intValue();
                        if (dotPos != -1) {
                            caret.setDot(dotPos);
                        } else {
                            int nowDotPos = caret.getDot();
                            caret.setDot(nowDotPos + 1);
                        }
                    }
                }
            }
        }
    }

    public static class HtmlDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {

        private JTextComponent currentTarget;

        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            currentTarget = target;
            super.actionPerformed(evt, target);
            currentTarget = null;
        }

        @Override
        protected void insertString(BaseDocument doc, int dotPos,
                Caret caret, String str,
                boolean overwrite) throws BadLocationException {
                
            if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                if (bracketCompletion != null) {
                    // TODO - check if we're in a comment etc. and if so, do nothing
                    boolean handled =
                            bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget,
                            str.charAt(0));

                    if (!handled) {
                            super.insertString(doc, dotPos, caret, str, overwrite);
                            handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget,
                                    str.charAt(0));
                        }


                    return;
                }
            }

            super.insertString(doc, dotPos, caret, str, overwrite);
        }

        @Override
        protected void replaceSelection(JTextComponent target, int dotPos, Caret caret,
                String str, boolean overwrite) throws BadLocationException {
            
            //workaround for #209019 - regression of issue 
            //#204450 - Rewrite actions to use TypingHooks SPI
            if(str.length() == 0) {
                //called from BaseKit.actionPerformed():1160 with empty str argument
                //==> ignore this call since we are going to be called a bit later
                //from HtmlKit.performTextInsertion() properly with the text typed
                return ;
            }
            
            char insertedChar = str.charAt(0);
            Document document = target.getDocument();

            if (document instanceof BaseDocument) {
                BaseDocument doc = (BaseDocument) document;

                if (completionSettingEnabled()) {
                    KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                    if (bracketCompletion != null) {
                        try {
                            int caretPosition = caret.getDot();

                            boolean handled =
                                    bracketCompletion.beforeCharInserted(doc, caretPosition,
                                    target, insertedChar);

                            int p0 = Math.min(caret.getDot(), caret.getMark());
                            int p1 = Math.max(caret.getDot(), caret.getMark());

                            if (p0 != p1) {
                                doc.remove(p0, p1 - p0);
                            }

                            if (!handled) {
                                if ((str != null) && (str.length() > 0)) {
                                    doc.insertString(p0, str, null);
                                }

                                bracketCompletion.afterCharInserted(doc, caret.getDot() - 1,
                                        target, insertedChar);

                            }
                        } catch (BadLocationException e) {
                            e.printStackTrace();
                        }

                        return;
                    }
                }
            }

            super.replaceSelection(target, dotPos, caret, str, overwrite);
        }

    }

    public static class HtmlDeleteCharAction extends DeleteCharAction {

        private JTextComponent currentTarget;
        
        public HtmlDeleteCharAction(String name, boolean nextChar) {
            super(name, nextChar);
        }
        
        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            try {
                currentTarget = target;
                super.actionPerformed(evt, target);
            } finally {
                currentTarget = null;
            }
        }

        @Override
        protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch) throws BadLocationException {
              if (completionSettingEnabled()) {
                KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);

                if (bracketCompletion != null) {
                    boolean success = bracketCompletion.charBackspaced(doc, dotPos, currentTarget, ch);
                    return;
                }
            }
            
            
            super.charBackspaced(doc, dotPos, caret, ch);
        }

        public boolean getNextChar() {
            return nextChar;
        }
    }

    /* !!!!!!!!!!!!!!!!!!!!!
     *
     * Inner classes bellow were taken from BasicTextUI and rewritten in the place marked




 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.html.editor.gsf;

import java.awt.EventQueue;
import java.awt.event.KeyEvent;
import java.util.prefs.Preferences;
import java.util.regex.Pattern;
import javax.swing.JEditorPane;
import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.PlainDocument;
import junit.framework.TestCase;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.html.lexer.HTMLTokenId;
import org.netbeans.api.lexer.Language;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.csl.editor.TypingCompletion;
import org.netbeans.modules.html.editor.api.HtmlKit;
import org.openide.awt.AcceleratorBinding;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.MIMEResolver;
import org.openide.util.lookup.ServiceProvider;


/**
 * Test java brackets completion - unlike the original test this one
 * emulates real typing and tests the resulting state of the document.
 *
 * @autor Miloslav Metelka
 */
public class TypingCompletionUnitTest extends NbTestCase {


    @Override
    protected void setUp() throws Exception {
        super.setUp();
        Preferences prefs = MimeLookup.getLookup(HtmlKit.HTML_MIME_TYPE).lookup(Preferences.class);
        prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, true);
        Class.forName(AcceleratorBinding.class.getName(), true, AcceleratorBinding.class.getClassLoader());
    }

    // ------- Tests for completion of right parenthesis ')' -------------

    public void testQuoteCompletion() {
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<div t=|"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "<div t=\"|\""
        );
    }

    public void testTypeSecondSemicolonInForLoop() { // #146139
        Context ctx = new Context(new JavaKit(),
                "for (int i = 0; i <= 0|)"
        );
        ctx.typeChar(';');
        ctx.assertDocumentTextEquals(
                "for (int i = 0; i <= 0;|)"
        );
    }

    public void testTypeSemicolonInArgs() { // #146139
        Context ctx = new Context(new JavaKit(),
                "m(|)"
        );
        ctx.typeChar(';');
        ctx.assertDocumentTextEquals(
                "m();|"
        );
    }
    
    public void testTypingQuote() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "\"|"
        );
        ctx.typeChar(';');
        ctx.assertDocumentTextEquals(
                "m();| "
        );
    }

    public void testTypeRightParenWithinBraces() { // #146139
        Context ctx = new Context(new JavaKit(),
                "{(()|; }"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "{(()); }"
        );
    }
    
    public void testTypeLeftParen() {
        Context ctx = new Context(new JavaKit(), "m|");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("m(|)");
    }

    public void testTypeSecondRightParen() {
        Context ctx = new Context(new JavaKit(),
                "m()|)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "m())|"
        );
    }

    public void testTypeRightParenSwingInvokeLaterRunnable() {
        Context ctx = new Context(new JavaKit(),
                "SwingUtilities.invokeLater(new Runnable()|))"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "SwingUtilities.invokeLater(new Runnable())|)"
        );
    }

    public void testTypeSimpleAdditionOfOpeningParenthesisAfterWhile () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "while |"
        );
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals(
                "while (|)"
        );
    }

    public void testTypeRightParenSwingInvokeLaterRunnableRun() {
        Context ctx = new Context(new JavaKit(),
                "SwingUtilities.invokeLater(new Runnable() {\n" +
                "    public void run()|)\n" +
                "})"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "SwingUtilities.invokeLater(new Runnable() {\n" +
                "    public void run())|\n" +
                "})"
        );
    }

    public void testTypeRightParenIfMethodCall() {
        Context ctx = new Context(new JavaKit(),
                "if (a()|) + 5 > 6) {\n" +
                "}"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a())| + 5 > 6) {\n" +
                "}"
        );
    }

    public void testTypeRightParenNoSkipNonBracketChar() {
        Context ctx = new Context(new JavaKit(),
                "m()|"
        );
        ctx.typeChar(' ');
        ctx.assertDocumentTextEquals(
                "m() |"
        );
    }



    // ------- Tests for completion of right brace '}' -------------

    public void testTypeAddRightBraceIfLeftBrace() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceWhiteSpace() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { \t|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { \t\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceLineComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { // line-comment|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { // line-comment\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceBlockComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* block-comment */|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* block-comment */\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceAlreadyPresent() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {|\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void XtestTypeAddRightBraceCaretInComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* unclosed-block-comment|\n" +
                "          */\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* unclosed-block-comment\n" +
                "                     * |\n" +
                "          */\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceMultiLine() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {| System.out.println(\n" +
                "        \"\");\n" +
                "    }\n" +
                "}\n"
                );

        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            System.out.println(\n" +
                "        \"\");\n" +
                "    }\n" +
                "}\n"
                );
    }

    public void testTypeAddRightBraceSingleLine() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {| System.out.println(\"\");\n" +
                "    }\n" +
                "}\n"
                );

        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            System.out.println(\"\");\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
                );
    }


    // ------- Tests for completion of quote (") -------------
    public void testTypeSimpleQuoteInEmptyDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"|\""
        );
    }

    public void testTypeSimpleQuoteAtBeginingOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|  "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"|\"  "
        );
    }

    public void testTypeSimpleQuoteAtEndOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\""
        );
    }

    public void testTypeSimpleQuoteInWhiteSpaceArea () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |  "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\"  "
        );
    }

    public void testTypeQuoteAtEOL () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |\n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\"\n"
        );
    }

    public void testTypeQuoteWithUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"unterminated string| \n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"unterminated string\"| \n"
        );
    }

    public void testTypeQuoteAtEOLWithUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"unterminated string | \n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"unterminated string \"| \n"
        );
    }

    public void testTypeQuoteInsideStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"stri|ng literal\" "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"stri\"|ng literal\" "
        );
    }

    public void testTypeQuoteInsideEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|\") "
        );
    }

    public void testTypeQuoteInsideNonEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|some text) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|some text) "
        );
    }

    public void testTypeQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(i+|) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(i+\"|\") "
        );
    }

    public void testTypeQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(\"unterminated string literal |); "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"unterminated string literal \"|); "
        );
    }

    public void testTypeQuoteBeforePlus () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|+\"string literal\"); "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|\"+\"string literal\"); "
        );
    }

    public void testTypeQuoteBeforeComma () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{|,\"two\"};"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"|\",\"two\"};"
        );
    }

    public void testTypeQuoteBeforeBrace () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{\"one\",|};"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"one\",\"|\"};"
        );
    }

    public void testTypeQuoteBeforeSemicolon() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" + |;"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s = \"\" + \"|\";"
        );
    }

    public void testTypeQuoteBeforeSemicolonWithWhitespace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" +| ;"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s = \"\" +\"|\" ;"
        );
    }

    public void testTypeQuoteAfterEscapeSequence() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\\|"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\\\"|"
        );
    }

    public void testTypeQuoteEaten() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('"');
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"\"|"
        );
    }
    
    public void testBackSlash() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html |"
        );
        ctx.typeChar('/');
        ctx.assertDocumentTextEquals(
                "<html />|"
        );
    }
    
    public void testChangeQuote() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html t=\"|\""
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "<html t='|'"
        );
    }
    
    public void testJumpingQuote() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html t=\"|\""
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "<html t=\"\"|"
        );
    }

    public void testTypeQuoteInsideComments() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "/** |\n */"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "/** \"|\n */"
        );
    }

    public void testTypeQuoteAtTheEndOfLineCommentLine() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "// test line comment |\n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "// test line comment \"|\n"
        );
    }


    // ------- Tests for completion of single quote (') -------------

    public void testTypeSingleQuoteInEmptyDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "'|'"
        );
    }

    public void testTypeSingleQuoteAtBeginingOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|  "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "'|'  "
        );
    }

    public void testTypeSingleQuoteAtEndOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'"
        );
    }

    public void testTypeSingleQuoteInWhiteSpaceArea () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |  "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'  "
        );
    }

    public void testTypeSingleQuoteAtEOL () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'\n"
        );
    }

    public void testTypeSingleQuoteWithUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  '| \n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ''| \n"
        );
    }

    public void testTypeSingleQuoteAtEOLWithUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  ' |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ' '|\n"
        );
    }

    public void testTypeSingleQuoteInsideCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  '| ' "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ''| ' "
        );
    }

    public void testTypeSingleQuoteInsideEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|') "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|some text) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|some text) "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(i+|) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println(i+'|') "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(' |); "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println(' '|); "
        );
    }

    public void testTypeSingleQuoteBeforePlus () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|+\"string literal\"); "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|'+\"string literal\"); "
        );
    }

    public void testTypeSingleQuoteBeforeComma () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{|,\"two\"};"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{'|',\"two\"};"
        );
    }

    public void testTypeSingleQuoteBeforeBrace () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{\"one\",|};"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"one\",'|'};"
        );
    }

    public void testTypeSingleQuoteBeforeSemicolon() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" + |;"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s = \"\" + '|';"
        );
    }

    public void testTypeSingleQuoteBeforeSemicolonWithWhitespace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" +| ;"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s = \"\" +'|' ;"
        );
    }

    public void testTypeSingleQuoteAfterEscapeSequence() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\\|"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "\\'|"
        );
    }

    public void testTypeSingleQuoteEaten() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('\'');
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "''|"
        );
    }

    public void testTypeSingleQuoteInsideComments() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "/* |\n */"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "/* \'|\n */"
        );
    }

    public void testTypeSingleQuoteAtTheEndOfLineCommentLine() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "// test line comment |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "// test line comment \'|\n"
        );
    }

    public void testDisable147641() throws Exception {
        boolean orig = TypingCompletion.isCompletionSettingEnabled();
        Preferences prefs = MimeLookup.getLookup(JavaKit.JAVA_MIME_TYPE).lookup(Preferences.class);

        try {
            prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, false);

            Context ctx = new Context(new JavaKit(),
                    "while |"
            );
            ctx.typeChar('(');
            ctx.assertDocumentTextEquals(
                    "while (|"
            );
        } finally {
            prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, orig);
        }
    }

    public void testDoNotSkipWhenNotBalanced147683a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "System.err.println((true|);"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "System.err.println((true)|);"
        );
    }

    public void testSkipWhenBalanced46517() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()| )"
        );
    }

    public void testDoNotSkipWhenNotBalanced147683b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) ; )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()|) ; )"
        );
    }

    public void testDoNotSkipWhenNotBalanced147683c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) \n )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()|) \n )"
        );
    }
//problem
    public void testSkipWhenBalanced198194a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(|); i < 10; i++)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a()|; i < 10; i++)"
        );
    }

    public void testSkipWhenNotBalanced198194a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(|; i < 10; i++)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a()|; i < 10; i++)"
        );
    }

    public void testSkipWhenBalanced198194b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i = a(|))"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i = a()|)"
        );
    }

    public void testSkipWhenNotBalanced198194b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i = a(|)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i = a()|)"
        );
    }

    public void testSkipWhenNotBalanced198194c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i++) a(|;"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i++) a()|;"
        );
    }

    public void testSkipWhenBalanced198194c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i++) a(|);"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i++) a()|;"
        );
    }

    public void testKeepBalance148878() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "Map[|] m = new HashMap[1];"
        );
        ctx.typeChar(']');
        ctx.assertDocumentTextEquals(
                "Map[]| m = new HashMap[1];"
        );
    }
    
    public void testCurlyBrace() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html><style type=\"text/css\">body|"
        );
        ctx.typeChar('{');
        ctx.assertDocumentTextEquals(
                "<html><style type=\"text/css\">body{|}"
        );
    }
   
    public void testPositionInString() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        \"H|\"\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        \"H\"\n"
                + "        + \"|\"\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testNewLineInCurlyBrace() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html><style type=\"text/css\">body{|}"
                + "    {\n"
                + "        \"|\"\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        \"\"\n"
                + "        + \"|\"\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testCommentBlockCompletion() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /*|\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /*\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
   
    public void testCommentBlockCompletionNotNeeded() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /*|\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /*\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
    

    public void testCommentBlockCompletionTwoComments () {
        Context ctx = new Context(new JavaKit(),
                "/*|\n" +
                "/*\n" +
                " */"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "<html><style type=\"text/css\">body{\n            |\n        }"
                " * |\n" +
                " */\n" +
                "/*\n" +
                " */"
        );
    }

    public void testCommentBlockCompletionTwoComments2 () {
        Context ctx = new Context(new JavaKit(),
                "/*|\n" +
                "\n" +
                "/*\n" +
                " */"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "/*\n" +
                " * |\n" +
                " */\n" +
                "\n" +
                "/*\n" +
                " */"
        );
    }
    
    public void testDeleteCurlyBrace() { 
        TypingCompletion.Context ctx = new TypingCompletion.Context(new HtmlKit(), HTMLTokenId.language(), HtmlKit.HTML_MIME_TYPE,
                "<html><style type=\"text/css\">body|"
        );
        ctx.typeChar('{');
        ctx.assertDocumentTextEquals(
                "<html><style type=\"text/css\">body{|}"
        );
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals(
                "<html><style type=\"text/css\">body|"
        );
    }
    
    public void testJavaDocCompletion() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testJavaDocCompletionNotNeeded() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
  
    public void insertBreakJavadocComplete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "        public static void main(String[] args) {\n"
                + "        }\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals (
            "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         * @param args\n"
                + "         */\n"
                + "        public static void main(String[] args) {\n"
                + "        }\n"
                + "    }\n"
                + "}\n"
        );
    }
    
    public void testRemoveBracketBackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "()(|)");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("()|");
    }

    public void testRemoveBracketDelete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "()|()");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("()|");
    }
    
    public void testRemoveQuotesBackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\"\"\"|\"");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testRemoveQuotesDelete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\"\"|\"\"");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testRemoveQuotes2BackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\'\'\'|\'");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("\'\'|");
    }
    
    public void testRemoveQuotes2Delete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\'\'|\'\'");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("\'\'|");
    }
    
    public void testJumpCharacters() throws Exception {
        Context ctx = new Context(new JavaKit(), "m(\"p|\");");
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals("m(\"p\"|);");
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals("m(\"p\")|;");
    }
    
    public void testJumpQuote() throws Exception {
        Context ctx = new Context(new JavaKit(), "\"|\"");
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testInsertSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "|");
        ctx.typeChar('[');
        ctx.assertDocumentTextEquals("[|]");
    }

    public void testBackspaceSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "[|]");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("|");
    }
    
    public void testDeleteSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "|[]");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("|");
    }
    
    public void testInsertBracketInString() throws Exception {
        Context ctx = new Context(new JavaKit(), "\"|\"");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("\"(|\"");
        ctx = new Context(new JavaKit(), "\" |\"");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("\" (|\"");
    }
    
    public void testInsertBracketInComment() throws Exception {
        Context ctx = new Context(new JavaKit(), "//|");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("//(|");
    }
    
    public void testSkipBracketInComment() throws Exception {
        Context ctx = new Context(new JavaKit(), "//(|)");
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals("//()|)");
    }
     
    public void testCorrectHandlingOfStringEscapes184059() throws Exception {
        assertTrue(isInsideString("foo\n\"bar|\""));
        assertTrue(isInsideString("foo\n\"bar\\\"|\""));
        assertFalse(isInsideString("foo\n\"bar\\\\\"|"));
        assertFalse(isInsideString("foo\n|\"bar\\\\\""));
        assertTrue(isInsideString("foo\n\"|bar\\\\\""));
    }

    private boolean isInsideString(String code) throws BadLocationException {
        int pos = code.indexOf('|');

        assertNotSame(-1, pos);

        code = code.replaceAll(Pattern.quote("|"), "");

        Document doc = new PlainDocument();

        doc.putProperty(Language.class, JavaTokenId.language());
        doc.insertString(0, code, null);

        return TypingCompletion.posWithinString(doc, pos);
    }

    private static final class Context {
        
        private JEditorPane pane;

        public Context(final EditorKit kit, final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        pane = new JEditorPane();
                        pane.setEditorKit(kit);
                        Document doc = pane.getDocument();
                        // Required by Java's default key typed
                        doc.putProperty(Language.class, JavaTokenId.language());
                        doc.putProperty("mimeType", "text/x-java");
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        pane.setText(text);
                        pane.setCaretPosition((caretOffset != -1) ? caretOffset : doc.getLength());
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
        
        public JEditorPane pane() {
            return pane;
        }

        public Document document() {
            return pane.getDocument();
        }
        
        public void typeChar(final char ch) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        KeyEvent keyEvent;
                        switch (ch) {
                            case '\n':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_ENTER, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Enter
                                break;
                            case '\b':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_BACK_SPACE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of BackSpace
                                break;
                            case '\f':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Delete
                                break;
                            default:
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_TYPED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_UNDEFINED, ch);
                        }
                        SwingUtilities.processKeyBindings(keyEvent);
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }

        public void typeText(String text) {
            for (int i = 0; i < text.length(); i++) {
                typeChar(text.charAt(i));
            }
        }

        public void assertDocumentTextEquals(final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        try {
                            // Use debug text to prefix special chars for easier readability
                            text = CharSequenceUtilities.debugText(text);
                            String docText = document().getText(0, document().getLength());
                            docText = CharSequenceUtilities.debugText(docText);
                            if (!text.equals(docText)) {
                                int diffIndex = 0;
                                int minLen = Math.min(docText.length(), text.length());
                                while (diffIndex < minLen) {
                                    if (text.charAt(diffIndex) != docText.charAt(diffIndex)) {
                                        break;
                                    }
                                    diffIndex++;
                                }
                                TestCase.fail("Invalid document text - diff at index " + diffIndex +
                                        "\nExpected: \"" + text +
                                        "\"\n  Actual: \"" + docText + "\""
                                );
                            }
                        } catch (BadLocationException e) {
                            throw new IllegalStateException(e);
                        }
                        if (caretOffset != -1) {
                            TestCase.assertEquals("Invalid caret offset", caretOffset, pane.getCaretPosition());
                        }
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
    }

    @ServiceProvider(service=MIMEResolver.class)
    public static final class MIMEResolverImpl extends MIMEResolver {

        public MIMEResolverImpl() {
            super("text/x-nbeditor-keybindingsettings");
        }

        @Override public String findMIMEType(FileObject fo) {
            return fo.getPath().contains("Keybindings") ? "text/x-nbeditor-keybindingsettings" : null;
        }
    }

}

Lines 42-48 Link Here

(-)a/java.editor/nbproject/project.properties (-1 / +1 lines)
42		42
43	javadoc.title=Java Editor	43	javadoc.title=Java Editor
44		44
45	spec.version.base=2.47.0	45	spec.version.base=2.48.0
46	test.qa-functional.cp.extra=${editor.dir}/modules/org-netbeans-modules-editor-fold.jar	46	test.qa-functional.cp.extra=${editor.dir}/modules/org-netbeans-modules-editor-fold.jar
47	javac.source=1.6	47	javac.source=1.6
48	#test.unit.cp.extra=	48	#test.unit.cp.extra=




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */
package org.netbeans.modules.editor.java;

import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.prefs.Preferences;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.java.lexer.JavaTokenId;
import org.netbeans.api.lexer.PartType;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenHierarchy;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Utilities;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.modules.editor.indent.api.Indent;
import org.openide.util.Exceptions;

/**
 * This static class groups the whole aspect of bracket
 * completion. It is defined to clearly separate the functionality
 * and keep actions clean. 
 * The methods of the class are called from different actions as
 * KeyTyped, DeletePreviousChar.
 * <br/>
 * This class is similar to old BracketCompletion but works solely
 * with the token hierarchy.
 */
class BraceCompletion {

    /**
     * A hook method called after a character was inserted into the
     * document. The function checks for special characters for
     * completion ()[]'"{} and other conditions and optionally performs
     * changes to the doc and or caret (complets braces, moves caret,
     * etc.)
     * @param doc the document where the change occurred
     * @param caretOffset position of the character that was inserted.
     * @param caret caret
     * @param ch the character that was inserted
     * @throws BadLocationException if caretOffset is not correct
     */
    static void charInserted(BaseDocument doc, int caretOffset, Caret caret, char ch) throws BadLocationException {
        if (!completionSettingEnabled()) {
          return;
        }

        if (ch == ')' || ch == ']' || ch == '(' || ch == '[' || ch == ';') {
            TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, caretOffset, false);
            if (javaTS != null) {
                switch (javaTS.token().id()) {
                    case RPAREN:
                    case RBRACKET:
                        skipClosingBracket(doc, caret, ch, javaTS);
                        break;
                    case LPAREN:
                    case LBRACKET:
                        completeOpeningBracket(doc, caretOffset, caret, ch, javaTS);
                        break;
                    case SEMICOLON:
                        moveSemicolon(doc, caretOffset, caret, javaTS);
                }
            }
        }
    }

    private static void moveSemicolon(BaseDocument doc, int caretOffset, Caret caret,
    TokenSequence<JavaTokenId> ts) throws BadLocationException {
        int eolOffset = Utilities.getRowEnd(doc, caretOffset);
        int lastParenPos = caretOffset;
        int index = ts.index();
        // Move beyond semicolon
        while (ts.moveNext() && ts.offset() <= eolOffset) {
            Token<JavaTokenId> token = ts.token();
            switch (token.id()) {
                case RPAREN:
                    lastParenPos = ts.offset();
                    break;
                case WHITESPACE:
                    break;
                default:
                    return; //
            }
        }
        // Restore ts position
        ts.moveIndex(index);
        ts.moveNext();
        if (isForLoopSemicolon(ts) || posWithinAnyQuote(doc, caretOffset)) {
            return;
        }
        doc.remove(caretOffset, 1);
        doc.insertString(lastParenPos, ";", null); // NOI18N
        caret.setDot(lastParenPos + 1);
    }

    private static boolean isForLoopSemicolon(TokenSequence<JavaTokenId> ts) {
        Token<JavaTokenId> token = ts.token();
        if (token == null || token.id() != JavaTokenId.SEMICOLON) {
            return false;
        }
        int parenDepth = 0; // parenthesis depth
        int braceDepth = 0; // brace depth
        boolean semicolonFound = false; // next semicolon
        int tsOrigIndex = ts.index();
        try {
            while (ts.movePrevious()) {
                token = ts.token();
                switch (token.id()) {
                    case LPAREN:
                        if (parenDepth == 0) { // could be a 'for ('
                            while (ts.movePrevious()) {
                                token = ts.token();
                                switch (token.id()) {
                                    case WHITESPACE:
                                    case BLOCK_COMMENT:
                                    case JAVADOC_COMMENT:
                                    case LINE_COMMENT:
                                        break; // skip
                                    case FOR:
                                        return true;
                                    default:
                                        return false;
                                }
                            }
                            return false;
                        } else { // non-zero depth
                            parenDepth--;
                        }
                        break;

                    case RPAREN:
                        parenDepth++;
                        break;

                    case LBRACE:
                        if (braceDepth == 0) { // unclosed left brace
                            return false;
                        }
                        braceDepth--;
                        break;

                    case RBRACE:
                        braceDepth++;
                        break;

                    case SEMICOLON:
                        if (semicolonFound) { // one semicolon already found
                            return false;
                        }
                        semicolonFound = true;
                        break;
                }
            }
        } finally {
            // Restore orig TS's location
            ts.moveIndex(tsOrigIndex);
            ts.moveNext();
        }
        return false;
    }

    /**
     * Hook called after a character *ch* was backspace-deleted from
     * *doc*. The function possibly removes bracket or quote pair if
     * appropriate.
     * @param doc the document
     * @param caretOffset position of the change
     * @param caret caret
     * @param ch the character that was deleted
     */
    static void charBackspaced(BaseDocument doc, int caretOffset, Caret caret, char ch) throws BadLocationException {
        if (!completionSettingEnabled()) {
            return;
        }
        // Get token (forward bias) behind removed char
        TokenSequence<JavaTokenId> ts = javaTokenSequence(doc, caretOffset, false);
        if (ts == null) {
            return;
        }
        if (ch == '(' || ch == '[') {
            switch (ts.token().id()) {
                case RPAREN:
                    if (tokenBalance(doc, JavaTokenId.LPAREN) != 0) {
                        doc.remove(caretOffset, 1);
                    }
                    break;
                case RBRACKET:
                    if (tokenBalance(doc, JavaTokenId.LBRACKET) != 0) {
                        doc.remove(caretOffset, 1);
                    }
                    break;
            }
        } else if (ch == '\"') {
            if (ts.token().id() == JavaTokenId.STRING_LITERAL && ts.offset() == caretOffset) {
                doc.remove(caretOffset, 1);
            }
        } else if (ch == '\'') {
            if (ts.token().id() == JavaTokenId.CHAR_LITERAL && ts.offset() == caretOffset) {
                doc.remove(caretOffset, 1);
            }
        }
    }

    static int tokenBalance(BaseDocument doc, JavaTokenId leftTokenId) {
        TokenBalance tb = TokenBalance.get(doc);
        if (!tb.isTracked(JavaTokenId.language())) {
            tb.addTokenPair(JavaTokenId.language(), JavaTokenId.LPAREN, JavaTokenId.RPAREN);
            tb.addTokenPair(JavaTokenId.language(), JavaTokenId.LBRACKET, JavaTokenId.RBRACKET);
            tb.addTokenPair(JavaTokenId.language(), JavaTokenId.LBRACE, JavaTokenId.RBRACE);
        }
        int balance = tb.balance(JavaTokenId.language(), leftTokenId);
        assert (balance != Integer.MAX_VALUE);
        return balance;
    }
    /**
     * Resolve whether pairing right curly should be added automatically
     * at the caret position or not.
     * <br>
     * There must be only whitespace or line comment or block comment
     * between the caret position
     * and the left brace and the left brace must be on the same line
     * where the caret is located.
     * <br>
     * The caret must not be "contained" in the opened block comment token.
     *
     * @param doc document in which to operate.
     * @param caretOffset offset of the caret.
     * @return true if a right brace '}' should be added
     *  or false if not.
     */
    static boolean isAddRightBrace(BaseDocument doc, int caretOffset)
            throws BadLocationException
    {
        if (!completionSettingEnabled()) {
            return false;
        }
        if (tokenBalance(doc, JavaTokenId.LBRACE) <= 0) {
            return false;
        }
        int caretRowStartOffset = Utilities.getRowStart(doc, caretOffset);
        TokenSequence<JavaTokenId> ts = javaTokenSequence(doc, caretOffset, true);
        if (ts == null) {
            return false;
        }
        boolean first = true;
        do {
            if (ts.offset() < caretRowStartOffset) {
                return false;
            }
            switch (ts.token().id()) {
                case WHITESPACE:
                case LINE_COMMENT:
                    break;
                case BLOCK_COMMENT:
                case JAVADOC_COMMENT:
                    if (first && caretOffset > ts.offset() && caretOffset < ts.offset() + ts.token().length()) {
                        // Caret contained within block comment -> do not add anything
                        return false;
                    }
                    break; // Skip
                case LBRACE:
                    return true;
            }
            first = false;
        } while (ts.movePrevious());
        return false;
    }

    /**
     * Returns position of the first unpaired closing paren/brace/bracket from the caretOffset
     * till the end of caret row. If there is no such element, position after the last non-white
     * character on the caret row is returned.
     */
    static int getRowOrBlockEnd(BaseDocument doc, int caretOffset, boolean[] insert) throws BadLocationException {
        int rowEnd = Utilities.getRowLastNonWhite(doc, caretOffset);
        if (rowEnd == -1 || caretOffset >= rowEnd) {
            return caretOffset;
        }
        rowEnd += 1;
        int parenBalance = 0;
        int braceBalance = 0;
        int bracketBalance = 0;
        TokenSequence<JavaTokenId> ts = javaTokenSequence(doc, caretOffset, false);
        if (ts == null) {
            return caretOffset;
        }
        while (ts.offset() < rowEnd) {
            switch (ts.token().id()) {
                case SEMICOLON:
                    return ts.offset() + 1;
                case LPAREN:
                    parenBalance++;
                    break;
                case RPAREN:
                    if (parenBalance-- == 0) {
                        return ts.offset();
                    }
                    break;
                case LBRACE:
                    braceBalance++;
                    break;
                case RBRACE:
                    if (braceBalance-- == 0) {
                        return ts.offset();
                    }
                    break;
                case LBRACKET:
                    bracketBalance++;
                    break;
                case RBRACKET:
                    if (bracketBalance-- == 0) {
                        return ts.offset();
                    }
                    break;
            }
            if (!ts.moveNext())
                break;
        }

        insert[0] = false;
        return rowEnd;
    }

    /**
     * Get token sequence positioned over a token.
     *
     * @param doc
     * @param offset
     * @param backwardBias
     * @return token sequence positioned over a token that "contains" the offset
     *  or null if the document does not contain any java token sequence
     *  or the offset is at doc-or-section-start-and-bwd-bias
     *  or doc-or-section-end-and-fwd-bias.
     */
    private static TokenSequence<JavaTokenId> javaTokenSequence(Document doc, int offset, boolean backwardBias) {
        TokenHierarchy<?> hi = TokenHierarchy.get(doc);
        List<TokenSequence<?>> tsList = hi.embeddedTokenSequences(offset, backwardBias);
        // Go from inner to outer TSes
        for (int i = tsList.size() - 1; i >= 0; i--) {
            TokenSequence<?> ts = tsList.get(i);
            if (ts.languagePath().innerLanguage() == JavaTokenId.language()) {
                TokenSequence<JavaTokenId> javaInnerTS = (TokenSequence<JavaTokenId>) ts;
                return javaInnerTS;
            }
        }
        return null;
    }

    /** 
     * Counts the number of braces starting at caretOffset to the end of the
     * document. Every occurence of { increses the count by 1, every
     * occurrence of } decreses the count by 1. The result is returned.
     * @return The number of { - number of } (>0 more { than } ,<0 more } than {)
     */
    private static int braceBalance(BaseDocument doc)
            throws BadLocationException {
        return tokenBalance(doc, JavaTokenId.LBRACE);
    }

    /**
     * A hook to be called after closing bracket ) or ] was inserted into
     * the document. The method checks if the bracket should stay there
     * or be removed and some exisitng bracket just skipped.
     *
     * @param doc the document
     * @param caretOffset position of the inserted bracket
     * @param caret caret
     * @param bracket the bracket character ']' or ')'
     */
    private static void skipClosingBracket(BaseDocument doc, Caret caret, char rightBracketChar,
            TokenSequence<JavaTokenId> innerTS) throws BadLocationException
    {
        JavaTokenId bracketId = bracketCharToId(rightBracketChar);
        int caretOffset = caret.getDot();
        if (isSkipClosingBracket(doc, caretOffset, bracketId)) {
            doc.remove(caretOffset - 1, 1);
            caret.setDot(caretOffset); // skip closing bracket
        }
    }

    private static Set<JavaTokenId> STOP_TOKENS_FOR_SKIP_CLOSING_BRACKET = EnumSet.of(JavaTokenId.LBRACE, JavaTokenId.RBRACE, JavaTokenId.SEMICOLON);
    
    /**
     * Check whether the typed bracket should stay in the document
     * or be removed.
     * <br>
     * This method is called by <code>skipClosingBracket()</code>.
     *
     * @param doc document into which typing was done.
     * @param caretOffset
     */
    static boolean isSkipClosingBracket(BaseDocument doc, int caretOffset, JavaTokenId rightBracketId) throws BadLocationException {
        // First check whether the caret is not after the last char in the document
        // because no bracket would follow then so it could not be skipped.
        if (caretOffset == doc.getLength()) {
            return false; // no skip in this case
        }
        boolean skipClosingBracket = false; // by default do not remove
        // Examine token at the caret offset
        TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, caretOffset, false);
        if (javaTS != null && javaTS.token().id() == rightBracketId) {
            JavaTokenId leftBracketId = matching(rightBracketId);
            // Skip all the brackets of the same type that follow the last one
            do {
                if (   STOP_TOKENS_FOR_SKIP_CLOSING_BRACKET.contains(javaTS.token().id())
                    || (javaTS.token().id() == JavaTokenId.WHITESPACE && javaTS.token().text().toString().contains("\n"))) {
                    while (javaTS.token().id() != rightBracketId && javaTS.movePrevious())
                        ;
                    break;
                }
            } while (javaTS.moveNext());
            // token var points to the last bracket in a group of two or more right brackets
            // Attempt to find the left matching bracket for it
            // Search would stop on an extra opening left brace if found
            int braceBalance = 0; // balance of '{' and '}'
            int bracketBalance = -1; // balance of the brackets or parenthesis
            int numOfSemi = 0;
            boolean finished = false;
            while (!finished && javaTS.movePrevious()) {
                JavaTokenId id = javaTS.token().id();
                switch (id) {
                    case LPAREN:
                    case LBRACKET:
                        if (id == leftBracketId) {
                            bracketBalance++;
                            if (bracketBalance == 0) {
                                if (braceBalance != 0) {
                                    // Here the bracket is matched but it is located
                                    // inside an unclosed brace block
                                    // e.g. ... ->( } a()|)
                                    // which is in fact illegal but it's a question
                                    // of what's best to do in this case.
                                    // We chose to leave the typed bracket
                                    // by setting bracketBalance to 1.
                                    // It can be revised in the future.
                                    bracketBalance = 1;
                                }
                                finished = javaTS.offset() < caretOffset;
                            }
                        }
                        break;

                    case RPAREN:
                    case RBRACKET:
                        if (id == rightBracketId) {
                            bracketBalance--;
                        }
                        break;

                    case LBRACE:
                        braceBalance++;
                        if (braceBalance > 0) { // stop on extra left brace
                            finished = true;
                        }
                        break;

                    case RBRACE:
                        braceBalance--;
                        break;
                        
                    case SEMICOLON:
                        numOfSemi++;
                        break;
                }
            }

            if (bracketBalance == 0 && numOfSemi < 2) {
                finished = false;
                while (!finished && javaTS.movePrevious()) {
                    switch (javaTS.token().id()) {
                        case WHITESPACE:
                        case LINE_COMMENT:
                        case BLOCK_COMMENT:
                        case JAVADOC_COMMENT:
                            break;
                        case FOR:
                            bracketBalance--;
                        default:
                            finished = true;
                            break;
                    }
                }
            }
            
            skipClosingBracket = bracketBalance != 0;

            //commented out due to #147683:
//            if (bracketBalance != 0) { // not found matching bracket
//                // Remove the typed bracket as it's unmatched
//                skipClosingBracket = true;
//
//            } else { // the bracket is matched
//                // Now check whether the bracket would be matched
//                // when the closing bracket would be removed
//                // i.e. starting from the original lastRBracketIndex token
//                // and search for the same bracket to the right in the text
//                // The search would stop on an extra right brace if found
//                braceBalance = 0;
//                bracketBalance = 1; // simulate one extra left bracket
//                finished = false;
//                // Relocate behind original rbracket and one token to right
//                if (lastRBracketIndex + 2 <= javaTS.tokenCount()) {
//                    javaTS.moveIndex(lastRBracketIndex + 2);
//                } else { // mark as finished
//                    finished = true;
//                }
//                while (!finished && javaTS.movePrevious()) {
//                    JavaTokenId id = javaTS.token().id();
//                    switch (id) {
//                        case LPAREN:
//                        case LBRACKET:
//                            if (id == leftBracketId) {
//                                bracketBalance++;
//                            }
//                            break;
//
//                        case RPAREN:
//                        case RBRACKET:
//                            if (id == rightBracketId) {
//                                bracketBalance--;
//                                if (bracketBalance == 0) {
//                                    if (braceBalance != 0) {
//                                        // Here the bracket is matched but it is located
//                                        // inside an unclosed brace block
//                                        // which is in fact illegal but it's a question
//                                        // of what's best to do in this case.
//                                        // We chose to leave the typed bracket
//                                        // by setting bracketBalance to -1.
//                                        // It can be revised in the future.
//                                        bracketBalance = -1;
//                                    }
//                                    finished = true;
//                                }
//                            }
//                            break;
//
//                        case LBRACE:
//                            braceBalance++;
//                            break;
//
//                        case RBRACE:
//                            braceBalance--;
//                            if (braceBalance < 0) { // stop on extra right brace
//                                finished = true;
//                            }
//                            break;
//                    }
//                }
//                // If bracketBalance == 0 the bracket would be matched
//                // by the bracket that follows the last right bracket.
//                skipClosingBracket = (bracketBalance == 0);
//            }
        }
        return skipClosingBracket;
    }

    /**
     * Check for various conditions and possibly add a pairing bracket.
     * to the already inserted.
     * @param doc the document
     * @param caretOffset position of the opening bracket (already in the doc)
     * @param caret caret
     * @param bracket the bracket that was inserted
     */
    private static void completeOpeningBracket(BaseDocument doc, int caretOffset, Caret caret, char bracketChar,
        TokenSequence<JavaTokenId> innerTS) throws BadLocationException
    {
        if (isCompletablePosition(doc, caretOffset + 1)) {
            doc.insertString(caretOffset + 1, String.valueOf(matching(bracketChar)), null);
            caret.setDot(caretOffset + 1);
        }
    }

    private static boolean isEscapeSequence(BaseDocument doc, int caretOffset) throws BadLocationException {
        if (caretOffset <= 0) {
            return false;
        }

        for (int i = 2; caretOffset - i >= 0; i += 2) {
            char[] previousChars = doc.getChars(caretOffset - i, 2);
            if (previousChars[1] != '\\')
                return false;
            if (previousChars[0] != '\\')
                return true;
        }

        char previousChar = doc.getChars(caretOffset - 1, 1)[0];
        return previousChar == '\\';
    }

    /** 
     * Called to decide whether either single bracket should be inserted
     * or whether bracket pair should be inserted instead.
     * It's called before anything was inserted into the document.
     *
     * @param doc the document
     * @param caretOffset position of the opening bracket (already in the doc)
     * @param caret caret
     * @param bracket the character that was inserted
     * @return true if the method serviced insertions or removals or false
     *  if there's nothing special to be done and the parent should handle the insertion regularly.
     */
    static boolean completeQuote(BaseDocument doc, int caretOffset, Caret caret, char bracket)
        throws BadLocationException
    {
        if (!completionSettingEnabled()) {
            return false;
        }
        if (isEscapeSequence(doc, caretOffset)) { // \" or \' typed
            return false;
        }
        // Examine token id at the caret offset
        TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, caretOffset, true);
        JavaTokenId id = (javaTS != null) ? javaTS.token().id() : null;
        int lastNonWhite = Utilities.getRowLastNonWhite(doc, caretOffset);
        // eol - true if the caret is at the end of line (ignoring whitespaces)
        boolean eol = lastNonWhite < caretOffset;

        // If caret within comment return false
        boolean caretInsideToken = (id != null) &&
                (javaTS.offset() + javaTS.token().length() > caretOffset ||
                 javaTS.token().partType() == PartType.START);
        if (caretInsideToken && (id == JavaTokenId.BLOCK_COMMENT ||
                id == JavaTokenId.JAVADOC_COMMENT ||
                id == JavaTokenId.LINE_COMMENT)
        ) {
            return false;
        }
        boolean completablePosition = isQuoteCompletablePosition(doc, caretOffset);
        boolean insideString = caretInsideToken &&
                (id == JavaTokenId.STRING_LITERAL ||
                 id == JavaTokenId.CHAR_LITERAL);
        if (insideString) {
            if (eol) {
                return false; // do not complete
            } else {
                //#69524
                char chr = doc.getChars(caretOffset, 1)[0];
                if (chr == bracket) {
                    //#83044
                    if (caretOffset > 0) {
                        javaTS.move(caretOffset - 1);
                        if (javaTS.moveNext()) {
                            id = javaTS.token().id();
                            if (id == JavaTokenId.STRING_LITERAL ||
                                id == JavaTokenId.CHAR_LITERAL)
                            {
                                doc.insertString(caretOffset, String.valueOf(bracket), null); //NOI18N
                                doc.remove(caretOffset, 1);
                                return true;
                            }
                        }
                    }
                //end of #83044
                }
            //end of #69524
            }
        }

        if ((completablePosition && !insideString) || eol) {
            doc.insertString(caretOffset, String.valueOf(bracket) + bracket, null); //NOI18N
            return true;
        }

        return false;
    }

    /** 
     * Checks whether caretOffset is a position at which bracket and quote
     * completion is performed. Brackets and quotes are not completed
     * everywhere but just at suitable places .
     * @param doc the document
     * @param caretOffset position to be tested
     */
    private static boolean isCompletablePosition(BaseDocument doc, int caretOffset)
            throws BadLocationException
    {
        if (caretOffset == doc.getLength()) // there's no other character to test
        {
            return true;
        } else {
            // test that we are in front of ) , " or '
            char chr = doc.getChars(caretOffset, 1)[0];
            return (chr == ')' ||
                    chr == ',' ||
                    chr == '\"' ||
                    chr == '\'' ||
                    chr == ' ' ||
                    chr == ']' ||
                    chr == '}' ||
                    chr == '\n' ||
                    chr == '\t' ||
                    chr == ';');
        }
    }

    private static boolean isQuoteCompletablePosition(BaseDocument doc, int caretOffset)
            throws BadLocationException
    {
        if (caretOffset == doc.getLength()) { // there's no other character to test
            return true;
        } else {
            // test that we are in front of ) , " or ' ... etc.
            int eolOffset = Utilities.getRowEnd(doc, caretOffset);
            if (caretOffset == eolOffset || eolOffset == -1) {
                return false;
            }
            int firstNonWhiteFwdOffset = Utilities.getFirstNonWhiteFwd(doc, caretOffset, eolOffset);
            if (firstNonWhiteFwdOffset == -1) {
                return false;
            }
            char chr = doc.getChars(firstNonWhiteFwdOffset, 1)[0];
            return (chr == ')' ||
                    chr == ',' ||
                    chr == '+' ||
                    chr == '}' ||
                    chr == ';');
        }
    }

    /** 
     * Returns true if bracket completion is enabled in options.
     */
    static boolean completionSettingEnabled() {
        Preferences prefs = MimeLookup.getLookup(JavaKit.JAVA_MIME_TYPE).lookup(Preferences.class);
        return prefs.getBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, false);
    }

    /**
     * Returns for an opening bracket or quote the appropriate closing
     * character.
     */
    private static char matching(char bracket) {
        switch (bracket) {
            case '(':
                return ')';
            case '[':
                return ']';
            case '\"':
                return '\"'; // NOI18N
            case '\'':
                return '\'';
            default:
                return ' ';
        }
    }

    private static JavaTokenId matching(JavaTokenId id) {
        switch (id) {
            case LPAREN:
                return JavaTokenId.RPAREN;
            case LBRACKET:
                return JavaTokenId.RBRACKET;
            case RPAREN:
                return JavaTokenId.LPAREN;
            case RBRACKET:
                return JavaTokenId.LBRACKET;
            default:
                return null;
        }
    }

    private static JavaTokenId bracketCharToId(char bracket) {
        switch (bracket) {
            case '(':
                return JavaTokenId.LPAREN;
            case ')':
                return JavaTokenId.RPAREN;
            case '[':
                return JavaTokenId.LBRACKET;
            case ']':
                return JavaTokenId.RBRACKET;
            case '{':
                return JavaTokenId.LBRACE;
            case '}':
                return JavaTokenId.RBRACE;
            default:
                throw new IllegalArgumentException("Not a bracket char '" + bracket + '\'');
        }
    }

    /**
     * posWithinString(doc, pos) iff position *pos* is within a string
     * literal in document doc.
     * @param doc the document
     * @param caretOffset position to be tested (before '\n' gets inserted into doc.
     */
    static boolean posWithinString(Document doc, int caretOffset) {
        return posWithinQuotes(doc, caretOffset, '"', JavaTokenId.STRING_LITERAL);
    }

    /**
     * Generalized posWithingString to any token and delimiting
     * character. It works for tokens are delimited by *quote* and
     * extend up to the other *quote* or whitespace in case of an
     * incomplete token.
     * @param doc the document
     * @param caretOffset position of typed quote
     */
    static boolean posWithinQuotes(Document doc, int caretOffset, char quote, JavaTokenId tokenId) {
        TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, caretOffset, false);
        if (javaTS != null) {
            if (javaTS.token().id() != tokenId) return false;
            if (caretOffset > javaTS.offset() && caretOffset < javaTS.offset() + javaTS.token().length()) return true;
            else return false;
        }
        return false;
    }

    static boolean posWithinAnyQuote(BaseDocument doc, int caretOffset) {
        TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, caretOffset - 1, false);
        if (javaTS != null) {
            JavaTokenId id = javaTS.token().id();
            if (id == JavaTokenId.STRING_LITERAL ||
                id == JavaTokenId.CHAR_LITERAL
            ) {
                char ch = DocumentUtilities.getText(doc).charAt(caretOffset - 1);
                return (caretOffset - javaTS.offset() == 1 || (ch != '"' && ch != '\''));
            }
        }
        return false;
    }

    static boolean isUnclosedStringAtLineEnd(BaseDocument doc, int caretOffset) {
        int lastNonWhiteOffset;
        try {
            lastNonWhiteOffset = Utilities.getRowLastNonWhite(doc, caretOffset);
        } catch (BadLocationException e) {
            return false;
        }
        TokenSequence<JavaTokenId> javaTS = javaTokenSequence(doc, lastNonWhiteOffset, true);
        if (javaTS != null) {
            return (javaTS.token().id() == JavaTokenId.STRING_LITERAL);
        }
        return false;
    }

    static boolean blockCommentCompletion(JTextComponent target, BaseDocument doc, final int dotPosition) {
        return blockCommentCompletionImpl(target, doc, dotPosition, false);
    }

    static boolean javadocBlockCompletion(JTextComponent target, BaseDocument doc, final int dotPosition) {
        return blockCommentCompletionImpl(target, doc, dotPosition, true);
    }

    private static boolean blockCommentCompletionImpl(JTextComponent target, BaseDocument doc, final int dotPosition, boolean javadoc) {
        try {
            TokenHierarchy<BaseDocument> tokens = TokenHierarchy.get(doc);
            TokenSequence ts = tokens.tokenSequence();
            if (ts == null) {
                return false;
            }
            ts.move(dotPosition);
            if (!((ts.moveNext() || ts.movePrevious()) && ts.token().id() == (javadoc ? JavaTokenId.JAVADOC_COMMENT : JavaTokenId.BLOCK_COMMENT))) {
                return false;
            }

            int jdoffset = dotPosition - (javadoc ? 3 : 2);
            if (jdoffset >= 0) {
                CharSequence content = org.netbeans.lib.editor.util.swing.DocumentUtilities.getText(doc);
                if (isOpenBlockComment(content, dotPosition - 1, javadoc) && !isClosedBlockComment(content, dotPosition) && isAtRowEnd(content, dotPosition)) {
                    // note that the formater will add one line of javadoc
                    doc.insertString(dotPosition, "*/", null); // NOI18N
                    Indent.get(doc).indentNewLine(dotPosition);
                    target.setCaretPosition(dotPosition);

                    return true;
                }
            }
        } catch (BadLocationException ex) {
            // ignore
            Exceptions.printStackTrace(ex);
        }
        return false;
    }

    private static boolean isOpenBlockComment(CharSequence content, int pos, boolean javadoc) {
        for (int i = pos; i >= 0; i--) {
            char c = content.charAt(i);
            if (c == '*' && (javadoc ? i - 2 >= 0 && content.charAt(i - 1) == '*' && content.charAt(i - 2) == '/' : i - 1 >= 0 && content.charAt(i - 1) == '/')) {
                // matched /*
                return true;
            } else if (c == '\n') {
                // no javadoc, matched start of line
                return false;
            } else if (c == '/' && i - 1 >= 0 && content.charAt(i - 1) == '*') {
                // matched javadoc enclosing tag
                return false;
            }
        }

        return false;
    }

    private static boolean isClosedBlockComment(CharSequence txt, int pos) {
        int length = txt.length();
        int quotation = 0;
        for (int i = pos; i < length; i++) {
            char c = txt.charAt(i);
            if (c == '*' && i < length - 1 && txt.charAt(i + 1) == '/') {
                if (quotation == 0 || i < length - 2) {
                    return true;
                }
                // guess it is not just part of some text constant
                boolean isClosed = true;
                for (int j = i + 2; j < length; j++) {
                    char cc = txt.charAt(j);
                    if (cc == '\n') {
                        break;
                    } else if (cc == '"' && j < length - 1 && txt.charAt(j + 1) != '\'') {
                        isClosed = false;
                        break;
                    }
                }

                if (isClosed) {
                    return true;
                }
            } else if (c == '/' && i < length - 1 && txt.charAt(i + 1) == '*') {
                // start of another comment block
                return false;
            } else if (c == '\n') {
                quotation = 0;
            } else if (c == '"' && i < length - 1 && txt.charAt(i + 1) != '\'') {
                quotation = ++quotation % 2;
            }
        }

        return false;
    }

    private static boolean isAtRowEnd(CharSequence txt, int pos) {
        int length = txt.length();
        for (int i = pos; i < length; i++) {
            char c = txt.charAt(i);
            if (c == '\n') {
                return true;
            }
            if (!Character.isWhitespace(c)) {
                return false;
            }
        }
        return true;
    }
}




        super.install(c);
        ClipboardHandler.install(c);
    }
    
    /**
     * @Deprecated This action is no longer used. It is reimplemented as JavaDefaultKeyTypedInterceptor.
     */
    @Deprecated
    public static class JavaDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {

        @Override
        protected void insertString(BaseDocument doc, int dotPos,
                                    Caret caret, String str,
                                    boolean overwrite) throws BadLocationException {
            char insertedChar = str.charAt(0);
            if (insertedChar == '\"' || insertedChar == '\''){
                boolean inserted = BraceCompletion.completeQuote(doc, dotPos, caret, insertedChar);
                if (inserted){
                    caret.setDot(dotPos+1);
                }else{
                    super.insertString(doc, dotPos, caret, str, overwrite);

                }
            } else {
                super.insertString(doc, dotPos, caret, str, overwrite);
                BraceCompletion.charInserted(doc, dotPos, caret, insertedChar);
            }
        }

        protected void replaceSelection(JTextComponent target,
                int dotPos,
                Caret caret,
                String str,
                boolean overwrite)
                throws BadLocationException {
            char insertedChar = str.charAt(0);
            Document doc = target.getDocument();
            if (insertedChar == '\"' || insertedChar == '\''){
                if (doc != null) {
                    try {
                        boolean inserted = false;
                        int p0 = Math.min(caret.getDot(), caret.getMark());
                        int p1 = Math.max(caret.getDot(), caret.getMark());
                        if (p0 != p1) {
                            doc.remove(p0, p1 - p0);
                        }
                        int caretPosition = caret.getDot();
                        if (doc instanceof BaseDocument){
                            inserted = BraceCompletion.completeQuote(
                                    (BaseDocument)doc,
                                    caretPosition,
                                    caret, insertedChar);
                        }
                        if (inserted){
                            caret.setDot(caretPosition+1);
                        } else {
                            if (str != null && str.length() > 0) {
                                doc.insertString(p0, str, null);
                            }
                        }
                    } catch (BadLocationException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                super.replaceSelection(target, dotPos, caret, str, overwrite);
                if (doc instanceof BaseDocument){
                    BraceCompletion.charInserted((BaseDocument)doc, caret.getDot()-1, caret, insertedChar);
                }
            }
        }
    }

    @EditorActionRegistration(name = generateGoToPopupAction, mimeType = JAVA_MIME_TYPE)
    public static class JavaGenerateGoToPopupAction extends NbGenerateGoToPopupAction {

            }
        }
    }
    
    /**
     * @Deprecated This action is no longer used. It is reimplemented as JavaTypedBreakInterceptor.
     */
    @Deprecated
    public static class JavaInsertBreakAction extends InsertBreakAction {

        static final long serialVersionUID = -1506173310438326380L;
        private boolean isJavadocTouched = false;

        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            try {
                super.actionPerformed(evt, target);
                Document doc = target.getDocument();
                if (isJavadocTouched && !org.netbeans.lib.editor.util.swing.DocumentUtilities.isWriteLocked(doc)) {
                    // XXX temporary solution until the editor will provide a SPI to plug. See issue #115739
                    // This must run outside the document lock
                    Lookup.Result<TextAction> res = MimeLookup.getLookup(MimePath.parse("text/x-javadoc")).lookupResult(TextAction.class);
                    ActionEvent newevt = new ActionEvent(target, ActionEvent.ACTION_PERFORMED, "fix-javadoc");
                    for (TextAction action : res.allInstances()) {
                        action.actionPerformed(newevt);
                    }
                }
            } finally {
                isJavadocTouched = false;
            }
        }

        @Override
        protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
            int dotPos = caret.getDot();
            if (BraceCompletion.posWithinString(doc, dotPos)) {
                try {
                    doc.insertString(dotPos, "\" + \"", null); //NOI18N
                    CodeStyle cs = CodeStyle.getDefault(doc);
                    if (cs.wrapAfterBinaryOps()) {
                        dotPos += 3;
                        caret.setDot(dotPos);
                        return new Integer(1);
                    } else {
                        dotPos += 1;
                        caret.setDot(dotPos);
                        return new Integer(3);
                    }
                } catch (BadLocationException ex) {
                }
            } else {
                try {
                    if (BraceCompletion.isAddRightBrace(doc, dotPos)) {
                        boolean insert[] = {true};
                        int end = BraceCompletion.getRowOrBlockEnd(doc, dotPos, insert);
                        if (insert[0]) {
                            doc.insertString(end, "}", null); // NOI18N
                            Indent.get(doc).indentNewLine(end);
                        }
                        caret.setDot(dotPos);
                        return Boolean.TRUE;
                    }
                } catch (BadLocationException ex) {
                }
            }
            BraceCompletion.blockCommentCompletion(target, doc, dotPos);
            isJavadocTouched = BraceCompletion.javadocBlockCompletion(target, doc, dotPos);
            return null;
        }

        @Override
        protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret, Object cookie) {
            if (cookie != null) {
                if (cookie instanceof Integer) {
                    // integer
                    int nowDotPos = caret.getDot();
                    caret.setDot(nowDotPos+((Integer)cookie).intValue());
                }
            }
        }
    }

    /**
     * @Deprecated This action is no longer used. It is reimplemented as JavaDeleteCharInterceptor.
     */
    @Deprecated
    public static class JavaDeleteCharAction extends ExtDeleteCharAction {

        public JavaDeleteCharAction(String nm, boolean nextChar) {
            super(nm, nextChar);
        }

        @Override
        protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch)
        throws BadLocationException {
            BraceCompletion.charBackspaced(doc, dotPos, caret, ch);
        }

        @Override
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            target.putClientProperty(JavaDeleteCharAction.class, this);

            try {
                super.actionPerformed(evt, target);
            } finally {
                target.putClientProperty(JavaDeleteCharAction.class, null);
            }
        }

        public boolean getNextChar() {
            return nextChar;
        }
    }

    @EditorActionRegistration(
            name = expandAllJavadocFolds,
            mimeType = JAVA_MIME_TYPE,

Lines 3-8 Link Here

(-)a/javascript2.editor/manifest.mf (-1 / +1 lines)
3	OpenIDE-Module-Install: org/netbeans/modules/javascript2/editor/ModuleInstaller.class	3	OpenIDE-Module-Install: org/netbeans/modules/javascript2/editor/ModuleInstaller.class
4	OpenIDE-Module-Layer: org/netbeans/modules/javascript2/editor/resources/layer.xml	4	OpenIDE-Module-Layer: org/netbeans/modules/javascript2/editor/resources/layer.xml
5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/javascript2/editor/Bundle.properties	5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/javascript2/editor/Bundle.properties
6	OpenIDE-Module-Specification-Version: 0.3	6	OpenIDE-Module-Specification-Version: 0.4
7	AutoUpdate-Show-In-Client: false	7	AutoUpdate-Show-In-Client: false
8		8

Lines 47-53 Link Here

(-)a/javascript2.editor/nbproject/project.xml (-1 / +1 lines)
47	<compile-dependency/>	47	<compile-dependency/>
48	<run-dependency>	48	<run-dependency>
49	<release-version>2</release-version>	49	<release-version>2</release-version>
50	<specification-version>2.25</specification-version>	50	<specification-version>2.34</specification-version>
51	</run-dependency>	51	</run-dependency>
52	</dependency>	52	</dependency>
53	<dependency>	53	<dependency>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.javascript2.editor;

import javax.swing.text.Document;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenId;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.editor.BaseDocument;
import org.netbeans.modules.csl.api.DeleteWordHandler;
import org.netbeans.modules.javascript2.editor.lexer.JsTokenId;
import org.netbeans.modules.javascript2.editor.lexer.LexUtilities;

@MimeRegistration(mimeType = JsTokenId.JAVASCRIPT_MIME_TYPE, service = DeleteWordHandler.class)
public class JsDeleteWordHandler implements DeleteWordHandler {

    @Override
    public int getNextWordOffset(Document doc, int caretOffset) {
        return getNextWordOffset(doc, caretOffset, false);
    }

    @Override
    public int getPreviousWordOffset(Document doc, int caretOffset) {
        return getNextWordOffset(doc, caretOffset, true);
    }
    
    // UGH - this method has gotten really ugly after successive refinements based on unit tests - consider cleaning up
    public int getNextWordOffset(Document document, int offset, boolean reverse) {
        BaseDocument doc = (BaseDocument)document;
        TokenSequence<?extends JsTokenId> ts = LexUtilities.getJsTokenSequence(doc, offset);
        if (ts == null) {
            return -1;
        }
        ts.move(offset);
        if (!ts.moveNext() && !ts.movePrevious()) {
            return -1;
        }
        if (reverse && ts.offset() == offset) {
            if (!ts.movePrevious()) {
                return -1;
            }
        }

        Token<? extends JsTokenId> token = ts.token();
        TokenId id = token.id();

        if (id == JsTokenId.WHITESPACE) {
            // Just eat up the space in the normal IDE way
            if ((reverse && ts.offset() < offset) || (!reverse && ts.offset() > offset)) {
                return ts.offset();
            }
            while (id == JsTokenId.WHITESPACE) {
                if (reverse && !ts.movePrevious()) {
                    return -1;
                } else if (!reverse && !ts.moveNext()) {
                    return -1;
                }

                token = ts.token();
                id = token.id();
            }
            if (reverse) {
                int start = ts.offset()+token.length();
                if (start < offset) {
                    return start;
                }
            } else {
                int start = ts.offset();
                if (start > offset) {
                    return start;
                }
            }
            
        }

        if (id == JsTokenId.IDENTIFIER) {
            String s = token.text().toString();
            int length = s.length();
            int wordOffset = offset-ts.offset();
            if (reverse) {
                // Find previous
                int offsetInImage = offset - 1 - ts.offset(); 
                if (offsetInImage < 0) {
                    return -1;
                }
                if (offsetInImage < length && Character.isUpperCase(s.charAt(offsetInImage))) {
                    for (int i = offsetInImage - 1; i >= 0; i--) {
                        char charAtI = s.charAt(i);
                        if (charAtI == '_') {
                            // return offset of previous uppercase char in the identifier
                            return ts.offset() + i + 1;
                        } else if (!Character.isUpperCase(charAtI)) {
                            // return offset of previous uppercase char in the identifier
                            return ts.offset() + i + 1;
                        }
                    }
                    return ts.offset();
                } else {
                    for (int i = offsetInImage - 1; i >= 0; i--) {
                        char charAtI = s.charAt(i);
                        if (charAtI == '_') {
                            return ts.offset() + i + 1;
                        }
                        if (Character.isUpperCase(charAtI)) {
                            // now skip over previous uppercase chars in the identifier
                            for (int j = i; j >= 0; j--) {
                                char charAtJ = s.charAt(j);
                                if (charAtJ == '_') {
                                    return ts.offset() + j+1;
                                }
                                if (!Character.isUpperCase(charAtJ)) {
                                    // return offset of previous uppercase char in the identifier
                                    return ts.offset() + j + 1;
                                }
                            }
                            return ts.offset();
                        }
                    }
                    
                    return ts.offset();
                }
            } else {
                // Find next
                int start = wordOffset+1;
                if (wordOffset < 0 || wordOffset >= s.length()) {
                    // Probably the end of a token sequence, such as this:
                    // <%s|%>
                    return -1;
                }
                if (Character.isUpperCase(s.charAt(wordOffset))) { 
                    // if starting from a Uppercase char, first skip over follwing upper case chars
                    for (int i = start; i < length; i++) {
                        char charAtI = s.charAt(i);
                        if (!Character.isUpperCase(charAtI)) {
                            break;
                        }
                        if (s.charAt(i) == '_') {
                            return ts.offset()+i;
                        }
                        start++;
                    }
                }
                for (int i = start; i < length; i++) {
                    char charAtI = s.charAt(i);
                    if (charAtI == '_' || Character.isUpperCase(charAtI)) {
                        return ts.offset()+i;
                    }
                }
            }
        }
        
        // Default handling in the IDE
        return -1;
    }
}

Lines 8-13 Link Here

(-)a/javascript2.editor/src/org/netbeans/modules/javascript2/editor/resources/layer.xml (+4 lines)
8	<folder name="text">	8	<folder name="text">
9	<folder name="javascript">	9	<folder name="javascript">
10	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.javascript2.editor.resources.Bundle"/>	10	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.modules.javascript2.editor.resources.Bundle"/>
		11	<file name="org-netbeans-modules-javascript2-editor-JsDeleteWordHandler.instance">
		12	<attr name="instanceOf" stringvalue="org.netbeans.modules.csl.api.DeleteWordPositionHandler"/>
		13	</file>
		14	<file name="org-netbeans-modules-javascript2-editor-JsDeleteWordPositionHandler.instance_hidden"/>
11	<file name="org-netbeans-modules-javascript2-editor-index-JsIndexer$Factory.instance">	15	<file name="org-netbeans-modules-javascript2-editor-index-JsIndexer$Factory.instance">
12	<attr name="instanceOf" stringvalue="org.netbeans.modules.parsing.spi.indexing.EmbeddingIndexerFactory"/>	16	<attr name="instanceOf" stringvalue="org.netbeans.modules.parsing.spi.indexing.EmbeddingIndexerFactory"/>
13	</file>	17	</file>




 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.php.editor;

import org.netbeans.modules.csl.editor.TypingCompletion.Context;
import java.awt.event.KeyEvent;
import java.util.prefs.Preferences;
import java.util.regex.Pattern;
import javax.swing.JEditorPane;
import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.PlainDocument;
import junit.framework.TestCase;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.java.lexer.JavaTokenId;
import org.netbeans.api.lexer.Language;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.csl.core.CslEditorKit;
import org.netbeans.modules.php.api.util.FileUtils;
import org.netbeans.modules.php.editor.lexer.PHPTokenId;
import org.openide.awt.AcceleratorBinding;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.MIMEResolver;
import org.openide.util.lookup.ServiceProvider;


/**
 * Test brackets completion - unlike the original test this one
 * emulates real typing and tests the resulting state of the document.
 *
 * @autor Miloslav Metelka
 */
public class TypingCompletionUnitTest extends NbTestCase {


    @Override
    protected void setUp() throws Exception {
        super.setUp();
        Preferences prefs = MimeLookup.getLookup(FileUtils.PHP_MIME_TYPE).lookup(Preferences.class);
        prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, true);
        Class.forName(AcceleratorBinding.class.getName(), true, AcceleratorBinding.class.getClassLoader());
    }

    public void testBracketCompletion() {
        Context ctx = new Context(new CslEditorKit(FileUtils.PHP_MIME_TYPE), PHPTokenId.language(), FileUtils.PHP_MIME_TYPE,
                "<?php | ?>"
        Context ctx = new Context(new JavaKit(),
                "for (int i = 0|)"
        );
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals(
                "<?php (|) ?>"
        );
    }
    
    public void testQuoteCompletion() {
        Context ctx = new Context(new CslEditorKit(FileUtils.PHP_MIME_TYPE), PHPTokenId.language(), FileUtils.PHP_MIME_TYPE,
                "<?php |"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "<?php \"|\""
        );
    }

    public void testDeleteQuote() {
        Context ctx = new Context(new CslEditorKit(FileUtils.PHP_MIME_TYPE), PHPTokenId.language(), FileUtils.PHP_MIME_TYPE,
                "<?php \"|\" ?>"
        );
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals(
                "<?php | ?>"
        );
    }

    public void testTypeSemicolonInArgs() { // #146139
        Context ctx = new Context(new JavaKit(),
                "m(|)"
        );
        ctx.typeChar(';');
        ctx.assertDocumentTextEquals(
                "m();|"
        );
    }
    
    public void testIfBreakInsert() {
        Context ctx = new Context(new CslEditorKit(FileUtils.PHP_MIME_TYPE), PHPTokenId.language(), FileUtils.PHP_MIME_TYPE,
                "<?php if(true):|?>"
        );
        ctx.typeChar(';');
        ctx.assertDocumentTextEquals(
                "m();| "
        );
    }

    public void testTypeRightParenWithinBraces() { // #146139
        Context ctx = new Context(new JavaKit(),
                "{(()|; }"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "{(()); }"
        );
    }
    
    public void testTypeLeftParen() {
        Context ctx = new Context(new JavaKit(), "m|");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("m(|)");
    }

    public void testTypeSecondRightParen() {
        Context ctx = new Context(new JavaKit(),
                "m()|)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "m())|"
        );
    }

    public void testTypeRightParenSwingInvokeLaterRunnable() {
        Context ctx = new Context(new JavaKit(),
                "SwingUtilities.invokeLater(new Runnable()|))"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "SwingUtilities.invokeLater(new Runnable())|)"
        );
    }

    public void testTypeSimpleAdditionOfOpeningParenthesisAfterWhile () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "while |"
        );
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals(
                "while (|)"
        );
    }

    public void testTypeRightParenSwingInvokeLaterRunnableRun() {
        Context ctx = new Context(new JavaKit(),
                "SwingUtilities.invokeLater(new Runnable() {\n" +
                "    public void run()|)\n" +
                "})"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "SwingUtilities.invokeLater(new Runnable() {\n" +
                "    public void run())|\n" +
                "})"
        );
    }

    public void testTypeRightParenIfMethodCall() {
        Context ctx = new Context(new JavaKit(),
                "if (a()|) + 5 > 6) {\n" +
                "}"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a())| + 5 > 6) {\n" +
                "}"
        );
    }

    public void testTypeRightParenNoSkipNonBracketChar() {
        Context ctx = new Context(new JavaKit(),
                "m()|"
        );
        ctx.typeChar(' ');
        ctx.assertDocumentTextEquals(
                "m() |"
        );
    }



    // ------- Tests for completion of right brace '}' -------------

    public void testTypeAddRightBraceIfLeftBrace() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "<?php if(true):\n    |\nendif;\n?>"
                "    {\n" +
                "        if (true) {\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceWhiteSpace() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { \t|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { \t\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceLineComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { // line-comment|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { // line-comment\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceBlockComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* block-comment */|\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* block-comment */\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceIfLeftBraceAlreadyPresent() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {|\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            |\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void XtestTypeAddRightBraceCaretInComment() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* unclosed-block-comment|\n" +
                "          */\n" +
                "    }\n" +
                "}\n"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) { /* unclosed-block-comment\n" +
                "                     * |\n" +
                "          */\n" +
                "    }\n" +
                "}\n"
        );
    }

    public void testTypeAddRightBraceMultiLine() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {| System.out.println(\n" +
                "        \"\");\n" +
                "    }\n" +
                "}\n"
                );

        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            System.out.println(\n" +
                "        \"\");\n" +
                "    }\n" +
                "}\n"
                );
    }

    public void testTypeAddRightBraceSingleLine() {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n" +
                "    {\n" +
                "        if (true) {| System.out.println(\"\");\n" +
                "    }\n" +
                "}\n"
                );

        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n" +
                "    {\n" +
                "        if (true) {\n" +
                "            System.out.println(\"\");\n" +
                "        }\n" +
                "    }\n" +
                "}\n"
                );
    }


    // ------- Tests for completion of quote (") -------------
    public void testTypeSimpleQuoteInEmptyDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"|\""
        );
    }

    public void testTypeSimpleQuoteAtBeginingOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|  "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"|\"  "
        );
    }

    public void testTypeSimpleQuoteAtEndOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\""
        );
    }

    public void testTypeSimpleQuoteInWhiteSpaceArea () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |  "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\"  "
        );
    }

    public void testTypeQuoteAtEOL () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |\n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"|\"\n"
        );
    }

    public void testTypeQuoteWithUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"unterminated string| \n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"unterminated string\"| \n"
        );
    }

    public void testTypeQuoteAtEOLWithUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"unterminated string | \n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"unterminated string \"| \n"
        );
    }

    public void testTypeQuoteInsideStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  \"stri|ng literal\" "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "  \"stri\"|ng literal\" "
        );
    }

    public void testTypeQuoteInsideEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|\") "
        );
    }

    public void testTypeQuoteInsideNonEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|some text) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|some text) "
        );
    }

    public void testTypeQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(i+|) "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(i+\"|\") "
        );
    }

    public void testTypeQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedStringLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(\"unterminated string literal |); "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"unterminated string literal \"|); "
        );
    }

    public void testTypeQuoteBeforePlus () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|+\"string literal\"); "
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " System.out.println(\"|\"+\"string literal\"); "
        );
    }

    public void testTypeQuoteBeforeComma () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{|,\"two\"};"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"|\",\"two\"};"
        );
    }

    public void testTypeQuoteBeforeBrace () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{\"one\",|};"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"one\",\"|\"};"
        );
    }

    public void testTypeQuoteBeforeSemicolon() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" + |;"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s = \"\" + \"|\";"
        );
    }

    public void testTypeQuoteBeforeSemicolonWithWhitespace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" +| ;"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "String s = \"\" +\"|\" ;"
        );
    }

    public void testTypeQuoteAfterEscapeSequence() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\\|"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\\\"|"
        );
    }

    public void testTypeQuoteEaten() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('"');
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "\"\"|"
        );
    }

    public void testTypeQuoteOnFirstQuote () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " |\"asdf\""
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                " \"|\"asdf\""
        );
    }

    public void testTypeQuoteInsideComments() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "/** |\n */"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "/** \"|\n */"
        );
    }

    public void testTypeQuoteAtTheEndOfLineCommentLine() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "// test line comment |\n"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "// test line comment \"|\n"
        );
    }


    // ------- Tests for completion of single quote (') -------------

    public void testTypeSingleQuoteInEmptyDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "'|'"
        );
    }

    public void testTypeSingleQuoteAtBeginingOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|  "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "'|'  "
        );
    }

    public void testTypeSingleQuoteAtEndOfDoc () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'"
        );
    }

    public void testTypeSingleQuoteInWhiteSpaceArea () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |  "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'  "
        );
    }

    public void testTypeSingleQuoteAtEOL () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  '|'\n"
        );
    }

    public void testTypeSingleQuoteWithUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  '| \n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ''| \n"
        );
    }

    public void testTypeSingleQuoteAtEOLWithUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  ' |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ' '|\n"
        );
    }

    public void testTypeSingleQuoteInsideCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "  '| ' "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "  ''| ' "
        );
    }

    public void testTypeSingleQuoteInsideEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|') "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|some text) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|some text) "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParenthesesBeforeClosingParentheses () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(i+|) "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println(i+'|') "
        );
    }

    public void testTypeSingleQuoteInsideNonEmptyParenthesesBeforeClosingParenthesesAndUnterminatedCharLiteral () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(' |); "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println(' '|); "
        );
    }

    public void testTypeSingleQuoteBeforePlus () throws Exception {
        Context ctx = new Context(new JavaKit(),
                " System.out.println(|+\"string literal\"); "
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                " System.out.println('|'+\"string literal\"); "
        );
    }

    public void testTypeSingleQuoteBeforeComma () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{|,\"two\"};"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{'|',\"two\"};"
        );
    }

    public void testTypeSingleQuoteBeforeBrace () throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s[] = new String[]{\"one\",|};"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s[] = new String[]{\"one\",'|'};"
        );
    }

    public void testTypeSingleQuoteBeforeSemicolon() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" + |;"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s = \"\" + '|';"
        );
    }

    public void testTypeSingleQuoteBeforeSemicolonWithWhitespace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "String s = \"\" +| ;"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "String s = \"\" +'|' ;"
        );
    }

    public void testTypeSingleQuoteAfterEscapeSequence() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\\|"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "\\'|"
        );
    }

    public void testTypeSingleQuoteEaten() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "|"
        );
        ctx.typeChar('\'');
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "''|"
        );
    }

    public void testTypeSingleQuoteInsideComments() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "/* |\n */"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "/* \'|\n */"
        );
    }

    public void testTypeSingleQuoteAtTheEndOfLineCommentLine() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "// test line comment |\n"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "// test line comment \'|\n"
        );
    }

    public void testDisable147641() throws Exception {
        boolean orig = TypingCompletion.isCompletionSettingEnabled();
        Preferences prefs = MimeLookup.getLookup(JavaKit.JAVA_MIME_TYPE).lookup(Preferences.class);

        try {
            prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, false);

            Context ctx = new Context(new JavaKit(),
                    "while |"
            );
            ctx.typeChar('(');
            ctx.assertDocumentTextEquals(
                    "while (|"
            );
        } finally {
            prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, orig);
        }
    }

    public void testDoNotSkipWhenNotBalanced147683a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "System.err.println((true|);"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "System.err.println((true)|);"
        );
    }

    public void testSkipWhenBalanced46517() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()| )"
        );
    }

    public void testDoNotSkipWhenNotBalanced147683b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) ; )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()|) ; )"
        );
    }

    public void testDoNotSkipWhenNotBalanced147683c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (a(|) \n )"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "if (a()|) \n )"
        );
    }
//problem
    public void testSkipWhenBalanced198194a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(|); i < 10; i++)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a()|; i < 10; i++)"
        );
    }

    public void testSkipWhenNotBalanced198194a() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(|; i < 10; i++)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a()|; i < 10; i++)"
        );
    }

    public void testSkipWhenBalanced198194b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i = a(|))"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i = a()|)"
        );
    }

    public void testSkipWhenNotBalanced198194b() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i = a(|)"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i = a()|)"
        );
    }

    public void testSkipWhenNotBalanced198194c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i++) a(|;"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i++) a()|;"
        );
    }

    public void testSkipWhenBalanced198194c() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "for (int i = a(); i < 10; i++) a(|);"
        );
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals(
                "for (int i = a(); i < 10; i++) a()|;"
        );
    }

    public void testKeepBalance148878() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "Map[|] m = new HashMap[1];"
        );
        ctx.typeChar(']');
        ctx.assertDocumentTextEquals(
                "Map[]| m = new HashMap[1];"
        );
    }
    
    public void testQuotes148878() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "if (c == '\\\\|')"
        );
        ctx.typeChar('\'');
        ctx.assertDocumentTextEquals(
                "if (c == '\\\\'|)"
        );
    }
   
    public void testPositionInString() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        \"H|\"\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        \"H\"\n"
                + "        + \"|\"\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testPositionInEmptyString() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        \"|\"\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        \"\"\n"
                + "        + \"|\"\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testCommentBlockCompletion() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /*|\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /*\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
   
    public void testCommentBlockCompletionNotNeeded() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /*|\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /*\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
    

    public void testCommentBlockCompletionTwoComments () {
        Context ctx = new Context(new JavaKit(),
                "/*|\n" +
                "/*\n" +
                " */"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "/*\n" +
                " * |\n" +
                " */\n" +
                "/*\n" +
                " */"
        );
    }

    public void testCommentBlockCompletionTwoComments2 () {
        Context ctx = new Context(new JavaKit(),
                "/*|\n" +
                "\n" +
                "/*\n" +
                " */"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "/*\n" +
                " * |\n" +
                " */\n" +
                "\n" +
                "/*\n" +
                " */"
        );
    }
    
    public void testCommentBlockCompletionNoClose () {
        Context ctx = new Context(new JavaKit(),
                "/*| a"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "/*\n" +
                " * |a"
        );
    }
    
    public void testJavaDocCompletion() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
    
    public void testJavaDocCompletionNotNeeded() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         */\n"
                + "    }\n"
                + "}\n");
    }
  
    public void insertBreakJavadocComplete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "class Test {\n"
                + "    {\n"
                + "        /**|\n"
                + "        public static void main(String[] args) {\n"
                + "        }\n"
                + "    }\n"
                + "}\n");
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals (
            "class Test {\n"
                + "    {\n"
                + "        /**\n"
                + "         * |\n"
                + "         * @param args\n"
                + "         */\n"
                + "        public static void main(String[] args) {\n"
                + "        }\n"
                + "    }\n"
                + "}\n"
        );
    }
    
    public void testRemoveBracketBackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "()(|)");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("()|");
    }

    public void testRemoveBracketDelete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "()|()");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("()|");
    }
    
    public void testRemoveQuotesBackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\"\"\"|\"");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testRemoveQuotesDelete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\"\"|\"\"");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testRemoveQuotes2BackSpace() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\'\'\'|\'");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("\'\'|");
    }
    
    public void testRemoveQuotes2Delete() throws Exception {
        Context ctx = new Context(new JavaKit(),
                "\'\'|\'\'");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("\'\'|");
    }
    
    public void testJumpCharacters() throws Exception {
        Context ctx = new Context(new JavaKit(), "m(\"p|\");");
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals("m(\"p\"|);");
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals("m(\"p\")|;");
    }
    
    public void testJumpQuote() throws Exception {
        Context ctx = new Context(new JavaKit(), "\"|\"");
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals("\"\"|");
    }
    
    public void testInsertSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "|");
        ctx.typeChar('[');
        ctx.assertDocumentTextEquals("[|]");
    }

    public void testBackspaceSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "[|]");
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals("|");
    }
    
    public void testDeleteSquareBracket() throws Exception {
        Context ctx = new Context(new JavaKit(), "|[]");
        ctx.typeChar('\f');
        ctx.assertDocumentTextEquals("|");
    }
    
    public void testInsertBracketInString() throws Exception {
        Context ctx = new Context(new JavaKit(), "\"|\"");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("\"(|\"");
        ctx = new Context(new JavaKit(), "\" |\"");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("\" (|\"");
    }
    
    public void testInsertBracketInComment() throws Exception {
        Context ctx = new Context(new JavaKit(), "//|");
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals("//(|");
    }
    
    public void testSkipBracketInComment() throws Exception {
        Context ctx = new Context(new JavaKit(), "//(|)");
        ctx.typeChar(')');
        ctx.assertDocumentTextEquals("//()|)");
    }
     
    public void testCorrectHandlingOfStringEscapes184059() throws Exception {
        assertTrue(isInsideString("foo\n\"bar|\""));
        assertTrue(isInsideString("foo\n\"bar\\\"|\""));
        assertFalse(isInsideString("foo\n\"bar\\\\\"|"));
        assertFalse(isInsideString("foo\n|\"bar\\\\\""));
        assertTrue(isInsideString("foo\n\"|bar\\\\\""));
    }

    private boolean isInsideString(String code) throws BadLocationException {
        int pos = code.indexOf('|');

        assertNotSame(-1, pos);

        code = code.replaceAll(Pattern.quote("|"), "");

        Document doc = new PlainDocument();

        doc.putProperty(Language.class, JavaTokenId.language());
        doc.insertString(0, code, null);

        return TypingCompletion.posWithinString(doc, pos);
    }

    private static final class Context {
        
        private JEditorPane pane;

        public Context(final EditorKit kit, final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        pane = new JEditorPane();
                        pane.setEditorKit(kit);
                        Document doc = pane.getDocument();
                        // Required by Java's default key typed
                        doc.putProperty(Language.class, JavaTokenId.language());
                        doc.putProperty("mimeType", "text/x-java");
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        pane.setText(text);
                        pane.setCaretPosition((caretOffset != -1) ? caretOffset : doc.getLength());
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
        
        public JEditorPane pane() {
            return pane;
        }

        public Document document() {
            return pane.getDocument();
        }
        
        public void typeChar(final char ch) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        KeyEvent keyEvent;
                        switch (ch) {
                            case '\n':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_ENTER, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Enter
                                break;
                            case '\b':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_BACK_SPACE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of BackSpace
                                break;
                            case '\f':
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Delete
                                break;
                            default:
                                keyEvent = new KeyEvent(pane, KeyEvent.KEY_TYPED,
                                        EventQueue.getMostRecentEventTime(),
                                        0, KeyEvent.VK_UNDEFINED, ch);
                        }
                        SwingUtilities.processKeyBindings(keyEvent);
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }

        public void typeText(String text) {
            for (int i = 0; i < text.length(); i++) {
                typeChar(text.charAt(i));
            }
        }

        public void assertDocumentTextEquals(final String textWithPipe) {
            try {
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        int caretOffset = textWithPipe.indexOf('|');
                        String text;
                        if (caretOffset != -1) {
                            text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
                        } else {
                            text = textWithPipe;
                        }
                        try {
                            // Use debug text to prefix special chars for easier readability
                            text = CharSequenceUtilities.debugText(text);
                            String docText = document().getText(0, document().getLength());
                            docText = CharSequenceUtilities.debugText(docText);
                            if (!text.equals(docText)) {
                                int diffIndex = 0;
                                int minLen = Math.min(docText.length(), text.length());
                                while (diffIndex < minLen) {
                                    if (text.charAt(diffIndex) != docText.charAt(diffIndex)) {
                                        break;
                                    }
                                    diffIndex++;
                                }
                                TestCase.fail("Invalid document text - diff at index " + diffIndex +
                                        "\nExpected: \"" + text +
                                        "\"\n  Actual: \"" + docText + "\""
                                );
                            }
                        } catch (BadLocationException e) {
                            throw new IllegalStateException(e);
                        }
                        if (caretOffset != -1) {
                            TestCase.assertEquals("Invalid caret offset", caretOffset, pane.getCaretPosition());
                        }
                    }
                });
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }
    }

    @ServiceProvider(service=MIMEResolver.class)
    public static final class MIMEResolverImpl extends MIMEResolver {

        public MIMEResolverImpl() {
            super("text/x-nbeditor-keybindingsettings");
        }

        @Override public String findMIMEType(FileObject fo) {
            return fo.getPath().contains("Keybindings") ? "text/x-nbeditor-keybindingsettings" : null;
        }
    }

}

Lines 49-55 Link Here

(-)a/web.core.syntax/nbproject/project.properties (-1 / +1 lines)
49	javac.source=1.6	49	javac.source=1.6
50	javadoc.arch=${basedir}/arch.xml	50	javadoc.arch=${basedir}/arch.xml
51		51
52	spec.version.base=2.33.0	52	spec.version.base=2.34.0
53		53
54	test.config.validation.includes=\	54	test.config.validation.includes=\
55	/AutoCompletionTest.class,/CompletionTest.class	55	/AutoCompletionTest.class,/CompletionTest.class

Lines 58-64 Link Here

(-)a/web.core.syntax/src/org/netbeans/modules/web/core/syntax/JspKit.java (-284 / +12 lines)
58	import javax.swing.Action;	58	import javax.swing.Action;
59	import javax.swing.SwingUtilities;	59	import javax.swing.SwingUtilities;
60	import javax.swing.text.*;	60	import javax.swing.text.*;
		61	import org.netbeans.api.editor.mimelookup.MimeLookup;
		62	import org.netbeans.api.editor.mimelookup.MimePath;
		63	import org.netbeans.api.editor.mimelookup.MimeRegistration;
		64	import org.netbeans.api.editor.mimelookup.MimeRegistrations;
61	import org.netbeans.api.java.lexer.JavaTokenId;	65	import org.netbeans.api.java.lexer.JavaTokenId;
		66	import org.netbeans.api.java.source.CodeStyle;
62	import org.netbeans.api.lexer.TokenHierarchy;	67	import org.netbeans.api.lexer.TokenHierarchy;
63	import org.netbeans.api.lexer.TokenSequence;	68	import org.netbeans.api.lexer.TokenSequence;
64	import org.netbeans.editor.BaseDocument;	69	import org.netbeans.editor.BaseDocument;
Lines 80-87 Link Here
80	import org.netbeans.editor.ext.ExtKit.ExtDefaultKeyTypedAction;	85	import org.netbeans.editor.ext.ExtKit.ExtDefaultKeyTypedAction;
81	import org.netbeans.editor.ext.ExtKit.ExtDeleteCharAction;	86	import org.netbeans.editor.ext.ExtKit.ExtDeleteCharAction;
82	import org.netbeans.modules.csl.api.*;	87	import org.netbeans.modules.csl.api.*;
		88	import org.netbeans.modules.editor.indent.api.Indent;
		89	import org.netbeans.modules.editor.indent.spi.Context;
83	import org.netbeans.modules.web.core.syntax.gsf.JspCommentHandler;	90	import org.netbeans.modules.web.core.syntax.gsf.JspCommentHandler;
		91	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
		92	import org.netbeans.spi.editor.typinghooks.TypedBreakInterceptor;
		93	import org.netbeans.spi.editor.typinghooks.TypedBreakInterceptor.MutableContext;
		94	import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor;
84	import org.netbeans.spi.lexer.MutableTextInput;	95	import org.netbeans.spi.lexer.MutableTextInput;
		96	import org.openide.util.Lookup;
85		97
86	/**	98	/**
87	* Editor kit implementation for JSP content type	99	* Editor kit implementation for JSP content type
Lines 177-186 Link Here
177	@Override	189	@Override
178	protected Action[] createActions() {	190	protected Action[] createActions() {
179	Action[] javaActions = new Action[] {	191	Action[] javaActions = new Action[] {
180	new JspInsertBreakAction(),
181	new JspDefaultKeyTypedAction(),
182	new JspDeleteCharAction(deletePrevCharAction, false),
183	new JspDeleteCharAction(deleteNextCharAction, true),
184	new SelectCodeElementAction(SelectCodeElementAction.selectNextElementAction, true),	192	new SelectCodeElementAction(SelectCodeElementAction.selectNextElementAction, true),
185	new SelectCodeElementAction(SelectCodeElementAction.selectPreviousElementAction, false),	193	new SelectCodeElementAction(SelectCodeElementAction.selectPreviousElementAction, false),
186	new InstantRenameAction(),	194	new InstantRenameAction(),
Lines 423-707 Link Here
423	return new org.openide.util.HelpCtx(JspKit.class);	431	return new org.openide.util.HelpCtx(JspKit.class);
424	}	432	}
425		433
426	/**
427	* Returns true if bracket completion is enabled in options.
428	*/
429	private static boolean completionSettingEnabled() {
430	//return ((Boolean)Settings.getValue(JspKit.class, JavaSettingsNames.PAIR_CHARACTERS_COMPLETION)).booleanValue();
431	return true;
432	}
433
434	public static class JspInsertBreakAction extends InsertBreakAction {
435
436	@Override
437	public void actionPerformed(ActionEvent e, JTextComponent target) {
438	if (target != null) {
439	TokenSequence javaTokenSequence;
440	AbstractDocument adoc = (AbstractDocument)target.getDocument();
441	adoc.readLock();
442	try {
443	javaTokenSequence = JspSyntaxSupport.tokenSequence(TokenHierarchy.get(target.getDocument()), JavaTokenId.language(), target.getCaret().getDot() - 1);
444	} finally {
445	adoc.readUnlock();
446	}
447
448	if (javaTokenSequence != null) {
449	JavaKit jkit = (JavaKit) getKit(JavaKit.class);
450	if (jkit != null) {
451	Action action = jkit.getActionByName(DefaultEditorKit.insertBreakAction);
452	if (action != null && action instanceof JavaKit.JavaInsertBreakAction) {
453	((JavaKit.JavaInsertBreakAction) action).actionPerformed(e, target);
454	return;
455	}
456	}
457	}
458	}
459	super.actionPerformed(e, target);
460	}
461
462	@Override
463	protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
464	if (completionSettingEnabled()) {
465	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, caret.getDot());
466
467	if (bracketCompletion != null) {
468	try {
469	int newOffset = bracketCompletion.beforeBreak(doc, caret.getDot(), target);
470
471	if (newOffset >= 0) {
472	return new Integer(newOffset);
473	}
474	} catch (BadLocationException ble) {
475	Exceptions.printStackTrace(ble);
476	}
477	}
478	}
479
480	return null;
481	}
482
483	@Override
484	protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret,
485	Object cookie) {
486	if (completionSettingEnabled()) {
487	if (cookie != null) {
488	if (cookie instanceof Integer) {
489	// integer
490	int dotPos = ((Integer) cookie).intValue();
491	if (dotPos != -1) {
492	caret.setDot(dotPos);
493	} else {
494	int nowDotPos = caret.getDot();
495	caret.setDot(nowDotPos + 1);
496	}
497	}
498	}
499	}
500	}
501
502	}
503
504	public static class JspDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {
505
506	private JTextComponent currentTarget;
507
508	@Override
509	public void actionPerformed(final ActionEvent e, final JTextComponent target) {
510	// Preliminary checks that avoid interpreting e.g. Ctrl+W that would then invoke runAtomic()
511	if ((target != null) && (e != null)) {
512	// Check whether the modifiers are OK
513	int mod = e.getModifiers();
514	boolean ctrl = ((mod & ActionEvent.CTRL_MASK) != 0);
515	// On the mac, norwegian and french keyboards use Alt to do bracket characters.
516	// This replicates Apple's modification DefaultEditorKit.DefaultKeyTypedAction
517	boolean alt = org.openide.util.Utilities.isMac() ? ((mod & ActionEvent.META_MASK) != 0) :
518	((mod & ActionEvent.ALT_MASK) != 0);
519	if (alt \|\| ctrl) {
520	return;
521	}
522	// Check whether the target is enabled and editable
523	if (!target.isEditable() \|\| !target.isEnabled()) {
524	target.getToolkit().beep();
525	return;
526	}
527	}
528
529	currentTarget = target;
530	try {
531	if (!triggerJavaDefaultKeyTypedAction(e, target)) {
532	super.actionPerformed(e, target);
533	} else {
534	return; //java triggered this already
535	}
536	} finally {
537	currentTarget = null;
538	}
539	}
540
541	private boolean triggerJavaDefaultKeyTypedAction(final ActionEvent e, final JTextComponent target) {
542	BaseDocument bdoc = (BaseDocument) target.getDocument();
543	final boolean[] retcode = new boolean[1];
544	bdoc.runAtomic(new Runnable() {
545	public void run() {
546	TokenSequence javaTokenSequence = JspSyntaxSupport.tokenSequence(TokenHierarchy.get(target.getDocument()), JavaTokenId.language(), target.getCaret().getDot() - 1);
547	if (javaTokenSequence != null) {
548	JavaKit jkit = (JavaKit) getKit(JavaKit.class);
549	if (jkit != null) {
550	Action action = jkit.getActionByName(DefaultEditorKit.defaultKeyTypedAction);
551	if (action != null && action instanceof JavaKit.JavaDefaultKeyTypedAction) {
552	((JavaKit.JavaDefaultKeyTypedAction) action).actionPerformed(e, target);
553	retcode[0] = true;
554	}
555	}
556	}
557	}
558	});
559	return retcode[0];
560	}
561
562	/** called under document atomic lock */
563	@Override
564	protected void insertString(BaseDocument doc, int dotPos,
565	Caret caret, String str,
566	boolean overwrite) throws BadLocationException {
567	// see issue #211036 - inserted string can be empty since #204450
568	if (str.isEmpty()) {
569	return;
570	}
571
572	if (completionSettingEnabled()) {
573	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
574
575	if (bracketCompletion != null) {
576	// TODO - check if we're in a comment etc. and if so, do nothing
577	boolean handled =
578	bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget,
579	str.charAt(0));
580
581	if (!handled) {
582	super.insertString(doc, dotPos, caret, str, overwrite);
583	handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget,
584	str.charAt(0));
585	}
586
587	return;
588	}
589	}
590
591	super.insertString(doc, dotPos, caret, str, overwrite);
592	}
593
594	@Override
595	protected void replaceSelection(JTextComponent target, int dotPos, Caret caret,
596	String str, boolean overwrite) throws BadLocationException {
597	//workaround for #209019 - regression of issue
598	//#204450 - Rewrite actions to use TypingHooks SPI
599	if(str.length() == 0) {
600	//called from BaseKit.actionPerformed():1160 with empty str argument
601	//==> ignore this call since we are going to be called a bit later
602	//from HtmlKit.performTextInsertion() properly with the text typed
603	return ;
604	}
605	char insertedChar = str.charAt(0);
606	Document document = target.getDocument();
607
608	if (document instanceof BaseDocument) {
609	BaseDocument doc = (BaseDocument) document;
610
611	if (completionSettingEnabled()) {
612	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
613
614	if (bracketCompletion != null) {
615	try {
616	int caretPosition = caret.getDot();
617
618	boolean handled =
619	bracketCompletion.beforeCharInserted(doc, caretPosition,
620	target, insertedChar);
621
622	int p0 = Math.min(caret.getDot(), caret.getMark());
623	int p1 = Math.max(caret.getDot(), caret.getMark());
624
625	if (p0 != p1) {
626	doc.remove(p0, p1 - p0);
627	}
628
629	if (!handled) {
630	if (str.length() > 0) {
631	doc.insertString(p0, str, null);
632	handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget, str.charAt(0));
633	}
634
635
636	}
637	} catch (BadLocationException e) {
638	e.printStackTrace();
639	}
640
641	return;
642	}
643	}
644	}
645
646	super.replaceSelection(target, dotPos, caret, str, overwrite);
647	}
648
649	}
650
651	public static class JspDeleteCharAction extends ExtDeleteCharAction {
652
653	JTextComponent currentTarget;
654
655	public JspDeleteCharAction(String nm, boolean nextChar) {
656	super(nm, nextChar);
657	}
658
659	@Override
660	public void actionPerformed(ActionEvent e, JTextComponent target) {
661	currentTarget = target;
662	if (target!=null){
663	TokenSequence javaTokenSequence;
664	AbstractDocument adoc = (AbstractDocument)target.getDocument();
665	adoc.readLock();
666	try {
667	javaTokenSequence = JspSyntaxSupport.tokenSequence(
668	TokenHierarchy.get(target.getDocument()),
669	JavaTokenId.language(),
670	target.getCaret().getDot() - 1);
671	} finally {
672	adoc.readUnlock();
673	}
674
675	if (javaTokenSequence != null){
676	JavaKit jkit = (JavaKit)getKit(JavaKit.class);
677	if (jkit!=null){
678	Action action = jkit.getActionByName(nextChar ? DefaultEditorKit.deleteNextCharAction : DefaultEditorKit.deletePrevCharAction);
679	if (action != null && action instanceof JavaKit.JavaDeleteCharAction){
680	((JavaKit.JavaDeleteCharAction)action).actionPerformed(e, target);
681	return;
682	}
683	}
684	}
685	}
686	super.actionPerformed(e, target);
687	currentTarget = null;
688	}
689
690	@Override
691	protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch) throws BadLocationException {
692	if (completionSettingEnabled()) {
693	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
694
695	if (bracketCompletion != null) {
696	bracketCompletion.charBackspaced(doc, dotPos, currentTarget, ch);
697	return;
698	}
699	}
700
701	super.charBackspaced(doc, dotPos, caret, ch);
702	}
703
704	}
705
706	}	434	}
707		435




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. 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 and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2011 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.web.core.syntax;

import org.netbeans.modules.csl.editor.TypingCompletion.Context;
import java.util.prefs.Preferences;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.jsp.lexer.JspTokenId;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.csl.core.CslEditorKit;
import org.openide.awt.AcceleratorBinding;


/**
 * Test brackets completion - unlike the original test this one
 * emulates real typing and tests the resulting state of the document.
 */
public class TypingCompletionUnitTest extends NbTestCase {

    public TypingCompletionUnitTest(String testMethodName) {
        super(testMethodName);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        Preferences prefs = MimeLookup.getLookup(JspKit.JSP_MIME_TYPE).lookup(Preferences.class);
        prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, true);
        Class.forName(AcceleratorBinding.class.getName(), true, AcceleratorBinding.class.getClassLoader());
    }

    public void testBracketCompletion() {
        Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
                "<% | %>"
        );
        ctx.typeChar('(');
        ctx.assertDocumentTextEquals(
                "<% (|) %>"
        );
    }
    
    public void testQuoteCompletion() {
        Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
                "<% |"
        );
        ctx.typeChar('"');
        ctx.assertDocumentTextEquals(
                "<% \"|\""
        );
    }

    public void testDeleteQuote() {
        Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
                "<% \"|\" %>"
        );
        ctx.typeChar('\b');
        ctx.assertDocumentTextEquals(
                "<% | %>"
        );
    }
    
    public void testIfBreakInsert() {
        Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
                "<% \"|\" %>"
        );
        ctx.typeChar('\n');
        ctx.assertDocumentTextEquals(
                "<% \"\"\n + \"|\" %>"
        );
    }
}

Return to bug 217163

Lines 307-381 Link Here

(-)a/java.editor/src/org/netbeans/modules/editor/java/JavaKit.java (-180 / +1 lines)
307	super.install(c);	307	super.install(c);
308	ClipboardHandler.install(c);	308	ClipboardHandler.install(c);
309	}	309	}
310
311	/**
312	* @Deprecated This action is no longer used. It is reimplemented as JavaDefaultKeyTypedInterceptor.
313	*/
314	@Deprecated
315	public static class JavaDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {
316
317	@Override
318	protected void insertString(BaseDocument doc, int dotPos,
319	Caret caret, String str,
320	boolean overwrite) throws BadLocationException {
321	char insertedChar = str.charAt(0);
322	if (insertedChar == '\"' \|\| insertedChar == '\''){
323	boolean inserted = BraceCompletion.completeQuote(doc, dotPos, caret, insertedChar);
324	if (inserted){
325	caret.setDot(dotPos+1);
326	}else{
327	super.insertString(doc, dotPos, caret, str, overwrite);
328
329	}
330	} else {
331	super.insertString(doc, dotPos, caret, str, overwrite);
332	BraceCompletion.charInserted(doc, dotPos, caret, insertedChar);
333	}
334	}
335
336	protected void replaceSelection(JTextComponent target,
337	int dotPos,
338	Caret caret,
339	String str,
340	boolean overwrite)
341	throws BadLocationException {
342	char insertedChar = str.charAt(0);
343	Document doc = target.getDocument();
344	if (insertedChar == '\"' \|\| insertedChar == '\''){
345	if (doc != null) {
346	try {
347	boolean inserted = false;
348	int p0 = Math.min(caret.getDot(), caret.getMark());
349	int p1 = Math.max(caret.getDot(), caret.getMark());
350	if (p0 != p1) {
351	doc.remove(p0, p1 - p0);
352	}
353	int caretPosition = caret.getDot();
354	if (doc instanceof BaseDocument){
355	inserted = BraceCompletion.completeQuote(
356	(BaseDocument)doc,
357	caretPosition,
358	caret, insertedChar);
359	}
360	if (inserted){
361	caret.setDot(caretPosition+1);
362	} else {
363	if (str != null && str.length() > 0) {
364	doc.insertString(p0, str, null);
365	}
366	}
367	} catch (BadLocationException e) {
368	e.printStackTrace();
369	}
370	}
371	} else {
372	super.replaceSelection(target, dotPos, caret, str, overwrite);
373	if (doc instanceof BaseDocument){
374	BraceCompletion.charInserted((BaseDocument)doc, caret.getDot()-1, caret, insertedChar);
375	}
376	}
377	}
378	}
379		310
380	@EditorActionRegistration(name = generateGoToPopupAction, mimeType = JAVA_MIME_TYPE)	311	@EditorActionRegistration(name = generateGoToPopupAction, mimeType = JAVA_MIME_TYPE)
381	public static class JavaGenerateGoToPopupAction extends NbGenerateGoToPopupAction {	312	public static class JavaGenerateGoToPopupAction extends NbGenerateGoToPopupAction {
Lines 705-821 Link Here
705	}	636	}
706	}	637	}
707	}	638	}
708		639
709	/**
710	* @Deprecated This action is no longer used. It is reimplemented as JavaTypedBreakInterceptor.
711	*/
712	@Deprecated
713	public static class JavaInsertBreakAction extends InsertBreakAction {
714
715	static final long serialVersionUID = -1506173310438326380L;
716	private boolean isJavadocTouched = false;
717
718	@Override
719	public void actionPerformed(ActionEvent evt, JTextComponent target) {
720	try {
721	super.actionPerformed(evt, target);
722	Document doc = target.getDocument();
723	if (isJavadocTouched && !org.netbeans.lib.editor.util.swing.DocumentUtilities.isWriteLocked(doc)) {
724	// XXX temporary solution until the editor will provide a SPI to plug. See issue #115739
725	// This must run outside the document lock
726	Lookup.Result<TextAction> res = MimeLookup.getLookup(MimePath.parse("text/x-javadoc")).lookupResult(TextAction.class);
727	ActionEvent newevt = new ActionEvent(target, ActionEvent.ACTION_PERFORMED, "fix-javadoc");
728	for (TextAction action : res.allInstances()) {
729	action.actionPerformed(newevt);
730	}
731	}
732	} finally {
733	isJavadocTouched = false;
734	}
735	}
736
737	@Override
738	protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
739	int dotPos = caret.getDot();
740	if (BraceCompletion.posWithinString(doc, dotPos)) {
741	try {
742	doc.insertString(dotPos, "\" + \"", null); //NOI18N
743	CodeStyle cs = CodeStyle.getDefault(doc);
744	if (cs.wrapAfterBinaryOps()) {
745	dotPos += 3;
746	caret.setDot(dotPos);
747	return new Integer(1);
748	} else {
749	dotPos += 1;
750	caret.setDot(dotPos);
751	return new Integer(3);
752	}
753	} catch (BadLocationException ex) {
754	}
755	} else {
756	try {
757	if (BraceCompletion.isAddRightBrace(doc, dotPos)) {
758	boolean insert[] = {true};
759	int end = BraceCompletion.getRowOrBlockEnd(doc, dotPos, insert);
760	if (insert[0]) {
761	doc.insertString(end, "}", null); // NOI18N
762	Indent.get(doc).indentNewLine(end);
763	}
764	caret.setDot(dotPos);
765	return Boolean.TRUE;
766	}
767	} catch (BadLocationException ex) {
768	}
769	}
770	BraceCompletion.blockCommentCompletion(target, doc, dotPos);
771	isJavadocTouched = BraceCompletion.javadocBlockCompletion(target, doc, dotPos);
772	return null;
773	}
774
775	@Override
776	protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret, Object cookie) {
777	if (cookie != null) {
778	if (cookie instanceof Integer) {
779	// integer
780	int nowDotPos = caret.getDot();
781	caret.setDot(nowDotPos+((Integer)cookie).intValue());
782	}
783	}
784	}
785	}
786
787	/**
788	* @Deprecated This action is no longer used. It is reimplemented as JavaDeleteCharInterceptor.
789	*/
790	@Deprecated
791	public static class JavaDeleteCharAction extends ExtDeleteCharAction {
792
793	public JavaDeleteCharAction(String nm, boolean nextChar) {
794	super(nm, nextChar);
795	}
796
797	@Override
798	protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch)
799	throws BadLocationException {
800	BraceCompletion.charBackspaced(doc, dotPos, caret, ch);
801	}
802
803	@Override
804	public void actionPerformed(ActionEvent evt, JTextComponent target) {
805	target.putClientProperty(JavaDeleteCharAction.class, this);
806
807	try {
808	super.actionPerformed(evt, target);
809	} finally {
810	target.putClientProperty(JavaDeleteCharAction.class, null);
811	}
812	}
813
814	public boolean getNextChar() {
815	return nextChar;
816	}
817	}
818
819	@EditorActionRegistration(	640	@EditorActionRegistration(
820	name = expandAllJavadocFolds,	641	name = expandAllJavadocFolds,
821	mimeType = JAVA_MIME_TYPE,	642	mimeType = JAVA_MIME_TYPE,

Lines 49-54 Link Here

(-)a/csl.api/apichanges.xml (+15 lines)
49	<apidef name="csl.api">Common Scripting Language API</apidef>	49	<apidef name="csl.api">Common Scripting Language API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="DeleteWordHandler">
		53	<api name="csl.api"/>
		54	<summary>Add DeleteWordHandler</summary>
		55	<version major="2" minor="34"/>
		56	<date day="13" month="11" year="2012"/>
		57	<author login="mkristofic"/>
		58	<compatibility addition="yes" deletion="no" modification="no" binary="compatible" source="compatible" deprecation="yes"/>
		59	<description>
		60	<p>
		61	Add DeleteWordHandler to replace KeystrokeHandler in future. KeystrokeHandler is deprecated since clients can use TypingHooks from editor.lib2
		62	</p>
		63	</description>
		64	<class package="org.netbeans.modules.csl.api" name="DeleteWordHandler"/>
		65	<issue number="217163"/>
		66	</change>
52	<change id="LanguageRegistration.useMultiview">	67	<change id="LanguageRegistration.useMultiview">
53	<api name="csl.api"/>	68	<api name="csl.api"/>
54	<summary>Add useMultiview to @LanguageRegistration</summary>	69	<summary>Add useMultiview to @LanguageRegistration</summary>

Lines 44-54 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/api/CamelCaseOperations.java (-1 / +23 lines)
44		44
45	package org.netbeans.modules.csl.api;	45	package org.netbeans.modules.csl.api;
46		46
		47	import java.util.Collection;
47	import javax.swing.text.BadLocationException;	48	import javax.swing.text.BadLocationException;
48	import javax.swing.text.Document;	49	import javax.swing.text.Document;
49	import javax.swing.text.JTextComponent;	50	import javax.swing.text.JTextComponent;
		51	import org.netbeans.api.editor.mimelookup.MimeLookup;
50	import org.netbeans.editor.BaseDocument;	52	import org.netbeans.editor.BaseDocument;
51	import org.netbeans.editor.Utilities;	53	import org.netbeans.editor.Utilities;
		54	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
52	import org.openide.ErrorManager;	55	import org.openide.ErrorManager;
53		56
54	/**	57	/**
Lines 68-74 Link Here
68	if (offset == doc.getLength()) {	71	if (offset == doc.getLength()) {
69	return -1;	72	return -1;
70	}	73	}
71		74	Collection<? extends DeleteWordHandler> deleteWordHandlers = MimeLookup.getLookup(UiUtils.getMimePath(doc, offset)).lookupAll(DeleteWordHandler.class);
		75	if (!deleteWordHandlers.isEmpty()) {
		76	for (DeleteWordHandler dw :deleteWordHandlers) {
		77	int nextOffset = dw.getNextWordOffset(doc, offset);
		78	if (nextOffset != -1) {
		79	return nextOffset;
		80	}
		81	}
		82	}
		83
72	KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);	84	KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);
73	if (bc != null) {	85	if (bc != null) {
74	int nextOffset = bc.getNextWordOffset(doc, offset, false);	86	int nextOffset = bc.getNextWordOffset(doc, offset, false);
Lines 96-101 Link Here
96		108
97	final Document doc = textComponent.getDocument();	109	final Document doc = textComponent.getDocument();
98		110
		111	Collection<? extends DeleteWordHandler> deleteWordHandlers = MimeLookup.getLookup(UiUtils.getMimePath(doc, offset)).lookupAll(DeleteWordHandler.class);
		112	if (!deleteWordHandlers.isEmpty()) {
		113	for (DeleteWordHandler dw :deleteWordHandlers) {
		114	int nextOffset = dw.getPreviousWordOffset(doc, offset);
		115	if (nextOffset != -1) {
		116	return nextOffset;
		117	}
		118	}
		119	}
		120
99	KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);	121	KeystrokeHandler bc = UiUtils.getBracketCompletion(doc, offset);
100	if (bc != null) {	122	if (bc != null) {
101	int nextOffset = bc.getNextWordOffset(	123	int nextOffset = bc.getNextWordOffset(

Line 0 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/core/CslDeletedTextInterceptor.java (+87 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.csl.core;
		43
		44	import javax.swing.text.BadLocationException;
		45	import org.netbeans.api.editor.mimelookup.MimePath;
		46	import org.netbeans.api.editor.mimelookup.MimeRegistration;
		47	import org.netbeans.api.editor.mimelookup.MimeRegistrations;
		48	import org.netbeans.modules.csl.api.KeystrokeHandler;
		49	import org.netbeans.modules.csl.api.UiUtils;
		50	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
		51
		52	public class CslDeletedTextInterceptor implements DeletedTextInterceptor {
		53
		54	@Override
		55	public boolean beforeRemove(Context context) throws BadLocationException {
		56	return false;
		57	}
		58
		59	@Override
		60	public void remove(Context context) throws BadLocationException {
		61	}
		62
		63	@Override
		64	public void afterRemove(Context context) throws BadLocationException {
65	if (CslEditorKit.completionSettingEnabled()) {
66	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(context.getDocument(), context.getOffset());
67	if (bracketCompletion != null) {
68	bracketCompletion.charBackspaced(context.getDocument(), context.getComponent().getCaretPosition(), context.getComponent(), context.getText().charAt(0));
69	}
70	}
71	}
72
73	@Override
74	public void cancelled(Context context) {
75	}
76
77	@MimeRegistrations(value = {
78	@MimeRegistration(mimeType = "", service = DeletedTextInterceptor.Factory.class)})
79	public static class Factory implements DeletedTextInterceptor.Factory {
80
81	@Override
82	public DeletedTextInterceptor createDeletedTextInterceptor(MimePath mimePath) {
83	return new CslDeletedTextInterceptor();
84	}
85	}
86
87	}

Lines 51-63 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/core/CslEditorKit.java (-172 / +9 lines)
51	import javax.swing.JMenuItem;	51	import javax.swing.JMenuItem;
52	import javax.swing.KeyStroke;	52	import javax.swing.KeyStroke;
53	import javax.swing.text.BadLocationException;	53	import javax.swing.text.BadLocationException;
54	import javax.swing.text.Caret;
55	import javax.swing.text.Document;	54	import javax.swing.text.Document;
56	import javax.swing.text.EditorKit;	55	import javax.swing.text.EditorKit;
57	import javax.swing.text.JTextComponent;	56	import javax.swing.text.JTextComponent;
58	import javax.swing.text.Keymap;	57	import javax.swing.text.Keymap;
59	import javax.swing.text.TextAction;	58	import javax.swing.text.TextAction;
60	import org.netbeans.api.editor.mimelookup.MimePath;	59	import org.netbeans.api.editor.mimelookup.MimePath;
		60	import org.netbeans.api.editor.mimelookup.MimeRegistration;
		61	import org.netbeans.api.editor.mimelookup.MimeRegistrations;
61	import org.netbeans.editor.BaseAction;	62	import org.netbeans.editor.BaseAction;
62	import org.netbeans.editor.BaseDocument;	63	import org.netbeans.editor.BaseDocument;
63	import org.netbeans.editor.BaseKit;	64	import org.netbeans.editor.BaseKit;
Lines 69-75 Link Here
69	import org.netbeans.modules.csl.api.CslActions;	70	import org.netbeans.modules.csl.api.CslActions;
70	import org.netbeans.modules.csl.api.DeleteToNextCamelCasePosition;	71	import org.netbeans.modules.csl.api.DeleteToNextCamelCasePosition;
71	import org.netbeans.modules.csl.api.DeleteToPreviousCamelCasePosition;	72	import org.netbeans.modules.csl.api.DeleteToPreviousCamelCasePosition;
72	import org.netbeans.modules.csl.api.GoToDeclarationAction;
73	import org.netbeans.modules.csl.api.InstantRenameAction;	73	import org.netbeans.modules.csl.api.InstantRenameAction;
74	import org.netbeans.modules.csl.api.KeystrokeHandler;	74	import org.netbeans.modules.csl.api.KeystrokeHandler;
75	import org.netbeans.modules.csl.api.NextCamelCasePosition;	75	import org.netbeans.modules.csl.api.NextCamelCasePosition;
Lines 82-90 Link Here
82	import org.netbeans.modules.csl.api.UiUtils;	82	import org.netbeans.modules.csl.api.UiUtils;
83	import org.netbeans.modules.csl.api.GoToMarkOccurrencesAction;	83	import org.netbeans.modules.csl.api.GoToMarkOccurrencesAction;
84	import org.netbeans.modules.editor.NbEditorKit;	84	import org.netbeans.modules.editor.NbEditorKit;
		85	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor;
		86	import org.netbeans.spi.editor.typinghooks.DeletedTextInterceptor.Context;
		87	import org.netbeans.spi.editor.typinghooks.TypedBreakInterceptor;
		88	import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor;
		89	import org.netbeans.spi.editor.typinghooks.TypedTextInterceptor.MutableContext;
85	import org.openide.awt.Mnemonics;	90	import org.openide.awt.Mnemonics;
86	import org.openide.filesystems.FileObject;	91	import org.openide.filesystems.FileObject;
87	import org.openide.util.Exceptions;
88	import org.openide.util.NbBundle;	92	import org.openide.util.NbBundle;
89		93
90	/**	94	/**
Lines 164-173 Link Here
164	Action[] superActions = super.createActions();	168	Action[] superActions = super.createActions();
165	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(mimeType);	169	Language language = LanguageRegistry.getInstance().getLanguageByMimeType(mimeType);
166	ArrayList<Action> actions = new ArrayList<Action>(30);	170	ArrayList<Action> actions = new ArrayList<Action>(30);
167
168	actions.add(new GsfDefaultKeyTypedAction());
169	actions.add(new GsfInsertBreakAction());
170	actions.add(new GsfDeleteCharAction(deletePrevCharAction, false));
171		171
172	// The php needs to handle special cases of toggle comment. There has to be	172	// The php needs to handle special cases of toggle comment. There has to be
173	// registered ToggleBlockCommentAction in PHP that handles these special cases,	173	// registered ToggleBlockCommentAction in PHP that handles these special cases,
Lines 226-397 Link Here
226	/**	226	/**
227	* Returns true if bracket completion is enabled in options.	227	* Returns true if bracket completion is enabled in options.
228	*/	228	*/
229	private static boolean completionSettingEnabled() {	229	static boolean completionSettingEnabled() {
230	//return ((Boolean)Settings.getValue(GsfEditorKit.class, JavaSettingsNames.PAIR_CHARACTERS_COMPLETION)).booleanValue();	230	//return ((Boolean)Settings.getValue(GsfEditorKit.class, JavaSettingsNames.PAIR_CHARACTERS_COMPLETION)).booleanValue();
231	return true;	231	return true;
232	}	232	}
233		233
234	private final class GsfDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {
235	private JTextComponent currentTarget;
236	private String replacedText = null;
237
238	@Override
239	public void actionPerformed(ActionEvent evt, JTextComponent target) {
240	currentTarget = target;
241	super.actionPerformed(evt, target);
242	currentTarget = null;
243	}
244
245	@Override
246	protected void insertString(BaseDocument doc, int dotPos, Caret caret, String str,
247	boolean overwrite) throws BadLocationException {
248	if (completionSettingEnabled()) {
249	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
250
251	if (bracketCompletion != null) {
252	// TODO - check if we're in a comment etc. and if so, do nothing
253	boolean handled =
254	bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget,
255	str.charAt(0));
256
257	if (!handled) {
258	super.insertString(doc, dotPos, caret, str, overwrite);
259	handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget,
260	str.charAt(0));
261	}
262
263	return;
264	}
265	}
266
267	super.insertString(doc, dotPos, caret, str, overwrite);
268	}
269
270	@Override
271	protected void replaceSelection(JTextComponent target, int dotPos, Caret caret,
272	String str, boolean overwrite) throws BadLocationException {
273	if (str.equals("")) {
274	return;
275	}
276	char insertedChar = str.charAt(0);
277	Document document = target.getDocument();
278
279	if (document instanceof BaseDocument) {
280	BaseDocument doc = (BaseDocument)document;
281
282	if (completionSettingEnabled()) {
283	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
284
285	if (bracketCompletion != null) {
286	try {
287	int caretPosition = caret.getDot();
288
289	boolean handled =
290	bracketCompletion.beforeCharInserted(doc, caretPosition,
291	target, insertedChar);
292
293	int p0 = Math.min(caret.getDot(), caret.getMark());
294	int p1 = Math.max(caret.getDot(), caret.getMark());
295
296	if (p0 != p1) {
297	doc.remove(p0, p1 - p0);
298	}
299
300	if (!handled) {
301	if ((str != null) && (str.length() > 0)) {
302	doc.insertString(p0, str, null);
303	}
304
305	bracketCompletion.afterCharInserted(doc, caret.getDot() - 1,
306	target, insertedChar);
307	}
308	} catch (BadLocationException e) {
309	e.printStackTrace();
310	}
311
312	return;
313	}
314	}
315	}
316
317	super.replaceSelection(target, dotPos, caret, str, overwrite);
318	}
319	}
320
321	private final class GsfInsertBreakAction extends InsertBreakAction {
322	static final long serialVersionUID = -1506173310438326380L;
323
324	@Override
325	protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
326	if (completionSettingEnabled()) {
327	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, caret.getDot());
328
329	if (bracketCompletion != null) {
330	try {
331	int newOffset = bracketCompletion.beforeBreak(doc, caret.getDot(), target);
332
333	if (newOffset >= 0) {
334	return new Integer(newOffset);
335	}
336	} catch (BadLocationException ble) {
337	Exceptions.printStackTrace(ble);
338	}
339	}
340	}
341
342	// return Boolean.TRUE;
343	return null;
344	}
345
346	@Override
347	protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret,
348	Object cookie) {
349	if (completionSettingEnabled()) {
350	if (cookie != null) {
351	if (cookie instanceof Integer) {
352	// integer
353	int dotPos = ((Integer)cookie).intValue();
354	if (dotPos != -1) {
355	caret.setDot(dotPos);
356	} else {
357	int nowDotPos = caret.getDot();
358	caret.setDot(nowDotPos + 1);
359	}
360	}
361	}
362	}
363	}
364	}
365
366	private final class GsfDeleteCharAction extends ExtDeleteCharAction {
367	private JTextComponent currentTarget;
368
369	public GsfDeleteCharAction(String nm, boolean nextChar) {
370	super(nm, nextChar);
371	}
372
373	@Override
374	public void actionPerformed(ActionEvent evt, JTextComponent target) {
375	currentTarget = target;
376	super.actionPerformed(evt, target);
377	currentTarget = null;
378	}
379
380	@Override
381	protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch)
382	throws BadLocationException {
383	if (completionSettingEnabled()) {
384	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
385
386	if (bracketCompletion != null) {
387	boolean success = bracketCompletion.charBackspaced(doc, dotPos, currentTarget, ch);
388	return;
389	}
390	}
391	super.charBackspaced(doc, dotPos, caret, ch);
392	}
393	}
394
395	private final class GenericGenerateGoToPopupAction extends NbGenerateGoToPopupAction {	234	private final class GenericGenerateGoToPopupAction extends NbGenerateGoToPopupAction {
396	@Override	235	@Override
397	public void actionPerformed(ActionEvent evt, JTextComponent target) {	236	public void actionPerformed(ActionEvent evt, JTextComponent target) {
Lines 501-506 Link Here
501	return jm;	340	return jm;
502	}	341	}
503	}	342	}
504
505
506	}	343	}

Line 0 Link Here

(-)a/csl.api/test/unit/src/org/netbeans/modules/csl/editor/TypingCompletion.java (+199 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.csl.editor;
		43
		44	import java.awt.EventQueue;
		45	import java.awt.event.KeyEvent;
		46	import javax.swing.JEditorPane;
		47	import javax.swing.SwingUtilities;
		48	import javax.swing.text.BadLocationException;
		49	import javax.swing.text.Document;
		50	import javax.swing.text.EditorKit;
		51	import junit.framework.TestCase;
		52	import org.netbeans.api.lexer.Language;
		53	import org.netbeans.lib.editor.util.CharSequenceUtilities;
		54	import org.openide.filesystems.FileObject;
		55	import org.openide.filesystems.MIMEResolver;
		56	import org.openide.util.lookup.ServiceProvider;
		57
		58	/**
		59	* Test brackets completion - unlike the original test this one
		60	* emulates real typing and tests the resulting state of the document.
		61	*/
		62	public class TypingCompletion {
		63	public static final class Context {
		64
65	private JEditorPane pane;
66
67	public Context(final EditorKit kit, final Language language, final String mimetype, final String textWithPipe) {
68	try {
69	SwingUtilities.invokeAndWait(new Runnable() {
70	@Override
71	public void run() {
72	pane = new JEditorPane();
73	pane.setEditorKit(kit);
74	Document doc = pane.getDocument();
75	// Required by Java's default key typed
76	doc.putProperty(Language.class, language);
77	doc.putProperty("mimeType", mimetype);
78	int caretOffset = textWithPipe.indexOf('\|');
79	String text;
80	if (caretOffset != -1) {
81	text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
82	} else {
83	text = textWithPipe;
84	}
85	pane.setText(text);
86	pane.setCaretPosition((caretOffset != -1) ? caretOffset : doc.getLength());
87	}
88	});
89	} catch (Exception e) {
90	throw new IllegalStateException(e);
91	}
92	}
93
94	public JEditorPane pane() {
95	return pane;
96	}
97
98	public Document document() {
99	return pane.getDocument();
100	}
101
102	public void typeChar(final char ch) {
103	try {
104	SwingUtilities.invokeAndWait(new Runnable() {
105	@Override
106	public void run() {
107	KeyEvent keyEvent;
108	switch (ch) {
109	case '\n':
110	keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
111	EventQueue.getMostRecentEventTime(),
112	0, KeyEvent.VK_ENTER, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Enter
113	break;
114	case '\b':
115	keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
116	EventQueue.getMostRecentEventTime(),
117	0, KeyEvent.VK_BACK_SPACE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of BackSpace
118	break;
119	case '\f':
120	keyEvent = new KeyEvent(pane, KeyEvent.KEY_PRESSED,
121	EventQueue.getMostRecentEventTime(),
122	0, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED); // Simulate pressing of Delete
123	break;
124	default:
125	keyEvent = new KeyEvent(pane, KeyEvent.KEY_TYPED,
126	EventQueue.getMostRecentEventTime(),
127	0, KeyEvent.VK_UNDEFINED, ch);
128	}
129	SwingUtilities.processKeyBindings(keyEvent);
130	}
131	});
132	} catch (Exception e) {
133	throw new IllegalStateException(e);
134	}
135	}
136
137	public void typeText(String text) {
138	for (int i = 0; i < text.length(); i++) {
139	typeChar(text.charAt(i));
140	}
141	}
142
143	public void assertDocumentTextEquals(final String textWithPipe) {
144	try {
145	SwingUtilities.invokeAndWait(new Runnable() {
146	@Override
147	public void run() {
148	int caretOffset = textWithPipe.indexOf('\|');
149	String text;
150	if (caretOffset != -1) {
151	text = textWithPipe.substring(0, caretOffset) + textWithPipe.substring(caretOffset + 1);
152	} else {
153	text = textWithPipe;
154	}
155	try {
156	// Use debug text to prefix special chars for easier readability
157	text = CharSequenceUtilities.debugText(text);
158	String docText = document().getText(0, document().getLength());
159	docText = CharSequenceUtilities.debugText(docText);
160	if (!text.equals(docText)) {
161	int diffIndex = 0;
162	int minLen = Math.min(docText.length(), text.length());
163	while (diffIndex < minLen) {
164	if (text.charAt(diffIndex) != docText.charAt(diffIndex)) {
165	break;
166	}
167	diffIndex++;
168	}
169	TestCase.fail("Invalid document text - diff at index " + diffIndex +
170	"\nExpected: \"" + text +
171	"\"\n Actual: \"" + docText + "\""
172	);
173	}
174	} catch (BadLocationException e) {
175	throw new IllegalStateException(e);
176	}
177	if (caretOffset != -1) {
178	TestCase.assertEquals("Invalid caret offset", caretOffset, pane.getCaretPosition());
179	}
180	}
181	});
182	} catch (Exception e) {
183	throw new IllegalStateException(e);
184	}
185	}
186	}
187
188	@ServiceProvider(service=MIMEResolver.class)
189	public static final class MIMEResolverImpl extends MIMEResolver {
190
191	public MIMEResolverImpl() {
192	super("text/x-nbeditor-keybindingsettings");
193	}
194
195	@Override public String findMIMEType(FileObject fo) {
196	return fo.getPath().contains("Keybindings") ? "text/x-nbeditor-keybindingsettings" : null;
197	}
198	}
199	}

Lines 123-147 Link Here

(-)a/html.editor/src/org/netbeans/modules/html/editor/api/HtmlKit.java (-199 lines)
123	c.setTransferHandler(new HtmlTransferHandler());	123	c.setTransferHandler(new HtmlTransferHandler());
124	}	124	}
125		125
126	protected DeleteCharAction createDeletePrevAction() {
127	return new HtmlDeleteCharAction(deletePrevCharAction, false);
128	}
129
130	protected ExtDefaultKeyTypedAction createDefaultKeyTypedAction() {
131	return new HtmlDefaultKeyTypedAction();
132	}
133
134	protected InsertBreakAction createInsertBreakAction() {
135	return new HtmlInsertBreakAction();
136	}
137		126
138	@Override	127	@Override
139	protected Action[] createActions() {	128	protected Action[] createActions() {
140	Action[] HtmlActions = new Action[]{	129	Action[] HtmlActions = new Action[]{
141	createInsertBreakAction(),
142	createDefaultKeyTypedAction(),
143	createDeletePrevAction(),
144	new HtmlDeleteCharAction(deleteNextCharAction, true),
145	CslActions.createSelectCodeElementAction(true),	130	CslActions.createSelectCodeElementAction(true),
146	CslActions.createSelectCodeElementAction(false),	131	CslActions.createSelectCodeElementAction(false),
147	CslActions.createInstantRenameAction(),	132	CslActions.createInstantRenameAction(),
Lines 370-559 Link Here
370	}	355	}
371	}	356	}
372		357
373
374	public class HtmlInsertBreakAction extends InsertBreakAction {
375
376	static final long serialVersionUID = -1506173310438326380L;
377
378	@Override
379	protected Object beforeBreak(JTextComponent target, BaseDocument doc, Caret caret) {
380	if (completionSettingEnabled()) {
381	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, caret.getDot());
382
383	if (bracketCompletion != null) {
384	try {
385	int newOffset = bracketCompletion.beforeBreak(doc, caret.getDot(), target);
386
387	if (newOffset >= 0) {
388	return new Integer(newOffset);
389	}
390	} catch (BadLocationException ble) {
391	Exceptions.printStackTrace(ble);
392	}
393	}
394	}
395
396	// return Boolean.TRUE;
397	return null;
398	}
399
400	@Override
401	protected void afterBreak(JTextComponent target, BaseDocument doc, Caret caret,
402	Object cookie) {
403	if (completionSettingEnabled()) {
404	if (cookie != null) {
405	if (cookie instanceof Integer) {
406	// integer
407	int dotPos = ((Integer) cookie).intValue();
408	if (dotPos != -1) {
409	caret.setDot(dotPos);
410	} else {
411	int nowDotPos = caret.getDot();
412	caret.setDot(nowDotPos + 1);
413	}
414	}
415	}
416	}
417	}
418	}
419
420	public static class HtmlDefaultKeyTypedAction extends ExtDefaultKeyTypedAction {
421
422	private JTextComponent currentTarget;
423
424	@Override
425	public void actionPerformed(ActionEvent evt, JTextComponent target) {
426	currentTarget = target;
427	super.actionPerformed(evt, target);
428	currentTarget = null;
429	}
430
431	@Override
432	protected void insertString(BaseDocument doc, int dotPos,
433	Caret caret, String str,
434	boolean overwrite) throws BadLocationException {
435
436	if (completionSettingEnabled()) {
437	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
438
439	if (bracketCompletion != null) {
440	// TODO - check if we're in a comment etc. and if so, do nothing
441	boolean handled =
442	bracketCompletion.beforeCharInserted(doc, dotPos, currentTarget,
443	str.charAt(0));
444
445	if (!handled) {
446	super.insertString(doc, dotPos, caret, str, overwrite);
447	handled = bracketCompletion.afterCharInserted(doc, dotPos, currentTarget,
448	str.charAt(0));
449	}
450
451
452	return;
453	}
454	}
455
456	super.insertString(doc, dotPos, caret, str, overwrite);
457	}
458
459	@Override
460	protected void replaceSelection(JTextComponent target, int dotPos, Caret caret,
461	String str, boolean overwrite) throws BadLocationException {
462
463	//workaround for #209019 - regression of issue
464	//#204450 - Rewrite actions to use TypingHooks SPI
465	if(str.length() == 0) {
466	//called from BaseKit.actionPerformed():1160 with empty str argument
467	//==> ignore this call since we are going to be called a bit later
468	//from HtmlKit.performTextInsertion() properly with the text typed
469	return ;
470	}
471
472	char insertedChar = str.charAt(0);
473	Document document = target.getDocument();
474
475	if (document instanceof BaseDocument) {
476	BaseDocument doc = (BaseDocument) document;
477
478	if (completionSettingEnabled()) {
479	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
480
481	if (bracketCompletion != null) {
482	try {
483	int caretPosition = caret.getDot();
484
485	boolean handled =
486	bracketCompletion.beforeCharInserted(doc, caretPosition,
487	target, insertedChar);
488
489	int p0 = Math.min(caret.getDot(), caret.getMark());
490	int p1 = Math.max(caret.getDot(), caret.getMark());
491
492	if (p0 != p1) {
493	doc.remove(p0, p1 - p0);
494	}
495
496	if (!handled) {
497	if ((str != null) && (str.length() > 0)) {
498	doc.insertString(p0, str, null);
499	}
500
501	bracketCompletion.afterCharInserted(doc, caret.getDot() - 1,
502	target, insertedChar);
503
504	}
505	} catch (BadLocationException e) {
506	e.printStackTrace();
507	}
508
509	return;
510	}
511	}
512	}
513
514	super.replaceSelection(target, dotPos, caret, str, overwrite);
515	}
516
517	}
518
519	public static class HtmlDeleteCharAction extends DeleteCharAction {
520
521	private JTextComponent currentTarget;
522
523	public HtmlDeleteCharAction(String name, boolean nextChar) {
524	super(name, nextChar);
525	}
526
527	@Override
528	public void actionPerformed(ActionEvent evt, JTextComponent target) {
529	try {
530	currentTarget = target;
531	super.actionPerformed(evt, target);
532	} finally {
533	currentTarget = null;
534	}
535	}
536
537	@Override
538	protected void charBackspaced(BaseDocument doc, int dotPos, Caret caret, char ch) throws BadLocationException {
539	if (completionSettingEnabled()) {
540	KeystrokeHandler bracketCompletion = UiUtils.getBracketCompletion(doc, dotPos);
541
542	if (bracketCompletion != null) {
543	boolean success = bracketCompletion.charBackspaced(doc, dotPos, currentTarget, ch);
544	return;
545	}
546	}
547
548
549	super.charBackspaced(doc, dotPos, caret, ch);
550	}
551
552	public boolean getNextChar() {
553	return nextChar;
554	}
555	}
556
557	/* !!!!!!!!!!!!!!!!!!!!!	358	/* !!!!!!!!!!!!!!!!!!!!!
558	*	359	*
559	* Inner classes bellow were taken from BasicTextUI and rewritten in the place marked	360	* Inner classes bellow were taken from BasicTextUI and rewritten in the place marked

Line 0 Link Here

(-)a/web.core.syntax/test/unit/src/org/netbeans/modules/web/core/syntax/TypingCompletionUnitTest.java (+114 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 1997-2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* Contributor(s):
		28	*
		29	* The Original Software is NetBeans. The Initial Developer of the Original
		30	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2011 Sun
		31	* Microsystems, Inc. All Rights Reserved.
		32	*
		33	* If you wish your version of this file to be governed by only the CDDL
		34	* or only the GPL Version 2, indicate your decision by adding
		35	* "[Contributor] elects to include this software in this distribution
		36	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		37	* single choice of license, a recipient has the option to distribute
		38	* your version of this file under either the CDDL, the GPL Version 2 or
		39	* to extend the choice of license to its licensees as provided above.
		40	* However, if you add GPL Version 2 code and therefore, elected the GPL
		41	* Version 2 license, then the option applies only if the new code is
		42	* made subject to such option by the copyright holder.
		43	*/
		44
		45	package org.netbeans.modules.web.core.syntax;
		46
		47	import org.netbeans.modules.csl.editor.TypingCompletion.Context;
		48	import java.util.prefs.Preferences;
		49	import org.netbeans.api.editor.mimelookup.MimeLookup;
		50	import org.netbeans.api.editor.settings.SimpleValueNames;
		51	import org.netbeans.api.jsp.lexer.JspTokenId;
		52	import org.netbeans.junit.NbTestCase;
		53	import org.netbeans.modules.csl.core.CslEditorKit;
		54	import org.openide.awt.AcceleratorBinding;
		55
		56
		57	/**
		58	* Test brackets completion - unlike the original test this one
		59	* emulates real typing and tests the resulting state of the document.
		60	*/
		61	public class TypingCompletionUnitTest extends NbTestCase {
		62
		63	public TypingCompletionUnitTest(String testMethodName) {
		64	super(testMethodName);
65	}
66
67	@Override
68	protected void setUp() throws Exception {
69	super.setUp();
70	Preferences prefs = MimeLookup.getLookup(JspKit.JSP_MIME_TYPE).lookup(Preferences.class);
71	prefs.putBoolean(SimpleValueNames.COMPLETION_PAIR_CHARACTERS, true);
72	Class.forName(AcceleratorBinding.class.getName(), true, AcceleratorBinding.class.getClassLoader());
73	}
74
75	public void testBracketCompletion() {
76	Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
77	"<% \| %>"
78	);
79	ctx.typeChar('(');
80	ctx.assertDocumentTextEquals(
81	"<% (\|) %>"
82	);
83	}
84
85	public void testQuoteCompletion() {
86	Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
87	"<% \|"
88	);
89	ctx.typeChar('"');
90	ctx.assertDocumentTextEquals(
91	"<% \"\|\""
92	);
93	}
94
95	public void testDeleteQuote() {
96	Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
97	"<% \"\|\" %>"
98	);
99	ctx.typeChar('\b');
100	ctx.assertDocumentTextEquals(
101	"<% \| %>"
102	);
103	}
104
105	public void testIfBreakInsert() {
106	Context ctx = new Context(new CslEditorKit(JspKit.JSP_MIME_TYPE), JspTokenId.language(), JspKit.JSP_MIME_TYPE,
107	"<% \"\|\" %>"
108	);
109	ctx.typeChar('\n');
110	ctx.assertDocumentTextEquals(
111	"<% \"\"\n + \"\|\" %>"
112	);
113	}
114	}