Attachment #92739 for bug #97517

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





import java.awt.AWTKeyStroke;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.KeyboardFocusManager;
import java.awt.event.ActionEvent;
import java.lang.reflect.InvocationTargetException;

import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionListener;
import java.io.IOException;
import javax.swing.text.StyledDocument;
import org.netbeans.api.debugger.Session;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.ext.ExtCaret;
import org.netbeans.spi.debugger.jpda.EditorContext;
import org.netbeans.spi.debugger.ui.EditorContextDispatcher;
import org.openide.ErrorManager;

                if (eui == null) {
                    return ;
                }
                editorPane.putClientProperty(
                    "HighlightsLayerExcludes", //NOI18N
                    "^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
                );
                // Do not draw text limit line
                try {
                    java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N

Lines 85-90 Link Here

(-)a/editor.lib/src/org/netbeans/editor/ActionFactory.java (-1 / +2 lines)
85	import org.netbeans.api.progress.ProgressUtils;	85	import org.netbeans.api.progress.ProgressUtils;
86	import org.netbeans.modules.editor.lib2.search.EditorFindSupport;	86	import org.netbeans.modules.editor.lib2.search.EditorFindSupport;
87	import org.netbeans.lib.editor.util.swing.DocumentUtilities;	87	import org.netbeans.lib.editor.util.swing.DocumentUtilities;
		88	import org.netbeans.lib.editor.view.GapBoxView;
88	import org.openide.util.NbBundle;	89	import org.openide.util.NbBundle;
89	import org.openide.util.WeakListeners;	90	import org.openide.util.WeakListeners;
90	import org.openide.util.actions.Presenter;	91	import org.openide.util.actions.Presenter;
Lines 2281-2287 Link Here
2281	}	2282	}
2282		2283
2283	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2284	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2284	DrawEngineDocView rootView = (DrawEngineDocView)Utilities.getDocumentView(target);	2285	GapBoxView rootView = (GapBoxView)Utilities.getDocumentView(target);
2285	AbstractDocument adoc = (AbstractDocument)target.getDocument();	2286	AbstractDocument adoc = (AbstractDocument)target.getDocument();
2286		2287
2287	// Dump fold hierarchy	2288	// Dump fold hierarchy

Lines 64-69 Link Here

(-)a/editor.lib/src/org/netbeans/editor/Annotations.java (-11 / +4 lines)
64	import javax.swing.JMenuItem;	64	import javax.swing.JMenuItem;
65	import javax.swing.SwingUtilities;	65	import javax.swing.SwingUtilities;
66	import org.netbeans.editor.ext.ExtKit;	66	import org.netbeans.editor.ext.ExtKit;
		67	import org.netbeans.modules.editor.lib.drawing.ChainDrawMark;
		68	import org.netbeans.modules.editor.lib.drawing.MarkChain;
67	import org.openide.awt.Actions;	69	import org.openide.awt.Actions;
68	import org.openide.awt.DynamicMenuContent;	70	import org.openide.awt.DynamicMenuContent;
69	import org.openide.util.ContextAwareAction;	71	import org.openide.util.ContextAwareAction;
Lines 178-192 Link Here
178		180
179	}	181	}
180		182
181	/** Finds the drawing layer for annotations.
182	* @return <code>null</code>
183	* @deprecated Please use Highlighting SPI instead, for details see
184	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
185	*/
186	public DrawLayerFactory.AnnotationLayer getLayer() {
187	return null;
188	}
189
190	/** Add annotation */	183	/** Add annotation */
191	public void addAnnotation(AnnotationDesc anno) {	184	public void addAnnotation(AnnotationDesc anno) {
192		185
Lines 241-247 Link Here
241	+ ", docLen=" + doc.getLength()); // NOI18N	234	+ ", docLen=" + doc.getLength()); // NOI18N
242	}	235	}
243	// attach created mark to annotation	236	// attach created mark to annotation
244	MarkFactory.ChainDrawMark annoMark = chain.getAddedMark();	237	ChainDrawMark annoMark = chain.getAddedMark();
245	if (annoMark == null) {	238	if (annoMark == null) {
246	throw new NullPointerException();	239	throw new NullPointerException();
247	}	240	}
Lines 320-326 Link Here
320	int line;	313	int line;
321	synchronized (lineAnnotationsArray) {	314	synchronized (lineAnnotationsArray) {
322	// find LineAnnotations for the mark	315	// find LineAnnotations for the mark
323	MarkFactory.ChainDrawMark annoMark = (MarkFactory.ChainDrawMark)anno.getMark();	316	ChainDrawMark annoMark = (ChainDrawMark)anno.getMark();
324	if (annoMark == null) {	317	if (annoMark == null) {
325	// Already removed? See #116955	318	// Already removed? See #116955
326	return;	319	return;

Lines 97-102 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseDocument.java (-36 / +19 lines)
97	import org.netbeans.modules.editor.lib.FormatterOverride;	97	import org.netbeans.modules.editor.lib.FormatterOverride;
98	import org.netbeans.modules.editor.lib.TrailingWhitespaceRemove;	98	import org.netbeans.modules.editor.lib.TrailingWhitespaceRemove;
99	import org.netbeans.modules.editor.lib.SettingsConversions;	99	import org.netbeans.modules.editor.lib.SettingsConversions;
		100	import org.netbeans.modules.editor.lib.drawing.DrawEngine;
		101	import org.netbeans.modules.editor.lib.drawing.DrawGraphics;
		102	import org.netbeans.modules.editor.lib.impl.MarkVector;
		103	import org.netbeans.modules.editor.lib.impl.MultiMark;
100	import org.openide.util.Lookup;	104	import org.openide.util.Lookup;
101	import org.openide.util.RequestProcessor;	105	import org.openide.util.RequestProcessor;
102	import org.openide.util.RequestProcessor.Task;	106	import org.openide.util.RequestProcessor.Task;
Lines 257-265 Link Here
257		261
258	private SyntaxSupport syntaxSupport;	262	private SyntaxSupport syntaxSupport;
259		263
260	/** Layer list for document level layers */
261	private DrawLayerList drawLayerList = new DrawLayerList();
262
263	/** Reset merging next created undoable edit to the last one. */	264	/** Reset merging next created undoable edit to the last one. */
264	boolean undoMergeReset;	265	boolean undoMergeReset;
265		266
Lines 2014-2051 Link Here
2014	return modified;	2015	return modified;
2015	}	2016	}
2016		2017
2017	/**
2018	* Get the layer with the specified name. Using of <code>DrawLayer</code>s
2019	* has been deprecated.
2020	*
2021	* @deprecated Please use Highlighting SPI instead, for details see
2022	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
2023	*/
2024	public DrawLayer findLayer(String layerName) {
2025	return drawLayerList.findLayer(layerName);
2026	}
2027
2028	/**
2029	* Using of <code>DrawLayer</code>s has been deprecated.
2030	*
2031	* @deprecated Please use Highlighting SPI instead, for details see
2032	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
2033	*/
2034	public boolean addLayer(DrawLayer layer, int visibility) {
2035	if (drawLayerList.add(layer, visibility)) {
2036	BaseDocumentEvent evt = getDocumentEvent(0, 0, DocumentEvent.EventType.CHANGE, null);
2037	evt.addEdit(new BaseDocumentEvent.DrawLayerChange(layer.getName(), visibility));
2038	fireChangedUpdate(evt);
2039	return true;
2040	} else {
2041	return false;
2042	}
2043	}
2044
2045	final DrawLayerList getDrawLayerList() {
2046	return drawLayerList;
2047	}
2048
2049	private LineRootElement getLineRootElement() {	2018	private LineRootElement getLineRootElement() {
2050	return lineRootElement;	2019	return lineRootElement;
2051	}	2020	}
Lines 2445-2454 Link Here
2445	private static final class Accessor extends EditorPackageAccessor {	2414	private static final class Accessor extends EditorPackageAccessor {
2446		2415
2447	@Override	2416	@Override
2448	public CompoundEdit markAtomicEditsNonSignificant(BaseDocument doc) {	2417	public CompoundEdit BaseDocument_markAtomicEditsNonSignificant(BaseDocument doc) {
2449	return doc.markAtomicEditsNonSignificant();	2418	return doc.markAtomicEditsNonSignificant();
2450	}	2419	}
2451		2420
		2421	@Override
		2422	public MarkVector BaseDocument_getMarksStorage(BaseDocument doc) {
		2423	return doc.marksStorage;
		2424	}
		2425
		2426	@Override
		2427	public Mark BaseDocument_getMark(BaseDocument doc, MultiMark multiMark) {
		2428	return doc.marks.get(multiMark);
		2429	}
		2430
		2431	@Override
		2432	public void Mark_insert(Mark mark, BaseDocument doc, int pos) throws InvalidMarkException, BadLocationException {
		2433	mark.insert(doc, pos);
		2434	}
2452	}	2435	}
2453		2436
2454	// XXX: the same as the one in CloneableEditorSupport	2437	// XXX: the same as the one in CloneableEditorSupport




import javax.swing.event.DocumentEvent;
import javax.swing.text.AttributeSet;
import javax.swing.undo.UndoableEdit;
import javax.swing.undo.AbstractUndoableEdit;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.CannotRedoException;


        return getFixLineSyntaxState().getSyntaxUpdateTokenList();
    }
    
    public String getDrawLayerName() {
        if (getType() != DocumentEvent.EventType.CHANGE) {
            throw new IllegalStateException("Can be called for CHANGE events only."); // NOI18N
        }

        DrawLayerChange dlc = (DrawLayerChange)findEdit(DrawLayerChange.class);

        return (dlc != null) ? dlc.getDrawLayerName() : null;
    }

    public int getDrawLayerVisibility() {
        if (getType() != DocumentEvent.EventType.CHANGE) {
            throw new IllegalStateException("Can be called for CHANGE events only."); // NOI18N
        }

        DrawLayerChange dlc = (DrawLayerChange)findEdit(DrawLayerChange.class);

        return (dlc != null) ? dlc.getDrawLayerVisibility() : -1;
    }

    /** Whether this event is being fired because it's being undone. */
    public boolean isInUndo() {
        return inUndo;

        return inRedo;
    }

    public @Override void undo() throws CannotUndoException {
        BaseDocument doc = (BaseDocument)getDocument();
        doc.incrementDocVersion();


        inUndo = false;
    }

    public @Override void redo() throws CannotRedoException {
        BaseDocument doc = (BaseDocument)getDocument();
        doc.incrementDocVersion();
        

        inRedo = false;
    }

    public @Override boolean addEdit(UndoableEdit anEdit) {
        // Super of addEdit()

        // if the number of changes gets too great, start using

        }
    }

    public @Override boolean canUndo() {
        // Super of canUndo
	return !inProgress2 && alive2 && hasBeenDone2
        // End super of canUndo

     * 
     * @see	#isInProgress
     */
    public @Override boolean canRedo() {
        // Super of canRedo
	return !inProgress2 && alive2 && !hasBeenDone2;
        // End super of canRedo
    }

    public @Override boolean isInProgress() {
        // Super of isInProgress()
        return inProgress2;
        // End super of isInProgress()
    }

    public @Override String getUndoPresentationName() {
        return ""; //NOI18N
    }

    public @Override String getRedoPresentationName() {
        return ""; //NOI18N
    }

    /** Returns true if this event can be merged by the previous

    * parts (words) and undoing/redoing them at once.
    * This method returns true whether 
    */
    public @Override boolean replaceEdit(UndoableEdit anEdit) {
        BaseDocument doc = (BaseDocument)getDocument();
        if (anEdit instanceof BaseDocument.AtomicCompoundEdit) {
            BaseDocument.AtomicCompoundEdit compEdit

        return false;
    }

    public @Override void die() {
        // Super of die()
	int size = edits.size();
	for (int i = size-1; i >= 0; i--)

        }
    }

    public @Override void end() {
        // Super of end()
	inProgress2 = false;
        // End super of end()
    }

    public @Override DocumentEvent.ElementChange getChange(Element elem) {
        // Super of getChange()
        if (changeLookup2 != null) {
            return (DocumentEvent.ElementChange) changeLookup2.get(elem);

    }


    public @Override String toString() {
        return System.identityHashCode(this) + " " + super.toString() // NOI18N
               + ", type=" + getType() // NOI18N
               + ((getType() != DocumentEvent.EventType.CHANGE)
                  ? ("text='" + getText() + "'") : ""); // NOI18N
    }

    /** Edit describing the change of the document draw-layers */
    static class DrawLayerChange extends AbstractUndoableEdit {

        String drawLayerName;

        int drawLayerVisibility;

        DrawLayerChange(String drawLayerName, int drawLayerVisibility) {
            this.drawLayerName = drawLayerName;
            this.drawLayerVisibility = drawLayerVisibility;
        }

        public String getDrawLayerName() {
            return drawLayerName;
        }

        public int getDrawLayerVisibility() {
            return drawLayerVisibility;
        }

    }
    
}

Lines 43-49 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseTextUI.java (-16 / +10 lines)
43		43
44	import java.awt.*;	44	import java.awt.*;
45	import java.awt.event.ActionEvent;	45	import java.awt.event.ActionEvent;
46	import java.beans.Customizer;
47	import java.beans.PropertyChangeListener;	46	import java.beans.PropertyChangeListener;
48	import java.beans.PropertyChangeEvent;	47	import java.beans.PropertyChangeEvent;
49	import java.util.ArrayList;	48	import java.util.ArrayList;
Lines 67-75 Link Here
67	import org.netbeans.api.editor.settings.SimpleValueNames;	66	import org.netbeans.api.editor.settings.SimpleValueNames;
68	import org.netbeans.modules.editor.lib2.EditorApiPackageAccessor;	67	import org.netbeans.modules.editor.lib2.EditorApiPackageAccessor;
69	import org.netbeans.editor.view.spi.LockView;	68	import org.netbeans.editor.view.spi.LockView;
		69	import org.netbeans.lib.editor.view.GapDocumentView;
70	import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;	70	import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
71	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;	71	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;
72	import org.netbeans.modules.editor.lib.SettingsConversions;	72	import org.netbeans.modules.editor.lib.SettingsConversions;
		73	import org.netbeans.modules.editor.lib.drawing.DrawEngineDocView;
		74	import org.netbeans.modules.editor.lib.drawing.DrawEngineLineView;
73	import org.openide.util.WeakListeners;	75	import org.openide.util.WeakListeners;
74		76
75	/**	77	/**
Lines 341-347 Link Here
341	LockView lockView = (LockView) view;	343	LockView lockView = (LockView) view;
342	lockView.lock();	344	lockView.lock();
343	try {	345	try {
344	DrawEngineDocView docView = (DrawEngineDocView)view.getView(0);	346	GapDocumentView docView = (GapDocumentView)view.getView(0);
345	doDamageRange = docView.checkDamageRange(p0, p1, p0Bias, p1Bias);	347	doDamageRange = docView.checkDamageRange(p0, p1, p0Bias, p1Bias);
346	} finally {	348	} finally {
347	lockView.unlock();	349	lockView.unlock();
Lines 472-492 Link Here
472	*/	474	*/
473	public void changedUpdate(DocumentEvent evt) {	475	public void changedUpdate(DocumentEvent evt) {
474	if (evt instanceof BaseDocumentEvent) {	476	if (evt instanceof BaseDocumentEvent) {
475	BaseDocumentEvent bdevt = (BaseDocumentEvent)evt;	477	try {
476	BaseDocument doc = (BaseDocument)bdevt.getDocument();	478	JTextComponent comp = getComponent();
477	String layerName = bdevt.getDrawLayerName();	479	if (comp!=null && comp.isShowing()) {
478	if (layerName != null) {	480	getEditorUI().repaintBlock(evt.getOffset(), evt.getOffset() + evt.getLength());
479	getEditorUI().addLayer(doc.findLayer(layerName),
480	bdevt.getDrawLayerVisibility());
481	}else{ //temp
482	try {
483	JTextComponent comp = getComponent();
484	if (comp!=null && comp.isShowing()) {
485	getEditorUI().repaintBlock(evt.getOffset(), evt.getOffset() + evt.getLength());
486	}
487	} catch (BadLocationException ex) {
488	Utilities.annotateLoggable(ex);
489	}	481	}
		482	} catch (BadLocationException ex) {
		483	Utilities.annotateLoggable(ex);
490	}	484	}
491	}	485	}
492	}	486	}




import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.BadLocationException;
import org.netbeans.modules.editor.lib.drawing.DrawGraphics;

/**
* Base abstract view serves as parent for both

    }

    /** Get aligment along an X_AXIS or Y_AXIS */
    public @Override float getAlignment(int axis) {
        return 0f;
    }

    /* package */ abstract void modelToViewDG(int pos, DrawGraphics dg) throws BadLocationException;
    throws BadLocationException;

    /** Get y-coord value from position */
    protected abstract int getYFromPos(int pos) throws BadLocationException;


    }

    public @Override String toString() {
        return "BaseView=" + System.identityHashCode(this) // NOI18N
               + ", elem=" + getElement() + ", parent=" // NOI18N
               + System.identityHashCode(getParent());

Lines 49-54 Link Here

(-)a/editor.lib/src/org/netbeans/editor/Coloring.java (-12 / +26 lines)
49	import javax.swing.text.AttributeSet;	49	import javax.swing.text.AttributeSet;
50	import javax.swing.text.StyleConstants;	50	import javax.swing.text.StyleConstants;
51	import org.netbeans.api.editor.settings.EditorStyleConstants;	51	import org.netbeans.api.editor.settings.EditorStyleConstants;
		52	import org.netbeans.modules.editor.lib.drawing.ColoringAccessor;
		53	import org.netbeans.modules.editor.lib.drawing.DrawContext;
52		54
53	/**	55	/**
54	* Immutable class that stores font and foreground and background colors.	56	* Immutable class that stores font and foreground and background colors.
Lines 137-143 Link Here
137	private Color rightBorderLineColor;	139	private Color rightBorderLineColor;
138	private Color bottomBorderLineColor;	140	private Color bottomBorderLineColor;
139	private Color leftBorderLineColor;	141	private Color leftBorderLineColor;
140		142
		143	private final String cacheLock = new String("Coloring.cacheLock"); //NOI18N
		144
141	/** Cache holding the [original-font, derived-font] pairs	145	/** Cache holding the [original-font, derived-font] pairs
142	* and also original [fore-color, derived-fore-color] pairs.	146	* and also original [fore-color, derived-fore-color] pairs.
143	* This helps to avoid the repetitive computations of the	147	* This helps to avoid the repetitive computations of the
Lines 334-340 Link Here
334	}	338	}
335		339
336	/** Apply this coloring to draw context. */	340	/** Apply this coloring to draw context. */
337	public void apply(DrawContext ctx) {	341	private void apply(DrawContext ctx) {
338	// Possibly change font	342	// Possibly change font
339	if (font != null) {	343	if (font != null) {
340	if (fontMode == FONT_MODE_DEFAULT) {	344	if (fontMode == FONT_MODE_DEFAULT) {
Lines 343-349 Link Here
343	} else { // non-default font-mode	347	} else { // non-default font-mode
344	Font origFont = ctx.getFont();	348	Font origFont = ctx.getFont();
345	if (origFont != null) {	349	if (origFont != null) {
346	synchronized (fontAndForeColorCache) {	350	synchronized (cacheLock) {
347	Font f = (Font)fontAndForeColorCache.get(origFont);	351	Font f = (Font)fontAndForeColorCache.get(origFont);
348	if (f == null) {	352	if (f == null) {
349	f = modifyFont(origFont);	353	f = modifyFont(origFont);
Lines 363-369 Link Here
363	} else { // has alpha	367	} else { // has alpha
364	Color origForeColor = ctx.getForeColor();	368	Color origForeColor = ctx.getForeColor();
365	if (origForeColor != null) {	369	if (origForeColor != null) {
366	synchronized (fontAndForeColorCache) {	370	synchronized (cacheLock) {
367	Color fc = (Color)fontAndForeColorCache.get(origForeColor);	371	Color fc = (Color)fontAndForeColorCache.get(origForeColor);
368	if (fc == null) {	372	if (fc == null) {
369	fc = modifyForeColor(origForeColor);	373	fc = modifyForeColor(origForeColor);
Lines 383-389 Link Here
383	} else { // non-default back color-mode	387	} else { // non-default back color-mode
384	Color origBackColor = ctx.getBackColor();	388	Color origBackColor = ctx.getBackColor();
385	if (origBackColor != null) {	389	if (origBackColor != null) {
386	synchronized (backColorCache) {	390	synchronized (cacheLock) {
387	Color bc = (Color)backColorCache.get(origBackColor);	391	Color bc = (Color)backColorCache.get(origBackColor);
388	if (bc == null) {	392	if (bc == null) {
389	bc = modifyBackColor(origBackColor);	393	bc = modifyBackColor(origBackColor);
Lines 436-442 Link Here
436	} else { // non-default font-mode	440	} else { // non-default font-mode
437	Font origFont = c.getFont();	441	Font origFont = c.getFont();
438	if (origFont != null) {	442	if (origFont != null) {
439	synchronized (fontAndForeColorCache) {	443	synchronized (cacheLock) {
440	Font f = (Font)fontAndForeColorCache.get(origFont);	444	Font f = (Font)fontAndForeColorCache.get(origFont);
441	if (f == null) {	445	if (f == null) {
442	f = modifyFont(origFont);	446	f = modifyFont(origFont);
Lines 456-462 Link Here
456	} else { // non-default fore color-mode	460	} else { // non-default fore color-mode
457	Color origForeColor = c.getForeground();	461	Color origForeColor = c.getForeground();
458	if (origForeColor != null) {	462	if (origForeColor != null) {
459	synchronized (fontAndForeColorCache) {	463	synchronized (cacheLock) {
460	Color fc = (Color)fontAndForeColorCache.get(origForeColor);	464	Color fc = (Color)fontAndForeColorCache.get(origForeColor);
461	if (fc == null) {	465	if (fc == null) {
462	fc = modifyForeColor(origForeColor);	466	fc = modifyForeColor(origForeColor);
Lines 476-482 Link Here
476	} else { // non-default back color-mode	480	} else { // non-default back color-mode
477	Color origBackColor = c.getBackground();	481	Color origBackColor = c.getBackground();
478	if (origBackColor != null) {	482	if (origBackColor != null) {
479	synchronized (backColorCache) {	483	synchronized (cacheLock) {
480	Color bc = (Color)backColorCache.get(origBackColor);	484	Color bc = (Color)backColorCache.get(origBackColor);
481	if (bc == null) {	485	if (bc == null) {
482	bc = modifyBackColor(origBackColor);	486	bc = modifyBackColor(origBackColor);
Lines 518-524 Link Here
518		522
519	} else { // non-default font-mode	523	} else { // non-default font-mode
520	if (newFont != null) {	524	if (newFont != null) {
521	synchronized (fontAndForeColorCache) {	525	synchronized (cacheLock) {
522	Font f = (Font)fontAndForeColorCache.get(newFont);	526	Font f = (Font)fontAndForeColorCache.get(newFont);
523	if (f == null) {	527	if (f == null) {
524	f = modifyFont(newFont);	528	f = modifyFont(newFont);
Lines 541-547 Link Here
541		545
542	} else { // non-default fore color-mode	546	} else { // non-default fore color-mode
543	if (newForeColor != null) {	547	if (newForeColor != null) {
544	synchronized (fontAndForeColorCache) {	548	synchronized (cacheLock) {
545	Color fc = (Color)fontAndForeColorCache.get(newForeColor);	549	Color fc = (Color)fontAndForeColorCache.get(newForeColor);
546	if (fc == null) {	550	if (fc == null) {
547	fc = modifyForeColor(newForeColor);	551	fc = modifyForeColor(newForeColor);
Lines 561-567 Link Here
561	} else { // non-default back color-mode	565	} else { // non-default back color-mode
562	newBackColor = backColor;	566	newBackColor = backColor;
563	if (newBackColor != null) {	567	if (newBackColor != null) {
564	synchronized (backColorCache) {	568	synchronized (cacheLock) {
565	Color bc = (Color)backColorCache.get(newBackColor);	569	Color bc = (Color)backColorCache.get(newBackColor);
566	if (bc == null) {	570	if (bc == null) {
567	bc = modifyBackColor(newBackColor);	571	bc = modifyBackColor(newBackColor);
Lines 851-855 Link Here
851	new Integer(applyMode)	855	new Integer(applyMode)
852	};	856	};
853	}	857	}
854		858
		859	static {
		860	ColoringAccessor.register(new Accessor());
		861	}
		862
		863	private static final class Accessor extends ColoringAccessor {
		864	@Override
		865	public void apply(Coloring c, DrawContext ctx) {
		866	c.apply(ctx);
		867	}
		868	} // End of Accessor class
855	}	869	}

Lines 50-55 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DocumentContent.java (+3 lines)
50	import javax.swing.undo.CannotRedoException;	50	import javax.swing.undo.CannotRedoException;
51	import javax.swing.undo.UndoableEdit;	51	import javax.swing.undo.UndoableEdit;
52	import org.netbeans.lib.editor.util.AbstractCharSequence;	52	import org.netbeans.lib.editor.util.AbstractCharSequence;
		53	import org.netbeans.modules.editor.lib.impl.BasePosition;
		54	import org.netbeans.modules.editor.lib.impl.MarkVector;
		55	import org.netbeans.modules.editor.lib.impl.MultiMark;
53		56
54	/**	57	/**
55	* Content of the document.	58	* Content of the document.




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
 *
 * 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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.editor;

import java.awt.Color;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.BadLocationException;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import org.netbeans.api.editor.settings.FontColorNames;

/**
 * Various draw layers are located here
 *
 * @author Miloslav Metelka
 * @version 1.00
 * 
 * @deprecated Please use Highlighting SPI instead, for details see
 *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
 */
public class DrawLayerFactory {

    private static final Logger LOG = Logger.getLogger(DrawLayerFactory.class.getName());
    
    /** Syntax draw layer name */
    public static final String SYNTAX_LAYER_NAME = "syntax-layer"; // NOI18N

    /** Syntax draw layer visibility */
    public static final int SYNTAX_LAYER_VISIBILITY = 1000;

    /** Annotation draw layer name */
    public static final String ANNOTATION_LAYER_NAME = "annotation-layer"; // NOI18N

    /** Annotation draw layer visibility */
    public static final int ANNOTATION_LAYER_VISIBILITY = 2100;
    
    /** Highlight search layer name */
    public static final String HIGHLIGHT_SEARCH_LAYER_NAME = "highlight-search-layer"; // NOI18N

    /** Highlight search layer visibility */
    public static final int HIGHLIGHT_SEARCH_LAYER_VISIBILITY = 9000;

    /** Incremental search layer name */
    public static final String INC_SEARCH_LAYER_NAME = "inc-search-layer"; // NOI18N

    /** Incremental search layer visibility */
    public static final int INC_SEARCH_LAYER_VISIBILITY = 9500;
    
    /** Search block layer name */
    public static final String BLOCK_SEARCH_LAYER_NAME = "block-search-layer"; // NOI18N

    /** Search block layer visibility */
    public static final int BLOCK_SEARCH_LAYER_VISIBILITY = 8500;

    /** Selection draw layer name */
    public static final String CARET_LAYER_NAME = "caret-layer"; // NOI18N

    /** Selection draw layer visibility */
    public static final int CARET_LAYER_VISIBILITY = 10000;


    /** Guarded layer name */
    public static final String GUARDED_LAYER_NAME = "guarded-layer"; // NOI18N

    /** Guarded layer visibility */
    public static final int GUARDED_LAYER_VISIBILITY = 1400;


    /** 
     * Layer that colors the text according to the tokens that were parsed.
     * It's active all the time.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class SyntaxLayer extends DrawLayer.AbstractLayer {

        public SyntaxLayer() {
            super(SYNTAX_LAYER_NAME);
        }

        public void init(DrawContext ctx) {
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            return true;
        }

        public void updateContext(DrawContext ctx) {
            // Get the token type and docColorings
            TokenID tokenID = ctx.getTokenID();
            TokenContextPath tcp = ctx.getTokenContextPath();
            if (tokenID != null && tcp != null) {
                // Get the coloring according the name of the token
                String fullName = tcp.getFullTokenName(tokenID);
                Coloring c = ctx.getEditorUI().getColoring(fullName);
                if (c != null) {
                    c.apply(ctx);

                } else { // Token coloring null, try category
                    TokenCategory cat = tokenID.getCategory();
                    if (cat != null) {
                        fullName = tcp.getFullTokenName(cat);
                        c = ctx.getEditorUI().getColoring(fullName);
                        if (c !=  null) {
                            c.apply(ctx);
                        }
                    }
                }
            }
        }

    }


    /** 
     * This layer colors the line by a color specified in constructor
     * It requires only activation mark since it deactivates automatically
     * at the end of line.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static abstract class ColorLineLayer extends DrawLayer.AbstractLayer {

        /** Coloring to use for highlighting */
        Coloring coloring;

        public ColorLineLayer(String name) {
            super(name);
        }

        public boolean extendsEOL() {
            return true;
        }

        public void init(DrawContext ctx) {
            coloring = null;
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active;
            if (mark == null) {
                View view = ctx instanceof DrawEngine.DrawInfo ? ((DrawEngine.DrawInfo)ctx).view.getParent() : null;
                if (view instanceof DrawEngineLineView) {
                    DrawEngineLineView delv = (DrawEngineLineView)view;
                    mark = getFoldedMark(delv, getName());
                    if (mark == null) {
                        view = delv.getView(delv.getViewCount() -1);
                        if (view instanceof DrawEngineLineView) {
                            delv = (DrawEngineLineView) view;
                            mark = getFoldedMark(delv, getName());
                        }
                    }
                }
            }
            if (mark != null) {
                active = (ctx.getEditorUI().getComponent() != null)
                    && mark.activateLayer;
                if (active) {
                    try {
                        BaseDocument doc = ctx.getEditorUI().getDocument();
                        int nextRowStartPos = Utilities.getRowStart(
                                doc, ctx.getFragmentOffset(), 1);
                        if (nextRowStartPos < 0) { // end of doc
                            nextRowStartPos = Integer.MAX_VALUE;
                        }
                        setNextActivityChangeOffset(nextRowStartPos);

                    } catch (BadLocationException e) {
                        active = false;
                    }
                }
            } else {
                active = false;
            }
            return active;
        }

        public void updateContext(DrawContext ctx) {
            if (coloring == null) {
                coloring = getColoring(ctx);
            }
            if (coloring != null) {
                coloring.apply(ctx);
            }
        }

        protected abstract Coloring getColoring(DrawContext ctx);
        
    }


    /** Layer that covers selection services provided by caret.
     * This layer assumes that both caretMark and selectionMark in
     * BaseCaret are properly served so that their active flags
     * are properly set.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class CaretLayer extends DrawLayer.AbstractLayer {

        Coloring coloring;

        public CaretLayer() {
            super(CARET_LAYER_NAME);
        }

        public boolean extendsEmptyLine() {
            return true;
        }

        public void init(DrawContext ctx) {
            coloring = null;
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active;
            if (mark != null) {
                active = mark.activateLayer;
            } else {
                JTextComponent c = ctx.getEditorUI().getComponent();
                active = (c != null) && Utilities.isSelectionShowing(c)
                         && ctx.getFragmentOffset() >= c.getSelectionStart()
                         && ctx.getFragmentOffset() < c.getSelectionEnd();
            }

            return active;
        }

        public void updateContext(DrawContext ctx) {
            if (coloring == null) {
                coloring = ctx.getEditorUI().getColoring(FontColorNames.SELECTION_COLORING);
            }
            if (coloring != null) {
                coloring.apply(ctx);
            }
        }

    }


    /** Highlight search layer highlights all occurences
     * of the searched string in text.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class HighlightSearchLayer extends DrawLayer.AbstractLayer {

        /** Pairs of start and end position of the found string */
        int blocks[] = new int[] { -1, -1 };

        /** Coloring to use for highlighting */
        Coloring coloring;

        /** Current index for painting */
        int curInd;

        /** Enabled flag */
        boolean enabled;

        public HighlightSearchLayer() {
            super(HIGHLIGHT_SEARCH_LAYER_NAME);
        }

        public boolean isEnabled() {
            return enabled;
        }

        public void setEnabled(boolean enabled) {
            this.enabled = enabled;
        }

        public void init(DrawContext ctx) {
            if (enabled) {
                try {
                    BaseDocument doc = ctx.getEditorUI().getDocument();
                    blocks = FindSupport.getFindSupport().getBlocks(blocks,
                             doc, ctx.getStartOffset(), ctx.getEndOffset());
                } catch (BadLocationException e) {
                    blocks = new int[] { -1, -1 };
                }
                coloring = null; // reset so it will be re-read
                curInd = 0;
            }
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active;
            if (enabled) {
                int pos = ctx.getFragmentOffset();
                if (pos == blocks[curInd]) {
                    active = true;
                    setNextActivityChangeOffset(blocks[curInd + 1]);

                } else if (pos == blocks[curInd + 1]) {
                    active = false;
                    curInd += 2;
                    setNextActivityChangeOffset(blocks[curInd]);
                    if (pos == blocks[curInd]) { // just follows
                        setNextActivityChangeOffset(blocks[curInd + 1]);
                        active = true;
                    }

                } else {
                    setNextActivityChangeOffset(blocks[curInd]);
                    active = false;
                }
            } else {
                active = false;
            }

            return active;
        }

        public void updateContext(DrawContext ctx) {
            int pos = ctx.getFragmentOffset();
            if (pos >= blocks[curInd] && pos < blocks[curInd + 1]) {
                if (coloring == null) {
                    coloring = ctx.getEditorUI().getColoring(FontColorNames.HIGHLIGHT_SEARCH_COLORING);
                }
                if (coloring != null) {
                    coloring.apply(ctx);
                }
            }
        }

    }

    /** Layer covering incremental search. There are just two positions
     * begining and end of the searched string
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class IncSearchLayer extends DrawLayer.AbstractLayer {

        /** Position where the searched string begins */
        int pos;

        /** Length of area to highlight */
        int len;

        /** Whether this layer is enabled */
        boolean enabled;
        
        boolean invert;

        public IncSearchLayer() {
            super(INC_SEARCH_LAYER_NAME);
        }

        public boolean isEnabled() {
            return enabled;
        }

        public void setEnabled(boolean enabled) {
            this.enabled = enabled;
        }

        void setArea(int pos, int len) {
            this.pos = pos;
            this.len = len;
        }

        public int getOffset() {
            return pos;
        }

        public int getLength() {
            return len;
        }

        public void init(DrawContext ctx) {
            setNextActivityChangeOffset(enabled ? pos : Integer.MAX_VALUE);
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active = false;
            if (enabled) {
                if (ctx.getFragmentOffset() == pos) {
                    active = true;
                    setNextActivityChangeOffset(pos + len);
                }
            }

            return active;
        }

        /** current INC_SEARCH_COLORING is used only in block search.
         *  if there is no search, use selection
         *  @param invert if true - selection  coloring is used
         */
        void setInversion(boolean invert){
            this.invert = invert;
        }
        
        public void updateContext(DrawContext ctx) {
            if (!invert) {
                Coloring coloring = ctx.getEditorUI().getColoring(FontColorNames.INC_SEARCH_COLORING);
                if (coloring != null) {
                    coloring.apply(ctx);
                }
            } else {
                Coloring invertedColoring = ctx.getEditorUI().getColoring(FontColorNames.SELECTION_COLORING);
                if (invertedColoring != null) {
                    invertedColoring.apply(ctx);
                }
            }
        }
    } // End of IncSearchLayer class

    /**
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class BlockSearchLayer extends DrawLayer.AbstractLayer {

        /** Position where the searched string begins */
        int pos;

        /** Length of area to highlight */
        int len;

        /** Whether this layer is enabled */
        boolean enabled;

        public BlockSearchLayer() {
            super(BLOCK_SEARCH_LAYER_NAME);
        }

        public boolean extendsEmptyLine(){
            return true;
        }
        
        public boolean isEnabled() {
            return enabled;
        }

        public void setEnabled(boolean enabled) {
            this.enabled = enabled;
        }

        void setArea(int pos, int len) {
            this.pos = pos;
            this.len = len;
        }

        int getOffset() {
            return pos;
        }

        int getLength() {
            return len;
        }

        public void init(DrawContext ctx) {
            setNextActivityChangeOffset(enabled ? pos : Integer.MAX_VALUE);
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active = false;
            if (enabled) {
                int fragOffset = ctx.getFragmentOffset();
                if (fragOffset >= pos && fragOffset<(pos+len))  {
                    active = true;
                    try {
                        BaseDocument doc = ctx.getEditorUI().getDocument();
                        int nextRowStartPos = Utilities.getRowStart(
                                doc, fragOffset, 1);
                        if (nextRowStartPos < 0) { // end of doc
                            nextRowStartPos = Integer.MAX_VALUE;
                        }
                        setNextActivityChangeOffset(Math.min(nextRowStartPos,(pos+len)));

                    } catch (BadLocationException e) {
                        active = false;
                    }
                
                }
           }

            return active;
        }

        public void updateContext(DrawContext ctx) {
            Coloring coloring = ctx.getEditorUI().getColoring(FontColorNames.BLOCK_SEARCH_COLORING);
            if (coloring != null) {
                coloring.apply(ctx);
            }
        }
    } // End of BlockSearchLayer class

//
//  XXX: Deprecated and not used anymore. Can be removed.
//
//    /** Layer for guarded blocks 
//     *
//     * @deprecated Please use Highlighting SPI instead, for details see
//     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
//     */
//    static class GuardedLayer extends ColorLineLayer {
//
//        GuardedDocument doc;
//
//        GuardedLayer() {
//            super(GUARDED_LAYER_NAME);
//        }
//
//        public void init(DrawContext ctx) {
//            super.init(ctx);
//            doc = (GuardedDocument)ctx.getEditorUI().getDocument();
//        }
//
//        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
//            boolean active;
//            if (mark != null) {
//                active = mark.activateLayer;
//            } else {
//                active = doc.isPosGuarded(ctx.getFragmentOffset());
//            }
//
//            return active;
//        }
//
//        protected Coloring getColoring(DrawContext ctx) {
//            return ctx.getEditorUI().getColoring(SettingsNames.GUARDED_COLORING);
//        }
//
//    }

    
    
    /** 
     * Style layer getting color settings from particular style 
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class StyleLayer extends DrawLayer.AbstractLayer {

        protected Style style;

        protected MarkChain markChain;

        protected Color backColor;

        protected Color foreColor;

        public StyleLayer(String layerName, BaseDocument doc, Style style) {
            super(layerName);
            this.style = style;
            markChain = new MarkChain(doc, layerName);
        }

        public boolean extendsEOL() {
            return true;
        }

        public final MarkChain getMarkChain() {
            return markChain;
        }

        public void init(DrawContext ctx) {
            foreColor = StyleConstants.getForeground(style);
            backColor = StyleConstants.getBackground(style);
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            boolean active = false;
            if (mark != null) {
                active = (ctx.getEditorUI().getComponent() != null)
                    && mark.activateLayer;
                if (active) {
                    try {
                        BaseDocument doc = ctx.getEditorUI().getDocument();
                        int nextRowStartPos = Utilities.getRowStart(
                                doc, ctx.getFragmentOffset(), 1);
                        if (nextRowStartPos < 0) { // end of doc
                            nextRowStartPos = Integer.MAX_VALUE;
                        }

                        setNextActivityChangeOffset(nextRowStartPos);

                    } catch (BadLocationException e) {
                        active = false;
                    }
                }

            }

            return active;
        }

        public void updateContext(DrawContext ctx) {
            if (foreColor != null) {
                ctx.setForeColor(foreColor);
            }
            if (backColor != null) {
                ctx.setBackColor(backColor);
            }
        }

        public String toString() {
            return super.toString() + ((markChain != null) ? (", " + markChain) : ""); // NOI18N
        }

    }

    /** 
     * Test layer for coloring the specific words
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class WordColoringLayer extends DrawLayer.AbstractLayer {

        protected StringMap stringMap = new StringMap();

        public WordColoringLayer(String name) {
            super(name);
        }

        public void put(String s, Coloring c) {
            stringMap.put(s, c);
        }

        public void put(String[] strings, Coloring c) {
            for (int i = 0; i < strings.length; i++) {
                put(strings[i], c);
            }
        }

        public void put(List stringList, Coloring c) {
            String strings[] = new String[stringList.size()];
            stringList.toArray(strings);
            put(strings, c);
        }

        public void init(DrawContext ctx) {
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            return true;
        }

        public void updateContext(DrawContext ctx) {
            Coloring c = (Coloring)stringMap.get(ctx.getBuffer(),
                                 ctx.getTokenOffset(), ctx.getTokenLength());
            if (c != null) {
                c.apply(ctx);
            }
        }

    }

    /** 
     * Annotation layer for drawing of annotations. Each mark which is stored in markChain has
     * corresponding Annotation. More than one Annotation can share one mark. In this case
     * the only one annotation is active and this must be drawn. 
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class AnnotationLayer extends DrawLayer.AbstractLayer {

        /** Current coloring */
        private Coloring coloring;
        
        /** Chain of marks attached to this layer */
        private MarkChain markChain;
                
        public AnnotationLayer(BaseDocument doc) {
            super(ANNOTATION_LAYER_NAME);
            coloring = null;
            markChain = new MarkChain(doc, ANNOTATION_LAYER_NAME);
        }

        /** Get chain of marks attached to this draw layer
         * @return mark chain */        
        public final MarkChain getMarkChain() {
            return markChain;
        }
        
        public boolean extendsEOL() {
            return true;
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            int nextActivityOffset;
            coloring = null;
//            LOG.setLevel(Level.FINE);
//            if (LOG.isLoggable(Level.FINE)) {
//                LOG.fine("  ctx-offset=" + ctx.getFragmentOffset() + ", mark=" + mark + '\n');
//            }

            if (mark == null) {
                View view = ctx instanceof DrawEngine.DrawInfo ? ((DrawEngine.DrawInfo)ctx).view : null;
                if (view instanceof DrawEngineLineView) {
                    mark = getFoldedMark((DrawEngineLineView)view, getName());
                }
            }
            
            if (mark == null) {
                return false;
            }

            if (ctx.getEditorUI().getComponent() == null || !mark.activateLayer) {
                return false;
            }
            
            BaseDocument doc = ctx.getEditorUI().getDocument();
            
            // Gets the active annotation attached to this mark. It is possible that
            // no active annotation might exist for the mark, e.g. there can be
            // mark at the beginning of the line for a whole line annotation
            // and there can be mark in the middle of the line for a line-part annotation
            AnnotationDesc anno = doc.getAnnotations().getActiveAnnotation(mark);
            if (anno == null) {
                // if no active annotation was found for the given mark, check
                // whether we are not already drawing some other annotation. If that's
                // true we have to continue drawing it (means return true here)
                AnnotationDesc activeAnno = doc.getAnnotations().getLineActiveAnnotation(mark);
                if (activeAnno == null) {
                    return false;
                }
                if (ctx.getFragmentOffset() >= activeAnno.getOffset()) {
                    if (ctx.getFragmentOffset() < activeAnno.getOffset() + activeAnno.getLength() || activeAnno.isWholeLine()) {
                        coloring = activeAnno.getColoring();
                        return true;
                    }
                }
                return false;
            }

//            if (LOG.isLoggable(Level.FINE)) {
//                LOG.log(Level.FINE, "anno: o=" + anno.getOffset() + ", l=" + anno.getLength() + ", wl=" + anno.isWholeLine()
//                    + ", m=" + mark + ", ctx-offset=" + ctx.getFragmentOffset() + '\n');
//            }
            if (anno.isWholeLine()) {
                try {
                    nextActivityOffset = Utilities.getRowEnd(doc, ctx.getFragmentOffset());
                } catch (BadLocationException ble) {
                    LOG.log(Level.FINE, null, ble);
                    return false;
                }
            } else {
                if (ctx.getFragmentOffset() < anno.getOffset()) { // Queried below annotation start
                    setNextActivityChangeOffset(anno.getOffset());
                    return false;
                }
                nextActivityOffset = anno.getOffset() + anno.getLength();
                if (ctx.getFragmentOffset() >= nextActivityOffset) { // Queried above annotation end
                    try {
                        setNextActivityChangeOffset(Utilities.getRowEnd(doc, ctx.getFragmentOffset()));
                    } catch (BadLocationException ble) {
                        LOG.log(Level.FINE, null, ble);
                        return false;
                    }
                    return false;
                }
            }
            
            setNextActivityChangeOffset(nextActivityOffset);
            coloring = anno.getColoring();
            
//      The following code ensures that if active annotation does not 
//      have highlight the color of next one will be used.
//      It was decided that it will not be used
//            
//            if (coloring.getBackColor() == null) {
//                AnnotationDesc[] annos = doc.getAnnotations().getPasiveAnnotations(anno.getLine());
//                if (annos != null) {
//                    for (int i=0; i<annos.length; i++) {
//                        if (annos[i].getColoring().getBackColor() != null) {
//                            coloring = annos[i].getColoring();
//                            break;
//                        }
//                    }
//                }
//            }
            
            return true;
        }

        public void updateContext(DrawContext ctx) {
            if (coloring != null) {
                coloring.apply(ctx);
            }
        }

    }

    private static MarkFactory.DrawMark getFoldedMark(DrawEngineLineView view, String layerName) {
        BaseDocument doc = (BaseDocument)view.getDocument();
        int startPos = view.getStartOffset();
        int endPos = view.getEndOffset() - 1;
        MarkVector docMarksStorage = doc.marksStorage;
        synchronized (docMarksStorage) {
            int low = 0;
            int high = docMarksStorage.getMarkCount() - 1;

            while (low < high) { // Unlike regular binary search only iterate (low < high) - code below handles that correctly
                int mid = (low + high) >> 1;
                int cmp = docMarksStorage.getMarkOffsetInternal(mid) - endPos;
                if (cmp < 0)
                    low = mid + 1;
                else if (cmp > 0)
                    high = mid - 1;
                else { // found
                    while (++mid <= high && docMarksStorage.getMarkOffsetInternal(mid) == endPos) { }
                    low = high = mid - 1;
                }
            }

            while (low >= 0 && low < docMarksStorage.getMarkCount()) {
                MultiMark mm = (MultiMark)docMarksStorage.getMark(low--);
                if (mm.isValid() && mm.getOffset() <= endPos) {
                    if (mm.getOffset() < startPos) {
                        break;
                    }
                    Mark mrk = doc.marks.get(mm);
                    if (mrk instanceof MarkFactory.DrawMark && layerName.equals(((MarkFactory.DrawMark)mrk).layerName)) {
                        return (MarkFactory.DrawMark)mrk;
                    }
                }
            }
        }

        return null;
    }
}

Lines 90-95 Link Here

(-)a/editor.lib/src/org/netbeans/editor/EditorUI.java (-58 / +105 lines)
90	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;	90	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;
91	import org.netbeans.modules.editor.lib.KitsTracker;	91	import org.netbeans.modules.editor.lib.KitsTracker;
92	import org.netbeans.modules.editor.lib.SettingsConversions;	92	import org.netbeans.modules.editor.lib.SettingsConversions;
		93	import org.netbeans.modules.editor.lib.drawing.EditorUiAccessor;
		94	import org.netbeans.modules.editor.lib.drawing.HighlightingDrawLayer;
93	import org.openide.util.WeakListeners;	95	import org.openide.util.WeakListeners;
94		96
95	/**	97	/**
Lines 156-164 Link Here
156	/** Document for the case ext ui is constructed without the component */	158	/** Document for the case ext ui is constructed without the component */
157	private BaseDocument printDoc;	159	private BaseDocument printDoc;
158		160
159	/** Draw layer chain */
160	private DrawLayerList drawLayerList = new DrawLayerList();
161
162	/** Map holding the [name, coloring] pairs */	161	/** Map holding the [name, coloring] pairs */
163	private ColoringMap coloringMap;	162	private ColoringMap coloringMap;
164		163
Lines 289-295 Link Here
289	}	288	}
290	};	289	};
291		290
292	HighlightingDrawLayer.hookUp(this);
293	getToolTipSupport();	291	getToolTipSupport();
294	}	292	}
295		293
Lines 316-324 Link Here
316	setLineNumberEnabled(lineNumberEnabled);	314	setLineNumberEnabled(lineNumberEnabled);
317		315
318	updateLineNumberWidth(0);	316	updateLineNumberWidth(0);
319
320	drawLayerList.add(printDoc.getDrawLayerList());
321	HighlightingDrawLayer.hookUp(this);
322	}	317	}
323		318
324	/**	319	/**
Lines 366-372 Link Here
366	// initialize rendering hints	361	// initialize rendering hints
367	FontColorSettings fcs = MimeLookup.getLookup(mimePath).lookup(FontColorSettings.class);	362	FontColorSettings fcs = MimeLookup.getLookup(mimePath).lookup(FontColorSettings.class);
368	renderingHints = (Map<?, ?>) fcs.getFontColors(FontColorNames.DEFAULT_COLORING).getAttribute(EditorStyleConstants.RenderingHints);	363	renderingHints = (Map<?, ?>) fcs.getFontColors(FontColorNames.DEFAULT_COLORING).getAttribute(EditorStyleConstants.RenderingHints);
369		364
		365	// Initialize draw layers
		366	HighlightingDrawLayer.hookUp(c);
		367
370	synchronized (getComponentLock()) {	368	synchronized (getComponentLock()) {
371	this.component = c;	369	this.component = c;
372		370
Lines 562-578 Link Here
562	}	560	}
563		561
564	protected void modelChanged(BaseDocument oldDoc, BaseDocument newDoc) {	562	protected void modelChanged(BaseDocument oldDoc, BaseDocument newDoc) {
565	if (oldDoc != null) {
566	// remove all document layers
567	drawLayerList.remove(oldDoc.getDrawLayerList());
568	}
569
570	if (newDoc != null) {	563	if (newDoc != null) {
571	coloringMap = ColoringMap.get(Utilities.getMimeType(newDoc));	564	coloringMap = ColoringMap.get(Utilities.getMimeType(newDoc));
572	listener.preferenceChange(null);	565	listener.preferenceChange(null);
573		566
574	// add all document layers
575	drawLayerList.add(newDoc.getDrawLayerList());
576	checkUndoManager(newDoc);	567	checkUndoManager(newDoc);
577	}	568	}
578	}	569	}
Lines 963-1011 Link Here
963	return statusBar;	954	return statusBar;
964	}	955	}
965		956
966
967	final DrawLayerList getDrawLayerList() {
968	return drawLayerList;
969	}
970
971	/**
972	* Find the layer with some layer name in the layer hierarchy.
973	*
974	* <p>Using of <code>DrawLayer</code>s has been deprecated.
975	*
976	* @deprecated Please use Highlighting SPI instead, for details see
977	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
978	*/
979	public DrawLayer findLayer(String layerName) {
980	return drawLayerList.findLayer(layerName);
981	}
982
983	/**
984	* Add new layer and use its priority to position it in the chain.
985	* If there's the layer with same visibility then the inserted layer
986	* will be placed after it.
987	*
988	* <p>Using of <code>DrawLayer</code>s has been deprecated.
989	*
990	* @param layer layer to insert into the chain
991	*
992	* @deprecated Please use Highlighting SPI instead, for details see
993	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
994	*/
995	public boolean addLayer(DrawLayer layer, int visibility) {
996	return drawLayerList.add(layer, visibility);
997	}
998
999	/**
1000	* Using of <code>DrawLayer</code>s has been deprecated.
1001	*
1002	* @deprecated Please use Highlighting SPI instead, for details see
1003	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
1004	*/
1005	public DrawLayer removeLayer(String layerName) {
1006	return drawLayerList.remove(layerName);
1007	}
1008
1009	public void repaint(int startY) {	957	public void repaint(int startY) {
1010	repaint(startY, component.getHeight());	958	repaint(startY, component.getHeight());
1011	}	959	}
Lines 1767-1770 Link Here
1767	public void setPopupMenu(JPopupMenu popupMenu) {	1715	public void setPopupMenu(JPopupMenu popupMenu) {
1768	this.popupMenu = popupMenu;	1716	this.popupMenu = popupMenu;
1769	}	1717	}
		1718
		1719	static {
		1720	EditorUiAccessor.register(new Accessor());
		1721	}
		1722
		1723	private static final class Accessor extends EditorUiAccessor {
		1724
		1725	@Override
		1726	public boolean isLineNumberVisible(EditorUI eui) {
		1727	return eui.lineNumberVisible;
		1728	}
		1729
		1730	@Override
		1731	public Coloring getColoring(EditorUI eui, String coloringName) {
		1732	return eui.getColoring(coloringName);
		1733	}
		1734
		1735	@Override
		1736	public int getLineNumberMaxDigitCount(EditorUI eui) {
		1737	return eui.lineNumberMaxDigitCount;
		1738	}
		1739
		1740	@Override
		1741	public int getLineNumberWidth(EditorUI eui) {
		1742	return eui.lineNumberWidth;
		1743	}
		1744
		1745	@Override
		1746	public int getLineNumberDigitWidth(EditorUI eui) {
		1747	return eui.lineNumberDigitWidth;
		1748	}
		1749
		1750	@Override
		1751	public Insets getLineNumberMargin(EditorUI eui) {
		1752	return eui.getLineNumberMargin();
		1753	}
		1754
		1755	@Override
		1756	public int getLineHeight(EditorUI eui) {
		1757	return eui.getLineHeight();
		1758	}
		1759
		1760	@Override
		1761	public Coloring getDefaultColoring(EditorUI eui) {
		1762	return eui.getDefaultColoring();
		1763	}
		1764
		1765	@Override
		1766	public int getDefaultSpaceWidth(EditorUI eui) {
		1767	return eui.defaultSpaceWidth;
		1768	}
		1769
		1770	@Override
		1771	public Map<?, ?> getRenderingHints(EditorUI eui) {
		1772	return eui.renderingHints;
		1773	}
		1774
		1775	@Override
		1776	public Rectangle getExtentBounds(EditorUI eui) {
		1777	return eui.getExtentBounds();
		1778	}
		1779
		1780	@Override
		1781	public Insets getTextMargin(EditorUI eui) {
1782	return eui.getTextMargin();
1783	}
1784
1785	@Override
1786	public int getTextLeftMarginWidth(EditorUI eui) {
1787	return eui.textLeftMarginWidth;
1788	}
1789
1790	@Override
1791	public boolean getTextLimitLineVisible(EditorUI eui) {
1792	return eui.textLimitLineVisible;
1793	}
1794
1795	@Override
1796	public Color getTextLimitLineColor(EditorUI eui) {
1797	return eui.getTextLimitLineColor();
1798	}
1799
1800	@Override
1801	public int getTextLimitWidth(EditorUI eui) {
1802	return eui.textLimitWidth;
1803	}
1804
1805	@Override
1806	public int getLineAscent(EditorUI eui) {
1807	return eui.getLineAscent();
1808	}
1809
1810	@Override
1811	public void paint(EditorUI eui, Graphics g) {
1812	eui.paint(g);
1813	}
1814
1815	} // End of Accessor class
1816
1770	}	1817	}




package org.netbeans.editor;

import java.text.MessageFormat;
import java.util.Hashtable;
import java.util.Enumeration;
import java.awt.Color;
import java.awt.Font;

    /** Style context to hold the styles */
    protected StyleContext styles;

    /** Style to layer name mapping */
    protected Hashtable stylesToLayers;

    /** Name of the normal style. The normal style is used to reset the effect
    * of all styles applied to the line.
    */

    
    private void init(StyleContext styles) {
        this.styles = styles;
        stylesToLayers = new Hashtable(5);
        guardedBlockChain = new MarkBlockChain(this) {
            protected @Override Mark createBlockStartMark() {
                MarkFactory.ContextMark startMark = new MarkFactory.ContextMark(Position.Bias.Forward, false);

        }
    }

    public void setCharacterAttributes(int offset, int length, AttributeSet attribs, boolean replace) {
        if (((Boolean)attribs.getAttribute(GUARDED_ATTRIBUTE)).booleanValue() == true) {
            guardedBlockChain.addBlock(offset, offset + length, false); // no concat
            fireChangedUpdate(getDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE, attribs));
        }
        if (((Boolean)attribs.getAttribute(GUARDED_ATTRIBUTE)).booleanValue() == false) {
            guardedBlockChain.removeBlock(offset, offset + length);
            fireChangedUpdate(getDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE, attribs));
        }
    }

    public @Override void runAtomic(Runnable r) {
        if (debugAtomic) {
            System.out.println("GuardedDocument.runAtomic() called"); // NOI18N

        return new GuardedDocumentEvent(this, offset, length, type);
    }

    /** Set the name for normal style. Normal style is used to reset the effect
    * of all aplied styles.
    */
    public void setNormalStyleName(String normalStyleName) {
        this.normalStyleName = normalStyleName;
    }

    /** Fetches the list of style names */
    public Enumeration getStyleNames() {
        return styles.getStyleNames();
    }

    // ------------------------------------------------------------------------
    // StyleDocument implementation
    // ------------------------------------------------------------------------

    /** Adds style to the document */
    public Style addStyle(String styleName, Style parent) {
        String layerName = (String)stylesToLayers.get(styleName);
        if (layerName == null) {
            layerName = styleName; // same layer name as style name
            addStyleToLayerMapping(styleName, layerName);
        }

        Style style =  styles.addStyle(styleName, parent);
        if (findLayer(layerName) == null) { // not created by default
            readLock();
            try {
                addStyledLayer(layerName, style);
            } finally {
                readUnlock();
            }
        }
        return style;
    }

    public void addStyleToLayerMapping(String styleName, String layerName) {
        stylesToLayers.put(styleName, layerName);
    }

    /** Removes style from document */
    public void removeStyle(String styleName) {
        styles.removeStyle(styleName);

        return styles.getStyle(styleName);
    }

    public void setCharacterAttributes(int offset, int length, AttributeSet attribs, boolean replace) {
        if (((Boolean)attribs.getAttribute(GUARDED_ATTRIBUTE)).booleanValue() == true) {
            guardedBlockChain.addBlock(offset, offset + length, false); // no concat
            fireChangedUpdate(getDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE, attribs));
        }
        if (((Boolean)attribs.getAttribute(GUARDED_ATTRIBUTE)).booleanValue() == false) {
            guardedBlockChain.removeBlock(offset, offset + length);
            fireChangedUpdate(getDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE, attribs));
        }
        return styles.getStyleNames();
    }

    /** Change attributes for part of the text.  */

     * @param s the style to set
     */
    public void setLogicalStyle(int pos, Style s) {
        readLock();
        try {
            pos = Utilities.getRowStart(this, pos);
            String layerName = (String)stylesToLayers.get(s.getName());
            // remove all applied styles
            DrawLayer[] layerArray = getDrawLayerList().currentLayers();
            for (int i = 0; i < layerArray.length; i++) {
                if (layerArray[i] instanceof DrawLayerFactory.StyleLayer) {
                    ((DrawLayerFactory.StyleLayer)layerArray[i]).markChain.removeMark(pos);
                }
            }
            // now set the requested style
            DrawLayerFactory.StyleLayer styleLayer
            = (DrawLayerFactory.StyleLayer)findLayer(layerName);
            if (styleLayer != null) {
                styleLayer.markChain.addMark(pos);
            }
            fireChangedUpdate(getDocumentEvent(
                pos, 0, DocumentEvent.EventType.CHANGE, null)); // enough to say length 0
        } catch (BadLocationException e) {
            // do nothing for invalid positions
        } finally {
            readUnlock();
        }
    }

    /** Get logical style for position in paragraph */
    public Style getLogicalStyle(int pos) {
        return null;
            pos = Utilities.getRowStart(this, pos);
            DrawLayer[] layerArray = getDrawLayerList().currentLayers();
            for (int i = 0; i < layerArray.length; i++) {
                DrawLayer layer = layerArray[i];
                if (layer instanceof DrawLayerFactory.StyleLayer) {
                    if (((DrawLayerFactory.StyleLayer)layer).markChain.isMark(pos)) {
                        return ((DrawLayerFactory.StyleLayer)layer).style;
                    }
                }
            }
            return getStyle(normalStyleName); // no style found
        } catch (BadLocationException e) {
            return null;
        }
    }

    /**

        return new Font("Default",Font.BOLD,12); // NOI18N
    }

    /**
     * Using of <code>DrawLayer</code>s has been deprecated.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    protected DrawLayer addStyledLayer(String layerName, Style style) {
        if (layerName != null) {
            try {
                int indColon = layerName.indexOf(':'); //NOI18N
                int layerVisibility = Integer.parseInt(layerName.substring(indColon + 1));
                DrawLayer layer = new DrawLayerFactory.StyleLayer(layerName, this, style);

                addLayer(layer, layerVisibility);
                return layer;

            } catch (NumberFormatException e) {
                // wrong name, let it pass
            }
        }
        return null;
    }

    public @Override String toStringDetail() {
        return super.toStringDetail()
               + getDrawLayerList()
               + ",\nGUARDED blocks:\n" + guardedBlockChain; // NOI18N
    }





import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.event.DocumentEvent;
import org.netbeans.modules.editor.lib.drawing.DrawContext;
import org.netbeans.modules.editor.lib.drawing.DrawEngine;
import org.netbeans.modules.editor.lib.drawing.DrawGraphics;

/**
* Leaf view implementation. This corresponds and requires leaf element

    protected int mainHeight;

    /** Draw graphics for converting position to coords */
    final ModelToViewDG modelToViewDG = new ModelToViewDG();

    /** Draw graphics for converting coords to position */
    final ViewToModelDG viewToModelDG = new ViewToModelDG();

    /** Construct new base view */
    public LeafView(Element elem) {
        super(elem);
    }

    public @Override void setParent(View parent) {
        super.setParent(parent);
        
        if (getParent() != null) {

                    int pos = getPosFromY(clipY + clipHeight - 1);
                    int endPos = Utilities.getRowEnd(doc, pos);
                    int baseY = getYFromPos(startPos);
                    DrawEngine.getDrawEngine().draw(
                        new DrawGraphics.GraphicsDG(g),
                        editorUI, startPos, endPos,
                        getBaseX(baseY), baseY, Integer.MAX_VALUE
                    );

    }

    /** Returns the number of child views in this view. */
    public @Override final int getViewCount() {
        return 0;
    }

    /** Gets the n-th child view.  */
    public @Override final View getView(int n) {
        return null;
    }

    /** !!! osetrit konec view -> jump na dalsi v branchview */
    public @Override int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,
                                         int direction, Position.Bias[] biasRet)
    throws BadLocationException {
        if (biasRet != null) {

        return ret;
    }

    public @Override Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1,
                             Shape a) throws BadLocationException {
        Rectangle r0 = (Rectangle)modelToView(p0, a, b0);
        Rectangle r1 = (Rectangle)modelToView(p1, a, b1);

    * @param a the current allocation of the view
    * @param f the factory to use to rebuild if the view has children
    */
    public @Override void insertUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
        try {
            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            EditorUI editorUI = getEditorUI();

    * @param a the current allocation of the view
    * @param f the factory to use to rebuild if the view has children
    */
    public @Override void removeUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
        try {
            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            EditorUI editorUI = getEditorUI();

    * @param a the current allocation of the view
    * @param f the factory to use to rebuild if the view has children
    */
    public @Override void changedUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
        try {
            if (getComponent().isShowing()) {
                getEditorUI().repaintBlock(evt.getOffset(), evt.getOffset() + evt.getLength());


        Rectangle r;

        public @Override boolean targetOffsetReached(int pos, char ch, int x,
                                           int charWidth, DrawContext ctx) {
            r.x = x;
            r.y = getY();

            return offset;
        }

        public @Override boolean targetOffsetReached(int offset, char ch, int x,
        int charWidth, DrawContext ctx) {
            if (offset <= eolOffset) {
                if (x + charWidth < targetX) {

Lines 48-53 Link Here

(-)a/editor.lib/src/org/netbeans/editor/Mark.java (+1 lines)
48	import javax.swing.text.Element;	48	import javax.swing.text.Element;
49	import javax.swing.text.Position;	49	import javax.swing.text.Position;
50	import javax.swing.text.Position.Bias;	50	import javax.swing.text.Position.Bias;
		51	import org.netbeans.modules.editor.lib.impl.MultiMark;
51		52
52	/**	53	/**
53	* Marks hold the relative position in the document.	54	* Marks hold the relative position in the document.




import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import javax.swing.text.BadLocationException;
import javax.swing.text.Position;

/**
* Support class for chain of MarkBlocks

        return pos;
    }

    public @Override String toString() {

        private String layerName;

        public LayerChain(BaseDocument doc, String layerName) {
            super(doc);
            this.layerName = layerName;
        }

        public final String getLayerName() {
            return layerName;
        }

        protected Mark createBlockStartMark() {
            MarkFactory.DrawMark startMark = new MarkFactory.DrawMark(layerName, null);
            startMark.activateLayer = true;
            return startMark;
        }

        protected Mark createBlockEndMark() {
            MarkFactory.DrawMark endMark = new MarkFactory.DrawMark(layerName, null, Position.Bias.Backward);
            return endMark;
        }

    }

    public String toString() {
        return "MarkBlockChain: currentBlock=" + currentBlock + "\nblock chain: " // NOI18N
               + (chain != null ? ("\n" + chain.toStringChain()) : " Empty"); // NOI18N
    }





package org.netbeans.editor;

import java.lang.ref.WeakReference;
import javax.swing.text.Position;

/**

        }

        /** When removal occurs */
        protected @Override void removeUpdateAction(int pos, int len) {
            try {
                remove();
            } catch (InvalidMarkException e) {


    }

    /** Activation mark for particular layer. When layer is not active
    * its updateContext() method is not called.
    */
    public static class DrawMark extends ContextMark {

        /** Activation flag means either activate layer or deactivate it */
        protected boolean activateLayer;

        /** Reference to draw layer this mark belogns to */
        String layerName;

        /** Reference to extended UI if this draw mark is info-specific or
        * null if it's document-wide.
        */
        WeakReference editorUIRef;

        public DrawMark(String layerName, EditorUI editorUI) {
            this(layerName, editorUI, Position.Bias.Forward);
        }
        
        public DrawMark(String layerName, EditorUI editorUI, Position.Bias bias) {
            super(bias, false);
            this.layerName = layerName;
            setEditorUI(editorUI);
        }

        public boolean isDocumentMark() {
            return (editorUIRef == null);
        }

        public EditorUI getEditorUI() {
            if (editorUIRef != null) {
                return (EditorUI)editorUIRef.get();
            }
            return null;
        }

        public void setEditorUI(EditorUI editorUI) {
            this.editorUIRef = (editorUI != null) ? new WeakReference(editorUI) : null;
        }

        public boolean isValidUI() {
            return !(editorUIRef != null && editorUIRef.get() == null);
        }

        public void setActivateLayer(boolean activateLayer) {
            this.activateLayer = activateLayer;
        }

        public boolean getActivateLayer() {
            return activateLayer;
        }

        public boolean removeInvalid() {
            if (!isValidUI() && isValid()) {
                try {
                    this.remove();
                } catch (InvalidMarkException e) {
                    throw new IllegalStateException(e.toString());
                }
                return true; // invalid and removed
            }
            return false; // valid
        }

        public String toString() {
            try {
                return "pos=" + getOffset() + ", line=" + getLine(); // NOI18N
            } catch (InvalidMarkException e) {
                return "mark not valid"; // NOI18N
            }
        }

    }

    /** Support for draw marks chained in double linked list */
    public static class ChainDrawMark extends DrawMark {

        /** Next mark in chain */
        protected ChainDrawMark next;

        /** Previous mark in chain */
        protected ChainDrawMark prev;

        public ChainDrawMark(String layerName, EditorUI editorUI) {
            this(layerName, editorUI, Position.Bias.Forward);
        }
        
        public ChainDrawMark(String layerName, EditorUI editorUI, Position.Bias bias) {
            super(layerName, editorUI, bias);
        }

        public final ChainDrawMark getNext() {
            return next;
        }

        public final void setNext(ChainDrawMark mark) {
            next = mark;
        }

        /** Set next mark in chain */
        public void setNextChain(ChainDrawMark mark) {
            this.next = mark;
            if (mark != null) {
                mark.prev = this;
            }
        }

        public final ChainDrawMark getPrev() {
            return prev;
        }

        public final void setPrev(ChainDrawMark mark) {
            prev = mark;
        }

        /** Set previous mark in chain */
        public void setPrevChain(ChainDrawMark mark) {
            this.prev = mark;
            if (mark != null) {
                mark.next = this;
            }
        }

        /** Insert mark before this one in chain
        * @return inserted mark
        */
        public ChainDrawMark insertChain(ChainDrawMark mark) {
            ChainDrawMark thisPrev = this.prev;
            mark.prev = thisPrev;
            mark.next = this;
            if (thisPrev != null) {
                thisPrev.next = mark;
            }
            this.prev = mark;
            return mark;
        }

        /** Remove this mark from the chain
        * @return next chain member or null for end of chain
        */
        public ChainDrawMark removeChain() {
            ChainDrawMark thisNext = this.next;
            ChainDrawMark thisPrev = this.prev;
            if (thisPrev != null) { // not the first
                thisPrev.next = thisNext;
                this.prev = null;
            }
            if (thisNext != null) { // not the last
                thisNext.prev = thisPrev;
                this.next = null;
            }
            try {
                this.remove(); // remove the mark from DocMarks
            } catch (InvalidMarkException e) {
                // already removed
            }
            return thisNext;
        }

        public String toStringChain() {
            return toString() + (next != null ? "\n" + next.toStringChain() : ""); // NOI18N
        }

        public String toString() {
            return super.toString() + ", " // NOI18N
                   + ((prev != null) ? ((next != null) ? "chain member" // NOI18N
                            : "last member") : ((next != null) ? "first member" // NOI18N
                                                            : "standalone member")); // NOI18N
        }

    }
}

Lines 62-67 Link Here

(-)a/editor.lib/src/org/netbeans/editor/Utilities.java (+1 lines)
62	import org.netbeans.api.editor.EditorRegistry;	62	import org.netbeans.api.editor.EditorRegistry;
63	import org.netbeans.lib.editor.util.CharSequenceUtilities;	63	import org.netbeans.lib.editor.util.CharSequenceUtilities;
64	import org.netbeans.lib.editor.util.swing.DocumentUtilities;	64	import org.netbeans.lib.editor.util.swing.DocumentUtilities;
		65	import org.netbeans.modules.editor.lib.drawing.DrawEngineDocView;
65	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;	66	import org.netbeans.modules.editor.lib2.EditorPreferencesKeys;
66	import org.openide.util.NbBundle;	67	import org.openide.util.NbBundle;
67		68





public class ExtCaret extends BaseCaret {

    /** 
     * Highlight row draw layer name.
     * 
     * <p>Using <code>DrawLayer</code>s has been deprecated and this constant
     * has no longer any meaning.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static final String HIGHLIGHT_ROW_LAYER_NAME = "highlight-row-layer"; // NOI18N

    /**
     * Highlight row draw layer visibility.
     * 
     * <p>Using <code>DrawLayer</code>s has been deprecated and this constant
     * has no longer any meaning.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static final int HIGHLIGHT_ROW_LAYER_VISIBILITY = 2050;

    /** 
     * Highlight matching brace draw layer name
     * 
     * @deprecated Please use Braces Matching SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
     */
    public static final String HIGHLIGHT_BRACE_LAYER_NAME = "highlight-brace-layer"; // NOI18N

    /** 
     * Highlight matching brace draw layer visibility 
     * 
     * @deprecated Please use Braces Matching SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
     */
    public static final int HIGHLIGHT_BRACE_LAYER_VISIBILITY = 11000;

// XXX: remove
//    /** Highlight a brace matching character before the caret */
//    public static final int MATCH_BRACE_BEFORE = -1;
//    
//    /** Highlight a brace matching character after (at) the caret */
//    public static final int MATCH_BRACE_AFTER = 0;
//    
//    /** Highlight a brace matching character either before or after caret;
//        the character before takes precedence. */
//    public static final int MATCH_BRACE_EITHER = java.lang.Integer.MAX_VALUE;
//
//    /** Whether to hightlight the matching brace */
//    boolean highlightBrace;
//
//    /** Coloring used for highlighting the matching brace */
//    Coloring highlightBraceColoring;
//
//    /** Mark holding the starting position of the matching brace. */
//    MarkFactory.DrawMark highlightBraceStartMark;
//
//    /** Mark holding the ending position of the matching brace. */
//    MarkFactory.DrawMark highlightBraceEndMark;
//
//    /** Timer that fires when the matching brace should be displayed */
//    private Timer braceTimer;
//    private ActionListener braceTimerListener; // because of unwanted GC
//
//    /** Signal that the next matching brace update
//    * will be immediate without waiting for the brace
//    * timer to fire the action.
//    */
//    private boolean matchBraceUpdateSync;
//
//    /** Whether the brace starting and ending marks are currently valid or not.
//     * If they are not valid the block they delimit is not highlighted.
//     */
//    boolean braceMarksValid;
//
//    boolean simpleMatchBrace;
//
//    private int matchBraceOffset = MATCH_BRACE_EITHER;
    
    static final long serialVersionUID =-4292670043122577690L;

// XXX: remove    
//    protected void modelChanged(BaseDocument oldDoc, BaseDocument newDoc) {
//        // Fix for #7108
//        braceMarksValid = false; // brace marks are out of date - new document
//        if (highlightBraceStartMark != null) {
//            try {
//                highlightBraceStartMark.remove();
//            } catch (InvalidMarkException e) {
//            }
//            highlightBraceStartMark = null;
//        }
//
//        if (highlightBraceEndMark != null) {
//            try {
//                highlightBraceEndMark.remove();
//            } catch (InvalidMarkException e) {
//            }
//            highlightBraceEndMark = null;
//        }
//
//        super.modelChanged( oldDoc, newDoc );
//    }

// XXX: remove
//    /** Called when settings were changed. The method is called
//    * also in constructor, so the code must count with the evt being null.
//    */
//    public void settingsChange(SettingsChangeEvent evt) {
//        super.settingsChange(evt);
//        JTextComponent c = component;
//        if (c != null) {
//            Class kitClass = Utilities.getKitClass(c);
//// XXX: remove
////            EditorUI editorUI = Utilities.getEditorUI(c);
////            highlightBraceColoring = editorUI.getColoring(
////                                           ExtSettingsNames.HIGHLIGHT_MATCH_BRACE_COLORING);
////
////            highlightBrace = SettingsUtil.getBoolean(kitClass,
////                               ExtSettingsNames.HIGHLIGHT_MATCH_BRACE,
////                               ExtSettingsDefaults.defaultHighlightMatchBrace);
////            int highlightBraceDelay = SettingsUtil.getInteger(kitClass,
////                                        ExtSettingsNames.HIGHLIGHT_MATCH_BRACE_DELAY,
////                                        ExtSettingsDefaults.defaultHighlightMatchBraceDelay);
////
////            if (highlightBrace) {
////                if (highlightBraceDelay > 0) {
////                    // jdk12 compiler doesn't allow inside run()
////                    final JTextComponent c2 = component;
////
////                    braceTimer = new Timer(highlightBraceDelay, null);
////                    braceTimerListener = 
////                         new ActionListener() {
////                             public void actionPerformed(ActionEvent evt2) {
////                                 SwingUtilities.invokeLater(
////                                     new Runnable() {
////                                         public void run() {
////                                             if (c2 != null) {
////                                                 BaseDocument doc = Utilities.getDocument(c2);
////                                                 if( doc != null ) {
////                                                     doc.readLock();
////                                                     try {
////                                                         updateMatchBrace();
////                                                     } finally {
////                                                         doc.readUnlock();
////                                                     }
////                                                 }
////                                             }
////                                         }
////                                     }
////                                 );
////                             }
////                         };
////                         
////                    braceTimer.addActionListener(new WeakTimerListener(braceTimerListener));
////                    braceTimer.setRepeats(false);
////                } else {
////                    braceTimer = null; // signal no delay
////                }
////                c.repaint();
////            }
////
////            simpleMatchBrace = SettingsUtil.getBoolean(kitClass,
////                                    ExtSettingsNames.CARET_SIMPLE_MATCH_BRACE,
////                                    ExtSettingsDefaults.defaultCaretSimpleMatchBrace);
////            
//            popupMenuEnabled = SettingsUtil.getBoolean(kitClass,
//                ExtSettingsNames.POPUP_MENU_ENABLED, true);
//        }
//    }
// XXX: remove
//    public void install(JTextComponent c) {
//        EditorUI editorUI = Utilities.getEditorUI(c);
//        editorUI.addLayer(new HighlightBraceLayer(), HIGHLIGHT_BRACE_LAYER_VISIBILITY);
//        super.install(c);
//    }
//
//    public void deinstall(JTextComponent c) {
//        EditorUI editorUI = Utilities.getEditorUI(c);
//        editorUI.removeLayer(HIGHLIGHT_BRACE_LAYER_NAME);
//        super.deinstall(c);
//    }
//    
//    /** Set the match brace offset.
//     * @param offset One of <code>MATCH_BRACE_BEFORE</code>,
//     * <code>MATCH_BRACE_AFTER</code> * or <code>MATCH_BRACE_EITHER</code>.
//     */
//    public void setMatchBraceOffset(int offset) {
//        if(offset != MATCH_BRACE_BEFORE && offset != MATCH_BRACE_AFTER
//           && offset != MATCH_BRACE_EITHER) {
//            throw new IllegalArgumentException("Offset "+ offset + " not allowed\n");
//        }
//        matchBraceOffset = offset;
//        BaseDocument doc = Utilities.getDocument(component);
//        if( doc != null ) {
//            doc.readLock();
//            try {
//                updateMatchBrace();
//            } finally {
//                doc.readUnlock();
//            }
//        }
//    }
//    
//    /** Fetch the match brace offset. */
//    public int getMatchBraceOffset() {
//        return matchBraceOffset;
//    }

    /** 
     * Update the matching brace of the caret. The document is read-locked
     * while this method is called.

     *   <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
     */
    protected void updateMatchBrace() {
// XXX: remove
//        JTextComponent c = component;
//        if (c != null && highlightBrace) {
//            try {
//                EditorUI editorUI = Utilities.getEditorUI(c);
//                BaseDocument doc = (BaseDocument)c.getDocument();
//                int dotPos = getDot();
//                ExtSyntaxSupport sup = (ExtSyntaxSupport)doc.getSyntaxSupport();
//                boolean madeValid = false; // whether brace marks display were validated
//                int[] matchBlk = null;
//                if(dotPos > 0 && (matchBraceOffset == MATCH_BRACE_BEFORE
//                                  || matchBraceOffset == MATCH_BRACE_EITHER)) {
//                    matchBlk = sup.findMatchingBlock(dotPos - 1, simpleMatchBrace);
//                }
//                if(matchBlk == null && (matchBraceOffset == MATCH_BRACE_AFTER
//                                        || matchBraceOffset == MATCH_BRACE_EITHER)) {
//                    matchBlk = sup.findMatchingBlock(dotPos, simpleMatchBrace);
//                }
//                if (matchBlk != null) {
//                    if (highlightBraceStartMark != null) {
//                        int markStartPos = highlightBraceStartMark.getOffset();
//                        int markEndPos = highlightBraceEndMark.getOffset();
//                        if (markStartPos != matchBlk[0] || markEndPos != matchBlk[1]) {
//                            editorUI.repaintBlock(markStartPos, markEndPos);
//                            Utilities.moveMark(doc, highlightBraceStartMark, matchBlk[0]);
//                            Utilities.moveMark(doc, highlightBraceEndMark, matchBlk[1]);
//                            editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
//                        } else { // on the same position
//                            if (!braceMarksValid) { // was not valid, must repaint
//                                editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
//                            }
//                        }
//                    } else { // highlight mark is null
//                        highlightBraceStartMark = new MarkFactory.DrawMark(
//                                                    HIGHLIGHT_BRACE_LAYER_NAME, editorUI);
//                        highlightBraceEndMark = new MarkFactory.DrawMark(
//                                                    HIGHLIGHT_BRACE_LAYER_NAME, editorUI);
//                        highlightBraceStartMark.setActivateLayer(true);
//                        Utilities.insertMark(doc, highlightBraceStartMark, matchBlk[0]);
//                        Utilities.insertMark(doc, highlightBraceEndMark, matchBlk[1]);
//                        editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
//                    }
//                    braceMarksValid = true;
//                    madeValid = true;
//                }
//
//                if (!madeValid) {
//                    if (braceMarksValid) {
//                        braceMarksValid = false;
//                        editorUI.repaintBlock(highlightBraceStartMark.getOffset(),
//                                highlightBraceEndMark.getOffset());
//                    }
//                }
//            } catch (BadLocationException e) {
//                Utilities.annotateLoggable(e);
//                highlightBrace = false;
//            } catch (InvalidMarkException e) {
//                Utilities.annotateLoggable(e);
//                highlightBrace = false;
//            }
//        }
    }
// XXX: remove
//    protected void update(boolean scrollViewToCaret) {
//        if (highlightBrace) {
//            if (matchBraceUpdateSync || braceTimer == null) {
//                updateMatchBrace();
//                matchBraceUpdateSync = false;
//
//            } else { // delay the brace update
//                braceTimer.restart();
//            }
//        }
//
//        super.update(scrollViewToCaret);
//    }

    /** 
     * Signal that the next matching brace update

     *   <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
     */
    public void requestMatchBraceUpdateSync() {
// XXX: remove
//        matchBraceUpdateSync = true;
    }
    
// XXX: remove
//    /* package */ static boolean NO_HIGHLIGHT_BRACE_LAYER = Boolean.getBoolean("nbeditor-no-HighlightBraceLayer");
//    
//    /** 
//     * Draw layer to highlight the matching brace.
//     * 
//     * XXX: The HighlightBraceLayer needs to be rewritten using the new Highlighting SPI.
//     */
//    class HighlightBraceLayer extends DrawLayer.AbstractLayer {
//
//        public HighlightBraceLayer() {
//            super(HIGHLIGHT_BRACE_LAYER_NAME);
//        }
//
//        public void init(DrawContext ctx) {
//        }
//
//        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
//            if (!NO_HIGHLIGHT_BRACE_LAYER && braceMarksValid) {
//                if (mark != null)
//                    return mark.getActivateLayer();
//                try {
//                    if (ctx.getStartOffset() > highlightBraceEndMark.getOffset())
//                        return highlightBraceEndMark.getActivateLayer();
//                    if (ctx.getStartOffset() > highlightBraceStartMark.getOffset())
//                        return highlightBraceStartMark.getActivateLayer();
//                } catch (InvalidMarkException ex) {                    
//                }
//            }
//
//            return false;
//        }
//
//        public void updateContext(DrawContext ctx) {
//            if (!NO_HIGHLIGHT_BRACE_LAYER && highlightBraceColoring != null) {
//                highlightBraceColoring.apply(ctx);
//            }
//        }
//
//    }

}

Lines 113-119 Link Here

(-)a/editor.lib/src/org/netbeans/modules/editor/lib/BeforeSaveTasks.java (-1 / +1 lines)
113	private void runTasks() {	113	private void runTasks() {
114	doc.runAtomicAsUser (new Runnable () {	114	doc.runAtomicAsUser (new Runnable () {
115	public void run () {	115	public void run () {
116	CompoundEdit atomicEdit = EditorPackageAccessor.get().markAtomicEditsNonSignificant(doc);	116	CompoundEdit atomicEdit = EditorPackageAccessor.get().BaseDocument_markAtomicEditsNonSignificant(doc);
117	// Since these are before-save actions they should generally not prevent	117	// Since these are before-save actions they should generally not prevent
118	// the save operation to succeed. Thus the possible exceptions thrown	118	// the save operation to succeed. Thus the possible exceptions thrown
119	// by the tasks will be notified but they will not prevent the save to succeed.	119	// by the tasks will be notified but they will not prevent the save to succeed.





package org.netbeans.modules.editor.lib;

import javax.swing.text.BadLocationException;
import javax.swing.undo.CompoundEdit;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.InvalidMarkException;
import org.netbeans.editor.Mark;
import org.netbeans.modules.editor.lib.impl.MarkVector;
import org.netbeans.modules.editor.lib.impl.MultiMark;


/**


public abstract class EditorPackageAccessor {

    private static EditorPackageAccessor ACCESSOR = null;

    public static synchronized void register(EditorPackageAccessor accessor) {
        assert ACCESSOR == null : "Can't register two package accessors!"; //NOI18N
        ACCESSOR = accessor;
            try {
                Class.forName(BaseDocument.class.getName(), true, EditorPackageAccessor.class.getClassLoader());
            } catch (ClassNotFoundException e) {
                // Should never happen
            }
        }
        return INSTANCE;
    }

    public static synchronized EditorPackageAccessor get() {
        // Trying to wake up BaseDocument ...
        try {
            Class clazz = Class.forName(BaseDocument.class.getName());
        } catch (ClassNotFoundException e) {
            // ignore
        }

        assert ACCESSOR != null : "There is no package accessor available!"; //NOI18N
        return ACCESSOR;
    }

    protected EditorPackageAccessor() {
    }

    public abstract CompoundEdit BaseDocument_markAtomicEditsNonSignificant(BaseDocument doc);
    public abstract MarkVector BaseDocument_getMarksStorage(BaseDocument doc);
    public abstract Mark BaseDocument_getMark(BaseDocument doc, MultiMark multiMark);
    public abstract void Mark_insert(Mark mark, BaseDocument doc, int pos) throws InvalidMarkException, BadLocationException;

}




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

package org.netbeans.modules.editor.lib.drawing;

import java.awt.Container;
import java.awt.FontMetrics;

import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.editor.BaseKit;
import org.netbeans.editor.BaseTextUI;
import org.netbeans.editor.Coloring;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.FoldingToolTip;
import org.netbeans.editor.FontMetricsCache;
import org.netbeans.editor.PopupManager;
import org.netbeans.editor.Utilities;
import org.netbeans.editor.ext.ToolTipSupport;
import org.netbeans.editor.view.spi.LockView;
import org.openide.util.Lookup;

Lines 39-48 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawContext.java (-1 / +4 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.awt.Color;	44	import java.awt.Color;
45	import java.awt.Font;	45	import java.awt.Font;
		46	import org.netbeans.editor.EditorUI;
		47	import org.netbeans.editor.TokenContextPath;
		48	import org.netbeans.editor.TokenID;
46		49
47	/** This interface provides methods for	50	/** This interface provides methods for
48	* getting and setting various drawing attributes.	51	* getting and setting various drawing attributes.




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

package org.netbeans.modules.editor.lib.drawing;

import java.awt.Graphics;
import java.awt.Graphics2D;

import java.awt.Insets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.BadLocationException;

import javax.swing.text.Segment;
import javax.swing.text.View;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.editor.Analyzer;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Coloring;
import org.netbeans.editor.EditorDebug;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.FontMetricsCache;
import org.netbeans.editor.InvalidMarkException;
import org.netbeans.editor.Mark;
import org.netbeans.editor.TokenContextPath;
import org.netbeans.editor.TokenID;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.lib.EditorPackageAccessor;
import org.netbeans.modules.editor.lib.impl.MarkVector;
import org.netbeans.modules.editor.lib.impl.MultiMark;

/**
 * This class is responsible for drawing editor components. It's a singleton.

 * 
 * @author Miloslav Metelka
 */
public final class DrawEngine {

    private static final Logger LOG = Logger.getLogger(DrawEngine.class.getName());
    

        return drawEngine;
    }
    
    private void initLineNumbering(DrawInfo ctx, EditorUI eui) {
        EditorUiAccessor accessor = EditorUiAccessor.get();
        // Resolve whether line numbers will be painted
        ctx.lineNumbering = accessor.isLineNumberVisible(eui)
                            && ctx.drawGraphics.supportsLineNumbers();

        // create buffer for showing line numbers

                LOG.log(Level.WARNING, null, e);
            }

            ctx.lineNumberColoring = accessor.getColoring(eui, FontColorNames.LINE_NUMBER_COLORING);
            if (ctx.lineNumberColoring == null) {
                ctx.lineNumberColoring = ctx.defaultColoring; // no number coloring found


                lnForeColor = ctx.defaultColoring.getForeColor();
            }

            ctx.lineNumberChars = new char[Math.max(accessor.getLineNumberMaxDigitCount(eui), 1)];
            ctx.lineNumberWidth = accessor.getLineNumberWidth(eui);
            ctx.lineNumberDigitWidth = accessor.getLineNumberDigitWidth(eui);
            ctx.lineNumberMargin = accessor.getLineNumberMargin(eui);
            if (ctx.graphics == null) {
                ctx.syncedLineNumbering = true;


        }
    }

    private void initInfo(DrawInfo ctx, EditorUI eui) throws BadLocationException {
        if (ctx.startOffset < ctx.lineStartOffset) {
            throw new BadLocationException("Invalid startOffset: " + ctx.startOffset + " < line start offset = " + ctx.lineStartOffset, ctx.startOffset); //NOI18N
        }
        if (ctx.endOffset > ctx.lineEndOffset) {
            throw new BadLocationException("Invalid endOffset: " + ctx.endOffset + " > line end offset = " + ctx.lineEndOffset, ctx.endOffset); //NOI18N
        }

        EditorUiAccessor accessor = EditorUiAccessor.get();

        ctx.x = ctx.startX;
        ctx.y = ctx.startY;
        ctx.lineHeight = accessor.getLineHeight(eui);
        ctx.defaultColoring = accessor.getDefaultColoring(eui);
        ctx.tabSize = ctx.doc.getTabSize();
        ctx.defaultSpaceWidth = accessor.getDefaultSpaceWidth(eui);
        ctx.fragmentOffset = ctx.startOffset; // actual painting position
        ctx.graphics = ctx.drawGraphics.getGraphics();

        if (ctx.graphics != null) {
            Map<?, ?> hints = accessor.getRenderingHints(eui);
            if (hints != null) {
                ((Graphics2D)ctx.graphics).setRenderingHints(hints);
            }
        }

        ctx.extentBounds = accessor.getExtentBounds(eui);
        ctx.textMargin = accessor.getTextMargin(eui);
        ctx.textLeftMarginWidth = accessor.getTextLeftMarginWidth(eui);
        ctx.textLimitLineVisible = accessor.getTextLimitLineVisible(eui);
        ctx.textLimitLineColor = accessor.getTextLimitLineColor(eui);
        ctx.textLimitWidth = accessor.getTextLimitWidth(eui);
        initLineNumbering(ctx, eui);

        // Initialize draw context
        ctx.foreColor = ctx.defaultColoring.getForeColor();

        ctx.drawGraphics.init(ctx);
        ctx.drawGraphics.setDefaultBackColor(ctx.defaultColoring.getBackColor());
        ctx.drawGraphics.setLineHeight(ctx.lineHeight);
        ctx.drawGraphics.setLineAscent(accessor.getLineAscent(eui));
        ctx.drawGraphics.setX(ctx.x);
        ctx.drawGraphics.setY(ctx.y);

        // Init all draw-layers
        ctx.layers = DrawLayerList.forComponent(ctx.component).currentLayers();
        int layersLength = ctx.layers.length;
        ctx.layerActives = new boolean[layersLength];
        ctx.layerActivityChangeOffsets = new int[layersLength];

            ctx.layers[i].init(ctx); // init all layers
        }

        ctx.drawMarkList = new ArrayList<DrawMark>();
        MarkVector docMarksStorage = EditorPackageAccessor.get().BaseDocument_getMarksStorage(ctx.doc);
        synchronized (docMarksStorage) {
            int offset = ctx.startOffset;
            int low = 0;

                        break;
                    }

                    Mark mark = EditorPackageAccessor.get().BaseDocument_getMark(ctx.doc, m);
                    if (mark == null) {
                        throw new IllegalStateException("No mark for m=" + m); // NOI18N
                    }
                    if (mark instanceof DrawMark) {
                        ctx.drawMarkList.add((DrawMark)mark);
                    }
                }


                }

                // Fill the DG's attributes and draw
                int numX = ctx.x - ctx.lineNumberWidth;
                if (ctx.lineNumberMargin != null) {
                    numX += ctx.lineNumberMargin.left;
                }
                ctx.drawGraphics.setX(numX);


                ctx.drawGraphics.setBottomBorderLineColor(ctx.bottomBorderLineColor);
                ctx.drawGraphics.setLeftBorderLineColor(ctx.leftBorderLineColor);
                ctx.drawGraphics.setFont(ctx.font);
                ctx.drawGraphics.drawChars(0, ctx.lineNumberChars.length, ctx.lineNumberWidth);
                    ctx.editorUI.lineNumberWidth);

                // When printing there should be an additional space between
                // line number and the text
                if (ctx.drawGraphics.getGraphics() == null) {
                    ctx.drawGraphics.setBuffer(SPACE);
                    ctx.drawGraphics.drawChars(0, 1, ctx.lineNumberDigitWidth);
                        ctx.editorUI.lineNumberDigitWidth);
                }

                ctx.drawGraphics.setX(ctx.x);

        // Handle possible white space expansion and compute display width
        FontMetricsCache.Info fmcInfo = FontMetricsCache.getInfo(ctx.font);
        ctx.spaceWidth = (ctx.component != null)
            ? fmcInfo.getSpaceWidth(ctx.component) : ctx.defaultSpaceWidth;

        // Compute real count of chars in fragment - can differ if tabs
        ctx.fragmentCharCount = ctx.fragmentLength;

                    
                    ctx.drawGraphics.setBackColor(ctx.backColor);
                    ctx.drawGraphics.fillRect(blankWidth);
                    if (emptyLine && ctx.x <= ctx.textMargin.left) { //#58652
                        ctx.x += blankWidth;
                    }
                }

    private void drawTheRestOfTextLine(DrawInfo ctx) {
        handleEOL(ctx);

        if (ctx.textLimitLineVisible) { // draw limit line
            int lineX = ctx.textMargin.left + ctx.textLimitWidth * ctx.defaultSpaceWidth;
            if (ctx.graphics !=null){
                ctx.graphics.setColor(ctx.textLimitLineColor);
                Rectangle clip = ctx.graphics.getClipBounds();
                if (clip.height>ctx.lineHeight){
                    ctx.graphics.drawLine(lineX, ctx.y, lineX, ctx.y+clip.height);
                }
            }

    }
    
    private void graphicsSpecificUpdates(DrawInfo ctx) {
        Rectangle bounds = ctx.extentBounds;
        Rectangle clip = ctx.graphics.getClipBounds();
        Insets textMargin = ctx.textMargin;
        int leftMarginWidth = textMargin.left - ctx.lineNumberWidth - ctx.textLeftMarginWidth;
                              - ctx.editorUI.textLeftMarginWidth;

        // Draw line numbers bar and all the line nummbers
        if (ctx.lineNumbering && !ctx.syncedLineNumbering) {

            int lnBarX = bounds.x + leftMarginWidth;
            if (!lnBackColor.equals(ctx.defaultColoring.getBackColor()) || bounds.x > 0) {
                ctx.graphics.setColor(lnBackColor);
                ctx.graphics.fillRect(lnBarX, numY, ctx.lineNumberWidth,
                                      ctx.lineIndex * ctx.lineHeight); // can't use dg because of height
            }



            int lastDigitInd = Math.max(ctx.lineNumberChars.length - 1, 0);
            int numX = lnBarX;
            if (ctx.lineNumberMargin != null) {
                numX += ctx.lineNumberMargin.left;
            }

            ctx.bol = true; //

                ctx.drawGraphics.setFont(ctx.font);

                ctx.drawGraphics.setX(lnBarX);
                ctx.drawGraphics.fillRect(ctx.lineNumberWidth);
                ctx.drawGraphics.setX(numX);

                ctx.drawGraphics.drawChars(0, ctx.lineNumberChars.length,
                    ctx.lineNumberChars.length * ctx.lineNumberDigitWidth);
                
                ctx.drawGraphics.setBuffer(null); // will do changes in buffer


                }

                // Initialize the draw-info
                initInfo(ctx, editorUI);

                // Draw the area
                drawArea(ctx);

        /** Coloring for the line-number. */
        Coloring lineNumberColoring;

        int lineNumberWidth;
        int lineNumberDigitWidth;
        Insets lineNumberMargin;

        /** Graphics object. It can be null when not drawing to the component. */
        Graphics graphics;


        boolean drawMarkUpdate;

        /** List of draw marks in the painted area. */
        List<DrawMark> drawMarkList;
        
        /** Current index in the drawMarkList */
        int drawMarkIndex;

        /** Current draw-mark */
        DrawMark drawMark;

        /** Position of the current draw-mark */
        int drawMarkOffset;


        /** Width of one space character for the current context font. */
        int spaceWidth;
        int defaultSpaceWidth;

        /** Display width of the fragment */
        int fragmentWidth;

        */
        int fragmentCharCount;

        Rectangle extentBounds;
        Insets textMargin;
        int textLeftMarginWidth;

        boolean textLimitLineVisible;
        Color textLimitLineColor;
        int textLimitWidth;
        
        public Color getForeColor() {
            return foreColor;
        }

        }

    } // End of DrawInfo class
    
}

Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawEngineDocView.java (-13 / +15 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.awt.Graphics;	44	import java.awt.Graphics;
45	import java.awt.Rectangle;	45	import java.awt.Rectangle;
Lines 59-64 Link Here
59	import org.netbeans.api.editor.fold.FoldUtilities;	59	import org.netbeans.api.editor.fold.FoldUtilities;
60	import org.netbeans.api.editor.fold.FoldHierarchyEvent;	60	import org.netbeans.api.editor.fold.FoldHierarchyEvent;
61	import org.netbeans.api.editor.fold.FoldHierarchyListener;	61	import org.netbeans.api.editor.fold.FoldHierarchyListener;
		62	import org.netbeans.editor.BaseTextUI;
		63	import org.netbeans.editor.EditorUI;
62	import org.netbeans.lib.editor.view.GapDocumentView;	64	import org.netbeans.lib.editor.view.GapDocumentView;
63	import org.netbeans.editor.view.spi.LockView;	65	import org.netbeans.editor.view.spi.LockView;
64		66
Lines 67-73 Link Here
67	*	69	*
68	* @author Miloslav Metelka	70	* @author Miloslav Metelka
69	*/	71	*/
70	/* package */ class DrawEngineDocView extends GapDocumentView	72	public class DrawEngineDocView extends GapDocumentView
71	implements FoldHierarchyListener, PropertyChangeListener {	73	implements FoldHierarchyListener, PropertyChangeListener {
72		74
73	private static final boolean debugRebuild	75	private static final boolean debugRebuild
Lines 86-98 Link Here
86		88
87	private boolean estimatedSpanResetInitiated;	89	private boolean estimatedSpanResetInitiated;
88		90
89	DrawEngineDocView(Element elem) {	91	public DrawEngineDocView(Element elem) {
90	super(elem);	92	super(elem);
91		93
92	setEstimatedSpan(true);	94	setEstimatedSpan(true);
93	}	95	}
94		96
95	public void setParent(View parent) {	97	public @Override void setParent(View parent) {
96	if (parent != null) { // start listening	98	if (parent != null) { // start listening
97	JTextComponent component = (JTextComponent)parent.getContainer();	99	JTextComponent component = (JTextComponent)parent.getContainer();
98	foldHierarchy = FoldHierarchy.get(component);	100	foldHierarchy = FoldHierarchy.get(component);
Lines 127-133 Link Here
127	return foldHierarchy;	129	return foldHierarchy;
128	}	130	}
129		131
130	protected boolean useCustomReloadChildren() {	132	protected @Override boolean useCustomReloadChildren() {
131	return true;	133	return true;
132	}	134	}
133		135
Lines 201-207 Link Here
201	collapsedFold = null;	203	collapsedFold = null;
202	}	204	}
203		205
204	protected void customReloadChildren(int index, int removeLength, int startOffset, int endOffset) {	206	protected @Override void customReloadChildren(int index, int removeLength, int startOffset, int endOffset) {
205	// if removing all the views reset the flag	207	// if removing all the views reset the flag
206	if (index == 0 && removeLength == getViewCount()) {	208	if (index == 0 && removeLength == getViewCount()) {
207	collapsedFoldsInPresentViews = false; // suppose there will be no folds in line views	209	collapsedFoldsInPresentViews = false; // suppose there will be no folds in line views
Lines 224-230 Link Here
224	}	226	}
225	}	227	}
226		228
227	protected View createCustomView(ViewFactory f,	229	protected @Override View createCustomView(ViewFactory f,
228	int startOffset, int maxEndOffset, int elementIndex) {	230	int startOffset, int maxEndOffset, int elementIndex) {
229	if (elementIndex == -1) {	231	if (elementIndex == -1) {
230	throw new IllegalStateException("Need underlying line element structure"); // NOI18N	232	throw new IllegalStateException("Need underlying line element structure"); // NOI18N
Lines 244-252 Link Here
244	List foldAndEndLineElemList = new ArrayList();	246	List foldAndEndLineElemList = new ArrayList();
245		247
246	while (true) {	248	while (true) {
247	int collapsedFoldEndOffset = collapsedFold.getEndOffset();	249	int _collapsedFoldEndOffset = collapsedFold.getEndOffset();
248	// Find line element index of the line in which the collapsed fold ends	250	// Find line element index of the line in which the collapsed fold ends
249	while (collapsedFoldEndOffset > lineElemEndOffset) {	251	while (_collapsedFoldEndOffset > lineElemEndOffset) {
250	elementIndex++;	252	elementIndex++;
251	lineElem = elem.getElement(elementIndex);	253	lineElem = elem.getElement(elementIndex);
252	lineElemEndOffset = lineElem.getEndOffset();	254	lineElemEndOffset = lineElem.getEndOffset();
Lines 322-333 Link Here
322	}	324	}
323	}	325	}
324		326
325	public void paint(Graphics g, Shape allocation) {	327	public @Override void paint(Graphics g, Shape allocation) {
326	java.awt.Component c = getContainer();	328	java.awt.Component c = getContainer();
327	if (c instanceof javax.swing.text.JTextComponent){	329	if (c instanceof javax.swing.text.JTextComponent){
328	TextUI textUI = ((javax.swing.text.JTextComponent)c).getUI();	330	TextUI textUI = ((javax.swing.text.JTextComponent)c).getUI();
329	if (textUI instanceof BaseTextUI){	331	if (textUI instanceof BaseTextUI){
330	((BaseTextUI) textUI).getEditorUI().paint(g);	332	EditorUiAccessor.get().paint(((BaseTextUI) textUI).getEditorUI(), g);
331	}	333	}
332	}	334	}
333		335
Lines 340-346 Link Here
340	}	342	}
341	}	343	}
342		344
343	public void setSize(float width, float height) {	345	public @Override void setSize(float width, float height) {
344	super.setSize(width, height);	346	super.setSize(width, height);
345		347
346	/* #69446 - disabled estimated span reset	348	/* #69446 - disabled estimated span reset
Lines 375-381 Link Here
375	*/	377	*/
376	}	378	}
377		379
378	protected boolean isChildrenResizeDisabled() {	380	protected @Override boolean isChildrenResizeDisabled() {
379	return true;	381	return true;
380	}	382	}
381		383

Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawEngineFakeDocView.java (-2 / +2 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import javax.swing.text.Element;	44	import javax.swing.text.Element;
45	import org.netbeans.api.editor.fold.Fold;	45	import org.netbeans.api.editor.fold.Fold;
Lines 50-56 Link Here
50	*	50	*
51	* @author Martin Roskanin	51	* @author Martin Roskanin
52	*/	52	*/
53	class DrawEngineFakeDocView extends DrawEngineDocView{	53	/* package */ class DrawEngineFakeDocView extends DrawEngineDocView{
54		54
55	private boolean useCollapsing = true;	55	private boolean useCollapsing = true;
56	private int fakeStartOffset;	56	private int fakeStartOffset;

Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawEngineLineView.java (-2 / +5 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.awt.Graphics;	44	import java.awt.Graphics;
45	import java.awt.Rectangle;	45	import java.awt.Rectangle;
Lines 55-60 Link Here
55	import javax.swing.text.Position.Bias;	55	import javax.swing.text.Position.Bias;
56	import javax.swing.text.View;	56	import javax.swing.text.View;
57	import javax.swing.text.ViewFactory;	57	import javax.swing.text.ViewFactory;
		58	import org.netbeans.editor.BaseDocument;
		59	import org.netbeans.editor.BaseTextUI;
		60	import org.netbeans.editor.EditorUI;
58	import org.netbeans.editor.view.spi.EstimatedSpanView;	61	import org.netbeans.editor.view.spi.EstimatedSpanView;
59	import org.netbeans.editor.view.spi.LockView;	62	import org.netbeans.editor.view.spi.LockView;
60	import org.netbeans.editor.view.spi.ViewLayoutState;	63	import org.netbeans.editor.view.spi.ViewLayoutState;
Lines 67-73 Link Here
67	*	70	*
68	* @author Martin Roskanin	71	* @author Martin Roskanin
69	*/	72	*/
70	/* package */ class DrawEngineLineView extends View implements ViewLayoutState, EstimatedSpanView {	73	public class DrawEngineLineView extends View implements ViewLayoutState, EstimatedSpanView {
71		74
72	private static final Logger LOG = Logger.getLogger(DrawEngineLineView.class.getName());	75	private static final Logger LOG = Logger.getLogger(DrawEngineLineView.class.getName());
73	private static final boolean loggable = LOG.isLoggable(Level.FINEST);	76	private static final boolean loggable = LOG.isLoggable(Level.FINEST);

Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawGraphics.java (-11 / +18 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.awt.Graphics;	44	import java.awt.Graphics;
45	import java.awt.Font;	45	import java.awt.Font;
Lines 53-58 Link Here
53	import java.awt.font.TextLayout;	53	import java.awt.font.TextLayout;
54	import javax.swing.JComponent;	54	import javax.swing.JComponent;
55	import javax.swing.text.View;	55	import javax.swing.text.View;
		56	import org.netbeans.editor.Analyzer;
		57	import org.netbeans.editor.AnnotationDesc;
		58	import org.netbeans.editor.AnnotationTypes;
		59	import org.netbeans.editor.Annotations;
		60	import org.netbeans.editor.FontMetricsCache;
		61	import org.netbeans.editor.PrintContainer;
56		62
57	/** Draw graphics functions as abstraction over various kinds of drawing. It's used	63	/** Draw graphics functions as abstraction over various kinds of drawing. It's used
58	* for drawing into classic graphics, printing and measuring.	64	* for drawing into classic graphics, printing and measuring.
Lines 63-69 Link Here
63	* @author Miloslav Metelka	69	* @author Miloslav Metelka
64	* @version 1.00	70	* @version 1.00
65	*/	71	*/
66	interface DrawGraphics {	72	public interface DrawGraphics {
67		73
68	/** Set foreground color */	74	/** Set foreground color */
69	public void setForeColor(Color foreColor);	75	public void setForeColor(Color foreColor);
Lines 191-197 Link Here
191	/** Abstract draw-graphics that maintains a fg and bg color, font,	197	/** Abstract draw-graphics that maintains a fg and bg color, font,
192	* current x and y coordinates.	198	* current x and y coordinates.
193	*/	199	*/
194	static abstract class AbstractDG implements DrawGraphics {	200	public static abstract class AbstractDG implements DrawGraphics {
195		201
196	/** Current foreground color */	202	/** Current foreground color */
197	Color foreColor;	203	Color foreColor;
Lines 326-332 Link Here
326		332
327	} // End of AbstractDG class	333	} // End of AbstractDG class
328		334
329	static class SimpleDG extends AbstractDG {	335	public static class SimpleDG extends AbstractDG {
330		336
331	public Graphics getGraphics() {	337	public Graphics getGraphics() {
332	return null;	338	return null;
Lines 359-365 Link Here
359	* It optimizes the drawing by joining together the pieces of	365	* It optimizes the drawing by joining together the pieces of
360	* the text drawn with the same font and fg/bg color.	366	* the text drawn with the same font and fg/bg color.
361	*/	367	*/
362	static final class GraphicsDG extends SimpleDG {	368	public static final class GraphicsDG extends SimpleDG {
363		369
364	/** Whether debug messages should be displayed */	370	/** Whether debug messages should be displayed */
365	private static final boolean debug	371	private static final boolean debug
Lines 420-426 Link Here
420		426
421	private JComponent component;	427	private JComponent component;
422		428
423	GraphicsDG(Graphics graphics) {	429	public GraphicsDG(Graphics graphics) {
424	this.graphics = graphics;	430	this.graphics = graphics;
425	// #33165 - set invalid y initially	431	// #33165 - set invalid y initially
426	this.y = -1;	432	this.y = -1;
Lines 532-542 Link Here
532	}	538	}
533		539
534	public @Override void init(DrawContext ctx) {	540	public @Override void init(DrawContext ctx) {
		541	EditorUiAccessor accessor = EditorUiAccessor.get();
535	annos = ctx.getEditorUI().getDocument().getAnnotations();	542	annos = ctx.getEditorUI().getDocument().getAnnotations();
536	drawTextLimitLine = ctx.getEditorUI().textLimitLineVisible;	543	drawTextLimitLine = accessor.getTextLimitLineVisible(ctx.getEditorUI());
537	textLimitWidth = ctx.getEditorUI().textLimitWidth();	544	textLimitWidth = accessor.getTextLimitWidth(ctx.getEditorUI());
538	defaultSpaceWidth = ctx.getEditorUI().defaultSpaceWidth;	545	defaultSpaceWidth = accessor.getDefaultSpaceWidth(ctx.getEditorUI());
539	textLimitLineColor = ctx.getEditorUI().getTextLimitLineColor();	546	textLimitLineColor = accessor.getTextLimitLineColor(ctx.getEditorUI());
540	absoluteX = ctx.getEditorUI().getTextMargin().left;	547	absoluteX = ctx.getEditorUI().getTextMargin().left;
541	maxWidth = ctx.getEditorUI().getExtentBounds().width;	548	maxWidth = ctx.getEditorUI().getExtentBounds().width;
542	component = ctx.getEditorUI().getComponent();	549	component = ctx.getEditorUI().getComponent();
Lines 822-828 Link Here
822		829
823	} // End of GraphicsDG class	830	} // End of GraphicsDG class
824		831
825	static final class PrintDG extends SimpleDG {	832	public static final class PrintDG extends SimpleDG {
826		833
827	PrintContainer container;	834	PrintContainer container;
828		835




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

package org.netbeans.modules.editor.lib.drawing;

/** Draw layer applies changes to draw context during painting process.
* Each extended UI has its own set of layers.

*/


/* package */ interface DrawLayer {

    /**
     * Start of the next region with the frame.

    * @param mark draw-mark at the fragment-offset or null if called
    * because of the next-activity-change-offset.
    */
    public boolean isActive(DrawContext ctx, DrawMark mark);

    /** Update draw context by setting colors, fonts and possibly other draw
    * properties.

            return lineNumber;
        }

        public @Override String toString() {
            return "Layer " + getClass() + ", name='" + name; // NOI18N
        }


Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/DrawLayerList.java (-3 / +14 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.util.ArrayList;	44	import java.util.ArrayList;
45	import java.util.Arrays;	45	import java.util.Arrays;
Lines 48-53 Link Here
48	import java.util.Set;	48	import java.util.Set;
49	import java.util.logging.Level;	49	import java.util.logging.Level;
50	import java.util.logging.Logger;	50	import java.util.logging.Logger;
		51	import javax.swing.text.JTextComponent;
		52	import org.netbeans.editor.EditorDebug;
51		53
52	/** Draw layer list stores multiple draw-layers sorted	54	/** Draw layer list stores multiple draw-layers sorted
53	* according to their visibility which is the integer giving the z-order	55	* according to their visibility which is the integer giving the z-order
Lines 59-65 Link Here
59	*/	61	*/
60		62
61		63
62	class DrawLayerList {	64	/* package */ class DrawLayerList {
63		65
64	private static final Logger LOG = Logger.getLogger(DrawLayerList.class.getName());	66	private static final Logger LOG = Logger.getLogger(DrawLayerList.class.getName());
65		67
Lines 71-76 Link Here
71		73
72	private final ArrayList visibilityList = new ArrayList();	74	private final ArrayList visibilityList = new ArrayList();
73		75
		76	public static synchronized DrawLayerList forComponent(JTextComponent jtc) {
		77	DrawLayerList dll = (DrawLayerList) jtc.getClientProperty(DrawLayerList.class);
		78	if (dll == null) {
		79	dll = new DrawLayerList();
		80	jtc.putClientProperty(DrawLayerList.class, dll);
		81	}
		82	return dll;
		83	}
		84
74	/** Add the new layer to the list depending on visibility.	85	/** Add the new layer to the list depending on visibility.
75	* @param layer layer to add to the layer list	86	* @param layer layer to add to the layer list
76	* @return true when new layer was added false otherwise. The layer	87	* @return true when new layer was added false otherwise. The layer
Lines 168-174 Link Here
168	return -1;	179	return -1;
169	}	180	}
170		181
171	public String toString() {	182	public @Override String toString() {
172	switch (layers.length) {	183	switch (layers.length) {
173	case 0:	184	case 0:
174	return "No layers"; // NOI18N	185	return "No layers"; // NOI18N




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

package org.netbeans.modules.editor.lib.drawing;

import java.util.ArrayList;
import java.util.List;

import javax.swing.text.View;
import javax.swing.text.ViewFactory;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.editor.BaseDocument;
import org.netbeans.lib.editor.view.GapMultiLineView;

/**

        return (JTextComponent)getContainer();
    }
    
    protected @Override boolean useCustomReloadChildren() {
        return true;
    }
    
    protected @Override void reloadChildren(int index, int removeLength, int startOffset, int endOffset) {
        // TODO uncomment assert (index == 0 && removeLength == 0
            // && startOffset == getStartOffset() && endOffset == getEndOffset());


Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/HighlightingDrawLayer.java (-28 / +33 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.drawing;
43		43
44	import java.lang.ref.WeakReference;	44	import java.lang.ref.WeakReference;
45	import java.util.ArrayList;	45	import java.util.ArrayList;
Lines 61-67 Link Here
61	import javax.swing.text.SimpleAttributeSet;	61	import javax.swing.text.SimpleAttributeSet;
62	import javax.swing.text.View;	62	import javax.swing.text.View;
63	import org.netbeans.api.editor.settings.AttributesUtilities;	63	import org.netbeans.api.editor.settings.AttributesUtilities;
64	import org.netbeans.editor.ext.ExtCaret;	64	import org.netbeans.editor.AtomicLockEvent;
		65	import org.netbeans.editor.AtomicLockListener;
		66	import org.netbeans.editor.BaseCaret;
		67	import org.netbeans.editor.BaseDocument;
		68	import org.netbeans.editor.Coloring;
65	import org.netbeans.editor.view.spi.LockView;	69	import org.netbeans.editor.view.spi.LockView;
66	import org.netbeans.modules.editor.lib2.highlighting.CaretBasedBlockHighlighting.CaretRowHighlighting;	70	import org.netbeans.modules.editor.lib2.highlighting.CaretBasedBlockHighlighting.CaretRowHighlighting;
67	import org.netbeans.modules.editor.lib2.highlighting.HighlightingManager;	71	import org.netbeans.modules.editor.lib2.highlighting.HighlightingManager;
Lines 80-86 Link Here
80	*	84	*
81	* @author vita	85	* @author vita
82	*/	86	*/
83	/* package */ final class HighlightingDrawLayer extends DrawLayer.AbstractLayer	87	public final class HighlightingDrawLayer extends DrawLayer.AbstractLayer
84	implements HighlightsChangeListener, AtomicLockListener	88	implements HighlightsChangeListener, AtomicLockListener
85	{	89	{
86	// -J-Dorg.netbeans.editor.HighlightingDrawLayer.level=FINE	90	// -J-Dorg.netbeans.editor.HighlightingDrawLayer.level=FINE
Lines 89-96 Link Here
89	// Above CaretRowHighlighting.LAYER_TYPE_ID	93	// Above CaretRowHighlighting.LAYER_TYPE_ID
90	private static final String LAYER_A_NAME = "org-netbeans-lib-editor-nview-HighlightingDrawLayer/A"; //NOI18N	94	private static final String LAYER_A_NAME = "org-netbeans-lib-editor-nview-HighlightingDrawLayer/A"; //NOI18N
91	// above ZOrder.SYNTAX_RACK and below (including) CaretRowHighlighting.LAYER_TYPE_ID	95	// above ZOrder.SYNTAX_RACK and below (including) CaretRowHighlighting.LAYER_TYPE_ID
92	// Using the original name for the caret row highlighting, some clients use it to remove the layer.	96	private static final String LAYER_B_NAME = "org-netbeans-lib-editor-nview-HighlightingDrawLayer/B"; //NOI18N
93	private static final String LAYER_B_NAME = ExtCaret.HIGHLIGHT_ROW_LAYER_NAME;
94	// Only ZOrder.SYNTAX_RACK	97	// Only ZOrder.SYNTAX_RACK
95	private static final String LAYER_C_NAME = "org-netbeans-lib-editor-nview-HighlightingDrawLayer/C"; //NOI18N	98	private static final String LAYER_C_NAME = "org-netbeans-lib-editor-nview-HighlightingDrawLayer/C"; //NOI18N
96	// ZOrder.BOTTOM_RACK	99	// ZOrder.BOTTOM_RACK
Lines 188-247 Link Here
188	}	191	}
189	}; // End of FILTER_D constant	192	}; // End of FILTER_D constant
190		193
191	public static void hookUp(EditorUI eui) {	194	public static void hookUp(JTextComponent jtc) {
192	DrawLayer layerA = eui.findLayer(LAYER_A_NAME);	195	DrawLayerList dll = DrawLayerList.forComponent(jtc);
		196	DrawLayer layerA = dll.findLayer(LAYER_A_NAME);
193	if (layerA == null) {	197	if (layerA == null) {
194	layerA = new HighlightingDrawLayer(LAYER_A_NAME, FILTER_A);	198	layerA = new HighlightingDrawLayer(LAYER_A_NAME, FILTER_A);
195	eui.addLayer(layerA, 10000); // the old text selection layer's z-order (DrawLayerFactory.CaretLayer)	199	dll.add(layerA, 10000); // the old text selection layer's z-order (DrawLayerFactory.CaretLayer)
196		200
197	if (LOG.isLoggable(Level.FINE)) {	201	if (LOG.isLoggable(Level.FINE)) {
198	LOG.fine("Successfully registered layerA in " + simpleToString(eui)); //NOI18N	202	LOG.fine("Successfully registered layerA in " + simpleToString(jtc)); //NOI18N
199	}	203	}
200	} else {	204	} else {
201	if (LOG.isLoggable(Level.FINE)) {	205	if (LOG.isLoggable(Level.FINE)) {
202	LOG.fine("LayerA is already registered in " + simpleToString(eui)); //NOI18N	206	LOG.fine("LayerA is already registered in " + simpleToString(jtc)); //NOI18N
203	}	207	}
204	}	208	}
205		209
206	DrawLayer layerB = eui.findLayer(LAYER_B_NAME);	210	DrawLayer layerB = dll.findLayer(LAYER_B_NAME);
207	if (layerB == null) {	211	if (layerB == null) {
208	layerB = new HighlightingDrawLayer(LAYER_B_NAME, FILTER_B);	212	layerB = new HighlightingDrawLayer(LAYER_B_NAME, FILTER_B);
209	eui.addLayer(layerB, 2050); // the old caret row highlight layer's z-order	213	dll.add(layerB, 2050); // the old caret row highlight layer's z-order
210		214
211	if (LOG.isLoggable(Level.FINE)) {	215	if (LOG.isLoggable(Level.FINE)) {
212	LOG.fine("Successfully registered layerB in " + simpleToString(eui)); //NOI18N	216	LOG.fine("Successfully registered layerB in " + simpleToString(jtc)); //NOI18N
213	}	217	}
214	} else {	218	} else {
215	if (LOG.isLoggable(Level.FINE)) {	219	if (LOG.isLoggable(Level.FINE)) {
216	LOG.fine("LayerB is already registered in " + simpleToString(eui)); //NOI18N	220	LOG.fine("LayerB is already registered in " + simpleToString(jtc)); //NOI18N
217	}	221	}
218	}	222	}
219		223
220	DrawLayer layerC = eui.findLayer(LAYER_C_NAME);	224	DrawLayer layerC = dll.findLayer(LAYER_C_NAME);
221	if (layerC == null) {	225	if (layerC == null) {
222	layerC = new HighlightingDrawLayer(LAYER_C_NAME, FILTER_C);	226	layerC = new HighlightingDrawLayer(LAYER_C_NAME, FILTER_C);
223	eui.addLayer(layerC, 1000); // the old syntax draw layer's z-order (DrawLayerFactory.SyntaxLayer)	227	dll.add(layerC, 1000); // the old syntax draw layer's z-order (DrawLayerFactory.SyntaxLayer)
224		228
225	if (LOG.isLoggable(Level.FINE)) {	229	if (LOG.isLoggable(Level.FINE)) {
226	LOG.fine("Successfully registered layerC in " + simpleToString(eui)); //NOI18N	230	LOG.fine("Successfully registered layerC in " + simpleToString(jtc)); //NOI18N
227	}	231	}
228	} else {	232	} else {
229	if (LOG.isLoggable(Level.FINE)) {	233	if (LOG.isLoggable(Level.FINE)) {
230	LOG.fine("LayerC is already registered in " + simpleToString(eui)); //NOI18N	234	LOG.fine("LayerC is already registered in " + simpleToString(jtc)); //NOI18N
231	}	235	}
232	}	236	}
233		237
234	DrawLayer layerD = eui.findLayer(LAYER_D_NAME);	238	DrawLayer layerD = dll.findLayer(LAYER_D_NAME);
235	if (layerD == null) {	239	if (layerD == null) {
236	layerD = new HighlightingDrawLayer(LAYER_D_NAME, FILTER_D);	240	layerD = new HighlightingDrawLayer(LAYER_D_NAME, FILTER_D);
237	eui.addLayer(layerD, 500);	241	dll.add(layerD, 500);
238		242
239	if (LOG.isLoggable(Level.FINE)) {	243	if (LOG.isLoggable(Level.FINE)) {
240	LOG.fine("Successfully registered layerD in " + simpleToString(eui)); //NOI18N	244	LOG.fine("Successfully registered layerD in " + simpleToString(jtc)); //NOI18N
241	}	245	}
242	} else {	246	} else {
243	if (LOG.isLoggable(Level.FINE)) {	247	if (LOG.isLoggable(Level.FINE)) {
244	LOG.fine("LayerD is already registered in " + simpleToString(eui)); //NOI18N	248	LOG.fine("LayerD is already registered in " + simpleToString(jtc)); //NOI18N
245	}	249	}
246	}	250	}
247	}	251	}
Lines 341-347 Link Here
341	}	345	}
342	}	346	}
343		347
344	public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {	348	public boolean isActive(DrawContext ctx, DrawMark mark) {
345	if (highlights != null) {	349	if (highlights != null) {
346	return processOffset(ctx, false);	350	return processOffset(ctx, false);
347	} else {	351	} else {
Lines 351-371 Link Here
351		355
352	public void updateContext(DrawContext ctx) {	356	public void updateContext(DrawContext ctx) {
353	if (highlights != null) {	357	if (highlights != null) {
		358	ColoringAccessor accessor = ColoringAccessor.get();
354	if (ctx.isEOL() && ctx.isBOL()) {	359	if (ctx.isEOL() && ctx.isBOL()) {
355	if (extendsEmptyLine() && !theLittleSpitAtTheBeginningOfAnEmptyLineDrawn) {	360	if (extendsEmptyLine() && !theLittleSpitAtTheBeginningOfAnEmptyLineDrawn) {
356	theLittleSpitAtTheBeginningOfAnEmptyLineDrawn = true;	361	theLittleSpitAtTheBeginningOfAnEmptyLineDrawn = true;
357	Coloring coloring = Coloring.fromAttributeSet(lastELAttribs);	362	Coloring coloring = Coloring.fromAttributeSet(lastELAttribs);
358	coloring.apply(ctx);	363	accessor.apply(coloring, ctx);
359	} else {	364	} else {
360	if (extendsEOL()) {	365	if (extendsEOL()) {
361	Coloring coloring = Coloring.fromAttributeSet(lastEOLAttribs);	366	Coloring coloring = Coloring.fromAttributeSet(lastEOLAttribs);
362	coloring.apply(ctx);	367	accessor.apply(coloring, ctx);
363	}	368	}
364	}	369	}
365	} else if (ctx.isEOL()) {	370	} else if (ctx.isEOL()) {
366	if (extendsEOL()) {	371	if (extendsEOL()) {
367	Coloring coloring = Coloring.fromAttributeSet(lastEOLAttribs);	372	Coloring coloring = Coloring.fromAttributeSet(lastEOLAttribs);
368	coloring.apply(ctx);	373	accessor.apply(coloring, ctx);
369	}	374	}
370	} else {	375	} else {
371	processOffset(ctx, true);	376	processOffset(ctx, true);
Lines 624-630 Link Here
624	if (hs.getStartOffset() <= currentOffset) {	629	if (hs.getStartOffset() <= currentOffset) {
625	if (applyAttributes) {	630	if (applyAttributes) {
626	Coloring coloring = Coloring.fromAttributeSet(hs.getAttributes());	631	Coloring coloring = Coloring.fromAttributeSet(hs.getAttributes());
627	coloring.apply(ctx);	632	ColoringAccessor.get().apply(coloring, ctx);
628	}	633	}
629		634
630	lastAttributeSet = hs.getAttributes();	635	lastAttributeSet = hs.getAttributes();
Lines 676-682 Link Here
676		681
677	return new AttributeSet [] { eolAttribs, elAttribs };	682	return new AttributeSet [] { eolAttribs, elAttribs };
678	}	683	}
679		684
680	private static String simpleToString(Object o) {	685	private static String simpleToString(Object o) {
681	return o == null ? "null" : o.getClass() + "@" + Integer.toHexString(System.identityHashCode(o)); //NOI18N	686	return o == null ? "null" : o.getClass() + "@" + Integer.toHexString(System.identityHashCode(o)); //NOI18N
682	}	687	}




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

package org.netbeans.modules.editor.lib.drawing;

import javax.swing.text.BadLocationException;
import javax.swing.text.Position;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.InvalidMarkException;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.lib.EditorPackageAccessor;

/**
* Support class for chain of MarkBlocks

* @version 1.00
*/

public final class MarkChain {

    /** Chain of all marks */
    protected ChainDrawMark chain;

    /** Current mark to make checks faster */
    protected ChainDrawMark curMark;

    /** Document for this mark */
    protected BaseDocument doc;

    /** The mark created by addMark() method is stored in this variable. In case
     * the mark was not created, because there already was some on this position,
     * the already existing mark is returned. */
    private ChainDrawMark recentlyAddedMark;
    
    /** Construct chain using draw marks */
    public MarkChain(BaseDocument doc, String layerName) {

        this.layerName = layerName;
    }

    public final ChainDrawMark getChain() {
        return chain;
    }

    public final ChainDrawMark getCurMark() {
        return curMark;
    }


        }
    }

    protected ChainDrawMark createAndInsertNewMark(int pos)
    throws BadLocationException {
        ChainDrawMark mark = createMark();
        try {
            EditorPackageAccessor.get().Mark_insert(mark, doc, pos);
        } catch (InvalidMarkException e) {
            Utilities.annotateLoggable(e);
        }
        return mark;
    }

    protected ChainDrawMark createMark() {
        ChainDrawMark mark = new ChainDrawMark(layerName, null, Position.Bias.Backward);
        mark.activateLayer = true;
        return mark;
    }

        int rel = compareMark(pos);
        if (rel == 0) {
            if (forceAdd) { // create fresh
                ChainDrawMark mark = createAndInsertNewMark(pos);
                recentlyAddedMark = mark;
                if (curMark == chain) { // curMark is first mark
                    chain = curMark.insertChain(mark);

            }

        } else if (rel > 0) { // curMark after pos
            ChainDrawMark mark = createAndInsertNewMark(pos);
            recentlyAddedMark = mark;
            if (curMark != null) {
                if (curMark == chain) { // curMark is first mark

                chain = mark;
            }
        } else { // curMark before pos
            ChainDrawMark mark = createAndInsertNewMark(pos);
            recentlyAddedMark = mark;
            if (curMark != null) {
                if (curMark.next != null) {

    /** The mark created by addMark() method is returned by this method. In case
     * the mark was not created, because there already was some on requested position,
     * the already existing mark is returned. */
    public ChainDrawMark getAddedMark() {
        return recentlyAddedMark;
    }
    

        }
    }
    
    public boolean removeMark(ChainDrawMark mark) {
        if (mark == null) {
            throw new NullPointerException();
        }




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

package org.netbeans.modules.editor.lib.impl;

import javax.swing.text.BadLocationException;
import javax.swing.text.Position;

* @version 1.00
*/

public final class BasePosition implements Position {

    /** The mark that serves this position */
    private MultiMark mark;

    public BasePosition() throws BadLocationException {
    }

    /** Get offset in document for this position */




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

package org.netbeans.modules.editor.lib.impl;

import java.util.List;
import javax.swing.text.Position;

 * @version 1.00
 */

public final class MarkVector {

    /** Empty array of marks used initially as markArray. */
    private static final MultiMark[] EMPTY = new MultiMark[0];

     */
    private int disposedMarkCount;
    
    public MarkVector() {
        markArray = EMPTY;
        offsetGapLength = INITIAL_OFFSET_GAP_SIZE;
    }

     * @param offset offset of the mark.
     * @param bias bias of the mark.
     */
    public MultiMark createBiasMark(int offset, Position.Bias bias) {
        return new MultiMark(null, this, offset, bias);
    }
    

     * @param offset offset of the mark.
     * @param bias bias of the mark.
     */
    public MultiMark createBiasMark(BasePosition pos, int offset, Position.Bias bias) {
        return new MultiMark(pos, this, offset, bias);
    }
    

     * inserted into the vector.
     * @param offset offset of the mark.
     */
    public MultiMark createMark(int offset) {
        return new MultiMark(null, this, offset);
    }
    

     * @param pos position that will delegate to this mark.
     * @param offset offset of the mark.
     */
    public MultiMark createMark(BasePosition pos, int offset) {
        return new MultiMark(pos, this, offset);
    }
    
    /** @return total count of marks in the vector.
     */
    public synchronized int getMarkCount() {
        return markArray.length - gapLength;
    }
    
    public synchronized MultiMark getMark(int index) {
        return markArray[getRawIndex(index)];
    }
    
    public synchronized int getMarkOffsetInternal(int index) {
        return getOffset(getMark(index).rawOffset);
    }


     * @param mark mark to insert. The mark must have the valid
     *  offset and flags filled in.
     */
    public synchronized MultiMark insert(MultiMark mark) {
        int flags = mark.flags;
        if ((flags & MultiMark.VALID) != 0) { // trying to re-insert valid mark
            throw new IllegalStateException();

        }
    }

    public synchronized void compact() {
        if (gapLength > 0) {
            int newLength = markArray.length - gapLength;
            MultiMark[] newMarkArray = new MultiMark[newLength];

     * @return non-null undo record or null in case an insert was done
     *  or there are no marks to be undone.
     */
    public synchronized Undo update(int offset, int length, Undo undo) {
        if (length < 0) { // removal occured - temporarily increase offset var
            offset -= length; // move offset after end of removal (length < 0)
        }

    
    /** Undo record holding the info about undo items.
     */
    public static final class Undo {
        
        Undo(UndoItem firstItem, UndoItem fbItem, UndoItem bbItem,
        ZeroUndoItem zeroItem) {

Lines 39-45 Link Here

(-)a/editor.lib/src/org/netbeans/editor/MultiMark.java (-2 / +2 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.editor;	42	package org.netbeans.modules.editor.lib.impl;
43		43
44	import java.lang.ref.WeakReference;	44	import java.lang.ref.WeakReference;
45	import javax.swing.text.Position;	45	import javax.swing.text.Position;
Lines 54-60 Link Here
54	* @version 1.00	54	* @version 1.00
55	*/	55	*/
56		56
57	final class MultiMark extends WeakReference<BasePosition> implements Runnable {	57	public final class MultiMark extends WeakReference<BasePosition> implements Runnable {
58		58
59	/** Whether mark has a backward (or forward) bias */	59	/** Whether mark has a backward (or forward) bias */
60	static final int BACKWARD_BIAS = 1;	60	static final int BACKWARD_BIAS = 1;

Lines 39-44 Link Here

(-)a/editor.lib/test/unit/src/org/netbeans/editor/DrawEngineTest.java (+2 lines)
39	import javax.swing.text.Position;	39	import javax.swing.text.Position;
40	import javax.swing.text.View;	40	import javax.swing.text.View;
41	import org.netbeans.junit.NbTestCase;	41	import org.netbeans.junit.NbTestCase;
		42	import org.netbeans.modules.editor.lib.drawing.DrawEngineDocView;
		43	import org.netbeans.modules.editor.lib.drawing.DrawEngineLineView;
42		44
43	/**	45	/**
44	*	46	*




    }
    
    private void init() {
        addStyleToLayerMapping(NbDocument.BREAKPOINT_STYLE_NAME,
                               NbDocument.BREAKPOINT_STYLE_NAME + "Layer:10"); // NOI18N
        addStyleToLayerMapping(NbDocument.ERROR_STYLE_NAME,
                               NbDocument.ERROR_STYLE_NAME + "Layer:20"); // NOI18N
        addStyleToLayerMapping(NbDocument.CURRENT_STYLE_NAME,
                               NbDocument.CURRENT_STYLE_NAME + "Layer:30"); // NOI18N
        setNormalStyleName(NbDocument.NORMAL_STYLE_NAME);
        
        annoMap = new HashMap(20);




import javax.swing.text.Document;
import javax.swing.tree.DefaultTreeModel;
import org.netbeans.api.editor.DialogBinding;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.ext.ExtCaret;

import org.openide.ErrorManager;
import org.openide.util.*;

        DialogBinding.bindComponentToDocument(document, ccPosition, 0, editor);

        // do not highlight current row
        editor.putClientProperty(
            "HighlightsLayerExcludes", //NOI18N
            "^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
        );

        setupTextUndoRedo(editor);
    }




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
 *
 * 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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.editor.ext.java;

import javax.swing.text.BadLocationException;

import org.netbeans.editor.*;
import org.netbeans.editor.ext.ExtSyntaxSupport;

/**
 * Various java-layers
 *
 * @author Miloslav Metelka
 * @version 1.00
 * @deprecated Please use Highlighting SPI instead, for details see
 *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
 */

public class JavaDrawLayerFactory {

    public static final String JAVA_LAYER_NAME = "java-layer"; // NOI18N

    public static final int JAVA_LAYER_VISIBILITY = 1010;

    /** Layer that colors extra java information like the methods or special
     * characters in the character and string literals.
     * 
     * @deprecated Please use Highlighting SPI instead, for details see
     *   <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
     */
    public static class JavaLayer extends DrawLayer.AbstractLayer {

        /** End of the area that is resolved right now. It saves
         * repetitive searches for '(' for multiple fragments
         * inside one identifier token.
         */
        private int resolvedEndOffset;

        private boolean resolvedValue;

        private NonWhitespaceFwdFinder nwFinder = new NonWhitespaceFwdFinder();

        public JavaLayer() {
            super(JAVA_LAYER_NAME);
        }

        public void init(DrawContext ctx) {
            resolvedEndOffset = 0; // nothing resolved
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            int nextOffset = ctx.getTokenOffset() + ctx.getTokenLength();

            setNextActivityChangeOffset(nextOffset);
            return true;
        }

        protected Coloring getMethodColoring(DrawContext ctx) {
            TokenContextPath path = ctx.getTokenContextPath().replaceStart(
                JavaLayerTokenContext.contextPath);
            return ctx.getEditorUI().getColoring(
                path.getFullTokenName(JavaLayerTokenContext.METHOD));
        }

        private boolean isMethod(DrawContext ctx) {
            int idEndOffset = ctx.getTokenOffset() + ctx.getTokenLength();
            if (idEndOffset > resolvedEndOffset) { // beyond the resolved area
                resolvedEndOffset = idEndOffset; // will resolve now
                int endOffset = ctx.getEndOffset();
                int bufferStartOffset = ctx.getBufferStartOffset();
                char[] buffer = ctx.getBuffer();
                ExtSyntaxSupport sup = (ExtSyntaxSupport) ctx.getEditorUI().getDocument().getSyntaxSupport().get(ExtSyntaxSupport.class);
                int nwOffset = Analyzer.findFirstNonWhite(buffer,
                        idEndOffset - bufferStartOffset,
                        endOffset - idEndOffset);
                if (nwOffset >= 0) { // found non-white
                    resolvedValue = (buffer[nwOffset] == '(');
                    if (!resolvedValue && buffer[nwOffset] == '<') {
                        try {
                            int[] block = sup.findMatchingBlock(ctx.getBufferStartOffset() + nwOffset, true);
                            if (block != null) {
                                int off = Utilities.getFirstNonWhiteFwd(ctx.getEditorUI().getDocument(), block[1]);
                                if (off > -1) {
                                    if (bufferStartOffset + buffer.length > off) {
                                        resolvedValue = (buffer[off - bufferStartOffset] == '(');
                                    } else {
                                        resolvedValue = (ctx.getEditorUI().getDocument().getChars(off, 1)[0] == '(');
                                    }
                                }
                            }
                        } catch (BadLocationException e) {
                            resolvedValue = false;
                        }
                    }
                } else { // must resolve after buffer end
                    try {
                        int off = ctx.getEditorUI().getDocument().find(nwFinder, endOffset, -1);
                        resolvedValue = off >= 0 && (nwFinder.getFoundChar() == '(');
                        if (!resolvedValue && nwFinder.getFoundChar() == '<') {
                            int[] block = sup.findMatchingBlock(off, true);
                            if (block != null) {
                                off = Utilities.getFirstNonWhiteFwd(ctx.getEditorUI().getDocument(), block[1]);
                                if (off > -1)
                                    resolvedValue = (ctx.getEditorUI().getDocument().getChars(off, 1)[0] == '(');
                            }
                        }
                    } catch (BadLocationException e) {
                        resolvedValue = false;
                    }
                }
            }

            return resolvedValue;
        }

        public void updateContext(DrawContext ctx) {
            if (ctx.getTokenID() == JavaTokenContext.IDENTIFIER && isMethod(ctx)) {
                Coloring mc = getMethodColoring(ctx);
                if (mc != null) {
                    mc.apply(ctx);
                }
            }
        }

    }

    /** Find first non-white character forward */
    static class NonWhitespaceFwdFinder extends FinderFactory.GenericFwdFinder {

        private char foundChar;

        public char getFoundChar() {
            return foundChar;
        }

        protected int scan(char ch, boolean lastChar) {
            if (!Character.isWhitespace(ch)) {
                found = true;
                foundChar = ch;
                return 0;
            }
            return 1;
        }
    }

    /** Find first non-white character backward */
    public static class NonWhitespaceBwdFinder extends FinderFactory.GenericBwdFinder {

        private char foundChar;

        public char getFoundChar() {
            return foundChar;
        }

        protected int scan(char ch, boolean lastChar) {
            if (!Character.isWhitespace(ch)) {
                found = true;
                foundChar = ch;
                return 0;
            }
            return -1;
        }
    }

}





        editor.errorstripe.api,\
        editor.fold,\
        editor.guards,\
        editor.highlights,\
        editor.indent,\
        editor.kit,\
        editor.lib,\

        languages.manifest,\
        languages.yaml,\
        lexer,\
        lexer.editorbridge,\
        lexer.nbbridge,\
        lib.cvsclient,\
        libs.bugtracking,\

        contrib/glassfish.v3enable,\
        contrib/graphicclassview,\
        contrib/group,\
        contrib/gsf.tools,\
        contrib/hexeditor,\
        contrib/htmlprojects,\
        contrib/hudsonfindbugs,\




import java.awt.Insets;
import java.awt.event.ActionListener;
import java.io.IOException;
import javax.naming.event.EventDirContext;
import javax.swing.text.StyledDocument;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.ext.ExtCaret;
import org.openide.ErrorManager;
import org.openide.cookies.EditorCookie;
import org.openide.text.NbDocument;

        final Runnable runnable = new Runnable() {
            public void run() {
                EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);
                if (eui == null) {
                    return ;
                }
                editorPane.putClientProperty(
                    "HighlightsLayerExcludes", //NOI18N
                    "^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
                );
                // Do not draw text limit line
                try {
                    java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N




import javax.swing.text.StyledDocument;
import org.netbeans.api.editor.DialogBinding;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.ext.ExtCaret;
import org.netbeans.spi.debugger.ui.EditorContextDispatcher;
import org.openide.ErrorManager;
import org.openide.cookies.EditorCookie;

        Runnable runnable = new Runnable() {
            public void run() {
                EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);
                if (eui == null) {
                    return;
                }
                editorPane.putClientProperty(
                    "HighlightsLayerExcludes", //NOI18N
                    "^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
                );
                // Do not draw text limit line
                try {
                    java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
 *
 * 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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

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

import org.netbeans.modules.web.core.syntax.deprecated.ELLayerTokenContext;
import org.netbeans.modules.web.core.syntax.*;
import javax.swing.text.BadLocationException;
import javax.swing.event.DocumentListener;
import javax.swing.event.DocumentEvent;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.BaseDocumentEvent;
import org.netbeans.editor.Coloring;
import org.netbeans.editor.DrawContext;
import org.netbeans.editor.DrawLayer;
import org.netbeans.editor.MarkFactory;
import org.netbeans.editor.FinderFactory;
import org.netbeans.editor.Analyzer;

/**
* Various EL-layers
*
* @author Petr Pisl
* @deprecated Will be replaced by Semantic Coloring
*/

public class ELDrawLayerFactory {

    public static final String EL_LAYER_NAME = "jsp-el-layer"; // NOI18N

    public static final int EL_LAYER_VISIBILITY = 1010;

    /** Layer that colors extra EL information like the methods or special
     * characters in the character and string literals.
     */
    public static class ELLayer extends DrawLayer.AbstractLayer {

        /** End of the area that is resolved right now. It saves
         * repetitive searches for '(' for multiple fragments
         * inside one identifier token.
         */
        private int resolvedEndOffset;

        private boolean resolvedValue;

        private NonWhitespaceFwdFinder nwFinder = new NonWhitespaceFwdFinder();

        public ELLayer() {
            super(EL_LAYER_NAME);
        }

        public void init(DrawContext ctx) {
            resolvedEndOffset = 0; // nothing resolved
        }

        public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
            int nextOffset = ctx.getTokenOffset() + ctx.getTokenLength();

            setNextActivityChangeOffset(nextOffset);
            return true;
        }

        protected Coloring getMethodColoring(DrawContext ctx) {
	    
	    /*TokenContextPath path = ctx.getTokenContextPath().replaceStart(
		    ELLayerTokenContext.contextPath);
		return ctx.getEditorUI().getColoring(
		    path.getFullTokenName(ELLayerTokenContext.METHOD));
	    */
	   
	   return ctx.getEditorUI().getColoring(ELLayerTokenContext.contextPath.getFullTokenName(ELLayerTokenContext.METHOD));
        }

        private boolean isMethod(DrawContext ctx) {
	    
            int idEndOffset = ctx.getTokenOffset() + ctx.getTokenLength();
            if (idEndOffset > resolvedEndOffset) { // beyond the resolved area
                resolvedEndOffset = idEndOffset; // will resolve now
                int endOffset = ctx.getEndOffset();		
                int bufferStartOffset = ctx.getBufferStartOffset();
                char[] buffer = ctx.getBuffer();
                int nwOffset = Analyzer.findFirstNonWhite(buffer,
                        idEndOffset - bufferStartOffset,
                        endOffset - idEndOffset);
                if (nwOffset >= 0) { // found non-white
                    resolvedValue = (buffer[nwOffset] == '(');
                } else { // must resolve after buffer end
                    try {
                        resolvedValue = (ctx.getEditorUI().getDocument().find(
                            nwFinder, endOffset, -1) >= 0)
                                && (nwFinder.getFoundChar() == '(');
                    } catch (BadLocationException e) {
                        resolvedValue = false;
                    }
                }
            }
            return resolvedValue;
        }
	/** Update draw context by setting colors, fonts and possibly other draw
	* properties.
	* The method can use information from the context to find where the painting
	* process is currently located. It is called only if the layer is active.
	*/
        public void updateContext(DrawContext ctx) {
            if (ctx.getTokenID() == ELTokenContext.IDENTIFIER && isMethod(ctx)) {
                Coloring mc = getMethodColoring(ctx);
                if (mc != null) {
                    mc.apply(ctx);
                }
            }
        }

    }

    /** Find first non-white character forward */
    static class NonWhitespaceFwdFinder extends FinderFactory.GenericFwdFinder {

        private char foundChar;

        public char getFoundChar() {
            return foundChar;
        }

        protected int scan(char ch, boolean lastChar) {
            if (!Character.isWhitespace(ch)) {
                found = true;
                foundChar = ch;
                return 0;
            }
            return 1;
        }
    }

    /** Find first non-white character backward */
    public static class NonWhitespaceBwdFinder extends FinderFactory.GenericBwdFinder {

        private char foundChar;

        public char getFoundChar() {
            return foundChar;
        }

        protected int scan(char ch, boolean lastChar) {
            if (!Character.isWhitespace(ch)) {
                found = true;
                foundChar = ch;
                return 0;
            }
            return -1;
        }
    }

}





        public XMLEditorDocument(String mimeType) {
            super(mimeType);
        }
        
        public @Override boolean addLayer(DrawLayer layer, int visibility) {
            //filter out the syntax layer adding
            if(!(layer instanceof DrawLayerFactory.SyntaxLayer)) {
                return super.addLayer(layer, visibility);
            } else {
                return false;
            }
        }
    }
}

Return to bug 97517

Lines 42-48 Link Here

(-)a/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/WatchPanel.java (-4 / +4 lines)
42		42
43	import java.awt.AWTKeyStroke;	43	import java.awt.AWTKeyStroke;
44	import java.awt.Dimension;	44	import java.awt.Dimension;
45	import java.awt.FontMetrics;
46	import java.awt.KeyboardFocusManager;	45	import java.awt.KeyboardFocusManager;
47	import java.awt.event.ActionEvent;	46	import java.awt.event.ActionEvent;
48	import java.lang.reflect.InvocationTargetException;	47	import java.lang.reflect.InvocationTargetException;
Lines 71-83 Link Here
71	import java.awt.EventQueue;	70	import java.awt.EventQueue;
72	import java.awt.GridBagConstraints;	71	import java.awt.GridBagConstraints;
73	import java.awt.GridBagLayout;	72	import java.awt.GridBagLayout;
74	import java.awt.Insets;
75	import java.awt.event.ActionListener;	73	import java.awt.event.ActionListener;
76	import java.io.IOException;	74	import java.io.IOException;
77	import javax.swing.text.StyledDocument;	75	import javax.swing.text.StyledDocument;
78	import org.netbeans.api.debugger.Session;	76	import org.netbeans.api.debugger.Session;
79	import org.netbeans.editor.EditorUI;	77	import org.netbeans.editor.EditorUI;
80	import org.netbeans.editor.ext.ExtCaret;
81	import org.netbeans.spi.debugger.jpda.EditorContext;	78	import org.netbeans.spi.debugger.jpda.EditorContext;
82	import org.netbeans.spi.debugger.ui.EditorContextDispatcher;	79	import org.netbeans.spi.debugger.ui.EditorContextDispatcher;
83	import org.openide.ErrorManager;	80	import org.openide.ErrorManager;
Lines 254-260 Link Here
254	if (eui == null) {	251	if (eui == null) {
255	return ;	252	return ;
256	}	253	}
257	eui.removeLayer(ExtCaret.HIGHLIGHT_ROW_LAYER_NAME);	254	editorPane.putClientProperty(
		255	"HighlightsLayerExcludes", //NOI18N
		256	"^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
		257	);
258	// Do not draw text limit line	258	// Do not draw text limit line
259	try {	259	try {
260	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N	260	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N

Lines 50-56 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseDocumentEvent.java (-58 / +15 lines)
50	import javax.swing.event.DocumentEvent;	50	import javax.swing.event.DocumentEvent;
51	import javax.swing.text.AttributeSet;	51	import javax.swing.text.AttributeSet;
52	import javax.swing.undo.UndoableEdit;	52	import javax.swing.undo.UndoableEdit;
53	import javax.swing.undo.AbstractUndoableEdit;
54	import javax.swing.undo.CannotUndoException;	53	import javax.swing.undo.CannotUndoException;
55	import javax.swing.undo.CannotRedoException;	54	import javax.swing.undo.CannotRedoException;
56		55
Lines 238-263 Link Here
238	return getFixLineSyntaxState().getSyntaxUpdateTokenList();	237	return getFixLineSyntaxState().getSyntaxUpdateTokenList();
239	}	238	}
240		239
241	public String getDrawLayerName() {
242	if (getType() != DocumentEvent.EventType.CHANGE) {
243	throw new IllegalStateException("Can be called for CHANGE events only."); // NOI18N
244	}
245
246	DrawLayerChange dlc = (DrawLayerChange)findEdit(DrawLayerChange.class);
247
248	return (dlc != null) ? dlc.getDrawLayerName() : null;
249	}
250
251	public int getDrawLayerVisibility() {
252	if (getType() != DocumentEvent.EventType.CHANGE) {
253	throw new IllegalStateException("Can be called for CHANGE events only."); // NOI18N
254	}
255
256	DrawLayerChange dlc = (DrawLayerChange)findEdit(DrawLayerChange.class);
257
258	return (dlc != null) ? dlc.getDrawLayerVisibility() : -1;
259	}
260
261	/** Whether this event is being fired because it's being undone. */	240	/** Whether this event is being fired because it's being undone. */
262	public boolean isInUndo() {	241	public boolean isInUndo() {
263	return inUndo;	242	return inUndo;
Lines 268-274 Link Here
268	return inRedo;	247	return inRedo;
269	}	248	}
270		249
271	public void undo() throws CannotUndoException {	250	public @Override void undo() throws CannotUndoException {
272	BaseDocument doc = (BaseDocument)getDocument();	251	BaseDocument doc = (BaseDocument)getDocument();
273	doc.incrementDocVersion();	252	doc.incrementDocVersion();
274		253
Lines 328-334 Link Here
328	inUndo = false;	307	inUndo = false;
329	}	308	}
330		309
331	public void redo() throws CannotRedoException {	310	public @Override void redo() throws CannotRedoException {
332	BaseDocument doc = (BaseDocument)getDocument();	311	BaseDocument doc = (BaseDocument)getDocument();
333	doc.incrementDocVersion();	312	doc.incrementDocVersion();
334		313
Lines 386-392 Link Here
386	inRedo = false;	365	inRedo = false;
387	}	366	}
388		367
389	public boolean addEdit(UndoableEdit anEdit) {	368	public @Override boolean addEdit(UndoableEdit anEdit) {
390	// Super of addEdit()	369	// Super of addEdit()
391		370
392	// if the number of changes gets too great, start using	371	// if the number of changes gets too great, start using
Lines 458-464 Link Here
458	}	437	}
459	}	438	}
460		439
461	public boolean canUndo() {	440	public @Override boolean canUndo() {
462	// Super of canUndo	441	// Super of canUndo
463	return !inProgress2 && alive2 && hasBeenDone2	442	return !inProgress2 && alive2 && hasBeenDone2
464	// End super of canUndo	443	// End super of canUndo
Lines 470-493 Link Here
470	*	449	*
471	* @see #isInProgress	450	* @see #isInProgress
472	*/	451	*/
473	public boolean canRedo() {	452	public @Override boolean canRedo() {
474	// Super of canRedo	453	// Super of canRedo
475	return !inProgress2 && alive2 && !hasBeenDone2;	454	return !inProgress2 && alive2 && !hasBeenDone2;
476	// End super of canRedo	455	// End super of canRedo
477	}	456	}
478		457
479	public boolean isInProgress() {	458	public @Override boolean isInProgress() {
480	// Super of isInProgress()	459	// Super of isInProgress()
481	return inProgress2;	460	return inProgress2;
482	// End super of isInProgress()	461	// End super of isInProgress()
483	}	462	}
484		463
485	public String getUndoPresentationName() {	464	public @Override String getUndoPresentationName() {
486	return "";	465	return ""; //NOI18N
487	}	466	}
488		467
489	public String getRedoPresentationName() {	468	public @Override String getRedoPresentationName() {
490	return "";	469	return ""; //NOI18N
491	}	470	}
492		471
493	/** Returns true if this event can be merged by the previous	472	/** Returns true if this event can be merged by the previous
Lines 532-538 Link Here
532	* parts (words) and undoing/redoing them at once.	511	* parts (words) and undoing/redoing them at once.
533	* This method returns true whether	512	* This method returns true whether
534	*/	513	*/
535	public boolean replaceEdit(UndoableEdit anEdit) {	514	public @Override boolean replaceEdit(UndoableEdit anEdit) {
536	BaseDocument doc = (BaseDocument)getDocument();	515	BaseDocument doc = (BaseDocument)getDocument();
537	if (anEdit instanceof BaseDocument.AtomicCompoundEdit) {	516	if (anEdit instanceof BaseDocument.AtomicCompoundEdit) {
538	BaseDocument.AtomicCompoundEdit compEdit	517	BaseDocument.AtomicCompoundEdit compEdit
Lines 557-563 Link Here
557	return false;	536	return false;
558	}	537	}
559		538
560	public void die() {	539	public @Override void die() {
561	// Super of die()	540	// Super of die()
562	int size = edits.size();	541	int size = edits.size();
563	for (int i = size-1; i >= 0; i--)	542	for (int i = size-1; i >= 0; i--)
Lines 575-587 Link Here
575	}	554	}
576	}	555	}
577		556
578	public void end() {	557	public @Override void end() {
579	// Super of end()	558	// Super of end()
580	inProgress2 = false;	559	inProgress2 = false;
581	// End super of end()	560	// End super of end()
582	}	561	}
583		562
584	public DocumentEvent.ElementChange getChange(Element elem) {	563	public @Override DocumentEvent.ElementChange getChange(Element elem) {
585	// Super of getChange()	564	// Super of getChange()
586	if (changeLookup2 != null) {	565	if (changeLookup2 != null) {
587	return (DocumentEvent.ElementChange) changeLookup2.get(elem);	566	return (DocumentEvent.ElementChange) changeLookup2.get(elem);
Lines 601-633 Link Here
601	}	580	}
602		581
603		582
604	public String toString() {	583	public @Override String toString() {
605	return System.identityHashCode(this) + " " + super.toString() // NOI18N	584	return System.identityHashCode(this) + " " + super.toString() // NOI18N
606	+ ", type=" + getType() // NOI18N	585	+ ", type=" + getType() // NOI18N
607	+ ((getType() != DocumentEvent.EventType.CHANGE)	586	+ ((getType() != DocumentEvent.EventType.CHANGE)
608	? ("text='" + getText() + "'") : ""); // NOI18N	587	? ("text='" + getText() + "'") : ""); // NOI18N
609	}	588	}
610		589
611	/** Edit describing the change of the document draw-layers */
612	static class DrawLayerChange extends AbstractUndoableEdit {
613
614	String drawLayerName;
615
616	int drawLayerVisibility;
617
618	DrawLayerChange(String drawLayerName, int drawLayerVisibility) {
619	this.drawLayerName = drawLayerName;
620	this.drawLayerVisibility = drawLayerVisibility;
621	}
622
623	public String getDrawLayerName() {
624	return drawLayerName;
625	}
626
627	public int getDrawLayerVisibility() {
628	return drawLayerVisibility;
629	}
630
631	}
632
633	}	590	}

Lines 51-56 Link Here

(-)a/editor.lib/src/org/netbeans/editor/LeafView.java (-13 / +17 lines)
51	import javax.swing.text.BadLocationException;	51	import javax.swing.text.BadLocationException;
52	import javax.swing.text.Document;	52	import javax.swing.text.Document;
53	import javax.swing.event.DocumentEvent;	53	import javax.swing.event.DocumentEvent;
		54	import org.netbeans.modules.editor.lib.drawing.DrawContext;
		55	import org.netbeans.modules.editor.lib.drawing.DrawEngine;
		56	import org.netbeans.modules.editor.lib.drawing.DrawGraphics;
54		57
55	/**	58	/**
56	* Leaf view implementation. This corresponds and requires leaf element	59	* Leaf view implementation. This corresponds and requires leaf element
Lines 103-119 Link Here
103	protected int mainHeight;	106	protected int mainHeight;
104		107
105	/** Draw graphics for converting position to coords */	108	/** Draw graphics for converting position to coords */
106	ModelToViewDG modelToViewDG = new ModelToViewDG();	109	final ModelToViewDG modelToViewDG = new ModelToViewDG();
107		110
108	/** Draw graphics for converting coords to position */	111	/** Draw graphics for converting coords to position */
109	ViewToModelDG viewToModelDG = new ViewToModelDG();	112	final ViewToModelDG viewToModelDG = new ViewToModelDG();
110		113
111	/** Construct new base view */	114	/** Construct new base view */
112	public LeafView(Element elem) {	115	public LeafView(Element elem) {
113	super(elem);	116	super(elem);
114	}	117	}
115		118
116	public void setParent(View parent) {	119	public @Override void setParent(View parent) {
117	super.setParent(parent);	120	super.setParent(parent);
118		121
119	if (getParent() != null) {	122	if (getParent() != null) {
Lines 173-179 Link Here
173	int pos = getPosFromY(clipY + clipHeight - 1);	176	int pos = getPosFromY(clipY + clipHeight - 1);
174	int endPos = Utilities.getRowEnd(doc, pos);	177	int endPos = Utilities.getRowEnd(doc, pos);
175	int baseY = getYFromPos(startPos);	178	int baseY = getYFromPos(startPos);
176	DrawEngine.getDrawEngine().draw(new DrawGraphics.GraphicsDG(g),	179	DrawEngine.getDrawEngine().draw(
		180	new DrawGraphics.GraphicsDG(g),
177	editorUI, startPos, endPos,	181	editorUI, startPos, endPos,
178	getBaseX(baseY), baseY, Integer.MAX_VALUE	182	getBaseX(baseY), baseY, Integer.MAX_VALUE
179	);	183	);
Lines 249-265 Link Here
249	}	253	}
250		254
251	/** Returns the number of child views in this view. */	255	/** Returns the number of child views in this view. */
252	public final int getViewCount() {	256	public @Override final int getViewCount() {
253	return 0;	257	return 0;
254	}	258	}
255		259
256	/** Gets the n-th child view. */	260	/** Gets the n-th child view. */
257	public final View getView(int n) {	261	public @Override final View getView(int n) {
258	return null;	262	return null;
259	}	263	}
260		264
261	/** !!! osetrit konec view -> jump na dalsi v branchview */	265	/** !!! osetrit konec view -> jump na dalsi v branchview */
262	public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,	266	public @Override int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a,
263	int direction, Position.Bias[] biasRet)	267	int direction, Position.Bias[] biasRet)
264	throws BadLocationException {	268	throws BadLocationException {
265	if (biasRet != null) {	269	if (biasRet != null) {
Lines 342-348 Link Here
342	return ret;	346	return ret;
343	}	347	}
344		348
345	public Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1,	349	public @Override Shape modelToView(int p0, Position.Bias b0, int p1, Position.Bias b1,
346	Shape a) throws BadLocationException {	350	Shape a) throws BadLocationException {
347	Rectangle r0 = (Rectangle)modelToView(p0, a, b0);	351	Rectangle r0 = (Rectangle)modelToView(p0, a, b0);
348	Rectangle r1 = (Rectangle)modelToView(p1, a, b1);	352	Rectangle r1 = (Rectangle)modelToView(p1, a, b1);
Lines 413-419 Link Here
413	* @param a the current allocation of the view	417	* @param a the current allocation of the view
414	* @param f the factory to use to rebuild if the view has children	418	* @param f the factory to use to rebuild if the view has children
415	*/	419	*/
416	public void insertUpdate(DocumentEvent evt, Shape a, ViewFactory f) {	420	public @Override void insertUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
417	try {	421	try {
418	BaseDocumentEvent bevt = (BaseDocumentEvent)evt;	422	BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
419	EditorUI editorUI = getEditorUI();	423	EditorUI editorUI = getEditorUI();
Lines 449-455 Link Here
449	* @param a the current allocation of the view	453	* @param a the current allocation of the view
450	* @param f the factory to use to rebuild if the view has children	454	* @param f the factory to use to rebuild if the view has children
451	*/	455	*/
452	public void removeUpdate(DocumentEvent evt, Shape a, ViewFactory f) {	456	public @Override void removeUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
453	try {	457	try {
454	BaseDocumentEvent bevt = (BaseDocumentEvent)evt;	458	BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
455	EditorUI editorUI = getEditorUI();	459	EditorUI editorUI = getEditorUI();
Lines 482-488 Link Here
482	* @param a the current allocation of the view	486	* @param a the current allocation of the view
483	* @param f the factory to use to rebuild if the view has children	487	* @param f the factory to use to rebuild if the view has children
484	*/	488	*/
485	public void changedUpdate(DocumentEvent evt, Shape a, ViewFactory f) {	489	public @Override void changedUpdate(DocumentEvent evt, Shape a, ViewFactory f) {
486	try {	490	try {
487	if (getComponent().isShowing()) {	491	if (getComponent().isShowing()) {
488	getEditorUI().repaintBlock(evt.getOffset(), evt.getOffset() + evt.getLength());	492	getEditorUI().repaintBlock(evt.getOffset(), evt.getOffset() + evt.getLength());
Lines 501-507 Link Here
501		505
502	Rectangle r;	506	Rectangle r;
503		507
504	public boolean targetOffsetReached(int pos, char ch, int x,	508	public @Override boolean targetOffsetReached(int pos, char ch, int x,
505	int charWidth, DrawContext ctx) {	509	int charWidth, DrawContext ctx) {
506	r.x = x;	510	r.x = x;
507	r.y = getY();	511	r.y = getY();
Lines 533-539 Link Here
533	return offset;	537	return offset;
534	}	538	}
535		539
536	public boolean targetOffsetReached(int offset, char ch, int x,	540	public @Override boolean targetOffsetReached(int offset, char ch, int x,
537	int charWidth, DrawContext ctx) {	541	int charWidth, DrawContext ctx) {
538	if (offset <= eolOffset) {	542	if (offset <= eolOffset) {
539	if (x + charWidth < targetX) {	543	if (x + charWidth < targetX) {

Lines 52-267 Link Here

(-)a/editor.lib/src/org/netbeans/editor/ext/ExtCaret.java (-326 lines)
52		52
53	public class ExtCaret extends BaseCaret {	53	public class ExtCaret extends BaseCaret {
54		54
55	/**
56	* Highlight row draw layer name.
57	*
58	* <p>Using <code>DrawLayer</code>s has been deprecated and this constant
59	* has no longer any meaning.
60	*
61	* @deprecated Please use Highlighting SPI instead, for details see
62	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
63	*/
64	public static final String HIGHLIGHT_ROW_LAYER_NAME = "highlight-row-layer"; // NOI18N
65
66	/**
67	* Highlight row draw layer visibility.
68	*
69	* <p>Using <code>DrawLayer</code>s has been deprecated and this constant
70	* has no longer any meaning.
71	*
72	* @deprecated Please use Highlighting SPI instead, for details see
73	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
74	*/
75	public static final int HIGHLIGHT_ROW_LAYER_VISIBILITY = 2050;
76
77	/**
78	* Highlight matching brace draw layer name
79	*
80	* @deprecated Please use Braces Matching SPI instead, for details see
81	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
82	*/
83	public static final String HIGHLIGHT_BRACE_LAYER_NAME = "highlight-brace-layer"; // NOI18N
84
85	/**
86	* Highlight matching brace draw layer visibility
87	*
88	* @deprecated Please use Braces Matching SPI instead, for details see
89	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
90	*/
91	public static final int HIGHLIGHT_BRACE_LAYER_VISIBILITY = 11000;
92
93	// XXX: remove
94	// /** Highlight a brace matching character before the caret */
95	// public static final int MATCH_BRACE_BEFORE = -1;
96	//
97	// /** Highlight a brace matching character after (at) the caret */
98	// public static final int MATCH_BRACE_AFTER = 0;
99	//
100	// /** Highlight a brace matching character either before or after caret;
101	// the character before takes precedence. */
102	// public static final int MATCH_BRACE_EITHER = java.lang.Integer.MAX_VALUE;
103	//
104	// /** Whether to hightlight the matching brace */
105	// boolean highlightBrace;
106	//
107	// /** Coloring used for highlighting the matching brace */
108	// Coloring highlightBraceColoring;
109	//
110	// /** Mark holding the starting position of the matching brace. */
111	// MarkFactory.DrawMark highlightBraceStartMark;
112	//
113	// /** Mark holding the ending position of the matching brace. */
114	// MarkFactory.DrawMark highlightBraceEndMark;
115	//
116	// /** Timer that fires when the matching brace should be displayed */
117	// private Timer braceTimer;
118	// private ActionListener braceTimerListener; // because of unwanted GC
119	//
120	// /** Signal that the next matching brace update
121	// * will be immediate without waiting for the brace
122	// * timer to fire the action.
123	// */
124	// private boolean matchBraceUpdateSync;
125	//
126	// /** Whether the brace starting and ending marks are currently valid or not.
127	// * If they are not valid the block they delimit is not highlighted.
128	// */
129	// boolean braceMarksValid;
130	//
131	// boolean simpleMatchBrace;
132	//
133	// private int matchBraceOffset = MATCH_BRACE_EITHER;
134
135	static final long serialVersionUID =-4292670043122577690L;	55	static final long serialVersionUID =-4292670043122577690L;
136		56
137	// XXX: remove
138	// protected void modelChanged(BaseDocument oldDoc, BaseDocument newDoc) {
139	// // Fix for #7108
140	// braceMarksValid = false; // brace marks are out of date - new document
141	// if (highlightBraceStartMark != null) {
142	// try {
143	// highlightBraceStartMark.remove();
144	// } catch (InvalidMarkException e) {
145	// }
146	// highlightBraceStartMark = null;
147	// }
148	//
149	// if (highlightBraceEndMark != null) {
150	// try {
151	// highlightBraceEndMark.remove();
152	// } catch (InvalidMarkException e) {
153	// }
154	// highlightBraceEndMark = null;
155	// }
156	//
157	// super.modelChanged( oldDoc, newDoc );
158	// }
159
160	// XXX: remove
161	// /** Called when settings were changed. The method is called
162	// * also in constructor, so the code must count with the evt being null.
163	// */
164	// public void settingsChange(SettingsChangeEvent evt) {
165	// super.settingsChange(evt);
166	// JTextComponent c = component;
167	// if (c != null) {
168	// Class kitClass = Utilities.getKitClass(c);
169	//// XXX: remove
170	//// EditorUI editorUI = Utilities.getEditorUI(c);
171	//// highlightBraceColoring = editorUI.getColoring(
172	//// ExtSettingsNames.HIGHLIGHT_MATCH_BRACE_COLORING);
173	////
174	//// highlightBrace = SettingsUtil.getBoolean(kitClass,
175	//// ExtSettingsNames.HIGHLIGHT_MATCH_BRACE,
176	//// ExtSettingsDefaults.defaultHighlightMatchBrace);
177	//// int highlightBraceDelay = SettingsUtil.getInteger(kitClass,
178	//// ExtSettingsNames.HIGHLIGHT_MATCH_BRACE_DELAY,
179	//// ExtSettingsDefaults.defaultHighlightMatchBraceDelay);
180	////
181	//// if (highlightBrace) {
182	//// if (highlightBraceDelay > 0) {
183	//// // jdk12 compiler doesn't allow inside run()
184	//// final JTextComponent c2 = component;
185	////
186	//// braceTimer = new Timer(highlightBraceDelay, null);
187	//// braceTimerListener =
188	//// new ActionListener() {
189	//// public void actionPerformed(ActionEvent evt2) {
190	//// SwingUtilities.invokeLater(
191	//// new Runnable() {
192	//// public void run() {
193	//// if (c2 != null) {
194	//// BaseDocument doc = Utilities.getDocument(c2);
195	//// if( doc != null ) {
196	//// doc.readLock();
197	//// try {
198	//// updateMatchBrace();
199	//// } finally {
200	//// doc.readUnlock();
201	//// }
202	//// }
203	//// }
204	//// }
205	//// }
206	//// );
207	//// }
208	//// };
209	////
210	//// braceTimer.addActionListener(new WeakTimerListener(braceTimerListener));
211	//// braceTimer.setRepeats(false);
212	//// } else {
213	//// braceTimer = null; // signal no delay
214	//// }
215	//// c.repaint();
216	//// }
217	////
218	//// simpleMatchBrace = SettingsUtil.getBoolean(kitClass,
219	//// ExtSettingsNames.CARET_SIMPLE_MATCH_BRACE,
220	//// ExtSettingsDefaults.defaultCaretSimpleMatchBrace);
221	////
222	// popupMenuEnabled = SettingsUtil.getBoolean(kitClass,
223	// ExtSettingsNames.POPUP_MENU_ENABLED, true);
224	// }
225	// }
226	// XXX: remove
227	// public void install(JTextComponent c) {
228	// EditorUI editorUI = Utilities.getEditorUI(c);
229	// editorUI.addLayer(new HighlightBraceLayer(), HIGHLIGHT_BRACE_LAYER_VISIBILITY);
230	// super.install(c);
231	// }
232	//
233	// public void deinstall(JTextComponent c) {
234	// EditorUI editorUI = Utilities.getEditorUI(c);
235	// editorUI.removeLayer(HIGHLIGHT_BRACE_LAYER_NAME);
236	// super.deinstall(c);
237	// }
238	//
239	// /** Set the match brace offset.
240	// * @param offset One of <code>MATCH_BRACE_BEFORE</code>,
241	// * <code>MATCH_BRACE_AFTER</code> * or <code>MATCH_BRACE_EITHER</code>.
242	// */
243	// public void setMatchBraceOffset(int offset) {
244	// if(offset != MATCH_BRACE_BEFORE && offset != MATCH_BRACE_AFTER
245	// && offset != MATCH_BRACE_EITHER) {
246	// throw new IllegalArgumentException("Offset "+ offset + " not allowed\n");
247	// }
248	// matchBraceOffset = offset;
249	// BaseDocument doc = Utilities.getDocument(component);
250	// if( doc != null ) {
251	// doc.readLock();
252	// try {
253	// updateMatchBrace();
254	// } finally {
255	// doc.readUnlock();
256	// }
257	// }
258	// }
259	//
260	// /** Fetch the match brace offset. */
261	// public int getMatchBraceOffset() {
262	// return matchBraceOffset;
263	// }
264
265	/**	57	/**
266	* Update the matching brace of the caret. The document is read-locked	58	* Update the matching brace of the caret. The document is read-locked
267	* while this method is called.	59	* while this method is called.
Lines 270-351 Link Here
270	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.	62	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
271	*/	63	*/
272	protected void updateMatchBrace() {	64	protected void updateMatchBrace() {
273	// XXX: remove
274	// JTextComponent c = component;
275	// if (c != null && highlightBrace) {
276	// try {
277	// EditorUI editorUI = Utilities.getEditorUI(c);
278	// BaseDocument doc = (BaseDocument)c.getDocument();
279	// int dotPos = getDot();
280	// ExtSyntaxSupport sup = (ExtSyntaxSupport)doc.getSyntaxSupport();
281	// boolean madeValid = false; // whether brace marks display were validated
282	// int[] matchBlk = null;
283	// if(dotPos > 0 && (matchBraceOffset == MATCH_BRACE_BEFORE
284	// \|\| matchBraceOffset == MATCH_BRACE_EITHER)) {
285	// matchBlk = sup.findMatchingBlock(dotPos - 1, simpleMatchBrace);
286	// }
287	// if(matchBlk == null && (matchBraceOffset == MATCH_BRACE_AFTER
288	// \|\| matchBraceOffset == MATCH_BRACE_EITHER)) {
289	// matchBlk = sup.findMatchingBlock(dotPos, simpleMatchBrace);
290	// }
291	// if (matchBlk != null) {
292	// if (highlightBraceStartMark != null) {
293	// int markStartPos = highlightBraceStartMark.getOffset();
294	// int markEndPos = highlightBraceEndMark.getOffset();
295	// if (markStartPos != matchBlk[0] \|\| markEndPos != matchBlk[1]) {
296	// editorUI.repaintBlock(markStartPos, markEndPos);
297	// Utilities.moveMark(doc, highlightBraceStartMark, matchBlk[0]);
298	// Utilities.moveMark(doc, highlightBraceEndMark, matchBlk[1]);
299	// editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
300	// } else { // on the same position
301	// if (!braceMarksValid) { // was not valid, must repaint
302	// editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
303	// }
304	// }
305	// } else { // highlight mark is null
306	// highlightBraceStartMark = new MarkFactory.DrawMark(
307	// HIGHLIGHT_BRACE_LAYER_NAME, editorUI);
308	// highlightBraceEndMark = new MarkFactory.DrawMark(
309	// HIGHLIGHT_BRACE_LAYER_NAME, editorUI);
310	// highlightBraceStartMark.setActivateLayer(true);
311	// Utilities.insertMark(doc, highlightBraceStartMark, matchBlk[0]);
312	// Utilities.insertMark(doc, highlightBraceEndMark, matchBlk[1]);
313	// editorUI.repaintBlock(matchBlk[0], matchBlk[1]);
314	// }
315	// braceMarksValid = true;
316	// madeValid = true;
317	// }
318	//
319	// if (!madeValid) {
320	// if (braceMarksValid) {
321	// braceMarksValid = false;
322	// editorUI.repaintBlock(highlightBraceStartMark.getOffset(),
323	// highlightBraceEndMark.getOffset());
324	// }
325	// }
326	// } catch (BadLocationException e) {
327	// Utilities.annotateLoggable(e);
328	// highlightBrace = false;
329	// } catch (InvalidMarkException e) {
330	// Utilities.annotateLoggable(e);
331	// highlightBrace = false;
332	// }
333	// }
334	}	65	}
335	// XXX: remove
336	// protected void update(boolean scrollViewToCaret) {
337	// if (highlightBrace) {
338	// if (matchBraceUpdateSync \|\| braceTimer == null) {
339	// updateMatchBrace();
340	// matchBraceUpdateSync = false;
341	//
342	// } else { // delay the brace update
343	// braceTimer.restart();
344	// }
345	// }
346	//
347	// super.update(scrollViewToCaret);
348	// }
349		66
350	/**	67	/**
351	* Signal that the next matching brace update	68	* Signal that the next matching brace update
Lines 357-405 Link Here
357	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.	74	* <a href="@org-netbeans-modules-editor-bracesmatching@/overview-summary.html">Editor Braces Matching</a>.
358	*/	75	*/
359	public void requestMatchBraceUpdateSync() {	76	public void requestMatchBraceUpdateSync() {
360	// XXX: remove
361	// matchBraceUpdateSync = true;
362	}	77	}
363		78
364	// XXX: remove
365	// /* package */ static boolean NO_HIGHLIGHT_BRACE_LAYER = Boolean.getBoolean("nbeditor-no-HighlightBraceLayer");
366	//
367	// /**
368	// * Draw layer to highlight the matching brace.
369	// *
370	// * XXX: The HighlightBraceLayer needs to be rewritten using the new Highlighting SPI.
371	// */
372	// class HighlightBraceLayer extends DrawLayer.AbstractLayer {
373	//
374	// public HighlightBraceLayer() {
375	// super(HIGHLIGHT_BRACE_LAYER_NAME);
376	// }
377	//
378	// public void init(DrawContext ctx) {
379	// }
380	//
381	// public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
382	// if (!NO_HIGHLIGHT_BRACE_LAYER && braceMarksValid) {
383	// if (mark != null)
384	// return mark.getActivateLayer();
385	// try {
386	// if (ctx.getStartOffset() > highlightBraceEndMark.getOffset())
387	// return highlightBraceEndMark.getActivateLayer();
388	// if (ctx.getStartOffset() > highlightBraceStartMark.getOffset())
389	// return highlightBraceStartMark.getActivateLayer();
390	// } catch (InvalidMarkException ex) {
391	// }
392	// }
393	//
394	// return false;
395	// }
396	//
397	// public void updateContext(DrawContext ctx) {
398	// if (!NO_HIGHLIGHT_BRACE_LAYER && highlightBraceColoring != null) {
399	// highlightBraceColoring.apply(ctx);
400	// }
401	// }
402	//
403	// }
404
405	}	79	}

Lines 41-48 Link Here

(-)a/editor.lib/src/org/netbeans/modules/editor/lib/EditorPackageAccessor.java (-14 / +26 lines)
41		41
42	package org.netbeans.modules.editor.lib;	42	package org.netbeans.modules.editor.lib;
43		43
		44	import javax.swing.text.BadLocationException;
44	import javax.swing.undo.CompoundEdit;	45	import javax.swing.undo.CompoundEdit;
45	import org.netbeans.editor.BaseDocument;	46	import org.netbeans.editor.BaseDocument;
		47	import org.netbeans.editor.InvalidMarkException;
		48	import org.netbeans.editor.Mark;
		49	import org.netbeans.modules.editor.lib.impl.MarkVector;
		50	import org.netbeans.modules.editor.lib.impl.MultiMark;
46		51
47		52
48	/**	53	/**
Lines 54-77 Link Here
54		59
55	public abstract class EditorPackageAccessor {	60	public abstract class EditorPackageAccessor {
56		61
57	private static EditorPackageAccessor INSTANCE;	62	private static EditorPackageAccessor ACCESSOR = null;
58		63
59	public static EditorPackageAccessor get() {	64	public static synchronized void register(EditorPackageAccessor accessor) {
60	if (INSTANCE == null) {	65	assert ACCESSOR == null : "Can't register two package accessors!"; //NOI18N
61	// Cause api accessor impl to get initialized	66	ACCESSOR = accessor;
62	try {
63	Class.forName(BaseDocument.class.getName(), true, EditorPackageAccessor.class.getClassLoader());
64	} catch (ClassNotFoundException e) {
65	// Should never happen
66	}
67	}
68	return INSTANCE;
69	}	67	}
70		68
71	public static void register(EditorPackageAccessor accessor) {	69	public static synchronized EditorPackageAccessor get() {
72	INSTANCE = accessor;	70	// Trying to wake up BaseDocument ...
		71	try {
		72	Class clazz = Class.forName(BaseDocument.class.getName());
		73	} catch (ClassNotFoundException e) {
		74	// ignore
		75	}
		76
		77	assert ACCESSOR != null : "There is no package accessor available!"; //NOI18N
		78	return ACCESSOR;
73	}	79	}
74		80
75	public abstract CompoundEdit markAtomicEditsNonSignificant(BaseDocument doc);	81	protected EditorPackageAccessor() {
		82	}
		83
		84	public abstract CompoundEdit BaseDocument_markAtomicEditsNonSignificant(BaseDocument doc);
		85	public abstract MarkVector BaseDocument_getMarksStorage(BaseDocument doc);
		86	public abstract Mark BaseDocument_getMark(BaseDocument doc, MultiMark multiMark);
		87	public abstract void Mark_insert(Mark mark, BaseDocument doc, int pos) throws InvalidMarkException, BadLocationException;
76		88
77	}	89	}

Lines 117-128 Link Here

(-)a/editor/src/org/netbeans/modules/editor/NbEditorDocument.java (-6 lines)
117	}	117	}
118		118
119	private void init() {	119	private void init() {
120	addStyleToLayerMapping(NbDocument.BREAKPOINT_STYLE_NAME,
121	NbDocument.BREAKPOINT_STYLE_NAME + "Layer:10"); // NOI18N
122	addStyleToLayerMapping(NbDocument.ERROR_STYLE_NAME,
123	NbDocument.ERROR_STYLE_NAME + "Layer:20"); // NOI18N
124	addStyleToLayerMapping(NbDocument.CURRENT_STYLE_NAME,
125	NbDocument.CURRENT_STYLE_NAME + "Layer:30"); // NOI18N
126	setNormalStyleName(NbDocument.NORMAL_STYLE_NAME);	120	setNormalStyleName(NbDocument.NORMAL_STYLE_NAME);
127		121
128	annoMap = new HashMap(20);	122	annoMap = new HashMap(20);

Lines 59-66 Link Here

(-)a/form/src/org/netbeans/modules/form/FormUtils.java (-6 / +4 lines)
59	import javax.swing.text.Document;	59	import javax.swing.text.Document;
60	import javax.swing.tree.DefaultTreeModel;	60	import javax.swing.tree.DefaultTreeModel;
61	import org.netbeans.api.editor.DialogBinding;	61	import org.netbeans.api.editor.DialogBinding;
62	import org.netbeans.editor.EditorUI;
63	import org.netbeans.editor.ext.ExtCaret;
64		62
65	import org.openide.ErrorManager;	63	import org.openide.ErrorManager;
66	import org.openide.util.*;	64	import org.openide.util.*;
Lines 942-951 Link Here
942	DialogBinding.bindComponentToDocument(document, ccPosition, 0, editor);	940	DialogBinding.bindComponentToDocument(document, ccPosition, 0, editor);
943		941
944	// do not highlight current row	942	// do not highlight current row
945	EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editor);	943	editor.putClientProperty(
946	if (eui != null) { // Issue 142686	944	"HighlightsLayerExcludes", //NOI18N
947	eui.removeLayer(ExtCaret.HIGHLIGHT_ROW_LAYER_NAME);	945	"^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
948	}	946	);
949		947
950	setupTextUndoRedo(editor);	948	setupTextUndoRedo(editor);
951	}	949	}

Lines 1-205 Link Here

(-)a/java.editor.lib/src/org/netbeans/editor/ext/java/JavaDrawLayerFactory.java (-205 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
5	*
6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common
8	* Development and Distribution License("CDDL") (collectively, the
9	* "License"). You may not use this file except in compliance with the
10	* License. You can obtain a copy of the License at
11	* http://www.netbeans.org/cddl-gplv2.html
12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
13	* specific language governing permissions and limitations under the
14	* License. When distributing the software, include this License Header
15	* Notice in each file and include the License file at
16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
17	* particular file as subject to the "Classpath" exception as provided
18	* by Sun in the GPL Version 2 section of the License file that
19	* accompanied this code. If applicable, add the following below the
20	* License Header, with the fields enclosed by brackets [] replaced by
21	* your own identifying information:
22	* "Portions Copyrighted [year] [name of copyright owner]"
23	*
24	* Contributor(s):
25	*
26	* The Original Software is NetBeans. The Initial Developer of the Original
27	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
28	* Microsystems, Inc. All Rights Reserved.
29	*
30	* If you wish your version of this file to be governed by only the CDDL
31	* or only the GPL Version 2, indicate your decision by adding
32	* "[Contributor] elects to include this software in this distribution
33	* under the [CDDL or GPL Version 2] license." If you do not indicate a
34	* single choice of license, a recipient has the option to distribute
35	* your version of this file under either the CDDL, the GPL Version 2 or
36	* to extend the choice of license to its licensees as provided above.
37	* However, if you add GPL Version 2 code and therefore, elected the GPL
38	* Version 2 license, then the option applies only if the new code is
39	* made subject to such option by the copyright holder.
40	*/
41
42	package org.netbeans.editor.ext.java;
43
44	import javax.swing.text.BadLocationException;
45
46	import org.netbeans.editor.*;
47	import org.netbeans.editor.ext.ExtSyntaxSupport;
48
49	/**
50	* Various java-layers
51	*
52	* @author Miloslav Metelka
53	* @version 1.00
54	* @deprecated Please use Highlighting SPI instead, for details see
55	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
56	*/
57
58	public class JavaDrawLayerFactory {
59
60	public static final String JAVA_LAYER_NAME = "java-layer"; // NOI18N
61
62	public static final int JAVA_LAYER_VISIBILITY = 1010;
63
64	/** Layer that colors extra java information like the methods or special
65	* characters in the character and string literals.
66	*
67	* @deprecated Please use Highlighting SPI instead, for details see
68	* <a href="@org-netbeans-modules-editor-lib2@/overview-summary.html">Editor Library 2</a>.
69	*/
70	public static class JavaLayer extends DrawLayer.AbstractLayer {
71
72	/** End of the area that is resolved right now. It saves
73	* repetitive searches for '(' for multiple fragments
74	* inside one identifier token.
75	*/
76	private int resolvedEndOffset;
77
78	private boolean resolvedValue;
79
80	private NonWhitespaceFwdFinder nwFinder = new NonWhitespaceFwdFinder();
81
82	public JavaLayer() {
83	super(JAVA_LAYER_NAME);
84	}
85
86	public void init(DrawContext ctx) {
87	resolvedEndOffset = 0; // nothing resolved
88	}
89
90	public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
91	int nextOffset = ctx.getTokenOffset() + ctx.getTokenLength();
92
93	setNextActivityChangeOffset(nextOffset);
94	return true;
95	}
96
97	protected Coloring getMethodColoring(DrawContext ctx) {
98	TokenContextPath path = ctx.getTokenContextPath().replaceStart(
99	JavaLayerTokenContext.contextPath);
100	return ctx.getEditorUI().getColoring(
101	path.getFullTokenName(JavaLayerTokenContext.METHOD));
102	}
103
104	private boolean isMethod(DrawContext ctx) {
105	int idEndOffset = ctx.getTokenOffset() + ctx.getTokenLength();
106	if (idEndOffset > resolvedEndOffset) { // beyond the resolved area
107	resolvedEndOffset = idEndOffset; // will resolve now
108	int endOffset = ctx.getEndOffset();
109	int bufferStartOffset = ctx.getBufferStartOffset();
110	char[] buffer = ctx.getBuffer();
111	ExtSyntaxSupport sup = (ExtSyntaxSupport) ctx.getEditorUI().getDocument().getSyntaxSupport().get(ExtSyntaxSupport.class);
112	int nwOffset = Analyzer.findFirstNonWhite(buffer,
113	idEndOffset - bufferStartOffset,
114	endOffset - idEndOffset);
115	if (nwOffset >= 0) { // found non-white
116	resolvedValue = (buffer[nwOffset] == '(');
117	if (!resolvedValue && buffer[nwOffset] == '<') {
118	try {
119	int[] block = sup.findMatchingBlock(ctx.getBufferStartOffset() + nwOffset, true);
120	if (block != null) {
121	int off = Utilities.getFirstNonWhiteFwd(ctx.getEditorUI().getDocument(), block[1]);
122	if (off > -1) {
123	if (bufferStartOffset + buffer.length > off) {
124	resolvedValue = (buffer[off - bufferStartOffset] == '(');
125	} else {
126	resolvedValue = (ctx.getEditorUI().getDocument().getChars(off, 1)[0] == '(');
127	}
128	}
129	}
130	} catch (BadLocationException e) {
131	resolvedValue = false;
132	}
133	}
134	} else { // must resolve after buffer end
135	try {
136	int off = ctx.getEditorUI().getDocument().find(nwFinder, endOffset, -1);
137	resolvedValue = off >= 0 && (nwFinder.getFoundChar() == '(');
138	if (!resolvedValue && nwFinder.getFoundChar() == '<') {
139	int[] block = sup.findMatchingBlock(off, true);
140	if (block != null) {
141	off = Utilities.getFirstNonWhiteFwd(ctx.getEditorUI().getDocument(), block[1]);
142	if (off > -1)
143	resolvedValue = (ctx.getEditorUI().getDocument().getChars(off, 1)[0] == '(');
144	}
145	}
146	} catch (BadLocationException e) {
147	resolvedValue = false;
148	}
149	}
150	}
151
152	return resolvedValue;
153	}
154
155	public void updateContext(DrawContext ctx) {
156	if (ctx.getTokenID() == JavaTokenContext.IDENTIFIER && isMethod(ctx)) {
157	Coloring mc = getMethodColoring(ctx);
158	if (mc != null) {
159	mc.apply(ctx);
160	}
161	}
162	}
163
164	}
165
166	/** Find first non-white character forward */
167	static class NonWhitespaceFwdFinder extends FinderFactory.GenericFwdFinder {
168
169	private char foundChar;
170
171	public char getFoundChar() {
172	return foundChar;
173	}
174
175	protected int scan(char ch, boolean lastChar) {
176	if (!Character.isWhitespace(ch)) {
177	found = true;
178	foundChar = ch;
179	return 0;
180	}
181	return 1;
182	}
183	}
184
185	/** Find first non-white character backward */
186	public static class NonWhitespaceBwdFinder extends FinderFactory.GenericBwdFinder {
187
188	private char foundChar;
189
190	public char getFoundChar() {
191	return foundChar;
192	}
193
194	protected int scan(char ch, boolean lastChar) {
195	if (!Character.isWhitespace(ch)) {
196	found = true;
197	foundChar = ch;
198	return 0;
199	}
200	return -1;
201	}
202	}
203
204	}
205

Lines 304-310 Link Here

(-)a/nbbuild/cluster.properties (-3 lines)
304	editor.errorstripe.api,\	304	editor.errorstripe.api,\
305	editor.fold,\	305	editor.fold,\
306	editor.guards,\	306	editor.guards,\
307	editor.highlights,\
308	editor.indent,\	307	editor.indent,\
309	editor.kit,\	308	editor.kit,\
310	editor.lib,\	309	editor.lib,\
Lines 350-356 Link Here
350	languages.manifest,\	349	languages.manifest,\
351	languages.yaml,\	350	languages.yaml,\
352	lexer,\	351	lexer,\
353	lexer.editorbridge,\
354	lexer.nbbridge,\	352	lexer.nbbridge,\
355	lib.cvsclient,\	353	lib.cvsclient,\
356	libs.bugtracking,\	354	libs.bugtracking,\
Lines 1242-1248 Link Here
1242	contrib/glassfish.v3enable,\	1240	contrib/glassfish.v3enable,\
1243	contrib/graphicclassview,\	1241	contrib/graphicclassview,\
1244	contrib/group,\	1242	contrib/group,\
1245	contrib/gsf.tools,\
1246	contrib/hexeditor,\	1243	contrib/hexeditor,\
1247	contrib/htmlprojects,\	1244	contrib/htmlprojects,\
1248	contrib/hudsonfindbugs,\	1245	contrib/hudsonfindbugs,\

Lines 72-81 Link Here

(-)a/python.debugger/src/org/netbeans/modules/python/debugger/gui/WatchPanel.java (-3 / +7 lines)
72	import java.awt.Insets;	72	import java.awt.Insets;
73	import java.awt.event.ActionListener;	73	import java.awt.event.ActionListener;
74	import java.io.IOException;	74	import java.io.IOException;
75	import javax.naming.event.EventDirContext;
76	import javax.swing.text.StyledDocument;	75	import javax.swing.text.StyledDocument;
77	import org.netbeans.editor.EditorUI;	76	import org.netbeans.editor.EditorUI;
78	import org.netbeans.editor.ext.ExtCaret;
79	import org.openide.ErrorManager;	77	import org.openide.ErrorManager;
80	import org.openide.cookies.EditorCookie;	78	import org.openide.cookies.EditorCookie;
81	import org.openide.text.NbDocument;	79	import org.openide.text.NbDocument;
Lines 180-186 Link Here
180	final Runnable runnable = new Runnable() {	178	final Runnable runnable = new Runnable() {
181	public void run() {	179	public void run() {
182	EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);	180	EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);
183	eui.removeLayer(ExtCaret.HIGHLIGHT_ROW_LAYER_NAME);	181	if (eui == null) {
		182	return ;
		183	}
		184	editorPane.putClientProperty(
		185	"HighlightsLayerExcludes", //NOI18N
		186	"^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
		187	);
184	// Do not draw text limit line	188	// Do not draw text limit line
185	try {	189	try {
186	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N	190	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N

Lines 57-63 Link Here

(-)a/spi.debugger.ui/src/org/netbeans/modules/debugger/ui/WatchPanel.java (-3 / +6 lines)
57	import javax.swing.text.StyledDocument;	57	import javax.swing.text.StyledDocument;
58	import org.netbeans.api.editor.DialogBinding;	58	import org.netbeans.api.editor.DialogBinding;
59	import org.netbeans.editor.EditorUI;	59	import org.netbeans.editor.EditorUI;
60	import org.netbeans.editor.ext.ExtCaret;
61	import org.netbeans.spi.debugger.ui.EditorContextDispatcher;	60	import org.netbeans.spi.debugger.ui.EditorContextDispatcher;
62	import org.openide.ErrorManager;	61	import org.openide.ErrorManager;
63	import org.openide.cookies.EditorCookie;	62	import org.openide.cookies.EditorCookie;
Lines 133-141 Link Here
133	Runnable runnable = new Runnable() {	132	Runnable runnable = new Runnable() {
134	public void run() {	133	public void run() {
135	EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);	134	EditorUI eui = org.netbeans.editor.Utilities.getEditorUI(editorPane);
136	if (eui != null) {	135	if (eui == null) {
137	eui.removeLayer(ExtCaret.HIGHLIGHT_ROW_LAYER_NAME);	136	return;
138	}	137	}
		138	editorPane.putClientProperty(
		139	"HighlightsLayerExcludes", //NOI18N
		140	"^org\\.netbeans\\.modules\\.editor\\.lib2\\.highlighting\\.CaretRowHighlighting$" //NOI18N
		141	);
139	// Do not draw text limit line	142	// Do not draw text limit line
140	try {	143	try {
141	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N	144	java.lang.reflect.Field textLimitLineField = EditorUI.class.getDeclaredField("textLimitLineVisible"); // NOI18N

Lines 1-192 Link Here

(-)a/web.core.syntax/src/org/netbeans/modules/web/core/syntax/deprecated/ELDrawLayerFactory.java (-192 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.
5	*
6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common
8	* Development and Distribution License("CDDL") (collectively, the
9	* "License"). You may not use this file except in compliance with the
10	* License. You can obtain a copy of the License at
11	* http://www.netbeans.org/cddl-gplv2.html
12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
13	* specific language governing permissions and limitations under the
14	* License. When distributing the software, include this License Header
15	* Notice in each file and include the License file at
16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
17	* particular file as subject to the "Classpath" exception as provided
18	* by Sun in the GPL Version 2 section of the License file that
19	* accompanied this code. If applicable, add the following below the
20	* License Header, with the fields enclosed by brackets [] replaced by
21	* your own identifying information:
22	* "Portions Copyrighted [year] [name of copyright owner]"
23	*
24	* Contributor(s):
25	*
26	* The Original Software is NetBeans. The Initial Developer of the Original
27	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
28	* Microsystems, Inc. All Rights Reserved.
29	*
30	* If you wish your version of this file to be governed by only the CDDL
31	* or only the GPL Version 2, indicate your decision by adding
32	* "[Contributor] elects to include this software in this distribution
33	* under the [CDDL or GPL Version 2] license." If you do not indicate a
34	* single choice of license, a recipient has the option to distribute
35	* your version of this file under either the CDDL, the GPL Version 2 or
36	* to extend the choice of license to its licensees as provided above.
37	* However, if you add GPL Version 2 code and therefore, elected the GPL
38	* Version 2 license, then the option applies only if the new code is
39	* made subject to such option by the copyright holder.
40	*/
41
42	package org.netbeans.modules.web.core.syntax.deprecated;
43
44	import org.netbeans.modules.web.core.syntax.deprecated.ELLayerTokenContext;
45	import org.netbeans.modules.web.core.syntax.*;
46	import javax.swing.text.BadLocationException;
47	import javax.swing.event.DocumentListener;
48	import javax.swing.event.DocumentEvent;
49	import org.netbeans.editor.BaseDocument;
50	import org.netbeans.editor.BaseDocumentEvent;
51	import org.netbeans.editor.Coloring;
52	import org.netbeans.editor.DrawContext;
53	import org.netbeans.editor.DrawLayer;
54	import org.netbeans.editor.MarkFactory;
55	import org.netbeans.editor.FinderFactory;
56	import org.netbeans.editor.Analyzer;
57
58	/**
59	* Various EL-layers
60	*
61	* @author Petr Pisl
62	* @deprecated Will be replaced by Semantic Coloring
63	*/
64
65	public class ELDrawLayerFactory {
66
67	public static final String EL_LAYER_NAME = "jsp-el-layer"; // NOI18N
68
69	public static final int EL_LAYER_VISIBILITY = 1010;
70
71	/** Layer that colors extra EL information like the methods or special
72	* characters in the character and string literals.
73	*/
74	public static class ELLayer extends DrawLayer.AbstractLayer {
75
76	/** End of the area that is resolved right now. It saves
77	* repetitive searches for '(' for multiple fragments
78	* inside one identifier token.
79	*/
80	private int resolvedEndOffset;
81
82	private boolean resolvedValue;
83
84	private NonWhitespaceFwdFinder nwFinder = new NonWhitespaceFwdFinder();
85
86	public ELLayer() {
87	super(EL_LAYER_NAME);
88	}
89
90	public void init(DrawContext ctx) {
91	resolvedEndOffset = 0; // nothing resolved
92	}
93
94	public boolean isActive(DrawContext ctx, MarkFactory.DrawMark mark) {
95	int nextOffset = ctx.getTokenOffset() + ctx.getTokenLength();
96
97	setNextActivityChangeOffset(nextOffset);
98	return true;
99	}
100
101	protected Coloring getMethodColoring(DrawContext ctx) {
102
103	/*TokenContextPath path = ctx.getTokenContextPath().replaceStart(
104	ELLayerTokenContext.contextPath);
105	return ctx.getEditorUI().getColoring(
106	path.getFullTokenName(ELLayerTokenContext.METHOD));
107	*/
108
109	return ctx.getEditorUI().getColoring(ELLayerTokenContext.contextPath.getFullTokenName(ELLayerTokenContext.METHOD));
110	}
111
112	private boolean isMethod(DrawContext ctx) {
113
114	int idEndOffset = ctx.getTokenOffset() + ctx.getTokenLength();
115	if (idEndOffset > resolvedEndOffset) { // beyond the resolved area
116	resolvedEndOffset = idEndOffset; // will resolve now
117	int endOffset = ctx.getEndOffset();
118	int bufferStartOffset = ctx.getBufferStartOffset();
119	char[] buffer = ctx.getBuffer();
120	int nwOffset = Analyzer.findFirstNonWhite(buffer,
121	idEndOffset - bufferStartOffset,
122	endOffset - idEndOffset);
123	if (nwOffset >= 0) { // found non-white
124	resolvedValue = (buffer[nwOffset] == '(');
125	} else { // must resolve after buffer end
126	try {
127	resolvedValue = (ctx.getEditorUI().getDocument().find(
128	nwFinder, endOffset, -1) >= 0)
129	&& (nwFinder.getFoundChar() == '(');
130	} catch (BadLocationException e) {
131	resolvedValue = false;
132	}
133	}
134	}
135	return resolvedValue;
136	}
137	/** Update draw context by setting colors, fonts and possibly other draw
138	* properties.
139	* The method can use information from the context to find where the painting
140	* process is currently located. It is called only if the layer is active.
141	*/
142	public void updateContext(DrawContext ctx) {
143	if (ctx.getTokenID() == ELTokenContext.IDENTIFIER && isMethod(ctx)) {
144	Coloring mc = getMethodColoring(ctx);
145	if (mc != null) {
146	mc.apply(ctx);
147	}
148	}
149	}
150
151	}
152
153	/** Find first non-white character forward */
154	static class NonWhitespaceFwdFinder extends FinderFactory.GenericFwdFinder {
155
156	private char foundChar;
157
158	public char getFoundChar() {
159	return foundChar;
160	}
161
162	protected int scan(char ch, boolean lastChar) {
163	if (!Character.isWhitespace(ch)) {
164	found = true;
165	foundChar = ch;
166	return 0;
167	}
168	return 1;
169	}
170	}
171
172	/** Find first non-white character backward */
173	public static class NonWhitespaceBwdFinder extends FinderFactory.GenericBwdFinder {
174
175	private char foundChar;
176
177	public char getFoundChar() {
178	return foundChar;
179	}
180
181	protected int scan(char ch, boolean lastChar) {
182	if (!Character.isWhitespace(ch)) {
183	found = true;
184	foundChar = ch;
185	return 0;
186	}
187	return -1;
188	}
189	}
190
191	}
192

Lines 348-361 Link Here

(-)a/xml.text/src/org/netbeans/modules/xml/text/syntax/XMLKit.java (-9 lines)
348	public XMLEditorDocument(String mimeType) {	348	public XMLEditorDocument(String mimeType) {
349	super(mimeType);	349	super(mimeType);
350	}	350	}
351
352	public @Override boolean addLayer(DrawLayer layer, int visibility) {
353	//filter out the syntax layer adding
354	if(!(layer instanceof DrawLayerFactory.SyntaxLayer)) {
355	return super.addLayer(layer, visibility);
356	} else {
357	return false;
358	}
359	}
360	}	351	}
361	}	352	}