Attachment #158507 for bug #257893

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 257893
Collapse All | Expand All

Lines 962-965 Link Here

(-)a/.hgtags (+2 lines)
962	37fc29481ec42daf8347ecc28cdf38079401b033 release81_beta_base	962	37fc29481ec42daf8347ecc28cdf38079401b033 release81_beta_base
963	ca20d6d4ed09fed2af119a1fd21a2eee31751d9e build_27	963	ca20d6d4ed09fed2af119a1fd21a2eee31751d9e build_27
964	294dca090459562fe1bbe59c5a4e61ab95d24d42 release81_base	964	294dca090459562fe1bbe59c5a4e61ab95d24d42 release81_base
		965	5cf4b63c4b9823e6fc4a8137827c99b8a753d773 editor_multi_caret_stable
965	8d2520b6f9672304f6326258c34ed8d2509e6d2a jdk9ea	966	8d2520b6f9672304f6326258c34ed8d2509e6d2a jdk9ea
		967




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.actions;

import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import org.netbeans.api.editor.EditorActionNames;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.EditorActionRegistrations;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.api.editor.caret.CaretMoveContext;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Utilities;
import org.netbeans.spi.editor.AbstractEditorAction;
import org.netbeans.spi.editor.caret.CaretMoveHandler;

/**
 *
 * @author Ralph Ruijs
 */
@EditorActionRegistrations({
    @EditorActionRegistration(name = EditorActionNames.addSelectionElseCaretUpAction),
    @EditorActionRegistration(name = EditorActionNames.addSelectionElseCaretDownAction)
})
public class AddSelectionElseCaretAction extends AbstractEditorAction {

    @Override
    protected void actionPerformed(ActionEvent evt, final JTextComponent target) {
        if (target != null) {
            Caret caret = target.getCaret();
            if (caret != null && caret instanceof EditorCaret) {
                final EditorCaret editorCaret = (EditorCaret) caret;
                final BaseDocument doc = (BaseDocument) target.getDocument();
                if(EditorActionNames.addSelectionElseCaretUpAction.equals(actionName())) {
                    doc.runAtomicAsUser(new Runnable() {
                        @Override
                        public void run() {
                            final List<Position> dots = new ArrayList<>(editorCaret.getCarets().size() << 1);
                            editorCaret.moveCarets(new CaretMoveHandler() {
                                @Override
                                public void moveCarets(CaretMoveContext context) {
                                    for (org.netbeans.api.editor.caret.CaretInfo caretInfo : context.getOriginalCarets()) {
                                        try {
                                            int dot = caretInfo.getDot();
                                            Point p = caretInfo.getMagicCaretPosition();
                                            if (p == null) {
                                                Rectangle r = target.modelToView(dot);
                                                if (r != null) {
                                                    p = new Point(r.x, r.y);
                                                    context.setMagicCaretPosition(caretInfo, p);
                                                } else {
                                                    return; // model to view failed
                                                }
                                            }
                                            try {
                                                dot = Utilities.getPositionAbove(target, dot, p.x);
                                                Position dotPos = doc.createPosition(dot);
                                                dots.add(dotPos);
                                                dots.add(dotPos);
                                            } catch (BadLocationException e) {
                                                // the position stays the same
                                            }
                                        } catch (BadLocationException ex) {
                                            target.getToolkit().beep();
                                        }
                                    }
                                }
                            });

                            editorCaret.addCarets(dots);
                        }
                    });
                } else {
                    doc.runAtomicAsUser(new Runnable() {
                        @Override
                        public void run() {
                            final List<Position> dots = new ArrayList<>(editorCaret.getCarets().size() << 1);
                            editorCaret.moveCarets(new CaretMoveHandler() {
                                @Override
                                public void moveCarets(CaretMoveContext context) {
                                    for (org.netbeans.api.editor.caret.CaretInfo caretInfo : context.getOriginalCarets()) {
                                        try {
                                            int dot = caretInfo.getDot();
                                            Point p = caretInfo.getMagicCaretPosition();
                                            if (p == null) {
                                                Rectangle r = target.modelToView(dot);
                                                if (r != null) {
                                                    p = new Point(r.x, r.y);
                                                    context.setMagicCaretPosition(caretInfo, p);
                                                } else {
                                                    return; // model to view failed
                                                }
                                            }
                                            try {
                                                dot = Utilities.getPositionBelow(target, dot, p.x);
                                                Position dotPos = doc.createPosition(dot);
                                                dots.add(dotPos);
                                                dots.add(dotPos);
                                            } catch (BadLocationException e) {
                                                // position stays the same
                                            }
                                        } catch (BadLocationException ex) {
                                            target.getToolkit().beep();
                                        }
                                    }
                                }
                            });
                            editorCaret.addCarets(dots);
                        }
                    });
                }
            }
        }
    }

}

Lines 52-57 Link Here

(-)a/editor.actions/src/org/netbeans/modules/editor/actions/Bundle.properties (-1 / +6 lines)
52	toggle-line-numbers_menu_text=&Show Line Numbers	52	toggle-line-numbers_menu_text=&Show Line Numbers
53	toggle-non-printable-characters=Toggle Non-printable Characters	53	toggle-non-printable-characters=Toggle Non-printable Characters
54	toggle-non-printable-characters_menu_text=Show &Non-printable Characters	54	toggle-non-printable-characters_menu_text=Show &Non-printable Characters
		55	toggle-typing-mode=Toggle Typing Mode
55	transpose-letters=Transpose Letters	56	transpose-letters=Transpose Letters
56	goto-declaration=Go to Declaration	57	goto-declaration=Go to Declaration
57	goto-declaration_menu_text=Go to &Declaration	58	goto-declaration_menu_text=Go to &Declaration
Lines 68-71 Link Here
68	caret-previous-word=Insertion Point to Previous Word	69	caret-previous-word=Insertion Point to Previous Word
69	selection-next-word=Extend Selection to Next Word	70	selection-next-word=Extend Selection to Next Word
70	selection-previous-word=Extend Selection to Previous Word	71	selection-previous-word=Extend Selection to Previous Word
71	toggle-lines-view=Show &Indent Guide Lines	72	toggle-lines-view=Show &Indent Guide Lines
		73	remove-last-caret=Remove Last Caret
		74	remove-last-caret_menu_text=Remove Last Caret
		75	add-selection-else-caret-up=Duplicate Insertion Point Up
		76	add-selection-else-caret-down=Duplicate Insertion Point Down




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.actions;

import java.awt.event.ActionEvent;
import javax.swing.text.Caret;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.EditorActionNames;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.EditorActionRegistrations;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.spi.editor.AbstractEditorAction;

/**
 *
 * @author Ralph Ruijs <ralphbenjamin@netbeans.org>
 */
@EditorActionRegistrations({
    @EditorActionRegistration(name = EditorActionNames.removeLastCaret,
                              menuPath = "Edit",
                              menuPosition = 840,
                              menuText = "#" + EditorActionNames.removeLastCaret + "_menu_text")
})
public class RemoveLastCaretAction extends AbstractEditorAction {

    @Override
    protected void actionPerformed(ActionEvent evt, JTextComponent component) {
        Caret caret = component.getCaret();
        if(caret instanceof EditorCaret) {
            EditorCaret editorCaret = (EditorCaret) caret;
            editorCaret.removeLastCaret();
        }
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.actions;

import java.awt.event.ActionEvent;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.EditorActionNames;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.EditorUtilities;
import org.netbeans.spi.editor.AbstractEditorAction;

/**
 * Switch caret from insert mode to overwrite mode or vice versa.
 *
 * @author Miloslav Metelka
 */

@EditorActionRegistration(name = EditorActionNames.toggleTypingMode)
public final class ToggleTypingModeAction extends AbstractEditorAction {

    private static final long serialVersionUID = 1L;

    public ToggleTypingModeAction() {
        super();
    }

    @Override
    public void actionPerformed(ActionEvent evt, JTextComponent target) {
        if (target != null) {
            Boolean overwriteMode = (Boolean) target.getClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY);
            // Now toggle
            overwriteMode = (overwriteMode == null || !overwriteMode) ? Boolean.TRUE : Boolean.FALSE;
            target.putClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY, overwriteMode);
        }
    }

}




<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>
      <change id="ShiftPositions">
          <api name="api"/>
          <summary>Added ShiftPositions</summary>
          <version major="1" minor="7"/>
          <date day="22" month="2" year="2016"/>
          <author login="mmetelka"/>
          <compatibility source="compatible" binary="compatible" semantic="compatible" addition="yes"/>
          <description>
              <p>
                  Added ShiftPositions class to create and read ShiftPositions.
                  The implementation ShiftPos is a position together with a 
                  shift of extra columns. This allows for positions behind
                  line's last character (newline) or within a tab character.
              </p>
          </description>
          <class name="ShiftPositions" package="org.netbeans.api.editor.document"/>
          <issue number="257889"/>
      </change>
      <change id="TextSearchUtils-getPreviousWordStart">
          <api name="api"/>
          <summary>Added TextSearchUtils.getPreviousWordStart() method</summary>

Lines 1-6 Link Here

(-)a/editor.document/nbproject/project.properties (-1 / +1 lines)
1	javac.source=1.7	1	javac.source=1.7
2	javac.compilerargs=-Xlint -Xlint:-serial	2	javac.compilerargs=-Xlint -Xlint:-serial
3	spec.version.base=1.6.0	3	spec.version.base=1.7.0
4	javadoc.arch=${basedir}/arch.xml	4	javadoc.arch=${basedir}/arch.xml
5	javadoc.apichanges=${basedir}/apichanges.xml	5	javadoc.apichanges=${basedir}/apichanges.xml
6	is.autoload=true	6	is.autoload=true




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.document;

import javax.swing.text.Position;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.modules.editor.lib2.document.ShiftPos;
import org.openide.util.Parameters;

/**
 * A position together with a shift of extra columns.
 * This allows for positions behind line's last character (newline) or within a tab character.
 *
 * @author Miloslav Metelka
 * @since 1.7
 */
public final class ShiftPositions {

    private ShiftPositions() {
        // No instances
    }
    
    /**
     * Produce an immutable shift position.
     * The returned position acts like the original position and it does not handle in any way
     * any subsequent document modifications.
     *
     * @param pos non-null position. If this is already a shift position its shift
     *  gets added to the shift parameter passed to this method.
     * @param shift >= 0 number of extra columns added to the position.
     *  For 0 the original position gets returned. Negative value throws an IllegalArgumentException.
     * @return virtual position whose {@link Position#getOffset()} returns the same value
     *  like the getPosition parameter.
     */
    public static Position create(@NonNull Position pos, int shift) {
        Parameters.notNull("pos", pos);   //NOI18N
        if (shift > 0) {
            if (pos.getClass() == ShiftPos.class) {
                return new ShiftPos((ShiftPos)pos, shift);
            } else {
                return new ShiftPos(pos, shift);
            }
        } else if (shift == 0) {
            return pos;
        } else {
            throw new IllegalArgumentException("shift=" + shift + " < 0");
        }
    }

    /**
     * Return shift of a passed virtual position or zero for regular positions.
     * @param pos non-null position.
     * @return >=0 shift or zero for regular positions.
     */
    public static int getShift(@NonNull Position pos) {
        return getShiftImpl(pos);
    }

    /**
     * Compare positions.
     * @param pos1 non-null position.
     * @param pos2 non-null position.
     * @return offset of pos1 minus offset of pos2 or diff of their shifts in case
     *  both positions have the same offset.
     * @NullPointerException if any passed position is null unless both positions are null
     *  in which case the method would return 0.
     */
    public static int compare(@NonNull Position pos1, @NonNull Position pos2) {
        if (pos1 == pos2) {
            return 0;
        }
        int offsetDiff = pos1.getOffset() - pos2.getOffset();
        return (offsetDiff != 0) ? offsetDiff : getShiftImpl(pos1) - getShiftImpl(pos2);
    }
    
    /**
     * Compare positions by providing their offsets and shifts obtained earlier.
     * @param offset1 offset of first position.
     * @param shift1 shift of first position.
     * @param offset2 offset of second position.
     * @param shift2 shift of second position.
     * @return offset1 minus offset2 or shift1 minus shift2 in case
     *  offset1 and offset2 are equal.
     */
    public static int compare(int offset1, int shift1, int offset2, int shift2) {
        int offsetDiff = offset1 - offset2;
        return (offsetDiff != 0) ? offsetDiff : shift1 - shift2;
    }
    
    private static int getShiftImpl(Position pos) {
        return (pos.getClass() == ShiftPos.class)
                ? ((ShiftPos)pos).getShift()
                : 0;
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.lib2.document;

import javax.swing.text.Position;


/**
 * Implementation of a shift position. The clients should only use methods
 * in {@link org.netbeans.api.editor.document.ShiftPositions} and never check
 * for an instance of this particular class.
 *
 * @author Miloslav Metelka
 */
public final class ShiftPos implements Position {

    private final Position pos;
    
    private final int shift;

    public ShiftPos(Position pos, int shift) {
        this.pos = pos;
        this.shift = shift;
    }
    
    public ShiftPos(ShiftPos shiftPos, int shift) {
        this.pos = shiftPos.pos;
        this.shift = shiftPos.shift + shift;
    }

    public Position getPosition() {
        return pos;
    }
    
    public int getShift() {
        return shift;
    }

    @Override
    public int getOffset() {
        return pos.getOffset();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.document;

import javax.swing.text.Document;
import javax.swing.text.PlainDocument;
import javax.swing.text.Position;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 *
 * @author Miloslav Metelka
 */
public class ShiftPositionsTest {
    
    public ShiftPositionsTest() {
    }

    @Test
    public void testPos() throws Exception {
        Document doc = new PlainDocument();
        doc.insertString(0, "\t\t\n\n", null);
        Position pos1 = doc.createPosition(1);
        Position pos2 = doc.createPosition(2);
        
        Position pos10 = ShiftPositions.create(pos1, 0);
        Position pos11 = ShiftPositions.create(pos1, 1);
        Position pos20 = ShiftPositions.create(pos2, 0);
        Position pos21 = ShiftPositions.create(pos2, 1);
        
        assertEquals(0, ShiftPositions.getShift(pos1));
        assertEquals(0, ShiftPositions.getShift(pos10));
        assertEquals(1, ShiftPositions.getShift(pos11));
        comparePos(pos1, pos10, 0);
        comparePos(pos10, pos11, -1);
        comparePos(pos1, pos2, -1);
        comparePos(pos10, pos20, -1);
        comparePos(pos20, pos21, -1);
    }
    
    private void comparePos(Position pos1, Position pos2, int expectedResult) {
        comparePosImpl(pos1, pos2, expectedResult, true);
    }

    private void comparePosImpl(Position pos1, Position pos2, int expectedResult, boolean reverseCompare) {
        int result = ShiftPositions.compare(pos1, pos2);
        assertEquals("Invalid result=" + result + " when comparing positions pos1=" +
                pos1 + " to pos2=" + pos2, expectedResult, result);

        result = ShiftPositions.compare(pos1.getOffset(), ShiftPositions.getShift(pos1),
                pos2.getOffset(), ShiftPositions.getShift(pos2));
        assertEquals("Invalid result=" + result + " when comparing positions pos1=" +
                pos1 + " to pos2=" + pos2, expectedResult, result);

        if (reverseCompare) {
            comparePosImpl(pos2, pos1, -expectedResult, false);
        }
    }

}

Lines 84-89 Link Here

(-)a/editor.errorstripe/nbproject/project.xml (+9 lines)
84	</run-dependency>	84	</run-dependency>
85	</dependency>	85	</dependency>
86	<dependency>	86	<dependency>
		87	<code-name-base>org.netbeans.modules.editor.lib2</code-name-base>
		88	<build-prerequisite/>
		89	<compile-dependency/>
		90	<run-dependency>
		91	<release-version>1</release-version>
		92	<specification-version>2.5</specification-version>
		93	</run-dependency>
		94	</dependency>
		95	<dependency>
87	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>	96	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
88	<build-prerequisite/>	97	<build-prerequisite/>
89	<compile-dependency/>	98	<compile-dependency/>





package org.netbeans.modules.editor.errorstripe.caret;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.StyledDocument;
import org.netbeans.api.editor.caret.CaretInfo;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.modules.editor.errorstripe.privatespi.Mark;
import org.netbeans.modules.editor.errorstripe.privatespi.MarkProvider;
import org.openide.text.NbDocument;

    
    private static final RequestProcessor RP = new RequestProcessor("CaretMarkProvider");
    
    private List<Mark> marks;
    private JTextComponent component;
    
    /** Creates a new instance of AnnotationMarkProvider */
    public CaretMarkProvider(JTextComponent component) {
        this.component = component;
        component.addCaretListener(this);
        marks = createMarks();
    }

    private List<Mark> createMarks() {
        int offset = component.getCaretPosition(); //TODO: AWT?
        Document doc = component.getDocument();
        if(!(doc instanceof StyledDocument)) {
            return Collections.singletonList((Mark)new CaretMark(0));
        if (doc instanceof StyledDocument) {
            line = NbDocument.findLineNumber((StyledDocument) doc, offset);
        }
        List<Mark> lines = new LinkedList<>();
        Caret caret = component.getCaret();
        if(caret instanceof EditorCaret) {
            EditorCaret editorCaret = (EditorCaret) caret;
            for (CaretInfo caretInfo : editorCaret.getCarets()) {
                int offset = caretInfo.getDot();
                int line = NbDocument.findLineNumber((StyledDocument) doc, offset);
                lines.add(new CaretMark(line));
            }
        } else {
            int offset = component.getCaretPosition(); //TODO: AWT?
            int line = NbDocument.findLineNumber((StyledDocument) doc, offset);
            lines.add(new CaretMark(line));
        }
        return lines;
    }
    
    @Override
    public synchronized List<Mark> getMarks() {
        return Collections.unmodifiableList(marks);
    }

    @Override
    public void caretUpdate(CaretEvent e) {
        final List<Mark> old = getMarks();
        
        marks = createMarks();
        
        final List<Mark> nue = getMarks();
        
        //Do not fire this event under the document's write lock
        //may deadlock with other providers:
        RP.post(new Runnable() {
            @Override
            public void run() {
                firePropertyChange(PROP_MARKS, old, nue);
            }

Lines 46-51 Link Here

(-)a/editor.lib/src/org/netbeans/editor/ActionFactory.java (-5 / +13 lines)
46		46
47	import java.awt.Component;	47	import java.awt.Component;
48	import java.awt.Cursor;	48	import java.awt.Cursor;
		49	import java.awt.Point;
49	import java.awt.Rectangle;	50	import java.awt.Rectangle;
50	import java.awt.Toolkit;	51	import java.awt.Toolkit;
51	import java.awt.event.ActionEvent;	52	import java.awt.event.ActionEvent;
Lines 56-61 Link Here
56	import java.lang.ref.Reference;	57	import java.lang.ref.Reference;
57	import java.lang.ref.WeakReference;	58	import java.lang.ref.WeakReference;
58	import java.text.SimpleDateFormat;	59	import java.text.SimpleDateFormat;
		60	import java.util.ArrayList;
59	import java.util.Arrays;	61	import java.util.Arrays;
60	import java.util.Date;	62	import java.util.Date;
61	import java.util.HashSet;	63	import java.util.HashSet;
Lines 87-95 Link Here
87	import javax.swing.text.AbstractDocument;	89	import javax.swing.text.AbstractDocument;
88	import javax.swing.text.View;	90	import javax.swing.text.View;
89	import javax.swing.undo.UndoManager;	91	import javax.swing.undo.UndoManager;
		92	import org.netbeans.api.editor.caret.CaretInfo;
90	import org.netbeans.api.editor.EditorActionNames;	93	import org.netbeans.api.editor.EditorActionNames;
91	import org.netbeans.api.editor.EditorActionRegistration;	94	import org.netbeans.api.editor.EditorActionRegistration;
92	import org.netbeans.api.editor.EditorActionRegistrations;	95	import org.netbeans.api.editor.EditorActionRegistrations;
		96	import org.netbeans.api.editor.EditorUtilities;
		97	import org.netbeans.api.editor.caret.EditorCaret;
93	import org.netbeans.api.editor.fold.FoldHierarchy;	98	import org.netbeans.api.editor.fold.FoldHierarchy;
94	import org.netbeans.api.lexer.TokenHierarchy;	99	import org.netbeans.api.lexer.TokenHierarchy;
95	import org.netbeans.api.progress.ProgressUtils;	100	import org.netbeans.api.progress.ProgressUtils;
Lines 98-103 Link Here
98	import org.netbeans.modules.editor.indent.api.Indent;	103	import org.netbeans.modules.editor.indent.api.Indent;
99	import org.netbeans.modules.editor.indent.api.Reformat;	104	import org.netbeans.modules.editor.indent.api.Reformat;
100	import org.netbeans.api.editor.NavigationHistory;	105	import org.netbeans.api.editor.NavigationHistory;
		106	import org.netbeans.api.editor.caret.CaretMoveContext;
		107	import org.netbeans.spi.editor.caret.CaretMoveHandler;
101	import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;	108	import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;
102	import org.netbeans.modules.editor.lib2.view.DocumentView;	109	import org.netbeans.modules.editor.lib2.view.DocumentView;
103	import org.netbeans.spi.editor.typinghooks.CamelCaseInterceptor;	110	import org.netbeans.spi.editor.typinghooks.CamelCaseInterceptor;
Lines 105-110 Link Here
105	import org.openide.util.ImageUtilities;	112	import org.openide.util.ImageUtilities;
106	import org.openide.util.Lookup;	113	import org.openide.util.Lookup;
107	import org.openide.util.NbBundle;	114	import org.openide.util.NbBundle;
		115	import org.openide.util.Pair;
108	import org.openide.util.actions.Presenter;	116	import org.openide.util.actions.Presenter;
109		117
110	/**	118	/**
Lines 854-861 Link Here
854	}	862	}
855	}	863	}
856		864
857	/** Switch to overwrite mode or back to insert mode */	865	/** Switch to overwrite mode or back to insert mode
858	@EditorActionRegistration(name = BaseKit.toggleTypingModeAction)	866	* @deprecated Replaced by ToggleTypingModeAction in editor.actions module
		867	*/
859	public static class ToggleTypingModeAction extends LocalBaseAction {	868	public static class ToggleTypingModeAction extends LocalBaseAction {
860		869
861	static final long serialVersionUID =-2431132686507799723L;	870	static final long serialVersionUID =-2431132686507799723L;
Lines 866-877 Link Here
866		875
867	public void actionPerformed(ActionEvent evt, JTextComponent target) {	876	public void actionPerformed(ActionEvent evt, JTextComponent target) {
868	if (target != null) {	877	if (target != null) {
869	EditorUI editorUI = Utilities.getEditorUI(target);	878	Boolean overwriteMode = (Boolean) target.getClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY);
870	Boolean overwriteMode = (Boolean)editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);
871	// Now toggle	879	// Now toggle
872	overwriteMode = (overwriteMode == null \|\| !overwriteMode.booleanValue())	880	overwriteMode = (overwriteMode == null \|\| !overwriteMode.booleanValue())
873	? Boolean.TRUE : Boolean.FALSE;	881	? Boolean.TRUE : Boolean.FALSE;
874	editorUI.putProperty(EditorUI.OVERWRITE_MODE_PROPERTY, overwriteMode);	882	target.putClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY, overwriteMode);
875	}	883	}
876	}	884	}
877	}	885	}




    /** Caret type representing block covering current character */
    public static final String BLOCK_CARET = EditorPreferencesDefaults.BLOCK_CARET; // NOI18N

    /** Default caret type */
    public static final String LINE_CARET = EditorPreferencesDefaults.LINE_CARET; // NOI18N

    /** One dot thin line compatible with Swing default caret */
    public static final String THIN_LINE_CARET = EditorPreferencesDefaults.THIN_LINE_CARET; // NOI18N

    /** @since 1.23 */
    public static final String THICK_LINE_CARET = EditorPreferencesDefaults.THICK_LINE_CARET; // NOI18N

    /** Default caret type */
    public static final String LINE_CARET = THICK_LINE_CARET; // NOI18N

    /** Boolean property defining whether selection is being rectangular in a particular text component. */
    private static final String RECTANGULAR_SELECTION_PROPERTY = "rectangular-selection"; // NOI18N

Lines 59-64 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseKit.java (-165 / +938 lines)
59	import java.util.Iterator;	59	import java.util.Iterator;
60	import java.util.List;	60	import java.util.List;
61	import java.util.ArrayList;	61	import java.util.ArrayList;
		62	import java.util.LinkedList;
62	import java.util.prefs.PreferenceChangeEvent;	63	import java.util.prefs.PreferenceChangeEvent;
63	import javax.swing.Action;	64	import javax.swing.Action;
64	import javax.swing.InputMap;	65	import javax.swing.InputMap;
Lines 88-98 Link Here
88	import javax.swing.event.ChangeListener;	89	import javax.swing.event.ChangeListener;
89	import javax.swing.plaf.TextUI;	90	import javax.swing.plaf.TextUI;
90	import javax.swing.text.AbstractDocument;	91	import javax.swing.text.AbstractDocument;
		92	import static javax.swing.text.DefaultEditorKit.selectionBackwardAction;
		93	import static javax.swing.text.DefaultEditorKit.selectionBeginLineAction;
		94	import static javax.swing.text.DefaultEditorKit.selectionDownAction;
		95	import static javax.swing.text.DefaultEditorKit.selectionEndLineAction;
		96	import static javax.swing.text.DefaultEditorKit.selectionForwardAction;
		97	import static javax.swing.text.DefaultEditorKit.selectionUpAction;
91	import javax.swing.text.EditorKit;	98	import javax.swing.text.EditorKit;
92	import javax.swing.text.Position;	99	import javax.swing.text.Position;
93	import javax.swing.text.View;	100	import javax.swing.text.View;
		101	import javax.swing.undo.AbstractUndoableEdit;
		102	import javax.swing.undo.CannotRedoException;
		103	import javax.swing.undo.CannotUndoException;
		104	import org.netbeans.api.editor.caret.CaretInfo;
94	import org.netbeans.api.editor.EditorActionRegistration;	105	import org.netbeans.api.editor.EditorActionRegistration;
95	import org.netbeans.api.editor.EditorActionRegistrations;	106	import org.netbeans.api.editor.EditorActionRegistrations;
		107	import org.netbeans.api.editor.caret.EditorCaret;
96	import org.netbeans.api.editor.mimelookup.MimeLookup;	108	import org.netbeans.api.editor.mimelookup.MimeLookup;
97	import org.netbeans.api.editor.mimelookup.MimePath;	109	import org.netbeans.api.editor.mimelookup.MimePath;
98	import org.netbeans.api.editor.settings.KeyBindingSettings;	110	import org.netbeans.api.editor.settings.KeyBindingSettings;
Lines 108-115 Link Here
108	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;	120	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;
109	import org.netbeans.modules.editor.lib.KitsTracker;	121	import org.netbeans.modules.editor.lib.KitsTracker;
110	import org.netbeans.api.editor.NavigationHistory;	122	import org.netbeans.api.editor.NavigationHistory;
		123	import org.netbeans.api.editor.caret.CaretMoveContext;
		124	import org.netbeans.spi.editor.caret.CaretMoveHandler;
111	import org.netbeans.lib.editor.util.swing.PositionRegion;	125	import org.netbeans.lib.editor.util.swing.PositionRegion;
112	import org.netbeans.modules.editor.lib.SettingsConversions;	126	import org.netbeans.modules.editor.lib.SettingsConversions;
		127	import org.netbeans.modules.editor.lib2.RectangularSelectionCaretAccessor;
113	import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;	128	import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;
114	import org.netbeans.modules.editor.lib2.actions.KeyBindingsUpdater;	129	import org.netbeans.modules.editor.lib2.actions.KeyBindingsUpdater;
115	import org.netbeans.modules.editor.lib2.typinghooks.DeletedTextInterceptorsManager;	130	import org.netbeans.modules.editor.lib2.typinghooks.DeletedTextInterceptorsManager;
Lines 122-127 Link Here
122	import org.openide.util.LookupEvent;	137	import org.openide.util.LookupEvent;
123	import org.openide.util.LookupListener;	138	import org.openide.util.LookupListener;
124	import org.openide.util.NbBundle;	139	import org.openide.util.NbBundle;
		140	import org.openide.util.Pair;
125	import org.openide.util.WeakListeners;	141	import org.openide.util.WeakListeners;
126	import org.openide.util.WeakSet;	142	import org.openide.util.WeakSet;
127		143
Lines 545-551 Link Here
545		561
546	/** Create caret to navigate through document */	562	/** Create caret to navigate through document */
547	public @Override Caret createCaret() {	563	public @Override Caret createCaret() {
548	return new BaseCaret();	564	return new EditorCaret();
549	}	565	}
550		566
551	/** Create empty document */	567	/** Create empty document */
Lines 1111-1118 Link Here
1111	}	1127	}
1112	});	1128	});
1113	Caret caret = target.getCaret();	1129	Caret caret = target.getCaret();
1114	if (caret instanceof BaseCaret) {	1130	if (caret instanceof EditorCaret) {
1115	((BaseCaret)caret).setRectangularSelectionToDotAndMark();	1131	RectangularSelectionCaretAccessor.get().setRectangularSelectionToDotAndMark((EditorCaret)caret);
1116	}	1132	}
1117	if (changed[0]) {	1133	if (changed[0]) {
1118	return;	1134	return;
Lines 1120-1185 Link Here
1120	}	1136	}
1121		1137
1122	try {	1138	try {
1123	final Position insertionOffset = doc.createPosition(computeInsertionOffset(target.getCaret()), Position.Bias.Backward);	1139	// for (final CaretInfo caret : ((EditorCaret)target.getCaret()).getCarets()) {
1124	String replacedText = "";	1140	// final Position insertionOffset = doc.createPosition(computeInsertionOffset(caret), Position.Bias.Backward);
1125	if (Utilities.isSelectionShowing(target.getCaret())) {	1141	// String replacedText = "";
1126	int p0 = Math.min(target.getCaret().getDot(), target.getCaret().getMark());	1142	// if (target.getCaret().isSelectionVisible() && caret.getDotPosition() != caret.getMarkPosition()) {
1127	int p1 = Math.max(target.getCaret().getDot(), target.getCaret().getMark());	1143	// int p0 = Math.min(caret.getDot(), caret.getMark());
1128	replacedText = doc.getText(p0, p1 - p0);	1144	// int p1 = Math.max(caret.getDot(), caret.getMark());
1129	}	1145	// replacedText = doc.getText(p0, p1 - p0);
1130	final TypedTextInterceptorsManager.Transaction transaction = TypedTextInterceptorsManager.getInstance().openTransaction(	1146	// }
1131	target, insertionOffset, cmd, replacedText);	1147	// final TypedTextInterceptorsManager.Transaction transaction = TypedTextInterceptorsManager.getInstance().openTransaction(
1132		1148	// target, insertionOffset, cmd, replacedText);
1133	try {	1149	//
1134	if (!transaction.beforeInsertion()) {	1150	// try {
1135	final Object [] result = new Object [] { Boolean.FALSE, "" }; //NOI18N	1151	// if (!transaction.beforeInsertion()) {
1136	doc.runAtomicAsUser (new Runnable () {	1152	// final Object [] result = new Object [] { Boolean.FALSE, "" }; //NOI18N
1137	public void run () {	1153	// doc.runAtomicAsUser (new Runnable () {
1138	boolean alreadyBeeped = false;	1154	// public void run () {
1139	if (Utilities.isSelectionShowing(target.getCaret())) { // valid selection	1155	// boolean alreadyBeeped = false;
1140	EditorUI editorUI = Utilities.getEditorUI(target);	1156	// if (target.getCaret().isSelectionVisible() && caret.getDot() != caret.getMark()) { // valid selection
1141	Boolean overwriteMode = (Boolean) editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);	1157	// EditorUI editorUI = Utilities.getEditorUI(target);
1142	boolean ovr = (overwriteMode != null && overwriteMode.booleanValue());	1158	// Boolean overwriteMode = (Boolean) editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);
		1159	// boolean ovr = (overwriteMode != null && overwriteMode.booleanValue());
		1160	final Caret[] caret = {target.getCaret()};
		1161
		1162	if(caret[0] instanceof EditorCaret) {
		1163	EditorCaret editorCaret = (EditorCaret) caret[0];
		1164	final List<CaretInfo> carets = editorCaret.getCarets();
		1165	if(carets.size() > 1) {
		1166	doc.runAtomicAsUser(new Runnable() {
		1167	public void run() {
		1168	boolean alreadyBeeped = false;
		1169	DocumentUtilities.setTypingModification(doc, true);
1143	try {	1170	try {
1144	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, true);	1171	List<Position> dotAndMarkPosPairs = new ArrayList<>(carets.size() << 1);
1145	replaceSelection(target, insertionOffset.getOffset(), target.getCaret(), "", ovr);	1172	for (CaretInfo c : carets) {
		1173	dotAndMarkPosPairs.add(c.getDotPosition());
		1174	dotAndMarkPosPairs.add(c.getMarkPosition());
		1175	if (c.isSelection()) { // valid selection
		1176	int p0 = Math.min(c.getDot(), c.getMark());
		1177	int p1 = Math.max(c.getDot(), c.getMark());
		1178	String replacedText = null;
		1179	try {
		1180	replacedText = doc.getText(p0, p1 - p0);
		1181	} catch (BadLocationException ble) {
		1182	LOG.log(Level.FINE, null, ble);
		1183	if (!alreadyBeeped) {
		1184	target.getToolkit().beep();
		1185	}
		1186	alreadyBeeped = true;
		1187	}
		1188	EditorUI editorUI = Utilities.getEditorUI(target);
		1189	Boolean overwriteMode = (Boolean) editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);
		1190	boolean ovr = (overwriteMode != null && overwriteMode.booleanValue());
		1191	try {
		1192	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, true);
		1193	doc.remove(p0, p1 - p0);
		1194	} catch (BadLocationException ble) {
		1195	LOG.log(Level.FINE, null, ble);
		1196	if (!alreadyBeeped) {
		1197	target.getToolkit().beep();
		1198	}
		1199	alreadyBeeped = true;
		1200	} finally {
		1201	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, null);
		1202	}
		1203	}
		1204	try {
		1205	// TBD: Mark for the last caret?
		1206	// try {
		1207	// NavigationHistory.getEdits().markWaypoint(target, insertionOffset, false, true);
		1208	// } catch (BadLocationException e) {
		1209	// LOG.log(Level.WARNING, "Can't add position to the history of edits.", e); //NOI18N
		1210	// }
		1211
		1212	final BaseDocument doc = (BaseDocument) target.getDocument();
		1213	EditorUI editorUI = Utilities.getEditorUI(target);
		1214	editorUI.getWordMatch().clear(); // reset word matching
		1215
		1216	int insertionOffset = c.getDot();
		1217	Boolean overwriteMode = (Boolean) editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);
		1218	boolean ovr = (overwriteMode != null && overwriteMode.booleanValue());
		1219	if (ovr && insertionOffset < doc.getLength() && doc.getChars(insertionOffset, 1)[0] != '\n') { //NOI18N
		1220	// overwrite current char
		1221	doc.remove(insertionOffset, 1);
		1222	doc.insertString(insertionOffset, cmd, null);
		1223	} else { // insert mode
		1224	doc.insertString(insertionOffset, cmd, null);
		1225	}
		1226	} catch (BadLocationException ble) {
		1227	LOG.log(Level.FINE, null, ble);
		1228	if (!alreadyBeeped) {
		1229	target.getToolkit().beep();
		1230	}
		1231	}
		1232	}
		1233	doc.addUndoableEdit(new CaretEdit(dotAndMarkPosPairs, target));
		1234	} finally {
		1235	DocumentUtilities.setTypingModification(doc, false);
		1236	}
1237	}
1238	});
1239	return;
1240	}
1241	}
1242
1243	final Position insertionOffset = doc.createPosition(computeInsertionOffset(caret[0]), Position.Bias.Backward);
1244	String replacedText = "";
1245	if (target.getCaret().isSelectionVisible() && caret[0].getDot() != caret[0].getMark()) {
1246	int p0 = Math.min(caret[0].getDot(), caret[0].getMark());
1247	int p1 = Math.max(caret[0].getDot(), caret[0].getMark());
1248	replacedText = doc.getText(p0, p1 - p0);
1249	}
1250	final TypedTextInterceptorsManager.Transaction transaction = TypedTextInterceptorsManager.getInstance().openTransaction(
1251	target, insertionOffset, cmd, replacedText);
1252
1253	try {
1254	if (!transaction.beforeInsertion()) {
1255	final Object[] result = new Object[]{Boolean.FALSE, ""}; //NOI18N
1256	doc.runAtomicAsUser(new Runnable() {
1257	public void run() {
1258	boolean alreadyBeeped = false;
1259	if (target.getCaret().isSelectionVisible() && caret[0].getDot() != caret[0].getMark()) { // valid selection
1260	EditorUI editorUI = Utilities.getEditorUI(target);
1261	Boolean overwriteMode = (Boolean) editorUI.getProperty(EditorUI.OVERWRITE_MODE_PROPERTY);
1262	boolean ovr = (overwriteMode != null && overwriteMode.booleanValue());
1263	try {
1264	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, true);
1265	replaceSelection(target, insertionOffset.getOffset(), target.getCaret(), "", ovr);
1266	} catch (BadLocationException ble) {
1267	LOG.log(Level.FINE, null, ble);
1268	target.getToolkit().beep();
1269	alreadyBeeped = true;
1270	} finally {
1271	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, null);
1272	}
1273	}
1274	Object[] r = transaction.textTyped();
1275	String insertionText = r == null ? cmd : (String) r[0];
1276	int caretPosition = r == null ? -1 : (Integer) r[1];
1277
1278	try {
1279	performTextInsertion(target, insertionOffset.getOffset(), insertionText, caretPosition);
1280	result[0] = Boolean.TRUE;
1281	result[1] = insertionText;
1146	} catch (BadLocationException ble) {	1282	} catch (BadLocationException ble) {
1147	LOG.log(Level.FINE, null, ble);	1283	LOG.log(Level.FINE, null, ble);
1148	target.getToolkit().beep();	1284	if (!alreadyBeeped) {
1149	alreadyBeeped = true;	1285	target.getToolkit().beep();
1150	}	1286	}
1151	finally {
1152	doc.putProperty(DOC_REPLACE_SELECTION_PROPERTY, null);
1153	}	1287	}
1154	}	1288	}
1155	Object [] r = transaction.textTyped();	1289	});
1156	String insertionText = r == null ? cmd : (String) r[0];	1290
1157	int caretPosition = r == null ? -1 : (Integer) r[1];	1291	if (((Boolean) result[0]).booleanValue()) {
1158		1292	transaction.afterInsertion();
1159	try {	1293
1160	performTextInsertion(target, insertionOffset.getOffset(), insertionText, caretPosition);	1294	// XXX: this is potentially wrong and we may need to call this with
1161	result[0] = Boolean.TRUE;	1295	// the original cmd; or maybe only if insertionText == cmd; but maybe
1162	result[1] = insertionText;	1296	// it does not matter, because nobody seems to be overwriting this method anyway
1163	} catch (BadLocationException ble) {	1297	checkIndent(target, (String) result[1]);
1164	LOG.log(Level.FINE, null, ble);	1298	} // else text insertion failed
1165	if (!alreadyBeeped)	1299	}
1166	target.getToolkit().beep();	1300	} finally {
1167	}	1301	transaction.close();
1168	}
1169	});
1170
1171	if (((Boolean)result[0]).booleanValue()) {
1172	transaction.afterInsertion();
1173
1174	// XXX: this is potentially wrong and we may need to call this with
1175	// the original cmd; or maybe only if insertionText == cmd; but maybe
1176	// it does not matter, because nobody seems to be overwriting this method anyway
1177	checkIndent(target, (String)result[1]);
1178	} // else text insertion failed
1179	}	1302	}
1180	} finally {
1181	transaction.close();
1182	}
1183	} catch (BadLocationException ble) {	1303	} catch (BadLocationException ble) {
1184	LOG.log(Level.FINE, null, ble);	1304	LOG.log(Level.FINE, null, ble);
1185	target.getToolkit().beep();	1305	target.getToolkit().beep();
Lines 1548-1553 Link Here
1548	public void run () {	1668	public void run () {
1549	DocumentUtilities.setTypingModification(doc, true);	1669	DocumentUtilities.setTypingModification(doc, true);
1550	try {	1670	try {
		1671	if(caret instanceof EditorCaret) {
		1672	EditorCaret editorCaret = (EditorCaret) caret;
		1673	editorCaret.moveCarets(new CaretMoveHandler() {
		1674	@Override
		1675	public void moveCarets(CaretMoveContext context) {
		1676	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		1677	if (caretInfo.isSelection()) { // block selected
		1678	try {
		1679	int start = Math.min(caretInfo.getDot(), caretInfo.getMark());
		1680	int end = Math.max(caretInfo.getDot(), caretInfo.getMark());
		1681	String replacedText = doc.getText(start, end - start);
		1682	if (replacedText.trim().isEmpty()) {
		1683	doc.remove(start, end - start);
		1684	insertTabString(doc, start);
		1685	} else {
		1686	boolean selectionAtLineStart = Utilities.getRowStart(doc, start) == start;
		1687	changeBlockIndent(doc, start, end, +1);
		1688	if (selectionAtLineStart) {
		1689	int newSelectionStartOffset = start;
		1690	int lineStartOffset = Utilities.getRowStart(doc, start);
		1691	if (lineStartOffset != newSelectionStartOffset) {
		1692	target.select(lineStartOffset, end);
		1693	}
		1694	}
		1695	}
		1696	} catch (GuardedException ge) {
		1697	LOG.log(Level.FINE, null, ge);
		1698	target.getToolkit().beep();
		1699	} catch (BadLocationException e) {
		1700	LOG.log(Level.WARNING, null, e);
		1701	}
		1702	} else { // no selected text
		1703	int dotOffset = caretInfo.getDot();
		1704	try {
		1705	// is there any char on this line before cursor?
		1706	int indent = Utilities.getRowIndent(doc, dotOffset);
		1707	// test whether we should indent
		1708	if (indent == -1) {
		1709	// find caret column
		1710	int caretCol = Utilities.getVisualColumn(doc, dotOffset);
		1711	// find next tab column
		1712	int nextTabCol = Utilities.getNextTabColumn(doc, dotOffset);
		1713
		1714	indenter.reindent(dotOffset);
		1715
		1716	dotOffset = caretInfo.getDot();
		1717	int newCaretCol = Utilities.getVisualColumn(doc, dotOffset);
		1718	if (newCaretCol <= caretCol) {
		1719	// find indent of the first previous non-white row
		1720	int upperCol = Utilities.getRowIndent(doc, dotOffset, false);
		1721	changeRowIndent(doc, dotOffset, upperCol > nextTabCol ? upperCol : nextTabCol);
		1722	// Fix of #32240
		1723	dotOffset = caretInfo.getDot();
		1724	Position newDotPos = doc.createPosition(Utilities.getRowEnd(doc, dotOffset));
		1725	context.setDot(caretInfo, newDotPos);
		1726	}
		1727	} else { // already chars on the line
		1728	insertTabString(doc, dotOffset);
		1729	}
		1730	} catch (GuardedException ge) {
		1731	LOG.log(Level.FINE, null, ge);
		1732	target.getToolkit().beep();
		1733	} catch (BadLocationException e) {
		1734	// use the same pos
1735	target.getToolkit().beep();
1736	LOG.log(Level.FINE, null, e);
1737	}
1738	}
1739	}
1740	}
1741	});
1742	} else {
1551	if (Utilities.isSelectionShowing(caret)) { // block selected	1743	if (Utilities.isSelectionShowing(caret)) { // block selected
1552	try {	1744	try {
1553	if (target.getSelectedText().trim().isEmpty()) {	1745	if (target.getSelectedText().trim().isEmpty()) {
Lines 1605-1610 Link Here
1605	LOG.log(Level.FINE, null, e);	1797	LOG.log(Level.FINE, null, e);
1606	}	1798	}
1607	}	1799	}
		1800	}
1608	} finally {	1801	} finally {
1609	DocumentUtilities.setTypingModification(doc, false);	1802	DocumentUtilities.setTypingModification(doc, false);
1610	}	1803	}
Lines 1802-1807 Link Here
1802		1995
1803	final BaseDocument doc = (BaseDocument)target.getDocument();	1996	final BaseDocument doc = (BaseDocument)target.getDocument();
1804	final Caret caret = target.getCaret();	1997	final Caret caret = target.getCaret();
		1998	if (caret instanceof EditorCaret) {
		1999	final EditorCaret editorCaret = (EditorCaret) caret;
		2000	final List<CaretInfo> carets = editorCaret.getSortedCarets();
		2001	if (carets.size() > 1) {
		2002	doc.runAtomicAsUser(new Runnable() {
		2003	public void run() {
		2004	boolean alreadyBeeped = false;
		2005	DocumentUtilities.setTypingModification(doc, true);
		2006	try {
		2007	List<Position> caretsDotAndMarkPositions = new ArrayList<>(carets.size() << 1);
		2008	for (CaretInfo c : carets) {
		2009	caretsDotAndMarkPositions.add(c.getDotPosition());
		2010	caretsDotAndMarkPositions.add(c.getMarkPosition());
		2011	if (c.isSelection()) {
		2012	// remove selection
		2013	final int dot = c.getDot();
		2014	final int mark = c.getMark();
		2015	try {
		2016	if (RectangularSelectionUtils.isRectangularSelection(target)) {
		2017	if (!RectangularSelectionUtils.removeSelection(target)) {
		2018	RectangularSelectionUtils.removeChar(target, nextChar);
		2019	}
		2020	RectangularSelectionCaretAccessor.get().setRectangularSelectionToDotAndMark((EditorCaret)caret);
		2021	} else {
		2022	doc.remove(Math.min(dot, mark), Math.abs(dot - mark));
		2023	}
		2024	} catch (BadLocationException ble) {
		2025	LOG.log(Level.FINE, null, ble);
		2026	if (!alreadyBeeped) {
		2027	target.getToolkit().beep();
		2028	}
		2029	alreadyBeeped = true;
		2030	}
		2031	} else {
		2032	final int dot = c.getDot();
		2033	char[] removedChar = null;
		2034
		2035	try {
		2036	removedChar = nextChar
		2037	? dot < doc.getLength() ? doc.getChars(dot, 1) : null
		2038	: dot > 0 ? doc.getChars(dot - 1, 1) : null;
		2039	} catch (BadLocationException ble) {
		2040	LOG.log(Level.FINE, null, ble);
		2041	if (!alreadyBeeped) {
		2042	target.getToolkit().beep();
		2043	}
		2044	alreadyBeeped = true;
		2045	}
		2046
		2047	if (removedChar != null) {
		2048	final String removedText = String.valueOf(removedChar);
		2049	try {
		2050	if (nextChar) { // remove next char
		2051	doc.remove(dot, 1);
		2052	} else { // remove previous char
		2053	doc.remove(dot - 1, 1);
		2054	}
		2055	} catch (BadLocationException ble) {
		2056	LOG.log(Level.FINE, null, ble);
		2057	if (!alreadyBeeped) {
		2058	target.getToolkit().beep();
		2059	}
		2060	alreadyBeeped = true;
		2061	}
2062	}
2063	}
2064	}
2065	doc.addUndoableEdit(new CaretEdit(caretsDotAndMarkPositions, target));
2066	} finally {
2067	DocumentUtilities.setTypingModification(doc, false);
2068	}
2069	}
2070	}
2071	);
2072	return;
2073	}
2074	}
2075
2076	// Non-multicaret case
1805	final int dot = caret.getDot();	2077	final int dot = caret.getDot();
1806	final int mark = caret.getMark();	2078	final int mark = caret.getMark();
1807		2079
Lines 1811-1826 Link Here
1811	public void run () {	2083	public void run () {
1812	DocumentUtilities.setTypingModification(doc, true);	2084	DocumentUtilities.setTypingModification(doc, true);
1813	try {	2085	try {
		2086	List<Position> dotAndMarkPosPairs = new ArrayList<>(2);
		2087	dotAndMarkPosPairs.add(doc.createPosition(caret.getDot()));
		2088	dotAndMarkPosPairs.add(doc.createPosition(caret.getMark()));
1814	if (RectangularSelectionUtils.isRectangularSelection(target)) {	2089	if (RectangularSelectionUtils.isRectangularSelection(target)) {
1815	if (!RectangularSelectionUtils.removeSelection(target)) {	2090	if (!RectangularSelectionUtils.removeSelection(target)) {
1816	RectangularSelectionUtils.removeChar(target, nextChar);	2091	RectangularSelectionUtils.removeChar(target, nextChar);
1817	}	2092	}
1818	if (caret instanceof BaseCaret) {	2093	if (caret instanceof EditorCaret) {
1819	((BaseCaret)caret).setRectangularSelectionToDotAndMark();	2094	RectangularSelectionCaretAccessor.get().setRectangularSelectionToDotAndMark((EditorCaret)caret);
1820	}	2095	}
1821	} else {	2096	} else {
1822	doc.remove(Math.min(dot, mark), Math.abs(dot - mark));	2097	doc.remove(Math.min(dot, mark), Math.abs(dot - mark));
1823	}	2098	}
		2099	doc.addUndoableEdit(new CaretEdit(dotAndMarkPosPairs, target));
1824	} catch (BadLocationException e) {	2100	} catch (BadLocationException e) {
1825	target.getToolkit().beep();	2101	target.getToolkit().beep();
1826	} finally {	2102	} finally {
Lines 1972-1994 Link Here
1972	// If on last line (without newline) then insert newline at very end temporarily	2248	// If on last line (without newline) then insert newline at very end temporarily
1973	// then cut and remove previous newline.	2249	// then cut and remove previous newline.
1974	int removeNewlineOffset = -1;	2250	int removeNewlineOffset = -1;
1975	if (!Utilities.isSelectionShowing(target)) {	2251	Caret caret = target.getCaret();
1976	Element elem = ((AbstractDocument) target.getDocument()).getParagraphElement(	2252	boolean disableNoSelectionCopy =
1977	target.getCaretPosition());	2253	Boolean.getBoolean("org.netbeans.editor.disable.no.selection.copy");
1978	int lineStartOffset = elem.getStartOffset();	2254	if(!disableNoSelectionCopy &&
1979	int lineEndOffset = elem.getEndOffset();	2255	(!(caret instanceof EditorCaret)) \|\| !(((EditorCaret)caret).getCarets().size() > 1)) {
1980	if (lineEndOffset == doc.getLength() + 1) { // Very end	2256	if (!Utilities.isSelectionShowing(target)) {
1981	// Temporarily insert extra newline	2257	Element elem = ((AbstractDocument) target.getDocument()).getParagraphElement(
1982	try {	2258	target.getCaretPosition());
1983	doc.insertString(lineEndOffset - 1, "\n", null);	2259	int lineStartOffset = elem.getStartOffset();
1984	if (lineStartOffset > 0) { // Only when not on first line	2260	int lineEndOffset = elem.getEndOffset();
1985	removeNewlineOffset = lineStartOffset - 1;	2261	if (lineEndOffset == doc.getLength() + 1) { // Very end
		2262	// Temporarily insert extra newline
		2263	try {
		2264	doc.insertString(lineEndOffset - 1, "\n", null);
		2265	if (lineStartOffset > 0) { // Only when not on first line
		2266	removeNewlineOffset = lineStartOffset - 1;
		2267	}
		2268	} catch (BadLocationException e) {
		2269	// could not insert extra newline
1986	}	2270	}
1987	} catch (BadLocationException e) {
1988	// could not insert extra newline
1989	}	2271	}
		2272	target.select(lineStartOffset, lineEndOffset);
1990	}	2273	}
1991	target.select(lineStartOffset, lineEndOffset);
1992	}	2274	}
1993		2275
1994	target.cut();	2276	target.cut();
Lines 2023-2038 Link Here
2023	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2305	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2024	if (target != null) {	2306	if (target != null) {
2025	try {	2307	try {
2026	int caretPosition = target.getCaretPosition();	2308	Caret caret = target.getCaret();
2027	boolean emptySelection = !Utilities.isSelectionShowing(target);	2309	boolean emptySelection = false;
2028	boolean disableNoSelectionCopy =	2310	boolean disableNoSelectionCopy =
2029	Boolean.getBoolean("org.netbeans.editor.disable.no.selection.copy");	2311	Boolean.getBoolean("org.netbeans.editor.disable.no.selection.copy");
2030	// If there is no selection then pre-select a current line including newline	2312	int caretPosition = caret.getDot();
2031	if (emptySelection && !disableNoSelectionCopy) {	2313	if(!disableNoSelectionCopy &&
2032	Element elem = ((AbstractDocument) target.getDocument()).getParagraphElement(	2314	(!(caret instanceof EditorCaret)) \|\| !(((EditorCaret)caret).getCarets().size() > 1)) {
2033	caretPosition);	2315	emptySelection = !Utilities.isSelectionShowing(target);
2034	if (!Utilities.isRowWhite((BaseDocument) target.getDocument(), elem.getStartOffset())) {	2316	// If there is no selection then pre-select a current line including newline
2035	target.select(elem.getStartOffset(), elem.getEndOffset());	2317	if (emptySelection && !disableNoSelectionCopy) {
		2318	Element elem = ((AbstractDocument) target.getDocument()).getParagraphElement(
		2319	caretPosition);
		2320	if (!Utilities.isRowWhite((BaseDocument) target.getDocument(), elem.getStartOffset())) {
		2321	target.select(elem.getStartOffset(), elem.getEndOffset());
		2322	}
2036	}	2323	}
2037	}	2324	}
2038	target.copy();	2325	target.copy();
Lines 2214-2223 Link Here
2214	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);	2501	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2215	}	2502	}
2216		2503
2217	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2504	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2218	if (target != null) {	2505	if (target != null) {
		2506	Caret caret = target.getCaret();
		2507	final Document doc = target.getDocument();
		2508	if(doc != null && caret instanceof EditorCaret) {
		2509	final EditorCaret editorCaret = (EditorCaret) caret;
		2510	editorCaret.moveCarets(new CaretMoveHandler() {
		2511	@Override
		2512	public void moveCarets(CaretMoveContext context) {
		2513	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		2514	try {
		2515	int dot = caretInfo.getDot();
		2516	Point p = caretInfo.getMagicCaretPosition();
		2517	if (p == null) {
		2518	Rectangle r = target.modelToView(dot);
		2519	if (r != null) {
		2520	p = new Point(r.x, r.y);
		2521	context.setMagicCaretPosition(caretInfo, p);
		2522	} else {
		2523	return; // model to view failed
		2524	}
		2525	}
		2526	try {
		2527	dot = Utilities.getPositionAbove(target, dot, p.x);
		2528	Position dotPos = doc.createPosition(dot);
		2529	boolean select = selectionUpAction.equals(getValue(Action.NAME));
		2530	if (select) {
		2531	context.moveDot(caretInfo, dotPos);
		2532	if (RectangularSelectionUtils.isRectangularSelection(target)) {
		2533	RectangularSelectionCaretAccessor.get().updateRectangularUpDownSelection(editorCaret);
		2534	}
		2535	} else {
		2536	context.setDot(caretInfo, dotPos);
		2537	}
		2538	} catch (BadLocationException e) {
		2539	// the position stays the same
		2540	}
		2541	} catch (BadLocationException ex) {
		2542	target.getToolkit().beep();
		2543	}
		2544	}
		2545	}
		2546	});
		2547	} else {
2219	try {	2548	try {
2220	Caret caret = target.getCaret();
2221	int dot = caret.getDot();	2549	int dot = caret.getDot();
2222	Point p = caret.getMagicCaretPosition();	2550	Point p = caret.getMagicCaretPosition();
2223	if (p == null) {	2551	if (p == null) {
Lines 2235-2242 Link Here
2235	if (select) {	2563	if (select) {
2236	caret.moveDot(dot);	2564	caret.moveDot(dot);
2237	if (RectangularSelectionUtils.isRectangularSelection(target)) {	2565	if (RectangularSelectionUtils.isRectangularSelection(target)) {
2238	if (caret instanceof BaseCaret) {	2566	if (caret instanceof EditorCaret) {
2239	((BaseCaret) caret).updateRectangularUpDownSelection();	2567	RectangularSelectionCaretAccessor.get().updateRectangularUpDownSelection((EditorCaret)caret);
2240	}	2568	}
2241	}	2569	}
2242	} else {	2570	} else {
Lines 2249-2254 Link Here
2249	target.getToolkit().beep();	2577	target.getToolkit().beep();
2250	}	2578	}
2251	}	2579	}
		2580	}
2252	}	2581	}
2253	}	2582	}
2254		2583
Lines 2264-2273 Link Here
2264	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);	2593	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2265	}	2594	}
2266		2595
2267	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2596	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2268	if (target != null) {	2597	if (target != null) {
		2598	Caret caret = target.getCaret();
		2599	final Document doc = target.getDocument();
		2600	if (doc != null && caret instanceof EditorCaret) {
		2601	final EditorCaret editorCaret = (EditorCaret) caret;
		2602	editorCaret.moveCarets(new CaretMoveHandler() {
		2603	@Override
		2604	public void moveCarets(CaretMoveContext context) {
		2605	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		2606	try {
		2607	int dot = caretInfo.getDot();
		2608	Point p = caretInfo.getMagicCaretPosition();
		2609	if (p == null) {
		2610	Rectangle r = target.modelToView(dot);
		2611	if (r != null) {
		2612	p = new Point(r.x, r.y);
		2613	context.setMagicCaretPosition(caretInfo, p);
		2614	} else {
		2615	return; // model to view failed
		2616	}
		2617	}
		2618	try {
		2619	dot = Utilities.getPositionBelow(target, dot, p.x);
		2620	Position dotPos = doc.createPosition(dot);
		2621	boolean select = selectionDownAction.equals(getValue(Action.NAME));
		2622	if (select) {
		2623	context.moveDot(caretInfo, dotPos);
		2624	if (RectangularSelectionUtils.isRectangularSelection(target)) {
		2625	RectangularSelectionCaretAccessor.get().updateRectangularUpDownSelection(editorCaret);
		2626	}
		2627	} else {
		2628	context.setDot(caretInfo, dotPos);
		2629	}
		2630	} catch (BadLocationException e) {
		2631	// position stays the same
		2632	}
		2633	} catch (BadLocationException ex) {
		2634	target.getToolkit().beep();
		2635	}
		2636	}
		2637	}
		2638	});
		2639	} else {
2269	try {	2640	try {
2270	Caret caret = target.getCaret();
2271	int dot = caret.getDot();	2641	int dot = caret.getDot();
2272	Point p = caret.getMagicCaretPosition();	2642	Point p = caret.getMagicCaretPosition();
2273	if (p == null) {	2643	if (p == null) {
Lines 2285-2292 Link Here
2285	if (select) {	2655	if (select) {
2286	caret.moveDot(dot);	2656	caret.moveDot(dot);
2287	if (RectangularSelectionUtils.isRectangularSelection(target)) {	2657	if (RectangularSelectionUtils.isRectangularSelection(target)) {
2288	if (caret instanceof BaseCaret) {	2658	if (caret instanceof EditorCaret) {
2289	((BaseCaret)caret).updateRectangularUpDownSelection();	2659	RectangularSelectionCaretAccessor.get().updateRectangularUpDownSelection((EditorCaret)caret);
2290	}	2660	}
2291	}	2661	}
2292	} else {	2662	} else {
Lines 2298-2303 Link Here
2298	} catch (BadLocationException ex) {	2668	} catch (BadLocationException ex) {
2299	target.getToolkit().beep();	2669	target.getToolkit().beep();
2300	}	2670	}
		2671	}
2301	}	2672	}
2302	}	2673	}
2303	}	2674	}
Lines 2315-2325 Link Here
2315	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);	2686	super(ABBREV_RESET \| UNDO_MERGE_RESET \| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2316	}	2687	}
2317		2688
2318	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2689	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2319	if (target != null) {	2690	if (target != null) {
2320	try {	2691	try {
2321	Caret caret = target.getCaret();	2692	Caret caret = target.getCaret();
2322	BaseDocument doc = (BaseDocument)target.getDocument();	2693	final Document doc = target.getDocument();
		2694	if(doc != null && caret instanceof EditorCaret) {
		2695	final EditorCaret editorCaret = (EditorCaret) caret;
		2696	editorCaret.moveCarets(new CaretMoveHandler() {
		2697	@Override
		2698	public void moveCarets(CaretMoveContext context) {
		2699	try {
		2700	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		2701	int caretOffset = caretInfo.getDot();
		2702	Rectangle caretBounds = ((BaseTextUI) target.getUI()).modelToView(target, caretOffset);
		2703	if (caretBounds == null) {
		2704	return; // Cannot continue reasonably
		2705	}
		2706
		2707	// Retrieve caret magic position and attempt to retain
		2708	// the x-coordinate information and use it
		2709	// for setting of the new caret position
		2710	Point magicCaretPosition = caretInfo.getMagicCaretPosition();
		2711	if (magicCaretPosition == null) {
		2712	magicCaretPosition = new Point(caretBounds.x, caretBounds.y);
		2713	}
		2714
		2715	Rectangle visibleBounds = target.getVisibleRect();
		2716	int newCaretOffset;
		2717	Rectangle newCaretBounds;
		2718
		2719	// Check whether caret was contained in the original visible window
		2720	if (visibleBounds.contains(caretBounds)) {
		2721	// Clone present view bounds
		2722	Rectangle newVisibleBounds = new Rectangle(visibleBounds);
		2723	// Do viewToModel() and modelToView() with the left top corner
		2724	// of the currently visible view. If that line is not fully visible
		2725	// then it should be the bottom line of the previous page
		2726	// (if it's fully visible then the line above it).
		2727	int topLeftOffset = target.viewToModel(new Point(
		2728	visibleBounds.x, visibleBounds.y));
		2729	Rectangle topLeftLineBounds = target.modelToView(topLeftOffset);
		2730
		2731	// newVisibleBounds.y will hold bottom of new view
		2732	if (topLeftLineBounds.y != visibleBounds.y) {
		2733	newVisibleBounds.y = topLeftLineBounds.y + topLeftLineBounds.height;
		2734	} // Component view starts right at the line boundary
		2735	// Go back by the view height
		2736	newVisibleBounds.y -= visibleBounds.height;
		2737
		2738	// Find the new caret bounds by using relative y position
		2739	// on the original caret bounds. If the caret's new relative bounds
		2740	// would be visually above the old bounds
		2741	// the view should be shifted so that the relative bounds
		2742	// are the same (user's eyes do not need to move).
		2743	int caretRelY = caretBounds.y - visibleBounds.y;
		2744	int caretNewY = newVisibleBounds.y + caretRelY;
		2745	newCaretOffset = target.viewToModel(new Point(magicCaretPosition.x, caretNewY));
		2746	newCaretBounds = target.modelToView(newCaretOffset);
		2747	if (newCaretBounds.y < caretNewY) {
		2748	// Need to go one line down to retain the top line
		2749	// of the present newVisibleBounds to be fully visible.
		2750	// Attempt to go forward by height of caret
		2751	newCaretOffset = target.viewToModel(new Point(magicCaretPosition.x,
		2752	newCaretBounds.y + newCaretBounds.height));
		2753	newCaretBounds = target.modelToView(newCaretOffset);
		2754	}
		2755
		2756	// Shift the new visible bounds so that the caret
		2757	// does not visually move
2758	newVisibleBounds.y = newCaretBounds.y - caretRelY;
2759
2760	// Scroll the window to the requested rectangle
2761	target.scrollRectToVisible(newVisibleBounds);
2762
2763	} else { // Caret outside of originally visible window
2764	// Shift the dot by the visible bounds height
2765	Point newCaretPoint = new Point(magicCaretPosition.x,
2766	caretBounds.y - visibleBounds.height);
2767	newCaretOffset = target.viewToModel(newCaretPoint);
2768	newCaretBounds = target.modelToView(newCaretOffset);
2769	}
2770
2771	boolean select = selectionPageUpAction.equals(getValue(Action.NAME));
2772	Position newCaretPos = doc.createPosition(newCaretOffset);
2773	if (select) {
2774	context.moveDot(caretInfo, newCaretPos);
2775	} else {
2776	context.setDot(caretInfo, newCaretPos);
2777	}
2778
2779	// Update magic caret position
2780	magicCaretPosition.y = newCaretBounds.y;
2781	context.setMagicCaretPosition(caretInfo, magicCaretPosition);
2782	}
2783	} catch (BadLocationException ex) {
2784	target.getToolkit().beep();
2785	}
2786	}
2787	});
2788	} else {
2323	int caretOffset = caret.getDot();	2789	int caretOffset = caret.getDot();
2324	Rectangle caretBounds = ((BaseTextUI)target.getUI()).modelToView(target, caretOffset);	2790	Rectangle caretBounds = ((BaseTextUI)target.getUI()).modelToView(target, caretOffset);
2325	if (caretBounds == null) {	2791	if (caretBounds == null) {
Lines 2400-2406 Link Here
2400	// Update magic caret position	2866	// Update magic caret position
2401	magicCaretPosition.y = newCaretBounds.y;	2867	magicCaretPosition.y = newCaretBounds.y;
2402	caret.setMagicCaretPosition(magicCaretPosition);	2868	caret.setMagicCaretPosition(magicCaretPosition);
2403		2869	}
2404	} catch (BadLocationException ex) {	2870	} catch (BadLocationException ex) {
2405	target.getToolkit().beep();	2871	target.getToolkit().beep();
2406	}	2872	}
Lines 2421-2429 Link Here
2421	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);	2887	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2422	}	2888	}
2423		2889
2424	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2890	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2425	if (target != null) {	2891	if (target != null) {
2426	Caret caret = target.getCaret();	2892	Caret caret = target.getCaret();
		2893	final Document doc = target.getDocument();
		2894	if (doc != null && caret instanceof EditorCaret) {
		2895	final EditorCaret editorCaret = (EditorCaret) caret;
		2896	editorCaret.moveCarets(new CaretMoveHandler() {
		2897	@Override
		2898	public void moveCarets(CaretMoveContext context) {
		2899	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		2900	try {
		2901	int offset;
		2902	boolean select = selectionForwardAction.equals(getValue(Action.NAME));
		2903	if (!select && Utilities.isSelectionShowing(editorCaret)) {
		2904	offset = target.getSelectionEnd();
		2905	if (offset != caretInfo.getDot()) {
		2906	offset--;
		2907	} else {
		2908	// clear the selection, but do not move the cursor
		2909	Position pos = doc.createPosition(offset);
		2910	context.setDot(caretInfo, pos);
		2911	return;
		2912	}
		2913	} else {
		2914	offset = caretInfo.getDot();
		2915	}
		2916	int dot = target.getUI().getNextVisualPositionFrom(target,
		2917	offset, Position.Bias.Forward, SwingConstants.EAST, null);
		2918	Position dotPos = doc.createPosition(dot);
		2919	if (select) {
		2920	if (RectangularSelectionUtils.isRectangularSelection(target)) {
		2921	RectangularSelectionCaretAccessor.get().extendRectangularSelection(editorCaret, true, false);
		2922	} else {
		2923	context.moveDot(caretInfo, dotPos);
		2924	}
		2925	} else {
		2926	context.setDot(caretInfo, dotPos);
		2927	}
		2928	} catch (BadLocationException ex) {
		2929	target.getToolkit().beep();
		2930	}
		2931	}
		2932	}
		2933	});
		2934	} else {
2427	try {	2935	try {
2428	int pos;	2936	int pos;
2429	boolean select = selectionForwardAction.equals(getValue(Action.NAME));	2937	boolean select = selectionForwardAction.equals(getValue(Action.NAME));
Lines 2443-2450 Link Here
2443	int dot = target.getUI().getNextVisualPositionFrom(target,	2951	int dot = target.getUI().getNextVisualPositionFrom(target,
2444	pos, Position.Bias.Forward, SwingConstants.EAST, null);	2952	pos, Position.Bias.Forward, SwingConstants.EAST, null);
2445	if (select) {	2953	if (select) {
2446	if (caret instanceof BaseCaret && RectangularSelectionUtils.isRectangularSelection(target)) {	2954	if (caret instanceof EditorCaret && RectangularSelectionUtils.isRectangularSelection(target)) {
2447	((BaseCaret)caret).extendRectangularSelection(true, false);	2955	RectangularSelectionCaretAccessor.get().extendRectangularSelection((EditorCaret)caret, true, false);
2448	} else {	2956	} else {
2449	caret.moveDot(dot);	2957	caret.moveDot(dot);
2450	}	2958	}
Lines 2455-2460 Link Here
2455	target.getToolkit().beep();	2963	target.getToolkit().beep();
2456	}	2964	}
2457	}	2965	}
		2966	}
2458	}	2967	}
2459	}	2968	}
2460		2969
Lines 2472-2481 Link Here
2472	\| CLEAR_STATUS_TEXT);	2981	\| CLEAR_STATUS_TEXT);
2473	}	2982	}
2474		2983
2475	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2984	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2476	if (target != null) {	2985	if (target != null) {
2477	try {	2986	try {
2478	Caret caret = target.getCaret();	2987	Caret caret = target.getCaret();
		2988	final Document doc = target.getDocument();
		2989	if(doc != null && caret instanceof EditorCaret) {
		2990	final EditorCaret editorCaret = (EditorCaret) caret;
		2991	editorCaret.moveCarets(new CaretMoveHandler() {
		2992	@Override
		2993	public void moveCarets(CaretMoveContext context) {
		2994	try {
		2995	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		2996	int caretOffset = caretInfo.getDot();
		2997	Rectangle caretBounds = ((BaseTextUI) target.getUI()).modelToView(target, caretOffset);
		2998	if (caretBounds == null) {
		2999	return; // Cannot continue reasonably
		3000	}
		3001
		3002	// Retrieve caret magic position and attempt to retain
		3003	// the x-coordinate information and use it
		3004	// for setting of the new caret position
		3005	Point magicCaretPosition = caretInfo.getMagicCaretPosition();
		3006	if (magicCaretPosition == null) {
		3007	magicCaretPosition = new Point(caretBounds.x, caretBounds.y);
		3008	}
		3009
		3010	Rectangle visibleBounds = target.getVisibleRect();
		3011	int newCaretOffset;
		3012	Rectangle newCaretBounds;
		3013
		3014	// Check whether caret was contained in the original visible window
		3015	if (visibleBounds.contains(caretBounds)) {
		3016	// Clone present view bounds
		3017	Rectangle newVisibleBounds = new Rectangle(visibleBounds);
		3018	// Do viewToModel() and modelToView() with the left bottom corner
		3019	// of the currently visible view.
		3020	// That line should be the top line of the next page.
		3021	int bottomLeftOffset = target.viewToModel(new Point(
		3022	visibleBounds.x, visibleBounds.y + visibleBounds.height));
		3023	Rectangle bottomLeftLineBounds = target.modelToView(bottomLeftOffset);
		3024
		3025	// newVisibleBounds.y will hold bottom of new view
		3026	newVisibleBounds.y = bottomLeftLineBounds.y;
		3027
		3028	// Find the new caret bounds by using relative y position
		3029	// on the original caret bounds. If the caret's new relative bounds
		3030	// would be visually below the old bounds
		3031	// the view should be shifted so that the relative bounds
		3032	// are the same (user's eyes do not need to move).
		3033	int caretRelY = caretBounds.y - visibleBounds.y;
		3034	int caretNewY = newVisibleBounds.y + caretRelY;
		3035	newCaretOffset = target.viewToModel(new Point(magicCaretPosition.x, caretNewY));
		3036	newCaretBounds = target.modelToView(newCaretOffset);
		3037	if (newCaretBounds.y > caretNewY) {
		3038	// Need to go one line above to retain the top line
		3039	// of the present newVisibleBounds to be fully visible.
		3040	// Attempt to go up by height of caret.
		3041	newCaretOffset = target.viewToModel(new Point(magicCaretPosition.x,
		3042	newCaretBounds.y - newCaretBounds.height));
		3043	newCaretBounds = target.modelToView(newCaretOffset);
		3044	}
		3045
		3046	// Shift the new visible bounds so that the caret
		3047	// does not visually move
		3048	newVisibleBounds.y = newCaretBounds.y - caretRelY;
		3049
		3050	// Scroll the window to the requested rectangle
		3051	target.scrollRectToVisible(newVisibleBounds);
3052
3053	} else { // Caret outside of originally visible window
3054	// Shift the dot by the visible bounds height
3055	Point newCaretPoint = new Point(magicCaretPosition.x,
3056	caretBounds.y + visibleBounds.height);
3057	newCaretOffset = target.viewToModel(newCaretPoint);
3058	newCaretBounds = target.modelToView(newCaretOffset);
3059	}
3060
3061	boolean select = selectionPageDownAction.equals(getValue(Action.NAME));
3062	Position newCaretPos = doc.createPosition(newCaretOffset);
3063	if (select) {
3064	context.moveDot(caretInfo, newCaretPos);
3065	} else {
3066	context.setDot(caretInfo, newCaretPos);
3067	}
3068
3069	// Update magic caret position
3070	magicCaretPosition.y = newCaretBounds.y;
3071	context.setMagicCaretPosition(caretInfo, magicCaretPosition);
3072	}
3073	} catch (BadLocationException ex) {
3074	target.getToolkit().beep();
3075	}
3076	}
3077	});
3078	} else {
2479	int caretOffset = caret.getDot();	3079	int caretOffset = caret.getDot();
2480	Rectangle caretBounds = ((BaseTextUI)target.getUI()).modelToView(target, caretOffset);	3080	Rectangle caretBounds = ((BaseTextUI)target.getUI()).modelToView(target, caretOffset);
2481	if (caretBounds == null) {	3081	if (caretBounds == null) {
Lines 2551-2606 Link Here
2551	// Update magic caret position	3151	// Update magic caret position
2552	magicCaretPosition.y = newCaretBounds.y;	3152	magicCaretPosition.y = newCaretBounds.y;
2553	caret.setMagicCaretPosition(magicCaretPosition);	3153	caret.setMagicCaretPosition(magicCaretPosition);
2554
2555	} catch (BadLocationException ex) {
2556	target.getToolkit().beep();
2557	}
2558	}
2559	}
2560	}
2561
2562	@EditorActionRegistrations({
2563	@EditorActionRegistration(name = backwardAction),
2564	@EditorActionRegistration(name = selectionBackwardAction)
2565	})
2566	public static class BackwardAction extends LocalBaseAction {
2567
2568	static final long serialVersionUID =-3048379822817847356L;
2569
2570	public BackwardAction() {
2571	super(MAGIC_POSITION_RESET \| ABBREV_RESET \| UNDO_MERGE_RESET
2572	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2573	}
2574
2575	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2576	if (target != null) {
2577	Caret caret = target.getCaret();
2578	try {
2579	int pos;
2580	boolean select = selectionBackwardAction.equals(getValue(Action.NAME));
2581	if (!select && Utilities.isSelectionShowing(caret))
2582	{
2583	pos = target.getSelectionStart();
2584	if (pos != caret.getDot()) {
2585	pos++;
2586	} else {
2587	// clear the selection, but do not move the cursor
2588	caret.setDot(pos);
2589	return;
2590	}
2591	}
2592	else
2593	pos = caret.getDot();
2594	int dot = target.getUI().getNextVisualPositionFrom(target,
2595	pos, Position.Bias.Backward, SwingConstants.WEST, null);
2596	if (select) {
2597	if (caret instanceof BaseCaret && RectangularSelectionUtils.isRectangularSelection(target)) {
2598	((BaseCaret)caret).extendRectangularSelection(false, false);
2599	} else {
2600	caret.moveDot(dot);
2601	}
2602	} else {
2603	caret.setDot(dot);
2604	}	3154	}
2605	} catch (BadLocationException ex) {	3155	} catch (BadLocationException ex) {
2606	target.getToolkit().beep();	3156	target.getToolkit().beep();
Lines 2609-2614 Link Here
2609	}	3159	}
2610	}	3160	}
2611		3161
		3162	@EditorActionRegistrations({
		3163	@EditorActionRegistration(name = backwardAction),
		3164	@EditorActionRegistration(name = selectionBackwardAction)
		3165	})
		3166	public static class BackwardAction extends LocalBaseAction {
		3167
		3168	static final long serialVersionUID = -3048379822817847356L;
		3169
		3170	public BackwardAction() {
		3171	super(MAGIC_POSITION_RESET \| ABBREV_RESET \| UNDO_MERGE_RESET
		3172	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
		3173	}
		3174
		3175	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
		3176	if (target != null) {
		3177	Caret caret = target.getCaret();
		3178	final Document doc = target.getDocument();
		3179	if (doc != null && caret instanceof EditorCaret) {
		3180	EditorCaret editorCaret = (EditorCaret) caret;
		3181	editorCaret.moveCarets(new CaretMoveHandler() {
		3182	@Override
		3183	public void moveCarets(CaretMoveContext context) {
		3184	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		3185	try {
		3186	int offset;
		3187	boolean select = selectionBackwardAction.equals(getValue(Action.NAME));
		3188	if (!select && caretInfo.isSelectionShowing()) {
		3189	offset = caretInfo.getSelectionStart();
		3190	if (offset != caretInfo.getDot()) {
		3191	offset++;
		3192	} else {
		3193	// clear the selection, but do not move the cursor
		3194	context.setDot(caretInfo, doc.createPosition(offset));
		3195	return;
		3196	}
		3197	} else {
		3198	offset = caretInfo.getDot();
		3199	}
		3200	int dot = target.getUI().getNextVisualPositionFrom(target,
		3201	offset, Position.Bias.Backward, SwingConstants.WEST, null);
		3202	Position dotPos = doc.createPosition(dot);
		3203	if (select) {
		3204	context.moveDot(caretInfo, dotPos);
		3205	} else {
		3206	context.setDot(caretInfo, dotPos);
		3207	}
		3208	} catch (BadLocationException ex) {
		3209	target.getToolkit().beep();
		3210	}
		3211	}
		3212	}
		3213	});
		3214	} else {
		3215	try {
		3216	int pos;
		3217	boolean select = selectionBackwardAction.equals(getValue(Action.NAME));
		3218	if (!select && Utilities.isSelectionShowing(caret)) {
		3219	pos = target.getSelectionStart();
		3220	if (pos != caret.getDot()) {
		3221	pos++;
		3222	} else {
		3223	// clear the selection, but do not move the cursor
		3224	caret.setDot(pos);
		3225	return;
3226	}
3227	} else {
3228	pos = caret.getDot();
3229	}
3230	int dot = target.getUI().getNextVisualPositionFrom(target,
3231	pos, Position.Bias.Backward, SwingConstants.WEST, null);
3232	if (select) {
3233	if (caret instanceof EditorCaret && RectangularSelectionUtils.isRectangularSelection(target)) {
3234	RectangularSelectionCaretAccessor.get().extendRectangularSelection((EditorCaret)caret, false, false);
3235	} else {
3236	caret.moveDot(dot);
3237	}
3238	} else {
3239	caret.setDot(dot);
3240	}
3241	} catch (BadLocationException ex) {
3242	target.getToolkit().beep();
3243	}
3244	}
3245	}
3246	}
3247	}
3248
2612	public static class BeginLineAction extends LocalBaseAction {	3249	public static class BeginLineAction extends LocalBaseAction {
2613		3250
2614	@EditorActionRegistrations({	3251	@EditorActionRegistrations({
Lines 2639-2648 Link Here
2639	homeKeyColumnOne = columnOne;	3276	homeKeyColumnOne = columnOne;
2640	}	3277	}
2641		3278
2642	public void actionPerformed(ActionEvent evt, JTextComponent target) {	3279	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2643	if (target != null) {	3280	if (target != null) {
2644	Caret caret = target.getCaret();	3281	Caret caret = target.getCaret();
2645	BaseDocument doc = (BaseDocument)target.getDocument();	3282	final Document doc = target.getDocument();
		3283	if (doc != null && caret instanceof EditorCaret) {
		3284	EditorCaret editorCaret = (EditorCaret) caret;
		3285	editorCaret.moveCarets(new CaretMoveHandler() {
		3286	@Override
		3287	public void moveCarets(CaretMoveContext context) {
		3288	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		3289	try {
		3290	int dot = caretInfo.getDot();
		3291	// #232675: if bounds are defined, use them rather than line start/end
		3292	Object o = target.getClientProperty(PROP_NAVIGATE_BOUNDARIES);
		3293	PositionRegion bounds = null;
		3294	if (o instanceof PositionRegion) {
		3295	bounds = (PositionRegion) o;
		3296	int start = bounds.getStartOffset();
		3297	int end = bounds.getEndOffset();
		3298	if (dot > start && dot <= end) {
		3299	// move to the region start
		3300	dot = start;
		3301	} else {
		3302	bounds = null;
		3303	}
		3304	}
		3305
		3306	if (bounds == null) {
		3307	int lineStartPos = Utilities.getRowStart(target, dot);
		3308	if (homeKeyColumnOne) { // to first column
		3309	dot = lineStartPos;
		3310	} else { // either to line start or text start
		3311	BaseDocument doc = (BaseDocument) target.getDocument();
		3312	int textStartPos = Utilities.getRowFirstNonWhite(doc, lineStartPos);
		3313	if (textStartPos < 0) { // no text on the line
		3314	textStartPos = Utilities.getRowEnd(target, lineStartPos);
		3315	}
		3316	if (dot == lineStartPos) { // go to the text start pos
		3317	dot = textStartPos;
		3318	} else if (dot <= textStartPos) {
		3319	dot = lineStartPos;
		3320	} else {
		3321	dot = textStartPos;
		3322	}
		3323	}
		3324	}
		3325	// For partial view hierarchy check bounds
		3326	dot = Math.max(dot, target.getUI().getRootView(target).getStartOffset());
		3327	String actionName = (String) getValue(Action.NAME);
		3328	boolean select = selectionBeginLineAction.equals(actionName)
		3329	\|\| selectionLineFirstColumnAction.equals(actionName);
		3330
		3331	// If possible scroll the view to its begining horizontally
		3332	// to ease user's orientation in the code.
		3333	Rectangle r = target.modelToView(dot);
		3334	Rectangle visRect = target.getVisibleRect();
		3335	if (r.getMaxX() < visRect.getWidth()) {
		3336	r.x = 0;
		3337	target.scrollRectToVisible(r);
		3338	}
		3339
		3340	Position dotPos = doc.createPosition(dot);
		3341	if (select) {
		3342	context.moveDot(caretInfo, dotPos);
		3343	} else {
		3344	context.setDot(caretInfo, dotPos);
		3345	}
		3346	} catch (BadLocationException e) {
3347	target.getToolkit().beep();
3348	}
3349	}
3350	}
3351	});
3352	} else {
2646	try {	3353	try {
2647	int dot = caret.getDot();	3354	int dot = caret.getDot();
2648	// #232675: if bounds are defined, use them rather than line start/end	3355	// #232675: if bounds are defined, use them rather than line start/end
Lines 2665-2671 Link Here
2665	if (homeKeyColumnOne) { // to first column	3372	if (homeKeyColumnOne) { // to first column
2666	dot = lineStartPos;	3373	dot = lineStartPos;
2667	} else { // either to line start or text start	3374	} else { // either to line start or text start
2668	int textStartPos = Utilities.getRowFirstNonWhite(doc, lineStartPos);	3375	int textStartPos = Utilities.getRowFirstNonWhite(((BaseDocument)doc), lineStartPos);
2669	if (textStartPos < 0) { // no text on the line	3376	if (textStartPos < 0) { // no text on the line
2670	textStartPos = Utilities.getRowEnd(target, lineStartPos);	3377	textStartPos = Utilities.getRowEnd(target, lineStartPos);
2671	}	3378	}
Lines 2702-2707 Link Here
2702	target.getToolkit().beep();	3409	target.getToolkit().beep();
2703	}	3410	}
2704	}	3411	}
		3412	}
2705	}	3413	}
2706	}	3414	}
2707		3415
Lines 2718-2726 Link Here
2718	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);	3426	\| WORD_MATCH_RESET \| CLEAR_STATUS_TEXT);
2719	}	3427	}
2720		3428
2721	public void actionPerformed(ActionEvent evt, JTextComponent target) {	3429	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2722	if (target != null) {	3430	if (target != null) {
2723	Caret caret = target.getCaret();	3431	Caret caret = target.getCaret();
		3432	if(caret instanceof EditorCaret) {
		3433	((EditorCaret) caret).moveCarets(new org.netbeans.spi.editor.caret.CaretMoveHandler() {
		3434	@Override
		3435	public void moveCarets(CaretMoveContext context) {
		3436	for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
		3437	try {
		3438	// #232675: if bounds are defined, use them rather than line start/end
		3439	Object o = target.getClientProperty(PROP_NAVIGATE_BOUNDARIES);
		3440	int dot = -1;
		3441
		3442	if (o instanceof PositionRegion) {
		3443	PositionRegion bounds = (PositionRegion) o;
		3444	int start = bounds.getStartOffset();
		3445	int end = bounds.getEndOffset();
		3446	int d = caretInfo.getDot();
		3447	if (d >= start && d < end) {
		3448	// move to the region start
		3449	dot = end;
		3450	}
		3451	}
		3452
		3453	if (dot == -1) {
		3454	dot = Utilities.getRowEnd(target, caretInfo.getDot());
		3455	}
		3456
		3457	// For partial view hierarchy check bounds
		3458	dot = Math.min(dot, target.getUI().getRootView(target).getEndOffset());
		3459	boolean select = selectionEndLineAction.equals(getValue(Action.NAME));
		3460	Position dotPos = context.getDocument().createPosition(dot);
		3461	if (select) {
		3462	context.moveDot(caretInfo, dotPos);
		3463	} else {
		3464	context.setDot(caretInfo, dotPos);
		3465	}
		3466	// now move the magic caret position far to the right
		3467	Rectangle r = target.modelToView(dot);
		3468	if (r != null) {
		3469	Point p = new Point(MAGIC_POSITION_MAX, r.y);
		3470	context.setMagicCaretPosition(caretInfo, p);
		3471	}
		3472	} catch (BadLocationException e) {
		3473	e.printStackTrace();
		3474	target.getToolkit().beep();
		3475	}
		3476	}
		3477	}
		3478	});
		3479
		3480	} else {
2724	try {	3481	try {
2725	// #232675: if bounds are defined, use them rather than line start/end	3482	// #232675: if bounds are defined, use them rather than line start/end
2726	Object o = target.getClientProperty(PROP_NAVIGATE_BOUNDARIES);	3483	Object o = target.getClientProperty(PROP_NAVIGATE_BOUNDARIES);
Lines 2760-2765 Link Here
2760	target.getToolkit().beep();	3517	target.getToolkit().beep();
2761	}	3518	}
2762	}	3519	}
		3520	}
2763	}	3521	}
2764	}	3522	}
2765		3523
Lines 2852-2868 Link Here
2852	int newDotOffset = getNextWordOffset(target);	3610	int newDotOffset = getNextWordOffset(target);
2853	boolean select = selectionNextWordAction.equals(getValue(Action.NAME));	3611	boolean select = selectionNextWordAction.equals(getValue(Action.NAME));
2854	if (select) {	3612	if (select) {
2855	if (caret instanceof BaseCaret && RectangularSelectionUtils.isRectangularSelection(target)) {	3613	if (caret instanceof EditorCaret && RectangularSelectionUtils.isRectangularSelection(target)) {
2856	((BaseCaret) caret).extendRectangularSelection(true, true);	3614	RectangularSelectionCaretAccessor.get().extendRectangularSelection((EditorCaret)caret, true, true);
2857	} else {	3615	} else {
2858	caret.moveDot(newDotOffset);	3616	caret.moveDot(newDotOffset);
2859	}	3617	}
2860	} else {	3618	} else {
2861	if (caret instanceof BaseCaret) {	3619	caret.setDot(newDotOffset);
2862	((BaseCaret)caret).setDot(newDotOffset, false);
2863	} else {
2864	caret.setDot(newDotOffset);
2865	}
2866	}	3620	}
2867	} catch (BadLocationException ex) {	3621	} catch (BadLocationException ex) {
2868	target.getToolkit().beep();	3622	target.getToolkit().beep();
Lines 2898-2914 Link Here
2898	int newDotOffset = getPreviousWordOffset(target);	3652	int newDotOffset = getPreviousWordOffset(target);
2899	boolean select = selectionPreviousWordAction.equals(getValue(Action.NAME));	3653	boolean select = selectionPreviousWordAction.equals(getValue(Action.NAME));
2900	if (select) {	3654	if (select) {
2901	if (caret instanceof BaseCaret && RectangularSelectionUtils.isRectangularSelection(target)) {	3655	if (caret instanceof EditorCaret && RectangularSelectionUtils.isRectangularSelection(target)) {
2902	((BaseCaret) caret).extendRectangularSelection(false, true);	3656	RectangularSelectionCaretAccessor.get().extendRectangularSelection((EditorCaret)caret, false, true);
2903	} else {	3657	} else {
2904	caret.moveDot(newDotOffset);	3658	caret.moveDot(newDotOffset);
2905	}	3659	}
2906	} else {	3660	} else {
2907	if (caret instanceof BaseCaret) {	3661	caret.setDot(newDotOffset);
2908	((BaseCaret)caret).setDot(newDotOffset, false);
2909	} else {
2910	caret.setDot(newDotOffset);
2911	}
2912	}	3662	}
2913	} catch (BadLocationException ex) {	3663	} catch (BadLocationException ex) {
2914	target.getToolkit().beep();	3664	target.getToolkit().beep();
Lines 3008-3014 Link Here
3008	if (target != null) {	3758	if (target != null) {
3009	final Caret caret = target.getCaret();	3759	final Caret caret = target.getCaret();
3010	final BaseDocument doc = (BaseDocument)target.getDocument();	3760	final BaseDocument doc = (BaseDocument)target.getDocument();
3011	doc.runAtomicAsUser (new Runnable () {	3761	doc.render(new Runnable () {
3012	public void run () {	3762	public void run () {
3013	DocumentUtilities.setTypingModification(doc, true);	3763	DocumentUtilities.setTypingModification(doc, true);
3014	try {	3764	try {
Lines 3171-3176 Link Here
3171	}	3921	}
3172	}	3922	}
3173	} // End of DefaultSyntaxTokenContext class	3923	} // End of DefaultSyntaxTokenContext class
		3924
		3925	private static class CaretEdit extends AbstractUndoableEdit {
		3926
		3927	private final JTextComponent target;
		3928	private final List<Position> offsets;
		3929
		3930	public CaretEdit(List<Position> offsets, JTextComponent target) {
		3931	this.target = target;
		3932	this.offsets = offsets;
		3933	}
		3934
		3935	@Override
		3936	public void undo() throws CannotUndoException {
		3937	EditorCaret caret = (EditorCaret) target.getCaret();
		3938	caret.replaceCarets(offsets);
		3939	}
		3940
		3941	@Override
		3942	public void redo() throws CannotRedoException {
		3943	EditorCaret caret = (EditorCaret) target.getCaret();
		3944	caret.replaceCarets(offsets);
		3945	}
		3946	}
3174		3947
3175	private class KeybindingsAndPreferencesTracker implements LookupListener, PreferenceChangeListener {	3948	private class KeybindingsAndPreferencesTracker implements LookupListener, PreferenceChangeListener {
3176		3949

Lines 82-87 Link Here

(-)a/editor.lib/src/org/netbeans/editor/EditorUI.java (-1 / +5 lines)
82	import javax.swing.plaf.TextUI;	82	import javax.swing.plaf.TextUI;
83	import javax.swing.text.*;	83	import javax.swing.text.*;
84	import javax.swing.undo.UndoManager;	84	import javax.swing.undo.UndoManager;
		85	import org.netbeans.api.editor.EditorUtilities;
85	import org.netbeans.api.editor.mimelookup.MimeLookup;	86	import org.netbeans.api.editor.mimelookup.MimeLookup;
86	import org.netbeans.api.editor.mimelookup.MimePath;	87	import org.netbeans.api.editor.mimelookup.MimePath;
87	import org.netbeans.api.editor.settings.EditorStyleConstants;	88	import org.netbeans.api.editor.settings.EditorStyleConstants;
Lines 655-661 Link Here
655	if (!component.isEnabled()) {	656	if (!component.isEnabled()) {
656	component.getCaret().setVisible(false);	657	component.getCaret().setVisible(false);
657	}	658	}
658	}	659	} else if (EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY.equals(propName)) {
		660	// Mirror the property into EditorUI
		661	putProperty(OVERWRITE_MODE_PROPERTY, component.getClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY));
		662	}
659		663
660	if (propName == null \|\| ColoringMap.PROP_COLORING_MAP.equals(propName)) {	664	if (propName == null \|\| ColoringMap.PROP_COLORING_MAP.equals(propName)) {
661	listener.preferenceChange(null);	665	listener.preferenceChange(null);

Lines 177-187 Link Here

(-)a/editor.lib/src/org/netbeans/editor/ext/ExtKit.java (-5 lines)
177	public ExtKit() {	177	public ExtKit() {
178	}	178	}
179		179
180	/** Create caret to navigate through document */
181	public @Override Caret createCaret() {
182	return new ExtCaret();
183	}
184
185	public @Override SyntaxSupport createSyntaxSupport(BaseDocument doc) {	180	public @Override SyntaxSupport createSyntaxSupport(BaseDocument doc) {
186	return new ExtSyntaxSupport(doc);	181	return new ExtSyntaxSupport(doc);
187	}	182	}




    </apidefs>

    <!-- ACTUAL CHANGES BEGIN HERE: -->
    
    <changes>
        <change id="editor-caret">
            <summary>Caret API introduced</summary>
            <version major="2" minor="7"/>
            <date day="22" month="2" year="2016"/>
            <author login="mmetelka"/>
            <author login="ralphbenjamin"/>
            <compatibility binary="compatible" semantic="compatible" source="compatible" addition="yes" deprecation="no" deletion="no"/>
            <description>
                <p>
                    The Caret API was introduced to allow working with multiple
                    carets within one document.
                </p>
            </description>
            <class name="EditorActionNames" package="org.netbeans.api.editor" />
            <class name="EditorUtilities" package="org.netbeans.api.editor" />
            <package name="org.netbeans.api.editor.caret" />
            <issue number="257893"/>
        </change>
        <change id="occurrences-names">
            <summary>Added IDs for goto prev/next occurrence actions</summary>
            <version major="2" minor="6"/>

            <class name="EditorActionNames" package="org.netbeans.api.editor"/>
            <issue number="194356"/>
        </change>
        <change id="shift-highlights-sequence">
            <summary>Extended HightlightsSequence by ShiftHighlightsSequence</summary>
            <version major="2" minor="5"/>
            <date day="22" month="2" year="2016"/>
            <author login="mmetelka"/>
            <compatibility binary="compatible" semantic="compatible" source="compatible" addition="yes" deprecation="no" deletion="no"/>
            <description>
                <p>
        Highlights sequence that supports shifts in addition to regular offsets.
        This allows to color individual spaces within a tab character
        or to color extra virtual characters beyond a newline character.
                </p>
            </description>
            <class name="ShiftHighlightsSequence" package="org.netbeans.spi.editor.highlighting"/>
            <issue number="XXX"/>
        </change>
        <change id="releasable-highlights-container">
            <summary>ReleasableHighlightsContainer added</summary>
            <version major="2" minor="4"/>

Lines 87-93 Link Here

(-)a/editor.lib2/arch.xml (-3 / +12 lines)
87	</li>	87	</li>
88	<li>	88	<li>
89	<api name="editor-typing-hooks" group="java" type="export" category="official" url="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/typinghooks/package-summary.html">Typing Hooks SPI</api>	89	<api name="editor-typing-hooks" group="java" type="export" category="official" url="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/typinghooks/package-summary.html">Typing Hooks SPI</api>
90	</li>	90	</li>
		91	<li>
		92	<api name="editor-caret" group="java" type="export" category="official" url="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/package-summary.html">Editor Caret API</api>
		93	</li>
91	</ul>	94	</ul>
92	</answer>	95	</answer>
93		96
Lines 126-133 Link Here
126	</question>	129	</question>
127	-->	130	-->
128	<answer id="arch-usecases">	131	<answer id="arch-usecases">
129	At the moment the Editor Library 2 module contains three distinct SPIs. Each SPI lives	132	At the moment the Editor Library 2 module contains distinct APIs/SPIs. They live
130	in its own package and the usecases can be found in the packages overview.	133	in their own package and the usecases can be found in the packages overview.
131	<ul>	134	<ul>
132	<li>Code Generator SPI -	135	<li>Code Generator SPI -
133	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/codegen/package-summary.html#usecases">org.netbeans.spi.editor.codegen</a>	136	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/codegen/package-summary.html#usecases">org.netbeans.spi.editor.codegen</a>
Lines 138-143 Link Here
138	<li>Typing Hooks SPI -	141	<li>Typing Hooks SPI -
139	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/typinghooks/package-summary.html#usecases">org.netbeans.spi.editor.typinghooks</a>	142	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/typinghooks/package-summary.html#usecases">org.netbeans.spi.editor.typinghooks</a>
140	</li>	143	</li>
		144	<li>Caret API -
		145	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/package-summary.html#usecases">org.netbeans.api.editor.caret</a>
		146	</li>
		147	<li>Caret SPI -
		148	<a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/caret/package-summary.html#usecases">org.netbeans.spi.editor.caret</a>
		149	</li>
141	</ul>	150	</ul>
142	</answer>	151	</answer>
143		152




                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.63</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>

                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.ui</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.3</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                        <specification-version>8.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.ui</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.3</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <test-dependencies>
                <test-type>

            </test-dependencies>
            <public-packages>
                <package>org.netbeans.api.editor</package>
                <package>org.netbeans.api.editor.caret</package>
                <package>org.netbeans.spi.editor</package>
                <package>org.netbeans.spi.editor.caret</package>
                <package>org.netbeans.spi.editor.codegen</package>
                <package>org.netbeans.spi.editor.document</package>
                <package>org.netbeans.spi.editor.highlighting</package>





    /**
     * Zoom text in by increasing default font size.
     * <br>
     * textComponent.getClientProperty("text-zoom") contains positive (or negative)
     * integer of how many points the font size should be increased (decreased).
     * @since 1.45

     * @since 1.64
     */
    public static final String organizeMembers = "organize-members"; // NOI18N


    /**
     * Toggle caret between regular insert mode and overwrite mode.
     * @since 1.31
     */
    public static final String toggleTypingMode = "toggle-typing-mode"; // NOI18N
    
    /**
     * Remove the last added caret.
     * @since 2.6
     */
    public static final String removeLastCaret = "remove-last-caret"; // NOI18N
    
    /**
     * Navigates to the previous occurence of the symbol under the caret. The action

     * @since 2.3
     */
    public static final String gotoNextOccurrence = "next-marked-occurrence"; // NOI18N
    
    /**
     * Add a caret to the line above at the same position.
     * @since 2.6
     */
    public static final String addSelectionElseCaretUpAction = "add-selection-else-caret-up"; // NOI18N
    
    /**
     * Add a caret to the line below at the same position.
     * @since 2.6
     */
    public static final String addSelectionElseCaretDownAction = "add-selection-else-caret-down"; // NOI18N

}




/**
 * Registration of an editor action so that it's automatically added into the list
 * of editor actions even without being explicitly created by <code>BaseKit.createActions()</code>.
 * <br>
 * The corresponding annotation processor will build a xml-layer entry file
 * in the corresponding <i>/Editors/&lt;mime-type&gt;/Actions</code> folder.
 *


    /**
     * Name of the action that will appear as <code>Action.NAME</code> attribute's value.
     * <br>
     * The Swing's text package actions use convention of lowercase letters with hyphens
     * e.g. "caret-end-word" - see String constants in {@link javax.swing.text.DefaultEditorKit}.
     *


    /**
     * Mime type for which the action will be registered.
     * <br>
     * It implies the target folder of the registration <i>/Editors/&lt;mime-type&gt;/Actions</code>.
     *
     * @return mime-type of the action registration (for example "text/x-java"

     * Menu text bundle key of the registered action.
     * If an empty string is used (the default) it will be set to the same value
     * like action's short description.
     * <br>
     * Value starting with a hash "#key" searches in a bundle in the same package
     * as the action's class.
     * <br>
     * "bundle#key" allows specification of both bundle and a corresponding key.
     */
    String menuText() default "";

     * Popup menu text bundle key of the registered action.
     * If an empty string is used (the default) it will be set to the same value
     * like menu text.
     * <br>
     * Value starting with a hash "#key" searches in a bundle in the same package
     * as the action's class.
     * <br>
     * "bundle#key" allows specification of both bundle and a corresponding key.
     */
    String popupText() default "";


    /**
     * Integer position of the main menu item among the other menu items.
     * <br>
     * The default Integer.MAX_VALUE value means no menu representation.
     */
    int menuPosition() default Integer.MAX_VALUE;


    /**
     * Integer position of the popup menu item among the other popup menu (or submenu) items.
     * <br>
     * The default Integer.MAX_VALUE value means no popup menu representation.
     */
    int popupPosition() default Integer.MAX_VALUE;

    /**
     * Integer position of this action in editor toolbar.
     * <br>
     * The default Integer.MAX_VALUE value means no toolbar representation.
     */
    int toolBarPosition() default Integer.MAX_VALUE;
    
    /**
     * True if the action should not display its icon in menu.
     * <br>
     * False by default (icon visible in menu).
     * @since 1.74
     */

    
    /**
     * True if the action should not be displayed in customizer for key bindings assignment.
     * <br>
     * False by default (key binding can be configured for the action).
     * @since 1.74
     */


    /**
     * Boolean key in preferences that corresponds to action's selected state.
     * <br>
     * If set to non-empty string the action will be represented by a check-box
     * in menu and popup menu and the corresponding key will be set in
     * global mime-lookup <code>MimeLookup.getLookup(MimePath.EMPTY)</code>.

    
    /**
     * Whether or not the action should be in checked state by default.
     * <br>
     * If the preference should default to true or to false. Only valid in conjunction
     * with {@link #preferencesKey() }.
     * 

Lines 52-58 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/EditorActionRegistrations.java (-1 / +1 lines)
52	/**	52	/**
53	* Annotation allowing to annotate one action class by multiple	53	* Annotation allowing to annotate one action class by multiple
54	* {@link EditorActionRegistration} annotations.	54	* {@link EditorActionRegistration} annotations.
55	* <br/>	55	* <br>
56	* Example:	56	* Example:
57	* <pre>	57	* <pre>
58	* @EditorActionRegistrations({ @EditorActionRegistration(name = "name1", ...),	58	* @EditorActionRegistrations({ @EditorActionRegistration(name = "name1", ...),





/**
 * Registry maintaining {@link JTextComponent}s in most-recently-used order.
 * <br>
 * The particular text component needs to register itself first (to avoid dealing
 * with all the JTextFields etc.). Then the registry will attach
 * a focus listener to the text component and once the component gains
 * the focus it will move to the head of the components list.
 * <br>
 * The registry will also fire a change in case a document property
 * of the focused component changes (by calling component.setDocument()).
 *


    /**
     * Fired when focus was delivered to a registered text component.
     * <br>
     * The focused component will become the first in the components list.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getOldValue()} will be a component
     * losing the focus {@link FocusEvent#getOppositeComponent()}.
     * The {@link java.beans.PropertyChangeEvent#getNewValue()} will be the text component gaining the focus.

    
    /**
     * Fired when a registered focused component has lost the focus.
     * <br>
     * The focused component will remain the first in the components list.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the text component
     * losing the focus and the {@link java.beans.PropertyChangeEvent#getNewValue()}
     * will be the component gaining the focus {@link FocusEvent#getOppositeComponent()}.

    /**
     * Fired when document property of the focused component changes
     * i.e. someone has called {@link JTextComponent#setDocument(Document)}.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the original document
     * of the focused text component and the {@link java.beans.PropertyChangeEvent#getNewValue()}
     * will be the new document set to the focused text component.

     * Fired when a component (returned previously from {@link #componentList()})
     * is removed from component hierarchy (so it's likely that the component will be released completely
     * and garbage-collected).
     * <br>
     * Such component will no longer be returned from {@link #componentList()}
     * or {@link #lastFocusedComponent()}.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed
     * component.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>
     */
    public static final String COMPONENT_REMOVED_PROPERTY = "componentRemoved"; //NOI18N

     * Fired when the last focused component (returned previously from {@link #lastFocusedComponent()})
     * was removed from component hierarchy (so it's likely that the component will be released completely
     * and garbage-collected).
     * <br>
     * Such component will no longer be returned from {@link #componentList()}
     * or {@link #lastFocusedComponent()}.
     * <br>
     * The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed
     * last focused component and the {@link java.beans.PropertyChangeEvent#getNewValue()}
     * will be the component that would currently be returned from {@link #lastFocusedComponent()}.
     * <br>
     * If {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>
     * then there are no longer any registered components
     * ({@link #componentList()} would return empty list). If the client


    /**
     * Return last focused text component (from the ones included in the registry).
     * <br>
     * It may or may not currently have a focus.
     * 
     * @return last focused text component or null if no text components

    /**
     * Return the last focused component if it currently has a focus
     * or return null if none of the registered components currently have the focus.
     * <br>
     * @return focused component or null if none of the registered components
     *  is currently focused.
     */

    /**
     * Get list of all components present in the registry starting with the most active
     * and ending with least active component.
     * <br>
     * The list is a snapshot of the current state and it may be modified
     * by the caller if desired.
     * 

     *   <li>{@link #FOCUS_LOST_PROPERTY}</li>
     *   <li>{@link #FOCUSED_DOCUMENT_PROPERTY}</li>
     * </ul>.
     * <br>
     * All the firing should occur in AWT thread only
     * (assuming the JTextComponent.setDocument() is done properly in AWT).
     * 

Lines 57-62 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/EditorUtilities.java (+9 lines)
57	*/	57	*/
58		58
59	public final class EditorUtilities {	59	public final class EditorUtilities {
		60
		61	/**
		62	* Client property of editor component which determines
		63	* whether caret is currently in overwrite mode (Boolean.TRUE) or insert mode (Boolean.FALSE or null).
		64	* <br>
		65	* It's modified by appropriate editor actions.
		66	* @since 2.6
		67	*/
		68	public static final String CARET_OVERWRITE_MODE_PROPERTY = "caret-overwrite-mode";
60		69
61	private EditorUtilities() {	70	private EditorUtilities() {
62	// No instances	71	// No instances




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import java.awt.Point;
import java.util.logging.Logger;
import javax.swing.text.Position;
import org.netbeans.api.annotations.common.CheckForNull;

/**
 * Immutable info about a single caret used in caret API - see {@link EditorCaret}.
 * <br>
 * There is one-to-one reference between immutable caret info and mutable {@link CaretItem}.
 * CaretItem is not accessible through the caret API and it's managed privately by EditorCaret.
 * Once the caret item gets mutated its corresponding caret info becomes obsolete
 * and new caret info instance gets created lazily.
 *
 * @author Miloslav Metelka
 * @author Ralph Ruijs
 * @see EditorCaret
 * @since 2.6
 */
public final class CaretInfo {
    
    // -J-Dorg.netbeans.api.editor.CaretInfo.level=FINEST
    private static final Logger LOG = Logger.getLogger(CaretInfo.class.getName());
    
    private final CaretItem caretItem;

    private final Position dotPos;

    private final Position markPos;

    private final Point magicCaretPosition;

    CaretInfo(CaretItem caretItem) {
        this.caretItem = caretItem;
        this.dotPos = caretItem.getDotPosition();
        this.markPos = caretItem.getMarkPosition();
        this.magicCaretPosition = caretItem.getMagicCaretPosition();
    }

    /**
     * Get position of the caret itself.
     * @return non-null position of the caret placement. The position may be virtual
     *  so methods in {@link org.netbeans.api.editor.document.ShiftPositions} may be used if necessary.
     */
    @CheckForNull
    public Position getDotPosition() {
        return dotPos;
    }

    /**
     * Return either the same object like {@link #getDotPosition()} if there's no selection
     * or return position denoting the other end of an existing selection (which is either before
     * or after the dot position depending of how the selection was created).
     * @return non-null position of the caret placement. The position may be virtual
     *  so methods in {@link org.netbeans.api.editor.document.ShiftPositions} may be used if necessary.
     */
    @CheckForNull
    public Position getMarkPosition() {
        return markPos;
    }
    
    /**
     * Fetches the current position of the caret.
     *
     * @return the position &gt;=0
     */
    public int getDot() {
        return (dotPos != null) ? dotPos.getOffset() : 0;
    }

    /**
     * Fetches the current position of the mark.  If there
     * is a selection, the mark will not be the same as
     * the dot.
     *
     * @return the position &gt;=0
     */
    public int getMark() {
        return (markPos != null) ? markPos.getOffset() : getDot();
    }
    
    /**
     * Determines if there currently is a selection.
     * 
     * @return true if there's a selection or false if there's no selection for this caret.
     */
    public boolean isSelection() {
        return (dotPos != null && markPos != null &&
                markPos != dotPos && dotPos.getOffset() != markPos.getOffset());
    }
    
    /**
     * Determines if the selection is currently visible.
     * 
     * @return true if both {@link #isSelection() } and {@link EditorCaret#isSelectionVisible() } are true.
     */
    public boolean isSelectionShowing() {
        return caretItem.editorCaret().isSelectionVisible() && isSelection();
    }

    /**
     * Returns the selected text's start position.  Return 0 for an
     * empty document, or the value of dot if no selection.
     *
     * @return the start position &ge; 0
     */
    public int getSelectionStart() {
        return Math.min(getDot(), getMark());
    }

    /**
     * Returns the selected text's end position.  Return 0 if the document
     * is empty, or the value of dot if there is no selection.
     *
     * @return the end position &ge; 0
     */
    public int getSelectionEnd() {
        return Math.max(getDot(), getMark());
    }
    
    /**
     * Gets the current caret visual location.
     *
     * @return the visual position.
     */
    public @CheckForNull Point getMagicCaretPosition() {
        return magicCaretPosition;
    }
    
    CaretItem getCaretItem() {
        return caretItem;
    }
    
    @Override
    public String toString() {
        return "dotPos=" + dotPos + ", markPos=" + markPos + ", magicCaretPosition=" + magicCaretPosition + // NOI18N
                "\n  caretItem=" + caretItem; // NOI18N
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import java.awt.Point;
import java.awt.Rectangle;
import java.util.logging.Logger;
import javax.swing.text.Position;
import org.netbeans.api.annotations.common.CheckForNull;

/**
 * A single caret inside {@link EditorCaret} handled internally by EditorCaret.
 * <br>
 * For API client methods {@link CaretInfo} class is used. There is one-to-one reference
 * between caret item and caret info. But the info is immutable so once the caret item
 * gets mutated its corresponding caret info becomes obsolete and new info gets created
 * lazily.
 *
 * @author Miloslav Metelka
 */
final class CaretItem implements Comparable {
    
    // -J-Dorg.netbeans.modules.editor.lib2.CaretItem.level=FINEST
    private static final Logger LOG = Logger.getLogger(CaretItem.class.getName());

    private static final int TRANSACTION_MARK_REMOVED = 1;
    
    private static final int UPDATE_VISUAL_BOUNDS = 2;

    private final EditorCaret editorCaret;
    
    private Position dotPos;

    private Position markPos;

    private Point magicCaretPosition;
    
    /**
     * Last info or null if info became obsolete and should be recomputed.
     */
    private CaretInfo info;
    
    private Rectangle caretBounds;
    
    /**
     * Hint of index of this caret item in replaceCaretItems in transaction context.
     */
    private int transactionIndexHint;
    
    /**
     * Transaction uses this flag to mark this item for removal.
     */
    private int statusBits;

    CaretItem(EditorCaret editorCaret, Position dotPos, Position markPos) {
        this.editorCaret = editorCaret;
        this.dotPos = dotPos;
        this.markPos = markPos;
        this.statusBits = UPDATE_VISUAL_BOUNDS; // Request visual bounds updating automatically
    }
    
    EditorCaret editorCaret() {
        return editorCaret;
    }
    
    void ensureValidInfo() {
        // No explicit locking - locking managed by EditorCaret
        if (info == null) {
            info = new CaretInfo(this);
        }
    }
    
    void clearInfo() {
        // No explicit locking - locking managed by EditorCaret
        this.info = null;
    }

    CaretInfo getValidInfo() {
        ensureValidInfo();
        return info;
    }

//    void clearTransactionInfo() {
//        // No explicit locking - locking managed by EditorCaret
//        this.transactionInfo = null;
//    }
//
//    CaretInfo getValidTransactionInfo() {
//        if (transactionInfo == null) {
//            transactionInfo = new CaretInfo(this);
//        }
//        return transactionInfo;
//    }
    
    /**
     * Get position of the caret itself.
     *
     * @return non-null position of the caret placement. The position may be
     * virtual so methods in {@link org.netbeans.api.editor.document.ShiftPositions} may be used if necessary.
     */
    @CheckForNull
    Position getDotPosition() {
        return dotPos;
    }

    /**
     * Return either the same object like {@link #getDotPosition()} if there's
     * no selection or return position denoting the other end of an existing
     * selection (which is either before or after the dot position depending of
     * how the selection was created).
     *
     * @return non-null position of the caret placement. The position may be
     * virtual so methods in {@link org.netbeans.api.editor.document.ShiftPositions} may be used if necessary.
     */
    @CheckForNull
    Position getMarkPosition() {
        return markPos;
    }

    int getDot() {
        return (dotPos != null) ? dotPos.getOffset() : 0;
    }

    int getMark() {
        return (markPos != null) ? markPos.getOffset() : 0;
    }

    /**
     * @return true if there's a selection or false if there's no selection for
     * this caret.
     */
    boolean isSelection() {
        return (dotPos != null && markPos != null &&
                markPos != dotPos && dotPos.getOffset() != markPos.getOffset());
    }
    
    boolean isSelectionShowing() {
        return editorCaret.isSelectionVisible() && isSelection();
    }

    Position getSelectionStart() {
        return dotPos; // TBD - possibly inspect virtual columns etc.
    }

    Position getSelectionEnd() {
        return dotPos; // TBD - possibly inspect virtual columns etc.
    }

    Point getMagicCaretPosition() {
        return magicCaretPosition;
    }

    void setDotPos(Position dotPos) {
        this.dotPos = dotPos;
    }

    void setMarkPos(Position markPos) {
        this.markPos = markPos;
    }

    void setMagicCaretPosition(Point newMagicCaretPosition) { // [TODO] move to transaction context
        this.magicCaretPosition = newMagicCaretPosition;
    }

    void setCaretBounds(Rectangle newCaretBounds) {
        this.caretBounds = newCaretBounds;
    }

    Rectangle getCaretBounds() {
        return this.caretBounds;
    }

    int getTransactionIndexHint() {
        return transactionIndexHint;
    }

    void setTransactionIndexHint(int transactionIndexHint) {
        this.transactionIndexHint = transactionIndexHint;
    }

    void markTransactionMarkRemoved() {
        this.statusBits |= TRANSACTION_MARK_REMOVED;
    }

    boolean isTransactionMarkRemoved() {
        return (this.statusBits & TRANSACTION_MARK_REMOVED) != 0;
    }

    void clearTransactionMarkRemoved() {
        this.statusBits &= ~TRANSACTION_MARK_REMOVED;
    }
    
    void markUpdateVisualBounds() {
        this.statusBits |= UPDATE_VISUAL_BOUNDS;
    }
    
    boolean isUpdateVisualBounds() {
        return (this.statusBits & UPDATE_VISUAL_BOUNDS) != 0;
    }
    
    void clearUpdateVisualBounds() {
        this.statusBits &= ~UPDATE_VISUAL_BOUNDS;
    }
    
    @Override
    public int compareTo(Object o) {
        return getDot() - ((CaretItem)o).getDot();
    }

    @Override
    public String toString() {
        return "dotPos=" + dotPos + ", markPos=" + markPos + ", magicCaretPosition=" + magicCaretPosition; // NOI18N
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import java.awt.Point;
import java.util.List;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import org.netbeans.api.annotations.common.NonNull;

/**
 * Context for carets moving within {@link CaretMoveHandler}.
 *
 * @author Miloslav Metelka
 * @since 2.6
 */
public final class CaretMoveContext {
    
    private CaretTransaction transaction;
    
    CaretMoveContext(CaretTransaction transactionContext) {
        this.transaction = transactionContext;
    }

    /**
     * Get list of carets at the time when transaction started.
     * <br>
     * <b>Note</b>: information contained in the returned list will not reflect changes
     * performed by the dot/selection modification methods contained in this class.
     * It will always return the original state from the beginning of the move transaction.
     * All the performed modifications will be incorporated at the end of the move transaction.
     *
     * @return list of carets at the time when moving transaction has started.
     */
    public @NonNull List<CaretInfo> getOriginalCarets() {
        return transaction.getOriginalCarets();
    }
    
    /**
     * Get last item from the list returned by {@link #getOriginalCarets()}.
     * @return last caret at the time when caret moving transaction has started.
     * @see #getOriginalCarets()
     */
    public @NonNull CaretInfo getOriginalLastCaret() {
        List<CaretInfo> origCarets = getOriginalCarets();
        return origCarets.get(origCarets.size() - 1);
    }
    
    /**
     * Get list of carets sorted ascending order at the time when transaction started.
     * <br>
     * <b>Note</b>: information contained in the returned list will not reflect changes
     * performed by the dot/selection modification methods contained in this class.
     * It will always return the original state from the beginning of the move transaction.
     * All the performed modifications will be incorporated at the end of the move transaction.
     *
     * @return list of carets at the time when caret moving transaction has started.
     */
    public @NonNull List<CaretInfo> getOriginalSortedCarets() {
        return transaction.getOriginalSortedCarets();
    }
    
    /**
     * Change dot of the given caret.
     *
     * @param caret non-null caret.
     * @param dotPos new dot position.
     * @return false if passed caret is obsolete or invalid (e.g. a member of another {@link EditorCaret})
     *  or true otherwise.
     */
    public boolean setDot(@NonNull CaretInfo caret, @NonNull Position dotPos) {
        return setDotAndMark(caret, dotPos, dotPos);
    }
    
    /**
     * Move dot of the given getCaret so getCaret selection gets created or changed.
     *
     * @param caret non-null getCaret.
     * @param dotPos new dot position.
     * @return false if passed caret is obsolete or invalid (e.g. a member of another {@link EditorCaret})
     *  or true otherwise.
     */
    public boolean moveDot(@NonNull CaretInfo caret, @NonNull Position dotPos) {
        return transaction.moveDot(caret.getCaretItem(), dotPos);
    }
    
    /**
     * Move dot of the given getCaret so getCaret selection gets created or changed.
     *
     * @param caret non-null getCaret.
     * @param dotPos new dot position.
     * @param markPos starting position of the selection or the same position like dotPos if there should be no selection.
     *  <br>
     *  The position may point to a lower offset than dotPos in case the selection
     *  should extend from a higher offset to a lower offset.
     * @return false if passed caret is obsolete or invalid (e.g. a member of another {@link EditorCaret})
     *  or true otherwise.
     */
    public boolean setDotAndMark(@NonNull CaretInfo caret, @NonNull Position dotPos, @NonNull Position markPos) {
        return transaction.setDotAndMark(caret.getCaretItem(), dotPos, markPos);
    }

    /**
     * Set magic caret position of the given caret.
     *
     * @param caret non-null caret.
     * @param p new magic caret position.
     * @return false if passed caret is obsolete or invalid (e.g. a member of another {@link EditorCaret})
     *  or true otherwise.
     */
    public boolean setMagicCaretPosition(@NonNull CaretInfo caret, Point p) {
        return transaction.setMagicCaretPosition(caret.getCaretItem(), p);
    }

    /**
     * Return component in which the caret is currently installed.
     * @return non-null component in which the caret is installed.
     */
    public @NonNull JTextComponent getComponent() {
        return transaction.getComponent();
    }
    
    /**
     * Get document associated with the text component.
     * @return document of the associated component.
     * @see #getComponent()
     */
    public Document getDocument() {
        return getComponent().getDocument();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import org.netbeans.spi.editor.caret.CaretMoveHandler;
import java.awt.Point;
import java.util.List;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.editor.document.ShiftPositions;
import org.netbeans.lib.editor.util.GapList;

/**
 * Context passed to getCaret transaction allowing to create/remove/modify the carets during the transaction.
 *
 * @author Miloslav Metelka
 */
final class CaretTransaction {
    
    private final EditorCaret editorCaret;
    
    private final JTextComponent component;
    
    private final Document doc;
    
    /**
     * Original items held here mainly due to latter repaints of the removed items.
     */
    private final GapList<CaretItem> origCaretItems;
    
    private int modIndex;
    
    /**
     * For MOVE_HANDLER and CARETS_REMOVE this is end index of modified area.
     * For CARETS_ADD and MIXED this is not filled.
     */
    private int modEndIndex;
    
    private CaretItem[] addCaretItems;
    
    private int affectedStartIndex = Integer.MAX_VALUE;

    private int affectedEndIndex;

    private int affectedStartOffset = Integer.MAX_VALUE;
    
    private int affectedEndOffset;
    
    private boolean addOrRemove;
    
    private boolean dotOrMarkChanged;
    
    private GapList<CaretItem> replaceItems;
    
    private GapList<CaretItem> replaceSortedItems;
    
    private GapList<CaretItem> extraRemovedItems;
    
    private int[] indexes;
    
    private int indexesLength;
    
    /**
     * End of area where index hints were updated.
     */
    private int indexHintEnd;
    
    private boolean fullResort;
    
    
    CaretTransaction(EditorCaret caret, JTextComponent component, Document doc) {
        this.editorCaret = caret;
        this.component = component;
        this.doc = doc;
        this.origCaretItems = editorCaret.getCaretItems();
    }
    

    @NonNull EditorCaret getCaret() {
        return editorCaret;
    }
    
    @NonNull JTextComponent getComponent() {
        return component;
    }
    
    @NonNull Document getDocument() {
        return doc;
    }
    
    boolean isAnyChange() {
        return addOrRemove || dotOrMarkChanged;
    }
    
    boolean moveDot(@NonNull CaretItem caret, @NonNull Position dotPos) {
        return setDotAndMark(caret, dotPos, caret.getMarkPosition());
    }

    boolean setDotAndMark(@NonNull CaretItem caretItem, @NonNull Position dotPos, @NonNull Position markPos) {
        assert (dotPos != null) : "dotPos must not be null";
        assert (markPos != null) : "markPos must not be null";
        int index = findCaretItemIndex(origCaretItems, caretItem);
        if (index != -1) {
            Position origDotPos = caretItem.getDotPosition();
            Position origMarkPos = caretItem.getMarkPosition();
            boolean changed = false;
            if (origDotPos == null || ShiftPositions.compare(dotPos, origDotPos) != 0) {
                caretItem.setDotPos(dotPos);
                changed = true;
            }
            if (origMarkPos == null || ShiftPositions.compare(markPos, origMarkPos) != 0) {
                caretItem.setMarkPos(markPos);
                changed = true;
            }
            if (changed) {
                updateAffectedIndexes(index, index + 1);
                caretItem.markUpdateVisualBounds();
                caretItem.clearInfo();
                dotOrMarkChanged = true;
            }
            return changed;
        }
        return false;
        //caret.setDotCaret(offset, this, true);
    }
    
    boolean setMagicCaretPosition(@NonNull CaretItem caretItem, Point p) {
        int index = findCaretItemIndex(origCaretItems, caretItem);
        if (index != -1) {
            caretItem.setMagicCaretPosition(p);
            caretItem.clearInfo();
            updateAffectedIndexes(index, index + 1);
            return true;
        }
        return false;
    }
    
    void documentInsertAtZeroOffset(int insertEndOffset) {
        // Nested insert inside active transaction for caret moving
        // Since carets may already be moved - do the operations with CaretItems directly
        Position insertEndPos = null;
        for (CaretItem caretItem : editorCaret.getSortedCaretItems()) {
            Position dotPos = caretItem.getDotPosition();
            boolean modifyDot = (dotPos == null || dotPos.getOffset() == 0);
            Position markPos = caretItem.getMarkPosition();
            boolean modifyMark = (markPos == null || markPos.getOffset() == 0);
            if (modifyDot || modifyMark) {
                if (insertEndPos == null) {
                    try {
                        insertEndPos = doc.createPosition(insertEndOffset);
                    } catch (BadLocationException ex) {
                        // Should never happen
                        return;
                    }
                }
                if (modifyDot) {
                    dotPos = insertEndPos;
                }
                if (modifyMark) {
                    markPos = insertEndPos;
                }
                setDotAndMark(caretItem, dotPos, markPos);
            }
            // Do not break the loop when caret's pos is above zero offset
            // since the carets may be already moved during the transaction
            // - possibly to offset zero. But there could be optimization
            // at least scan position of only the caret items that were modified and not others.
        }
        if (insertEndPos != null) {
            updateAffectedOffsets(0, insertEndOffset); // TODO isn't this extra work that setDotAndMark() already did??
            fullResort = true;
        }
    }
    
    void documentRemove(int offset) {
        fullResort = true; // TODO modify to more specific update
    }

    private void setSelectionStartEnd(@NonNull CaretItemInfo info, @NonNull Position pos, boolean start) {
        int index = findCaretItemIndex(origCaretItems, info.caretItem);
        assert (index != -1) : "Index=" + index + " should be valid";
        if (start == info.dotAtStart) {
            info.caretItem.setDotPos(pos);
        } else {
            info.caretItem.setMarkPos(pos);
        }
        updateAffectedIndexes(index, index + 1);
    }
    
    void handleCaretRemove(@NonNull CaretInfo caret) {
        
    }

    GapList<CaretItem> getReplaceItems() {
        return replaceItems;
    }
    
    GapList<CaretItem> getSortedCaretItems() {
        return replaceSortedItems;
    }
    
    List<CaretInfo> getOriginalCarets() {
        // Current impl ignores possible replaceItems content since client transactions only operate over
        // original infos from editorCaret. Internal transactions know the type of transaction
        // that was performed so they will skip carets possibly removed by the transaction.
        return editorCaret.getCarets();
    }

    List<CaretInfo> getOriginalSortedCarets() {
        // Current impl ignores possible replaceItems content - see getOriginalCarets()
        return editorCaret.getSortedCarets();
    }

    void replaceCarets(RemoveType removeType, int offset, CaretItem[] addCaretItems) {
        int size = origCaretItems.size();
        switch (removeType) {
            case NO_REMOVE:
                break;
            case REMOVE_LAST_CARET:
                if (size > 1) {
                    modIndex = size - 1;
                    modEndIndex = size;
                    addOrRemove = true;
                }
                break;
            case RETAIN_LAST_CARET:
                if (size > 1) {
                    modEndIndex = size - 1;
                    addOrRemove = true;
                }
                break;
            case REMOVE_ALL_CARETS:
                if (size > 0) {
                    modEndIndex = size;
                    addOrRemove = true;
                }
                break;
            case DOCUMENT_REMOVE:
                break;
            case DOCUMENT_INSERT_ZERO_OFFSET:
                documentInsertAtZeroOffset(offset);
                break;

            default:
                throw new AssertionError("Unhandled removeType=" + removeType); // NOI18N
        }
        if (addCaretItems != null) {
            this.addCaretItems = addCaretItems;
            addOrRemove = true;
        }
    }
    
    void runCaretMoveHandler(CaretMoveHandler handler) {
        CaretMoveContext context = new CaretMoveContext(this);
        handler.moveCarets(context);
    }
    
    private static int getOffset(Position pos) {
        return (pos != null) ? pos.getOffset() : 0;
    }
    
    void removeOverlappingRegions() {
        removeOverlappingRegions(0, Integer.MAX_VALUE);
    }

    void removeOverlappingRegions(int removeOffset) {
        removeOverlappingRegions(0, removeOffset); // TODO compute startIndex by binary search
    }
    
    void removeOverlappingRegions(int startIndex, int stopOffset) {
        if (addOrRemove) {
            initReplaceItems();
        } else if (dotOrMarkChanged) {
            initReplaceItems(); // TODO optimize for low number of changed items
        }
        GapList<CaretItem> origSortedItems = (replaceSortedItems != null)
                ? replaceSortedItems
                : editorCaret.getSortedCaretItems();
        int origSortedItemsSize = origSortedItems.size();
        GapList<CaretItem> nonOverlappingItems = null;
        int copyStartIndex = 0;
        int i = startIndex - 1;
        boolean itemsRemoved = false;
        CaretItemInfo lastInfo = new CaretItemInfo();
        if (i >= 0) {
            lastInfo.update(origSortedItems.get(i));
        } // Otherwise leave the default zeros in lastInfo
        
        CaretItemInfo itemInfo = new CaretItemInfo();
        while (++i < origSortedItemsSize) {
            itemInfo.update(origSortedItems.get(i));
            if (itemInfo.overlapsAtStart(lastInfo)) {
                if (nonOverlappingItems == null) {
                    nonOverlappingItems = new GapList<CaretItem>(origSortedItemsSize - 1); // At least one will be skipped
                }
                itemsRemoved = true;
                // Determine type of overlap
                if (!lastInfo.dotAtStart) { // Caret of lastInfo moved into next block
                    if (lastInfo.startsBelow(itemInfo)) {
                        // Extend selection of itemInfo to start of lastInfo
                        updateAffectedOffsets(lastInfo.startOffset, itemInfo.startOffset);
                        setSelectionStartEnd(itemInfo, lastInfo.startPos, true);
                    }
                    // Remove lastInfo's getCaret item
                    lastInfo.caretItem.markTransactionMarkRemoved();
                    origSortedItems.copyElements(copyStartIndex, i - 1, nonOverlappingItems);
                    copyStartIndex = i;
                    
                } else { // Remove itemInfo and set selection of lastInfo to end of itemInfo
                    if (itemInfo.endsAbove(lastInfo)) {
                        updateAffectedOffsets(lastInfo.endOffset, itemInfo.endOffset);
                        setSelectionStartEnd(lastInfo, itemInfo.endPos, false);
                    }
                    // Remove itemInfo's getCaret item
                    itemInfo.caretItem.markTransactionMarkRemoved();
                    origSortedItems.copyElements(copyStartIndex, i, nonOverlappingItems);
                    copyStartIndex = i + 1;
                }
            } else { // No overlapping
                // Swap the items to reuse original lastInfo
                CaretItemInfo tmp = lastInfo;
                lastInfo = itemInfo;
                itemInfo = tmp;
                if (lastInfo.endOffset > stopOffset) {
                    break;
                }
            }
        }

        if (itemsRemoved) { // At least one item removed
            if (copyStartIndex < origSortedItemsSize) {
                origSortedItems.copyElements(copyStartIndex, origSortedItemsSize, nonOverlappingItems);
            }
            GapList<CaretItem> origItems = resultItems();
            int origItemsSize = origItems.size();
            replaceItems = new GapList<>(origItemsSize);
            for (i = 0; i < origItemsSize; i++) {
                CaretItem caretItem = origItems.get(i);
                if (caretItem.isTransactionMarkRemoved()) {
                    caretItem.clearTransactionMarkRemoved();
                    if (extraRemovedItems == null) {
                        extraRemovedItems = new GapList<>();
                    }
                    extraRemovedItems.add(caretItem);
                } else {
                    replaceItems.add(caretItem);
                }
            }
            replaceSortedItems = nonOverlappingItems;
        }
    }
    
    GapList<CaretItem> addRemovedItems(GapList<CaretItem> toItems) {
        int removeSize = modEndIndex - modIndex;
        int extraRemovedSize = (extraRemovedItems != null) ? extraRemovedItems.size() : 0;
        if (removeSize + extraRemovedSize > 0) {
            if (toItems == null) {
                toItems = new GapList<>(removeSize + extraRemovedSize);
            }
            if (removeSize > 0) {
                toItems.addAll(origCaretItems, modIndex, removeSize);
            }
            if (extraRemovedSize > 0) {
                toItems.addAll(extraRemovedItems);
            }
        }
        return toItems;
    }
    
    GapList<CaretItem> addUpdateVisualBoundsItems(GapList<CaretItem> toItems) {
        GapList<CaretItem> items = resultItems();
        int size = items.size();
        for (int i = 0; i < size; i++) {
            CaretItem caretItem = items.get(i);
            if (caretItem.isUpdateVisualBounds()) {
                caretItem.clearUpdateVisualBounds();
                if (toItems == null) {
                    toItems = new GapList<>();
                }
                toItems.add(caretItem);
            }
        }
        return toItems;
    }

    private GapList<CaretItem> resultItems() {
        return (replaceItems != null) ? replaceItems : origCaretItems;
    }

    private void initReplaceItems() {
        assert (replaceItems == null) : "replaceItems already inited to " + replaceItems; // NOI18N
        int size = origCaretItems.size();
        int removeSize = modEndIndex - modIndex;
        int addSize = (addCaretItems != null) ? addCaretItems.length : 0;
        int newSize = size - removeSize + addSize;
        replaceItems = new GapList<>(newSize);
        if (removeSize > 0) {
            replaceItems.addAll(origCaretItems, 0, modIndex);
            replaceItems.addAll(origCaretItems, modEndIndex, size - modEndIndex);
        } else {
            replaceItems.addAll(origCaretItems);
        }
        if (addCaretItems != null) {
            replaceItems.addArray(replaceItems.size(), addCaretItems);
        }

        assert (replaceItems.size() == newSize);
        boolean updateIndividual = (removeSize + addSize) < (newSize >> 2); // Threshold 1/4 of total size for full resort
        if (fullResort || true) { // Force full resort
            replaceSortedItems = replaceItems.copy();
            if (newSize > 1) {
                
            }
        } else { // Partial resort TODO
            
        }
    }

    private void resetIndexes() {
        indexesLength = 0;
    }
    
    private void addToIndexes(int index) {
        if (indexes == null) {
            indexes = new int[8];
        } else if (indexesLength == indexes.length) {
            int[] orig = indexes;
            indexes = new int[indexesLength << 1];
            System.arraycopy(orig, 0, indexes, 0, indexesLength);
        }
        indexes[indexesLength++] = index;
    }
    
    
    private int findCaretItemIndex(GapList<CaretItem> caretItems, CaretItem caretItem) {
        // Method only resolves existing items not added items
        int i = caretItem.getTransactionIndexHint();
        int size = caretItems.size();
        if (i >= size || caretItems.get(i) != caretItem) {
            while (indexHintEnd < size) {
                CaretItem c = caretItems.get(indexHintEnd);
                c.setTransactionIndexHint(indexHintEnd++);
                if (c == caretItem) {
                    return indexHintEnd - 1;
                }
            }
            return -1;
        }
        return i;
    }
    
    private void updateAffectedIndexes(int startIndex, int endIndex) {
        if (affectedStartIndex == Integer.MAX_VALUE) {
            affectedStartIndex = startIndex;
            affectedEndIndex = endIndex;
        } else {
            affectedStartIndex = Math.min(affectedStartIndex, startIndex);
            affectedEndIndex = Math.max(affectedEndIndex, endIndex);
        }
    }

    private void updateAffectedOffsets(int startOffset, int endOffset) {
        if (affectedStartOffset == Integer.MAX_VALUE) { // Affected range not inited yet
            affectedStartOffset = startOffset;
            affectedEndOffset = endOffset;
        } else { // Affected range already inited
            if (startOffset < affectedStartOffset) {
                affectedStartOffset = startOffset;
            }
            if (endOffset > affectedEndOffset) {
                affectedEndOffset = endOffset;
            }
        }
    }

    static CaretItem[] asCaretItems(EditorCaret caret, @NonNull List<Position> dotAndSelectionStartPosPairs) {
        int size = dotAndSelectionStartPosPairs.size();
        if ((size & 1) != 0) {
            throw new IllegalStateException("Passed list has size=" + size + " which is not an even number.");
        }
        CaretItem[] addedCarets = new CaretItem[size >> 1];
        int listIndex = 0;
        for (int j = 0; j < addedCarets.length; j++) {
            Position dotPos = dotAndSelectionStartPosPairs.get(listIndex++);
            Position selectionStartPos = dotAndSelectionStartPosPairs.get(listIndex++);
            CaretItem caretItem = new CaretItem(caret, dotPos, selectionStartPos);
            addedCarets[j] = caretItem;
        }
        return addedCarets;
    }

    enum RemoveType {
        NO_REMOVE,
        REMOVE_LAST_CARET,
        RETAIN_LAST_CARET,
        REMOVE_ALL_CARETS,
        DOCUMENT_REMOVE,
        DOCUMENT_INSERT_ZERO_OFFSET
    }
    
    /**
     * Helper class for resolving overlapping getCaret selections.
     */
    private static final class CaretItemInfo {
        
        CaretItem caretItem;
        
        Position startPos;
        
        Position endPos;

        int startOffset;

        int startShift;
        
        int endOffset;

        int endShift;
        
        boolean dotAtStart;
        
        void update(CaretItem caret) {
            this.caretItem = caret;
            Position dotPos = caret.getDotPosition();
            if (dotPos != null) {
                int dotOffset = dotPos.getOffset();
                int dotShift = ShiftPositions.getShift(dotPos);
                Position markPos = caret.getMarkPosition();
                if (markPos != null && markPos != dotPos) { // Still they may be equal which means no selection
                    int markOffset = markPos.getOffset();
                    int markShift = ShiftPositions.getShift(markPos);
                    if (markOffset < dotOffset || (markOffset == dotOffset && markShift <= dotShift)) {
                        startPos = markPos;
                        endPos = dotPos;
                        startOffset = markOffset;
                        startShift = markShift;
                        endOffset = dotOffset;
                        endShift = dotShift;
                        dotAtStart = false;
                    } else {
                        startPos = dotPos;
                        endPos = markPos;
                        startOffset = dotOffset;
                        startShift = dotShift;
                        endOffset = markOffset;
                        endShift = markShift;
                        dotAtStart = true;
                    }
                } else {
                    startPos = endPos = dotPos;
                    startOffset = endOffset = dotOffset;
                    startShift = startShift = dotShift;
                    dotAtStart = false;
                }
            } else {
                clear();
            }
        }

        private void clear() {
            caretItem = null;
            startPos = endPos = null;
            startOffset = endOffset = 0;
            startShift = startShift = 0;
            dotAtStart = false;
        }
        
        private boolean overlapsAtStart(CaretItemInfo info) {
            return (ShiftPositions.compare(info.endOffset, info.endShift,
                    startOffset, startShift) > 0);
        }
        
        private boolean startsBelow(CaretItemInfo info) {
            return (ShiftPositions.compare(startOffset, startShift,
                    info.startOffset, info.startShift) < 0);
        }
        
        private boolean endsAbove(CaretItemInfo info) {
            return (ShiftPositions.compare(endOffset, endShift,
                    info.endOffset, info.endShift) > 0);
        }
        
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
    package org.netbeans.api.editor.caret;

import org.netbeans.spi.editor.caret.CaretMoveHandler;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Composite;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.swing.Action;
import javax.swing.JComponent;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JViewport;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.TransferHandler;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.DefaultEditorKit;
import javax.swing.text.Document;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import javax.swing.text.StyleConstants;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.editor.EditorUtilities;
import org.netbeans.api.editor.document.AtomicLockDocument;
import org.netbeans.api.editor.document.AtomicLockEvent;
import org.netbeans.api.editor.document.AtomicLockListener;
import org.netbeans.api.editor.document.LineDocument;
import org.netbeans.api.editor.document.LineDocumentUtils;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.lib.editor.util.ArrayUtilities;
import org.netbeans.lib.editor.util.GapList;
import org.netbeans.lib.editor.util.ListenerList;
import org.netbeans.lib.editor.util.swing.DocumentListenerPriority;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
import org.netbeans.modules.editor.lib2.RectangularSelectionCaretAccessor;
import org.netbeans.modules.editor.lib2.RectangularSelectionTransferHandler;
import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;
import org.netbeans.modules.editor.lib2.actions.EditorActionUtilities;
import org.netbeans.modules.editor.lib2.highlighting.CaretOverwriteModeHighlighting;
import org.netbeans.modules.editor.lib2.view.DocumentView;
import org.netbeans.modules.editor.lib2.view.LockedViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyEvent;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyListener;
import org.netbeans.modules.editor.lib2.view.ViewUtils;
import org.openide.util.Exceptions;
import org.openide.util.WeakListeners;

/**
 * Extension to standard Swing caret used by all NetBeans editors.
 * <br>
 * It supports multi-caret editing mode where an arbitrary number of carets
 * is placed at arbitrary positions throughout a document.
 * In this mode each caret is described by its <code>CaretInfo</code> object.
 * <br>
 * The caret works over text components having {@link AbstractDocument} based document.
 *
 * @author Miloslav Metelka
 * @author Ralph Ruijs
 * @since 2.6
 */
public final class EditorCaret implements Caret {
    
    // Temporary until rectangular selection gets ported to multi-caret support
    private static final String RECTANGULAR_SELECTION_PROPERTY = "rectangular-selection"; // NOI18N
    private static final String RECTANGULAR_SELECTION_REGIONS_PROPERTY = "rectangular-selection-regions"; // NOI18N
    
    // -J-Dorg.netbeans.editor.BaseCaret.level=FINEST
    private static final Logger LOG = Logger.getLogger(EditorCaret.class.getName());
    
    static {
        RectangularSelectionCaretAccessor.register(new RectangularSelectionCaretAccessor() {
            @Override
            public void setRectangularSelectionToDotAndMark(EditorCaret editorCaret) {
                editorCaret.setRectangularSelectionToDotAndMark();
            }

            @Override
            public void updateRectangularUpDownSelection(EditorCaret editorCaret) {
                editorCaret.updateRectangularUpDownSelection();
            }

            @Override
            public void extendRectangularSelection(EditorCaret editorCaret, boolean toRight, boolean ctrl) {
                editorCaret.extendRectangularSelection(toRight, ctrl);
            }
        });
    }

    static final long serialVersionUID = 0L;

    /**
     * Non-empty list of individual carets in the order they were created.
     * At least one item is always present.
     */
    private @NonNull GapList<CaretItem> caretItems;
    
    /**
     * Non-empty list of individual carets in the order they were created.
     * At least one item is always present.
     */
    private @NonNull GapList<CaretItem> sortedCaretItems;
    
    /**
     * Cached infos corresponding to caret items or null if any of the items were changed
     *  so another copy of the caret items- (translated into caret infos) will get created
     * upon query to {@link #getCarets() }.
     * <br>
     * Once the list gets created both the list content and information in each caret info are immutable.
     */
    private List<CaretInfo> caretInfos;
    
    /**
     * Cached infos corresponding to sorted caret items or null if any of the sorted items were changed
     * so another copy of the sorted caret items (translated into caret infos) will get created
     * upon query to {@link #getSortedCarets() }.
     * <br>
     * Once the list gets created both the list content and information in each caret info are immutable.
     */
    private List<CaretInfo> sortedCaretInfos;
    
    /** Component this caret is bound to */
    private JTextComponent component;
    
    /** List of individual carets */
    private boolean overwriteMode;

    private final ListenerList<EditorCaretListener> listenerList;

    private final ListenerList<ChangeListener> changeListenerList;

    /**
     * Implementor of various listeners.
     */
    private final ListenerImpl listenerImpl;
    
    /** Is the caret visible (after <code>setVisible(true)</code> call? */
    private boolean visible;

    /**
     * Whether blinking caret is currently visible on the screen.
     * <br>
     * This changes from true to false after each tick of a timer
     * (assuming <code>visible == true</code>).
     */
    private boolean blinkVisible;

    /**
     * Determine if a possible selection would be displayed or not.
     */
    private boolean selectionVisible;

    /** Type of the caret */
    private CaretType type = CaretType.THICK_LINE_CARET;

    /** Width of caret */
    private int thickCaretWidth = EditorPreferencesDefaults.defaultThickCaretWidth;
    
    private MouseState mouseState = MouseState.DEFAULT;
    
    /** Timer used for blinking the caret */
    private Timer flasher;

    private Action selectWordAction;
    private Action selectLineAction;

    private AbstractDocument activeDoc;
    
    private Thread lockThread;
    
    private int lockDepth;
    
    private CaretTransaction activeTransaction;
    
    /**
     * Items from previous transaction(s) that need their visual rectangle
     * to get repainted to clear the previous caret representation visually.
     */
    private GapList<CaretItem> pendingRepaintRemovedItemsList;

    /**
     * Items from previous transaction(s) that need their visual bounds
     * to be recomputed and caret to be repainted then.
     */
    private GapList<CaretItem> pendingUpdateVisualBoundsItemsList;
    
    /**
     * Caret item to which the view should scroll or null for no scrolling.
     */
    private CaretItem scrollToItem;

    /**
     * Whether the text is being modified under atomic lock.
     * If so just one caret change is fired at the end of all modifications.
     */
    private transient boolean inAtomicLock = false;
    private transient boolean inAtomicUnlock = false;
    
    /**
     * Helps to check whether there was modification performed
     * and so the caret change needs to be fired.
     */
    private transient boolean modified;
    
    /**
     * Set to true once the folds have changed. The caret should retain
     * its relative visual position on the screen.
     */
    private boolean updateAfterFoldHierarchyChange;
    
    /**
     * Whether at least one typing change occurred during possibly several atomic operations.
     */
    private boolean typingModificationOccurred;

    private Preferences prefs = null;

    private PreferenceChangeListener weakPrefsListener = null;
    
    private boolean caretUpdatePending;
    
    /**
     * Minimum selection start for word and line selections.
     * This helps to ensure that when extending word (or line) selections
     * the selection will always include at least the initially selected word (or line).
     */
    private int minSelectionStartOffset;
    
    private int minSelectionEndOffset;
    
    private boolean rectangularSelection;
    
    /**
     * Rectangle that corresponds to model2View of current point of selection.
     */
    private Rectangle rsDotRect;

    /**
     * Rectangle that corresponds to model2View of beginning of selection.
     */
    private Rectangle rsMarkRect;
    
    /**
     * Rectangle marking rectangular selection.
     */
    private Rectangle rsPaintRect;
    
    /**
     * List of start-pos and end-pos pairs that denote rectangular selection
     * on the selected lines.
     */
    private List<Position> rsRegions;

    /**
     * Used for showing the default cursor instead of the text cursor when the
     * mouse is over a block of selected text.
     * This field is used to prevent repeated calls to component.setCursor()
     * with the same cursor.
     */
    private boolean showingTextCursor = true;
    
    public EditorCaret() {
        caretItems = new GapList<>();
        sortedCaretItems = new GapList<>();
        CaretItem singleCaret = new CaretItem(this, null, null);
        caretItems.add(singleCaret);
        sortedCaretItems.add(singleCaret);

        listenerList = new ListenerList<>();
        changeListenerList = new ListenerList<>();
        listenerImpl = new ListenerImpl();
    }

    @Override
    public int getDot() {
        return getLastCaret().getDot();
    }
    
    @Override
    public int getMark() {
        return getLastCaret().getMark();
    }
    
    /**
     * Get information about all existing carets in the order they were created.
     * <br>
     * The list always has at least one item. The last caret (last item of the list)
     * is the most recent caret.
     * <br>
     * The list is a snapshot of the current state of the carets. The list content itself and its contained
     * caret infos are guaranteed not change after subsequent calls to caret API or document modifications.
     * <br>
     * The list is nonmodifiable.
     * <br>
     * This method should be called with document's read-lock acquired which will guarantee
     * stability of {@link CaretInfo#getDot() } and {@link CaretInfo#getMark() } and prevent
     * caret merging as a possible effect of document modifications.
     * 
     * @return copy of caret list with size &gt;= 1 containing information about all carets.
     */
    public @NonNull List<CaretInfo> getCarets() {
        synchronized (listenerList) {
            if (caretInfos == null) {
                int i = caretItems.size();
                CaretInfo[] infos = new CaretInfo[i--];
                for (; i >= 0; i--) {
                    infos[i] = caretItems.get(i).getValidInfo();
                }
                caretInfos = ArrayUtilities.unmodifiableList(infos);
            }
            return caretInfos;
        }
    }
    
    /**
     * Get information about all existing carets sorted by dot positions in ascending order.
     * <br>
     * The list is a snapshot of the current state of the carets. The list content itself and its contained
     * caret infos are guaranteed not change after subsequent calls to caret API or document modifications.
     * <br>
     * The list is nonmodifiable.
     * <br>
     * This method should be called with document's read-lock acquired which will guarantee
     * stability of {@link CaretInfo#getDot() } and {@link CaretInfo#getMark() } and prevent
     * caret merging as a possible effect of document modifications.
     * 
     * @return copy of caret list with size &gt;= 1 sorted by dot positions in ascending order.
     */
    public @NonNull List<CaretInfo> getSortedCarets() {
        synchronized (listenerList) {
            if (sortedCaretInfos == null) {
                int i = sortedCaretItems.size();
                CaretInfo[] sortedInfos = new CaretInfo[i--];
                for (; i >= 0; i--) {
                    sortedInfos[i] = sortedCaretItems.get(i).getValidInfo();
                }
                sortedCaretInfos = ArrayUtilities.unmodifiableList(sortedInfos);
            }
            return sortedCaretInfos;
        }
    }
    
    /**
     * Get info about the most recently created caret.
     * <br>
     * For normal mode this is the only caret returned by {@link #getCarets() }.
     * <br>
     * For multi-caret mode this is the last item in the list returned by {@link #getCarets() }.
     * 
     * @return last caret (the most recently added caret).
     */
    public @NonNull CaretInfo getLastCaret() {
        synchronized (listenerList) {
            return caretItems.get(caretItems.size() - 1).getValidInfo();
        }
    }
    
    /**
     * Get information about the caret at the specified offset.
     *
     * @param offset the offset of the caret
     * @return CaretInfo for the caret at offset, null if there is no caret or
     * the offset is invalid
     */
    public @CheckForNull CaretInfo getCaretAt(int offset) {
        return null; // TBD
    }
    
    /**
     * Assign a new offset to the caret in the underlying document.
     * <br>
     * This method implicitly sets the selection range to zero.
     * <br>
     * If multiple carets are present this method retains only last caret
     * which then moves to the given offset.
     * 
     * @param offset {@inheritDoc}
     * @see Caret#setDot(int) 
     */
    public @Override void setDot(final int offset) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("setDot: offset=" + offset); //NOI18N
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.log(Level.INFO, "setDot call stack", new Exception());
            }
        }
        runTransaction(CaretTransaction.RemoveType.RETAIN_LAST_CARET, 0, null, new CaretMoveHandler() {
            @Override
            public void moveCarets(CaretMoveContext context) {
                Document doc = context.getComponent().getDocument();
                if (doc != null) {
                    try {
                        Position pos = doc.createPosition(offset);
                        context.setDot(context.getOriginalLastCaret(), pos);
                    } catch (BadLocationException ex) {
                        // Ignore the setDot() request
                    }
                }
            }
        });
    }

    /**
     * Moves the caret position (dot) to some other position, leaving behind the
     * mark. This is useful for making selections.
     * <br>
     * If multiple carets are present this method retains all carets
     * and moves the dot of the last caret to the given offset.
     * 
     * @param offset {@inheritDoc}
     * @see Caret#moveDot(int) 
     */
    public @Override void moveDot(final int offset) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("moveDot: offset=" + offset); //NOI18N
        }
        
        runTransaction(CaretTransaction.RemoveType.NO_REMOVE, 0, null, new CaretMoveHandler() {
            @Override
            public void moveCarets(CaretMoveContext context) {
                Document doc = context.getComponent().getDocument();
                if (doc != null) {
                    try {
                        Position pos = doc.createPosition(offset);
                        context.moveDot(context.getOriginalLastCaret(), pos);
                    } catch (BadLocationException ex) {
                        // Ignore the setDot() request
                    }
                }
            }
        });
    }

    /**
     * Move multiple carets or create/modify selections.
     * <br>
     * For performance reasons this is made as a single transaction over the caret
     * with only one change event being fired.
     * <br>
     * Note that the move handler does not permit to add or remove carets - this has to be performed
     * by other methods present in this class (as another transaction over the editor caret).
     * <br>
     * <pre>
     * <code>
     *   // Go one line up with all carets
     *   editorCaret.moveCarets(new CaretMoveHandler() {
     *     &#64;Override public void moveCarets(CaretMoveContext context) {
     *       for (CaretInfo caretInfo : context.getOriginalSortedCarets()) {
     *         try {
     *           int dot = caretInfo.getDot();
     *           dot = Utilities.getPositionAbove(target, dot, p.x);
     *           Position dotPos = doc.createPosition(dot);
     *           context.setDot(caretInfo, dotPos);
     *         } catch (BadLocationException e) {
     *           // the position stays the same
     *         }
     *       }
     *     }
     *   });
     * </code>
     * </pre>
     *
     * @param moveHandler non-null move handler to perform the changes. The handler's methods
     *  will be given a context to operate on.
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     */
    public int moveCarets(@NonNull CaretMoveHandler moveHandler) {
        return runTransaction(CaretTransaction.RemoveType.NO_REMOVE, 0, null, moveHandler);
    }

    /**
     * Create a new caret at the given position with a possible selection.
     * <br>
     * The caret will become the last caret of the list returned by {@link #getCarets() }.
     * <br>
     * This method requires the caller to have either read lock or write lock acquired
     * over the underlying document.
     * <br>
     * <pre>
     * <code>
     *   editorCaret.addCaret(pos, pos); // Add a new caret at pos.getOffset()
     * 
     *   Position pos2 = doc.createPosition(pos.getOffset() + 2);
     *   // Add a new caret with selection starting at pos and extending to pos2 with caret located at pos2
     *   editorCaret.addCaret(pos2, pos);
     *   // Add a new caret with selection starting at pos and extending to pos2 with caret located at pos
     *   editorCaret.addCaret(pos, pos2);
     * </code>
     * </pre>
     * 
     * @param dotPos position of the newly created caret.
     * @param markPos beginning of the selection (the other end is dotPos) or the same position like dotPos for no selection.
     *  The markPos may have higher offset than dotPos to select in a backward direction.
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     *  <br>
     *  Note that adding a new caret to offset where another caret is already located may lead
     *  to its immediate removal.
     */
    public int addCaret(@NonNull Position dotPos, @NonNull Position markPos) {
        return runTransaction(CaretTransaction.RemoveType.NO_REMOVE, 0,
                new CaretItem[] { new CaretItem(this, dotPos, markPos) }, null);
    }
    
    /**
     * Add multiple carets at once.
     * <br>
     * It is similar to calling {@link #addCaret(javax.swing.text.Position, javax.swing.text.Position) }
     * multiple times but this method is more efficient (it only fires caret change once).
     * <br>
     * This method requires the caller to have either read lock or write lock acquired
     * over the underlying document.
     * <br>
     * <pre>
     * <code>
     *   List&lt;Position&gt; pairs = new ArrayList&lt;&gt;();
     *   pairs.add(dotPos);
     *   pairs.add(dotPos);
     *   pairs.add(dot2Pos);
     *   pairs.add(mark2Pos);
     *   // Add caret located at dotPos.getOffset() and another one with selection
     *   // starting at mark2Pos and extending to dot2Pos with caret located at dot2Pos
     *   editorCaret.addCaret(pairs);
     * </code>
     * </pre>
     * 
     * @param dotAndMarkPosPairs list of position pairs consisting of dot position
     *  and mark position (selection start position) which may be the same position like the dot
     *  if the particular caret has no selection. The list must have even size.
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     */
    public int addCarets(@NonNull List<Position> dotAndMarkPosPairs) {
        return runTransaction(CaretTransaction.RemoveType.NO_REMOVE, 0,
                CaretTransaction.asCaretItems(this, dotAndMarkPosPairs), null);
    }

    /**
     * Replace all current carets with the new ones.
     * <br>
     * This method requires the caller to have either read lock or write lock acquired
     * over the underlying document.
     * <br>
     * @param dotAndMarkPosPairs list of position pairs consisting of dot position
     *  and mark position (selection start position) which may be the same position like dot
     *  if the particular caret has no selection. The list must have even size.
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     */
    public int replaceCarets(@NonNull List<Position> dotAndMarkPosPairs) {
        if (dotAndMarkPosPairs.isEmpty()) {
            throw new IllegalArgumentException("dotAndSelectionStartPosPairs list must not be empty");
        }
        CaretItem[] addedItems = CaretTransaction.asCaretItems(this, dotAndMarkPosPairs);
        return runTransaction(CaretTransaction.RemoveType.REMOVE_ALL_CARETS, 0, addedItems, null);
    }

    /**
     * Remove last added caret (determined by {@link #getLastCaret() }).
     * <br>
     * If there is just one caret the method has no effect.
     * 
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     */
    public int removeLastCaret() {
        return runTransaction(CaretTransaction.RemoveType.REMOVE_LAST_CARET, 0, null, null);
    }

    /**
     * Switch to single caret mode by removing all carets except the last caret.
     * @return difference between current count of carets and the number of carets when the operation started.
     *  Returns Integer.MIN_VALUE if the operation was cancelled due to the caret not being installed in any text component
     *  or no document installed in the text component.
     */
    public int retainLastCaretOnly() {
        return runTransaction(CaretTransaction.RemoveType.RETAIN_LAST_CARET, 0, null, null);
    }
    
    /**
     * Adds listener to track caret changes in detail.
     * 
     * @param listener non-null listener.
     */
    public void addEditorCaretListener(@NonNull EditorCaretListener listener) {
        listenerList.add(listener);
    }
    
    /**
     * Adds listener to track caret position changes (to fulfil {@link Caret} interface).
     */
    @Override
    public void addChangeListener(@NonNull ChangeListener l) {
        changeListenerList.add(l);
    }

    public void removeEditorCaretListener(@NonNull EditorCaretListener listener) {
        listenerList.remove(listener);
    }
    
    /**
     * Removes listener to track caret position changes (to fulfil {@link Caret} interface).
     */
    @Override
    public void removeChangeListener(@NonNull ChangeListener l) {
        changeListenerList.remove(l);
    }

    /**
     * Determines if the caret is currently visible (it may be blinking depending on settings).
     * <p>
     * Caret becomes visible after <code>setVisible(true)</code> gets called on it.
     *
     * @return <code>true</code> if visible else <code>false</code>
     */
    @Override
    public boolean isVisible() {
        synchronized (listenerList) {
            return visible;
        }
    }

    /**
     * Sets the caret visibility, and repaints the caret.
     *
     * @param visible the visibility specifier
     * @see Caret#setVisible
     */
    @Override
    public void setVisible(boolean visible) {
        if (LOG.isLoggable(Level.FINER)) {
            LOG.finer("BaseCaret.setVisible(" + visible + ")\n");
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.log(Level.INFO, "", new Exception());
            }
        }
        synchronized (listenerList) {
            if (flasher != null) {
                if (this.visible) {
                    flasher.stop();
                }
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.finer((visible ? "Starting" : "Stopping") + // NOI18N
                            " the caret blinking timer: " + dumpVisibility() + '\n'); // NOI18N
                }
                this.visible = visible;
                if (visible) {
                    flasher.start();
                } else {
                    flasher.stop();
                }
            }
        }
        JTextComponent c = component;
        if (c != null) {
            // TODO only paint carets showing on screen
            List<CaretInfo> sortedCarets = getSortedCarets();
            for (CaretInfo caret : sortedCarets) {
                CaretItem caretItem = caret.getCaretItem();
                if (caretItem.getCaretBounds() != null) {
                    Rectangle repaintRect = caretItem.getCaretBounds();
                    c.repaint(repaintRect);
                }
            }
        }
    }

    @Override
    public boolean isSelectionVisible() {
        return selectionVisible;
    }

    @Override
    public void setSelectionVisible(boolean v) {
        if (selectionVisible == v) {
            return;
        }
        JTextComponent c = component;
        Document doc;
        if (c != null && (doc = c.getDocument()) != null) {
            selectionVisible = v;
            // [TODO] ensure to repaint 
        }
    }

    @Override
    public void install(JTextComponent c) {
        assert (SwingUtilities.isEventDispatchThread()); // must be done in AWT
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Installing to " + s2s(c)); //NOI18N
        }
        
        component = c;
        visible = true;
        modelChanged(null, c.getDocument());

        Boolean b = (Boolean) c.getClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY);
        overwriteMode = (b != null) ? b : false;
        updateOverwriteModeLayer(true);
        setBlinkVisible(true);
        
        // Attempt to assign initial bounds - usually here the component
        // is not yet added to the component hierarchy.
        updateAllCaretsBounds();
        
        if(getLastCaretItem().getCaretBounds() == null) {
            // For null bounds wait for the component to get resized
            // and attempt to recompute bounds then
            component.addComponentListener(listenerImpl);
        }

        component.addPropertyChangeListener(listenerImpl);
        component.addFocusListener(listenerImpl);
        component.addMouseListener(listenerImpl);
        component.addMouseMotionListener(listenerImpl);
        component.addKeyListener(listenerImpl);
        ViewHierarchy.get(component).addViewHierarchyListener(listenerImpl);

        if (component.hasFocus()) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Component has focus, calling BaseCaret.focusGained(); doc=" // NOI18N
                    + component.getDocument().getProperty(Document.TitleProperty) + '\n');
            }
            listenerImpl.focusGained(null); // emulate focus gained
        }

        dispatchUpdate(false);
    }

    @Override
    public void deinstall(JTextComponent c) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Deinstalling from " + s2s(c)); //NOI18N
        }
        
        synchronized (listenerList) {
            if (flasher != null) {
                setBlinkRate(0);
            }
        }
        
        c.removeComponentListener(listenerImpl);
        c.removePropertyChangeListener(listenerImpl);
        c.removeFocusListener(listenerImpl);
        c.removeMouseListener(listenerImpl);
        c.removeMouseMotionListener(listenerImpl);
        ViewHierarchy.get(c).removeViewHierarchyListener(listenerImpl);

        
        modelChanged(activeDoc, null);
    }

    @Override
    public void paint(Graphics g) {
        JTextComponent c = component;
        if (c == null) return;
        
        // Check whether the caret was moved but the component was not
        // validated yet and therefore the caret bounds are still null
        // and if so compute the bounds and scroll the view if necessary.
        // TODO - could this be done by an extra flag rather than bounds checking??
        CaretItem lastCaret = getLastCaretItem();
        if (getDot() != 0 && lastCaret.getCaretBounds() == null) {
            update(true);
        }
        
        List<CaretInfo> carets = getSortedCarets();
        for (CaretInfo caretInfo : carets) { // TODO only paint the items in the clipped area - use binary search to located first item
            CaretItem caretItem = caretInfo.getCaretItem();
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.finest("BaseCaret.paint(): caretBounds=" + caretItem.getCaretBounds() + dumpVisibility() + '\n');
            }
            if (caretItem.getCaretBounds() != null && isVisible() && blinkVisible) {
                paintCaret(g, caretItem);
            }
            if (rectangularSelection && rsPaintRect != null && g instanceof Graphics2D) {
                Graphics2D g2d = (Graphics2D) g;
                Stroke stroke = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] {4, 2}, 0);
                Stroke origStroke = g2d.getStroke();
                Color origColor = g2d.getColor();
                try {
                    // Render translucent rectangle
                    Color selColor = c.getSelectionColor();
                    g2d.setColor(selColor);
                    Composite origComposite = g2d.getComposite();
                    try {
                        g2d.setComposite(AlphaComposite.SrcOver.derive(0.2f));
                        g2d.fill(rsPaintRect);
                    } finally {
                        g2d.setComposite(origComposite);
                    }
                    // Paint stroked line around rectangular selection rectangle
                    g.setColor(c.getCaretColor());
                    g2d.setStroke(stroke);
                    Rectangle onePointSmallerRect = new Rectangle(rsPaintRect);
                    onePointSmallerRect.width--;
                    onePointSmallerRect.height--;
                    g2d.draw(onePointSmallerRect);

                } finally {
                    g2d.setStroke(origStroke);
                    g2d.setColor(origColor);
                }
            }
        }
    }

    public @Override void setMagicCaretPosition(Point p) {
        getLastCaretItem().setMagicCaretPosition(p);
    }

    public @Override final Point getMagicCaretPosition() {
        return getLastCaretItem().getMagicCaretPosition();
    }

    public @Override void setBlinkRate(int rate) {
        if (LOG.isLoggable(Level.FINER)) {
            LOG.finer("setBlinkRate(" + rate + ")" + dumpVisibility() + '\n'); // NOI18N
        }
        synchronized (listenerList) {
            if (flasher == null && rate > 0) {
                flasher = new Timer(rate, listenerImpl);
            }
            if (flasher != null) {
                if (rate > 0) {
                    if (flasher.getDelay() != rate) {
                        flasher.setDelay(rate);
                    }
                } else { // zero rate - don't blink
                    flasher.stop();
                    flasher.removeActionListener(listenerImpl);
                    flasher = null;
                    setBlinkVisible(true);
                    if (LOG.isLoggable(Level.FINER)){
                        LOG.finer("Zero blink rate - no blinking. flasher=null; blinkVisible=true"); // NOI18N
                    }
                }
            }
        }
    }

    @Override
    public int getBlinkRate() {
        synchronized (listenerList) {
            return (flasher != null) ? flasher.getDelay() : 0;
        }
    }

    /**
     * 
     */
    void setRectangularSelectionToDotAndMark() {
        int dotOffset = getDot();
        int markOffset = getMark();
        try {
            rsDotRect = component.modelToView(dotOffset);
            rsMarkRect = component.modelToView(markOffset);
        } catch (BadLocationException ex) {
            rsDotRect = rsMarkRect = null;
        }
        updateRectangularSelectionPaintRect();
    }

    /**
     * 
     */
    void updateRectangularUpDownSelection() {
        JTextComponent c = component;
        int dotOffset = getDot();
        try {
            Rectangle r = c.modelToView(dotOffset);
            rsDotRect.y = r.y;
            rsDotRect.height = r.height;
        } catch (BadLocationException ex) {
            // Leave rsDotRect unchanged
        }
    }
    
    /**
     * Extend rectangular selection either by char in a specified selection
     * or by word (if ctrl is pressed).
     *
     * @param toRight true for right or false for left.
     * @param ctrl true for ctrl pressed.
     */
    void extendRectangularSelection(boolean toRight, boolean ctrl) {
        JTextComponent c = component;
        Document doc = c.getDocument();
        int dotOffset = getDot();
        Element lineRoot = doc.getDefaultRootElement();
        int lineIndex = lineRoot.getElementIndex(dotOffset);
        Element lineElement = lineRoot.getElement(lineIndex);
        float charWidth;
        LockedViewHierarchy lvh = ViewHierarchy.get(c).lock();
        try {
            charWidth = lvh.getDefaultCharWidth();
        } finally {
            lvh.unlock();
        }
        int newDotOffset = -1;
        try {
            int newlineOffset = lineElement.getEndOffset() - 1;
            Rectangle newlineRect = c.modelToView(newlineOffset);
            if (!ctrl) {
                if (toRight) {
                    if (rsDotRect.x < newlineRect.x) {
                        newDotOffset = dotOffset + 1;
                    } else {
                        rsDotRect.x += charWidth;
                    }
                } else { // toLeft
                    if (rsDotRect.x > newlineRect.x) {
                        rsDotRect.x -= charWidth;
                        if (rsDotRect.x < newlineRect.x) { // Fix on rsDotRect
                            newDotOffset = newlineOffset;
                        }
                    } else {
                        newDotOffset = Math.max(dotOffset - 1, lineElement.getStartOffset());
                    }
                }

            } else { // With Ctrl
                int numVirtualChars = 8; // Number of virtual characters per one Ctrl+Shift+Arrow press
                if (toRight) {
                    if (rsDotRect.x < newlineRect.x) {
//[TODO] fix                        newDotOffset = Math.min(Utilities.getNextWord(c, dotOffset), lineElement.getEndOffset() - 1);
                    } else { // Extend virtually
                        rsDotRect.x += numVirtualChars * charWidth;
                    }
                } else { // toLeft
                    if (rsDotRect.x > newlineRect.x) { // Virtually extended
                        rsDotRect.x -= numVirtualChars * charWidth;
                        if (rsDotRect.x < newlineRect.x) {
                            newDotOffset = newlineOffset;
                        }
                    } else {
//[TODO] fix                        newDotOffset = Math.max(Utilities.getPreviousWord(c, dotOffset), lineElement.getStartOffset());
                    }
                }
            }

            if (newDotOffset != -1) {
                rsDotRect = c.modelToView(newDotOffset);
                moveDot(newDotOffset); // updates rs and fires state change
            } else {
                updateRectangularSelectionPaintRect();
                fireStateChanged();
            }
        } catch (BadLocationException ex) {
            // Leave selection as is
        }
    }
    
    
    // Private implementation
    
    /** This method should only be accessed by transaction's methods */
    GapList<CaretItem> getCaretItems() {
        return caretItems; // No sync as this should only be accessed by transaction's methods
    }
    
    /** This method should only be accessed by transaction's methods */
    GapList<CaretItem> getSortedCaretItems() {
        return sortedCaretItems; // No sync as this should only be accessed by transaction's methods
    }

    /** This method may be accessed arbitrarily */
    private CaretItem getLastCaretItem() {
        synchronized (listenerList) {
            return caretItems.get(caretItems.size() - 1);
        }
    }

    /**
     * Run a transaction to modify number of carets or their dots or selections.
     * @param removeType type of carets removal.
     * @param offset offset of document text removal otherwise the value is ignored.
     *  Internally this is also used for an end offset of the insertion at offset zero once it happens.
     * @param addCarets carets to be added if any.
     * @param moveHandler caret move handler or null if there's no caret moving. API client's move handlers
     *  are only invoked without any extra removals or additions so the original caret infos are used.
     *  Internal transactions may use caret additions or removals together with caret move handlers
     *  but they are also passed with original caret infos so the handlers must be aware of the removal
     *  and only pick the valid non-removed items.
     * @return 
     */
    private int runTransaction(CaretTransaction.RemoveType removeType, int offset, CaretItem[] addCarets, CaretMoveHandler moveHandler) {
        lock();
        try {
            if (activeTransaction == null) {
                JTextComponent c = component;
                Document d = activeDoc;
                if (c != null && d != null) {
                    activeTransaction = new CaretTransaction(this, c, d);
                    try {
                        activeTransaction.replaceCarets(removeType, offset, addCarets);
                        if (moveHandler != null) {
                            activeTransaction.runCaretMoveHandler(moveHandler);
                        }
                        activeTransaction.removeOverlappingRegions();
                        int diffCount = 0;
                        synchronized (listenerList) {
                            GapList<CaretItem> replaceItems = activeTransaction.getReplaceItems();
                            if (replaceItems != null) {
                                diffCount = replaceItems.size() - caretItems.size();
                                caretItems = replaceItems;
                                sortedCaretItems = activeTransaction.getSortedCaretItems();
                                assert (sortedCaretItems != null) : "Null sortedCaretItems! removeType=" + removeType; // NOI18N
                            }
                        }
                        if (activeTransaction.isAnyChange()) {
                            caretInfos = null;
                            sortedCaretInfos = null;
                        }
                        pendingRepaintRemovedItemsList = activeTransaction.
                                addRemovedItems(pendingRepaintRemovedItemsList);
                        pendingUpdateVisualBoundsItemsList = activeTransaction.
                                addUpdateVisualBoundsItems(pendingUpdateVisualBoundsItemsList);
                        if (pendingUpdateVisualBoundsItemsList != null || pendingRepaintRemovedItemsList != null) {
                            // For now clear the lists and use old way TODO update to selective updating and rendering
                            fireStateChanged();
                            dispatchUpdate(true);
                            pendingRepaintRemovedItemsList = null;
                            pendingUpdateVisualBoundsItemsList = null;
                        }
                        return diffCount;
                    } finally {
                        activeTransaction = null;
                    }
                }
                return Integer.MIN_VALUE;
                
            } else { // Nested transaction - document insert/remove within transaction
                switch (removeType) {
                    case DOCUMENT_REMOVE:
                        activeTransaction.documentRemove(offset);
                        break;
                    case DOCUMENT_INSERT_ZERO_OFFSET:
                        activeTransaction.documentInsertAtZeroOffset(offset);
                        break;
                    default:
                        throw new AssertionError("Unsupported removeType=" + removeType + " in nested transaction"); // NOI18N
                }
                return 0;
            }
        } finally {
            unlock();
        }
    }
    
    private void moveDotCaret(int offset, CaretItem caret) throws IllegalStateException {
        JTextComponent c = component;
        AbstractDocument doc;
        if (c != null && (doc = activeDoc) != null) {
            if (offset >= 0 && offset <= doc.getLength()) {
                doc.readLock();
                try {
                    int oldCaretPos = caret.getDot();
                    if (offset == oldCaretPos) { // no change
                        return;
                    }
                    caret.setDotPos(doc.createPosition(offset));
                    // Selection highlighting should be handled automatically by highlighting layers
                    if (rectangularSelection) {
                        Rectangle r = c.modelToView(offset);
                        if (rsDotRect != null) {
                            rsDotRect.y = r.y;
                            rsDotRect.height = r.height;
                        } else {
                            rsDotRect = r;
                        }
                        updateRectangularSelectionPaintRect();
                    }
                } catch (BadLocationException e) {
                    throw new IllegalStateException(e.toString());
                    // position is incorrect
                } finally {
                    doc.readUnlock();
                }
            }
            fireStateChanged();
            dispatchUpdate(true);
        }
    }
    
    private void fireEditorCaretChange(EditorCaretEvent evt) {
        for (EditorCaretListener listener : listenerList.getListeners()) {
            listener.caretChanged(evt);
        }
    }
    
    /**
     * Notifies listeners that caret position has changed.
     */
    private void fireStateChanged() {
        Runnable runnable = new Runnable() {
            public @Override void run() {
                JTextComponent c = component;
                if (c == null || c.getCaret() != EditorCaret.this) {
                    return;
                }
                fireEditorCaretChange(new EditorCaretEvent(EditorCaret.this, 0, Integer.MAX_VALUE)); // [TODO] temp firing without detailed info
                ChangeEvent evt = new ChangeEvent(EditorCaret.this);
                List<ChangeListener> listeners = changeListenerList.getListeners();
                for (ChangeListener l : listeners) {
                    l.stateChanged(evt);
                }
            }
        };
        
        // Always fire in EDT
        if (inAtomicUnlock) { // Cannot fire within atomic lock9
            SwingUtilities.invokeLater(runnable);
        } else {
            ViewUtils.runInEDT(runnable);
        }
        updateSystemSelection();
    }

    private void lock() {
        Thread curThread = Thread.currentThread();
        try {
            synchronized (listenerList) {
                while (lockThread != null) {
                    if (curThread == lockThread) {
                        lockDepth++;
                        return;
                    }
                    listenerList.wait();
                }
                lockThread = curThread;
                lockDepth = 1;

            }
        } catch (InterruptedException e) {
            throw new Error("Interrupted attempt to acquire lock"); // NOI18N
        }
    }
    
    private void unlock() {
        Thread curThread = Thread.currentThread();
        synchronized (listenerList) {
            if (lockThread == curThread) {
                lockDepth--;
                if (lockDepth == 0) {
                    lockThread = null;
                    listenerList.notifyAll();
                }
            } else {
                throw new IllegalStateException("Invalid thread called EditorCaret.unlock():  thread=" + // NOI18N
                        curThread + ", lockThread=" + lockThread); // NOI18N
            }
        }
    }

    private void updateType() {
        final JTextComponent c = component;
        if (c != null) {
            Color caretColor = null;
            CaretType newType;
            boolean cIsTextField = Boolean.TRUE.equals(c.getClientProperty("AsTextField"));
            
            if (cIsTextField) {
                newType = CaretType.THIN_LINE_CARET;
            } else if (prefs != null) {
                String newTypeStr;
                if (overwriteMode) {
                    newTypeStr = prefs.get(SimpleValueNames.CARET_TYPE_OVERWRITE_MODE, EditorPreferencesDefaults.defaultCaretTypeOverwriteMode);
                } else { // insert mode
                    newTypeStr = prefs.get(SimpleValueNames.CARET_TYPE_INSERT_MODE, EditorPreferencesDefaults.defaultCaretTypeInsertMode);
                    this.thickCaretWidth = prefs.getInt(SimpleValueNames.THICK_CARET_WIDTH, EditorPreferencesDefaults.defaultThickCaretWidth);
                }
                newType = CaretType.decode(newTypeStr);
            } else {
                newType = CaretType.THICK_LINE_CARET;
            }

            String mimeType = DocumentUtilities.getMimeType(c);
            FontColorSettings fcs = (mimeType != null) ? MimeLookup.getLookup(mimeType).lookup(FontColorSettings.class) : null;
            if (fcs != null) {
                AttributeSet attribs = fcs.getFontColors(overwriteMode
                        ? FontColorNames.CARET_COLOR_OVERWRITE_MODE
                        : FontColorNames.CARET_COLOR_INSERT_MODE); //NOI18N
                if (attribs != null) {
                    caretColor = (Color) attribs.getAttribute(StyleConstants.Foreground);
                }
            }
            
            this.type = newType;
            final Color caretColorFinal = caretColor;
            ViewUtils.runInEDT(
                new Runnable() {
                    public @Override void run() {
                        if (caretColorFinal != null) {
                            c.setCaretColor(caretColorFinal);
                            if (LOG.isLoggable(Level.FINER)) {
                                LOG.finer("Updating caret color:" + caretColorFinal + '\n'); // NOI18N
                            }
                        }

                        resetBlink();
                        dispatchUpdate(false);
                    }
                }
            );
        }
    }

    /**
     * Assign new caret bounds into <code>caretBounds</code> variable.
     *
     * @return true if the new caret bounds were successfully computed
     *  and assigned or false otherwise.
     */
    private boolean updateAllCaretsBounds() {
        JTextComponent c = component;
        AbstractDocument doc;
        boolean ret = false;
        if (c != null && (doc = activeDoc) != null) {
            doc.readLock();
            try {
                List<CaretInfo> sortedCarets = getSortedCarets();
                for (CaretInfo caret : sortedCarets) {
                    ret |= updateRealCaretBounds(caret.getCaretItem(), doc, c);
                }
            } finally {
                doc.readUnlock();
            }
        }
        return ret;
    }
    
    private boolean updateCaretBounds(CaretItem caret) {
        JTextComponent c = component;
        boolean ret = false;
        AbstractDocument doc;
        if (c != null && (doc = activeDoc) != null) {
            doc.readLock();
            try {
                ret = updateRealCaretBounds(caret, doc, c);
            } finally {
                doc.readUnlock();
            }
        }
        return ret;
    }
    
    private boolean updateRealCaretBounds(CaretItem caret, Document doc, JTextComponent c) {
        Position dotPos = caret.getDotPosition();
        int offset = dotPos == null? 0 : dotPos.getOffset();
        if (offset > doc.getLength()) {
            offset = doc.getLength();
        }
        Rectangle newCaretBounds;
        try {
            DocumentView docView = DocumentView.get(c);
            if (docView != null) {
                // docView.syncViewsRebuild(); // Make sure pending views changes are resolved
            }
            newCaretBounds = c.getUI().modelToView(
                    c, offset, Position.Bias.Forward);
            // [TODO] Temporary fix - impl should remember real bounds computed by paintCustomCaret()
            if (newCaretBounds != null) {
                newCaretBounds.width = Math.max(newCaretBounds.width, 2);
            }

        } catch (BadLocationException e) {
            
            newCaretBounds = null;
        }
        if (newCaretBounds != null) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.log(Level.FINE, "updateCaretBounds: old={0}, new={1}, offset={2}",
                        new Object[]{caret.getCaretBounds(), newCaretBounds, offset}); //NOI18N
            }
            caret.setCaretBounds(newCaretBounds);
            return true;
        } else {
            return false;
        }
    }

    private void modelChanged(Document oldDoc, Document newDoc) {
        if (oldDoc != null) {
            // ideally the oldDoc param shouldn't exist and only listenDoc should be used
            assert (oldDoc == activeDoc);

            DocumentUtilities.removeDocumentListener(
                    oldDoc, listenerImpl, DocumentListenerPriority.CARET_UPDATE);
            AtomicLockDocument oldAtomicDoc = LineDocumentUtils.as(oldDoc, AtomicLockDocument.class);
            if (oldAtomicDoc != null) {
                oldAtomicDoc.removeAtomicLockListener(listenerImpl);
            }

            activeDoc = null;
            if (prefs != null && weakPrefsListener != null) {
                prefs.removePreferenceChangeListener(weakPrefsListener);
            }
        }

        // EditorCaret only installs successfully into AbstractDocument based documents that carry a mime-type
        if (newDoc instanceof AbstractDocument) {
            String mimeType = DocumentUtilities.getMimeType(newDoc);
            activeDoc = (AbstractDocument) newDoc;
            DocumentUtilities.addDocumentListener(
                    newDoc, listenerImpl, DocumentListenerPriority.CARET_UPDATE);
            AtomicLockDocument newAtomicDoc = LineDocumentUtils.as(oldDoc, AtomicLockDocument.class);
            if (newAtomicDoc != null) {
                newAtomicDoc.addAtomicLockListener(listenerImpl);
            }

            // Set caret to zero position upon document change (DefaultCaret impl does this too)
            runTransaction(CaretTransaction.RemoveType.REMOVE_ALL_CARETS, 0,
                    new CaretItem[] { new CaretItem(this, newDoc.getStartPosition(), null) }, null);
            
            // Leave caretPos and markPos null => offset==0
            prefs = (mimeType != null) ? MimeLookup.getLookup(mimeType).lookup(Preferences.class) : null;
            if (prefs != null) {
                weakPrefsListener = WeakListeners.create(PreferenceChangeListener.class, listenerImpl, prefs);
                prefs.addPreferenceChangeListener(weakPrefsListener);
            }
            
            updateType();
        }
    }
    
    private void paintCaret(Graphics g, CaretItem caret) {
        JTextComponent c = component;
        if (c != null) {
            g.setColor(c.getCaretColor());
            Rectangle caretBounds = caret.getCaretBounds();
            switch (type) {
                case THICK_LINE_CARET:
                    g.fillRect(caretBounds.x, caretBounds.y, this.thickCaretWidth, caretBounds.height - 1);
                    break;

                case THIN_LINE_CARET:
                    int upperX = caret.getCaretBounds().x;
                    g.drawLine((int) upperX, caret.getCaretBounds().y, caret.getCaretBounds().x,
                            (caret.getCaretBounds().y + caret.getCaretBounds().height - 1));
                    break;

                case BLOCK_CARET:
                    // Use a CaretOverwriteModeHighlighting layer to paint the caret
                    break;

                default:
                    throw new IllegalStateException("Invalid caret type=" + type);
            }
        }
    }

    void dispatchUpdate() {
        JTextComponent c = component;
        if (c != null) {
            dispatchUpdate(c.hasFocus()); // Scroll to caret only for component with focus
        }
    }
    /** Update visual position of caret(s) */
    private void dispatchUpdate(final boolean scrollViewToCaret) {
        /* Ensure that the caret's document listener will be added AFTER the views hierarchy's
         * document listener so the code can run synchronously again
         * which should eliminate the problem with caret lag.
         * However the document can be modified from non-AWT thread
         * which is the case in #57316 and in that case the code
         * must run asynchronously in AWT thread.
         */
        ViewUtils.runInEDT(
            new Runnable() {
                public @Override void run() {
                    AbstractDocument doc = activeDoc;
                    if (doc != null) {
                        doc.readLock();
                        try {
                            update(scrollViewToCaret);
                        } finally {
                            doc.readUnlock();
                        }
                    }
                }
            }
        );
    }

    /**
     * Update the caret's visual position.
     * <br>
     * The document is read-locked while calling this method.
     *
     * @param scrollViewToCaret whether the view of the text component should be
     *  scrolled to the position of the caret.
     */
    private void update(boolean scrollViewToCaret) {
        caretUpdatePending = false;
        JTextComponent c = component;
        if (c != null) {
            if (!c.isValid()) {
                c.validate();
            }
            Document doc = c.getDocument();
            if (doc != null) {
                List<CaretInfo> sortedCarets = getSortedCarets();
                for (CaretInfo caret : sortedCarets) {
                    CaretItem caretItem = caret.getCaretItem();
                    Rectangle oldCaretBounds = caretItem.getCaretBounds(); // no need to deep copy
                    if (oldCaretBounds != null) {
                        c.repaint(oldCaretBounds);
                    }

                    // note - the order is important ! caret bounds must be updated even if the fold flag is true.
                    if (updateCaretBounds(caretItem) || updateAfterFoldHierarchyChange) {
                        Rectangle scrollBounds = new Rectangle(caretItem.getCaretBounds());

                        // Optimization to avoid extra repaint:
                        // If the caret bounds were not yet assigned then attempt
                        // to scroll the window so that there is an extra vertical space 
                        // for the possible horizontal scrollbar that may appear
                        // if the line-view creation process finds line-view that
                        // is too wide and so the horizontal scrollbar will appear
                        // consuming an extra vertical space at the bottom.
                        if (oldCaretBounds == null) {
                            Component viewport = c.getParent();
                            if (viewport instanceof JViewport) {
                                Component scrollPane = viewport.getParent();
                                if (scrollPane instanceof JScrollPane) {
                                    JScrollBar hScrollBar = ((JScrollPane) scrollPane).getHorizontalScrollBar();
                                    if (hScrollBar != null) {
                                        int hScrollBarHeight = hScrollBar.getPreferredSize().height;
                                        Dimension extentSize = ((JViewport) viewport).getExtentSize();
                                        // If the extent size is high enough then extend
                                        // the scroll region by extra vertical space
                                        if (extentSize.height >= caretItem.getCaretBounds().height + hScrollBarHeight) {
                                            scrollBounds.height += hScrollBarHeight;
                                        }
                                    }
                                }
                            }
                        }

                        Rectangle visibleBounds = c.getVisibleRect();

                        // If folds have changed attempt to scroll the view so that 
                        // relative caret's visual position gets retained
                        // (the absolute position will change because of collapsed/expanded folds).
                        boolean doScroll = scrollViewToCaret;
                        boolean explicit = false;
                        if (oldCaretBounds != null && (!scrollViewToCaret || updateAfterFoldHierarchyChange)) {
                            int oldRelY = oldCaretBounds.y - visibleBounds.y;
                            // Only fix if the caret is within visible bounds and the new x or y coord differs from the old one
                            if (LOG.isLoggable(Level.FINER)) {
                                LOG.log(Level.FINER, "oldCaretBounds: {0}, visibleBounds: {1}, caretBounds: {2}",
                                        new Object[]{oldCaretBounds, visibleBounds, caretItem.getCaretBounds()});
                            }
                            if (oldRelY >= 0 && oldRelY < visibleBounds.height
                                    && (oldCaretBounds.y != caretItem.getCaretBounds().y || oldCaretBounds.x != caretItem.getCaretBounds().x)) {
                                doScroll = true; // Perform explicit scrolling
                                explicit = true;
                                int oldRelX = oldCaretBounds.x - visibleBounds.x;
                                // Do not retain the horizontal caret bounds by scrolling
                                // since many modifications do not explicitly say that they are typing modifications
                                // and this would cause problems like #176268
//                            scrollBounds.x = Math.max(caretBounds.x - oldRelX, 0);
                                scrollBounds.y = Math.max(caretItem.getCaretBounds().y - oldRelY, 0);
//                            scrollBounds.width = visibleBounds.width;
                                scrollBounds.height = visibleBounds.height;
                            }
                        }

                        // Historically the caret is expected to appear
                        // in the middle of the window if setDot() gets called
                        // e.g. by double-clicking in Navigator.
                        // If the caret bounds are more than a caret height below the present
                        // visible view bounds (or above the view bounds)
                        // then scroll the window so that the caret is in the middle
                        // of the visible window to see the context around the caret.
                        // This should work fine with PgUp/Down because these
                        // scroll the view explicitly.
                        if (scrollViewToCaret
                                && !explicit
                                && // #219580: if the preceding if-block computed new scrollBounds, it cannot be offset yet more
                                /* # 70915 !updateAfterFoldHierarchyChange && */ (caretItem.getCaretBounds().y > visibleBounds.y + visibleBounds.height + caretItem.getCaretBounds().height
                                || caretItem.getCaretBounds().y + caretItem.getCaretBounds().height < visibleBounds.y - caretItem.getCaretBounds().height)) {
                            // Scroll into the middle
                            scrollBounds.y -= (visibleBounds.height - caretItem.getCaretBounds().height) / 2;
                            scrollBounds.height = visibleBounds.height;
                        }
                        if (LOG.isLoggable(Level.FINER)) {
                            LOG.finer("Resetting fold flag, current: " + updateAfterFoldHierarchyChange);
                        }
                        updateAfterFoldHierarchyChange = false;

                        // Ensure that the viewport will be scrolled either to make the caret visible
                        // or to retain cart's relative visual position against the begining of the viewport's visible rectangle.
                        if (doScroll) {
                            if (LOG.isLoggable(Level.FINER)) {
                                LOG.finer("Scrolling to: " + scrollBounds);
                            }
                            c.scrollRectToVisible(scrollBounds);
                            if (!c.getVisibleRect().intersects(scrollBounds)) {
                                // HACK: see #219580: for some reason, the scrollRectToVisible may fail.
                                c.scrollRectToVisible(scrollBounds);
                            }
                        }
                        resetBlink();
                        c.repaint(caretItem.getCaretBounds());
                    }
                }
            }
        }
    }

    private void updateSystemSelection() {
        if(component == null) return;
        Clipboard clip = null;
        try {
            clip = component.getToolkit().getSystemSelection();
        } catch (SecurityException ex) {
            // XXX: ignore for now, there is no ExClipboard for SystemSelection Clipboard
        }
        if(clip != null) {
            StringBuilder builder = new StringBuilder();
            boolean first = true;
            List<CaretInfo> sortedCarets = getSortedCarets();
            for (CaretInfo caret : sortedCarets) {
                CaretItem caretItem = caret.getCaretItem();
                if(caretItem.isSelection()) {
                    if(!first) {
                        builder.append("\n");
                    } else {
                        first = false;
                    }
                    builder.append(getSelectedText(caretItem));
                }
            }
            if(builder.length() > 0) {
                clip.setContents(new java.awt.datatransfer.StringSelection(builder.toString()), null);
            }
        }
    }
    
    /**
     * Returns the selected text contained for this
     * <code>Caret</code>.  If the selection is
     * <code>null</code> or the document empty, returns <code>null</code>.
     *
     * @param caret
     * @return the text
     * @exception IllegalArgumentException if the selection doesn't
     *  have a valid mapping into the document for some reason
     */
    private String getSelectedText(CaretItem caret) {
        String txt = null;
        int p0 = Math.min(caret.getDot(), caret.getMark());
        int p1 = Math.max(caret.getDot(), caret.getMark());
        if (p0 != p1) {
            try {
                Document doc = component.getDocument();
                txt = doc.getText(p0, p1 - p0);
            } catch (BadLocationException e) {
                throw new IllegalArgumentException(e.getMessage());
            }
        }
        return txt;
    }

    private void updateRectangularSelectionPositionBlocks() {
        JTextComponent c = component;
        if (rectangularSelection) {
            AbstractDocument doc = activeDoc;
            if (doc != null) {
                doc.readLock();
                try {
                    if (rsRegions == null) {
                        rsRegions = new ArrayList<Position>();
                        component.putClientProperty(RECTANGULAR_SELECTION_REGIONS_PROPERTY, rsRegions);
                    }
                    synchronized (rsRegions) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("Rectangular-selection position regions:\n");
                        }
                        rsRegions.clear();
                        if (rsPaintRect != null) {
                            LockedViewHierarchy lvh = ViewHierarchy.get(c).lock();
                            try {
                                float rowHeight = lvh.getDefaultRowHeight();
                                double y = rsPaintRect.y;
                                double maxY = y + rsPaintRect.height;
                                double minX = rsPaintRect.getMinX();
                                double maxX = rsPaintRect.getMaxX();
                                do {
                                    int startOffset = lvh.viewToModel(minX, y, null);
                                    int endOffset = lvh.viewToModel(maxX, y, null);
                                    // They could be swapped due to RTL text
                                    if (startOffset > endOffset) {
                                        int tmp = startOffset;
                                        startOffset = endOffset;
                                        endOffset = tmp;
                                    }
                                    Position startPos = activeDoc.createPosition(startOffset);
                                    Position endPos = activeDoc.createPosition(endOffset);
                                    rsRegions.add(startPos);
                                    rsRegions.add(endPos);
                                    if (LOG.isLoggable(Level.FINE)) {
                                        LOG.fine("  <" + startOffset + "," + endOffset + ">\n");
                                    }
                                    y += rowHeight;
                                } while (y < maxY);
                                c.putClientProperty(RECTANGULAR_SELECTION_REGIONS_PROPERTY, rsRegions);
                            } finally {
                                lvh.unlock();
                            }
                        }
                    }
                } catch (BadLocationException ex) {
                    Exceptions.printStackTrace(ex);
                } finally {
                    doc.readUnlock();
                }
            }
        }
    }

    private String dumpVisibility() {
        return "visible=" + isVisible() + ", blinkVisible=" + blinkVisible;
    }

    /*private*/ void resetBlink() {
        boolean visible = isVisible();
        synchronized (listenerList) {
            if (flasher != null) {
                flasher.stop();
                setBlinkVisible(true);
                if (visible) {
                    if (LOG.isLoggable(Level.FINER)){
                        LOG.finer("Reset blinking (caret already visible)" + // NOI18N
                                " - starting the caret blinking timer: " + dumpVisibility() + '\n'); // NOI18N
                    }
                    flasher.start();
                } else {
                    if (LOG.isLoggable(Level.FINER)){
                        LOG.finer("Reset blinking (caret not visible)" + // NOI18N
                                " - caret blinking timer not started: " + dumpVisibility() + '\n'); // NOI18N
                    }
                }
            }
        }
    }
    
    /*private*/ void setBlinkVisible(boolean blinkVisible) {
        synchronized (listenerList) {
            this.blinkVisible = blinkVisible;
        }
        updateOverwriteModeLayer(false);
    }
    
    private void updateOverwriteModeLayer(boolean forceUpdate) {
        JTextComponent c;
        if ((forceUpdate || overwriteMode) && (c = component) != null) {
            CaretOverwriteModeHighlighting overwriteModeHighlighting = (CaretOverwriteModeHighlighting)
                    c.getClientProperty(CaretOverwriteModeHighlighting.class);
            if (overwriteModeHighlighting != null) {
                overwriteModeHighlighting.setVisible(visible && blinkVisible);
            }
        }
    }

    private void adjustRectangularSelectionMouseX(int x, int y) {
        if (!rectangularSelection) {
            return;
        }
        JTextComponent c = component;
        int offset = c.viewToModel(new Point(x, y));
        Rectangle r = null;;
        if (offset >= 0) {
            try {
                r = c.modelToView(offset);
            } catch (BadLocationException ex) {
                r = null;
            }
        }
        if (r != null) {
            float xDiff = x - r.x;
            if (xDiff > 0) {
                float charWidth;
                LockedViewHierarchy lvh = ViewHierarchy.get(c).lock();
                try {
                    charWidth = lvh.getDefaultCharWidth();
                } finally {
                    lvh.unlock();
                }
                int n = (int) (xDiff / charWidth);
                r.x += n * charWidth;
                r.width = (int) charWidth;
            }
            rsDotRect.x = r.x;
            rsDotRect.width = r.width;
            updateRectangularSelectionPaintRect();
            fireStateChanged();
        }
    }
    
    private void updateRectangularSelectionPaintRect() {
        // Repaint current rect
        JTextComponent c = component;
        Rectangle repaintRect = rsPaintRect;
        if (rsDotRect == null || rsMarkRect == null) {
            return;
        }
        Rectangle newRect = new Rectangle();
        if (rsDotRect.x < rsMarkRect.x) { // Swap selection to left
            newRect.x = rsDotRect.x; // -1 to make the visual selection non-empty
            newRect.width = rsMarkRect.x - newRect.x;
        } else { // Extend or shrink on right
            newRect.x = rsMarkRect.x;
            newRect.width = rsDotRect.x - newRect.x;
        }
        if (rsDotRect.y < rsMarkRect.y) {
            newRect.y = rsDotRect.y;
            newRect.height = (rsMarkRect.y + rsMarkRect.height) - newRect.y;
        } else {
            newRect.y = rsMarkRect.y;
            newRect.height = (rsDotRect.y + rsDotRect.height) - newRect.y;
        }
        if (newRect.width < 2) {
            newRect.width = 2;
        }
        rsPaintRect = newRect;

        // Repaint merged region with original rect
        if (repaintRect == null) {
            repaintRect = rsPaintRect;
        } else {
            repaintRect = repaintRect.union(rsPaintRect);
        }
        c.repaint(repaintRect);
        
        updateRectangularSelectionPositionBlocks();
    }

    private void selectEnsureMinSelection(int mark, int dot, int newDot) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("selectEnsureMinSelection: mark=" + mark + ", dot=" + dot + ", newDot=" + newDot); // NOI18N
        }
        if (dot >= mark) { // Existing forward selection
            if (newDot >= mark) {
                moveDot(Math.max(newDot, minSelectionEndOffset));
            } else { // newDot < mark => swap mark and dot
                setDot(minSelectionEndOffset);
                moveDot(Math.min(newDot, minSelectionStartOffset));
            }

        } else { // Existing backward selection 
            if (newDot <= mark) {
                moveDot(Math.min(newDot, minSelectionStartOffset));
            } else { // newDot > mark => swap mark and dot
                setDot(minSelectionStartOffset);
                moveDot(Math.max(newDot, minSelectionEndOffset));
            }
        }
    }
    
    private boolean isLeftMouseButtonExt(MouseEvent evt) {
        return (SwingUtilities.isLeftMouseButton(evt)
                && !(evt.isPopupTrigger())
                && (evt.getModifiers() & (InputEvent.META_MASK/* | InputEvent.ALT_MASK*/)) == 0);
    }
    
    private boolean isMiddleMouseButtonExt(MouseEvent evt) {
        return (evt.getButton() == MouseEvent.BUTTON2) &&
                (evt.getModifiersEx() & (InputEvent.CTRL_DOWN_MASK | InputEvent.META_DOWN_MASK | /* cannot be tested bcs of bug in JDK InputEvent.ALT_DOWN_MASK | */ InputEvent.ALT_GRAPH_DOWN_MASK)) == 0;
    }

    private int mapDragOperationFromModifiers(MouseEvent e) {
        int mods = e.getModifiersEx();
        
        if ((mods & InputEvent.BUTTON1_DOWN_MASK) == 0) {
            return TransferHandler.NONE;
        }
        
        return TransferHandler.COPY_OR_MOVE;
    }

    /**
     * Determines if the following are true:
     * <ul>
     * <li>the press event is located over a selection
     * <li>the dragEnabled property is true
     * <li>A TranferHandler is installed
     * </ul>
     * <p>
     * This is implemented to check for a TransferHandler.
     * Subclasses should perform the remaining conditions.
     */
    private boolean isDragPossible(MouseEvent e) {
	Object src = e.getSource();
	if (src instanceof JComponent) {
	    JComponent comp = (JComponent) src;
            boolean possible =  (comp == null) ? false : (comp.getTransferHandler() != null);
            if (possible && comp instanceof JTextComponent) {
                JTextComponent c = (JTextComponent) comp;
                if (c.getDragEnabled()) {
                    Caret caret = c.getCaret();
                    int dot = caret.getDot();
                    int mark = caret.getMark();
                    if (dot != mark) {
                        Point p = new Point(e.getX(), e.getY());
                        int pos = c.viewToModel(p);

                        int p0 = Math.min(dot, mark);
                        int p1 = Math.max(dot, mark);
                        if ((pos >= p0) && (pos < p1)) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    
    private void refresh() {
        updateType();
        SwingUtilities.invokeLater(new Runnable() {
            public @Override void run() {
                updateAllCaretsBounds(); // the line height etc. may have change
            }
        });
    }
    
    private static String logMouseEvent(MouseEvent evt) {
        return "x=" + evt.getX() + ", y=" + evt.getY() + ", clicks=" + evt.getClickCount() //NOI18N
            + ", component=" + s2s(evt.getComponent()) //NOI18N
            + ", source=" + s2s(evt.getSource()) + ", button=" + evt.getButton() + ", mods=" + evt.getModifiers() + ", modsEx=" + evt.getModifiersEx(); //NOI18N
    }

    private static String s2s(Object o) {
        return o == null ? "null" : o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o)); //NOI18N
    }

    private final class ListenerImpl extends ComponentAdapter
    implements DocumentListener, AtomicLockListener, MouseListener, MouseMotionListener, FocusListener, ViewHierarchyListener,
            PropertyChangeListener, ActionListener, PreferenceChangeListener, KeyListener
    {

        ListenerImpl() {
        }

        public @Override void preferenceChange(PreferenceChangeEvent evt) {
            String setingName = evt == null ? null : evt.getKey();
            if (setingName == null || SimpleValueNames.CARET_BLINK_RATE.equals(setingName)) {
                int rate = prefs.getInt(SimpleValueNames.CARET_BLINK_RATE, -1);
                if (rate == -1) {
                    rate = EditorPreferencesDefaults.defaultCaretBlinkRate;
                }
                setBlinkRate(rate);
                refresh();
            }
        }

        public @Override void propertyChange(PropertyChangeEvent evt) {
            String propName = evt.getPropertyName();
            JTextComponent c = component;
            if ("document".equals(propName)) { // NOI18N
                if (c != null) {
                    modelChanged(activeDoc, c.getDocument());
                }

            } else if (EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY.equals(propName)) {
                Boolean b = (Boolean) evt.getNewValue();
                overwriteMode = (b != null) ? b : false;
                updateOverwriteModeLayer(true);
                updateType();

            } else if ("ancestor".equals(propName) && evt.getSource() == component) { // NOI18N
                // The following code ensures that when the width of the line views
                // gets computed on background after the file gets opened
                // (so the horizontal scrollbar gets added after several seconds
                // for larger files) that the suddenly added horizontal scrollbar
                // will not hide the caret laying on the last line of the viewport.
                // A component listener gets installed into horizontal scrollbar
                // and if it's fired the caret's bounds will be checked whether
                // they intersect with the horizontal scrollbar
                // and if so the view will be scrolled.
                Container parent = component.getParent();
                if (parent instanceof JViewport) {
                    parent = parent.getParent(); // parent of viewport
                    if (parent instanceof JScrollPane) {
                        JScrollPane scrollPane = (JScrollPane) parent;
                        JScrollBar hScrollBar = scrollPane.getHorizontalScrollBar();
                        if (hScrollBar != null) {
                            // Add weak listener so that editor pane could be removed
                            // from scrollpane without being held by scrollbar
                            hScrollBar.addComponentListener(
                                    (ComponentListener) WeakListeners.create(
                                            ComponentListener.class, listenerImpl, hScrollBar));
                        }
                    }
                }
            } else if ("enabled".equals(propName)) {
                Boolean enabled = (Boolean) evt.getNewValue();
                if (component.isFocusOwner()) {
                    if (enabled == Boolean.TRUE) {
                        if (component.isEditable()) {
                            setVisible(true);
                        }
                        setSelectionVisible(true);
                    } else {
                        setVisible(false);
                        setSelectionVisible(false);
                    }
                }
            } else if (RECTANGULAR_SELECTION_PROPERTY.equals(propName)) {
                boolean origRectangularSelection = rectangularSelection;
                rectangularSelection = Boolean.TRUE.equals(component.getClientProperty(RECTANGULAR_SELECTION_PROPERTY));
                if (rectangularSelection != origRectangularSelection) {
                    if (rectangularSelection) {
                        setRectangularSelectionToDotAndMark();
                        RectangularSelectionTransferHandler.install(component);

                    } else { // No rectangular selection
                        RectangularSelectionTransferHandler.uninstall(component);
                    }
                    fireStateChanged();
                }
            }
        }

        // ActionListener methods
        /**
         * Fired when blink timer fires
         */
        public @Override void actionPerformed(ActionEvent evt) {
            JTextComponent c = component;
            if (c != null) {
                setBlinkVisible(!blinkVisible);
                List<CaretInfo> sortedCarets = getSortedCarets(); // TODO only repaint carets showing on screen
                for (CaretInfo caret : sortedCarets) {
                    CaretItem caretItem = caret.getCaretItem();
                    if (caretItem.getCaretBounds() != null) {
                        Rectangle repaintRect = caretItem.getCaretBounds();
                        c.repaint(repaintRect);
                    }
                }
            }
        }

        // DocumentListener methods
        public @Override void insertUpdate(DocumentEvent evt) {
            JTextComponent c = component;
            if (c != null) {
                Document doc = evt.getDocument();
                int offset = evt.getOffset();
                final int endOffset = offset + evt.getLength();
                if (offset == 0) {
                    // Manually shift carets at offset zero
                    runTransaction(CaretTransaction.RemoveType.DOCUMENT_INSERT_ZERO_OFFSET, endOffset, null, null);
                }
                // [TODO] proper undo solution
                modified = true;
                modifiedUpdate(true);
                
            }
        }

        public @Override void removeUpdate(DocumentEvent evt) {
            JTextComponent c = component;
            if (c != null) {
                // [TODO] proper undo solution
                modified = true;
                int offset = evt.getOffset();
                runTransaction(CaretTransaction.RemoveType.DOCUMENT_REMOVE, offset, null, null);
                modifiedUpdate(true);
            }
        }

        public @Override void changedUpdate(DocumentEvent evt) {
        }

        public @Override
        void atomicLock(AtomicLockEvent evt) {
            inAtomicLock = true;
        }

        public @Override
        void atomicUnlock(AtomicLockEvent evt) {
            inAtomicLock = false;
            inAtomicUnlock = true;
            try {
                modifiedUpdate(typingModificationOccurred);
            } finally {
                inAtomicUnlock = false;
                typingModificationOccurred = false;
            }
        }

        private void modifiedUpdate(boolean typingModification) {
            if (!inAtomicLock) {
                JTextComponent c = component;
                if (modified && c != null) {
                    fireStateChanged();
                    modified = false;
                }
            } else {
                typingModificationOccurred |= typingModification;
            }
        }

        // MouseListener methods
        @Override
        public void mousePressed(MouseEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("mousePressed: " + logMouseEvent(evt) + ", state=" + mouseState + '\n'); // NOI18N
            }

            JTextComponent c = component;
            AbstractDocument doc = activeDoc;
            if (c != null && doc != null && isLeftMouseButtonExt(evt)) {
                doc.readLock();
                try {
                    // Expand fold if offset is in collapsed fold
                    int offset = mouse2Offset(evt);
                    switch (evt.getClickCount()) {
                        case 1: // Single press
                            if (c.isEnabled() && !c.hasFocus()) {
                                c.requestFocus();
                            }
                            c.setDragEnabled(true);
                            if (evt.isAltDown() && evt.isShiftDown()) {
                                mouseState = MouseState.CHAR_SELECTION;
                                try {
                                    Position pos = doc.createPosition(offset);
                                    runTransaction(CaretTransaction.RemoveType.NO_REMOVE, 0, 
                                            new CaretItem[] { new CaretItem(EditorCaret.this, pos, pos) }, null);
                                } catch (BadLocationException ex) {
                                    // Do nothing
                                }
                            } else if (evt.isShiftDown()) { // Select till offset
                                moveDot(offset);
                                adjustRectangularSelectionMouseX(evt.getX(), evt.getY()); // also fires state change
                                mouseState = MouseState.CHAR_SELECTION;
                            } else // Regular press
                            // check whether selection drag is possible
                            if (isDragPossible(evt) && mapDragOperationFromModifiers(evt) != TransferHandler.NONE) {
                                mouseState = MouseState.DRAG_SELECTION_POSSIBLE;
                            } else { // Drag not possible
                                mouseState = MouseState.CHAR_SELECTION;
                                setDot(offset);
                            }
                            break;

                        case 2: // double-click => word selection
                            mouseState = MouseState.WORD_SELECTION;
                            // Disable drag which would otherwise occur when mouse would be over text
                            c.setDragEnabled(false);
                            // Check possible fold expansion
                            try {
                                // hack, to get knowledge of possible expansion. Editor depends on Folding, so it's not really possible
                                // to have Folding depend on BaseCaret (= a cycle). If BaseCaret moves to editor.lib2, this contract
                                // can be formalized as an interface.
                                @SuppressWarnings("unchecked")
                                Callable<Boolean> cc = (Callable<Boolean>) c.getClientProperty("org.netbeans.api.fold.expander");
                                if (cc == null || !cc.equals(this)) {
                                    if (selectWordAction == null) {
                                        selectWordAction = EditorActionUtilities.getAction(
                                                c.getUI().getEditorKit(c), DefaultEditorKit.selectWordAction);
                                    }
                                    if (selectWordAction != null) {
                                        selectWordAction.actionPerformed(null);
                                    }
                                    // Select word action selects forward i.e. dot > mark
                                    minSelectionStartOffset = getMark();
                                    minSelectionEndOffset = getDot();
                                }
                            } catch (Exception ex) {
                                Exceptions.printStackTrace(ex);
                            }
                            break;

                        case 3: // triple-click => line selection
                            mouseState = MouseState.LINE_SELECTION;
                            // Disable drag which would otherwise occur when mouse would be over text
                            c.setDragEnabled(false);
                            if (selectLineAction == null) {
                                selectLineAction = EditorActionUtilities.getAction(
                                                c.getUI().getEditorKit(c), DefaultEditorKit.selectLineAction);
                            }
                            if (selectLineAction != null) {
                                selectLineAction.actionPerformed(null);
                                // Select word action selects forward i.e. dot > mark
                                minSelectionStartOffset = getMark();
                                minSelectionEndOffset = getDot();
                            }
                            break;

                        default: // multi-click
                    }
                } finally {
                    doc.readUnlock();
                }
            }
        }

        @Override
        public void mouseReleased(MouseEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("mouseReleased: " + logMouseEvent(evt) + ", state=" + mouseState + '\n'); // NOI18N
            }

            int offset = mouse2Offset(evt);
            switch (mouseState) {
                case DRAG_SELECTION_POSSIBLE:
                    setDot(offset);
                    adjustRectangularSelectionMouseX(evt.getX(), evt.getY()); // also fires state change
                    break;

                case CHAR_SELECTION:
                    if (evt.isAltDown() && evt.isShiftDown()) {
                        moveDotCaret(offset, getLastCaretItem());
                    } else {
                        moveDot(offset); // Will do setDot() if no selection
                        adjustRectangularSelectionMouseX(evt.getX(), evt.getY()); // also fires state change
                    }
                    break;
            }
            // Set DEFAULT state; after next mouse press the state may change
            // to another state according to particular click count
            mouseState = MouseState.DEFAULT;
            component.setDragEnabled(true);
        }

        /**
         * Translates mouse event to text offset
         */
        int mouse2Offset(MouseEvent evt) {
            JTextComponent c = component;
            int offset = 0;
            if (c != null) {
                int y = evt.getY();
                if (y < 0) {
                    offset = 0;
                } else if (y > c.getSize().getHeight()) {
                    offset = c.getDocument().getLength();
                } else {
                    offset = c.viewToModel(new Point(evt.getX(), evt.getY()));
                }
            }
            return offset;
        }

        @Override
        public void mouseClicked(MouseEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("mouseClicked: " + logMouseEvent(evt) + ", state=" + mouseState + '\n'); // NOI18N
            }

            JTextComponent c = component;
            if (c != null) {
                if (isMiddleMouseButtonExt(evt)) {
                    if (evt.getClickCount() == 1) {
                        if (c == null) {
                            return;
                        }
                        Clipboard buffer = component.getToolkit().getSystemSelection();

                        if (buffer == null) {
                            return;
                        }

                        Transferable trans = buffer.getContents(null);
                        if (trans == null) {
                            return;
                        }

                        final Document doc = c.getDocument();
                        if (doc == null) {
                            return;
                        }

                        final int offset = c.getUI().viewToModel(c, new Point(evt.getX(), evt.getY()));

                        try {
                            final String pastingString = (String) trans.getTransferData(DataFlavor.stringFlavor);
                            if (pastingString == null) {
                                return;
                            }
                            Runnable pasteRunnable = new Runnable() {
                                public @Override
                                void run() {
                                    try {
                                        doc.insertString(offset, pastingString, null);
                                        setDot(offset + pastingString.length());
                                    } catch (BadLocationException exc) {
                                    }
                                }
                            };
                            AtomicLockDocument ald = LineDocumentUtils.as(doc, AtomicLockDocument.class);
                            if (ald != null) {
                                ald.runAtomic(pasteRunnable);
                            } else {
                                pasteRunnable.run();
                            }
                        } catch (UnsupportedFlavorException ufe) {
                        } catch (IOException ioe) {
                        }
                    }
                }
            }
        }

        @Override
        public void mouseEntered(MouseEvent evt) {
        }

        @Override
        public void mouseExited(MouseEvent evt) {
        }

        // MouseMotionListener methods
        @Override
        public void mouseMoved(MouseEvent evt) {
            if (mouseState == MouseState.DEFAULT) {
                boolean textCursor = true;
                int position = component.viewToModel(evt.getPoint());
                if (RectangularSelectionUtils.isRectangularSelection(component)) {
                    List<Position> positions = RectangularSelectionUtils.regionsCopy(component);
                    for (int i = 0; textCursor && i < positions.size(); i += 2) {
                        int a = positions.get(i).getOffset();
                        int b = positions.get(i + 1).getOffset();
                        if (a == b) {
                            continue;
                        }

                        textCursor &= !(position >= a && position <= b || position >= b && position <= a);
                    }
                } else // stream selection
                if (getDot() == getMark()) {
                    // empty selection
                    textCursor = true;
                } else {
                    int dot = getDot();
                    int mark = getMark();
                    if (position >= dot && position <= mark || position >= mark && position <= dot) {
                        textCursor = false;
                    } else {
                        textCursor = true;
                    }
                }

                if (textCursor != showingTextCursor) {
                    int cursorType = textCursor ? Cursor.TEXT_CURSOR : Cursor.DEFAULT_CURSOR;
                    component.setCursor(Cursor.getPredefinedCursor(cursorType));
                    showingTextCursor = textCursor;
                }
            }
        }

        @Override
        public void mouseDragged(MouseEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("mouseDragged: " + logMouseEvent(evt) + ", state=" + mouseState + '\n'); //NOI18N
            }

            if (isLeftMouseButtonExt(evt)) {
                JTextComponent c = component;
                int offset = mouse2Offset(evt);
                int dot = getDot();
                int mark = getMark();
                LineDocument lineDoc = LineDocumentUtils.asRequired(c.getDocument(), LineDocument.class);
                
                try {
                    switch (mouseState) {
                        case DEFAULT:
                        case DRAG_SELECTION:
                            break;

                        case DRAG_SELECTION_POSSIBLE:
                            mouseState = MouseState.DRAG_SELECTION;
                            break;

                        case CHAR_SELECTION:
                            if (evt.isAltDown() && evt.isShiftDown()) {
                                moveDotCaret(offset, getLastCaretItem());
                            } else {
                                moveDot(offset);
                                adjustRectangularSelectionMouseX(evt.getX(), evt.getY());
                            }
                            break; // Use the offset under mouse pointer

                        case WORD_SELECTION:
                            // Increase selection if at least in the middle of a word.
                            // It depends whether selection direction is from lower offsets upward or back.
                            if (offset >= mark) { // Selection extends forward.
                                offset = LineDocumentUtils.getWordEnd(lineDoc, offset);
                            } else { // Selection extends backward.
                                offset = LineDocumentUtils.getWordStart(lineDoc, offset);
                            }
                            selectEnsureMinSelection(mark, dot, offset);
                            break;

                        case LINE_SELECTION:
                            if (offset >= mark) { // Selection extends forward
                                offset = Math.min(LineDocumentUtils.getLineEnd(lineDoc, offset) + 1, c.getDocument().getLength());
                            } else { // Selection extends backward
                                offset = LineDocumentUtils.getLineStart(lineDoc, offset);
                            }
                            selectEnsureMinSelection(mark, dot, offset);
                            break;

                        default:
                            throw new AssertionError("Invalid state " + mouseState); // NOI18N
                    }
                } catch (BadLocationException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
        }

        // FocusListener methods
        public @Override void focusGained(FocusEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine(
                        "BaseCaret.focusGained(); doc=" + // NOI18N
                        component.getDocument().getProperty(Document.TitleProperty) + '\n'
                );
            }
            
            JTextComponent c = component;
            if (c != null) {
                updateType();
                if (component.isEnabled()) {
                    if (component.isEditable()) {
                        setVisible(true);
                }
                    setSelectionVisible(true);
                }
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.finer("Caret visibility: " + isVisible() + '\n'); // NOI18N
                }
            } else {
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.finer("Text component is null, caret will not be visible" + '\n'); // NOI18N
                }
            }
        }

        public @Override void focusLost(FocusEvent evt) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("BaseCaret.focusLost(); doc=" + // NOI18N
                        component.getDocument().getProperty(Document.TitleProperty) +
                        "\nFOCUS GAINER: " + evt.getOppositeComponent() + '\n' // NOI18N
                );
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.finer("FOCUS EVENT: " + evt + '\n'); // NOI18N
                }
            }
	    setVisible(false);
            setSelectionVisible(evt.isTemporary());
        }

        // ComponentListener methods
        /**
         * May be called for either component or horizontal scrollbar.
         */
        public @Override void componentShown(ComponentEvent e) {
            // Called when horizontal scrollbar gets visible
            // (but the same listener added to component as well so must check first)
            // Check whether present caret position will not get hidden
            // under horizontal scrollbar and if so scroll the view
            Component hScrollBar = e.getComponent();
            if (hScrollBar != component) { // really called for horizontal scrollbar
                Component scrollPane = hScrollBar.getParent();
                boolean needsUpdate = false;
                List<CaretInfo> sortedCarets = getSortedCarets();
                for (CaretInfo caret : sortedCarets) { // TODO This is wrong, but a quick prototype
                    CaretItem caretItem = caret.getCaretItem();
                    if (caretItem.getCaretBounds() != null && scrollPane instanceof JScrollPane) {
                        Rectangle viewRect = ((JScrollPane)scrollPane).getViewport().getViewRect();
                        Rectangle hScrollBarRect = new Rectangle(
                                viewRect.x,
                                viewRect.y + viewRect.height,
                                hScrollBar.getWidth(),
                                hScrollBar.getHeight()
                                );
                        if (hScrollBarRect.intersects(caretItem.getCaretBounds())) {
                            // Update caret's position
                            needsUpdate = true;
                        }
                    }
                }
                if(needsUpdate) {
                    dispatchUpdate(true); // should be visible so scroll the view
                }
            }
        }
        
        /**
         * May be called for either component or horizontal scrollbar.
         */
        public @Override void componentResized(ComponentEvent e) {
            Component c = e.getComponent();
            if (c == component) { // called for component
                // In case the caretBounds are still null
                // (component not connected to hierarchy yet or it has zero size
                // so the modelToView() returned null) re-attempt to compute the bounds.
                CaretItem caret = getLastCaretItem();
                if (caret.getCaretBounds() == null) {
                    dispatchUpdate(true);
                    if (caret.getCaretBounds() != null) { // detach the listener - no longer necessary
                        c.removeComponentListener(this);
                    }
                }
            }
        }

        @Override
        public void viewHierarchyChanged(ViewHierarchyEvent evt) {
            if (!caretUpdatePending) {
                caretUpdatePending = true;
                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        update(false);
                    }
                });
            }
        }

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                // Retain just the last caret
                retainLastCaretOnly();
            }
        }

        @Override
        public void keyTyped(KeyEvent e) {
        }

        @Override
        public void keyReleased(KeyEvent e) {
        }
        
    } // End of ListenerImpl class
    
    
    private enum CaretType {
        
        /**
         * Two-pixel line caret (the default).
         */
        THICK_LINE_CARET,
        
        /**
         * Thin one-pixel line caret.
         */
        THIN_LINE_CARET,

        /**
         * Rectangle corresponding to a single character.
         */
        BLOCK_CARET;
        
        static CaretType decode(String typeStr) {
            switch (typeStr) {
                case EditorPreferencesDefaults.THIN_LINE_CARET:
                    return THIN_LINE_CARET;
                case EditorPreferencesDefaults.BLOCK_CARET:
                    return BLOCK_CARET;
                default:
                    return THICK_LINE_CARET;
            }
        };

    }
    
    private static enum MouseState {

        DEFAULT, // Mouse released; not extending any selection
        CHAR_SELECTION, // Extending character selection after single mouse press 
        WORD_SELECTION, // Extending word selection after double-click when mouse button still pressed
        LINE_SELECTION, // Extending line selection after triple-click when mouse button still pressed
        DRAG_SELECTION_POSSIBLE,  // There was a selected text when mouse press arrived so drag is possible
        DRAG_SELECTION  // Drag is being done (text selection existed at the mouse press)
        
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import org.netbeans.api.annotations.common.NonNull;

/**
 * Notification event about changes in editor caret.
 *
 * @author Miloslav Metelka
 * @since 2.6
 */
public final class EditorCaretEvent extends java.util.EventObject {
    
    private final int affectedStartOffset;
    
    private final int affectedEndOffset;
    
    EditorCaretEvent(EditorCaret source, int affectedStartOffset, int affectedEndOffset) {
        super(source);
        this.affectedStartOffset = affectedStartOffset;
        this.affectedEndOffset = affectedEndOffset;
    }
    
    /**
     * Get caret instance to which this event relates.
     *
     * @return caret instance.
     */
    public @NonNull EditorCaret getCaret() {
        return (EditorCaret) getSource();
    }

    /**
     * Get start of the region that was affected by caret change.
     * <br>
     * This offset region will be repainted automatically by the editor infrastructure.
     *
     * @return &gt;= 0 offset.
     */
    public int getAffectedStartOffset() {
        return affectedStartOffset;
    }
    
    /**
     * Get end of the region that was affected by caret change.
     * <br>
     * This offset region will be repainted automatically by the editor infrastructure.
     *
     * @return &gt;= 0 offset.
     */
    public int getAffectedEndOffset() {
        return affectedEndOffset;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.api.editor.caret;

import org.netbeans.api.annotations.common.NonNull;

/**
 * Listener for changes in editor caret.
 *
 * @author Miloslav Metelka
 * @since 2.6
 */
public interface EditorCaretListener extends java.util.EventListener {

    /**
     * Notification about change in terms of caret addition/removal or movement.
     *
     * @param evt caret event describing the change.
     */
    void caretChanged(@NonNull EditorCaretEvent evt);

}




<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 2016 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 2016 Sun Microsystems, Inc.
-->

<html>
  <head>
    <title>org.netbeans.api.editor.caret</title>
  </head>
  <body>

  <p>
  The Editor Caret API opens up the editor to give information about its carets
  and to manipulate them.
  </p>
  
  <h3>Key parts of the API</h3>
  
  <p>
  The whole API is organized around the
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaret.html">EditorCaret</a></code>
  class, an implementation of the <code>javax.swing.text.Caret</code> managing
  all the carets in a single document. Information about carets maintained by
  <code>EditorCaret</code> is stored in the immutable class
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/CaretInfo.html">CaretInfo</a></code>.
  Once a caret gets mutated its corresponding caret info becomes obsolete
  and new caret info instance gets created lazily.
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaretListener.html">EditorCaretListener</a></code>
  can be registered to an <code>EditorCaret</code> to be informed about caret
  addition/removal or movement with an
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaretEvent.html">EditorCaretEvent</a></code>.
  </p>
  
  <p>
  The <code>EditorCaret</code> mutates its carets in a single transaction.
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/CaretMoveContext.html">CaretMoveContext</a></code>
  allows clients implementing
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/caret/CaretMoveHandler.html">CaretMoveHandler</a></code>
  to manipulate carets. The following code shows how all carets are moved to the
  end of the word they are currently on.
  
  <pre><code>
    editorCaret.moveCarets((CaretMoveContext context) -> {
        for (CaretInfo ci : context.getOriginalCarets()) {
            Position pos = target.getDocument().createPosition(Utilities.getWordEnd(target, ci.getDot()));
            context.setDot(ci, pos);
        }
    });
  </code>
  </pre>
  </p>

  <h3>Locking and <code>Document</code> changes</h3>
  
  <p>
  The basics of the locking and events model of Swing documents is
  described in the javadoc of the
  <a href="http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/text/AbstractDocument.html">javax.swing.text.AbstractDocument</a>
  class. Netbeans documents use the same patterns and so does the Caret API,
  because of its tight relation to documents. The fundamentals of the Swing documents
  locking model are that any changes to a document are done under the
  document's write lock, the document's listeners are notified synchronously on the
  mutating thread and have full read access to the document, but can't modify it.
  </p>
  
  <ul>
    <li>
    Any calls from the infrastructure to <code>EditorCaret</code> to query or
    mutate its carets, should be called with document's read-lock acquired which
    will guarantee stability of <code>CaretInfo#getDot()</code> and
    <code>CaretInfo#getMark()</code> and prevent caret merging as a possible
    effect of document modifications.
    </li>
    <li>
    When <code>EditorCaret</code> needs to notify its listeners that some
    of its carets have changed, all the events have to be fired under the
    layer's document's read lock. Obviously, the listeners are not allowed to
    modify the document from the event notification methods.
    </li>
  </ul>
  
  <p>
  The Caret API does not use any special threads and any processing it
  does is always done on the caller's thread. This means that the above described
  constraints hardly cause any limitation for practical use.
  </p>
  
  <p>
  The Caret API is generally thread-safe meaning that it can be used
  simultaneously from multiple threads if not stated otherwise. This doesn't
  change in any way the rule of acquiring a read lock before calling the API.
  Swing documents generally allow access for multiple readers that can run
  concurrently.
  </p>
  
  <h3><a name="compatibilty">Backwards compatibility</a></h3>
  <p>
  As a technical limitation, <code>EditorCaret</code> has to implement <code>Caret</code>
  to be able to work with Swings Text API. The <code>Caret</code> interface is not
  aware of multiple carets and any call to its method will work on the last added
  caret. Manipulating the caret using <code>setDot(int)</code> or <code>moveDot(int)</code>
  will retain only the last added caret and move it accordingly.
  <br>
  <code>editorTextComponent.getCaret()</code> will now always return <code>EditorCaret</code>
  instance instead of the original caret implementation <code>org.netbeans.editor.BaseCaret</code>.
  Since clients were expected to only rely on <code>javax.swing.text.Caret</code> returned type
  (except internal code in editor modules) they should not be affected by the change
  since <code>EditorCaret</code> implements <code>Caret</code> interface.
  <br>
  With official Caret API the clients can start to cast
  <code>editorTextComponent.getCaret()</code> to <code>EditorCaret</code> type
  and use its extended functionality.
  </p>
  
  <h3><a name="usecases">Use cases</a></h3>
  <p>
  Use cases are shown in javadoc documentation of particular methods.
  </p>
  </body>
</html>

Lines 47-50 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/Bundle.properties (-1 / +2 lines)
47		47
48	#DocUtils.debugPosition	48	#DocUtils.debugPosition
49	wrong_position=Wrong position	49	wrong_position=Wrong position
50	MSG_RectangularSelectionClipboardFlavor=Rectangular Selection	50	MSG_RectangularSelectionClipboardFlavor=Rectangular Selection
		51	MSG_MultiCaretClipboardFlavor=Multi Caret





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

import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.TransferHandler;
import javax.swing.text.AbstractDocument;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import org.netbeans.api.editor.caret.CaretInfo;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

/**
 * Clipboard transfer handler for rectangular selection.
 * <br>
 * It overrides the original transfer handler during the rectangular selection.
 *
 * @author Miloslav Metelka
 */
public class EditorCaretTransferHandler extends TransferHandler {
    
    public static void install(JTextComponent c) {
        TransferHandler origHandler = c.getTransferHandler();
        if (!(origHandler instanceof EditorCaretTransferHandler)) {
            c.setTransferHandler(new EditorCaretTransferHandler(c.getTransferHandler()));
        }
    }
    
    public static void uninstall(JTextComponent c) {
        TransferHandler origHandler = c.getTransferHandler();
        if (origHandler instanceof EditorCaretTransferHandler) {
            c.setTransferHandler(((EditorCaretTransferHandler)origHandler).getDelegate());
        }
    }
    
    private static final DataFlavor RECTANGULAR_SELECTION_FLAVOR = new DataFlavor(RectangularSelectionData.class,
            NbBundle.getMessage(EditorCaretTransferHandler.class, "MSG_RectangularSelectionClipboardFlavor"));
    
    private static final DataFlavor MULTI_CARET_FLAVOR = new DataFlavor(MultiCaretData.class,
            NbBundle.getMessage(EditorCaretTransferHandler.class, "MSG_MultiCaretClipboardFlavor"));

    /** Boolean property defining whether selection is being rectangular in a particular text component. */
    private static final String RECTANGULAR_SELECTION_PROPERTY = "rectangular-selection"; // NOI18N

    // -J-Dorg.netbeans.modules.editor.lib2.RectangularSelectionClipboardHandler.level=FINE
    private static final Logger LOG = Logger.getLogger(EditorCaretTransferHandler.class.getName());


    private final TransferHandler delegate;

    public EditorCaretTransferHandler(TransferHandler delegate) {
        this.delegate = delegate;
    }
    

            }

            clip.setContents(
                    new RectangularTransferable(
                        new StringSelection(stringSelectionBuffer.toString()),
                        new RectangularSelectionData(data)),
                    null);

            }
            return;

        } else if (c instanceof JTextComponent &&
                ((JTextComponent)c).getCaret() instanceof EditorCaret &&
                ((EditorCaret)((JTextComponent)c).getCaret()).getCarets().size() > 1)
        {
            EditorCaret editorCaret = (EditorCaret) ((JTextComponent)c).getCaret();
            final JTextComponent tc = (JTextComponent) c;
            StringBuilder stringSelectionBuffer;
            String[] lines = null;
            AbstractDocument doc = (AbstractDocument) tc.getDocument();
            doc.readLock();
            try {
                CharSequence docText = DocumentUtilities.getText(doc);
                stringSelectionBuffer = new StringBuilder(100);
                List<CaretInfo> carets = editorCaret.getSortedCarets();
                lines = new String[carets.size()];
                boolean newline = false;
                for (int i = 0; i < carets.size(); i++) {
                    CaretInfo caret = carets.get(i);
                    if(!caret.isSelection()) continue;
                    int startOffset = caret.getSelectionStart();
                    int endOffset = caret.getSelectionEnd();
                    CharSequence lineSel = docText.subSequence(startOffset, endOffset);
                    if (newline) {
                        stringSelectionBuffer.append('\n');
                    } else {
                        newline = true;
                    }
                    stringSelectionBuffer.append(lineSel);
                    lines[i] = lineSel.toString();
                }
            } finally {
                doc.readUnlock();
            }

            clip.setContents(
                    new MultiCaretTransferable(
                        new StringSelection(stringSelectionBuffer.toString()),
                        new MultiCaretData(lines)),
                    null);

            if (action == TransferHandler.MOVE) {
                List<CaretInfo> carets = editorCaret.getSortedCarets();
                for (CaretInfo caret : carets) {
                    if (caret.isSelection()) {
                        // remove selection
                        final int dot = caret.getDot();
                        final int mark = caret.getMark();
                        try {
                            if (RectangularSelectionUtils.isRectangularSelection(tc)) {
                                RectangularSelectionUtils.removeSelection(tc);
                                RectangularSelectionCaretAccessor.get().setRectangularSelectionToDotAndMark(editorCaret);
                            } else {
                                doc.remove(Math.min(dot, mark), Math.abs(dot - mark));
                            }
                        } catch (BadLocationException ble) {
                            LOG.log(Level.FINE, null, ble);
                        }
                    }
                }
            }
            return;
        } else { // No rectangular selection or multiple carets
            delegate.exportToClipboard(c, clip, action);
        }
    }

                    } else { // Regular selection
                        String s = (String) t.getTransferData(DataFlavor.stringFlavor); // There should be string flavor
                        if (s != null) {
                            tc.replaceSelection(s);
                        }
                    }
                    result = true;

                        Exceptions.printStackTrace(ex);
                    }
                }
            } else {
                Caret caret = ((JTextComponent) c).getCaret();
                if(caret instanceof EditorCaret && ((EditorCaret) caret).getSortedCarets().size() > 1) {
                    final EditorCaret editorCaret = (EditorCaret) caret;
                    boolean result = false;
                    MultiCaretData multiCaretData = null;
                    if(t.isDataFlavorSupported(MULTI_CARET_FLAVOR)) {
                        try {
                            multiCaretData = (MultiCaretData) t.getTransferData(MULTI_CARET_FLAVOR);
                        } catch (UnsupportedFlavorException | IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    }
                    if(multiCaretData != null && multiCaretData.strings().length == editorCaret.getCarets().size()) {
                        final MultiCaretData content = multiCaretData;
                        final Document doc = ((JTextComponent) c).getDocument();
                        DocUtils.runAtomicAsUser(doc, new Runnable() {
                            @Override
                            public void run() {
                                for (int i = 0; i < editorCaret.getSortedCarets().size(); i++) {
                                    CaretInfo ci = editorCaret.getSortedCarets().get(i);
                                    try {
                                        int startOffset = ci.getSelectionStart();
                                        int endOffset = ci.getSelectionEnd();
                                        if (startOffset != endOffset) {
                                            doc.remove(startOffset, endOffset - startOffset);
                                        }
                                        if (content.strings()[i] != null && content.strings()[i].length() > 0) {
                                            doc.insertString(startOffset, content.strings()[i], null);
                                        }
                                    } catch (BadLocationException ex) {
                                        //ignore ?
                                    }
                                }
                            }
                        });
                    } else {
                        try {
                            final String content = (String) t.getTransferData(DataFlavor.stringFlavor); // There should be string flavor
                            final Document doc = ((JTextComponent) c).getDocument();
                            DocUtils.runAtomicAsUser(doc, new Runnable() {
                                @Override
                                public void run() {
                                    for (CaretInfo ci : editorCaret.getSortedCarets()) {
                                        try {
                                            int startOffset = ci.getSelectionStart();
                                            int endOffset = ci.getSelectionEnd();
                                            if (startOffset != endOffset) {
                                                doc.remove(startOffset, endOffset - startOffset);
                                            }
                                            if (content != null && content.length() > 0) {
                                                doc.insertString(startOffset, content, null);
                                            }
                                        } catch (BadLocationException ex) {
                                            //ignore ?
                                        }
                                    }
                                }
                            });
                            result = true;
                        } catch (UnsupportedFlavorException | IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    }

                    return result;
                }
            }
        }
        return delegate.importData(support); // Regular importData()
    }

    @Override
    public boolean importData(JComponent comp, Transferable t) {
        return delegate.importData(comp, t);
    }

    private static List<String> splitByLines(String s) {
        StringTokenizer splitByLines = new StringTokenizer(s, "\n", false);
        List<String> lines = new ArrayList<String>();

        return lines;
    }

    private static final class RectangularTransferable implements Transferable {

        private final Transferable delegate;



        private DataFlavor[] transferDataFlavorsCache;

        public RectangularTransferable(Transferable delegate, RectangularSelectionData rectangularSelectionData) {
            this.delegate = delegate;
            this.rectangularSelectionData = rectangularSelectionData;
        }

            return delegate.getTransferData(flavor);
        }
    }
    
    private static final class MultiCaretTransferable implements Transferable {

        private final Transferable delegate;

        private final MultiCaretData multiCaretData;

        private DataFlavor[] transferDataFlavorsCache;

        public MultiCaretTransferable(Transferable delegate, MultiCaretData multiCaretData) {
            this.delegate = delegate;
            this.multiCaretData = multiCaretData;
        }

        @Override
        public synchronized DataFlavor[] getTransferDataFlavors() {
            if (transferDataFlavorsCache != null) {
                return transferDataFlavorsCache;
            }
            DataFlavor[] flavors = delegate.getTransferDataFlavors();
            DataFlavor[] result = Arrays.copyOf(flavors, flavors.length + 1);
            result[flavors.length] = MULTI_CARET_FLAVOR;

            return transferDataFlavorsCache = result;
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return MULTI_CARET_FLAVOR.equals(flavor) || delegate.isDataFlavorSupported(flavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            if (MULTI_CARET_FLAVOR.equals(flavor)) {
                return multiCaretData;
            }
            return delegate.getTransferData(flavor);
        }
    }
    
    public static final class MultiCaretData {
        
        private final String[] strings;
        
        public MultiCaretData(String[] strings) {
            this.strings = strings;
        }
        
        /**
         * Strings containing rectangular selection (on particular selected line).
         */
        public String[] strings() {
            return strings;
        }
    }

    public static final class RectangularSelectionData {





        // no-op
    }

    /**
     * One dot thin line compatible with Swing default caret.
     */
    public static final String THIN_LINE_CARET = "thin-line-caret"; // NOI18N

    /**
     * Two dots line - the default for the editor.
     */
    public static final String THICK_LINE_CARET = "thick-line-caret"; // NOI18N

    /**
     * Rectangle covering character to possibly be overwritten.
     */
    public static final String BLOCK_CARET = "block-caret";
    
    public static final boolean defaultToolbarVisible = true; // Currently unused - see ToggleAction in editor.actions


    public static final boolean defaultExpandTabs = true;

    public static final String defaultCaretTypeInsertMode = THICK_LINE_CARET;
    public static final String defaultCaretTypeOverwriteMode = BLOCK_CARET;
    public static final boolean defaultCaretItalicInsertMode = false;
    public static final boolean defaultCaretItalicOverwriteMode = false;
    /** @since 1.23 */
    public static final int defaultThickCaretWidth = 2;
    public static final Acceptor defaultAbbrevExpandAcceptor = AcceptorFactory.WHITESPACE;
    public static final Acceptor defaultAbbrevAddTypedCharAcceptor = AcceptorFactory.NL;
    public static final Acceptor defaultAbbrevResetAcceptor = AcceptorFactory.NON_JAVA_IDENTIFIER;




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.lib2;

import org.netbeans.api.editor.caret.EditorCaret;

/**
 * Accessor of EditorCaret's rectangular selection methods.
 *
 * @author Miloslav Metelka
 */
public abstract class RectangularSelectionCaretAccessor {
    
    private static RectangularSelectionCaretAccessor INSTANCE;

    public static RectangularSelectionCaretAccessor get() {
        if (INSTANCE == null) {
            // Cause api accessor impl to get initialized
            try {
                Class.forName(EditorCaret.class.getName(), true, RectangularSelectionCaretAccessor.class.getClassLoader());
            } catch (ClassNotFoundException e) {
                // Should never happen
            }
        }
        return INSTANCE;
    }

    public static void register(RectangularSelectionCaretAccessor accessor) {
        INSTANCE = accessor;
    }

    public abstract void setRectangularSelectionToDotAndMark(EditorCaret editorCaret);

    public abstract void updateRectangularUpDownSelection(EditorCaret editorCaret);

    public abstract void extendRectangularSelection(EditorCaret editorCaret, boolean toRight, boolean ctrl);

}





/**
 * Clipboard transfer handler for rectangular selection.
 * <br>
 * It overrides the original transfer handler during the rectangular selection.
 *
 * @author Miloslav Metelka
 * @deprecated replaced by {@link EditorCaretTransferHandler}, kept in place for BaseCaret
 */
@Deprecated
public class RectangularSelectionTransferHandler extends TransferHandler {
    
    public static void install(JTextComponent c) {

Lines 50-56 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/WeakReferenceStableList.java (-1 / +1 lines)
50		50
51	/**	51	/**
52	* List holding non-null items weakly with automatic collection of GCed items.	52	* List holding non-null items weakly with automatic collection of GCed items.
53	* <br/>	53	* <br>
54	* Add and remove operations do not affect a list previously obtained by {@link #getList() }	54	* Add and remove operations do not affect a list previously obtained by {@link #getList() }
55	* so it may be used in a similar way like ListenerList holding all listener instances	55	* so it may be used in a similar way like ListenerList holding all listener instances
56	* by a weak reference.	56	* by a weak reference.

Lines 382-388 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/actions/EditorActionUtilities.java (-1 / +1 lines)
382		382
383	/**	383	/**
384	* Get single-key accelerator for a given declared action.	384	* Get single-key accelerator for a given declared action.
385	* <br/>	385	* <br>
386	* Unfortunately currently there's no easy way to display multi-keybinding in menu-item	386	* Unfortunately currently there's no easy way to display multi-keybinding in menu-item
387	* (there's just JMenuItem.setAccelerator() and its impl is L&F-based)	387	* (there's just JMenuItem.setAccelerator() and its impl is L&F-based)
388	* so just display single-keystroke accelerators.	388	* so just display single-keystroke accelerators.

Lines 73-79 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/actions/PresenterEditorAction.java (-1 / +1 lines)
73	/**	73	/**
74	* Action that represents a named editor action in main menu, popup menu	74	* Action that represents a named editor action in main menu, popup menu
75	* and editor toolbar.	75	* and editor toolbar.
76	* <br/>	76	* <br>
77	* The actions are registered into "Editors/ActionPresenters" regardless	77	* The actions are registered into "Editors/ActionPresenters" regardless
78	* of the mime-type for which the actions get created.	78	* of the mime-type for which the actions get created.
79	*/	79	*/

Lines 106-112 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/actions/PresenterUpdater.java (-1 / +1 lines)
106		106
107	/**	107	/**
108	* For menu presenters hold action of last focused editor component.	108	* For menu presenters hold action of last focused editor component.
109	* <br/>	109	* <br>
110	* Hold reference strongly but may be changed to weak reference in case	110	* Hold reference strongly but may be changed to weak reference in case
111	* even actions of last activated text component are desired to be released.	111	* even actions of last activated text component are desired to be released.
112	*/	112	*/

Lines 643-653 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/AbstractOffsetGapList.java (-2 / +2 lines)
643	/**	643	/**
644	* This method updates element's offset (shifts it below offset gap if necessary)	644	* This method updates element's offset (shifts it below offset gap if necessary)
645	* before (or after) the element gets removed from the list.	645	* before (or after) the element gets removed from the list.
646	* <br/>	646	* <br>
647	* This method should be called after the element is physically removed	647	* This method should be called after the element is physically removed
648	* from the list and it's desired that it retains its natural offset	648	* from the list and it's desired that it retains its natural offset
649	* (not possibly shifted by the offset gap length).	649	* (not possibly shifted by the offset gap length).
650	* <br/>	650	* <br>
651	* If the element was located below the offset gap prior removal	651	* If the element was located below the offset gap prior removal
652	* then calling of this method is not necessary.	652	* then calling of this method is not necessary.
653	*/	653	*/




import javax.swing.text.Position;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import org.netbeans.api.editor.caret.CaretInfo;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.lib.editor.util.swing.BlockCompare;
import org.netbeans.modules.editor.lib2.DocUtils;
import org.netbeans.modules.editor.lib2.RectangularSelectionUtils;
import org.netbeans.spi.editor.highlighting.HighlightsChangeEvent;
import org.netbeans.spi.editor.highlighting.HighlightsChangeListener;
import org.netbeans.spi.editor.highlighting.HighlightsContainer;
import org.netbeans.spi.editor.highlighting.HighlightsSequence;
import org.netbeans.spi.editor.highlighting.support.AbstractHighlightsContainer;
import org.netbeans.spi.editor.highlighting.support.PositionsBag;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;

 * 
 * @author Vita Stejskal
 */
public abstract class CaretBasedBlockHighlighting implements HighlightsContainer, ChangeListener, PropertyChangeListener {

    // -J-Dorg.netbeans.modules.editor.lib2.highlighting.CaretBasedBlockHighlighting.level=FINE
    private static final Logger LOG = Logger.getLogger(CaretBasedBlockHighlighting.class.getName());

    private final boolean extendsEOL;
    private final boolean extendsEmptyLine;
    
    private final PositionsBag selectionsBag;
    private Position currentBlockEnd;
    
    private AttributeSet attribs;
    

        
        // Hook up the component
        this.component = component;
        
        selectionsBag = new PositionsBag(component.getDocument(), false);
    }
    
    private void init() {

            inited = true;
            init();
        }
        
        return selectionsBag.getHighlights(startOffset, endOffset);
    }

    @Override
    public void addHighlightsChangeListener(HighlightsChangeListener listener) {
        selectionsBag.addHighlightsChangeListener(listener);
    }
            blockEnd = currentBlockEnd;
        }
        if (blockStart != null && blockEnd != null &&
            endOffset >= blockStart.getOffset() && startOffset <= blockEnd.getOffset())
        {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Queried for highlights in <" //NOI18N
                    + startOffset + ", " + endOffset + ">, returning <" //NOI18N
                    + positionToString(blockStart) + ", " + positionToString(blockEnd) + ">" //NOI18N
                    + ", layer=" + s2s(this) + '\n'); //NOI18N
            }

    @Override
    public void removeHighlightsChangeListener(HighlightsChangeListener listener) {
        selectionsBag.removeHighlightsChangeListener(listener);
                getAttribs()
            );
        } else {
            return HighlightsSequence.EMPTY;
        }
    }

    // ------------------------------------------------

        updateLineInfo(true);
    }

    protected abstract PositionsBag getCurrentBlockPositions(Document document);
    
    // ------------------------------------------------
    // private implementation

    private final void updateLineInfo(boolean fire) {
        ((AbstractDocument) component.getDocument()).readLock();
        try {
            PositionsBag newPositions = getCurrentBlockPositions(component.getDocument());
            Position newEnd;
            Position changeStart;
            Position changeEnd;
            Position[] newBlock = getCurrentBlockPositions(component.getDocument());
            synchronized (this) {
                if (newPositions != null) {
                    selectionsBag.setHighlights(newPositions);
                    newEnd = newBlock[1];
                    if (currentBlockStart == null) { // not valid yet
                        if (newStart.getOffset() < newEnd.getOffset()) { // Valid non-empty block
                            changeStart = newStart;
                            changeEnd = newEnd;
                        } else {
                            changeStart = null; // Invalid or empty block => no change
                            changeEnd = null;
                        }
                    } else { // Valid current start and end blocks
                        // Compare new block to old one
                        BlockCompare compare = BlockCompare.get(
                                newStart.getOffset(), newEnd.getOffset(),
                                currentBlockStart.getOffset(), currentBlockEnd.getOffset());
                        if (compare.invalidX()) { // newStart > newEnd
                            changeStart = null; // No change
                            changeEnd = null;
                        } else if (compare.equal()) { // Same blocks
                            changeStart = null; // No firing
                            changeEnd = null;
                        } else if (compare.equalStart()) {
                            if (compare.containsStrict()) {
                                changeStart = currentBlockEnd;
                                changeEnd = newEnd;
                            } else {
                                assert (compare.insideStrict());
                                changeStart = newEnd;
                                changeEnd = currentBlockEnd;
                            }
                        } else if (compare.equalEnd()) {
                            if (compare.containsStrict()) {
                                changeStart = newStart;
                                changeEnd = currentBlockStart;
                            } else {
                                assert (compare.insideStrict());
                                changeStart = currentBlockStart;
                                changeEnd = newStart;
                            }
                        } else {
                            changeStart = (compare.lowerStart()) ? newStart : currentBlockStart;
                            changeEnd = (compare.lowerEnd()) ? currentBlockEnd : newEnd;
                        }
                    }

                } else { // newBlock is null => selection removed
                    selectionsBag.clear();
                    newEnd = null;
                    changeStart = currentBlockStart;
                    changeEnd = currentBlockEnd;
                }

                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Caret selection block changed from [" //NOI18N
                            + positionToString(currentBlockStart) + ", " + positionToString(currentBlockEnd) + "] to [" //NOI18N
                            + positionToString(newStart) + ", " + positionToString(newEnd) + "]" //NOI18N
                            + ", layer=" + s2s(this) + '\n'); //NOI18N
                }
                currentBlockStart = newStart;
                currentBlockEnd = newEnd;
            }

            if (changeStart != null) {
                if (fire) {
                    fireHighlightsChange(changeStart.getOffset(), changeEnd.getOffset());
                }
            }
        } finally {

    private static String s2s(Object o) {
        return o == null ? "null" : o.getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(o)); //NOI18N
    }

    public static final class SimpleHighlightsSequence implements HighlightsSequence {
        
        private int startOffset;
        private int endOffset;
        private AttributeSet attribs;
        
        private boolean end = false;
        
        public SimpleHighlightsSequence(int startOffset, int endOffset, AttributeSet attribs) {
            this.startOffset = startOffset;
            this.endOffset = endOffset;
            this.attribs = attribs;
        }

        @Override
        public boolean moveNext() {
            if (!end) {
                end = true;
                return true;
            } else {
                return false;
            }
        }

        @Override
        public int getStartOffset() {
            return startOffset;
        }

        @Override
        public int getEndOffset() {
            return endOffset;
        }

        @Override
        public AttributeSet getAttributes() {
            return attribs;
        }
    } // End of SimpleHighlightsSequence
    
    public static final class CaretRowHighlighting extends CaretBasedBlockHighlighting {
        

            super(component, FontColorNames.CARET_ROW_COLORING, true, false);
        }
        
        @Override
        protected PositionsBag getCurrentBlockPositions(Document document) {
            Caret caret = caret();
            PositionsBag selections = null;
            if (document != null && caret != null) {
                selections = new PositionsBag(document);
                if(caret instanceof EditorCaret) {
                    EditorCaret editorCaret = (EditorCaret) caret;
                    List<CaretInfo> carets = editorCaret.getCarets();
                    for (CaretInfo c : carets) {
                        int caretOffset = c.getDot();
                        try {
                            int startOffset = DocUtils.getRowStart(document, caretOffset, 0);
                            int endOffset = DocUtils.getRowEnd(document, caretOffset);
                            // include the new-line character or the end of the document
                            endOffset++;
                            Position startPos = document.createPosition(startOffset);
                            Position endPos = document.createPosition(endOffset);
                            selections.addHighlight(startPos, endPos, getAttribs());
                        } catch(BadLocationException e) {
                            LOG.log(Level.WARNING, e.getMessage(), e);
                        }
                    }
                } else {
                    int caretOffset = caret.getDot();
                    try {
                        int startOffset = DocUtils.getRowStart(document, caretOffset, 0);
                        int endOffset = DocUtils.getRowEnd(document, caretOffset);

                        // include the new-line character or the end of the document
                        endOffset++;
                        Position startPos = document.createPosition(startOffset);
                        Position endPos = document.createPosition(endOffset);
                        selections.addHighlight(startPos, endPos, getAttribs());
                    } catch (BadLocationException e) {
                        LOG.log(Level.WARNING, e.getMessage(), e);
                    }
                    LOG.log(Level.WARNING, e.getMessage(), e);
                }
            }
            return selections;
            return null;
        }
    } // End of CaretRowHighlighting class
    

        }
    
        @Override
        protected PositionsBag getCurrentBlockPositions(Document document) {
            Caret caret = caret();
            PositionsBag selections = null;
            if (document != null && caret != null) {
                selections = new PositionsBag(document);
                if(caret instanceof EditorCaret) {
                    EditorCaret editorCaret = (EditorCaret) caret;
                    for (CaretInfo caretInfo : editorCaret.getCarets()) {
                        int caretOffset = caretInfo.getDot();
                        int markOffset = caretInfo.getMark();

                        if (caretOffset != markOffset) {
                            try {
                                Position start = document.createPosition(Math.min(caretOffset, markOffset));
                                Position end = document.createPosition(Math.max(caretOffset, markOffset));
                                selections.addHighlight(start, end, getAttribs());
                            } catch (BadLocationException e) {
                                LOG.log(Level.WARNING, e.getMessage(), e);
                            }
                        }
                    }
                } else {
                    int caretOffset = caret.getDot();
                    int markOffset = caret.getMark();

                    if (caretOffset != markOffset) {
                        try {
                            Position start = document.createPosition(Math.min(caretOffset, markOffset));
                            Position end = document.createPosition(Math.max(caretOffset, markOffset));
                            selections.addHighlight(start, end, getAttribs());
                        } catch (BadLocationException e) {
                            LOG.log(Level.WARNING, e.getMessage(), e);
                        }
                    }
                }
            }
            
            return selections;
        }

//        @Override
//        public HighlightsSequence getHighlights(int startOffset, int endOffset) {
//            if (!RectangularSelectionUtils.isRectangularSelection(component())) { // regular selection
//                return super.getHighlights(startOffset, endOffset);
//            } else { // rectangular selection
//                return (rectangularSelectionBag != null)
//                        ? (rectangularSelectionBag.getHighlights(startOffset, endOffset))
//                        : HighlightsSequence.EMPTY;
//            }
//        }

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            super.propertyChange(evt);
            if (RectangularSelectionUtils.getRectangularSelectionProperty().equals(evt.getPropertyName())) {
//                fireHighlightsChange(0, component().getDocument().getLength());
            }
        }


                    }
                    // Fire change at once
                    if (hlChangeStartOffset != -1) {
//                        fireHighlightsChange(hlChangeStartOffset, hlChangeEndOffset);
                        hlChangeStartOffset = -1;
                    }
                }




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2015 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 2015 Sun Microsystems, Inc.
 */
package org.netbeans.modules.editor.lib2.highlighting;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.AttributeSet;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.StyleConstants;
import org.netbeans.api.editor.caret.CaretInfo;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.api.editor.caret.EditorCaretEvent;
import org.netbeans.api.editor.caret.EditorCaretListener;
import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.lib.editor.util.ListenerList;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.spi.editor.highlighting.HighlightsChangeEvent;
import org.netbeans.spi.editor.highlighting.HighlightsChangeListener;
import org.netbeans.spi.editor.highlighting.HighlightsSequence;
import org.netbeans.spi.editor.highlighting.ReleasableHighlightsContainer;
import org.netbeans.spi.editor.highlighting.ShiftHighlightsSequence;
import org.openide.util.WeakListeners;

/**
 * Used by EditorCaret to color a single character under the block caret(s) with inverse colors in
 * overwrite mode when the caret blinking timer ticks.
 *
 * @author Miloslav Metelka
 */
public final class CaretOverwriteModeHighlighting implements ReleasableHighlightsContainer, PropertyChangeListener, EditorCaretListener {

    public static final String LAYER_TYPE_ID = "org.netbeans.modules.editor.lib2.highlighting.CaretOverwriteModeHighlighting"; //NOI18N

    // -J-Dorg.netbeans.modules.editor.lib2.highlighting.CaretOverwriteModeHighlighting.level=FINE
    private static final Logger LOG = Logger.getLogger(CaretOverwriteModeHighlighting.class.getName());
    
    private final JTextComponent component;
    
    private boolean inited;
    
    private boolean visible;

    private EditorCaret editorCaret;

    private EditorCaretListener weakEditorCaretListener;
    
    private ListenerList<HighlightsChangeListener> listenerList = new ListenerList<>();
    
    private AttributeSet coloringAttrs;
    
    private CharSequence docText;
    
    private List<CaretInfo> sortedCarets;
    
    /** Creates a new instance of CaretSelectionLayer */
    public CaretOverwriteModeHighlighting(JTextComponent component) {
        this.component = component;
        component.putClientProperty(CaretOverwriteModeHighlighting.class, this);
    }
    
    public void setVisible(boolean visible) {
        if (visible != this.visible) {
            this.visible = visible;
            if (editorCaret != null) {
                List<CaretInfo> sortedCaretsL;
                if (visible) {
                    sortedCaretsL = editorCaret.getSortedCarets();
                    synchronized (this) {
                        sortedCarets = sortedCaretsL;
                    }
                } else {
                    synchronized (this) {
                        sortedCaretsL = sortedCarets;
                        sortedCarets = null;
                    }
                }
                if (sortedCaretsL != null) {
                    int changeStartOffset = sortedCaretsL.get(0).getDot();
                    int changeEndOffset = sortedCaretsL.get(sortedCaretsL.size() - 1).getDot() + 1;
                    fireHighlightsChange(changeStartOffset, changeEndOffset);
                }
            }
        }
    }
    
    private void init() {
        component.addPropertyChangeListener(WeakListeners.propertyChange(this, component));
        updateActiveCaret();
        updateColoring();
    }
    
    // ------------------------------------------------
    // AbstractHighlightsContainer implementation
    // ------------------------------------------------
    
    @Override
    public HighlightsSequence getHighlights(int startOffset, int endOffset) {
        if (!inited) {
            inited = true;
            init();
        }
        HighlightsSequence hs;
        boolean visibleL;
        List<CaretInfo> sortedCaretsL;
        synchronized (this) {
            visibleL = visible;
            sortedCaretsL = sortedCarets;
        }
        if (editorCaret != null && visibleL) {
            hs = new HS(sortedCaretsL, startOffset, endOffset);
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("CaretOverwriteModeHighlighting.getHighlights() <" + startOffset + "," + endOffset + ">\n");
            }
        } else {
            hs = HighlightsSequence.EMPTY;
        }
        return hs;
    }

    @Override
    public void addHighlightsChangeListener(HighlightsChangeListener listener) {
        listenerList.add(listener);
    }

    @Override
    public void removeHighlightsChangeListener(HighlightsChangeListener listener) {
        listenerList.remove(listener);
    }
    
    private void fireHighlightsChange(HighlightsChangeEvent evt) {
        for (HighlightsChangeListener listener : listenerList.getListeners()) {
            listener.highlightChanged(evt);
        }
    }

    private void fireHighlightsChange(int startOffset, int endOffset) {
        fireHighlightsChange(new HighlightsChangeEvent(this, startOffset, endOffset));
    }

    // ------------------------------------------------
    // PropertyChangeListener implementation
    // ------------------------------------------------
    
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        String propName = evt.getPropertyName();
        if (propName == null || "caret".equals(propName)) { //NOI18N
            updateActiveCaret();
        } else if ("document".equals(propName)) {
            updateDocText();
        } else if ("caretColor".equals(propName) || "background".equals(propName)) {
            updateColoring();
        }
    }
    
    @Override
    public void caretChanged(EditorCaretEvent evt) {
        if (visible) {
            fireHighlightsChange(evt.getAffectedStartOffset(), evt.getAffectedEndOffset());
            List<CaretInfo> sortedCaretsL;
            sortedCaretsL = editorCaret.getSortedCarets();
            synchronized (this) {
                sortedCarets = sortedCaretsL;
            }
        }
    }

    @Override
    public void released() {
        component.removePropertyChangeListener(this);
    }
    
    private void updateActiveCaret() {
        if (visible) {
            setVisible(false);
        }
        if (editorCaret != null) {
            editorCaret.removeEditorCaretListener(weakEditorCaretListener);
            weakEditorCaretListener = null;
            editorCaret = null;
            docText = null;
        }

        Caret caret = component.getCaret();
        if (caret instanceof EditorCaret) { // Only work for editor caret
            editorCaret = (EditorCaret) caret;
        }

        if (editorCaret != null) {
            updateDocText();
            weakEditorCaretListener = WeakListeners.create(EditorCaretListener.class, this, editorCaret);
            editorCaret.addEditorCaretListener(weakEditorCaretListener);
        }
    }

    private void updateColoring() {
        coloringAttrs = AttributesUtilities.createImmutable(
                StyleConstants.Background, component.getCaretColor(),
                StyleConstants.Foreground, component.getBackground());
    }
    
    private void updateDocText() {
        JTextComponent c = component;
        CharSequence text = null;
        if (c != null) {
            Document doc = c.getDocument();
            if (doc != null) {
                text = DocumentUtilities.getText(doc);
            }
        }
        docText = text;
    }
    
    private final class HS implements ShiftHighlightsSequence {
        
        private final List<CaretInfo> sortedCarets;
        
        private final int startOffset;
        
        private final int endOffset;

        private int caretOffset = -1;
        
        private int caretOffsetEndShift;

        private int caretIndex;
        
        HS(List<CaretInfo> sortedCarets, int startOffset, int endOffset) {
            this.sortedCarets = sortedCarets;
            this.startOffset = startOffset;
            this.endOffset = endOffset;
        }

        @Override
        public boolean moveNext() {
            boolean ret = false;
            if (caretOffset == -1) { // Return first highlight
                while (caretOffset < startOffset && caretIndex < sortedCarets.size()) {
                    CaretInfo caret = sortedCarets.get(caretIndex++);
                    caretOffset = caret.getDot();
                }
                if (caretOffset != -1) {
                    ret = true;
                }
            } else {
                while (caretIndex < sortedCarets.size()) {
                    CaretInfo caret = sortedCarets.get(caretIndex++);
                    int offset = caret.getDot();
                    // Check for case if sorted carets would not be truly sorted or there would be duplicates
                    if (offset > caretOffset) {
                        caretOffset = offset;
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("  CaretOverwriteModeHighlighting.Highlight <" + caretOffset + "," + (caretOffset + 1) + ">\n");
                        }
                        return true;
                    }
                    if (offset >= endOffset) {
                        return false;
                    }
                }
            }
            if (ret) {
                caretOffsetEndShift = 0;
                CharSequence text = docText;
                if (text != null) {
                    char ch = text.charAt(caretOffset);
                    if (ch == '\t' || ch == '\n') {
                        caretOffsetEndShift = 1;
                    }
                }
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("  CaretOverwriteModeHighlighting.Highlight <" + caretOffset + "(sh=0)," +
                            (caretOffset + 1) + "(sh=" + caretOffsetEndShift + ")>\n");
                }
                return true;
            }
            return false;
        }

        @Override
        public int getStartOffset() {
            return caretOffset;
        }

        @Override
        public int getEndOffset() {
            return caretOffset + 1;
        }

        @Override
        public AttributeSet getAttributes() {
            return coloringAttrs;
        }

        @Override
        public int getStartShift() {
            return 0;
        }

        @Override
        public int getEndShift() {
            return caretOffsetEndShift;
        }
        
        
    }
}

Lines 50-58 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/CompoundAttributes.java (-2 / +2 lines)
50	/**	50	/**
51	* Multiple highlights for a particular view contains an array of highlights	51	* Multiple highlights for a particular view contains an array of highlights
52	* and a starting offset to which the (ending) offsets in HighlightItem(s) are related.	52	* and a starting offset to which the (ending) offsets in HighlightItem(s) are related.
53	* <br/>	53	* <br>
54	* The view should assign this object to its internal 'attributes' variable that holds the AttributeSet.	54	* The view should assign this object to its internal 'attributes' variable that holds the AttributeSet.
55	* <br/>	55	* <br>
56	* The AttributeSet implementation returns attributes of the first section of the compound attributes.	56	* The AttributeSet implementation returns attributes of the first section of the compound attributes.
57	*	57	*
58	* @author Miloslav Metelka	58	* @author Miloslav Metelka




import org.netbeans.spi.editor.highlighting.HighlightsContainer;
import org.netbeans.spi.editor.highlighting.HighlightsSequence;
import org.netbeans.spi.editor.highlighting.ReleasableHighlightsContainer;
import org.netbeans.spi.editor.highlighting.ShiftHighlightsSequence;
import org.openide.util.WeakListeners;

/**
 * Compound highlights-layer container that does non-cached direct merging
 * of individual layers' highlights.
 * <br>
 * It's somewhat similar to a view building process in view hierarchy which also maintains
 * next-change-offset where a change in the particular layer occurs and needs to be processed.
 * <br>
 * {@link ShiftHighlightsSequence} are supported and the highlights sequences returned by the container
 * are always instances of this interface.
 *
 * @author Miloslav Metelka
 */

        layerEvent = event;
        try {
            if (!listeners.isEmpty()) {
                HighlightsChangeEvent thisEvt = new HighlightsChangeEvent(this, event.getStartOffset(), event.getEndOffset());
                for (HighlightsChangeListener l : listeners) {
                    l.highlightChanged(thisEvt);
                }
            }
            synchronized (activeHlSeqs) {

    /**
     * Get event from a contained layer which caused highlight change
     * (mainly for debugging purposes).
     * <br>
     * The information is only available during firing to change listeners registered by
     * {@link #addHighlightsChangeListener(org.netbeans.spi.editor.highlighting.HighlightsChangeListener)}.
     * 

        }
    }
    
    static final class HlSequence implements ShiftHighlightsSequence {

        /**
         * Wrappers around layers used to compute merged highlights.

        
        private int topWrapperIndex;
        
        final int endOffset;
        
        int mergedHighlightStartOffset;
        
        int mergedHighlightStartShift;
        
        int mergedHighlightEndOffset;
        
        int mergedHighlightEndShift;
        
        AttributeSet mergedAttrs;
        
        volatile boolean finished; // Either no more highlights or layers were changed;

            for (int i = 0; i < layers.length; i++) {
                HighlightsContainer container = layers[i];
                HighlightsSequence hlSequence = container.getHighlights(startOffset, endOffset);
                Wrapper wrapper = new Wrapper(container, hlSequence, endOffset);
                if (wrapper.init(startOffset)) { // For no-highlight wrapper do not include it at all in the array
                    wrappers[topWrapperIndex++] = wrapper;
                }
            }
            topWrapperIndex--;
            updateMergeVars(-1, startOffset, 0); // Update all layers to fetch correct values
        }
        
        @Override
        public boolean moveNext() {
            if (finished) {
                return false;
            }
            Wrapper topWrapper;
            int nextHighlightStartOffset = mergedHighlightEndOffset;
            int nextHighlightStartShift = mergedHighlightEndShift;
            while ((topWrapper = nextMerge(nextHighlightStartOffset, nextHighlightStartShift)) != null) {
                int nextChangeOffset = topWrapper.mergedNextChangeOffset;
                int nextChangeShift = topWrapper.mergedNextChangeShift;
                    return false;
                }
                AttributeSet attrs = topWrapper.mAttrs;
                if (attrs != null) { // Do not return regions with empty attrs (they are not highlights)
                    mergedHighlightStartOffset = nextHighlightStartOffset;
                    mergedHighlightStartShift = nextHighlightStartShift;
                    mergedHighlightEndOffset = nextChangeOffset;
                    mergedHighlightEndShift = nextChangeShift;
                    mergedAttrs = attrs;
                    return true;
                }
                nextHighlightStartOffset = nextChangeOffset;
                nextHighlightStartShift = nextChangeShift;
            }
            finished = true;
            return false;
        }


        }

        @Override
        public int getStartShift() {
            return mergedHighlightStartShift;
        }
        
        @Override
        public int getEndOffset() {
            return mergedHighlightEndOffset;
        }

        @Override
        public int getEndShift() {
            return mergedHighlightEndShift;
        }
        
        @Override
        public AttributeSet getAttributes() {
            return mergedAttrs;
        }

        @Override
        public boolean isStale() {
            return finished;
        }
        
        void notifyLayersChanged() { // Notify that layers were changed => stop iteration
            finished = true;
        }

         * Do merge above the given offset.
         *
         * @param offset end of last merged highlight.
         * @param shift end shift of last merged highlight (accompanying the offset).
         * @return top wrapper containing info about the performed merge or null
         *  if there is zero wrappers.
         */
        Wrapper nextMerge(int offset, int shift) {
            int i = topWrapperIndex;
            for (; i >= 0 && wrappers[i].isMergedNextChangeBelowOrAt(offset, shift); i--) { }
            // i contains first layer which has mergedNextChangeOffset > offset (or same offset but lower shift)
            return updateMergeVars(i, offset, shift);
        }
        
        /**
         * Update merged vars of wrappers at (startIndex+1) and above.
         *
         * @param startIndex index of first wrapper which has mergedNextChangeOffset above given offset (and shift)
         *  or -1 if all wrappers need to be updated.
         *  All wrappers above this index will have their mergedNextChangeOffset and mAttrs updated.
         * @param offset current offset at which to update.
         * @param shift current shift "within" the char at offset.
         * @return top wrapper (wrapper at topWrapperIndex).
         */
        Wrapper updateMergeVars(int startIndex, int offset, int shift) {
            Wrapper wrapper = null;
            int nextChangeOffset;
            int nextChangeShift;
            AttributeSet lastAttrs;
            if (startIndex < 0) { // No valid layers
                nextChangeOffset = endOffset;
                nextChangeShift = 0;
                lastAttrs = null;
            } else {
                wrapper = wrappers[startIndex];
                nextChangeOffset = wrapper.mergedNextChangeOffset;
                nextChangeShift = wrapper.mergedNextChangeShift;
                lastAttrs = wrapper.mAttrs;
            }
            // Start with first wrapper that needs to be updated
            wrapperIteration:
            for (int i = startIndex + 1; i <= topWrapperIndex; i++) {
                wrapper = wrappers[i];
                if (wrapper.isNextChangeBelowOrAt(offset, shift)) {
                    while (wrapper.updateCurrentState(offset, shift)) { // Check if next highlight fetch is necessary
                        if (!wrapper.fetchNextHighlight()) { // Finished all highlights in sequence
                            removeWrapper(i); // Remove this wrapper (does topWrapperIndex--)
                            // Ensure that the wrapper returned from method is correct after removeWrapper()
                            // topWrapperIndex already decreased by removeWrapper()
                            i--; // Compensate wrapper removal in for(;;)
                            if (i == topWrapperIndex) {
                                // Since "wrapper" variable should return wrapper at current topWrapperIndex
                                // that in this particular case was just removed
                                // then assign current top wrapper explicitly.
                                wrapper = (i >= 0) ? wrappers[i] : null;
                                break wrapperIteration;
                            }
                            continue wrapperIteration;
                        }
                        wrapper.updateCurrentState(offset); // Update state to just fetched highlight
                    }
                }
                if (wrapper.isNextChangeBelow(nextChangeOffset, nextChangeShift)) {
                    nextChangeOffset = wrapper.nextChangeOffset;
                    nextChangeShift = wrapper.nextChangeShift;
                }
                wrapper.mergedNextChangeOffset = nextChangeOffset;
                wrapper.mergedNextChangeShift = nextChangeShift;
                lastAttrs = (lastAttrs != null)
                        ? ((wrapper.currentAttrs != null)
                            ? AttributesUtilities.createComposite(wrapper.currentAttrs, lastAttrs) // first prior second

    static final class Wrapper {

        /**
         * Layer over which layerSequence is constructed (for debugging purposes).
         */
        final HighlightsContainer layer;
        
        /**
         * Highlights sequence for layer corresponding to this wrapper.
         */
        final HighlightsSequence layerSequence;
        
        /**
         * Highlights sequence supporting coloring of characters inside tabs or newlines.
         */
        final ShiftHighlightsSequence shiftLayerSequence;
        
        /**
         * End offset of the region on which upper hlSequence operates so the highlights
         * returned by layerSequence should adhere to this limit too.
         */
        final int endOffset;
        
        /**
         * Start offset of the last fetched highlight.

        int hlStartOffset;
        
        /**
         * Possible shift accompanying hlStartOffset or zero for non-ShiftHighlightsSequence.
         */
        int hlStartShift;
        
        /**
         * End offset of the last fetched highlight.
         */
        int hlEndOffset;
        
        /**
         * Possible shift accompanying hlEndOffset or zero for non-ShiftHighlightsSequence.
         */
        int hlEndShift;

        /**
         * Attributes of the last fetched highlight.
         */
        AttributeSet hlAttrs;
        
        /**
         * Offset where a change in highlighting for the current layer will occur.
         * If currently processed offset is below current highlight (fetched into hlStartOffset and hlEndOffset)
         * then the value is set to hlStartOffset.
         * For an offset inside current highlight the value will be set to hlEndOffset.
         * Offset above hlEndOffset will trigger a next highlight fetching.
         */
        int nextChangeOffset;
        
        /**
         * If shiftHLSequence != null then (similarly to nextChangeOffset)
         * this is set either to start shift of the next highlight
         * or (if the offset and its shift are inside current highlight) then
         * this variable is set to end shift of the current highlight
         * or a next highlight will be fetched (if current offset and shift are above the highlight).
         */
        int nextChangeShift;
        
        /**
         * Attributes for an offset: when before hlStartOffset it's null.
         * Otherwise it's hlAttrs.
         */

         * Merged next change offset: minimum of nextChangeOffset from all
         * wrappers below this one in the wrappers array.
         */
        int mergedNextChangeOffset;
        
        /**
         * Merged next change shift - possible shift accompanying mergedNextChangeOffset or zero.
         */
        int mergedNextChangeShift;
        
        /**
         * Merged attributes: merge of currentAttrs from all

        private int emptyHighlightCount;
        
        
        public Wrapper(HighlightsContainer layer, HighlightsSequence hlSequence, int endOffset) {
            this.layer = layer;
            this.layerSequence = hlSequence;
            this.shiftLayerSequence = (hlSequence instanceof ShiftHighlightsSequence) ? (ShiftHighlightsSequence) hlSequence : null;
            this.endOffset = endOffset;
            this.mNextChangeOffset = startOffset; // Will cause recomputation
        }
        
        boolean init(int startOffset) {
            do {
                if (!fetchNextHighlight()) {
                    return false;
                }
            } while (hlEndOffset <= startOffset); // Exclude any possible highlights ending below startOffset
            updateCurrentState(startOffset, 0);
            return true;
        }
        
        /**
         * Whether next change offset and shift of this wrapper are below the given parameters.
         *
         * @param offset current offset.
         * @param shift current shift (accompanying the current offset).
         * @return true if next change offset and shift of this wrapper are below the given parameters
         *  or false otherwise.
         */
        boolean isNextChangeBelow(int offset, int shift) {
            return nextChangeOffset < offset || (nextChangeOffset == offset && nextChangeShift < shift);
        }

        /**
         * Whether next change offset and shift of this wrapper are below the given parameters
         * or right at them.
         *
         * @param offset current offset.
         * @param shift current shift (accompanying the current offset).
         * @return true if next change offset and shift of this wrapper are below or right at the given parameters
         *  or false otherwise.
         */
        boolean isNextChangeBelowOrAt(int offset, int shift) {
            return nextChangeOffset < offset || (nextChangeOffset == offset && nextChangeShift <= shift);
        }

        /**
         * Whether merged next change offset and shift of this wrapper are below the given parameters
         * or right at them.
         *
         * @param offset current offset.
         * @param shift current shift (accompanying the current offset).
         * @return true if next change offset and shift of this wrapper are below or right at the given parameters
         *  or false otherwise.
         */
        boolean isMergedNextChangeBelowOrAt(int offset, int shift) {
            return mergedNextChangeOffset < offset || (mergedNextChangeOffset == offset && mergedNextChangeShift <= shift);
        }

        /**
         * Update currentAttrs and nextChangeOffset according to given offset.
         * @param offset offset to which to update
         * @param shift shift inside tab or newline character on the given offset.
         * @return true if the offset is >= hlEndOffset and so fetchNextHighlight() is necessary.
         */
        boolean updateCurrentState(int offset, int shift) {
            if (offset < hlStartOffset) { // offset before current hl start
                currentAttrs = null;
                nextChangeOffset = hlStartOffset;
                nextChangeShift = hlStartShift;
                return false;
            } else if (offset == hlStartOffset) { // inside hl (assuming call after fetchNextHighlight())
                if (shift < hlStartShift) {
                    currentAttrs = null;
                    nextChangeOffset = hlStartOffset;
                    nextChangeShift = hlStartShift;
                    return false;
                    
                } else { // Above (or at) highlight's start
                    if (offset < hlEndOffset || (offset == hlEndOffset && shift < hlEndShift)) {
                        currentAttrs = hlAttrs;
                        nextChangeOffset = hlEndOffset;
                        nextChangeShift = hlEndShift;
                        return false;
                    } else {
                        return true; // Fetch next highlight
                    }
                } // else: fetch next highlight
            } else if (offset < hlEndOffset || (offset == hlEndOffset && shift < hlEndShift)) {
                currentAttrs = hlAttrs;
                nextChangeOffset = hlEndOffset;
                nextChangeShift = hlEndShift;
                return false;
            } else { // Above hlEndOffset (or hlEndShift) => fetch next highlight
                return true; // Fetch next highlight
            }
        }
        
        /**

         * @param offset
         * @return true if highlight fetched successfully or false if there are no more highlights.
         */
        boolean fetchNextHighlight() {
            while (layerSequence.moveNext()) { // Loop to allow for skip over empty highlights
                hlStartOffset = layerSequence.getStartOffset();
                if (hlStartOffset < hlEndOffset) { // Invalid layer: next highlight overlaps previous one
                    // To prevent infinite loops finish this HL
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Disabled an invalid highlighting layer: hlStartOffset=" + hlStartOffset + // NOI18N
                            " < previous hlEndOffset=" + hlEndOffset + " for layer=" + layer); // NOI18N
                    }
                    return false;
                }
                hlEndOffset = layerSequence.getEndOffset();
                if (hlEndOffset <= hlStartOffset) {
                    if (hlEndOffset < hlStartOffset) { // Invalid highlight: end offset before start offset
                        // To prevent infinite loops finish this HL
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("Disabled an invalid highlighting layer: hlStartOffset=" + hlStartOffset + // NOI18N
                                " > hlEndOffset=" + hlEndOffset + " for layer=" + layer); // NOI18N
                        }
                        hlStartOffset = hlEndOffset = Integer.MAX_VALUE;
                        return false;
                    }
                    emptyHighlightCount++;
                    if (emptyHighlightCount >= MAX_EMPTY_HIGHLIGHT_COUNT) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("Disabled an invalid highlighting layer: too many empty highlights=" + emptyHighlightCount); // NOI18N
                            if (LOG.isLoggable(Level.FINE)) {
                                LOG.fine("Disabled an invalid highlighting layer: hlStartOffset=" + hlStartOffset + // NOI18N
                                    " > hlEndOffset=" + hlEndOffset + " for layer=" + layer); // NOI18N
                            }
                            hlStartOffset = hlEndOffset = Integer.MAX_VALUE;
                            return false;
                        }
                        return false;
                        if (emptyHighlightCount >= MAX_EMPTY_HIGHLIGHT_COUNT) {
                            if (LOG.isLoggable(Level.FINE)) {
                                LOG.fine("Disabled an invalid highlighting layer: too many empty highlights=" + emptyHighlightCount); // NOI18N
                            }
                            hlStartOffset = hlEndOffset = Integer.MAX_VALUE;
                            return false;
                        }
                    }
                    continue; // Fetch next highlight
                }
                if (hlEndOffset > endOffset) {
                    if (hlStartOffset >= endOffset) {
                        return false;
                    }
                    hlEndOffset = endOffset; // Limit the highlight to endOffset - it should still remain non-empty
                    hlStartOffset = hlEndOffset = Integer.MAX_VALUE; // Signal that sequence is finished
                    return false;
                }
                if (shiftLayerSequence != null) {
                    hlStartShift = shiftLayerSequence.getStartShift();
                    hlEndShift = shiftLayerSequence.getEndShift();
                    // Do not perform extra checking of validity (non-overlapping with previous highlight
                    //  and validity of shifts since it should not be crucial
                    //  for proper functioning of updateCurrentState() method.
                } // else hlStartShift and hlEndShift are always zero in the wrapper
                hlAttrs = layerSequence.getAttributes();
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.fine("Fetched highlight: <" + hlStartOffset + // NOI18N
                            "," + hlEndOffset + "> for layer=" + layer + '\n'); // NOI18N
                }
                return true; // Valid highlight fetched
            }
            return false; // No more highlights
        }

        @Override
        public String toString() {
            return  "M[" + mergedNextChangeOffset + ",A=" + mAttrs + // NOI18N
                    "]  Next[" + nextChangeOffset + ",A=" + currentAttrs + // NOI18N
                    "]  HL:<" + hlStartOffset + "," + hlEndOffset + ">,A=" + hlAttrs; // NOI18N
        }

Lines 114-119 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/Factory.java (+7 lines)
114	true, // fixed size	114	true, // fixed size
115	new WhitespaceHighlighting(context.getComponent()))	115	new WhitespaceHighlighting(context.getComponent()))
116	);	116	);
		117
		118	layers.add(HighlightsLayer.create(
		119	CaretOverwriteModeHighlighting.LAYER_TYPE_ID,
		120	ZOrder.TOP_RACK.forPosition(100),
		121	true, // fixed size
		122	new CaretOverwriteModeHighlighting(context.getComponent()))
		123	);
117		124
118	return layers.toArray(new HighlightsLayer [layers.size()]);	125	return layers.toArray(new HighlightsLayer [layers.size()]);
119	}	126	}

Lines 81-90 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/HighlightingManager.java (-2 / +2 lines)
81		81
82	/**	82	/**
83	* Highlighting manager maintains all the highlighting layers instances.	83	* Highlighting manager maintains all the highlighting layers instances.
84	* <br/>	84	* <br>
85	* It divides them into two groups according to their z-order and fixedSize attributes.	85	* It divides them into two groups according to their z-order and fixedSize attributes.
86	* Top layers that have fixedSize set to true are one group. The rest is the other group.	86	* Top layers that have fixedSize set to true are one group. The rest is the other group.
87	* <br/>	87	* <br>
88	* View hierarchy only rebuilds views if the second group of layers (bottom ones) changes.	88	* View hierarchy only rebuilds views if the second group of layers (bottom ones) changes.
89	* If the top group changes the view hierarchy only triggers repaint of affected part.	89	* If the top group changes the view hierarchy only triggers repaint of affected part.
90	*	90	*




    
    /**
     * List of highlight items. First highlights item starts at startOffset.
     * <br>
     * GapList is used due to its copyElements() method.
     */
    private HighlightItem[] highlightItems;

     * Create attribute set covering {@link #startOffset()} till maxEndOffset
     * or lower offset if font would differ for the particular attribute set
     * of an item.
     * <br>
     * The list must cover cutEndOffset otherwise the behavior is undefined.
     *
     * @param defaultFont default font to which the attributes in highlight items

    
    /**
     * Create attribute set covering single character at {@link #startOffset()}.
     * <br>
     * The list must cover {@link #startOffset()} otherwise the behavior is undefined.
     *
     * @return attribute set.




                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Highlighting file " + file + " in <" + startOffset + ", " + endOffset + ">"); //NOI18N
                }
                return new SimpleHighlightsSequence(
                    Math.max(0, startOffset),
                    Math.min(document.getLength(), endOffset),
                    attribs);

        }
        return null;
    }
    
    private static final class SimpleHighlightsSequence implements HighlightsSequence {
        
        private int startOffset;
        private int endOffset;
        private AttributeSet attribs;
        
        private boolean end = false;
        
        public SimpleHighlightsSequence(int startOffset, int endOffset, AttributeSet attribs) {
            this.startOffset = startOffset;
            this.endOffset = endOffset;
            this.attribs = attribs;
        }

        @Override
        public boolean moveNext() {
            if (!end) {
                end = true;
                return true;
            } else {
                return false;
            }
        }

        @Override
        public int getStartOffset() {
            return startOffset;
        }

        @Override
        public int getEndOffset() {
            return endOffset;
        }

        @Override
        public AttributeSet getAttributes() {
            return attribs;
        }
    } // End of SimpleHighlightsSequence
}

Lines 79-85 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/SyntaxHighlighting.java (-1 / +1 lines)
79		79
80	/**	80	/**
81	* The syntax coloring layer.	81	* The syntax coloring layer.
82	* <br/>	82	* <br>
83	* It excludes newline chars from any colorings so that if e.g. a whitespace highlighting is set	83	* It excludes newline chars from any colorings so that if e.g. a whitespace highlighting is set
84	* the rest of line after newline is not colored.	84	* the rest of line after newline is not colored.
85	*	85	*

Lines 44-50 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/VisualMark.java (-2 / +2 lines)
44	/**	44	/**
45	* Visual mark encapsulates y-coordinate offset together with an object	45	* Visual mark encapsulates y-coordinate offset together with an object
46	* that provides an offset (assumed that it's tracked as a SWing position).	46	* that provides an offset (assumed that it's tracked as a SWing position).
47	* <br/>	47	* <br>
48	* The y-coordinate is tracked as a raw value that must first be preprocessed	48	* The y-coordinate is tracked as a raw value that must first be preprocessed
49	* by {@link VisualMarkVector}.	49	* by {@link VisualMarkVector}.
50	*	50	*
Lines 62-68 Link Here
62		62
63	/**	63	/**
64	* Get offset of this visual mark.	64	* Get offset of this visual mark.
65	* <br/>	65	* <br>
66	* It's assumed that the offset is tracked as a Swing position.	66	* It's assumed that the offset is tracked as a Swing position.
67	*	67	*
68	* @return >=0 offset of this mark.	68	* @return >=0 offset of this mark.

Lines 60-66 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/WhitespaceHighlighting.java (-1 / +1 lines)
60		60
61	/**	61	/**
62	* Highlighting of indentation and trailing whitespace.	62	* Highlighting of indentation and trailing whitespace.
63	* <br/>	63	* <br>
64	* If there's no non-WS text on the line the whitespace is treated as trailing.	64	* If there's no non-WS text on the line the whitespace is treated as trailing.
65	*	65	*
66	* @author Miloslav Metelka	66	* @author Miloslav Metelka

Lines 47-53 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/search/TextStorageSet.java (-1 / +1 lines)
47		47
48	/**	48	/**
49	* Set of character sequences allowing to compare a part of character sequence.	49	* Set of character sequences allowing to compare a part of character sequence.
50	* <br/>	50	* <br>
51	* Note: Character sequences stored must be comparable by their equals() method.	51	* Note: Character sequences stored must be comparable by their equals() method.
52	*	52	*
53	* @author Miloslav Metelka	53	* @author Miloslav Metelka

Lines 49-58 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/AttributedCharSequence.java (-2 / +2 lines)
49		49
50	/**	50	/**
51	* Char sequence with additional attributes.	51	* Char sequence with additional attributes.
52	* <br/>	52	* <br>
53	* Method operate with javax.swing.text.AttributeSet which they transfer	53	* Method operate with javax.swing.text.AttributeSet which they transfer
54	* to corresponding TextAttribute constants.	54	* to corresponding TextAttribute constants.
55	* <br/>	55	* <br>
56	* After creation the series of addTextRun() is called followed by setText()	56	* After creation the series of addTextRun() is called followed by setText()
57	* which completes modification and makes the object ready for clients.	57	* which completes modification and makes the object ready for clients.
58	*	58	*





/**
 * View representing the whole document.
 * <br>
 * It consists of individual paragraph views that typically map to line elements
 * but e.g. code folding may cause multiple line elements correspond to one line view.
 * 

    
    /**
     * Start offset of the document view after last processed modification.
     * <br>
     * This is used during updating of the document view by document modification.
     * For undo of removal the position of first paragraph may restore inside the inserted area
     * and holding integer offset allows to know the original start offset.


    /**
     * Start offset of the document view.
     * <br>
     * This is used during updating of the document view by document modification.
     * For undo of removal the position of last paragraph may restore inside the inserted area
     * and holding integer offset allows to know the original end offset of the document view.

    /**
     * Get current allocation of the document view by using size from last call
     * to {@link #setSize(float, float)}.
     * <br>
     * Returned instance may not be mutated (use getAllocationMutable()).
     *
     * @return current allocation of document view.





/**
 * Class that manages children of {@link EditorBoxView}.
 * <br>
 * The class can manage offsets of children in case {@link #rawEndOffsetManaged()}
 * returns true. In such case each child must properly implement {@link EditorView#getRawEndOffset()}
 * and the maintained raw offsets are relative to corresponding box view's getStartOffset().
 * <br>
 * Generally children of {@link #ParagraphView} manage their raw end offsets
 * while children of {@link #DocumentView} do not manage them (they use Position objects
 * to manage its start).

    
    /**
     * Replace paragraph views inside DocumentView.
     * <br>
     * In case both removeCount == 0 and addedViews is empty this method does not need to be called.
     *
     * @param docView

    /**
     * Get view index of first view that "contains" the offset (starts with it or it's inside)
     * by examining child views' absolute start offsets.
     * <br>
     * This is suitable for document view where start offsets of paragraph views
     * are maintained as positions.
     * 




    
    /**
     * Whether the "children" is currently reflecting the document state.
     * <br>
     * The children may hold a semi-valid view hierarchy which may still be partly used
     * to resolve queries in some cases.
     */

     * Constant retrieved from preferences settings that allows the user to increase/decrease
     * paragraph view's height (which may help for problematic fonts that do not report its height
     * correctly for them to fit the line).
     * <br>
     * By default it's 1.0. All the ascents, descent and leadings of all fonts
     * are multiplied by the constant.
     */

    /**
     * Get displayed portion of the component (either viewport.getViewRect())
     * or (if viewport is missing) size of the component.
     * <br>
     * Note: The value may be obsolete during paint - clipping bounds may already
     *  incorporate a just performed scroll while visibleRect does not yet.
     *

Lines 51-57 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/EditorTabExpander.java (-1 / +1 lines)
51		51
52	/**	52	/**
53	* Tab expander of the editor.	53	* Tab expander of the editor.
54	* <br/>	54	* <br>
55	* It aligns visually (not by number of characters) since it's a desired behavior	55	* It aligns visually (not by number of characters) since it's a desired behavior
56	* for asian languages characters that visually occupy two regular characters and they should	56	* for asian languages characters that visually occupy two regular characters and they should
57	* be treated in that way in terms of tab aligning.	57	* be treated in that way in terms of tab aligning.





/**
 * Base class for views in editor view hierarchy.
 * <br>
 * In general there are three types of views:<ul>
 * <li>Document view</li>
 * <li>Paragraph views</li>
 * <li>Children of paragraph views which include highlights view, newline view and others.</li>
 * </ul>
 * <br>
 * Paragraph views have their start offset based over a swing text position. Their end offset
 * is based on last child's end offset.
 * <br>
 * Children of paragraph views have their start offset based over a relative distance
 * to their parent's paragraph view's start offset. Therefore their start offset does not mutate
 * upon modification unless the whole paragraph's start offset mutates.

    /**
     * Get raw end offset of the view which may transform to real end offset
     * when post-processed by parent view.
     * <br>
     * <b>Note:</b> Typical clients should NOT call this method (they should call
     * {@link #getEndOffset()} method instead).
     *





/**
 * SPI class allowing to produce views.
 * <br>
 * There are two main factories: for folds and for highlights (the default one).
 * The factories have a priority and factory with highest priority
 * will always "win" in terms that its view will surely be created as desired.
 * Factories at lower levels will receive a limitOffset into createView()
 * being a start offset of the view produced by a higher level factory.
 * The factory may decide whether it will create view with limiting offset or not.
 * <br>
 * Factory generally operates in two modes:<ul>
 * <li>Regular mode when the factory produces views</li>
 * <li>Offset mode when the factory only returns bounds of the produced views

    /**
     * Notify next offset area where views will be created in case endCreationOffset
     * in {@link #restart(int, int)} was exceeded.
     * <br>
     * This method may be called multiple times if views building still does not match
     * original views boundaries.
     *


    /**
     * Return starting offset of the next view to be produced by this view factory.
     * <br>
     * This method gets called after restarting of this view factory
     * (with a <code>startOffset</code> parameter passed to {@link #restart(int)})
     * and also after any of the registered view factories created a view

     * Create a view at the given offset. The view factory must determine
     * the appropriate end offset of the produced view and set its length
     * returned by {@link EditorView#getLength()} appropriately.
     * <br>
     * This method is only called if the factory is in view-producing mode
     * (its {@link #viewEndOffset(startOffset, limitOffset)} is not called).
     *

     * @param origView original view located at the given position (it may have a different
     *  physical offset due to just performed modification but it corresponds to the same text
     *  in the document). It may be null if there is no view to reuse.
     *  <br>
     *  The factory may not return the given instance but it may reuse an arbitrary information
     *  from it.
     *  <br>
     *  For example for text layout reuse the highlights view factory will first check if the view
     *  is non-null and matches views produced by it then it will check
     *  if the new view has same length as the original one and that the view attributes


    /**
     * Return to-be-created view's end offset.
     * <br>
     * This method is only called when createViews parameter
     * in {@link #restart(int, int, boolean)} is false. In such mode no physical views
     * are created and only view boundaries of potential views are being determined.


    /**
     * Finish this round of views creation.
     * <br>
     * {@link #restart(int) } may be called subsequently to init a new round
     * of views creation.
     */


    /**
     * Schedule repaint request on the view hierarchy.
     * <br>
     * Document must be read-locked prior calling this method.
     *
     * @param startOffset

     *  Signal that this view factory is no longer able to produce
     *  valid views due to some serious changes that it processes
     *  (for example highlights change for HighlightsViewFactory).
     *  <br>
     *  View creation may be stopped immediately by the caller and restarted to get
     *  the correct views. However if it would fail periodically the caller may decide
     *  to continue the creation to have at least some views. In both cases
     *  the view factory should be able to continue working normally.
     *  <br>
     *  This method can be called from any thread.
     */
    protected final void notifyStaleCreation() {

    /**
     * Notification that this factory is no longer being used so it should
     * release its resources - for example detach all listeners.
     * <br>
     * It's called upon document view receives setParent(null) which typically signals
     * that a new document view will be created for the particular editor pane.
     */

Lines 43-49 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/EditorViewFactoryChange.java (-1 / +1 lines)
43		43
44	/**	44	/**
45	* Offset range describing change in particular view factory.	45	* Offset range describing change in particular view factory.
46	* <br/>	46	* <br>
47	* Each factory may fire a list of changes of different types at once.	47	* Each factory may fire a list of changes of different types at once.
48	*	48	*
49	* @author Miloslav Metelka	49	* @author Miloslav Metelka

Lines 60-66 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/HighlightsView.java (-1 / +1 lines)
60		60
61	/**	61	/**
62	* View with highlights. This is the most used view.	62	* View with highlights. This is the most used view.
63	* <br/>	63	* <br>
64	* It can either have no highlights (attributes == null) or simple attributes	64	* It can either have no highlights (attributes == null) or simple attributes
65	* (attributes == non-	65	* (attributes == non-
66	*	66	*

Lines 67-73 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/HighlightsViewFactory.java (-2 / +2 lines)
67	/**	67	/**
68	* View factory returning highlights views. It is specific in that it always	68	* View factory returning highlights views. It is specific in that it always
69	* covers the whole document area by views even if there are no particular highlights	69	* covers the whole document area by views even if there are no particular highlights
70	* <br/>	70	* <br>
71	* Currently the factory coalesces highlights change requests from non-AWT thread.	71	* Currently the factory coalesces highlights change requests from non-AWT thread.
72	*	72	*
73	* @author Miloslav Metelka	73	* @author Miloslav Metelka
Lines 94-100 Link Here
94	* then the infrastructure will attempt to end current long view creation	94	* then the infrastructure will attempt to end current long view creation
95	* at a given nextOrigViewOffset parameter in order to save views creation and reuse	95	* at a given nextOrigViewOffset parameter in order to save views creation and reuse
96	* existing text layouts (and their slit text layouts for line wrapping).	96	* existing text layouts (and their slit text layouts for line wrapping).
97	* <br/>	97	* <br>
98	* The user would have to insert or remove LONG_VIEW_TOLERANCE of characters into long view	98	* The user would have to insert or remove LONG_VIEW_TOLERANCE of characters into long view
99	* in order to force the factory to not match to the given nextOrigViewOffset.	99	* in order to force the factory to not match to the given nextOrigViewOffset.
100	*/	100	*/

Lines 66-71 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/HighlightsViewUtils.java (-3 / +14 lines)
66	import javax.swing.text.Position.Bias;	66	import javax.swing.text.Position.Bias;
67	import javax.swing.text.StyleConstants;	67	import javax.swing.text.StyleConstants;
68	import javax.swing.text.View;	68	import javax.swing.text.View;
		69	import org.netbeans.api.editor.caret.CaretInfo;
		70	import org.netbeans.api.editor.caret.EditorCaret;
69	import org.netbeans.api.editor.settings.EditorStyleConstants;	71	import org.netbeans.api.editor.settings.EditorStyleConstants;
70	import org.netbeans.lib.editor.util.CharSequenceUtilities;	72	import org.netbeans.lib.editor.util.CharSequenceUtilities;
71	import org.netbeans.lib.editor.util.swing.DocumentUtilities;	73	import org.netbeans.lib.editor.util.swing.DocumentUtilities;
Lines 73-79 Link Here
73		75
74	/**	76	/**
75	* Utilities related to HighlightsView and TextLayout management.	77	* Utilities related to HighlightsView and TextLayout management.
76	* <br/>	78	* <br>
77	* Unfortunately the TextLayout based on AttributedCharacterIterator does not handle	79	* Unfortunately the TextLayout based on AttributedCharacterIterator does not handle
78	* correctly italic fonts (at least on Mac it renders background rectangle non-italicized).	80	* correctly italic fonts (at least on Mac it renders background rectangle non-italicized).
79	* Therefore child views with foreground that differs from text layout's "global" foreground	81	* Therefore child views with foreground that differs from text layout's "global" foreground
Lines 159-165 Link Here
159	return 0d;	161	return 0d;
160	}	162	}
161	Caret caret = textComponent.getCaret();	163	Caret caret = textComponent.getCaret();
162	Point magicCaretPoint = (caret != null) ? caret.getMagicCaretPosition() : null;	164	Point magicCaretPoint = null;
		165	if(caret != null) {
		166	if(caret instanceof EditorCaret) {
		167	EditorCaret editorCaret = (EditorCaret) caret;
		168	CaretInfo info = editorCaret.getCaretAt(offset);
		169	magicCaretPoint = (info != null) ? info.getMagicCaretPosition() : null;
		170	} else {
		171	magicCaretPoint = caret.getMagicCaretPosition();
		172	}
		173	}
163	double x;	174	double x;
164	if (magicCaretPoint == null) {	175	if (magicCaretPoint == null) {
165	Shape offsetBounds = view.modelToViewChecked(offset, alloc, bias);	176	Shape offsetBounds = view.modelToViewChecked(offset, alloc, bias);
Lines 528-534 Link Here
528	/**	539	/**
529	* Paint strike-through line for a font currently set to the graphics	540	* Paint strike-through line for a font currently set to the graphics
530	* with the color currently set to the graphics.	541	* with the color currently set to the graphics.
531	* <br/>	542	* <br>
532	* It's assumed that the clipping is set appropriately because the method	543	* It's assumed that the clipping is set appropriately because the method
533	* renders whole textLayoutAlloc with the strike-through.	544	* renders whole textLayoutAlloc with the strike-through.
534	*	545	*





/**
 * Locked view hierarchy as result of {@link ViewHierarchy#lock() }.
 * <br>
 * Underlying document of the view hierarchy's text component must be
 * read-locked to guarantee stability of offsets passed to methods of this class.
 * <br>
 * If editor view hierarchy is not installed into text component
 * (text component's root view is not an instance of DocumentView)
 * the methods return default values as described in their documentation.


    /**
     * Get text component that this view hierarchy is associated with.
     * <br>
     * 
     * @return non-null text component.
     */

    
    /**
     * Get y coordinate of a visual row that corresponds to given offset.
     * <br>
     * Underlying document of the view hierarchy's text component should be read-locked
     * to guarantee stability of passed offset.
     * <br>
     * If editor view hierarchy is not installed into text component this method
     * delegates to {@link JTextComponent#modelToView(int) }.
     *


    /**
     * Get height of a visual row of text.
     * <br>
     * For wrapped lines (containing multiple visual rows) this is height of a single visual row.
     * <br>
     * Current editor view hierarchy implementation uses uniform row height for all the rows.
     * 
     * @return height of a visual row.

    
    /**
     * Get width of a typical character of a default font used by view hierarchy.
     * <br>
     * In case mixed fonts (non-monospaced) are used this gives a little value
     * but certain tools such as rectangular selection may use this value.
     */

    
    /**
     * Return true if the view hierarchy is actively managing its contained views.
     * <br>
     * Infrastructure may turn the view hierarchy inactive in case there are many
     * edits performed in the document (mainly during code reformatting).
     * <br>
     * Also the view hierarchy is not active when a document modification was performed
     * but the view hierarchy did not update itself accordingly yet (its DocumentListener
     * was not called yet).

Lines 127-133 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/OffsetRegion.java (-2 / +2 lines)
127		127
128	/**	128	/**
129	* Return union of this region with the given region.	129	* Return union of this region with the given region.
130	* <br/>	130	* <br>
131	* If the given region is empty then return "this" region.	131	* If the given region is empty then return "this" region.
132	*	132	*
133	* @param doc non-null document to which the offsets relate.	133	* @param doc non-null document to which the offsets relate.
Lines 164-170 Link Here
164		164
165	/**	165	/**
166	* Return union of this region with the given region.	166	* Return union of this region with the given region.
167	* <br/>	167	* <br>
168	* If the given region is empty then return "this" region.	168	* If the given region is empty then return "this" region.
169	*	169	*
170	* @param region region to union with.	170	* @param region region to union with.




/**
 * View of a line typically spans a single textual line of a corresponding document
 * but it may span several lines if it contains a fold view for collapsed code fold.
 * <br>
 * It is capable to do a word-wrapping.
 * <br>
 * It is not tight to any element (its element is null).
 * Its contained views may span multiple lines (e.g. in case of code folding).
 * 


    /**
     * Whether children are non-null and contain up-to-date views.
     * <br>
     * If false then either children == null (children not computed yet)
     * or some (or all) child views are marked as invalid (they should be recomputed
     * since some highlight factories reported particular text span as changed).
     * <br>
     * The local offset range of invalid children can be obtained (if children != null)
     * by children.getStartInvalidChildrenLocalOffset()
     * and children.getEndInvalidChildrenLocalOffset()).
     * <br>
     * When all children are dropped (children == null) then LAYOUT_VALID is cleared too.
     */
    private static final int CHILDREN_VALID = 1;

    /**
     * Whether layout information is valid for this paragraph view
     * (note that layout may be valid even when some children were marked as invalid).
     * <br>
     * Since span of child views is initialized upon views replace
     * the layout updating means checking whether the pView is too wide
     * and thus needs to compute wrap lines and building of those wrap lines.
     * <br>
     * Whether particular operation (mainly model-to-view, view-to-model and painting operations)
     * needs an up-to-date layout is upon decision of each operation
     * (done in DocumentViewChildren).

    
    /**
     * Check whether layout must be updated.
     * <br>
     * It should only be called when children != null.
     *
     * @return true if layout update was necessary or false otherwise.

Lines 373-379 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ParagraphViewChildren.java (-1 / +1 lines)
373		373
374	/**	374	/**
375	* Layout pView's children according to line wrap setting.	375	* Layout pView's children according to line wrap setting.
376	* <br/>	376	* <br>
377	* This method should ONLY be called by pView which then re-checks children size	377	* This method should ONLY be called by pView which then re-checks children size
378	* and possibly updates itself appropriately.	378	* and possibly updates itself appropriately.
379	*/	379	*/




    
    /**
     * Get start offset of the paragraph view represented by this descriptor.
     * <br>
     * When a LockedViewHierarchy that provided this paragraph view descriptor
     * is unlocked then operation of this method is undefined.
     *


    /**
     * Get textual length of the paragraph view represented by this descriptor.
     * <br>
     * When a LockedViewHierarchy that provided this paragraph view descriptor
     * is unlocked then operation of this method is undefined.
     *

    
    /**
     * Get visual allocation of the whole paragraph view (represented by this descriptor).
     * <br>
     * When a LockedViewHierarchy that provided this paragraph view descriptor
     * is unlocked then operation of this method is undefined.
     *

    /**
     * Get ascent (useful for text rendering using a particular font)
     * of the paragraph view represented by this descriptor.
     * <br>
     * This method is useful when a tool (such as a side bar performing rendering of a line
     * number) wants to render a text that should vertically match the text
     * rendered by the paragraph view.
     * <br>
     * When a LockedViewHierarchy that provided this paragraph view descriptor
     * is unlocked then operation of this method is undefined.
     *





/**
 * View of (possibly multiple) '\t' characters.
 * <br>
 * It needs to be measured specially - it needs to get visually aligned to multiples
 * of TAB_SIZE char width.
 * <br>
 * Note that the view does not hold a last tab expander itself by itself so if tab expander
 * changes the view does not call a preference change.
 * <br>
 * Due to line wrap the view cannot base its tab-stop calculations upon alloc.getX().
 *
 *

Lines 45-51 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/TextLayoutBreakInfo.java (-1 / +1 lines)
45		45
46	/**	46	/**
47	* Info about last successful breaking of the view.	47	* Info about last successful breaking of the view.
48	* <br/>	48	* <br>
49	* Since TextLayout creation is expensive this should speed up breaking of the views	49	* Since TextLayout creation is expensive this should speed up breaking of the views
50	* (used in line wrap) considerably.	50	* (used in line wrap) considerably.
51	*	51	*

Lines 54-60 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/TextLayoutCache.java (-1 / +1 lines)
54	/**	54	/**
55	* Cache containing paragraph-view references of lines where text layouts	55	* Cache containing paragraph-view references of lines where text layouts
56	* are actively held or where children are actively maintained.	56	* are actively held or where children are actively maintained.
57	* <br/>	57	* <br>
58	* This class is not multi-thread safe.	58	* This class is not multi-thread safe.
59	*	59	*
60	* @author Miloslav Metelka	60	* @author Miloslav Metelka

Lines 136-142 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/TextLayoutUtils.java (-1 / +1 lines)
136		136
137	/**	137	/**
138	* Get real allocation (possibly not rectangular) of a part of layout.	138	* Get real allocation (possibly not rectangular) of a part of layout.
139	* <br/>	139	* <br>
140	* It's used when rendering the text layout for filling background highlights of the view.	140	* It's used when rendering the text layout for filling background highlights of the view.
141	*	141	*
142	* @param length Total number of characters for which the allocation is computed.	142	* @param length Total number of characters for which the allocation is computed.




    
    /**
     * Start offset of a before-modOffset local view that may be reused.
     * <br>
     * If set to Integer.MAX_VALUE then no more before-modOffset reusing possible
     * or bmReusePView has no children.
     */

    /**
     * Start offset of an above-modOffset local view that may be reused
     * (or if no local views exist inside 
     * <br>
     * If set to Integer.MAX_VALUE then no more before-modOffset reusing possible
     * or bmReusePView has no children.
     */


    /**
     * Actual local views replace inside currently served paragraph view.
     * <br>
     * It may be equal to firstReplace when replacing inside firstly updated paragraph view.
     */
    private ViewReplace<ParagraphView,EditorView> localReplace;





/**
 * Class that manages children of either DocumentView or ParagraphView.
 * <br>
 * For document view the class manages visual spans (end visual offsets).
 * For paragraphs the class manages end offsets of children as well as their end visual offsets.
 * <br>
 * Generally children of {@link #ParagraphView} manage their raw end offsets
 * while children of {@link #DocumentView} do not manage them (they use Position objects
 * to manage its start).

    /**
     * Get view index of first view that "contains" the given offset (starts with it or it's inside)
     * by examining child views' raw end offsets.
     * <br>
     * This is suitable for paragraph view which manages its views' raw end offsets.
     * 
     * @param offset offset to search for.

Lines 69-75 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ViewGapStorage.java (-2 / +2 lines)
69		69
70	/**	70	/**
71	* Start of the visual gap in child views along their major axis.	71	* Start of the visual gap in child views along their major axis.
72	* <br/>	72	* <br>
73	* Place it above end of all views initially.	73	* Place it above end of all views initially.
74	*/	74	*/
75	double visualGapStart; // 8-super + 8 = 16 bytes	75	double visualGapStart; // 8-super + 8 = 16 bytes
Lines 86-92 Link Here
86	/**	86	/**
87	* Start of the offset gap used for managing end offsets of HighlightsView views.	87	* Start of the offset gap used for managing end offsets of HighlightsView views.
88	* It is not used for paragraph views.	88	* It is not used for paragraph views.
89	* <br/>	89	* <br>
90	* Place it above end of all views initially.	90	* Place it above end of all views initially.
91	*/	91	*/
92	int offsetGapStart; // 28 + 4 = 32 bytes	92	int offsetGapStart; // 28 + 4 = 32 bytes





/**
 * View hierarchy associated with a particular text component (for its whole lifetime).
 * <br>
 * View hierarchy needs to be locked before doing most operations - see {@link #lock() }.
 * <br>
 * If editor view hierarchy is currently not installed into particular text component
 * (text component's root view is not an instance of DocumentView)
 * the methods (in LockedViewHierarchy) return default values as described in their documentation.

    
    /**
     * Get text component that this view hierarchy is associated with.
     * <br>
     * 
     * @return non-null text component.
     */

    
    /**
     * Lock view hierarchy in order to perform operations described in {@link LockedViewHierarchy }.
     * <br>
     * Underlying document of the view hierarchy's text component must be read-locked
     * to guarantee stability of offsets passed to methods of LockedViewHierarchy.
     * <br>
     * Code example:<code>
     * // Possible textComponent.getDocument() read-locking
     * LockedViewHierarchy lvh = ViewHierarchy.get(textComponent).lock();

    
    /**
     * Add listener for view hierarchy changes.
     * <br>
     * Listener will be notified on a locked view hierarchy.
     *
     * @param l non-null listener.





/**
 * View hierarchy event describing view rebuilding or view re-measurement change in view hierarchy.
 * <br>
 * Change may be related to several events:<ul>
 * <li> Document modification produces immediate updates to view hierarchy.
 * </li>

 * {@link #changeEndOffset()}) and whether the change produces any changes for y-coordinate related
 * components (such as error stripe and various side bars). Note that y-coordinate related clients
 * may completely ignore the change start/end offsets and only take care of y-related change information.
 * <br>
 * If change produces y-coordinate changes the changed visual area corresponds to
 * &lt;{@link #startY()},{@link #endY()}&gt;.
 * <br>
 * The change may cause rest of the document to move visually down/up which is reflected in {@link #deltaY()}
 * giving amount of pixels the area starting at {@link #endY()} moves down (negative value means moving up).
 * </p>

 * <p>
 * Note that when this event is notified the listeners must make no direct queries to view hierarchy.
 * They should only mark what has changed and needs to be recomputed and ask later.
 * <br>
 * View hierarchy events are fired rather frequently so the code in listeners should be efficient.
 * </p>
 * 

    
    /**
     * Start offset of a visual change in view hierarchy.
     * <br>
     * All model-to-view translations between {@link #changeStartOffset()} till {@link #changeEndOffset()}
     * might shift or change. They could change in x-coordinate and possibly also in y-coordinate in case
     * they lay between {@link #startY()} and {@link #endY()}. Those below {@link #endY()} have y-coordinate
     * shifted down by {@link #deltaY()} (may be negative for shifting up).
     * <br>
     * Offset corresponds to a state after possible document modification
     * (returned by {@link #documentEvent()}.
     *

    
    /**
     * End offset of a visual change in view hierarchy.
     * <br>
     * All model-to-view translations between {@link #changeStartOffset()} till {@link #changeEndOffset()}
     * might shift or change. They could change in x-coordinate and possibly also in y-coordinate in case
     * they lay between {@link #startY()} and {@link #endY()}. Those below {@link #endY()} have y-coordinate
     * shifted down by {@link #deltaY()} (may be negative for shifting up).
     * <br>
     * Offset corresponds to a state after possible document modification
     * (returned by {@link #documentEvent()}.
     *


    /**
     * Whether this change affects y-coordinate clients or not.
     * <br>
     * Return true if there was at least one paragraph view which changed its visual height.
     * Such views are be included inside {@link #startY()} and {@link #endY()} interval
     * and a corresponding {@link #deltaY()} is provided.
     * <br>
     * If the paragraph views retain their original offset boundaries upon rebuild
     * (and their precise span is not computed) they are not reported
     * as being y-changed.


    /**
     * Where the y-coordinate change begins.
     * <br>
     * Previously computed model-to-view values that have their y-coordinate
     * within {@link #startY()} and {@link #endY()} interval may be affected.
     * <br>
     * Measurements below {@link #endY()} should shift
     * its y-coordinate down by {@link #deltaY()} (may be negative for shifting up).
     *

    
    /**
     * Where the y-coordinate change ends.
     * <br>
     * Previously computed model-to-view values that have their y-coordinate
     * within {@link #startY()} and {@link #endY()} interval may be affected.
     * <br>
     * Measurements below {@link #endY()} should shift
     * its y-coordinate down by {@link #deltaY()} (may be negative for shifting up).
     *


    /**
     * Shift of area starting at {@link #endY()} down (or up if negative).
     * <br>
     * Measurements below {@link #endY()} should shift
     * its y-coordinate down by {@link #deltaY()} (may be negative for shifting up).
     *




    
    /**
     * Logger for core operations of the view hierarchy - resolving modelToView() and viewToModel() etc.
     * <br>
     * FINE logs basic info about view hierarchy operations performed.
     * <br>
     * FINER also reports query during document's modification (when the view hierarchy cannot respond
     *  appropriately to queries since it would give incorrect results).
     */

    /**
     * Logger tracking all view factory changes that cause either rebuild of the views
     * or offset repaints.
     * <br>
     * FINE reports which factory reported a change and an offset range of that change.
     * <br>
     * FINER reports additional detailed information about the change.
     * <br>
     * FINEST reports stacktrace where a particular span change request originated.
     */
    static final Logger CHANGE_LOG = Logger.getLogger("org.netbeans.editor.view.change"); // -J-Dorg.netbeans.editor.view.change.level=FINE

    
    /**
     * Logger for span change requests on the views and underlying text component.
     * <br>
     * FINE reports span change descriptions
     * <br>
     * FINEST reports stacktrace where a particular span change request originated.
     */
    static final Logger SPAN_LOG = Logger.getLogger("org.netbeans.editor.view.span"); // -J-Dorg.netbeans.editor.view.span.level=FINE
    
    /**
     * Logger for repaint requests of the underlying text component.
     * <br>
     * FINE reports repaint request's coordinates
     * <br>
     * FINEST reports stacktrace where a particular repaint request originated.
     */
    static final Logger REPAINT_LOG = Logger.getLogger("org.netbeans.editor.view.repaint"); // -J-Dorg.netbeans.editor.view.repaint.level=FINE
    
    /**
     * Logger for extra consistency checks inside view hierarchy (may slow down processing).
     * <br>
     */
    static final Logger CHECK_LOG = Logger.getLogger("org.netbeans.editor.view.check"); // -J-Dorg.netbeans.editor.view.check.level=FINE
    
    /**
     * Logger related to any settings being used in view hierarchy.
     * <br>
     */
    static final Logger SETTINGS_LOG = Logger.getLogger("org.netbeans.editor.view.settings"); // -J-Dorg.netbeans.editor.view.settings.level=FINE
    
    /**
     * Logger related to view hierarchy events generation.
     * <br>
     */
    static final Logger EVENT_LOG = Logger.getLogger("org.netbeans.editor.view.event"); // -J-Dorg.netbeans.editor.view.event.level=FINE
    
    /**
     * Logger for tracking view hierarchy locking.
     * <br>
     * FINER stores the stack of the lock thread of view hierarchy in lockStack variable
     * (it should help to find missing unlock).
     * <br>
     * FINEST in addition it dumps thread dump of each locker of a view hierarchy. 
     */
    // -J-Dorg.netbeans.modules.editor.lib2.view.ViewHierarchyImpl.level=FINER





    /**
     * Notification about visual change that occurred in view hierarchy.
     * <br>
     * Notification may come in response to document modification but also in response
     * to a model&lt;-&gt;view query to view hierarchy (due to fact that view hierarchy is computed lazily).
     * <br>
     * Notification may come from any thread.
     * <br>
     * When this event is notified the listeners must make no
     * queries to view hierarchy synchronously (they should only mark what has changed and
     * ask later).





/**
 * Special highlights sequence used for painting of individual views.
 * <br>
 * It merges together highlights contained in views (as attributes) together
 * with extra painting highlights (from highlighting layers that do not change metrics).
 * <br>
 * It "covers" even non-highlighted areas by returning null from {@link #getAttributes()}.
 * <br>
 * The instance can only be used by a single thread.
 *
 * @author mmetelka





/**
 * Additional info related to view rendering.
 * <br>
 * Provided by {@link EditorView.Parent }.
 *
 * @author Miloslav Metelka


    /**
     * Get special highlighting sequence that is a merge of attributes of the
     * view with top painting highlights. <br> It's only allowed to call this
     * method (and use the returned value) during view's paint() methods
     * execution otherwise it throws an IllegalStateException.
     *


    /**
     * Get row height of an single row of views being rendered by a paragraph view.
     * <br>
     * For views that only render text the views should return this height
     * as their vertical span since the user may forcibly decrease row height
     * (see DocumentViewOp.rowHeightCorrection).

    /**
     * Get font for text rendering that incorporates a possible text zoom
     * (Alt+MouseWheel function).
     * <br>
     * Ideally all the fonts rendered by views should be "translated" by this method.
     */
    public Font getRenderFont(Font font) {

Lines 59-65 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/WrapInfo.java (-1 / +1 lines)
59		59
60	/**	60	/**
61	* Information about line wrapping that may be attached to {@link ParagraphViewChildren}.	61	* Information about line wrapping that may be attached to {@link ParagraphViewChildren}.
62	* <br/>	62	* <br>
63	* Wrapping uses constant wrap line height - children height from {@link ParagraphViewChildren}.	63	* Wrapping uses constant wrap line height - children height from {@link ParagraphViewChildren}.
64	*	64	*
65	* @author Miloslav Metelka	65	* @author Miloslav Metelka

Lines 68-74 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/WrapLine.java (-2 / +2 lines)
68		68
69	/**	69	/**
70	* Index of a first view located at this line.	70	* Index of a first view located at this line.
71	* <br/>	71	* <br>
72	* Logically if there's a non-null startPart then it comes from view	72	* Logically if there's a non-null startPart then it comes from view
73	* at (firstViewIndex - 1).	73	* at (firstViewIndex - 1).
74	*/	74	*/
Lines 76-82 Link Here
76		76
77	/**	77	/**
78	* Index that follows last view located at this line.	78	* Index that follows last view located at this line.
79	* <br/>	79	* <br>
80	* It should be >= firstViewIndex.	80	* It should be >= firstViewIndex.
81	*/	81	*/
82	int endViewIndex;	82	int endViewIndex;




/**
 * Base class for editor actions that should be used together with
 * {@link EditorActionRegistration} annotation.
 * <br>
 * It may be constructed and used in two ways: direct construction or construction
 * upon invocation by a wrapper action:
 * <ul>
 *   <li> Direct construction - action is created directly when an editor kit
 *        gets constructed (its <code>kit.getActions()</code> gets used).
 *        <br>
 *        Advantages: Action controls all its behavior and properties (including enabled status)
 *        since the begining.
 *        <br>
 *        Disadvantages: Action's class is loaded by classloader at editor kit's construction.
 *        <br>
 *        Example of registration:
 *        <br>
 * <code>
 * public static final class MyAction extends AbstractEditorAction {<br>
 *<br>
 *     &#64;EditorActionRegistration(name = "my-action")<br>
 *     public static MyAction create(Map&lt;String,?&gt; attrs) {<br>
 *         return new MyAction(attrs);<br>
 *     }<br>
 * <br>
 *     private MyAction(Map&lt;String,?&gt; attrs) {<br>
 *         super(attrs);<br>
 *         ...<br>
 *     }<br>
 * <br>
 *     protected void actionPerformed(ActionEvent evt, JTextComponent component) {<br>
 *         ...<br>
 *     }<br>
 * <br>
 * }<br>
 * </code>
 *   </li>
 * 

 *        (upon {@link Action#actionPerformed(java.awt.event.ActionEvent)} call).
 *        Existing properties of the wrapper action (including <code>Action.NAME</code> property)
 *        get transferred into delegate action.
 *        <br>
 *        Advantages: Action's class is only loaded upon action's execution.
 *        <br>
 *        Disadvantages: Only a limited set of action's properties gets populated
 *        (those defined by {@link EditorActionRegistration}).
 *        <br>
 *        Example of registration:
 *        <br>
 * <code>
 * &#64;EditorActionRegistration(name = "my-action")<br>
 * public static final class MyAction extends AbstractEditorAction {<br>
 *<br>
 *     public MyAction() {<br>
 *         // Here the properties are not yet set.<br>
 *     }<br>
 * <br>
 *     &#64;Override<br>
 *     protected void valuesUpdated() {<br>
 *         // Here the wrapper action has transferred all its properties into this action<br>
 *         // so properties like Action.NAME etc. are now populated.<br>
 *     }<br>
 * <br>
 *     protected void actionPerformed(ActionEvent evt, JTextComponent component) {<br>
 *         ...<br>
 *     }<br>
 * <br>
 * }<br>
 * </code>
 *   </li>
 * </ul>

    
    /**
     * Key of {@link String} property containing a localized display name of the action.
     * <br>
     * It may be passed to {@link #getValue(java.lang.String) } to obtain the property value.
     */
    public static final String DISPLAY_NAME_KEY = "displayName"; // (named in sync with AlwaysEnabledAction) NOI18N

    /**
     * Key of {@link String} property containing a localized text to be displayed in a main menu for this action.
     * <br>
     * It may be passed to {@link #getValue(java.lang.String) } to obtain the property value.
     */
    public static final String MENU_TEXT_KEY = "menuText"; // (named in sync with AlwaysEnabledAction) NOI18N

    /**
     * Key of {@link String} property containing a localized text to be displayed in a popup menu for this action.
     * <br>
     * If this property is not set then {@link #MENU_TEXT_KEY} is attempted.
     * <br>
     * It may be passed to {@link #getValue(java.lang.String) } to obtain the property value.
     */
    public static final String POPUP_TEXT_KEY = "popupText"; // (named in sync with AlwaysEnabledAction) NOI18N

    /**
     * Key of {@link Boolean} property which determines whether icon of this action should be
     * displayed in menu (false or unset) or not (true).
     * <br>
     * It may be passed to {@link #getValue(java.lang.String) } to obtain the property value.
     * @since 1.74
     */

    /**
     * Key of {@link Boolean} property which determines if this action should be
     * displayed in key binding customizer (false or unset) or not (true).
     * <br>
     * It may be passed to {@link #getValue(java.lang.String) } to obtain the property value.
     * @since 1.74
     */

    /**
     * Key of property containing a <code>List &lt; List &lt; {@link KeyStroke} &gt; &gt;</code>
     * listing all multi-key bindings by which the action may be invoked.
     * <br>
     * There may be multiple multi-key bindings to invoke a single action e.g. a code completion
     * may be invoked by Ctrl+SPACE and also Ctrl+'\'
     * (in fact each of these bindings could also consist of multiple keystrokes).

    /**
     * Key of {@link String} property containing a mime type for which this action
     * is registered.
     * <br>
     * Note: action's mime-type is not necessarily the same like <code>EditorKit.getContentType()</code>
     * for which the action was created because the kit may inherit some actions
     * from a global mime-type "".
     * <br>
     * Value of this property is checked at action's initialization
     * (it needs to be passed as part of 'attrs' parameter to constructor).
     * Subsequent modifications of this property should be avoided and they will likely not affect its behavior.

    /**
     * Key of {@link String} property containing a name of a boolean key in preferences in which this action changes settings
     * (according to {@link #PREFERENCES_NODE_KEY} property).
     * <br>
     * Once this property is set then it's expected that {@link #PREFERENCES_NODE_KEY} is also set
     * to a valid value and checkbox menu presenter will be used automatically.
     */

     * Key of {@link Boolean} property determining whether this is just a wrapper action
     * that is being used until the action needs to be executed. Then the target action
     * gets created and run.
     * <br>
     * Value of this property is checked at action's initialization
     * (it needs to be passed as part of 'attrs' parameter to constructor).
     * Subsequent modifications of this property should be avoided and they will likely not affect its behavior.

     * Constructor that takes a map of attributes that are typically obtained
     * from an xml layer when an action's creation method is annotated with
     * <code>@EditorActionRegistration</code>.
     * <br>
     * Example:
     * <br>
     * <code>
     * public static final class MyAction extends AbstractEditorAction {<br>
     *<br>
     *     &#64;EditorActionRegistration(name = "my-action")<br>
     *     public static MyAction create(Map&lt;String,?&gt; attrs) {<br>
     *         return new MyAction(attrs);<br>
     *     }<br>
     * <br>
     *     private MyAction(Map&lt;String,?&gt; attrs) {<br>
     *         super(attrs);<br>
     *         ...<br>
     *     }<br>
     * <br>
     *     protected void actionPerformed(ActionEvent evt, JTextComponent component) {<br>
     *         ...<br>
     *     }<br>
     * <br>
     * }<br>
     * </code>
     *
     * @param attrs non-null attributes that hold action's properties.

     * Constructor typically used when action is constructed lazily
     * upon its performing (the action is always enabled and its properties
     * are declared in xml layer by annotation processor for <code>@EditorActionRegistration</code>).
     * <br>
     * Example:
     * <br>
     * <code>
     * &#64;EditorActionRegistration(name = "my-action")<br>
     * public static final class MyAction extends AbstractEditorAction {<br>
     *<br>
     *     public MyAction() {<br>
     *         // Here the properties are not yet set.<br>
     *     }<br>
     * <br>
     *     &#64;Override<br>
     *     protected void valuesUpdated() {<br>
     *         // Here the wrapper action has transferred all its properties into this action<br>
     *         // so properties like Action.NAME etc. are now populated.<br>
     *     }<br>
     * <br>
     *     protected void actionPerformed(ActionEvent evt, JTextComponent component) {<br>
     *         ...<br>
     *     }<br>
     * <br>
     * }<br>
     * </code>
     */
    protected AbstractEditorAction() {


    /**
     * Reset caret's magic position.
     * <br>
     * Magic caret position is useful when going through empty lines with Down/Up arrow
     * then the caret returns on original horizontal column when a particular line has sufficient
     * number of characters.


    /**
     * Get presenter of this action in main menu.
     * <br>
     * Default implementation uses {@link #MENU_TEXT_KEY} for menu item's text
     * and the presenter is placed in the menu according to rules
     * given in the corresponding {@link EditorActionRegistration}.
     * <br>
     * Moreover the default presenter is sensitive to currently active text component
     * and if the active editor kit has that action redefined it uses the active action's
     * properties for this presenter.


    /**
     * Get presenter of this action in popup menu.
     * <br>
     * Default implementation uses {@link #POPUP_TEXT_KEY} for popup menu item's text
     * and the presenter is placed in the popup menu according to rules
     * given in the corresponding {@link EditorActionRegistration}.

    /**
     * This method is called when a value for the given property
     * was not yet populated.
     * <br>
     * This method is only called once for the given property. Even if this method
     * returns null for the given property the infrastructure remembers the
     * returned value and no longer queries this method (the property can still
     * be modified by {@link #putValue(java.lang.String, java.lang.Object) }.)
     * <br>
     * Calling of this method and remembering of the returned value does not trigger
     * {@link #firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object) }.
     *




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.spi.editor.caret;

import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.editor.caret.CaretMoveContext;

/**
 * Handle possible moving of individual carets to new positions or change their selections.
 *
 * @author Miloslav Metelka
 * @since 2.6
 */
public interface CaretMoveHandler {
    
    /**
     * Possibly move one or more carets to new position or change their selections
     * by using methods in the given context.
     * <br>
     * The method will be called with a document lock acquired.
     * <br>
     * The method is allowed to make document mutations in case the caller
     * of {@link org.netbeans.api.editor.caret.EditorCaret#moveCarets(CaretMoveHandler) }
     * acquired document write-lock.
     * <br>
     * To prevent deadlocks the method should not acquire any additional locks.
     * <br>
     * The method is not allowed to call methods of EditorCaret that mutate its state
     * and do nested calls to <code>EditorCaret.moveCarets()</code>.
     *
     * @param context non-null context containing the manipulation methods.
     */
    void moveCarets(@NonNull CaretMoveContext context);
    
}




<!DOCTYPE html>
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 2016 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 2016 Sun Microsystems, Inc.
-->
<html>
  <head>
    <title>org.netbeans.spi.editor.caret</title>
  </head>
  <body>

  <p>
  The Editor Caret SPI contains interface(s) to be implemented by clients
  in order to manipulate the editor carets.
  </p>
  
  <h3>Key parts of the SPI</h3>
  
  <p>
  <code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/caret/CaretMoveHandler.html">CaretMoveHandler</a></code>
  allows to implement a transaction that will move individual carets or change their selections.
  <br>
  The following code shows how all carets are moved to the
  end of the word they are currently on.  
  </p>
  <pre>
  <code>
    editorCaret.moveCarets((CaretMoveContext context) -> {
        for (CaretInfo ci : context.getOriginalCarets()) {
            Position pos = target.getDocument().createPosition(Utilities.getWordEnd(target, ci.getDot()));
            context.setDot(ci, pos);
        }
    });
  </code>
  </pre>

  <h3><a name="compatibilty">Backwards compatibility</a></h3>
  
  <h3><a name="usecases">Use cases</a></h3>
  <p>
  Use cases are shown in javadoc documentation of particular methods.
  </p>
  
  </body>
</html>

Lines 73-79 Link Here

(-)a/editor.lib2/src/org/netbeans/spi/editor/codegen/CodeGenerator.java (-1 / +1 lines)
73	public void invoke();	73	public void invoke();
74		74
75	/**	75	/**
76	* Factory creating code generators.<br/> The factory instances are looked up	76	* Factory creating code generators.<br> The factory instances are looked up
77	* by the {@link org.netbeans.api.editor.mimelookup.MimeLookup} so they	77	* by the {@link org.netbeans.api.editor.mimelookup.MimeLookup} so they
78	* should be registered in an xml-layer in	78	* should be registered in an xml-layer in
79	* <i>Editors/<mime-type>/CodeGenerators</i> directory.	79	* <i>Editors/<mime-type>/CodeGenerators</i> directory.

Lines 48-54 Link Here

(-)a/editor.lib2/src/org/netbeans/spi/editor/codegen/CodeGeneratorContextProvider.java (-1 / +1 lines)
48	/**	48	/**
49	* Serves for adding an additonal content to the context which is passed	49	* Serves for adding an additonal content to the context which is passed
50	* as a parameter to the {@link CodeGenerator.Factory#create(org.openide.util.Lookup)}	50	* as a parameter to the {@link CodeGenerator.Factory#create(org.openide.util.Lookup)}
51	* method.<br/> Instances of this interface are looked up by the	51	* method.<br> Instances of this interface are looked up by the
52	* {@link org.netbeans.api.editor.mimelookup.MimeLookup} so they should be	52	* {@link org.netbeans.api.editor.mimelookup.MimeLookup} so they should be
53	* registered in an xml-layer in	53	* registered in an xml-layer in
54	* <i>Editors/<mime-type>/CodeGeneratorContextProviders</i> directory.	54	* <i>Editors/<mime-type>/CodeGeneratorContextProviders</i> directory.




     * Perform the given runnable under a lock specific for this task.
     * The runnable will include a call to {@link #performTask() } but it may
     * also call other tasks if there are multiple ones.
     * <br>
     * For multiple task factories registered their {@link #runLocked(java.lang.Runnable) }
     * methods will be called subsequently (according to their registration order) in a nested way.
     *


    /**
     * Factory for creation of on-save task.
     * It should be registered in MimeLookup by using mime registration e.g.<br>
     * <code>@MimeRegistration(mimeType="", service=OnSaveTask.Factory.class, position=300)</code><br>
     * Optional 'position' parameter may be used to force an order of tasks.
     * Currently there are two default global factories:
     * <ul>


        /**
         * Task may add a custom undoable edit related to its operation by using this method.
         * <br>
         * When undo would be performed after the save then this edit would be undone
         * (together with any possible modification changes performed by the task on the underlying document).
         * <br>
         * Note: this method should only be called during {@link OnSaveTask#performTask() }.
         * 
         * @param edit a custom undoable edit provided by the task.

        /**
         * Get a root element with zero or more child elements each designating a modified region
         * of a document.
         * <br>
         * Tasks may use this information to work on modified document parts only.
         * <br>
         * Note: unlike in some other root element implementations here the child elements
         * do not fully cover the root element's offset space.
         *




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.spi.editor.highlighting;

/**
 * Highlights sequence that supports shifts in addition to regular offsets.
 * This allows to color individual spaces within a tab character
 * or to color extra virtual characters beyond a newline character.
 *
 * @author Miloslav Metelka
 * @since 2.5.0
 */
public interface ShiftHighlightsSequence extends HighlightsSequence {

    /**
     * Get extra shift "within" a particular character (either tab or newline)
     * while {@link #getStartOffset()} points to the tab or newline character.
     * <br>
     * To highlight second and third space of a tab character at offset == 123
     * the {@link #getStartOffset() } == {@link #getEndOffset() } == 123
     * and {@link #getStartShift() } == 1 and {@link #getEndShift() } == 3.
     *
     * @return &gt;=0 start shift.
     * @see #getStartOffset() 
     */
    int getStartShift();
    
    /**
     * Get end shift of a highlight "within" a particular character (either tab or newline)
     * while {@link #getEndOffset()} points to the tab or newline character.
     *
     * @return &gt;=0 end shift.
     * @see #getStartShift() 
     */
    int getEndShift();

}

Lines 97-103 Link Here

(-)a/editor.lib2/src/org/netbeans/spi/editor/typinghooks/TypedBreakInterceptor.java (-1 / +1 lines)
97	* additional rules (eg. correctly replacing selected text, handling insert vs override	97	* additional rules (eg. correctly replacing selected text, handling insert vs override
98	* modes of the caret, etc). The first interceptor that modifies the insertion text	98	* modes of the caret, etc). The first interceptor that modifies the insertion text
99	* will win and no other interceptor's <code>insert</code> method will be called.	99	* will win and no other interceptor's <code>insert</code> method will be called.
100	* <br/>	100	* <br>
101	* The interceptors are allowed to insert more than just a line break, but the text	101	* The interceptors are allowed to insert more than just a line break, but the text
102	* they insert has to contain at least one line break. They can also request the	102	* they insert has to contain at least one line break. They can also request the
103	* inserted text to be reindented. Please see {@link MutableContext#setText(java.lang.String, int, int, int...)}	103	* inserted text to be reindented. Please see {@link MutableContext#setText(java.lang.String, int, int, int...)}




    @Test
    public void testRandomMerges() throws Exception {
        RandomTestContainer container = HighlightsMergeTesting.createContainer();
        container.setName("testRandomMerges");
        RandomTestContainer.Round round = HighlightsMergeTesting.addRound(container);
        round.setOpCount(100);
//        container.setLogOp(true);
//        HighlightsMergeTesting.setLogChecks(true);
        container.runInit(1303832573413L);
        container.runOps(1);
        container.runOps(1);
        container.runOps(0); // Run till end

//        container.run(0L);
    }

}





    private static final int DOCUMENT_LENGTH = 1000; // Fixed document length
    private static final int MAX_LAYER_HIGHLIGHT_COUNT = 20;
    
    private static boolean logChecks;
    
    public static void setLogChecks(boolean logChecks) {
        HighlightsMergeTesting.logChecks = logChecks;
    }

    public static RandomTestContainer createContainer() {
        RandomTestContainer container = new RandomTestContainer();

            Highlight highlight = new Highlight(offset0, offset1, (AttributeSet)highlights[i+2]);
            highlightList.add(highlight);
        }
        // Possibly do logging
        if (context.isLogOp()) {
            StringBuilder sb = context.logOpBuilder();
            sb.append(" ADD_LAYER(").append(zIndex).append("): ");
            sb.append('\n');
            int digitCount = ArrayUtilities.digitCount(highlightList.size());
            for (int i = 0; i < highlightList.size(); i++) {
                Highlight hi = highlightList.get(i);
                ArrayUtilities.appendBracketedIndex(sb, i, digitCount);
                sb.append(hi);
                sb.append('\n');
            }
            context.logOp(sb);
        }
        
        HighlightsContainer[] layers = compoundHighlightsContainer.getLayers();
        HighlightsContainer[] newLayers = new HighlightsContainer[layers.length + 1];
        zIndex = Math.min(zIndex, layers.length);

            highlight.addTo(bag);
        }
        newLayers[zIndex] = bag;
        
        // Possibly do logging
        if (context.isLogOp()) {
            StringBuilder sb = context.logOpBuilder();
            sb.append(" ADD_LAYER(").append(zIndex).append("): ");
            sb.append('\n');
            int digitCount = ArrayUtilities.digitCount(highlightList.size());
            for (int i = 0; i < highlightList.size(); i++) {
                Highlight hi = highlightList.get(i);
                sb.append("Parameter highlight");
                ArrayUtilities.appendBracketedIndex(sb, i, digitCount);
                sb.append(hi);
                sb.append('\n');
            }
            HighlightsSequence hs = bag.getHighlights(0, Integer.MAX_VALUE);
            int i = 0;
            while (hs.moveNext()) {
                int startOffset = hs.getStartOffset();
                int endOffset = hs.getEndOffset();
                AttributeSet attrs = hs.getAttributes();
                sb.append("Bag highlight");
                ArrayUtilities.appendBracketedIndex(sb, i, digitCount); // May be actually more/less digits due to splitting/merging
                sb.append(new Highlight(startOffset, endOffset, attrs));
                sb.append('\n');
            }
            context.logOp(sb);
        }
        compoundHighlightsContainer.setLayers(doc, newLayers);
        DirectMergeContainer directMergeContainer = directMergeContainer(context);
        directMergeContainer = new DirectMergeContainer(newLayers);

        int startOffset = 0;
        int endOffset = 0;
        AttributeSet attrs = null;
        int i = 0;
        while (expectedSeq.moveNext()) {
            startOffset = expectedSeq.getStartOffset();
            endOffset = expectedSeq.getEndOffset();

            assert (attrs.equals(testAttrs)) : "attrs=" + attrs + " != testAttrs=" + testAttrs
                    + ", startOffset=" + startOffset + ", endOffset=" + endOffset + " seq: " + testSeq;
            if (logChecks) {
                StringBuilder sb = context.logOpBuilder();
                sb.append("DMContainer passed highlight");
                ArrayUtilities.appendBracketedIndex(sb, i, 1); // Unknown digit count
                sb.append(new Highlight(startOffset, endOffset, attrs));
                sb.append('\n');
                context.logOp(sb);
            }
            i++;
        }
    }



        @Override
        protected void check(Context context) throws Exception {
            checkMerge(context, HighlightsMergeTesting.logChecks);
        }
        
    }




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.ui</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.3</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                        <specification-version>8.12</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.ui</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>9.3</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <test-dependencies>
                <test-type>

Lines 6-13 Link Here

(-)a/editor.search/src/org/netbeans/modules/editor/search/Bundle.properties (+2 lines)
6	TOOLTIP_CloseIncrementalSearchSidebar=Close Incremental Search Sidebar (Esc)	6	TOOLTIP_CloseIncrementalSearchSidebar=Close Incremental Search Sidebar (Esc)
7	CTL_Find=&Find:	7	CTL_Find=&Find:
8	TOOLTIP_IncrementalSearchText=Search Text (ENTER - Find Next, Shift+ENTER - Find Previous)	8	TOOLTIP_IncrementalSearchText=Search Text (ENTER - Find Next, Shift+ENTER - Find Previous)
		9	TOOLTIP_SelectAllText=Place a selection around all occurrences in the editor
9	TOOLTIP_ReplaceText=Replace Text (ENTER - Replace, Shift+ENTER - Replace All)	10	TOOLTIP_ReplaceText=Replace Text (ENTER - Replace, Shift+ENTER - Replace All)
10	CTL_FindNext=Next	11	CTL_FindNext=Next
		12	CTL_SelectAll=Select
11	CTL_FindPrevious=Previous	13	CTL_FindPrevious=Previous
12	TT_MatchCase=Match case (Alt + C)	14	TT_MatchCase=Match case (Alt + C)
13	TT_WholeWords=Whole word (Alt + O)	15	TT_WholeWords=Whole word (Alt + O)




import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.editor.NavigationHistory;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.modules.editor.lib2.ComponentUtils;
import org.netbeans.modules.editor.lib2.DocUtils;
import org.netbeans.modules.editor.lib2.highlighting.BlockHighlighting;
import org.netbeans.modules.editor.lib2.highlighting.Factory;
import org.netbeans.modules.editor.search.DocumentFinder.FindReplaceResult;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

/**

    public static final String FIND_BLOCK_SEARCH = "find-block-search"; //NOI18N
    public static final String FIND_BLOCK_SEARCH_START = "find-block-search-start"; //NOI18N
    public static final String FIND_BLOCK_SEARCH_END = "find-block-search-end"; //NOI18N
    public static final String ADD_MULTICARET = "add-multi-caret"; //NOI18N

    private static final String FOUND_LOCALE = "find-found"; // NOI18N
    private static final String NOT_FOUND_LOCALE = "find-not-found"; // NOI18N

        props.put(FIND_REG_EXP, Boolean.FALSE);
        props.put(FIND_HISTORY, Integer.valueOf(30));
        props.put(FIND_PRESERVE_CASE, Boolean.FALSE);
        props.put(ADD_MULTICARET, Boolean.FALSE);

        return props;
    }

        }
        return back;
    }
    
    private void addCaretSelectText(JTextComponent c, int start, int end, boolean back) {
        Caret eCaret = c.getCaret();
        ensureVisible(c, start, end);
        if (eCaret instanceof EditorCaret) {
            EditorCaret caret = (EditorCaret) eCaret;
            try {
                caret.addCaret(c.getDocument().createPosition(end), c.getDocument().createPosition(start));
            } catch (BadLocationException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    private void selectText(JTextComponent c, int start, int end, boolean back){
        Caret caret = c.getCaret();

                    blk = result.getFoundPositions();
                }
                if (blk != null) {
                    if (Boolean.TRUE.equals(props.get(EditorFindSupport.ADD_MULTICARET))) {
                        addCaretSelectText(c, blk[0], blk[1], back);
                    } else {
                        selectText(c, blk[0], blk[1], back);
                    }
                    String msg = NbBundle.getMessage(EditorFindSupport.class, FOUND_LOCALE, findWhat, DocUtils.debugPosition(c.getDocument(), Integer.valueOf(blk[0])));
//                    String msg = exp + NbBundle.getMessage(EditorFindSupport.class, FOUND_LOCALE)
//                                 + ' ' + DocUtils.debugPosition(c.getDocument(), blk[0]);

                                                    EditorFindSupport.class, NOT_FOUND_LOCALE, findWhat), IMPORTANCE_FIND_OR_REPLACE);
                    // issue 14189 - selection was not removed
                    c.getCaret().setDot(c.getCaret().getDot());
                    }
            } catch (BadLocationException e) {
                LOG.log(Level.WARNING, e.getMessage(), e);
            }




import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.api.search.ReplacePattern;
import org.netbeans.api.search.SearchHistory;
import org.netbeans.api.search.SearchPattern;

import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.Pair;
import org.openide.util.WeakListeners;

/**

    private boolean hadFocusOnIncSearchTextField = false;
    private final JButton findNextButton;
    private final JButton findPreviousButton;
    private final JButton selectAllButton;
    private final JToggleButton matchCase;
    private final JToggleButton wholeWords;
    private final JToggleButton regexp;

        incSearchTextField.getDocument().addDocumentListener(incSearchTextFieldListener);
        addEnterKeystrokeFindNextTo(incSearchTextField);
        addShiftEnterKeystrokeFindPreviousTo(incSearchTextField);
        addAltEnterKeystrokeSelect(incSearchTextField);
        if (getCurrentKeyMapProfile().startsWith("Emacs")) { // NOI18N
            emacsProfileFix(incSearchTextField);
        }

        });
        add(findNextButton);
        
        selectAllButton = SearchButton.createButton("org/netbeans/modules/editor/search/resources/select_all.png", "CTL_SelectAll"); // NOI18N
        selectAllButton.setToolTipText(NbBundle.getMessage(SearchBar.class, "TOOLTIP_SelectAllText")); //NOI18N
        selectAllButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                selectAll();
            }
        });
        add(selectAllButton);
        
        final JToolBar.Separator rightSeparator = new JToolBar.Separator();
        rightSeparator.setOrientation(SwingConstants.VERTICAL);
        add(rightSeparator);

            @Override
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                    if(looseFocus()) {
                        e.consume();
                    };
                    ReplaceBar replaceBarInstance = ReplaceBar.getInstance(SearchBar.this);
                    if (replaceBarInstance.isVisible()) {
                        replaceBarInstance.looseFocus();

        return pcl;
    }

     private void addAltEnterKeystrokeSelect(JTextComponent incSearchTextField) {
        incSearchTextField.getInputMap().put(KeyStroke.getKeyStroke(
                KeyEvent.VK_ENTER, InputEvent.ALT_MASK, true),
                "select-all"); // NOI18N
        incSearchTextField.getActionMap().put("select-all", // NOI18N
                new AbstractAction() {

            @Override
            public void actionPerformed(ActionEvent e) {
                selectAll();
            }
        });
    }
     
    private void addShiftEnterKeystrokeFindPreviousTo(JTextComponent incSearchTextField) {
        incSearchTextField.getInputMap().put(KeyStroke.getKeyStroke(
                KeyEvent.VK_ENTER, InputEvent.SHIFT_MASK, true),

        incSearchTextField.getDocument().addDocumentListener(incSearchTextFieldListener);
    }

    public boolean looseFocus() {
        hadFocusOnIncSearchTextField = false;
        if (!isVisible()) {
            return false;
        }
        EditorFindSupport.getInstance().setBlockSearchHighlight(0, 0);
        EditorFindSupport.getInstance().incSearchReset();

                searchProps.saveToPrefs();
            }
        });
        return true;
    }

    private void incrementalSearch() {

    void findPrevious() {
        find(false);
    }
    
    void selectAll() {
        EditorFindSupport findSupport = EditorFindSupport.getInstance();
        JTextComponent textComponent = getActualTextComponent();
        Document doc = textComponent.getDocument();
        Caret caret = textComponent.getCaret();
        if(caret instanceof EditorCaret) {
            EditorCaret editorCaret = (EditorCaret) caret;
            try {
                int[] blocks = findSupport.getBlocks(new int[]{-1, -1}, doc, 0, doc.getLength());
                if(blocks[0] >= 0 && blocks.length % 2 == 0) {
                    List<Position> newCarets = new ArrayList<>(editorCaret.getCarets().size() << 1);
                    for (int i = 0; i < blocks.length; i += 2) {
                        int start = blocks[i];
                        int end = blocks[i+1];
                        if(start == -1 || end == -1) {
                            break;
                        }
                        Position startPos = doc.createPosition(start);
                        Position endPos = doc.createPosition(end);
                        newCarets.add(endPos);
                        newCarets.add(startPos);
                    }
                    
                    editorCaret.replaceCarets(newCarets);
                    
                    textComponent.requestFocusInWindow();
                }
            } catch (BadLocationException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    public int getNumOfMatches() {
        return numOfMatches;

        String lfID = laf.getID();
        return lf.equals(lfID);
    }
}




package org.netbeans.modules.editor.search.actions;

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

 * Portions Copyrighted 2013 Sun Microsystems, Inc.
 */

package org.netbeans.modules.editor.search.actions;

import java.awt.event.ActionEvent;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.BadLocationException;
import javax.swing.text.Caret;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.caret.EditorCaret;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.BaseKit;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.search.EditorFindSupport;
import org.netbeans.spi.editor.AbstractEditorAction;
import org.openide.util.Exceptions;
import org.openide.util.Pair;

/**
 * Select
 */
// NOI18N
@EditorActionRegistration(
        name = "addCaretSelectAll")
public class AddCaretSelectAllAction extends AbstractEditorAction {
    private static final Logger LOGGER = Logger.getLogger(FindSelectionAction.class.getName());

    private static final Logger LOGGER = Logger.getLogger(AddCaretSelectAllAction.class.getName());

    public AddCaretSelectAllAction() {
        super();
    }


    @SuppressWarnings("unchecked")
    public void actionPerformed(ActionEvent evt, JTextComponent target) {
        if (target != null) {
            EditorFindSupport findSupport = EditorFindSupport.getInstance();
            Caret caret = target.getCaret();
            if (!Utilities.isSelectionShowing(caret)) {
            HashMap<String, Object> props = new HashMap<>(findSupport.createDefaultFindProperties());
            String searchWord = null;
            boolean revert = false;
            Boolean originalValue = null;
            Map<String, Object> revertMap = (Map<String, Object>) props.get(EditorFindSupport.REVERT_MAP);
            Boolean revertValue = revertMap != null ? (Boolean) revertMap.get(EditorFindSupport.FIND_WHOLE_WORDS) : null;
            if (Utilities.isSelectionShowing(caret)) {
                // valid selection
                searchWord = target.getSelectedText();
                originalValue = (Boolean) props.put(EditorFindSupport.FIND_WHOLE_WORDS, Boolean.FALSE);
                if (Boolean.FALSE.equals(revertValue)) {
                    revertMap.remove(EditorFindSupport.FIND_WHOLE_WORDS);
                } else {
                    revert = !Boolean.FALSE.equals(originalValue);
                }
            } else {
                // no selection, get current word
                try {
                    int[] identifierBlock = Utilities.getIdentifierBlock((BaseDocument) target.getDocument(), caret.getDot());
                    if (identifierBlock != null) {
                        caret.setDot(identifierBlock[0]);
                        caret.moveDot(identifierBlock[1]);
                    } else {
                        revert = !Boolean.TRUE.equals(originalValue);
                    }
                } catch (BadLocationException e) {
                    LOGGER.log(Level.WARNING, null, e);
                }
            }

            EditorFindSupport findSupport = EditorFindSupport.getInstance();
            HashMap<String, Object> props = new HashMap<>(findSupport.createDefaultFindProperties());
            String searchWord = target.getSelectedText();
            int n = searchWord.indexOf('\n');
            if (n >= 0) {
                searchWord = searchWord.substring(0, n);
            }
            props.put(EditorFindSupport.FIND_WHAT, searchWord);
            Document doc = target.getDocument();
            EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(target);
            if (eui.getComponent().getClientProperty("AsTextField") == null) { //NOI18N
                findSupport.setFocusedTextComponent(eui.getComponent());
            }
            findSupport.putFindProperties(props);
            findSupport.find(null, false);

            if (caret instanceof EditorCaret) {
                EditorCaret editorCaret = (EditorCaret) caret;
                try {
                    int[] blocks = findSupport.getBlocks(new int[]{-1, -1}, doc, 0, doc.getLength());
                    if (blocks[0] >= 0 && blocks.length % 2 == 0) {
                        List<Position> newCarets = new ArrayList<>();

                        for (int i = 0; i < blocks.length; i += 2) {
                            int start = blocks[i];
                            int end = blocks[i + 1];
                            if (start == -1 || end == -1) {
                                break;
                            }
                            Position startPos = doc.createPosition(start);
                            Position endPos = doc.createPosition(end);
                            newCarets.add(endPos);
                            newCarets.add(startPos);
                        }

                        editorCaret.replaceCarets(newCarets);
                    }
                } catch (BadLocationException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }

        }
    }

}




package org.netbeans.modules.editor.search.actions;

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

 * Portions Copyrighted 2013 Sun Microsystems, Inc.
 */

package org.netbeans.modules.editor.search.actions;

import java.awt.event.ActionEvent;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.BadLocationException;

import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.BaseKit;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.search.EditorFindSupport;
import org.netbeans.spi.editor.AbstractEditorAction;

/** 
 * Select a whole word if there is not selection on word otherwise it adds a new caret for selected text
 */
// NOI18N
@EditorActionRegistration(
        name = "addCaretSelectNext")
public class AddCaretSelectNextAction extends AbstractEditorAction {
    private static final Logger LOGGER = Logger.getLogger(AddCaretSelectNextAction.class.getName());

    public AddCaretSelectNextAction() {
        super();
    }


    @SuppressWarnings("unchecked")
    public void actionPerformed(ActionEvent evt, JTextComponent target) {
        if (target != null) {
            EditorFindSupport findSupport = EditorFindSupport.getInstance();
            Caret caret = target.getCaret();
            int dotPos = caret.getDot();
            HashMap<String, Object> props = new HashMap<>(findSupport.createDefaultFindProperties());
            String searchWord = null;
            boolean revert = false;
            Boolean originalValue = null;
            Map<String, Object> revertMap = (Map<String, Object>) props.get(EditorFindSupport.REVERT_MAP);
            Boolean revertValue = revertMap != null ? (Boolean) revertMap.get(EditorFindSupport.FIND_WHOLE_WORDS) : null;
            if (Utilities.isSelectionShowing(caret)) {
                EditorFindSupport findSupport = EditorFindSupport.getInstance();
                HashMap<String, Object> props = new HashMap<>(findSupport.createDefaultFindProperties());
                String searchWord = target.getSelectedText();
                if (Boolean.FALSE.equals(revertValue)) {
                    revertMap.remove(EditorFindSupport.FIND_WHOLE_WORDS);
                } else {
                    revert = !Boolean.FALSE.equals(originalValue);
                }
            } else {
                // no selection, get current word
                try {
                    searchWord = Utilities.getIdentifier((BaseDocument) target.getDocument(), dotPos);
                    originalValue = (Boolean) props.put(EditorFindSupport.FIND_WHOLE_WORDS, Boolean.TRUE);
                    if (Boolean.TRUE.equals(revertValue)) {
                        revertMap.remove(EditorFindSupport.FIND_WHOLE_WORDS);
                    } else {
                        revert = !Boolean.TRUE.equals(originalValue);
                    }
                } catch (BadLocationException e) {
                    LOGGER.log(Level.WARNING, null, e);
                }
            }
            if (searchWord != null) {
                int n = searchWord.indexOf('\n');
                if (n >= 0) {
                    searchWord = searchWord.substring(0, n);
                }
                props.put(EditorFindSupport.FIND_WHAT, searchWord);
                props.put(EditorFindSupport.ADD_MULTICARET, Boolean.TRUE);
                    revertMap = new HashMap<>();
                    revertMap.put(EditorFindSupport.FIND_WHOLE_WORDS, originalValue != null ? originalValue : Boolean.FALSE);
                    props.put(EditorFindSupport.REVERT_MAP, revertMap);
                }
                props.put(EditorFindSupport.FIND_BLOCK_SEARCH, Boolean.FALSE);
                props.put(EditorFindSupport.FIND_BLOCK_SEARCH_START, null);
                props.put(EditorFindSupport.FIND_BLOCK_SEARCH_END, null);
                EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(target);
                if (eui.getComponent().getClientProperty("AsTextField") == null) { //NOI18N
                    //NOI18N
                    findSupport.setFocusedTextComponent(eui.getComponent());
                }
                findSupport.putFindProperties(props);
                findSupport.find(null, false);
            } else {
                try {
                    int[] identifierBlock = Utilities.getIdentifierBlock((BaseDocument) target.getDocument(), caret.getDot());
                    if (identifierBlock != null) {
                        caret.setDot(identifierBlock[0]);
                        caret.moveDot(identifierBlock[1]);
                    }
                } catch (BadLocationException e) {
                    LOGGER.log(Level.WARNING, null, e);
                }
            }
        }

Lines 5-8 Link Here

(-)a/editor.search/src/org/netbeans/modules/editor/search/actions/Bundle.properties (-1 / +3 lines)
5	find-next=Find Next Occurrence	5	find-next=Find Next Occurrence
6	find-previous=Find Previous Occurrence	6	find-previous=Find Previous Occurrence
7	find-selection=Find Selection	7	find-selection=Find Selection
8	toggle-highlight-search=Toggle Highlight Search	8	toggle-highlight-search=Toggle Highlight Search
		9	addCaretSelectNext=Add Selection For Next Occurrence
		10	addCaretSelectAll=Select All Occurrences




<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>
      <change id="GapListAddAll">
          <summary>Added methods to append elements to a GapList</summary>
          <version major="1" minor="64"/>
          <date day="22" month="2" year="2016"/>
          <author login="mmetelka"/>
          <compatibility addition="yes" deletion="no" modification="no" binary="compatible" semantic="compatible"/>
          <description>
              Added supplementary methods to GapList to accompany the existing
              methods to add elements.
          </description>
          <class name="GapList" package="org.netbeans.lib.editor.util"/>
          <issue number="257888"/>
      </change>
      <change id="EventPropertyStorage.test">
          <summary>Added test for property storage support on events</summary>
          <version major="1" minor="60"/>

Lines 2-5 Link Here

(-)a/editor.util/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.editor.util/1	2	OpenIDE-Module: org.netbeans.modules.editor.util/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/lib/editor/util/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/lib/editor/util/Bundle.properties
4	AutoUpdate-Show-In-Client: false	4	AutoUpdate-Show-In-Client: false
5	OpenIDE-Module-Specification-Version: 1.63	5	OpenIDE-Module-Specification-Version: 1.64

Lines 122-127 Link Here

(-)a/editor.util/src/org/netbeans/lib/editor/util/GapList.java (-3 / +79 lines)
122	this.gapLength = elementData.length - size;	122	this.gapLength = elementData.length - size;
123	}	123	}
124		124
		125	private GapList(E[] data, int gapStart, int gapLength) {
		126	this.elementData = data;
		127	this.gapStart = gapStart;
		128	this.gapLength = gapLength;
		129	}
		130
125	/**	131	/**
126	* Trims the capacity of this <tt>GapList</tt> instance to be the	132	* Trims the capacity of this <tt>GapList</tt> instance to be the
127	* list's current size. An application can use this operation to minimize	133	* list's current size. An application can use this operation to minimize
Lines 314-320 Link Here
314	throw new InternalError();	320	throw new InternalError();
315	}	321	}
316	}	322	}
317		323
		324	/**
		325	* Create shallow copy of this gap list.
		326	* @return copy of this gap list with zero extra capacity.
		327	* @since 1.63
		328	*/
		329	public GapList<E> copy() {
		330	int size = size();
		331	E[] data = allocateElementsArray(size);
		332	copyAllData(data);
		333	return new GapList<E>(data, size, 0);
		334	}
		335
318	/**	336	/**
319	* @deprecated use {@link #copyElements(int, int, Object[], int)} which performs the same operation	337	* @deprecated use {@link #copyElements(int, int, Object[], int)} which performs the same operation
320	*/	338	*/
Lines 556-561 Link Here
556	}	574	}
557		575
558	/**	576	/**
		577	* Appends elements from the specified collection to the end of
		578	* this list, in the order that they are returned by the
		579	* specified collection's iterator. The behavior of this operation is
		580	* undefined if the specified Collection is modified while the operation
		581	* is in progress. (This implies that the behavior of this call is
		582	* undefined if the specified Collection is this list, and this
		583	* list is nonempty.)
		584	*
		585	* @param c collection containing the elements to be inserted into this list.
		586	* @param off offset in the collection pointing to first element to copy.
		587	* @param len number of elements to copy from the collection.
		588	* @return <tt>true</tt> if this list changed as a result of the call.
		589	* @throws IndexOutOfBoundsException if index out of range <tt>(index
		590	* < 0 \|\| index > size())</tt>.
		591	* @throws NullPointerException if the specified Collection is null.
		592	* @since 1.64
		593	*/
		594	public boolean addAll(Collection<? extends E> c, int off, int len) {
		595	return addArray(size(), c.toArray(), off, len);
		596	}
		597
		598	/**
559	* Inserts all of the elements in the specified Collection into this	599	* Inserts all of the elements in the specified Collection into this
560	* list, starting at the specified position. Shifts the element	600	* list, starting at the specified position. Shifts the element
561	* currently at that position (if any) and any subsequent elements to	601	* currently at that position (if any) and any subsequent elements to
Lines 575-586 Link Here
575	return addArray(index, c.toArray());	615	return addArray(index, c.toArray());
576	}	616	}
577		617
578	/*	618	/**
		619	* Inserts elements in the specified Collection into this
		620	* list, starting at the specified position. Shifts the element
		621	* currently at that position (if any) and any subsequent elements to
		622	* the right (increases their indices). The new elements will appear
		623	* in the list in the order that they are returned by the
		624	* specified Collection's iterator.
		625	*
		626	* @param index index at which to insert first element
		627	* from the specified collection.
		628	* @param c collection containing the elements to be inserted into this list.
		629	* @param off offset in the collection pointing to first element to copy.
		630	* @param len number of elements to copy from the collection.
		631	* @return <tt>true</tt> if this list changed as a result of the call.
		632	* @throws IndexOutOfBoundsException if index out of range <tt>(index
		633	* < 0 \|\| index > size())</tt>.
		634	* @throws NullPointerException if the specified Collection is null.
		635	* @since 1.64
		636	*/
		637	public boolean addAll(int index, Collection<? extends E> c, int off, int len) {
		638	return addArray(index, c.toArray(), off, len);
		639	}
		640
		641	/**
		642	* Inserts all elements of the given array at the end of this list.
		643	*
		644	* @param elements array of elements to insert.
		645	* @return <tt>true</tt> if this list changed as a result of the call.
		646	* @since 1.64
		647	*/
		648	public boolean addArray(Object[] elements) {
		649	return addArray(size(), elements, 0, elements.length);
		650	}
		651
		652	/**
579	* Inserts all elements from the given array into this list, starting	653	* Inserts all elements from the given array into this list, starting
580	* at the given index.	654	* at the given index.
581	*	655	*
582	* @param index index at which to insert first element from the array.	656	* @param index index at which to insert first element from the array.
583	* @param elements array of elements to insert.	657	* @param elements array of elements to insert.
		658	* @return <tt>true</tt> if this list changed as a result of the call.
584	*/	659	*/
585	public boolean addArray(int index, Object[] elements) {	660	public boolean addArray(int index, Object[] elements) {
586	return addArray(index, elements, 0, elements.length);	661	return addArray(index, elements, 0, elements.length);
Lines 594-599 Link Here
594	* @param elements array of elements from which to insert elements.	669	* @param elements array of elements from which to insert elements.
595	* @param off offset in the elements pointing to first element to copy.	670	* @param off offset in the elements pointing to first element to copy.
596	* @param len number of elements to copy from the elements array.	671	* @param len number of elements to copy from the elements array.
		672	* @return <tt>true</tt> if this list changed as a result of the call.
597	*/	673	*/
598	public boolean addArray(int index, Object[] elements, int off, int len) {	674	public boolean addArray(int index, Object[] elements, int off, int len) {
599	int size = size();	675	int size = size();
Lines 646-652 Link Here
646		722
647	return oldValue;	723	return oldValue;
648	}	724	}
649		725
650	/**	726	/**
651	* Removes elements at the given index.	727	* Removes elements at the given index.
652	*	728	*




package org.netbeans.lib.editor.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import junit.framework.TestCase;


    private static final int REMOVE_RANGE_RATIO_1 = 10;
    private static final int CLEAR_RATIO_1 = 5;
    private static final int SET_RATIO_1 = 50;
    private static final int COPY_RATIO_1 = 50;
    
    private static final int OP_COUNT_2 = 10000;
    private static final int ADD_RATIO_2 = 50;

    private static final int REMOVE_RANGE_RATIO_2 = 10;
    private static final int CLEAR_RATIO_2 = 3;
    private static final int SET_RATIO_2 = 50;
    private static final int COPY_RATIO_2 = 50;
    
    private ArrayList<Object> al;
    

        
        
        testRound(random, OP_COUNT_1, ADD_RATIO_1, ADD_ALL_RATIO_1, ADD_ALL_MAX_COUNT_1,
            REMOVE_RATIO_1, REMOVE_RANGE_RATIO_1, CLEAR_RATIO_1, SET_RATIO_1, COPY_RATIO_1);
        testRound(random, OP_COUNT_2, ADD_RATIO_2, ADD_ALL_RATIO_2, ADD_ALL_MAX_COUNT_2,
            REMOVE_RATIO_2, REMOVE_RANGE_RATIO_2, CLEAR_RATIO_2, SET_RATIO_2, COPY_RATIO_2);
    }
    
    private void testRound(Random random, int opCount,
    int addRatio, int addAllRatio, int addAllMaxCount,
    int removeRatio, int removeRangeRatio, int clearRatio, int setRatio, int copyRatio) {
        
        int ratioSum = addRatio + addAllRatio + removeRatio + removeRangeRatio
            + clearRatio + setRatio;


            } else if ((r -= addAllRatio) < 0) {
                int count = (int)(random.nextDouble() * addAllMaxCount);
                int index = (int)(random.nextDouble() * (al.size() + 1));
                int off = (int)(random.nextDouble() * count);
                int len = (int)(random.nextDouble() * (count + 1 - off));
                ArrayList<Object> l = new ArrayList<Object>();
                for (int i = count; i > 0; i--) {
                    l.add(new Object());
                }
                int methodType = (int)(random.nextDouble() * 5);
                switch (methodType) {
                    case 0: // addAll(Collection<? extends E> c)
                        al.addAll(l);
                        if (debug) {
                            debugOp(op, "addAll(index, collection)"); // NOI18N
                        }
                        gl.addAll(l);
                        break;
                    case 1: // addAll(Collection<? extends E> c, int off, int len)
                        al.addAll(l.subList(off, off + len));
                        if (debug) {
                            debugOp(op, "addAll(collection, off, len)"); // NOI18N
                        }
                        gl.addAll(l, off, len);
                        break;
                    case 2: // addAll(int index, Collection<? extends E> c)
                        al.addAll(index, l);
                        if (debug) {
                            debugOp(op, "addAll(index, collection)"); // NOI18N
                        }
                        gl.addAll(index, l);
                        break;
                    case 3: // addAll(int index, Collection<? extends E> c, int off, int len)
                        al.addAll(index, l.subList(off, off + len));
                        if (debug) {
                            debugOp(op, "addAll(index, collection, off, len)"); // NOI18N
                        }
                        gl.addAll(index, l, off, len);
                        break;
                    case 4: // addArray(Object[] elements)
                        al.addAll(l);
                        if (debug) {
                            debugOp(op, "addArray(array)"); // NOI18N
                        }
                        gl.addArray(l.toArray());
                        break;
                        
                    default:
                        throw new AssertionError();
                }

                Object o = new Object();
                int index = (int)(al.size() * random.nextDouble());
                al.addAll(index, l);
                if (debug) {
                    debugOp(op, "addAll() at index=" + index); // NOI18N
                }
                gl.addAll(index, l);

            } else if ((r -= removeRatio) < 0) {
                if (al.size() > 0) { // is anything to remove

                    }
                    gl.set(index, o);
                }
            } else if ((r -= copyRatio) < 0) {
                int methodType = (int)(random.nextDouble() * 3);
                int alSize = al.size();
                int off = (int)(random.nextDouble() * alSize);
                int len = (int)(random.nextDouble() * (alSize + 1 - off));
                switch (methodType) {
                    case 0:
                        GapList copyList = gl.copy();
                        assertEquals("Lists differ", al, copyList);
                        break;
                    case 1:
                        ArrayList<Object> targetList = new ArrayList<Object>();
                        gl.copyElements(off, len, targetList);
                        assertEquals("Lists differ", al.subList(off, off + len), targetList);
                        break;
                    case 2:
                        Object[] targetArray = new Object[len];
                        gl.copyElements(off, len, targetArray, 0);
                        assertEquals("Lists differ", al.subList(off, off + len), Arrays.asList(targetArray));
                        break;
                    default:
                        throw new AssertionError();
                }
            }

            checkConsistency();




                    }
                    context.incrementOpCount();
                }
                container.dumpString(container.name() + " finished successfully.\n"); // NOI18N
                ok = true;
            } finally {
                if (!ok) {

        
        private StringBuilder logOpBuilder = new StringBuilder(256);

        private int maxOpsLogged = 4; // By default log only last 4 operations

        private final Map<Object,Object> properties;


                logOpBuilder.setLength(0);
                addOpLog(opLog);
            }
            if (true) { // Dump the op logs always (not only after failure) - might want to examine something
                StringBuilder sb = new StringBuilder(1024);
                for (String opLog : opLogs) {
                    sb.append(opLog);
                }
                opLogs.clear();
                container.dumpString(sb.toString());
            }
        }




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.html.editor;

import org.netbeans.modules.html.editor.api.HtmlKit;

/**
 *
 * @author Ralph Ruijs
 */
public abstract class APIAccessor {
    public static APIAccessor DEFAULT;

    static {
        Class c = HtmlKit.class;
        try {
            Class.forName(c.getName(), true, c.getClassLoader());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public abstract void setContentType(HtmlKit kit, String contentType);
}




 */
package org.netbeans.modules.html.editor;

import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.event.InputEvent;
import javax.swing.Icon;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.JPasswordField;
import javax.swing.TransferHandler;
import javax.swing.plaf.UIResource;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.JTextComponent;
import org.netbeans.modules.html.editor.api.HtmlKit;

/* !!!!!!!!!!!!!!!!!!!!!
 *
 * fix for issue #43309
 * with [REWRITE_PLACE]. This needs to be done to fix the issue #43309
 *
 * !!!!!!!!!!!!!!!!!!!!!
 */
public class HtmlTransferHandler extends TransferHandler implements UIResource {
    
    public static void install(JTextComponent c) {
        TransferHandler origHandler = c.getTransferHandler();
        if (!(origHandler instanceof HtmlTransferHandler)) {
            c.setTransferHandler(new HtmlTransferHandler(c.getTransferHandler()));
        }
    }
    
    private final TransferHandler delegate;

    public HtmlTransferHandler(TransferHandler delegate) {
        this.delegate = delegate;
    }
    
    TransferHandler getDelegate() {
        return delegate;
    }
    
    @Override
    public boolean canImport(TransferSupport support) {
        if(support.getComponent() instanceof JEditorPane &&
                ((JEditorPane) support.getComponent()).getEditorKit() instanceof HtmlKit) {
            HtmlKit kit = (HtmlKit) ((JEditorPane) support.getComponent()).getEditorKit();
            APIAccessor.DEFAULT.setContentType(kit, "text/plain");
            try {
                return delegate.canImport(support);
            } finally {
                APIAccessor.DEFAULT.setContentType(kit, HtmlKit.HTML_MIME_TYPE);
                String mime = flavors[i].getMimeType();
                if (mime.startsWith(((JEditorPane) c).getEditorKit().getContentType())) {
                    //return flavors[i]; [REWRITE_PLACE]
                } else if (plainFlavor == null && mime.startsWith("text/plain")) {
                    //NOI18N
                    plainFlavor = flavors[i];
                } else if (refFlavor == null && mime.startsWith("application/x-java-jvm-local-objectref") && flavors[i].getRepresentationClass() == java.lang.String.class) {
                    refFlavor = flavors[i];
                } else if (stringFlavor == null && flavors[i].equals(DataFlavor.stringFlavor)) {
                    stringFlavor = flavors[i];
                }
            }
        } else {
            return delegate.canImport(support);
        }
    }
    
    @Override
    public boolean importData(TransferSupport support) {
        if(support.getComponent() instanceof JEditorPane &&
                ((JEditorPane) support.getComponent()).getEditorKit() instanceof HtmlKit) {
            HtmlKit kit = (HtmlKit) ((JEditorPane) support.getComponent()).getEditorKit();
            APIAccessor.DEFAULT.setContentType(kit, "text/plain");
            try {
                return delegate.importData(support);
            } finally {
                APIAccessor.DEFAULT.setContentType(kit, HtmlKit.HTML_MIME_TYPE);
            }
        } else {
            return delegate.importData(support);
        }
    }

    @Override
    public boolean canImport(JComponent comp, DataFlavor[] t) {
        if(comp instanceof JEditorPane &&
                ((JEditorPane) comp).getEditorKit() instanceof HtmlKit) {
            HtmlKit kit = (HtmlKit) ((JEditorPane) comp).getEditorKit();
            APIAccessor.DEFAULT.setContentType(kit, "text/plain");
            try {
                return delegate.canImport(comp, t);
            } finally {
                APIAccessor.DEFAULT.setContentType(kit, HtmlKit.HTML_MIME_TYPE);
            }
        } else {
            return delegate.canImport(comp, t);
        }
    }

    @Override
    public boolean importData(JComponent comp, Transferable t) {
        if(comp instanceof JEditorPane &&
                ((JEditorPane) comp).getEditorKit() instanceof HtmlKit) {
            HtmlKit kit = (HtmlKit) ((JEditorPane) comp).getEditorKit();
            APIAccessor.DEFAULT.setContentType(kit, "text/plain");
            try {
                return delegate.importData(comp, t);
            } finally {
                APIAccessor.DEFAULT.setContentType(kit, HtmlKit.HTML_MIME_TYPE);
            }
        } else {
            return delegate.importData(comp, t);
        }
    }
    
    @Override
    protected Transferable createTransferable(JComponent c) {
        try {
            java.lang.reflect.Method method = delegate.getClass().getDeclaredMethod(
                    "createTransferable", // NOI18N
                    new Class[]{javax.swing.JComponent.class});
            method.setAccessible(true);

            return (Transferable) method.invoke(delegate, new Object[]{c});
        } catch (NoSuchMethodException ex) {
            ex.printStackTrace();
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
        } catch (java.lang.reflect.InvocationTargetException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    @Override
    public void exportAsDrag(JComponent comp, InputEvent e, int action) {
        delegate.exportAsDrag(comp, e, action);
    }

    @Override
    protected void exportDone(JComponent source, Transferable data, int action) {
        try {
            java.lang.reflect.Method method = delegate.getClass().getDeclaredMethod(
                    "exportDone", // NOI18N
                    new Class[]{javax.swing.JComponent.class, Transferable.class, int.class});
            method.setAccessible(true);
            method.invoke(delegate, new Object[]{source, data, new Integer(action)});
        } catch (NoSuchMethodException ex) {
            ex.printStackTrace();
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
        } catch (java.lang.reflect.InvocationTargetException ex) {
            ex.printStackTrace();
            StringBuffer sbuff = null;
            // Read in a block at a time, mapping \r\n to \n, as well as single
            // \r to \n.
            while ((nch = in.read(buff, 0, buff.length)) != -1) {
                if (sbuff == null) {
                    sbuff = new StringBuffer(nch);
                }
                last = 0;
                for (int counter = 0; counter < nch; counter++) {
                    switch (buff[counter]) {
                        case '\r':
                            if (lastWasCR) {
                                if (counter == 0) {
                                    sbuff.append('\n');
                                } else {
                                    buff[counter - 1] = '\n';
                                }
                            } else {
                                lastWasCR = true;
                            }
                            break;
                        case '\n':
                            if (lastWasCR) {
                                if (counter > (last + 1)) {
                                    sbuff.append(buff, last, counter - last - 1);
                                }
                                // else nothing to do, can skip \r, next write will
                                // write \n
                                lastWasCR = false;
                                last = counter;
                            }
                            break;
                        default:
                            if (lastWasCR) {
                                if (counter == 0) {
                                    sbuff.append('\n');
                                } else {
                                    buff[counter - 1] = '\n';
                                }
                                lastWasCR = false;
                            }
                            break;
                    }
                }
                if (last < nch) {
                    if (lastWasCR) {
                        if (last < (nch - 1)) {
                            sbuff.append(buff, last, nch - last - 1);
                        }
                    } else {
                        sbuff.append(buff, last, nch - last);
                    }
                }
            }
            if (lastWasCR) {
                sbuff.append('\n');
            }
            c.replaceSelection(sbuff != null ? sbuff.toString() : ""); //NOI18N
        }
    }

    @Override
    public void exportToClipboard(JComponent c, Clipboard clip, int action) throws IllegalStateException {
        delegate.exportToClipboard(c, clip, action);
    }

     *
     * @param c The component holding the data to be transfered. This
     * argument is provided to enable sharing of TransferHandlers by
     * multiple components.
     * @return This is implemented to return NONE if the component is a
     * JPasswordField since exporting data via user gestures is not allowed.
     * If the text component is editable, COPY_OR_MOVE is returned,
     * otherwise just COPY is allowed.
     */
    @Override
    public int getSourceActions(JComponent c) {
        return delegate.getSourceActions(c);
        if (!(c instanceof JPasswordField)) {
            if (((JTextComponent) c).isEditable()) {
                actions = COPY_OR_MOVE;
            } else {
                actions = COPY;
            }
        }
        return actions;
    }

    /**
     * Create a Transferable to use as the source for a data transfer.
     *
     * @param comp The component holding the data to be transfered. This
     * argument is provided to enable sharing of TransferHandlers by
     * multiple components.
     * @return The representation of the data to be transfered.
     *
     */
    @Override
    public Icon getVisualRepresentation(Transferable t) {
        return delegate.getVisualRepresentation(t);
        shouldRemove = true;
        p0 = exportComp.getSelectionStart();
        p1 = exportComp.getSelectionEnd();
        return (p0 != p1) ? (new HtmlTransferable(exportComp, p0, p1)) : null;
    }

    /**
     * This method is called after data has been exported. This method
     * should remove the data that was transfered if the action was MOVE.
     *
     * @param source The component that was the source of the data.
     * @param data The data that was transferred or possibly null if the
     * action is <code>NONE</code>.
     * @param action The actual action that was performed.
     */
    @Override
    protected void exportDone(JComponent source, Transferable data, int action) {
        // only remove the text if shouldRemove has not been set to
        // false by importData and only if the action is a move
        if (shouldRemove && action == MOVE) {
            HtmlTransferable t = (HtmlTransferable) data;
            t.removeText();
        }
        exportComp = null;
    }

    /**
     * This method causes a transfer to a component from a clipboard or a
     * DND drop operation. The Transferable represents the data to be
     * imported into the component.
     *
     * @param comp The component to receive the transfer. This argument is
     * provided to enable sharing of TransferHandlers by multiple
     * components.
     * @param t The data to import
     * @return true if the data was inserted into the component, false
     * otherwise.
     */
    @Override
    public boolean importData(JComponent comp, Transferable t) {
        JTextComponent c = (JTextComponent) comp;
        // if we are importing to the same component that we exported from
        // then don't actually do anything if the drop location is inside
        // the drag location and set shouldRemove to false so that exportDone
        // knows not to remove any data
        if (c == exportComp && c.getCaretPosition() >= p0 && c.getCaretPosition() <= p1) {
            shouldRemove = false;
            return true;
        }
        boolean imported = false;
        DataFlavor importFlavor = getImportFlavor(t.getTransferDataFlavors(), c);
        if (importFlavor != null) {
            try {
                boolean useRead = false;
                if (comp instanceof JEditorPane) {
                    JEditorPane ep = (JEditorPane) comp;
                    if (!ep.getContentType().startsWith("text/plain") && importFlavor.getMimeType().startsWith(ep.getContentType())) {
                        useRead = true;
                    }
                }
                InputContext ic = c.getInputContext();
                if (ic != null) {
                    ic.endComposition();
                }
                Reader r = importFlavor.getReaderForText(t);
                handleReaderImport(r, c, useRead);
                imported = true;
            } catch (UnsupportedFlavorException | BadLocationException | IOException ufe) {
                //just ignore
            }
        }
        return imported;
    }

    /**
     * This method indicates if a component would accept an import of the
     * given set of data flavors prior to actually attempting to import it.
     *
     * @param comp The component to receive the transfer. This argument is
     * provided to enable sharing of TransferHandlers by multiple
     * components.
     * @param flavors The data formats available
     * @return true if the data can be inserted into the component, false
     * otherwise.
     */
    @Override
    public boolean canImport(JComponent comp, DataFlavor[] flavors) {
        JTextComponent c = (JTextComponent) comp;
        if (!(c.isEditable() && c.isEnabled())) {
            return false;
        }
        return getImportFlavor(flavors, c) != null;
    }

    /**
     * A possible implementation of the Transferable interface for text
     * components. For a JEditorPane with a rich set of EditorKit
     * implementations, conversions could be made giving a wider set of
     * formats. This is implemented to offer up only the active content type
     * and text/plain (if that is not the active format) since that can be
     * extracted from other formats.
     */
    static class HtmlTransferable extends BasicTransferable {

        HtmlTransferable(JTextComponent c, int start, int end) {
            super(null, null);
            this.c = c;
            Document doc = c.getDocument();
            try {
                p0 = doc.createPosition(start);
                p1 = doc.createPosition(end);
                plainData = c.getSelectedText();
                if (c instanceof JEditorPane) {
                    JEditorPane ep = (JEditorPane) c;
                    mimeType = ep.getContentType();
                    if (mimeType.startsWith("text/plain")) {
                        //NOI18N
                        return;
                    }
                    StringWriter sw = new StringWriter(p1.getOffset() - p0.getOffset());
                    ep.getEditorKit().write(sw, doc, p0.getOffset(), p1.getOffset() - p0.getOffset());
                    if (mimeType.startsWith("text/html")) {
                        //NOI18N
                        htmlData = sw.toString();
                    } else {
                        richText = sw.toString();
                    }
                }
            } catch (BadLocationException | IOException ble) {
            }
        }

        void removeText() {
            if ((p0 != null) && (p1 != null) && (p0.getOffset() != p1.getOffset())) {
                try {
                    Document doc = c.getDocument();
                    doc.remove(p0.getOffset(), p1.getOffset() - p0.getOffset());
                } catch (BadLocationException e) {
                }
            }
        }

        // ---- EditorKit other than plain or HTML text -----------------------
        /**
         * If the EditorKit is not for text/plain or text/html, that format
         * is supported through the "richer flavors" part of
         * BasicTransferable.
         */
        @Override
        protected DataFlavor[] getRicherFlavors() {
            if (richText == null) {
                return null;
            }
            try {
                DataFlavor[] flavors = new DataFlavor[3];
                flavors[0] = new DataFlavor(mimeType + ";class=java.lang.String"); //NOI18N
                flavors[1] = new DataFlavor(mimeType + ";class=java.io.Reader"); //NOI18N
                flavors[2] = new DataFlavor(mimeType + ";class=java.io.InputStream;charset=unicode"); //NOI18N
                return flavors;
            } catch (ClassNotFoundException cle) {
                // fall through to unsupported (should not happen)
            }
            return null;
        }

        /**
         * The only richer format supported is the file list flavor
         */
        @Override
        protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException {
            if (richText == null) {
                return null;
            }
            if (String.class.equals(flavor.getRepresentationClass())) {
                return richText;
            } else if (Reader.class.equals(flavor.getRepresentationClass())) {
                return new StringReader(richText);
            } else if (InputStream.class.equals(flavor.getRepresentationClass())) {
                return new ByteArrayInputStream(richText.getBytes());
            }
            throw new UnsupportedFlavorException(flavor);
        }
        Position p0;
        Position p1;
        String mimeType;
        String richText;
        JTextComponent c;
    }
    
    private static class BasicTransferable implements Transferable, UIResource {

        protected String plainData;
        protected String htmlData;
        private static DataFlavor[] htmlFlavors;
        private static DataFlavor[] stringFlavors;
        private static DataFlavor[] plainFlavors;

        static {
            try {
                htmlFlavors = new DataFlavor[3];
                htmlFlavors[0] = new DataFlavor("text/html;class=java.lang.String"); //NOI18N
                htmlFlavors[1] = new DataFlavor("text/html;class=java.io.Reader"); //NOI18N
                htmlFlavors[2] = new DataFlavor("text/html;charset=unicode;class=java.io.InputStream"); //NOI18N

                plainFlavors = new DataFlavor[3];
                plainFlavors[0] = new DataFlavor("text/plain;class=java.lang.String"); //NOI18N
                plainFlavors[1] = new DataFlavor("text/plain;class=java.io.Reader"); //NOI18N
                plainFlavors[2] = new DataFlavor("text/plain;charset=unicode;class=java.io.InputStream"); //NOI18N

                stringFlavors = new DataFlavor[2];
                stringFlavors[0] = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=java.lang.String"); //NOI18N
                stringFlavors[1] = DataFlavor.stringFlavor;

            } catch (ClassNotFoundException cle) {
                System.err.println("error initializing javax.swing.plaf.basic.BasicTranserable"); ////NOI18N
            }
        }

        public BasicTransferable(String plainData, String htmlData) {
            this.plainData = plainData;
            this.htmlData = htmlData;
        }

        /**
         * Returns an array of DataFlavor objects indicating the flavors the
         * data can be provided in. The array should be ordered according to
         * preference for providing the data (from most richly descriptive to
         * least descriptive).
         *
         * @return an array of data flavors in which this data can be
         * transferred
         */
        @Override
        public DataFlavor[] getTransferDataFlavors() {
            DataFlavor[] richerFlavors = getRicherFlavors();
            int nRicher = (richerFlavors != null) ? richerFlavors.length : 0;
            int nHTML = (isHTMLSupported()) ? htmlFlavors.length : 0;
            int nPlain = (isPlainSupported()) ? plainFlavors.length : 0;
            int nString = (isPlainSupported()) ? stringFlavors.length : 0;
            int nFlavors = nRicher + nHTML + nPlain + nString;
            DataFlavor[] flavors = new DataFlavor[nFlavors];

            // fill in the array
            int nDone = 0;
            if (nRicher > 0) {
                System.arraycopy(richerFlavors, 0, flavors, nDone, nRicher);
                nDone += nRicher;
            }
            if (nHTML > 0) {
                System.arraycopy(htmlFlavors, 0, flavors, nDone, nHTML);
                nDone += nHTML;
            }
            if (nPlain > 0) {
                System.arraycopy(plainFlavors, 0, flavors, nDone, nPlain);
                nDone += nPlain;
            }
            if (nString > 0) {
                System.arraycopy(stringFlavors, 0, flavors, nDone, nString);
                nDone += nString;
            }
            return flavors;
        }

        /**
         * Returns whether or not the specified data flavor is supported for
         * this object.
         *
         * @param flavor the requested flavor for the data
         * @return boolean indicating whether or not the data flavor is
         * supported
         */
        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            DataFlavor[] flavors = getTransferDataFlavors();
            for (int i = 0; i < flavors.length; i++) {
                if (flavors[i].equals(flavor)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Returns an object which represents the data to be transferred. The
         * class of the object returned is defined by the representation class
         * of the flavor.
         *
         * @param flavor the requested flavor for the data
         * @see DataFlavor#getRepresentationClass
         * @exception IOException if the data is no longer available in the
         * requested flavor.
         * @exception UnsupportedFlavorException if the requested data flavor is
         * not supported.
         */
        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            DataFlavor[] richerFlavors = getRicherFlavors();
            if (isRicherFlavor(flavor)) {
                return getRicherData(flavor);
            } else if (isHTMLFlavor(flavor)) {
                String data = getHTMLData();
                data = (data == null) ? "" : data; //NOI18N
                if (String.class.equals(flavor.getRepresentationClass())) {
                    return data;
                } else if (Reader.class.equals(flavor.getRepresentationClass())) {
                    return new StringReader(data);
                } else if (InputStream.class.equals(flavor.getRepresentationClass())) {
                    return new ByteArrayInputStream(data.getBytes());
                }
                // fall through to unsupported
            } else if (isPlainFlavor(flavor)) {
                String data = getPlainData();
                data = (data == null) ? "" : data;
                if (String.class.equals(flavor.getRepresentationClass())) {
                    return data;
                } else if (Reader.class.equals(flavor.getRepresentationClass())) {
                    return new StringReader(data);
                } else if (InputStream.class.equals(flavor.getRepresentationClass())) {
                    return new ByteArrayInputStream(data.getBytes());
                }
                // fall through to unsupported

            } else if (isStringFlavor(flavor)) {
                String data = getPlainData();
                data = (data == null) ? "" : data; //NOI18N
                return data;
            }
            throw new UnsupportedFlavorException(flavor);
        }

        // --- richer subclass flavors ----------------------------------------------
        protected boolean isRicherFlavor(DataFlavor flavor) {
            DataFlavor[] richerFlavors = getRicherFlavors();
            int nFlavors = (richerFlavors != null) ? richerFlavors.length : 0;
            for (int i = 0; i < nFlavors; i++) {
                if (richerFlavors[i].equals(flavor)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Some subclasses will have flavors that are more descriptive than HTML
         * or plain text. If this method returns a non-null value, it will be
         * placed at the start of the array of supported flavors.
         */
        protected DataFlavor[] getRicherFlavors() {
            return null;
        }

        protected Object getRicherData(DataFlavor flavor) throws UnsupportedFlavorException {
            return null;
        }

        // --- html flavors ----------------------------------------------------------
        /**
         * Returns whether or not the specified data flavor is an HTML flavor
         * that is supported.
         *
         * @param flavor the requested flavor for the data
         * @return boolean indicating whether or not the data flavor is
         * supported
         */
        protected boolean isHTMLFlavor(DataFlavor flavor) {
            DataFlavor[] flavors = htmlFlavors;
            for (int i = 0; i < flavors.length; i++) {
                if (flavors[i].equals(flavor)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Should the HTML flavors be offered? If so, the method getHTMLData
         * should be implemented to provide something reasonable.
         */
        protected boolean isHTMLSupported() {
            return htmlData != null;
        }

        /**
         * Fetch the data in a text/html format
         */
        protected String getHTMLData() {
            return htmlData;
        }

        // --- plain text flavors ----------------------------------------------------
        /**
         * Returns whether or not the specified data flavor is an plain flavor
         * that is supported.
         *
         * @param flavor the requested flavor for the data
         * @return boolean indicating whether or not the data flavor is
         * supported
         */
        protected boolean isPlainFlavor(DataFlavor flavor) {
            DataFlavor[] flavors = plainFlavors;
            for (int i = 0; i < flavors.length; i++) {
                if (flavors[i].equals(flavor)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Should the plain text flavors be offered? If so, the method
         * getPlainData should be implemented to provide something reasonable.
         */
        protected boolean isPlainSupported() {
            return plainData != null;
        }

        /**
         * Fetch the data in a text/plain format.
         */
        protected String getPlainData() {
            return plainData;
        }

        // --- string flavorss --------------------------------------------------------
        /**
         * Returns whether or not the specified data flavor is a String flavor
         * that is supported.
         *
         * @param flavor the requested flavor for the data
         * @return boolean indicating whether or not the data flavor is
         * supported
         */
        protected boolean isStringFlavor(DataFlavor flavor) {
            DataFlavor[] flavors = stringFlavors;
            for (int i = 0; i < flavors.length; i++) {
                if (flavors[i].equals(flavor)) {
                    return true;
                }
            }
            return false;
        }
    }
    // END of fix of issue #43309
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 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 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.html.editor.api;

import org.netbeans.modules.html.editor.APIAccessor;

/**
 *
 * @author Ralph Ruijs
 */
class AccessorImpl extends APIAccessor {
    
    AccessorImpl() {}

    @Override
    public void setContentType(HtmlKit kit, String contentType) {
        kit.setContentType(contentType);
    }
}

Lines 49-54 Link Here

(-)a/html.editor/src/org/netbeans/modules/html/editor/api/HtmlKit.java (-2 / +13 lines)
49	import org.netbeans.editor.ext.ExtKit;	49	import org.netbeans.editor.ext.ExtKit;
50	import org.netbeans.modules.csl.api.CslActions;	50	import org.netbeans.modules.csl.api.CslActions;
51	import org.netbeans.modules.editor.NbEditorKit;	51	import org.netbeans.modules.editor.NbEditorKit;
		52	import org.netbeans.modules.html.editor.APIAccessor;
52		53
53	/**	54	/**
54	* Editor kit implementation for HTML content type	55	* Editor kit implementation for HTML content type
Lines 57-62 Link Here
57	*	58	*
58	*/	59	*/
59	public class HtmlKit extends NbEditorKit implements org.openide.util.HelpCtx.Provider {	60	public class HtmlKit extends NbEditorKit implements org.openide.util.HelpCtx.Provider {
		61
		62	static {
		63	APIAccessor.DEFAULT = new AccessorImpl();
		64	}
60		65
61	public @Override	66	public @Override
62	org.openide.util.HelpCtx getHelpCtx() {	67	org.openide.util.HelpCtx getHelpCtx() {
Lines 65-70 Link Here
65	static final long serialVersionUID = -1381945567613910297L;	70	static final long serialVersionUID = -1381945567613910297L;
66		71
67	public static final String HTML_MIME_TYPE = "text/html"; // NOI18N	72	public static final String HTML_MIME_TYPE = "text/html"; // NOI18N
		73	private String contentType;
68		74
69	public HtmlKit() {	75	public HtmlKit() {
70	this(HTML_MIME_TYPE);	76	this(HTML_MIME_TYPE);
Lines 72-82 Link Here
72		78
73	public HtmlKit(String mimeType) {	79	public HtmlKit(String mimeType) {
74	super();	80	super();
		81	contentType = HTML_MIME_TYPE;
75	}	82	}
76		83
77	@Override	84	@Override
78	public String getContentType() {	85	public String getContentType() {
79	return HTML_MIME_TYPE;	86	return contentType;
		87	}
		88
		89	void setContentType(String contentType) {
		90	this.contentType = contentType;
80	}	91	}
81		92
82	@Override	93	@Override
Lines 90-96 Link Here
90	@Override	101	@Override
91	public void install(javax.swing.JEditorPane c) {	102	public void install(javax.swing.JEditorPane c) {
92	super.install(c);	103	super.install(c);
93	c.setTransferHandler(new HtmlTransferHandler());	104	HtmlTransferHandler.install(c);
94	}	105	}
95		106
96	@Override	107	@Override

Lines 97-102 Link Here

(-)a/java.editor/src/org/netbeans/modules/java/editor/imports/ClipboardHandler.java (-8 / +13 lines)
97	import com.sun.source.tree.ClassTree;	97	import com.sun.source.tree.ClassTree;
98	import com.sun.source.tree.ImportTree;	98	import com.sun.source.tree.ImportTree;
99	import com.sun.source.tree.MethodTree;	99	import com.sun.source.tree.MethodTree;
		100	import java.awt.Component;
100	import java.util.Set;	101	import java.util.Set;
101	import org.netbeans.api.editor.EditorActionRegistration;	102	import org.netbeans.api.editor.EditorActionRegistration;
102	import org.netbeans.api.editor.EditorActionRegistrations;	103	import org.netbeans.api.editor.EditorActionRegistrations;
Lines 550-561 Link Here
550	}	551	}
551		552
552	@Override	553	@Override
553	public boolean importData(TransferSupport support) {	554	public boolean importData(JComponent comp, Transferable t) {
554	return delegate.importData(support);	555	return delegate.importData(comp, t);
555	}	556	}
556		557
557	@Override	558	@Override
558	public boolean importData(JComponent comp, Transferable t) {	559	public boolean importData(TransferSupport support) {
		560	Transferable t = support.getTransferable();
		561	Component comp = support.getComponent();
559	if (t.isDataFlavorSupported(IMPORT_FLAVOR) && comp instanceof JTextComponent && !insideToken((JTextComponent)comp, JavaTokenId.STRING_LITERAL, JavaTokenId.BLOCK_COMMENT, JavaTokenId.JAVADOC_COMMENT, JavaTokenId.LINE_COMMENT)) {	562	if (t.isDataFlavorSupported(IMPORT_FLAVOR) && comp instanceof JTextComponent && !insideToken((JTextComponent)comp, JavaTokenId.STRING_LITERAL, JavaTokenId.BLOCK_COMMENT, JavaTokenId.JAVADOC_COMMENT, JavaTokenId.LINE_COMMENT)) {
560	boolean result = false;	563	boolean result = false;
561		564
Lines 563-569 Link Here
563	final JTextComponent tc = (JTextComponent) comp;	566	final JTextComponent tc = (JTextComponent) comp;
564	final int caret = tc.getSelectionStart();	567	final int caret = tc.getSelectionStart();
565		568
566	if (result = delegatedImportData(comp, t)) {	569	if (result = delegatedImportData(support)) {
567	final ImportsWrapper imports = (ImportsWrapper) t.getTransferData(IMPORT_FLAVOR);	570	final ImportsWrapper imports = (ImportsWrapper) t.getTransferData(IMPORT_FLAVOR);
568	final FileObject file = NbEditorUtilities.getFileObject(tc.getDocument());	571	final FileObject file = NbEditorUtilities.getFileObject(tc.getDocument());
569	final Document doc = tc.getDocument();	572	final Document doc = tc.getDocument();
Lines 610-620 Link Here
610	return result;	613	return result;
611	}	614	}
612		615
613	return delegatedImportData(comp, t);	616	return delegatedImportData(support);
614	}	617	}
615		618
616	private boolean delegatedImportData(final JComponent comp, final Transferable t) {	619	private boolean delegatedImportData(final TransferSupport support) {
617	if (comp instanceof JTextComponent && !t.isDataFlavorSupported(COPY_FROM_STRING_FLAVOR) && insideToken((JTextComponent) comp, JavaTokenId.STRING_LITERAL)) {	620	JComponent comp = (JComponent) support.getComponent();
		621	if (comp instanceof JTextComponent && !support.isDataFlavorSupported(COPY_FROM_STRING_FLAVOR) && insideToken((JTextComponent) comp, JavaTokenId.STRING_LITERAL)) {
		622	final Transferable t = support.getTransferable();
618	return delegate.importData(comp, new Transferable() {	623	return delegate.importData(comp, new Transferable() {
619	@Override	624	@Override
620	public DataFlavor[] getTransferDataFlavors() {	625	public DataFlavor[] getTransferDataFlavors() {
Lines 654-660 Link Here
654	}	659	}
655	});	660	});
656	}	661	}
657	return delegate.importData(comp, t);	662	return delegate.importData(support);
658	}	663	}
659		664
660	private boolean insideToken(final JTextComponent jtc, final JavaTokenId first, final JavaTokenId... rest) {	665	private boolean insideToken(final JTextComponent jtc, final JavaTokenId first, final JavaTokenId... rest) {

Lines 373-381 Link Here

(-)a/openide.text/src/org/openide/text/QuietEditorPane.java (-4 / +16 lines)
373		373
374	@Override	374	@Override
375	public boolean importData(JComponent comp, Transferable t) {	375	public boolean importData(JComponent comp, Transferable t) {
		376	return delegator.importData(comp, t);
		377	}
		378
		379	@Override
		380	public boolean importData(TransferSupport t) {
376	try {	381	try {
377	if (t.isDataFlavorSupported(ActiveEditorDrop.FLAVOR)){	382	if (t.isDataFlavorSupported(ActiveEditorDrop.FLAVOR)){
378	Object obj = t.getTransferData(ActiveEditorDrop.FLAVOR);	383	Object obj = t.getTransferable().getTransferData(ActiveEditorDrop.FLAVOR);
		384	final JComponent comp = (JComponent) t.getComponent();
379	if (obj instanceof ActiveEditorDrop && comp instanceof JTextComponent){	385	if (obj instanceof ActiveEditorDrop && comp instanceof JTextComponent){
380	boolean success = false;	386	boolean success = false;
381	try {	387	try {
Lines 390-396 Link Here
390	} catch (Exception exc){	396	} catch (Exception exc){
391	exc.printStackTrace();	397	exc.printStackTrace();
392	}	398	}
393	return delegator.importData(comp, t);	399	return delegator.importData(t);
394	}	400	}
395		401
396	private void requestFocus(JComponent comp) {	402	private void requestFocus(JComponent comp) {
Lines 412-426 Link Here
412	comp.requestFocus();	418	comp.requestFocus();
413	}	419	}
414	}	420	}
		421
		422	@Override
		423	public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
		424	return delegator.canImport(comp, transferFlavors);
		425	}
415		426
416	@Override	427	@Override
417	public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {	428	public boolean canImport(TransferSupport support) {
		429	DataFlavor[] transferFlavors = support.getDataFlavors();
418	for (int i=0; i<transferFlavors.length; i++){	430	for (int i=0; i<transferFlavors.length; i++){
419	if (transferFlavors[i] == ActiveEditorDrop.FLAVOR){	431	if (transferFlavors[i] == ActiveEditorDrop.FLAVOR){
420	return true;	432	return true;
421	}	433	}
422	}	434	}
423	return delegator.canImport(comp, transferFlavors);	435	return delegator.canImport(support);
424	}	436	}
425		437
426	@Override	438	@Override




     </file>
   </folder> <!-- Window -->
  </folder>
  <!-- Removed shortcut as it conflicts with Remove Last Caret. -->
<!--    <folder name="Shortcuts">
        <file name="OS-U.shadow">
            <attr name="originalFile" stringvalue="Actions/Window/org-netbeans-modules-refactoring-spi-impl-FindUsagesOpenAction.instance"/>
        </file>
    </folder>-->

     <folder name="Windows2">
        <folder name="Modes">

Return to bug 257893

Line 0 Link Here

(-)a/editor.actions/src/org/netbeans/modules/editor/actions/AddSelectionElseCaretAction.java (+162 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2016 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 2016 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.editor.actions;
		43
		44	import java.awt.Point;
		45	import java.awt.Rectangle;
		46	import java.awt.event.ActionEvent;
		47	import java.util.ArrayList;
		48	import java.util.List;
		49	import javax.swing.text.BadLocationException;
		50	import javax.swing.text.Caret;
		51	import javax.swing.text.JTextComponent;
		52	import javax.swing.text.Position;
		53	import org.netbeans.api.editor.EditorActionNames;
		54	import org.netbeans.api.editor.EditorActionRegistration;
		55	import org.netbeans.api.editor.EditorActionRegistrations;
		56	import org.netbeans.api.editor.caret.EditorCaret;
		57	import org.netbeans.api.editor.caret.CaretMoveContext;
		58	import org.netbeans.editor.BaseDocument;
		59	import org.netbeans.editor.Utilities;
		60	import org.netbeans.spi.editor.AbstractEditorAction;
		61	import org.netbeans.spi.editor.caret.CaretMoveHandler;
		62
		63	/**
		64	*
65	* @author Ralph Ruijs
66	*/
67	@EditorActionRegistrations({
68	@EditorActionRegistration(name = EditorActionNames.addSelectionElseCaretUpAction),
69	@EditorActionRegistration(name = EditorActionNames.addSelectionElseCaretDownAction)
70	})
71	public class AddSelectionElseCaretAction extends AbstractEditorAction {
72
73	@Override
74	protected void actionPerformed(ActionEvent evt, final JTextComponent target) {
75	if (target != null) {
76	Caret caret = target.getCaret();
77	if (caret != null && caret instanceof EditorCaret) {
78	final EditorCaret editorCaret = (EditorCaret) caret;
79	final BaseDocument doc = (BaseDocument) target.getDocument();
80	if(EditorActionNames.addSelectionElseCaretUpAction.equals(actionName())) {
81	doc.runAtomicAsUser(new Runnable() {
82	@Override
83	public void run() {
84	final List<Position> dots = new ArrayList<>(editorCaret.getCarets().size() << 1);
85	editorCaret.moveCarets(new CaretMoveHandler() {
86	@Override
87	public void moveCarets(CaretMoveContext context) {
88	for (org.netbeans.api.editor.caret.CaretInfo caretInfo : context.getOriginalCarets()) {
89	try {
90	int dot = caretInfo.getDot();
91	Point p = caretInfo.getMagicCaretPosition();
92	if (p == null) {
93	Rectangle r = target.modelToView(dot);
94	if (r != null) {
95	p = new Point(r.x, r.y);
96	context.setMagicCaretPosition(caretInfo, p);
97	} else {
98	return; // model to view failed
99	}
100	}
101	try {
102	dot = Utilities.getPositionAbove(target, dot, p.x);
103	Position dotPos = doc.createPosition(dot);
104	dots.add(dotPos);
105	dots.add(dotPos);
106	} catch (BadLocationException e) {
107	// the position stays the same
108	}
109	} catch (BadLocationException ex) {
110	target.getToolkit().beep();
111	}
112	}
113	}
114	});
115
116	editorCaret.addCarets(dots);
117	}
118	});
119	} else {
120	doc.runAtomicAsUser(new Runnable() {
121	@Override
122	public void run() {
123	final List<Position> dots = new ArrayList<>(editorCaret.getCarets().size() << 1);
124	editorCaret.moveCarets(new CaretMoveHandler() {
125	@Override
126	public void moveCarets(CaretMoveContext context) {
127	for (org.netbeans.api.editor.caret.CaretInfo caretInfo : context.getOriginalCarets()) {
128	try {
129	int dot = caretInfo.getDot();
130	Point p = caretInfo.getMagicCaretPosition();
131	if (p == null) {
132	Rectangle r = target.modelToView(dot);
133	if (r != null) {
134	p = new Point(r.x, r.y);
135	context.setMagicCaretPosition(caretInfo, p);
136	} else {
137	return; // model to view failed
138	}
139	}
140	try {
141	dot = Utilities.getPositionBelow(target, dot, p.x);
142	Position dotPos = doc.createPosition(dot);
143	dots.add(dotPos);
144	dots.add(dotPos);
145	} catch (BadLocationException e) {
146	// position stays the same
147	}
148	} catch (BadLocationException ex) {
149	target.getToolkit().beep();
150	}
151	}
152	}
153	});
154	editorCaret.addCarets(dots);
155	}
156	});
157	}
158	}
159	}
160	}
161
162	}

Line 0 Link Here

(-)a/editor.actions/src/org/netbeans/modules/editor/actions/ToggleTypingModeAction.java (+76 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2015 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 2015 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.editor.actions;
		43
		44	import java.awt.event.ActionEvent;
		45	import javax.swing.text.JTextComponent;
		46	import org.netbeans.api.editor.EditorActionNames;
		47	import org.netbeans.api.editor.EditorActionRegistration;
		48	import org.netbeans.api.editor.EditorUtilities;
		49	import org.netbeans.spi.editor.AbstractEditorAction;
		50
		51	/**
		52	* Switch caret from insert mode to overwrite mode or vice versa.
		53	*
		54	* @author Miloslav Metelka
		55	*/
		56
		57	@EditorActionRegistration(name = EditorActionNames.toggleTypingMode)
		58	public final class ToggleTypingModeAction extends AbstractEditorAction {
		59
		60	private static final long serialVersionUID = 1L;
		61
		62	public ToggleTypingModeAction() {
		63	super();
		64	}
65
66	@Override
67	public void actionPerformed(ActionEvent evt, JTextComponent target) {
68	if (target != null) {
69	Boolean overwriteMode = (Boolean) target.getClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY);
70	// Now toggle
71	overwriteMode = (overwriteMode == null \|\| !overwriteMode) ? Boolean.TRUE : Boolean.FALSE;
72	target.putClientProperty(EditorUtilities.CARET_OVERWRITE_MODE_PROPERTY, overwriteMode);
73	}
74	}
75
76	}

Lines 112-117 Link Here

(-)a/editor.document/apichanges.xml (+18 lines)
112	<!-- ACTUAL CHANGES BEGIN HERE: -->	112	<!-- ACTUAL CHANGES BEGIN HERE: -->
113		113
114	<changes>	114	<changes>
		115	<change id="ShiftPositions">
		116	<api name="api"/>
		117	<summary>Added ShiftPositions</summary>
		118	<version major="1" minor="7"/>
		119	<date day="22" month="2" year="2016"/>
		120	<author login="mmetelka"/>
		121	<compatibility source="compatible" binary="compatible" semantic="compatible" addition="yes"/>
		122	<description>
		123	<p>
		124	Added ShiftPositions class to create and read ShiftPositions.
		125	The implementation ShiftPos is a position together with a
		126	shift of extra columns. This allows for positions behind
		127	line's last character (newline) or within a tab character.
		128	</p>
		129	</description>
		130	<class name="ShiftPositions" package="org.netbeans.api.editor.document"/>
		131	<issue number="257889"/>
		132	</change>
115	<change id="TextSearchUtils-getPreviousWordStart">	133	<change id="TextSearchUtils-getPreviousWordStart">
116	<api name="api"/>	134	<api name="api"/>
117	<summary>Added TextSearchUtils.getPreviousWordStart() method</summary>	135	<summary>Added TextSearchUtils.getPreviousWordStart() method</summary>

Line 0 Link Here

(-)a/editor.document/src/org/netbeans/api/editor/document/ShiftPositions.java (+135 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2015 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 2015 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.api.editor.document;
		43
		44	import javax.swing.text.Position;
		45	import org.netbeans.api.annotations.common.NonNull;
		46	import org.netbeans.modules.editor.lib2.document.ShiftPos;
		47	import org.openide.util.Parameters;
		48
		49	/**
		50	* A position together with a shift of extra columns.
		51	* This allows for positions behind line's last character (newline) or within a tab character.
		52	*
		53	* @author Miloslav Metelka
		54	* @since 1.7
		55	*/
		56	public final class ShiftPositions {
		57
		58	private ShiftPositions() {
		59	// No instances
		60	}
		61
		62	/**
		63	* Produce an immutable shift position.
		64	* The returned position acts like the original position and it does not handle in any way
65	* any subsequent document modifications.
66	*
67	* @param pos non-null position. If this is already a shift position its shift
68	* gets added to the shift parameter passed to this method.
69	* @param shift >= 0 number of extra columns added to the position.
70	* For 0 the original position gets returned. Negative value throws an IllegalArgumentException.
71	* @return virtual position whose {@link Position#getOffset()} returns the same value
72	* like the getPosition parameter.
73	*/
74	public static Position create(@NonNull Position pos, int shift) {
75	Parameters.notNull("pos", pos); //NOI18N
76	if (shift > 0) {
77	if (pos.getClass() == ShiftPos.class) {
78	return new ShiftPos((ShiftPos)pos, shift);
79	} else {
80	return new ShiftPos(pos, shift);
81	}
82	} else if (shift == 0) {
83	return pos;
84	} else {
85	throw new IllegalArgumentException("shift=" + shift + " < 0");
86	}
87	}
88
89	/**
90	* Return shift of a passed virtual position or zero for regular positions.
91	* @param pos non-null position.
92	* @return >=0 shift or zero for regular positions.
93	*/
94	public static int getShift(@NonNull Position pos) {
95	return getShiftImpl(pos);
96	}
97
98	/**
99	* Compare positions.
100	* @param pos1 non-null position.
101	* @param pos2 non-null position.
102	* @return offset of pos1 minus offset of pos2 or diff of their shifts in case
103	* both positions have the same offset.
104	* @NullPointerException if any passed position is null unless both positions are null
105	* in which case the method would return 0.
106	*/
107	public static int compare(@NonNull Position pos1, @NonNull Position pos2) {
108	if (pos1 == pos2) {
109	return 0;
110	}
111	int offsetDiff = pos1.getOffset() - pos2.getOffset();
112	return (offsetDiff != 0) ? offsetDiff : getShiftImpl(pos1) - getShiftImpl(pos2);
113	}
114
115	/**
116	* Compare positions by providing their offsets and shifts obtained earlier.
117	* @param offset1 offset of first position.
118	* @param shift1 shift of first position.
119	* @param offset2 offset of second position.
120	* @param shift2 shift of second position.
121	* @return offset1 minus offset2 or shift1 minus shift2 in case
122	* offset1 and offset2 are equal.
123	*/
124	public static int compare(int offset1, int shift1, int offset2, int shift2) {
125	int offsetDiff = offset1 - offset2;
126	return (offsetDiff != 0) ? offsetDiff : shift1 - shift2;
127	}
128
129	private static int getShiftImpl(Position pos) {
130	return (pos.getClass() == ShiftPos.class)
131	? ((ShiftPos)pos).getShift()
132	: 0;
133	}
134
135	}

Line 0 Link Here

(-)a/editor.document/src/org/netbeans/modules/editor/lib2/document/ShiftPos.java (+83 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2015 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 2015 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.editor.lib2.document;
		43
		44	import javax.swing.text.Position;
		45
		46
		47	/**
		48	* Implementation of a shift position. The clients should only use methods
		49	* in {@link org.netbeans.api.editor.document.ShiftPositions} and never check
		50	* for an instance of this particular class.
		51	*
		52	* @author Miloslav Metelka
		53	*/
		54	public final class ShiftPos implements Position {
		55
		56	private final Position pos;
		57
		58	private final int shift;
		59
		60	public ShiftPos(Position pos, int shift) {
		61	this.pos = pos;
		62	this.shift = shift;
		63	}
		64
65	public ShiftPos(ShiftPos shiftPos, int shift) {
66	this.pos = shiftPos.pos;
67	this.shift = shiftPos.shift + shift;
68	}
69
70	public Position getPosition() {
71	return pos;
72	}
73
74	public int getShift() {
75	return shift;
76	}
77
78	@Override
79	public int getOffset() {
80	return pos.getOffset();
81	}
82
83	}

Line 0 Link Here

(-)a/editor.document/test/unit/src/org/netbeans/api/editor/document/ShiftPositionsTest.java (+100 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2016 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 2016 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.api.editor.document;
		43
		44	import javax.swing.text.Document;
		45	import javax.swing.text.PlainDocument;
		46	import javax.swing.text.Position;
		47	import org.junit.Test;
		48	import static org.junit.Assert.*;
		49
		50	/**
		51	*
		52	* @author Miloslav Metelka
		53	*/
		54	public class ShiftPositionsTest {
		55
		56	public ShiftPositionsTest() {
		57	}
		58
		59	@Test
		60	public void testPos() throws Exception {
		61	Document doc = new PlainDocument();
		62	doc.insertString(0, "\t\t\n\n", null);
		63	Position pos1 = doc.createPosition(1);
		64	Position pos2 = doc.createPosition(2);
65
66	Position pos10 = ShiftPositions.create(pos1, 0);
67	Position pos11 = ShiftPositions.create(pos1, 1);
68	Position pos20 = ShiftPositions.create(pos2, 0);
69	Position pos21 = ShiftPositions.create(pos2, 1);
70
71	assertEquals(0, ShiftPositions.getShift(pos1));
72	assertEquals(0, ShiftPositions.getShift(pos10));
73	assertEquals(1, ShiftPositions.getShift(pos11));
74	comparePos(pos1, pos10, 0);
75	comparePos(pos10, pos11, -1);
76	comparePos(pos1, pos2, -1);
77	comparePos(pos10, pos20, -1);
78	comparePos(pos20, pos21, -1);
79	}
80
81	private void comparePos(Position pos1, Position pos2, int expectedResult) {
82	comparePosImpl(pos1, pos2, expectedResult, true);
83	}
84
85	private void comparePosImpl(Position pos1, Position pos2, int expectedResult, boolean reverseCompare) {
86	int result = ShiftPositions.compare(pos1, pos2);
87	assertEquals("Invalid result=" + result + " when comparing positions pos1=" +
88	pos1 + " to pos2=" + pos2, expectedResult, result);
89
90	result = ShiftPositions.compare(pos1.getOffset(), ShiftPositions.getShift(pos1),
91	pos2.getOffset(), ShiftPositions.getShift(pos2));
92	assertEquals("Invalid result=" + result + " when comparing positions pos1=" +
93	pos1 + " to pos2=" + pos2, expectedResult, result);
94
95	if (reverseCompare) {
96	comparePosImpl(pos2, pos1, -expectedResult, false);
97	}
98	}
99
100	}

Lines 44-55 Link Here

(-)a/editor.errorstripe/src/org/netbeans/modules/editor/errorstripe/caret/CaretMarkProvider.java (-12 / +29 lines)
44		44
45	package org.netbeans.modules.editor.errorstripe.caret;	45	package org.netbeans.modules.editor.errorstripe.caret;
46	import java.util.Collections;	46	import java.util.Collections;
		47	import java.util.LinkedList;
47	import java.util.List;	48	import java.util.List;
48	import javax.swing.event.CaretEvent;	49	import javax.swing.event.CaretEvent;
49	import javax.swing.event.CaretListener;	50	import javax.swing.event.CaretListener;
		51	import javax.swing.text.Caret;
50	import javax.swing.text.Document;	52	import javax.swing.text.Document;
51	import javax.swing.text.JTextComponent;	53	import javax.swing.text.JTextComponent;
52	import javax.swing.text.StyledDocument;	54	import javax.swing.text.StyledDocument;
		55	import org.netbeans.api.editor.caret.CaretInfo;
		56	import org.netbeans.api.editor.caret.EditorCaret;
53	import org.netbeans.modules.editor.errorstripe.privatespi.Mark;	57	import org.netbeans.modules.editor.errorstripe.privatespi.Mark;
54	import org.netbeans.modules.editor.errorstripe.privatespi.MarkProvider;	58	import org.netbeans.modules.editor.errorstripe.privatespi.MarkProvider;
55	import org.openide.text.NbDocument;	59	import org.openide.text.NbDocument;
Lines 64-105 Link Here
64		68
65	private static final RequestProcessor RP = new RequestProcessor("CaretMarkProvider");	69	private static final RequestProcessor RP = new RequestProcessor("CaretMarkProvider");
66		70
67	private Mark mark;	71	private List<Mark> marks;
68	private JTextComponent component;	72	private JTextComponent component;
69		73
70	/** Creates a new instance of AnnotationMarkProvider */	74	/** Creates a new instance of AnnotationMarkProvider */
71	public CaretMarkProvider(JTextComponent component) {	75	public CaretMarkProvider(JTextComponent component) {
72	this.component = component;	76	this.component = component;
73	component.addCaretListener(this);	77	component.addCaretListener(this);
74	mark = createMark();	78	marks = createMarks();
75	}	79	}
76		80
77	private Mark createMark() {	81	private List<Mark> createMarks() {
78	int offset = component.getCaretPosition(); //TODO: AWT?
79	Document doc = component.getDocument();	82	Document doc = component.getDocument();
80	int line = 0;	83	if(!(doc instanceof StyledDocument)) {
81		84	return Collections.singletonList((Mark)new CaretMark(0));
82	if (doc instanceof StyledDocument) {
83	line = NbDocument.findLineNumber((StyledDocument) doc, offset);
84	}	85	}
85		86	List<Mark> lines = new LinkedList<>();
86	return new CaretMark(line);	87	Caret caret = component.getCaret();
		88	if(caret instanceof EditorCaret) {
		89	EditorCaret editorCaret = (EditorCaret) caret;
		90	for (CaretInfo caretInfo : editorCaret.getCarets()) {
		91	int offset = caretInfo.getDot();
		92	int line = NbDocument.findLineNumber((StyledDocument) doc, offset);
		93	lines.add(new CaretMark(line));
		94	}
		95	} else {
		96	int offset = component.getCaretPosition(); //TODO: AWT?
		97	int line = NbDocument.findLineNumber((StyledDocument) doc, offset);
		98	lines.add(new CaretMark(line));
		99	}
		100	return lines;
87	}	101	}
88		102
		103	@Override
89	public synchronized List<Mark> getMarks() {	104	public synchronized List<Mark> getMarks() {
90	return Collections.singletonList(mark);	105	return Collections.unmodifiableList(marks);
91	}	106	}
92		107
		108	@Override
93	public void caretUpdate(CaretEvent e) {	109	public void caretUpdate(CaretEvent e) {
94	final List<Mark> old = getMarks();	110	final List<Mark> old = getMarks();
95		111
96	mark = createMark();	112	marks = createMarks();
97		113
98	final List<Mark> nue = getMarks();	114	final List<Mark> nue = getMarks();
99		115
100	//Do not fire this event under the document's write lock	116	//Do not fire this event under the document's write lock
101	//may deadlock with other providers:	117	//may deadlock with other providers:
102	RP.post(new Runnable() {	118	RP.post(new Runnable() {
		119	@Override
103	public void run() {	120	public void run() {
104	firePropertyChange(PROP_MARKS, old, nue);	121	firePropertyChange(PROP_MARKS, old, nue);
105	}	122	}

Lines 137-150 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseCaret.java (-5 / +5 lines)
137	/** Caret type representing block covering current character */	137	/** Caret type representing block covering current character */
138	public static final String BLOCK_CARET = EditorPreferencesDefaults.BLOCK_CARET; // NOI18N	138	public static final String BLOCK_CARET = EditorPreferencesDefaults.BLOCK_CARET; // NOI18N
139		139
140	/** Default caret type */
141	public static final String LINE_CARET = EditorPreferencesDefaults.LINE_CARET; // NOI18N
142
143	/** One dot thin line compatible with Swing default caret */	140	/** One dot thin line compatible with Swing default caret */
144	public static final String THIN_LINE_CARET = "thin-line-caret"; // NOI18N	141	public static final String THIN_LINE_CARET = EditorPreferencesDefaults.THIN_LINE_CARET; // NOI18N
145		142
146	/** @since 1.23 */	143	/** @since 1.23 */
147	public static final String THICK_LINE_CARET = "thick-line-caret"; // NOI18N	144	public static final String THICK_LINE_CARET = EditorPreferencesDefaults.THICK_LINE_CARET; // NOI18N
		145
		146	/** Default caret type */
		147	public static final String LINE_CARET = THICK_LINE_CARET; // NOI18N
148		148
149	/** Boolean property defining whether selection is being rectangular in a particular text component. */	149	/** Boolean property defining whether selection is being rectangular in a particular text component. */
150	private static final String RECTANGULAR_SELECTION_PROPERTY = "rectangular-selection"; // NOI18N	150	private static final String RECTANGULAR_SELECTION_PROPERTY = "rectangular-selection"; // NOI18N

Lines 105-112 Link Here

(-)a/editor.lib2/apichanges.xml (-1 / +35 lines)
105	</apidefs>	105	</apidefs>
106		106
107	<!-- ACTUAL CHANGES BEGIN HERE: -->	107	<!-- ACTUAL CHANGES BEGIN HERE: -->
108		108
109	<changes>	109	<changes>
		110	<change id="editor-caret">
		111	<summary>Caret API introduced</summary>
		112	<version major="2" minor="7"/>
		113	<date day="22" month="2" year="2016"/>
		114	<author login="mmetelka"/>
		115	<author login="ralphbenjamin"/>
		116	<compatibility binary="compatible" semantic="compatible" source="compatible" addition="yes" deprecation="no" deletion="no"/>
		117	<description>
		118	<p>
		119	The Caret API was introduced to allow working with multiple
		120	carets within one document.
		121	</p>
		122	</description>
		123	<class name="EditorActionNames" package="org.netbeans.api.editor" />
		124	<class name="EditorUtilities" package="org.netbeans.api.editor" />
		125	<package name="org.netbeans.api.editor.caret" />
		126	<issue number="257893"/>
		127	</change>
110	<change id="occurrences-names">	128	<change id="occurrences-names">
111	<summary>Added IDs for goto prev/next occurrence actions</summary>	129	<summary>Added IDs for goto prev/next occurrence actions</summary>
112	<version major="2" minor="6"/>	130	<version major="2" minor="6"/>
Lines 122-127 Link Here
122	<class name="EditorActionNames" package="org.netbeans.api.editor"/>	140	<class name="EditorActionNames" package="org.netbeans.api.editor"/>
123	<issue number="194356"/>	141	<issue number="194356"/>
124	</change>	142	</change>
		143	<change id="shift-highlights-sequence">
		144	<summary>Extended HightlightsSequence by ShiftHighlightsSequence</summary>
		145	<version major="2" minor="5"/>
		146	<date day="22" month="2" year="2016"/>
		147	<author login="mmetelka"/>
		148	<compatibility binary="compatible" semantic="compatible" source="compatible" addition="yes" deprecation="no" deletion="no"/>
		149	<description>
		150	<p>
		151	Highlights sequence that supports shifts in addition to regular offsets.
		152	This allows to color individual spaces within a tab character
		153	or to color extra virtual characters beyond a newline character.
		154	</p>
		155	</description>
		156	<class name="ShiftHighlightsSequence" package="org.netbeans.spi.editor.highlighting"/>
		157	<issue number="XXX"/>
		158	</change>
125	<change id="releasable-highlights-container">	159	<change id="releasable-highlights-container">
126	<summary>ReleasableHighlightsContainer added</summary>	160	<summary>ReleasableHighlightsContainer added</summary>
127	<version major="2" minor="4"/>	161	<version major="2" minor="4"/>

Lines 90-96 Link Here

(-)a/editor.lib2/nbproject/project.xml (-10 / +11 lines)
90	<compile-dependency/>	90	<compile-dependency/>
91	<run-dependency>	91	<run-dependency>
92	<release-version>1</release-version>	92	<release-version>1</release-version>
93	<specification-version>1.44</specification-version>	93	<specification-version>1.63</specification-version>
94	</run-dependency>	94	</run-dependency>
95	</dependency>	95	</dependency>
96	<dependency>	96	<dependency>
Lines 127-140 Link Here
127	</run-dependency>	127	</run-dependency>
128	</dependency>	128	</dependency>
129	<dependency>	129	<dependency>
130	<code-name-base>org.openide.util.ui</code-name-base>
131	<build-prerequisite/>
132	<compile-dependency/>
133	<run-dependency>
134	<specification-version>9.3</specification-version>
135	</run-dependency>
136	</dependency>
137	<dependency>
138	<code-name-base>org.openide.util</code-name-base>	130	<code-name-base>org.openide.util</code-name-base>
139	<build-prerequisite/>	131	<build-prerequisite/>
140	<compile-dependency/>	132	<compile-dependency/>
Lines 150-155 Link Here
150	<specification-version>8.0</specification-version>	142	<specification-version>8.0</specification-version>
151	</run-dependency>	143	</run-dependency>
152	</dependency>	144	</dependency>
		145	<dependency>
		146	<code-name-base>org.openide.util.ui</code-name-base>
		147	<build-prerequisite/>
		148	<compile-dependency/>
		149	<run-dependency>
		150	<specification-version>9.3</specification-version>
		151	</run-dependency>
		152	</dependency>
153	</module-dependencies>	153	</module-dependencies>
154	<test-dependencies>	154	<test-dependencies>
155	<test-type>	155	<test-type>
Lines 209-216 Link Here
209	</test-dependencies>	209	</test-dependencies>
210	<public-packages>	210	<public-packages>
211	<package>org.netbeans.api.editor</package>	211	<package>org.netbeans.api.editor</package>
212	<package>org.netbeans.api.editor.document</package>	212	<package>org.netbeans.api.editor.caret</package>
213	<package>org.netbeans.spi.editor</package>	213	<package>org.netbeans.spi.editor</package>
		214	<package>org.netbeans.spi.editor.caret</package>
214	<package>org.netbeans.spi.editor.codegen</package>	215	<package>org.netbeans.spi.editor.codegen</package>
215	<package>org.netbeans.spi.editor.document</package>	216	<package>org.netbeans.spi.editor.document</package>
216	<package>org.netbeans.spi.editor.highlighting</package>	217	<package>org.netbeans.spi.editor.highlighting</package>

Lines 81-87 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/EditorActionNames.java (-1 / +27 lines)
81		81
82	/**	82	/**
83	* Zoom text in by increasing default font size.	83	* Zoom text in by increasing default font size.
84	* <br/>	84	* <br>
85	* textComponent.getClientProperty("text-zoom") contains positive (or negative)	85	* textComponent.getClientProperty("text-zoom") contains positive (or negative)
86	* integer of how many points the font size should be increased (decreased).	86	* integer of how many points the font size should be increased (decreased).
87	* @since 1.45	87	* @since 1.45
Lines 136-141 Link Here
136	* @since 1.64	136	* @since 1.64
137	*/	137	*/
138	public static final String organizeMembers = "organize-members"; // NOI18N	138	public static final String organizeMembers = "organize-members"; // NOI18N
		139
		140
		141	/**
		142	* Toggle caret between regular insert mode and overwrite mode.
		143	* @since 1.31
		144	*/
		145	public static final String toggleTypingMode = "toggle-typing-mode"; // NOI18N
		146
		147	/**
		148	* Remove the last added caret.
		149	* @since 2.6
		150	*/
		151	public static final String removeLastCaret = "remove-last-caret"; // NOI18N
139		152
140	/**	153	/**
141	* Navigates to the previous occurence of the symbol under the caret. The action	154	* Navigates to the previous occurence of the symbol under the caret. The action
Lines 150-153 Link Here
150	* @since 2.3	163	* @since 2.3
151	*/	164	*/
152	public static final String gotoNextOccurrence = "next-marked-occurrence"; // NOI18N	165	public static final String gotoNextOccurrence = "next-marked-occurrence"; // NOI18N
		166
		167	/**
		168	* Add a caret to the line above at the same position.
		169	* @since 2.6
		170	*/
		171	public static final String addSelectionElseCaretUpAction = "add-selection-else-caret-up"; // NOI18N
		172
		173	/**
		174	* Add a caret to the line below at the same position.
		175	* @since 2.6
		176	*/
		177	public static final String addSelectionElseCaretDownAction = "add-selection-else-caret-down"; // NOI18N
		178
153	}	179	}

Lines 52-58 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/EditorActionRegistration.java (-14 / +14 lines)
52	/**	52	/**
53	* Registration of an editor action so that it's automatically added into the list	53	* Registration of an editor action so that it's automatically added into the list
54	* of editor actions even without being explicitly created by <code>BaseKit.createActions()</code>.	54	* of editor actions even without being explicitly created by <code>BaseKit.createActions()</code>.
55	* <br/>	55	* <br>
56	* The corresponding annotation processor will build a xml-layer entry file	56	* The corresponding annotation processor will build a xml-layer entry file
57	* in the corresponding <i>/Editors/<mime-type>/Actions</code> folder.	57	* in the corresponding <i>/Editors/<mime-type>/Actions</code> folder.
58	*	58	*
Lines 65-71 Link Here
65		65
66	/**	66	/**
67	* Name of the action that will appear as <code>Action.NAME</code> attribute's value.	67	* Name of the action that will appear as <code>Action.NAME</code> attribute's value.
68	* <br/>	68	* <br>
69	* The Swing's text package actions use convention of lowercase letters with hyphens	69	* The Swing's text package actions use convention of lowercase letters with hyphens
70	* e.g. "caret-end-word" - see String constants in {@link javax.swing.text.DefaultEditorKit}.	70	* e.g. "caret-end-word" - see String constants in {@link javax.swing.text.DefaultEditorKit}.
71	*	71	*
Lines 75-81 Link Here
75		75
76	/**	76	/**
77	* Mime type for which the action will be registered.	77	* Mime type for which the action will be registered.
78	* <br/>	78	* <br>
79	* It implies the target folder of the registration <i>/Editors/<mime-type>/Actions</code>.	79	* It implies the target folder of the registration <i>/Editors/<mime-type>/Actions</code>.
80	*	80	*
81	* @return mime-type of the action registration (for example "text/x-java"	81	* @return mime-type of the action registration (for example "text/x-java"
Lines 117-126 Link Here
117	* Menu text bundle key of the registered action.	117	* Menu text bundle key of the registered action.
118	* If an empty string is used (the default) it will be set to the same value	118	* If an empty string is used (the default) it will be set to the same value
119	* like action's short description.	119	* like action's short description.
120	* <br/>	120	* <br>
121	* Value starting with a hash "#key" searches in a bundle in the same package	121	* Value starting with a hash "#key" searches in a bundle in the same package
122	* as the action's class.	122	* as the action's class.
123	* <br/>	123	* <br>
124	* "bundle#key" allows specification of both bundle and a corresponding key.	124	* "bundle#key" allows specification of both bundle and a corresponding key.
125	*/	125	*/
126	String menuText() default "";	126	String menuText() default "";
Lines 129-138 Link Here
129	* Popup menu text bundle key of the registered action.	129	* Popup menu text bundle key of the registered action.
130	* If an empty string is used (the default) it will be set to the same value	130	* If an empty string is used (the default) it will be set to the same value
131	* like menu text.	131	* like menu text.
132	* <br/>	132	* <br>
133	* Value starting with a hash "#key" searches in a bundle in the same package	133	* Value starting with a hash "#key" searches in a bundle in the same package
134	* as the action's class.	134	* as the action's class.
135	* <br/>	135	* <br>
136	* "bundle#key" allows specification of both bundle and a corresponding key.	136	* "bundle#key" allows specification of both bundle and a corresponding key.
137	*/	137	*/
138	String popupText() default "";	138	String popupText() default "";
Lines 144-150 Link Here
144		144
145	/**	145	/**
146	* Integer position of the main menu item among the other menu items.	146	* Integer position of the main menu item among the other menu items.
147	* <br/>	147	* <br>
148	* The default Integer.MAX_VALUE value means no menu representation.	148	* The default Integer.MAX_VALUE value means no menu representation.
149	*/	149	*/
150	int menuPosition() default Integer.MAX_VALUE;	150	int menuPosition() default Integer.MAX_VALUE;
Lines 157-177 Link Here
157		157
158	/**	158	/**
159	* Integer position of the popup menu item among the other popup menu (or submenu) items.	159	* Integer position of the popup menu item among the other popup menu (or submenu) items.
160	* <br/>	160	* <br>
161	* The default Integer.MAX_VALUE value means no popup menu representation.	161	* The default Integer.MAX_VALUE value means no popup menu representation.
162	*/	162	*/
163	int popupPosition() default Integer.MAX_VALUE;	163	int popupPosition() default Integer.MAX_VALUE;
164		164
165	/**	165	/**
166	* Integer position of this action in editor toolbar.	166	* Integer position of this action in editor toolbar.
167	* <br/>	167	* <br>
168	* The default Integer.MAX_VALUE value means no toolbar representation.	168	* The default Integer.MAX_VALUE value means no toolbar representation.
169	*/	169	*/
170	int toolBarPosition() default Integer.MAX_VALUE;	170	int toolBarPosition() default Integer.MAX_VALUE;
171		171
172	/**	172	/**
173	* True if the action should not display its icon in menu.	173	* True if the action should not display its icon in menu.
174	* <br/>	174	* <br>
175	* False by default (icon visible in menu).	175	* False by default (icon visible in menu).
176	* @since 1.74	176	* @since 1.74
177	*/	177	*/
Lines 179-185 Link Here
179		179
180	/**	180	/**
181	* True if the action should not be displayed in customizer for key bindings assignment.	181	* True if the action should not be displayed in customizer for key bindings assignment.
182	* <br/>	182	* <br>
183	* False by default (key binding can be configured for the action).	183	* False by default (key binding can be configured for the action).
184	* @since 1.74	184	* @since 1.74
185	*/	185	*/
Lines 187-193 Link Here
187		187
188	/**	188	/**
189	* Boolean key in preferences that corresponds to action's selected state.	189	* Boolean key in preferences that corresponds to action's selected state.
190	* <br/>	190	* <br>
191	* If set to non-empty string the action will be represented by a check-box	191	* If set to non-empty string the action will be represented by a check-box
192	* in menu and popup menu and the corresponding key will be set in	192	* in menu and popup menu and the corresponding key will be set in
193	* global mime-lookup <code>MimeLookup.getLookup(MimePath.EMPTY)</code>.	193	* global mime-lookup <code>MimeLookup.getLookup(MimePath.EMPTY)</code>.
Lines 196-202 Link Here
196		196
197	/**	197	/**
198	* Whether or not the action should be in checked state by default.	198	* Whether or not the action should be in checked state by default.
199	* <br/>	199	* <br>
200	* If the preference should default to true or to false. Only valid in conjunction	200	* If the preference should default to true or to false. Only valid in conjunction
201	* with {@link #preferencesKey() }.	201	* with {@link #preferencesKey() }.
202	*	202	*

Lines 72-83 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/EditorRegistry.java (-17 / +17 lines)
72		72
73	/**	73	/**
74	* Registry maintaining {@link JTextComponent}s in most-recently-used order.	74	* Registry maintaining {@link JTextComponent}s in most-recently-used order.
75	* <br/>	75	* <br>
76	* The particular text component needs to register itself first (to avoid dealing	76	* The particular text component needs to register itself first (to avoid dealing
77	* with all the JTextFields etc.). Then the registry will attach	77	* with all the JTextFields etc.). Then the registry will attach
78	* a focus listener to the text component and once the component gains	78	* a focus listener to the text component and once the component gains
79	* the focus it will move to the head of the components list.	79	* the focus it will move to the head of the components list.
80	* <br/>	80	* <br>
81	* The registry will also fire a change in case a document property	81	* The registry will also fire a change in case a document property
82	* of the focused component changes (by calling component.setDocument()).	82	* of the focused component changes (by calling component.setDocument()).
83	*	83	*
Lines 98-106 Link Here
98		98
99	/**	99	/**
100	* Fired when focus was delivered to a registered text component.	100	* Fired when focus was delivered to a registered text component.
101	* <br/>	101	* <br>
102	* The focused component will become the first in the components list.	102	* The focused component will become the first in the components list.
103	* <br/>	103	* <br>
104	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be a component	104	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be a component
105	* losing the focus {@link FocusEvent#getOppositeComponent()}.	105	* losing the focus {@link FocusEvent#getOppositeComponent()}.
106	* The {@link java.beans.PropertyChangeEvent#getNewValue()} will be the text component gaining the focus.	106	* The {@link java.beans.PropertyChangeEvent#getNewValue()} will be the text component gaining the focus.
Lines 109-117 Link Here
109		109
110	/**	110	/**
111	* Fired when a registered focused component has lost the focus.	111	* Fired when a registered focused component has lost the focus.
112	* <br/>	112	* <br>
113	* The focused component will remain the first in the components list.	113	* The focused component will remain the first in the components list.
114	* <br/>	114	* <br>
115	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the text component	115	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the text component
116	* losing the focus and the {@link java.beans.PropertyChangeEvent#getNewValue()}	116	* losing the focus and the {@link java.beans.PropertyChangeEvent#getNewValue()}
117	* will be the component gaining the focus {@link FocusEvent#getOppositeComponent()}.	117	* will be the component gaining the focus {@link FocusEvent#getOppositeComponent()}.
Lines 121-127 Link Here
121	/**	121	/**
122	* Fired when document property of the focused component changes	122	* Fired when document property of the focused component changes
123	* i.e. someone has called {@link JTextComponent#setDocument(Document)}.	123	* i.e. someone has called {@link JTextComponent#setDocument(Document)}.
124	* <br/>	124	* <br>
125	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the original document	125	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the original document
126	* of the focused text component and the {@link java.beans.PropertyChangeEvent#getNewValue()}	126	* of the focused text component and the {@link java.beans.PropertyChangeEvent#getNewValue()}
127	* will be the new document set to the focused text component.	127	* will be the new document set to the focused text component.
Lines 132-144 Link Here
132	* Fired when a component (returned previously from {@link #componentList()})	132	* Fired when a component (returned previously from {@link #componentList()})
133	* is removed from component hierarchy (so it's likely that the component will be released completely	133	* is removed from component hierarchy (so it's likely that the component will be released completely
134	* and garbage-collected).	134	* and garbage-collected).
135	* <br/>	135	* <br>
136	* Such component will no longer be returned from {@link #componentList()}	136	* Such component will no longer be returned from {@link #componentList()}
137	* or {@link #lastFocusedComponent()}.	137	* or {@link #lastFocusedComponent()}.
138	* <br/>	138	* <br>
139	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed	139	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed
140	* component.	140	* component.
141	* <br/>	141	* <br>
142	* The {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>	142	* The {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>
143	*/	143	*/
144	public static final String COMPONENT_REMOVED_PROPERTY = "componentRemoved"; //NOI18N	144	public static final String COMPONENT_REMOVED_PROPERTY = "componentRemoved"; //NOI18N
Lines 147-160 Link Here
147	* Fired when the last focused component (returned previously from {@link #lastFocusedComponent()})	147	* Fired when the last focused component (returned previously from {@link #lastFocusedComponent()})
148	* was removed from component hierarchy (so it's likely that the component will be released completely	148	* was removed from component hierarchy (so it's likely that the component will be released completely
149	* and garbage-collected).	149	* and garbage-collected).
150	* <br/>	150	* <br>
151	* Such component will no longer be returned from {@link #componentList()}	151	* Such component will no longer be returned from {@link #componentList()}
152	* or {@link #lastFocusedComponent()}.	152	* or {@link #lastFocusedComponent()}.
153	* <br/>	153	* <br>
154	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed	154	* The {@link java.beans.PropertyChangeEvent#getOldValue()} will be the removed
155	* last focused component and the {@link java.beans.PropertyChangeEvent#getNewValue()}	155	* last focused component and the {@link java.beans.PropertyChangeEvent#getNewValue()}
156	* will be the component that would currently be returned from {@link #lastFocusedComponent()}.	156	* will be the component that would currently be returned from {@link #lastFocusedComponent()}.
157	* <br/>	157	* <br>
158	* If {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>	158	* If {@link java.beans.PropertyChangeEvent#getNewValue()} returns <code>null</code>
159	* then there are no longer any registered components	159	* then there are no longer any registered components
160	* ({@link #componentList()} would return empty list). If the client	160	* ({@link #componentList()} would return empty list). If the client
Lines 180-186 Link Here
180		180
181	/**	181	/**
182	* Return last focused text component (from the ones included in the registry).	182	* Return last focused text component (from the ones included in the registry).
183	* <br/>	183	* <br>
184	* It may or may not currently have a focus.	184	* It may or may not currently have a focus.
185	*	185	*
186	* @return last focused text component or null if no text components	186	* @return last focused text component or null if no text components
Lines 193-199 Link Here
193	/**	193	/**
194	* Return the last focused component if it currently has a focus	194	* Return the last focused component if it currently has a focus
195	* or return null if none of the registered components currently have the focus.	195	* or return null if none of the registered components currently have the focus.
196	* <br/>	196	* <br>
197	* @return focused component or null if none of the registered components	197	* @return focused component or null if none of the registered components
198	* is currently focused.	198	* is currently focused.
199	*/	199	*/
Lines 205-211 Link Here
205	/**	205	/**
206	* Get list of all components present in the registry starting with the most active	206	* Get list of all components present in the registry starting with the most active
207	* and ending with least active component.	207	* and ending with least active component.
208	* <br/>	208	* <br>
209	* The list is a snapshot of the current state and it may be modified	209	* The list is a snapshot of the current state and it may be modified
210	* by the caller if desired.	210	* by the caller if desired.
211	*	211	*
Lines 240-246 Link Here
240	* <li>{@link #FOCUS_LOST_PROPERTY}</li>	240	* <li>{@link #FOCUS_LOST_PROPERTY}</li>
241	* <li>{@link #FOCUSED_DOCUMENT_PROPERTY}</li>	241	* <li>{@link #FOCUSED_DOCUMENT_PROPERTY}</li>
242	* </ul>.	242	* </ul>.
243	* <br/>	243	* <br>
244	* All the firing should occur in AWT thread only	244	* All the firing should occur in AWT thread only
245	* (assuming the JTextComponent.setDocument() is done properly in AWT).	245	* (assuming the JTextComponent.setDocument() is done properly in AWT).
246	*	246	*

Line 0 Link Here

(-)a/editor.lib2/src/org/netbeans/api/editor/caret/package.html (+158 lines)
		1	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
		2	<!--
		3	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		4
		5	Copyright 2016 Oracle and/or its affiliates. All rights reserved.
		6
		7	Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		8	Other names may be trademarks of their respective owners.
		9
		10	The contents of this file are subject to the terms of either the GNU
		11	General Public License Version 2 only ("GPL") or the Common
		12	Development and Distribution License("CDDL") (collectively, the
		13	"License"). You may not use this file except in compliance with the
		14	License. You can obtain a copy of the License at
		15	http://www.netbeans.org/cddl-gplv2.html
		16	or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		17	specific language governing permissions and limitations under the
		18	License. When distributing the software, include this License Header
		19	Notice in each file and include the License file at
		20	nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		21	particular file as subject to the "Classpath" exception as provided
		22	by Oracle in the GPL Version 2 section of the License file that
		23	accompanied this code. If applicable, add the following below the
		24	License Header, with the fields enclosed by brackets [] replaced by
		25	your own identifying information:
		26	"Portions Copyrighted [year] [name of copyright owner]"
		27
		28	If you wish your version of this file to be governed by only the CDDL
		29	or only the GPL Version 2, indicate your decision by adding
		30	"[Contributor] elects to include this software in this distribution
		31	under the [CDDL or GPL Version 2] license." If you do not indicate a
		32	single choice of license, a recipient has the option to distribute
		33	your version of this file under either the CDDL, the GPL Version 2 or
		34	to extend the choice of license to its licensees as provided above.
		35	However, if you add GPL Version 2 code and therefore, elected the GPL
		36	Version 2 license, then the option applies only if the new code is
		37	made subject to such option by the copyright holder.
		38
		39	Contributor(s):
		40
		41	Portions Copyrighted 2016 Sun Microsystems, Inc.
		42	-->
		43
		44	<html>
		45	<head>
		46	<title>org.netbeans.api.editor.caret</title>
		47	</head>
		48	<body>
		49
		50	<p>
		51	The Editor Caret API opens up the editor to give information about its carets
		52	and to manipulate them.
		53	</p>
		54
		55	<h3>Key parts of the API</h3>
		56
		57	<p>
		58	The whole API is organized around the
		59	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaret.html">EditorCaret</a></code>
		60	class, an implementation of the <code>javax.swing.text.Caret</code> managing
		61	all the carets in a single document. Information about carets maintained by
		62	<code>EditorCaret</code> is stored in the immutable class
		63	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/CaretInfo.html">CaretInfo</a></code>.
		64	Once a caret gets mutated its corresponding caret info becomes obsolete
65	and new caret info instance gets created lazily.
66	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaretListener.html">EditorCaretListener</a></code>
67	can be registered to an <code>EditorCaret</code> to be informed about caret
68	addition/removal or movement with an
69	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/EditorCaretEvent.html">EditorCaretEvent</a></code>.
70	</p>
71
72	<p>
73	The <code>EditorCaret</code> mutates its carets in a single transaction.
74	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/api/editor/caret/CaretMoveContext.html">CaretMoveContext</a></code>
75	allows clients implementing
76	<code><a href="@org-netbeans-modules-editor-lib2@/org/netbeans/spi/editor/caret/CaretMoveHandler.html">CaretMoveHandler</a></code>
77	to manipulate carets. The following code shows how all carets are moved to the
78	end of the word they are currently on.
79
80	<pre><code>
81	editorCaret.moveCarets((CaretMoveContext context) -> {
82	for (CaretInfo ci : context.getOriginalCarets()) {
83	Position pos = target.getDocument().createPosition(Utilities.getWordEnd(target, ci.getDot()));
84	context.setDot(ci, pos);
85	}
86	});
87	</code>
88	</pre>
89	</p>
90
91	<h3>Locking and <code>Document</code> changes</h3>
92
93	<p>
94	The basics of the locking and events model of Swing documents is
95	described in the javadoc of the
96	<a href="http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/text/AbstractDocument.html">javax.swing.text.AbstractDocument</a>
97	class. Netbeans documents use the same patterns and so does the Caret API,
98	because of its tight relation to documents. The fundamentals of the Swing documents
99	locking model are that any changes to a document are done under the
100	document's write lock, the document's listeners are notified synchronously on the
101	mutating thread and have full read access to the document, but can't modify it.
102	</p>
103
104	<ul>
105	<li>
106	Any calls from the infrastructure to <code>EditorCaret</code> to query or
107	mutate its carets, should be called with document's read-lock acquired which
108	will guarantee stability of <code>CaretInfo#getDot()</code> and
109	<code>CaretInfo#getMark()</code> and prevent caret merging as a possible
110	effect of document modifications.
111	</li>
112	<li>
113	When <code>EditorCaret</code> needs to notify its listeners that some
114	of its carets have changed, all the events have to be fired under the
115	layer's document's read lock. Obviously, the listeners are not allowed to
116	modify the document from the event notification methods.
117	</li>
118	</ul>
119
120	<p>
121	The Caret API does not use any special threads and any processing it
122	does is always done on the caller's thread. This means that the above described
123	constraints hardly cause any limitation for practical use.
124	</p>
125
126	<p>
127	The Caret API is generally thread-safe meaning that it can be used
128	simultaneously from multiple threads if not stated otherwise. This doesn't
129	change in any way the rule of acquiring a read lock before calling the API.
130	Swing documents generally allow access for multiple readers that can run
131	concurrently.
132	</p>
133
134	<h3><a name="compatibilty">Backwards compatibility</a></h3>
135	<p>
136	As a technical limitation, <code>EditorCaret</code> has to implement <code>Caret</code>
137	to be able to work with Swings Text API. The <code>Caret</code> interface is not
138	aware of multiple carets and any call to its method will work on the last added
139	caret. Manipulating the caret using <code>setDot(int)</code> or <code>moveDot(int)</code>
140	will retain only the last added caret and move it accordingly.
141	<br>
142	<code>editorTextComponent.getCaret()</code> will now always return <code>EditorCaret</code>
143	instance instead of the original caret implementation <code>org.netbeans.editor.BaseCaret</code>.
144	Since clients were expected to only rely on <code>javax.swing.text.Caret</code> returned type
145	(except internal code in editor modules) they should not be affected by the change
146	since <code>EditorCaret</code> implements <code>Caret</code> interface.
147	<br>
148	With official Caret API the clients can start to cast
149	<code>editorTextComponent.getCaret()</code> to <code>EditorCaret</code> type
150	and use its extended functionality.
151	</p>
152
153	<h3><a name="usecases">Use cases</a></h3>
154	<p>
155	Use cases are shown in javadoc documentation of particular methods.
156	</p>
157	</body>
158	</html>

Lines 58-64 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/EditorPreferencesDefaults.java (-3 / +15 lines)
58	// no-op	58	// no-op
59	}	59	}
60		60
61	public static final String LINE_CARET = "line-caret";	61	/**
		62	* One dot thin line compatible with Swing default caret.
		63	*/
		64	public static final String THIN_LINE_CARET = "thin-line-caret"; // NOI18N
		65
		66	/**
		67	* Two dots line - the default for the editor.
		68	*/
		69	public static final String THICK_LINE_CARET = "thick-line-caret"; // NOI18N
		70
		71	/**
		72	* Rectangle covering character to possibly be overwritten.
		73	*/
62	public static final String BLOCK_CARET = "block-caret";	74	public static final String BLOCK_CARET = "block-caret";
63		75
64	public static final boolean defaultToolbarVisible = true; // Currently unused - see ToggleAction in editor.actions	76	public static final boolean defaultToolbarVisible = true; // Currently unused - see ToggleAction in editor.actions
Lines 100-111 Link Here
100		112
101	public static final boolean defaultExpandTabs = true;	113	public static final boolean defaultExpandTabs = true;
102		114
103	public static final String defaultCaretTypeInsertMode = LINE_CARET;	115	public static final String defaultCaretTypeInsertMode = THICK_LINE_CARET;
104	public static final String defaultCaretTypeOverwriteMode = BLOCK_CARET;	116	public static final String defaultCaretTypeOverwriteMode = BLOCK_CARET;
105	public static final boolean defaultCaretItalicInsertMode = false;	117	public static final boolean defaultCaretItalicInsertMode = false;
106	public static final boolean defaultCaretItalicOverwriteMode = false;	118	public static final boolean defaultCaretItalicOverwriteMode = false;
107	/** @since 1.23 */	119	/** @since 1.23 */
108	public static final int defaultThickCaretWidth = 5;	120	public static final int defaultThickCaretWidth = 2;
109	public static final Acceptor defaultAbbrevExpandAcceptor = AcceptorFactory.WHITESPACE;	121	public static final Acceptor defaultAbbrevExpandAcceptor = AcceptorFactory.WHITESPACE;
110	public static final Acceptor defaultAbbrevAddTypedCharAcceptor = AcceptorFactory.NL;	122	public static final Acceptor defaultAbbrevAddTypedCharAcceptor = AcceptorFactory.NL;
111	public static final Acceptor defaultAbbrevResetAcceptor = AcceptorFactory.NON_JAVA_IDENTIFIER;	123	public static final Acceptor defaultAbbrevResetAcceptor = AcceptorFactory.NON_JAVA_IDENTIFIER;

Lines 65-75 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/RectangularSelectionTransferHandler.java (-1 / +3 lines)
65		65
66	/**	66	/**
67	* Clipboard transfer handler for rectangular selection.	67	* Clipboard transfer handler for rectangular selection.
68	* <br/>	68	* <br>
69	* It overrides the original transfer handler during the rectangular selection.	69	* It overrides the original transfer handler during the rectangular selection.
70	*	70	*
71	* @author Miloslav Metelka	71	* @author Miloslav Metelka
		72	* @deprecated replaced by {@link EditorCaretTransferHandler}, kept in place for BaseCaret
72	*/	73	*/
		74	@Deprecated
73	public class RectangularSelectionTransferHandler extends TransferHandler {	75	public class RectangularSelectionTransferHandler extends TransferHandler {
74		76
75	public static void install(JTextComponent c) {	77	public static void install(JTextComponent c) {

Lines 56-62 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/HighlightsList.java (-3 / +3 lines)
56		56
57	/**	57	/**
58	* List of highlight items. First highlights item starts at startOffset.	58	* List of highlight items. First highlights item starts at startOffset.
59	* <br/>	59	* <br>
60	* GapList is used due to its copyElements() method.	60	* GapList is used due to its copyElements() method.
61	*/	61	*/
62	private HighlightItem[] highlightItems;	62	private HighlightItem[] highlightItems;
Lines 128-134 Link Here
128	* Create attribute set covering {@link #startOffset()} till maxEndOffset	128	* Create attribute set covering {@link #startOffset()} till maxEndOffset
129	* or lower offset if font would differ for the particular attribute set	129	* or lower offset if font would differ for the particular attribute set
130	* of an item.	130	* of an item.
131	* <br/>	131	* <br>
132	* The list must cover cutEndOffset otherwise the behavior is undefined.	132	* The list must cover cutEndOffset otherwise the behavior is undefined.
133	*	133	*
134	* @param defaultFont default font to which the attributes in highlight items	134	* @param defaultFont default font to which the attributes in highlight items
Lines 251-257 Link Here
251		251
252	/**	252	/**
253	* Create attribute set covering single character at {@link #startOffset()}.	253	* Create attribute set covering single character at {@link #startOffset()}.
254	* <br/>	254	* <br>
255	* The list must cover {@link #startOffset()} otherwise the behavior is undefined.	255	* The list must cover {@link #startOffset()} otherwise the behavior is undefined.
256	*	256	*
257	* @return attribute set.	257	* @return attribute set.

Lines 114-120 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/highlighting/ReadOnlyFilesHighlighting.java (-1 / +41 lines)
114	if (LOG.isLoggable(Level.FINE)) {	114	if (LOG.isLoggable(Level.FINE)) {
115	LOG.fine("Highlighting file " + file + " in <" + startOffset + ", " + endOffset + ">"); //NOI18N	115	LOG.fine("Highlighting file " + file + " in <" + startOffset + ", " + endOffset + ">"); //NOI18N
116	}	116	}
117	return new CaretBasedBlockHighlighting.SimpleHighlightsSequence(	117	return new SimpleHighlightsSequence(
118	Math.max(0, startOffset),	118	Math.max(0, startOffset),
119	Math.min(document.getLength(), endOffset),	119	Math.min(document.getLength(), endOffset),
120	attribs);	120	attribs);
Lines 215-218 Link Here
215	}	215	}
216	return null;	216	return null;
217	}	217	}
		218
		219	private static final class SimpleHighlightsSequence implements HighlightsSequence {
		220
		221	private int startOffset;
		222	private int endOffset;
		223	private AttributeSet attribs;
		224
		225	private boolean end = false;
		226
		227	public SimpleHighlightsSequence(int startOffset, int endOffset, AttributeSet attribs) {
		228	this.startOffset = startOffset;
		229	this.endOffset = endOffset;
		230	this.attribs = attribs;
		231	}
		232
		233	@Override
		234	public boolean moveNext() {
		235	if (!end) {
		236	end = true;
		237	return true;
		238	} else {
		239	return false;
		240	}
		241	}
		242
		243	@Override
		244	public int getStartOffset() {
		245	return startOffset;
		246	}
		247
		248	@Override
		249	public int getEndOffset() {
		250	return endOffset;
		251	}
		252
		253	@Override
		254	public AttributeSet getAttributes() {
		255	return attribs;
		256	}
		257	} // End of SimpleHighlightsSequence
218	}	258	}

Lines 72-78 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/DocumentView.java (-4 / +4 lines)
72		72
73	/**	73	/**
74	* View representing the whole document.	74	* View representing the whole document.
75	* <br/>	75	* <br>
76	* It consists of individual paragraph views that typically map to line elements	76	* It consists of individual paragraph views that typically map to line elements
77	* but e.g. code folding may cause multiple line elements correspond to one line view.	77	* but e.g. code folding may cause multiple line elements correspond to one line view.
78	*	78	*
Lines 165-171 Link Here
165		165
166	/**	166	/**
167	* Start offset of the document view after last processed modification.	167	* Start offset of the document view after last processed modification.
168	* <br/>	168	* <br>
169	* This is used during updating of the document view by document modification.	169	* This is used during updating of the document view by document modification.
170	* For undo of removal the position of first paragraph may restore inside the inserted area	170	* For undo of removal the position of first paragraph may restore inside the inserted area
171	* and holding integer offset allows to know the original start offset.	171	* and holding integer offset allows to know the original start offset.
Lines 174-180 Link Here
174		174
175	/**	175	/**
176	* Start offset of the document view.	176	* Start offset of the document view.
177	* <br/>	177	* <br>
178	* This is used during updating of the document view by document modification.	178	* This is used during updating of the document view by document modification.
179	* For undo of removal the position of last paragraph may restore inside the inserted area	179	* For undo of removal the position of last paragraph may restore inside the inserted area
180	* and holding integer offset allows to know the original end offset of the document view.	180	* and holding integer offset allows to know the original end offset of the document view.
Lines 472-478 Link Here
472	/**	472	/**
473	* Get current allocation of the document view by using size from last call	473	* Get current allocation of the document view by using size from last call
474	* to {@link #setSize(float, float)}.	474	* to {@link #setSize(float, float)}.
475	* <br/>	475	* <br>
476	* Returned instance may not be mutated (use getAllocationMutable()).	476	* Returned instance may not be mutated (use getAllocationMutable()).
477	*	477	*
478	* @return current allocation of document view.	478	* @return current allocation of document view.

Lines 63-73 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/DocumentViewChildren.java (-4 / +4 lines)
63		63
64	/**	64	/**
65	* Class that manages children of {@link EditorBoxView}.	65	* Class that manages children of {@link EditorBoxView}.
66	* <br/>	66	* <br>
67	* The class can manage offsets of children in case {@link #rawEndOffsetManaged()}	67	* The class can manage offsets of children in case {@link #rawEndOffsetManaged()}
68	* returns true. In such case each child must properly implement {@link EditorView#getRawEndOffset()}	68	* returns true. In such case each child must properly implement {@link EditorView#getRawEndOffset()}
69	* and the maintained raw offsets are relative to corresponding box view's getStartOffset().	69	* and the maintained raw offsets are relative to corresponding box view's getStartOffset().
70	* <br/>	70	* <br>
71	* Generally children of {@link #ParagraphView} manage their raw end offsets	71	* Generally children of {@link #ParagraphView} manage their raw end offsets
72	* while children of {@link #DocumentView} do not manage them (they use Position objects	72	* while children of {@link #DocumentView} do not manage them (they use Position objects
73	* to manage its start).	73	* to manage its start).
Lines 125-131 Link Here
125		125
126	/**	126	/**
127	* Replace paragraph views inside DocumentView.	127	* Replace paragraph views inside DocumentView.
128	* <br/>	128	* <br>
129	* In case both removeCount == 0 and addedViews is empty this method does not need to be called.	129	* In case both removeCount == 0 and addedViews is empty this method does not need to be called.
130	*	130	*
131	* @param docView	131	* @param docView
Lines 242-248 Link Here
242	/**	242	/**
243	* Get view index of first view that "contains" the offset (starts with it or it's inside)	243	* Get view index of first view that "contains" the offset (starts with it or it's inside)
244	* by examining child views' absolute start offsets.	244	* by examining child views' absolute start offsets.
245	* <br/>	245	* <br>
246	* This is suitable for document view where start offsets of paragraph views	246	* This is suitable for document view where start offsets of paragraph views
247	* are maintained as positions.	247	* are maintained as positions.
248	*	248	*

Lines 197-203 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/DocumentViewOp.java (-3 / +3 lines)
197		197
198	/**	198	/**
199	* Whether the "children" is currently reflecting the document state.	199	* Whether the "children" is currently reflecting the document state.
200	* <br/>	200	* <br>
201	* The children may hold a semi-valid view hierarchy which may still be partly used	201	* The children may hold a semi-valid view hierarchy which may still be partly used
202	* to resolve queries in some cases.	202	* to resolve queries in some cases.
203	*/	203	*/
Lines 322-328 Link Here
322	* Constant retrieved from preferences settings that allows the user to increase/decrease	322	* Constant retrieved from preferences settings that allows the user to increase/decrease
323	* paragraph view's height (which may help for problematic fonts that do not report its height	323	* paragraph view's height (which may help for problematic fonts that do not report its height
324	* correctly for them to fit the line).	324	* correctly for them to fit the line).
325	* <br/>	325	* <br>
326	* By default it's 1.0. All the ascents, descent and leadings of all fonts	326	* By default it's 1.0. All the ascents, descent and leadings of all fonts
327	* are multiplied by the constant.	327	* are multiplied by the constant.
328	*/	328	*/
Lines 1221-1227 Link Here
1221	/**	1221	/**
1222	* Get displayed portion of the component (either viewport.getViewRect())	1222	* Get displayed portion of the component (either viewport.getViewRect())
1223	* or (if viewport is missing) size of the component.	1223	* or (if viewport is missing) size of the component.
1224	* <br/>	1224	* <br>
1225	* Note: The value may be obsolete during paint - clipping bounds may already	1225	* Note: The value may be obsolete during paint - clipping bounds may already
1226	* incorporate a just performed scroll while visibleRect does not yet.	1226	* incorporate a just performed scroll while visibleRect does not yet.
1227	*	1227	*

Lines 60-75 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/EditorView.java (-4 / +4 lines)
60		60
61	/**	61	/**
62	* Base class for views in editor view hierarchy.	62	* Base class for views in editor view hierarchy.
63	* <br/>	63	* <br>
64	* In general there are three types of views:<ul>	64	* In general there are three types of views:<ul>
65	* <li>Document view</li>	65	* <li>Document view</li>
66	* <li>Paragraph views</li>	66	* <li>Paragraph views</li>
67	* <li>Children of paragraph views which include highlights view, newline view and others.</li>	67	* <li>Children of paragraph views which include highlights view, newline view and others.</li>
68	* </ul>	68	* </ul>
69	* <br/>	69	* <br>
70	* Paragraph views have their start offset based over a swing text position. Their end offset	70	* Paragraph views have their start offset based over a swing text position. Their end offset
71	* is based on last child's end offset.	71	* is based on last child's end offset.
72	* <br/>	72	* <br>
73	* Children of paragraph views have their start offset based over a relative distance	73	* Children of paragraph views have their start offset based over a relative distance
74	* to their parent's paragraph view's start offset. Therefore their start offset does not mutate	74	* to their parent's paragraph view's start offset. Therefore their start offset does not mutate
75	* upon modification unless the whole paragraph's start offset mutates.	75	* upon modification unless the whole paragraph's start offset mutates.
Lines 97-103 Link Here
97	/**	97	/**
98	* Get raw end offset of the view which may transform to real end offset	98	* Get raw end offset of the view which may transform to real end offset
99	* when post-processed by parent view.	99	* when post-processed by parent view.
100	* <br/>	100	* <br>
101	* <b>Note:</b> Typical clients should NOT call this method (they should call	101	* <b>Note:</b> Typical clients should NOT call this method (they should call
102	* {@link #getEndOffset()} method instead).	102	* {@link #getEndOffset()} method instead).
103	*	103	*

Lines 55-68 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/EditorViewFactory.java (-13 / +13 lines)
55		55
56	/**	56	/**
57	* SPI class allowing to produce views.	57	* SPI class allowing to produce views.
58	* <br/>	58	* <br>
59	* There are two main factories: for folds and for highlights (the default one).	59	* There are two main factories: for folds and for highlights (the default one).
60	* The factories have a priority and factory with highest priority	60	* The factories have a priority and factory with highest priority
61	* will always "win" in terms that its view will surely be created as desired.	61	* will always "win" in terms that its view will surely be created as desired.
62	* Factories at lower levels will receive a limitOffset into createView()	62	* Factories at lower levels will receive a limitOffset into createView()
63	* being a start offset of the view produced by a higher level factory.	63	* being a start offset of the view produced by a higher level factory.
64	* The factory may decide whether it will create view with limiting offset or not.	64	* The factory may decide whether it will create view with limiting offset or not.
65	* <br/>	65	* <br>
66	* Factory generally operates in two modes:<ul>	66	* Factory generally operates in two modes:<ul>
67	* <li>Regular mode when the factory produces views</li>	67	* <li>Regular mode when the factory produces views</li>
68	* <li>Offset mode when the factory only returns bounds of the produced views	68	* <li>Offset mode when the factory only returns bounds of the produced views
Lines 152-158 Link Here
152	/**	152	/**
153	* Notify next offset area where views will be created in case endCreationOffset	153	* Notify next offset area where views will be created in case endCreationOffset
154	* in {@link #restart(int, int)} was exceeded.	154	* in {@link #restart(int, int)} was exceeded.
155	* <br/>	155	* <br>
156	* This method may be called multiple times if views building still does not match	156	* This method may be called multiple times if views building still does not match
157	* original views boundaries.	157	* original views boundaries.
158	*	158	*
Lines 165-171 Link Here
165		165
166	/**	166	/**
167	* Return starting offset of the next view to be produced by this view factory.	167	* Return starting offset of the next view to be produced by this view factory.
168	* <br/>	168	* <br>
169	* This method gets called after restarting of this view factory	169	* This method gets called after restarting of this view factory
170	* (with a <code>startOffset</code> parameter passed to {@link #restart(int)})	170	* (with a <code>startOffset</code> parameter passed to {@link #restart(int)})
171	* and also after any of the registered view factories created a view	171	* and also after any of the registered view factories created a view
Lines 181-187 Link Here
181	* Create a view at the given offset. The view factory must determine	181	* Create a view at the given offset. The view factory must determine
182	* the appropriate end offset of the produced view and set its length	182	* the appropriate end offset of the produced view and set its length
183	* returned by {@link EditorView#getLength()} appropriately.	183	* returned by {@link EditorView#getLength()} appropriately.
184	* <br/>	184	* <br>
185	* This method is only called if the factory is in view-producing mode	185	* This method is only called if the factory is in view-producing mode
186	* (its {@link #viewEndOffset(startOffset, limitOffset)} is not called).	186	* (its {@link #viewEndOffset(startOffset, limitOffset)} is not called).
187	*	187	*
Lines 197-206 Link Here
197	* @param origView original view located at the given position (it may have a different	197	* @param origView original view located at the given position (it may have a different
198	* physical offset due to just performed modification but it corresponds to the same text	198	* physical offset due to just performed modification but it corresponds to the same text
199	* in the document). It may be null if there is no view to reuse.	199	* in the document). It may be null if there is no view to reuse.
200	* <br/>	200	* <br>
201	* The factory may not return the given instance but it may reuse an arbitrary information	201	* The factory may not return the given instance but it may reuse an arbitrary information
202	* from it.	202	* from it.
203	* <br/>	203	* <br>
204	* For example for text layout reuse the highlights view factory will first check if the view	204	* For example for text layout reuse the highlights view factory will first check if the view
205	* is non-null and matches views produced by it then it will check	205	* is non-null and matches views produced by it then it will check
206	* if the new view has same length as the original one and that the view attributes	206	* if the new view has same length as the original one and that the view attributes
Lines 222-228 Link Here
222		222
223	/**	223	/**
224	* Return to-be-created view's end offset.	224	* Return to-be-created view's end offset.
225	* <br/>	225	* <br>
226	* This method is only called when createViews parameter	226	* This method is only called when createViews parameter
227	* in {@link #restart(int, int, boolean)} is false. In such mode no physical views	227	* in {@link #restart(int, int, boolean)} is false. In such mode no physical views
228	* are created and only view boundaries of potential views are being determined.	228	* are created and only view boundaries of potential views are being determined.
Lines 240-246 Link Here
240		240
241	/**	241	/**
242	* Finish this round of views creation.	242	* Finish this round of views creation.
243	* <br/>	243	* <br>
244	* {@link #restart(int) } may be called subsequently to init a new round	244	* {@link #restart(int) } may be called subsequently to init a new round
245	* of views creation.	245	* of views creation.
246	*/	246	*/
Lines 263-269 Link Here
263		263
264	/**	264	/**
265	* Schedule repaint request on the view hierarchy.	265	* Schedule repaint request on the view hierarchy.
266	* <br/>	266	* <br>
267	* Document must be read-locked prior calling this method.	267	* Document must be read-locked prior calling this method.
268	*	268	*
269	* @param startOffset	269	* @param startOffset
Lines 277-288 Link Here
277	* Signal that this view factory is no longer able to produce	277	* Signal that this view factory is no longer able to produce
278	* valid views due to some serious changes that it processes	278	* valid views due to some serious changes that it processes
279	* (for example highlights change for HighlightsViewFactory).	279	* (for example highlights change for HighlightsViewFactory).
280	* <br/>	280	* <br>
281	* View creation may be stopped immediately by the caller and restarted to get	281	* View creation may be stopped immediately by the caller and restarted to get
282	* the correct views. However if it would fail periodically the caller may decide	282	* the correct views. However if it would fail periodically the caller may decide
283	* to continue the creation to have at least some views. In both cases	283	* to continue the creation to have at least some views. In both cases
284	* the view factory should be able to continue working normally.	284	* the view factory should be able to continue working normally.
285	* <br/>	285	* <br>
286	* This method can be called from any thread.	286	* This method can be called from any thread.
287	*/	287	*/
288	protected final void notifyStaleCreation() {	288	protected final void notifyStaleCreation() {
Lines 303-309 Link Here
303	/**	303	/**
304	* Notification that this factory is no longer being used so it should	304	* Notification that this factory is no longer being used so it should
305	* release its resources - for example detach all listeners.	305	* release its resources - for example detach all listeners.
306	* <br/>	306	* <br>
307	* It's called upon document view receives setParent(null) which typically signals	307	* It's called upon document view receives setParent(null) which typically signals
308	* that a new document view will be created for the particular editor pane.	308	* that a new document view will be created for the particular editor pane.
309	*/	309	*/

Lines 44-53 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/LockedViewHierarchy.java (-10 / +10 lines)
44		44
45	/**	45	/**
46	* Locked view hierarchy as result of {@link ViewHierarchy#lock() }.	46	* Locked view hierarchy as result of {@link ViewHierarchy#lock() }.
47	* <br/>	47	* <br>
48	* Underlying document of the view hierarchy's text component must be	48	* Underlying document of the view hierarchy's text component must be
49	* read-locked to guarantee stability of offsets passed to methods of this class.	49	* read-locked to guarantee stability of offsets passed to methods of this class.
50	* <br/>	50	* <br>
51	* If editor view hierarchy is not installed into text component	51	* If editor view hierarchy is not installed into text component
52	* (text component's root view is not an instance of DocumentView)	52	* (text component's root view is not an instance of DocumentView)
53	* the methods return default values as described in their documentation.	53	* the methods return default values as described in their documentation.
Lines 82-88 Link Here
82		82
83	/**	83	/**
84	* Get text component that this view hierarchy is associated with.	84	* Get text component that this view hierarchy is associated with.
85	* <br/>	85	* <br>
86	*	86	*
87	* @return non-null text component.	87	* @return non-null text component.
88	*/	88	*/
Lines 93-102 Link Here
93		93
94	/**	94	/**
95	* Get y coordinate of a visual row that corresponds to given offset.	95	* Get y coordinate of a visual row that corresponds to given offset.
96	* <br/>	96	* <br>
97	* Underlying document of the view hierarchy's text component should be read-locked	97	* Underlying document of the view hierarchy's text component should be read-locked
98	* to guarantee stability of passed offset.	98	* to guarantee stability of passed offset.
99	* <br/>	99	* <br>
100	* If editor view hierarchy is not installed into text component this method	100	* If editor view hierarchy is not installed into text component this method
101	* delegates to {@link JTextComponent#modelToView(int) }.	101	* delegates to {@link JTextComponent#modelToView(int) }.
102	*	102	*
Lines 197-205 Link Here
197		197
198	/**	198	/**
199	* Get height of a visual row of text.	199	* Get height of a visual row of text.
200	* <br/>	200	* <br>
201	* For wrapped lines (containing multiple visual rows) this is height of a single visual row.	201	* For wrapped lines (containing multiple visual rows) this is height of a single visual row.
202	* <br/>	202	* <br>
203	* Current editor view hierarchy implementation uses uniform row height for all the rows.	203	* Current editor view hierarchy implementation uses uniform row height for all the rows.
204	*	204	*
205	* @return height of a visual row.	205	* @return height of a visual row.
Lines 211-217 Link Here
211		211
212	/**	212	/**
213	* Get width of a typical character of a default font used by view hierarchy.	213	* Get width of a typical character of a default font used by view hierarchy.
214	* <br/>	214	* <br>
215	* In case mixed fonts (non-monospaced) are used this gives a little value	215	* In case mixed fonts (non-monospaced) are used this gives a little value
216	* but certain tools such as rectangular selection may use this value.	216	* but certain tools such as rectangular selection may use this value.
217	*/	217	*/
Lines 222-231 Link Here
222		222
223	/**	223	/**
224	* Return true if the view hierarchy is actively managing its contained views.	224	* Return true if the view hierarchy is actively managing its contained views.
225	* <br/>	225	* <br>
226	* Infrastructure may turn the view hierarchy inactive in case there are many	226	* Infrastructure may turn the view hierarchy inactive in case there are many
227	* edits performed in the document (mainly during code reformatting).	227	* edits performed in the document (mainly during code reformatting).
228	* <br/>	228	* <br>
229	* Also the view hierarchy is not active when a document modification was performed	229	* Also the view hierarchy is not active when a document modification was performed
230	* but the view hierarchy did not update itself accordingly yet (its DocumentListener	230	* but the view hierarchy did not update itself accordingly yet (its DocumentListener
231	* was not called yet).	231	* was not called yet).

Lines 66-74 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ParagraphView.java (-8 / +8 lines)
66	/**	66	/**
67	* View of a line typically spans a single textual line of a corresponding document	67	* View of a line typically spans a single textual line of a corresponding document
68	* but it may span several lines if it contains a fold view for collapsed code fold.	68	* but it may span several lines if it contains a fold view for collapsed code fold.
69	* <br/>	69	* <br>
70	* It is capable to do a word-wrapping.	70	* It is capable to do a word-wrapping.
71	* <br/>	71	* <br>
72	* It is not tight to any element (its element is null).	72	* It is not tight to any element (its element is null).
73	* Its contained views may span multiple lines (e.g. in case of code folding).	73	* Its contained views may span multiple lines (e.g. in case of code folding).
74	*	74	*
Lines 82-96 Link Here
82		82
83	/**	83	/**
84	* Whether children are non-null and contain up-to-date views.	84	* Whether children are non-null and contain up-to-date views.
85	* <br/>	85	* <br>
86	* If false then either children == null (children not computed yet)	86	* If false then either children == null (children not computed yet)
87	* or some (or all) child views are marked as invalid (they should be recomputed	87	* or some (or all) child views are marked as invalid (they should be recomputed
88	* since some highlight factories reported particular text span as changed).	88	* since some highlight factories reported particular text span as changed).
89	* <br/>	89	* <br>
90	* The local offset range of invalid children can be obtained (if children != null)	90	* The local offset range of invalid children can be obtained (if children != null)
91	* by children.getStartInvalidChildrenLocalOffset()	91	* by children.getStartInvalidChildrenLocalOffset()
92	* and children.getEndInvalidChildrenLocalOffset()).	92	* and children.getEndInvalidChildrenLocalOffset()).
93	* <br/>	93	* <br>
94	* When all children are dropped (children == null) then LAYOUT_VALID is cleared too.	94	* When all children are dropped (children == null) then LAYOUT_VALID is cleared too.
95	*/	95	*/
96	private static final int CHILDREN_VALID = 1;	96	private static final int CHILDREN_VALID = 1;
Lines 98-108 Link Here
98	/**	98	/**
99	* Whether layout information is valid for this paragraph view	99	* Whether layout information is valid for this paragraph view
100	* (note that layout may be valid even when some children were marked as invalid).	100	* (note that layout may be valid even when some children were marked as invalid).
101	* <br/>	101	* <br>
102	* Since span of child views is initialized upon views replace	102	* Since span of child views is initialized upon views replace
103	* the layout updating means checking whether the pView is too wide	103	* the layout updating means checking whether the pView is too wide
104	* and thus needs to compute wrap lines and building of those wrap lines.	104	* and thus needs to compute wrap lines and building of those wrap lines.
105	* <br/>	105	* <br>
106	* Whether particular operation (mainly model-to-view, view-to-model and painting operations)	106	* Whether particular operation (mainly model-to-view, view-to-model and painting operations)
107	* needs an up-to-date layout is upon decision of each operation	107	* needs an up-to-date layout is upon decision of each operation
108	* (done in DocumentViewChildren).	108	* (done in DocumentViewChildren).
Lines 255-261 Link Here
255		255
256	/**	256	/**
257	* Check whether layout must be updated.	257	* Check whether layout must be updated.
258	* <br/>	258	* <br>
259	* It should only be called when children != null.	259	* It should only be called when children != null.
260	*	260	*
261	* @return true if layout update was necessary or false otherwise.	261	* @return true if layout update was necessary or false otherwise.

Lines 58-64 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ParagraphViewDescriptor.java (-5 / +5 lines)
58		58
59	/**	59	/**
60	* Get start offset of the paragraph view represented by this descriptor.	60	* Get start offset of the paragraph view represented by this descriptor.
61	* <br/>	61	* <br>
62	* When a LockedViewHierarchy that provided this paragraph view descriptor	62	* When a LockedViewHierarchy that provided this paragraph view descriptor
63	* is unlocked then operation of this method is undefined.	63	* is unlocked then operation of this method is undefined.
64	*	64	*
Lines 70-76 Link Here
70		70
71	/**	71	/**
72	* Get textual length of the paragraph view represented by this descriptor.	72	* Get textual length of the paragraph view represented by this descriptor.
73	* <br/>	73	* <br>
74	* When a LockedViewHierarchy that provided this paragraph view descriptor	74	* When a LockedViewHierarchy that provided this paragraph view descriptor
75	* is unlocked then operation of this method is undefined.	75	* is unlocked then operation of this method is undefined.
76	*	76	*
Lines 82-88 Link Here
82		82
83	/**	83	/**
84	* Get visual allocation of the whole paragraph view (represented by this descriptor).	84	* Get visual allocation of the whole paragraph view (represented by this descriptor).
85	* <br/>	85	* <br>
86	* When a LockedViewHierarchy that provided this paragraph view descriptor	86	* When a LockedViewHierarchy that provided this paragraph view descriptor
87	* is unlocked then operation of this method is undefined.	87	* is unlocked then operation of this method is undefined.
88	*	88	*
Lines 95-105 Link Here
95	/**	95	/**
96	* Get ascent (useful for text rendering using a particular font)	96	* Get ascent (useful for text rendering using a particular font)
97	* of the paragraph view represented by this descriptor.	97	* of the paragraph view represented by this descriptor.
98	* <br/>	98	* <br>
99	* This method is useful when a tool (such as a side bar performing rendering of a line	99	* This method is useful when a tool (such as a side bar performing rendering of a line
100	* number) wants to render a text that should vertically match the text	100	* number) wants to render a text that should vertically match the text
101	* rendered by the paragraph view.	101	* rendered by the paragraph view.
102	* <br/>	102	* <br>
103	* When a LockedViewHierarchy that provided this paragraph view descriptor	103	* When a LockedViewHierarchy that provided this paragraph view descriptor
104	* is unlocked then operation of this method is undefined.	104	* is unlocked then operation of this method is undefined.
105	*	105	*

Lines 58-70 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/TabView.java (-3 / +3 lines)
58		58
59	/**	59	/**
60	* View of (possibly multiple) '\t' characters.	60	* View of (possibly multiple) '\t' characters.
61	* <br/>	61	* <br>
62	* It needs to be measured specially - it needs to get visually aligned to multiples	62	* It needs to be measured specially - it needs to get visually aligned to multiples
63	* of TAB_SIZE char width.	63	* of TAB_SIZE char width.
64	* <br/>	64	* <br>
65	* Note that the view does not hold a last tab expander itself by itself so if tab expander	65	* Note that the view does not hold a last tab expander itself by itself so if tab expander
66	* changes the view does not call a preference change.	66	* changes the view does not call a preference change.
67	* <br/>	67	* <br>
68	* Due to line wrap the view cannot base its tab-stop calculations upon alloc.getX().	68	* Due to line wrap the view cannot base its tab-stop calculations upon alloc.getX().
69	*	69	*
70	*	70	*

Lines 117-123 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ViewBuilder.java (-3 / +3 lines)
117		117
118	/**	118	/**
119	* Start offset of a before-modOffset local view that may be reused.	119	* Start offset of a before-modOffset local view that may be reused.
120	* <br/>	120	* <br>
121	* If set to Integer.MAX_VALUE then no more before-modOffset reusing possible	121	* If set to Integer.MAX_VALUE then no more before-modOffset reusing possible
122	* or bmReusePView has no children.	122	* or bmReusePView has no children.
123	*/	123	*/
Lines 136-142 Link Here
136	/**	136	/**
137	* Start offset of an above-modOffset local view that may be reused	137	* Start offset of an above-modOffset local view that may be reused
138	* (or if no local views exist inside	138	* (or if no local views exist inside
139	* <br/>	139	* <br>
140	* If set to Integer.MAX_VALUE then no more before-modOffset reusing possible	140	* If set to Integer.MAX_VALUE then no more before-modOffset reusing possible
141	* or bmReusePView has no children.	141	* or bmReusePView has no children.
142	*/	142	*/
Lines 186-192 Link Here
186		186
187	/**	187	/**
188	* Actual local views replace inside currently served paragraph view.	188	* Actual local views replace inside currently served paragraph view.
189	* <br/>	189	* <br>
190	* It may be equal to firstReplace when replacing inside firstly updated paragraph view.	190	* It may be equal to firstReplace when replacing inside firstly updated paragraph view.
191	*/	191	*/
192	private ViewReplace<ParagraphView,EditorView> localReplace;	192	private ViewReplace<ParagraphView,EditorView> localReplace;

Lines 52-61 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ViewChildren.java (-3 / +3 lines)
52		52
53	/**	53	/**
54	* Class that manages children of either DocumentView or ParagraphView.	54	* Class that manages children of either DocumentView or ParagraphView.
55	* <br/>	55	* <br>
56	* For document view the class manages visual spans (end visual offsets).	56	* For document view the class manages visual spans (end visual offsets).
57	* For paragraphs the class manages end offsets of children as well as their end visual offsets.	57	* For paragraphs the class manages end offsets of children as well as their end visual offsets.
58	* <br/>	58	* <br>
59	* Generally children of {@link #ParagraphView} manage their raw end offsets	59	* Generally children of {@link #ParagraphView} manage their raw end offsets
60	* while children of {@link #DocumentView} do not manage them (they use Position objects	60	* while children of {@link #DocumentView} do not manage them (they use Position objects
61	* to manage its start).	61	* to manage its start).
Lines 95-101 Link Here
95	/**	95	/**
96	* Get view index of first view that "contains" the given offset (starts with it or it's inside)	96	* Get view index of first view that "contains" the given offset (starts with it or it's inside)
97	* by examining child views' raw end offsets.	97	* by examining child views' raw end offsets.
98	* <br/>	98	* <br>
99	* This is suitable for paragraph view which manages its views' raw end offsets.	99	* This is suitable for paragraph view which manages its views' raw end offsets.
100	*	100	*
101	* @param offset offset to search for.	101	* @param offset offset to search for.

Lines 42-50 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/view/ViewHierarchy.java (-6 / +6 lines)
42		42
43	/**	43	/**
44	* View hierarchy associated with a particular text component (for its whole lifetime).	44	* View hierarchy associated with a particular text component (for its whole lifetime).
45	* <br/>	45	* <br>
46	* View hierarchy needs to be locked before doing most operations - see {@link #lock() }.	46	* View hierarchy needs to be locked before doing most operations - see {@link #lock() }.
47	* <br/>	47	* <br>
48	* If editor view hierarchy is currently not installed into particular text component	48	* If editor view hierarchy is currently not installed into particular text component
49	* (text component's root view is not an instance of DocumentView)	49	* (text component's root view is not an instance of DocumentView)
50	* the methods (in LockedViewHierarchy) return default values as described in their documentation.	50	* the methods (in LockedViewHierarchy) return default values as described in their documentation.
Lines 76-82 Link Here
76		76
77	/**	77	/**
78	* Get text component that this view hierarchy is associated with.	78	* Get text component that this view hierarchy is associated with.
79	* <br/>	79	* <br>
80	*	80	*
81	* @return non-null text component.	81	* @return non-null text component.
82	*/	82	*/
Lines 86-95 Link Here
86		86
87	/**	87	/**
88	* Lock view hierarchy in order to perform operations described in {@link LockedViewHierarchy }.	88	* Lock view hierarchy in order to perform operations described in {@link LockedViewHierarchy }.
89	* <br/>	89	* <br>
90	* Underlying document of the view hierarchy's text component must be read-locked	90	* Underlying document of the view hierarchy's text component must be read-locked
91	* to guarantee stability of offsets passed to methods of LockedViewHierarchy.	91	* to guarantee stability of offsets passed to methods of LockedViewHierarchy.
92	* <br/>	92	* <br>
93	* Code example:<code>	93	* Code example:<code>
94	* // Possible textComponent.getDocument() read-locking	94	* // Possible textComponent.getDocument() read-locking
95	* LockedViewHierarchy lvh = ViewHierarchy.get(textComponent).lock();	95	* LockedViewHierarchy lvh = ViewHierarchy.get(textComponent).lock();
Lines 109-115 Link Here
109		109
110	/**	110	/**
111	* Add listener for view hierarchy changes.	111	* Add listener for view hierarchy changes.
112	* <br/>	112	* <br>
113	* Listener will be notified on a locked view hierarchy.	113	* Listener will be notified on a locked view hierarchy.
114	*	114	*
115	* @param l non-null listener.	115	* @param l non-null listener.