Attachment #131623 for bug #226413

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

Lines 40-46 Link Here

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

Lines 119-125 Link Here

(-)a/csl.api/nbproject/project.xml (-1 / +1 lines)
119	<compile-dependency/>	119	<compile-dependency/>
120	<run-dependency>	120	<run-dependency>
121	<release-version>1</release-version>	121	<release-version>1</release-version>
122	<specification-version>1.6</specification-version>	122	<specification-version>1.34</specification-version>
123	</run-dependency>	123	</run-dependency>
124	</dependency>	124	</dependency>
125	<dependency>	125	<dependency>

Lines 50-55 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/api/StructureScanner.java (-1 / +15 lines)
50	import org.netbeans.api.annotations.common.CheckForNull;	50	import org.netbeans.api.annotations.common.CheckForNull;
51	import org.netbeans.api.annotations.common.NonNull;	51	import org.netbeans.api.annotations.common.NonNull;
52	import org.netbeans.modules.csl.spi.ParserResult;	52	import org.netbeans.modules.csl.spi.ParserResult;
		53	import org.netbeans.api.editor.fold.FoldType;
		54	import org.netbeans.spi.editor.fold.FoldTypeProvider;
53		55
54	/**	56	/**
55	* Given a parse tree, scan its structure and produce a flat list of	57	* Given a parse tree, scan its structure and produce a flat list of
Lines 69-76 Link Here
69	@NonNull List<? extends StructureItem> scan(@NonNull ParserResult info);	71	@NonNull List<? extends StructureItem> scan(@NonNull ParserResult info);
70		72
71	/**	73	/**
72	* @todo Do this in the same pass as the structure scan?
73	* Compute a list of foldable regions, named "codeblocks", "comments", "imports", "initial-comment", ...	74	* Compute a list of foldable regions, named "codeblocks", "comments", "imports", "initial-comment", ...
		75	* The returned Map must be keyed by {@link FoldType#code}. For backward compatibility, the following
		76	* tokens are temporarily supported although no FoldType is registered explicitly.
		77	* <ul>
		78	* <li>codeblocks
		79	* <li>comments
		80	* <li>initial-comment
		81	* <li>imports
		82	* <li>tags
		83	* <li>inner-classes
		84	* <li>othercodeblocks
		85	* </ul>
		86	* This additional support will cease to exist after NB-8.0. Language owners are required to register
		87	* their {@link FoldTypeProvider} and define their own folding.
74	*/	88	*/
75	@NonNull Map<String,List<OffsetRange>> folds(@NonNull ParserResult info);	89	@NonNull Map<String,List<OffsetRange>> folds(@NonNull ParserResult info);
76		90

Lines 51-59 Link Here

(-)a/csl.api/src/org/netbeans/modules/csl/editor/fold/GsfFoldManager.java (-338 / +185 lines)
51	import java.util.Collection;	51	import java.util.Collection;
52	import java.util.Collections;	52	import java.util.Collections;
53	import java.util.HashMap;	53	import java.util.HashMap;
		54	import java.util.HashSet;
54	import java.util.Iterator;	55	import java.util.Iterator;
55	import java.util.List;	56	import java.util.List;
56	import java.util.Map;	57	import java.util.Map;
		58	import java.util.Set;
57	import java.util.TreeMap;	59	import java.util.TreeMap;
58	import java.util.TreeSet;	60	import java.util.TreeSet;
59	import java.util.WeakHashMap;	61	import java.util.WeakHashMap;
Lines 65-73 Link Here
65	import javax.swing.event.DocumentEvent;	67	import javax.swing.event.DocumentEvent;
66	import javax.swing.text.BadLocationException;	68	import javax.swing.text.BadLocationException;
67	import javax.swing.text.Document;	69	import javax.swing.text.Document;
68	import javax.swing.text.Position;
69	import org.netbeans.api.editor.fold.Fold;	70	import org.netbeans.api.editor.fold.Fold;
		71	import org.netbeans.spi.editor.fold.FoldInfo;
		72	import org.netbeans.api.editor.fold.FoldTemplate;
70	import org.netbeans.api.editor.fold.FoldType;	73	import org.netbeans.api.editor.fold.FoldType;
		74	import org.netbeans.api.editor.fold.FoldUtilities;
71	import org.netbeans.api.editor.mimelookup.MimeLookup;	75	import org.netbeans.api.editor.mimelookup.MimeLookup;
72	import org.netbeans.modules.csl.api.OffsetRange;	76	import org.netbeans.modules.csl.api.OffsetRange;
73	import org.netbeans.modules.csl.api.Severity;	77	import org.netbeans.modules.csl.api.Severity;
Lines 92-98 Link Here
92	import org.netbeans.modules.parsing.api.Source;	96	import org.netbeans.modules.parsing.api.Source;
93	import org.netbeans.modules.parsing.api.UserTask;	97	import org.netbeans.modules.parsing.api.UserTask;
94	import org.netbeans.modules.parsing.spi.*;	98	import org.netbeans.modules.parsing.spi.*;
95	import org.openide.text.NbDocument;	99	import org.openide.util.NbBundle;
		100
		101	import static org.netbeans.modules.csl.editor.fold.Bundle.*;
96		102
97	/**	103	/**
98	* This file is originally from Retouche, the Java Support	104	* This file is originally from Retouche, the Java Support
Lines 100-106 Link Here
100	* as possible to make merging Retouche fixes back as simple as	106	* as possible to make merging Retouche fixes back as simple as
101	* possible.	107	* possible.
102	*	108	*
103	* Copied from both JavaFoldManager and JavaElementFoldManager	109	* Copied from both JavaFoldManager and JavaElementFoldManager.
		110	* <p/>
		111	*
		112	* From introduction of {@link FoldType}, this Manager accepts these Strings
		113	* from {@link StructureScanner#folds}:<ul>
		114	* <li>codes of FoldTypes registered for the language, or
		115	* <li>legacy FoldType codes.
		116	* </ul>
		117	* The registered FoldTypes take precedence; that is if the SPI returns
		118	* "code-block" and a FoldType is registered with that code, that FoldType (and its FoldTemplate)
		119	* will be used to create the Fold. If no such FoldType exists, the GsfFoldManager will still
		120	* create the fold in a bw compatible mode with an <b>unregistered</b> fold type. But because
		121	* of implementation peculiarities, the FoldType will eventually default to one of the generic
		122	* settings.
		123	* <p/>
		124	* If a code other than registered FoldTypes and bw compatible constants is used,
		125	* a warning will be printed - to detect programmer errors.
104	*	126	*
105	*	127	*
106	* @author Jan Lahoda	128	* @author Jan Lahoda
Lines 110-238 Link Here
110		132
111	private static final Logger LOG = Logger.getLogger(GsfFoldManager.class.getName());	133	private static final Logger LOG = Logger.getLogger(GsfFoldManager.class.getName());
112		134
113	public static final FoldType CODE_BLOCK_FOLD_TYPE = new FoldType("code-block"); // NOI18N	135	private static final FoldTemplate TEMPLATE_CODEBLOCK = new org.netbeans.api.editor.fold.FoldTemplate(1, 1, "{...}"); // NOI18N
114	public static final FoldType INITIAL_COMMENT_FOLD_TYPE = new FoldType("initial-comment"); // NOI18N	136
115	public static final FoldType IMPORTS_FOLD_TYPE = new FoldType("imports"); // NOI18N	137	/**
116	public static final FoldType JAVADOC_FOLD_TYPE = new FoldType("javadoc"); // NOI18N	138	* This definition and all Fold types defined in CSL are deprecated and for backward
117	public static final FoldType TAG_FOLD_TYPE = new FoldType("tag"); // NOI18N	139	* compatibility only.
118	public static final FoldType INNER_CLASS_FOLD_TYPE = new FoldType("inner-class"); // NOI18N	140	*/
119		141	@Deprecated
		142	public static final FoldType CODE_BLOCK_FOLD_TYPE = FoldType.CODE_BLOCK;
120		143
121	private static final String IMPORTS_FOLD_DESCRIPTION = "..."; // NOI18N	144	@Deprecated
122		145	public static final FoldType INITIAL_COMMENT_FOLD_TYPE = FoldType.INITIAL_COMMENT;
123	private static final String COMMENT_FOLD_DESCRIPTION = "..."; // NOI18N
124
125	private static final String JAVADOC_FOLD_DESCRIPTION = "..."; // NOI18N
126
127	private static final String CODE_BLOCK_FOLD_DESCRIPTION = "{...}"; // NOI18N
128
129	private static final String TAG_FOLD_DESCRIPTION = "<.../>"; // NOI18N
130
131
132	public static final FoldTemplate CODE_BLOCK_FOLD_TEMPLATE
133	= new FoldTemplate(CODE_BLOCK_FOLD_TYPE, CODE_BLOCK_FOLD_DESCRIPTION, 1, 1);
134
135	public static final FoldTemplate INITIAL_COMMENT_FOLD_TEMPLATE
136	= new FoldTemplate(INITIAL_COMMENT_FOLD_TYPE, COMMENT_FOLD_DESCRIPTION, 2, 2);
137
138	public static final FoldTemplate IMPORTS_FOLD_TEMPLATE
139	= new FoldTemplate(IMPORTS_FOLD_TYPE, IMPORTS_FOLD_DESCRIPTION, 0, 0);
140
141	public static final FoldTemplate JAVADOC_FOLD_TEMPLATE
142	= new FoldTemplate(JAVADOC_FOLD_TYPE, JAVADOC_FOLD_DESCRIPTION, 3, 2);
143
144	public static final FoldTemplate TAG_FOLD_TEMPLATE
145	= new FoldTemplate(TAG_FOLD_TYPE, TAG_FOLD_DESCRIPTION, 0, 0);
146
147	public static final FoldTemplate INNER_CLASS_FOLD_TEMPLATE
148	= new FoldTemplate(INNER_CLASS_FOLD_TYPE, CODE_BLOCK_FOLD_DESCRIPTION, 0, 0);
149
150
151	public static final String CODE_FOLDING_ENABLE = "code-folding-enable"; //NOI18N
152
153	/** Collapse methods by default
154	* NOTE: This must be kept in sync with string literal in editor/options
155	*/
156	public static final String CODE_FOLDING_COLLAPSE_METHOD = "code-folding-collapse-method"; //NOI18N
157		146
158	/**	147	/**
159	* Collapse inner classes by default	148	* Note: this FoldType's code was changed from 'imports' to 'import' to match the used preference key.
160	* NOTE: This must be kept in sync with string literal in editor/options
161	*/	149	*/
162	public static final String CODE_FOLDING_COLLAPSE_INNERCLASS = "code-folding-collapse-innerclass"; //NOI18N	150	@NbBundle.Messages("FT_label_imports=Imports or Includes")
		151	@Deprecated
		152	public static final FoldType IMPORTS_FOLD_TYPE = FoldType.IMPORT;
		153
		154	@Deprecated
		155	public static final FoldType JAVADOC_FOLD_TYPE = FoldType.DOCUMENTATION;
		156
		157	@Deprecated
		158	public static final FoldType TAG_FOLD_TYPE = FoldType.TAG;
163		159
164	/**	160	/**
165	* Collapse import section default	161	* This type's code was renamed from inner-class to innerclass to match the preference value
166	* NOTE: This must be kept in sync with string literal in editor/options
167	*/	162	*/
168	public static final String CODE_FOLDING_COLLAPSE_IMPORT = "code-folding-collapse-import"; //NOI18N	163	@NbBundle.Messages("FT_label_innerclass=Inner Classes")
		164	@Deprecated
		165	public static final FoldType INNER_CLASS_FOLD_TYPE = FoldType.create("innerclass", FT_label_innerclass(), TEMPLATE_CODEBLOCK);
169		166
170	/**	167	@NbBundle.Messages("FT_label_othercodeblocks=Other code blocks")
171	* Collapse javadoc comment by default	168	@Deprecated
172	* NOTE: This must be kept in sync with string literal in editor/options	169	public static final FoldType OTHER_CODEBLOCKS_FOLD_TYPE = FoldType.TAG.derive("othercodeblocks", FT_label_othercodeblocks(),
173	*/	170	TEMPLATE_CODEBLOCK);
174	public static final String CODE_FOLDING_COLLAPSE_JAVADOC = "code-folding-collapse-javadoc"; //NOI18N
175
176	/**
177	* Collapse initial comment by default
178	* NOTE: This must be kept in sync with string literal in editor/options
179	*/
180	public static final String CODE_FOLDING_COLLAPSE_INITIAL_COMMENT = "code-folding-collapse-initial-comment"; //NOI18N
181		171
182	/**	172	private static final Set<String> LEGACY_FOLD_TAGS = new HashSet<String>(11);
183	* Collapse tags by default
184	* NOTE: This must be kept in sync with string literal in editor/options
185	*/
186	public static final String CODE_FOLDING_COLLAPSE_TAGS = "code-folding-collapse-tags"; //NOI18N
187
188		173
189	protected static final class FoldTemplate {	174	static {
190		175	LEGACY_FOLD_TAGS.add(OTHER_CODEBLOCKS_FOLD_TYPE.code());
191	private FoldType type;	176	LEGACY_FOLD_TAGS.add(INNER_CLASS_FOLD_TYPE.code());
192		177	LEGACY_FOLD_TAGS.add(TAG_FOLD_TYPE.code());
193	private String description;	178	LEGACY_FOLD_TAGS.add(JAVADOC_FOLD_TYPE.code());
194		179	LEGACY_FOLD_TAGS.add(IMPORTS_FOLD_TYPE.code());
195	private int startGuardedLength;	180	LEGACY_FOLD_TAGS.add(INITIAL_COMMENT_FOLD_TYPE.code());
196		181	LEGACY_FOLD_TAGS.add(CODE_BLOCK_FOLD_TYPE.code());
197	private int endGuardedLength;
198
199	protected FoldTemplate(FoldType type, String description,
200	int startGuardedLength, int endGuardedLength) {
201	this.type = type;
202	this.description = description;
203	this.startGuardedLength = startGuardedLength;
204	this.endGuardedLength = endGuardedLength;
205	}
206
207	public FoldType getType() {
208	return type;
209	}
210
211	public String getDescription() {
212	return description;
213	}
214
215	public int getStartGuardedLength() {
216	return startGuardedLength;
217	}
218
219	public int getEndGuardedLength() {
220	return endGuardedLength;
221	}
222
223	}	182	}
224		183
225	private FoldOperation operation;	184	private FoldOperation operation;
226	private FileObject file;	185	private FileObject file;
227	private JavaElementFoldTask task;	186	private JavaElementFoldTask task;
228		187
229	// // Folding presets	188	private volatile Preferences prefs;
230	// private boolean foldImportsPreset;
231	// private boolean foldInnerClassesPreset;
232	// private boolean foldJavadocsPreset;
233	// private boolean foldCodeBlocksPreset;
234	// private boolean foldInitialCommentsPreset;
235	private static volatile Preferences prefs;
236		189
237	/** Creates a new instance of GsfFoldManager */	190	/** Creates a new instance of GsfFoldManager */
238	public GsfFoldManager() {	191	public GsfFoldManager() {
Lines 253-259 Link Here
253	file = DataLoadersBridge.getDefault().getFileObject(doc);	206	file = DataLoadersBridge.getDefault().getFileObject(doc);
254		207
255	if (file != null) {	208	if (file != null) {
256	currentFolds = new HashMap<FoldInfo, Fold>();
257	task = JavaElementFoldTask.getTask(file);	209	task = JavaElementFoldTask.getTask(file);
258	task.setGsfFoldManager(GsfFoldManager.this, file);	210	task.setGsfFoldManager(GsfFoldManager.this, file);
259	}	211	}
Lines 278-284 Link Here
278		230
279	@Override	231	@Override
280	public void removeDamagedNotify(Fold damagedFold) {	232	public void removeDamagedNotify(Fold damagedFold) {
281	currentFolds.remove(operation.getExtraInfo(damagedFold));
282	if (importsFold == damagedFold) {	233	if (importsFold == damagedFold) {
283	importsFold = null;//not sure if this is correct...	234	importsFold = null;//not sure if this is correct...
284	}	235	}
Lines 297-324 Link Here
297		248
298	task = null;	249	task = null;
299	file = null;	250	file = null;
300	currentFolds = null;
301	importsFold = null;	251	importsFold = null;
302	initialCommentFold = null;	252	initialCommentFold = null;
303	}	253	}
304		254
305	// public void settingsChange(SettingsChangeEvent evt) {
306	// // Get folding presets
307	// foldInitialCommentsPreset = getSetting(GsfOptions.CODE_FOLDING_COLLAPSE_INITIAL_COMMENT);
308	// foldImportsPreset = getSetting(GsfOptions.CODE_FOLDING_COLLAPSE_IMPORT);
309	// foldCodeBlocksPreset = getSetting(GsfOptions.CODE_FOLDING_COLLAPSE_METHOD);
310	// foldInnerClassesPreset = getSetting(GsfOptions.CODE_FOLDING_COLLAPSE_INNERCLASS);
311	// foldJavadocsPreset = getSetting(GsfOptions.CODE_FOLDING_COLLAPSE_JAVADOC);
312	// }
313
314	private static boolean getSetting(String settingName) {
315	return prefs.getBoolean(settingName, false);
316	}
317
318	static final class JavaElementFoldTask extends IndexingAwareParserResultTask<ParserResult> {	255	static final class JavaElementFoldTask extends IndexingAwareParserResultTask<ParserResult> {
319		256
320	private final AtomicBoolean cancelled = new AtomicBoolean(false);	257	private final AtomicBoolean cancelled = new AtomicBoolean(false);
321		258
		259	private FoldInfo initComment;
		260
		261	private FoldInfo imports;
		262
322	public JavaElementFoldTask() {	263	public JavaElementFoldTask() {
323	super(TaskIndexingMode.ALLOWED_DURING_SCAN);	264	super(TaskIndexingMode.ALLOWED_DURING_SCAN);
324	}	265	}
Lines 397-403 Link Here
397	return;	338	return;
398	}	339	}
399		340
400	final TreeSet<FoldInfo> folds = new TreeSet<FoldInfo>();	341	final Collection<FoldInfo> folds = new HashSet<FoldInfo>();
401	final Document doc = info.getSnapshot().getSource().getDocument(false);	342	final Document doc = info.getSnapshot().getSource().getDocument(false);
402	if (doc == null) {	343	if (doc == null) {
403	return;	344	return;
Lines 408-420 Link Here
408	}	349	}
409		350
410	if (mgrs instanceof GsfFoldManager) {	351	if (mgrs instanceof GsfFoldManager) {
411	SwingUtilities.invokeLater(((GsfFoldManager)mgrs).new CommitFolds(folds, doc, info.getSnapshot().getSource()));	352	SwingUtilities.invokeLater(((GsfFoldManager)mgrs).createCommit(
		353	folds,
		354	initComment, imports, doc, info.getSnapshot().getSource()));
412	} else {	355	} else {
413	SwingUtilities.invokeLater(new Runnable() {	356	SwingUtilities.invokeLater(new Runnable() {
414	Collection<GsfFoldManager> jefms = (Collection<GsfFoldManager>)mgrs;	357	Collection<GsfFoldManager> jefms = (Collection<GsfFoldManager>)mgrs;
415	public void run() {	358	public void run() {
416	for (GsfFoldManager jefm : jefms) {	359	for (GsfFoldManager jefm : jefms) {
417	jefm.new CommitFolds(folds, doc, info.getSnapshot().getSource()).run();	360	jefm.createCommit(folds, initComment, imports,
		361	doc, info.getSnapshot().getSource()).run();
418	}	362	}
419	}});	363	}});
420	}	364	}
Lines 430-436 Link Here
430	*	374	*
431	* @return true If folds were found, false if cancelled	375	* @return true If folds were found, false if cancelled
432	*/	376	*/
433	private boolean gsfFoldScan(final Document doc, ParserResult info, final TreeSet<FoldInfo> folds) {	377	private boolean gsfFoldScan(final Document doc, ParserResult info, final Collection<FoldInfo> folds) {
434	final boolean [] success = new boolean [] { false };	378	final boolean [] success = new boolean [] { false };
435	Source source = info.getSnapshot().getSource();	379	Source source = info.getSnapshot().getSource();
436		380
Lines 482-488 Link Here
482	return success[0];	426	return success[0];
483	}	427	}
484		428
485	private boolean checkInitialFold(final Document doc, final TreeSet<FoldInfo> folds) {	429	private boolean checkInitialFold(final Document doc, final Collection<FoldInfo> folds) {
486	final boolean[] ret = new boolean[1];	430	final boolean[] ret = new boolean[1];
487	ret[0] = true;	431	ret[0] = true;
488	final TokenHierarchy<?> th = TokenHierarchy.get(doc);	432	final TokenHierarchy<?> th = TokenHierarchy.get(doc);
Lines 492-543 Link Here
492	doc.render(new Runnable() {	436	doc.render(new Runnable() {
493	@Override	437	@Override
494	public void run() {	438	public void run() {
495	try {	439	TokenSequence<?> ts = th.tokenSequence();
496	TokenSequence<?> ts = th.tokenSequence();	440	if (ts == null) {
497	if (ts == null) {	441	return;
		442	}
		443	while (ts.moveNext()) {
		444	Token<?> token = ts.token();
		445	String category = token.id().primaryCategory();
		446	if ("comment".equals(category)) { // NOI18N
		447	int startOffset = ts.offset();
		448	int endOffset = startOffset + token.length();
		449
		450	// Find end - could be a block of single-line statements
		451	while (ts.moveNext()) {
		452	token = ts.token();
		453	category = token.id().primaryCategory();
		454	if ("comment".equals(category)) { // NOI18N
		455	endOffset = ts.offset() + token.length();
		456	} else if (!"whitespace".equals(category)) { // NOI18N
		457	break;
		458	}
		459	}
		460
		461	try {
		462	// Start the fold at the END of the line
		463	startOffset = org.netbeans.editor.Utilities.getRowEnd((BaseDocument) doc, startOffset);
		464	if (startOffset >= endOffset) {
		465	return;
		466	}
		467	} catch (BadLocationException ex) {
		468	LOG.log(Level.WARNING, null, ex);
		469	}
		470
		471	folds.add(initComment = FoldInfo.range(startOffset, endOffset, INITIAL_COMMENT_FOLD_TYPE));
498	return;	472	return;
499	}	473	}
500	while (ts.moveNext()) {	474	if (!"whitespace".equals(category)) { // NOI18N
501	Token<?> token = ts.token();	475	break;
502	String category = token.id().primaryCategory();
503	if ("comment".equals(category)) { // NOI18N
504	int startOffset = ts.offset();
505	int endOffset = startOffset + token.length();
506	boolean collapsed = getSetting(CODE_FOLDING_COLLAPSE_INITIAL_COMMENT); //foldInitialCommentsPreset;
507
508
509	// Find end - could be a block of single-line statements
510
511	while (ts.moveNext()) {
512	token = ts.token();
513	category = token.id().primaryCategory();
514	if ("comment".equals(category)) { // NOI18N
515	endOffset = ts.offset() + token.length();
516	} else if (!"whitespace".equals(category)) { // NOI18N
517	break;
518	}
519	}
520
521	try {
522	// Start the fold at the END of the line
523	startOffset = org.netbeans.editor.Utilities.getRowEnd((BaseDocument) doc, startOffset);
524	if (startOffset >= endOffset) {
525	return;
526	}
527	} catch (BadLocationException ex) {
528	LOG.log(Level.WARNING, null, ex);
529	}
530
531	folds.add(new FoldInfo(doc, startOffset, endOffset, INITIAL_COMMENT_FOLD_TEMPLATE, collapsed));
532	return;
533	}
534	if (!"whitespace".equals(category)) { // NOI18N
535	break;
536	}
537
538	}	476	}
539	} catch (BadLocationException e) {
540	ret[0] = false;
541	}	477	}
542	}	478	}
543	});	479	});
Lines 545-551 Link Here
545	}	481	}
546		482
547	private void scan(final ParserResult info,	483	private void scan(final ParserResult info,
548	final TreeSet<FoldInfo> folds, final Document doc, final	484	final Collection<FoldInfo> folds, final Document doc, final
549	StructureScanner scanner) {	485	StructureScanner scanner) {
550		486
551	doc.render(new Runnable() {	487	doc.render(new Runnable() {
Lines 556-623 Link Here
556	});	492	});
557	}	493	}
558		494
559	private void addFoldsOfType(	495	private boolean addFoldsOfType(
560	StructureScanner scanner,
561	String type, Map<String,List<OffsetRange>> folds,	496	String type, Map<String,List<OffsetRange>> folds,
562	TreeSet<FoldInfo> result,	497	Collection<FoldInfo> result,
563	Document doc,	498	Document doc,
564	String collapsedOptionName,	499	FoldType foldType) {
565	FoldTemplate template) {
566		500
567	List<OffsetRange> ranges = folds.get(type); //NOI18N	501	List<OffsetRange> ranges = folds.get(type); //NOI18N
568	if (ranges != null) {	502	if (ranges != null) {
569	boolean collapseByDefault = getSetting(collapsedOptionName);
570	if (LOG.isLoggable(Level.FINEST)) {	503	if (LOG.isLoggable(Level.FINEST)) {
571	LOG.log(Level.FINEST, "Creating folds {0}, collapsed: {1}", new Object[] {	504	LOG.log(Level.FINEST, "Creating folds {0}", new Object[] {
572	type, collapseByDefault	505	type
573	});	506	});
574	}	507	}
575	for (OffsetRange range : ranges) {	508	for (OffsetRange range : ranges) {
576	try {	509	if (LOG.isLoggable(Level.FINEST)) {
577	if (LOG.isLoggable(Level.FINEST)) {	510	LOG.log(Level.FINEST, "Fold: {0}", range);
578	LOG.log(Level.FINEST, "Fold: {0}", range);
579	}
580	addFold(range, result, doc, collapseByDefault, template);
581	} catch (BadLocationException ble) {
582	LOG.log(Level.WARNING, "StructureScanner " + scanner + " supplied invalid fold " + range, ble); //NOI18N
583	}	511	}
		512	addFold(range, result, doc, foldType);
584	}	513	}
		514	folds.remove(type);
		515	return true;
585	} else {	516	} else {
586	LOG.log(Level.FINEST, "No folds of type {0}", type);	517	LOG.log(Level.FINEST, "No folds of type {0}", type);
		518	return false;
587	}	519	}
588	}	520	}
589		521
590	private void addTree(TreeSet<FoldInfo> result, ParserResult info, Document doc, StructureScanner scanner) {	522	private void addTree(Collection<FoldInfo> result, ParserResult info, Document doc, StructureScanner scanner) {
591	// #217322, disabled folding -> no folds will be created	523	// #217322, disabled folding -> no folds will be created
592	if (!getSetting(CODE_FOLDING_ENABLE)) {	524	String mime = info.getSnapshot().getMimeType();
		525
		526	if (!FoldUtilities.isFoldingEnabled(mime)) {
593	return;	527	return;
594	}	528	}
595	Map<String,List<OffsetRange>> folds = scanner.folds(info);	529	Map<String,List<OffsetRange>> folds = scanner.folds(info);
596	if (cancelled.get()) {	530	if (cancelled.get()) {
597	return;	531	return;
598	}	532	}
599	addFoldsOfType(scanner, "codeblocks", folds, result, doc,	533	Collection<? extends FoldType> ftypes = FoldUtilities.getFoldTypes(mime).values();
600	CODE_FOLDING_COLLAPSE_METHOD, CODE_BLOCK_FOLD_TEMPLATE);	534	for (FoldType ft : ftypes) {
601	addFoldsOfType(scanner, "comments", folds, result, doc,	535	addFoldsOfType(ft.code(), folds, result, doc, ft);
602	CODE_FOLDING_COLLAPSE_JAVADOC, JAVADOC_FOLD_TEMPLATE);	536	}
603	addFoldsOfType(scanner, "initial-comment", folds, result, doc,	537	// fallback: transform the legacy keys into FoldInfos
604	CODE_FOLDING_COLLAPSE_INITIAL_COMMENT, INITIAL_COMMENT_FOLD_TEMPLATE);	538	addFoldsOfType("codeblocks", folds, result, doc,
605	addFoldsOfType(scanner, "imports", folds, result, doc,	539	CODE_BLOCK_FOLD_TYPE);
606	CODE_FOLDING_COLLAPSE_IMPORT, IMPORTS_FOLD_TEMPLATE);	540	addFoldsOfType("comments", folds, result, doc,
607	addFoldsOfType(scanner, "tags", folds, result, doc,	541	JAVADOC_FOLD_TYPE);
608	CODE_FOLDING_COLLAPSE_TAGS, TAG_FOLD_TEMPLATE);	542	addFoldsOfType("initial-comment", folds, result, doc,
609	addFoldsOfType(scanner, "othercodeblocks", folds, result, doc,	543	INITIAL_COMMENT_FOLD_TYPE);
610	CODE_FOLDING_COLLAPSE_TAGS, CODE_BLOCK_FOLD_TEMPLATE);	544	addFoldsOfType("imports", folds, result, doc,
611	addFoldsOfType(scanner, "inner-classes", folds, result, doc,	545	IMPORTS_FOLD_TYPE);
612	CODE_FOLDING_COLLAPSE_INNERCLASS, INNER_CLASS_FOLD_TEMPLATE);	546	addFoldsOfType("tags", folds, result, doc,
		547	TAG_FOLD_TYPE);
		548	addFoldsOfType("othercodeblocks", folds, result, doc,
		549	CODE_BLOCK_FOLD_TYPE);
		550	addFoldsOfType("inner-classes", folds, result, doc,
		551	INNER_CLASS_FOLD_TYPE);
		552
		553	if (folds.size() > 0) {
		554	LOG.log(Level.WARNING, "Undefined fold types used in {0}: {1}", new Object[] {
		555	info, folds.keySet()
		556	});
		557	}
613	}	558	}
614		559
615	private void addFold(OffsetRange range, TreeSet<FoldInfo> folds, Document doc, boolean collapseByDefault, FoldTemplate template) throws BadLocationException {	560	private void addFold(OffsetRange range, Collection<FoldInfo> folds, Document doc, FoldType type) {
616	if (range != OffsetRange.NONE) {	561	if (range != OffsetRange.NONE) {
617	int start = range.getStart();	562	int start = range.getStart();
618	int end = range.getEnd();	563	int end = range.getEnd();
619	if (start != (-1) && end != (-1) && end <= doc.getLength()) {	564	if (start != (-1) && end != (-1) && end <= doc.getLength()) {
620	folds.add(new FoldInfo(doc, start, end, template, collapseByDefault));	565	FoldInfo fi = FoldInfo.range(start, end, type);
		566	// hack for singular imports fold
		567	if (fi.getType() == IMPORTS_FOLD_TYPE && imports == null) {
		568	imports = fi;
		569	}
		570	folds.add(fi);
621	}	571	}
622	}	572	}
623	}	573	}
Lines 639-655 Link Here
639		589
640	}	590	}
641		591
		592	private Runnable createCommit(Collection<FoldInfo> folds, FoldInfo initComment, FoldInfo imports, Document d, Source s) {
		593	return new CommitFolds(folds, initComment, imports, d, s);
		594	}
		595
642	private class CommitFolds implements Runnable {	596	private class CommitFolds implements Runnable {
643	private Document scannedDocument;	597	private final Document scannedDocument;
644	private Source scanSource;	598	private Source scanSource;
645		599
646	private boolean insideRender;	600	private boolean insideRender;
647	private TreeSet<FoldInfo> infos;	601	private Collection<FoldInfo> infos;
648	private long startTime;	602	private long startTime;
		603	private FoldInfo initComment;
		604	private FoldInfo imports;
649		605
650	public CommitFolds(TreeSet<FoldInfo> infos, Document scanedDocument, Source s) {	606	public CommitFolds(Collection<FoldInfo> infos, FoldInfo initComment, FoldInfo imports, Document scannedDocument, Source s) {
651	this.infos = infos;	607	this.infos = infos;
652	this.scannedDocument = scanedDocument;	608	this.initComment = initComment;
		609	this.imports = imports;
		610	this.scannedDocument = scannedDocument;
653	this.scanSource = s;	611	this.scanSource = s;
654	}	612	}
655		613
Lines 658-674 Link Here
658	* ignores the default state, and takes it from the actual state of	616	* ignores the default state, and takes it from the actual state of
659	* existing fold.	617	* existing fold.
660	*/	618	*/
661	private boolean mergeSpecialFoldState(FoldInfo fi) {	619	private void mergeSpecialFoldState(FoldInfo fi, Fold f) {
662	if (fi.template == IMPORTS_FOLD_TEMPLATE) {	620	if (fi != null && f != null) {
663	if (importsFold != null) {	621	fi.collapsed(f.isCollapsed());
664	return importsFold.isCollapsed();
665	}
666	} else if (fi.template == INITIAL_COMMENT_FOLD_TEMPLATE) {
667	if (initialCommentFold != null) {
668	return initialCommentFold.isCollapsed();
669	}
670	}	622	}
671	return fi.collapseByDefault;
672	}	623	}
673		624
674	public void run() {	625	public void run() {
Lines 682-687 Link Here
682	}	633	}
683		634
684	operation.getHierarchy().lock();	635	operation.getHierarchy().lock();
		636	if (task == null) {
		637	return;
		638	}
685	if (operation.getHierarchy().getComponent().getDocument() != this.scannedDocument) {	639	if (operation.getHierarchy().getComponent().getDocument() != this.scannedDocument) {
686	Throwable t = (Throwable)scannedDocument.getProperty("Issue-222763-debug");	640	Throwable t = (Throwable)scannedDocument.getProperty("Issue-222763-debug");
687	StringWriter sw = new StringWriter();	641	StringWriter sw = new StringWriter();
Lines 704-774 Link Here
704	return;	658	return;
705	}	659	}
706	try {	660	try {
707	FoldHierarchyTransaction tr = operation.openTransaction();
708
709	try {	661	try {
710	if (currentFolds == null) {	662	mergeSpecialFoldState(imports, importsFold);
711	return;	663	mergeSpecialFoldState(initComment, initialCommentFold);
		664
		665	Map<FoldInfo, Fold> newState = operation.update(infos, null, null);
		666	if (imports != null) {
		667	importsFold = newState.get(imports);
712	}	668	}
713		669	if (initComment != null) {
714	Map<FoldInfo, Fold> added = new TreeMap<FoldInfo, Fold>();	670	initialCommentFold = newState.get(initComment);
715	// TODO - use map duplication here instead?
716	TreeSet<FoldInfo> removed = new TreeSet<FoldInfo>(currentFolds.keySet());
717	int documentLength = document.getLength();
718
719	for (FoldInfo i : infos) {
720	if (removed.remove(i)) {
721	continue ;
722	}
723
724	int start = i.start.getOffset();
725	int end = i.end.getOffset();
726
727	if (end > documentLength) {
728	continue;
729	}
730
731	if (end > start && (end - start) > (i.template.getStartGuardedLength() + i.template.getEndGuardedLength())) {
732	Fold f = operation.addToHierarchy(i.template.getType(),
733	i.template.getDescription(),
734	mergeSpecialFoldState(i),
735	start,
736	end,
737	i.template.getStartGuardedLength(),
738	i.template.getEndGuardedLength(),
739	i,
740	tr);
741
742	added.put(i, f);
743
744	if (i.template == IMPORTS_FOLD_TEMPLATE) {
745	importsFold = f;
746	}
747	if (i.template == INITIAL_COMMENT_FOLD_TEMPLATE) {
748	initialCommentFold = f;
749	}
750	}
751	}	671	}
752
753	for (FoldInfo i : removed) {
754	Fold f = currentFolds.remove(i);
755
756	operation.removeFromHierarchy(f, tr);
757
758	if (importsFold == f ) {
759	importsFold = null;
760	}
761
762	if (initialCommentFold == f) {
763	initialCommentFold = f;
764	}
765	}
766
767	currentFolds.putAll(added);
768	} catch (BadLocationException e) {	672	} catch (BadLocationException e) {
769	LOG.log(Level.WARNING, null, e);	673	LOG.log(Level.WARNING, null, e);
770	} finally {
771	tr.commit();
772	}	674	}
773	} finally {	675	} finally {
774	operation.getHierarchy().unlock();	676	operation.getHierarchy().unlock();
Lines 781-843 Link Here
781	}	683	}
782	}	684	}
783		685
784	private Map<FoldInfo, Fold> currentFolds;
785	private Fold initialCommentFold;	686	private Fold initialCommentFold;
786	private Fold importsFold;	687	private Fold importsFold;
787
788	protected static final class FoldInfo implements Comparable {
789
790	private Position start;
791	private Position end;
792	private FoldTemplate template;
793	private boolean collapseByDefault;
794
795	public FoldInfo(Document doc, int start, int end, FoldTemplate template, boolean collapseByDefault) throws BadLocationException {
796	this.start = doc.createPosition(start);
797	// see issue #216378; while Fold.end Position is manually updated by FoldHierarchyTransactionImpl, the
798	// FoldInfos are left alone, and end marker must stick with the content, so characters typed after it does
799	// not extend the FoldInfo
800	this.end = NbDocument.createPosition(doc, end, Position.Bias.Backward);
801	this.template = template;
802	this.collapseByDefault = collapseByDefault;
803	}
804
805	@Override
806	public int hashCode() {
807	return 1;
808	}
809
810	@Override
811	public boolean equals(Object o) {
812	if (!(o instanceof FoldInfo)) {
813	return false;
814	}
815
816	return compareTo(o) == 0;
817	}
818
819	public int compareTo(Object o) {
820	FoldInfo remote = (FoldInfo) o;
821
822	if (start.getOffset() < remote.start.getOffset()) {
823	return -1;
824	}
825
826	if (start.getOffset() > remote.start.getOffset()) {
827	return 1;
828	}
829
830	if (end.getOffset() < remote.end.getOffset()) {
831	return -1;
832	}
833
834	if (end.getOffset() > remote.end.getOffset()) {
835	return 1;
836	}
837
838	return 0;
839	}
840	}
841		688
842	private static boolean hasErrors(ParserResult r) {	689	private static boolean hasErrors(ParserResult r) {
843	for(org.netbeans.modules.csl.api.Error e : r.getDiagnostics()) {	690	for(org.netbeans.modules.csl.api.Error e : r.getDiagnostics()) {

Lines 1-5 Link Here

(-)a/editor.codetemplates/nbproject/org-netbeans-modules-editor-codetemplates.sig (-1 / +1 lines)
1	#Signature file v4.1	1	#Signature file v4.1
2	#Version 1.26.1	2	#Version 1.31.0
3		3
4	CLSS public java.lang.Object	4	CLSS public java.lang.Object
5	cons public init()	5	cons public init()

Lines 45-50 Link Here

(-)a/editor.codetemplates/nbproject/project.properties (-1 / +1 lines)
45	#javadoc.name=EditorCodeTemplates	45	#javadoc.name=EditorCodeTemplates
46	javadoc.apichanges=${basedir}/apichanges.xml	46	javadoc.apichanges=${basedir}/apichanges.xml
47	javadoc.arch=${basedir}/arch.xml	47	javadoc.arch=${basedir}/arch.xml
48	spec.version.base=1.31.0	48	spec.version.base=1.32.0
49		49
50	test.config.stableBTD.includes=*/Test.class	50	test.config.stableBTD.includes=*/Test.class

Lines 99-105 Link Here

(-)a/editor.codetemplates/nbproject/project.xml (-1 / +1 lines)
99	<compile-dependency/>	99	<compile-dependency/>
100	<run-dependency>	100	<run-dependency>
101	<release-version>1</release-version>	101	<release-version>1</release-version>
102	<specification-version>1.20</specification-version>	102	<specification-version>1.31</specification-version>
103	</run-dependency>	103	</run-dependency>
104	</dependency>	104	</dependency>
105	<dependency>	105	<dependency>




            this.ic = ic;
            
            // Start listening
            List<MimePath> allPaths = mimePath.getIncludedPaths();
            this.allCtsi = new CodeTemplateSettingsImpl[allPaths.size()];
            
            for(int i = 0; i < allPaths.size(); i++) {
                this.allCtsi[i] = CodeTemplateSettingsImpl.get(allPaths.get(i));
                this.allCtsi[i].addPropertyChangeListener(WeakListeners.propertyChange(this, this.allCtsi[i]));
            }
        }

        }
        
    } // End of CompositeCTS class
    
    private static MimePath [] computeInheritedMimePaths(MimePath mimePath) {
        List<String> paths = null;
        try {
            Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
            m.setAccessible(true);
            @SuppressWarnings("unchecked")
            List<String> ret = (List<String>) m.invoke(mimePath, null, null);
            paths = ret;
        } catch (Exception e) {
            LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
        }

        if (paths != null) {
            ArrayList<MimePath> mimePaths = new ArrayList<MimePath>(paths.size());

            for (String path : paths) {
                mimePaths.add(MimePath.parse(path));
            }

            return mimePaths.toArray(new MimePath[mimePaths.size()]);
        } else {
            return new MimePath [] { mimePath, MimePath.EMPTY };
        }
    }
    
}




    }
</pre>

<h3>Updating Fold hierarchy</h3>
In the preceding cases, maintaining Folds was the FoldManager's responsibility. The FoldManager typically
held a copy of the Folds added to the hierarchy, and during the refresh, it compared them to the new data
and decided what folds to remove.
For simple cases, which only create/remove folds based on text positions, part of the work can be offloaded to the
FoldOperation:

<pre>
    // create new fold positional information for all folds.
    Collection&lt;FoldInfo> newInfos = ...;
    
    // create FoldInfo for each of the fold
    newInfos.add(
        FoldInfo.range(start, end, type).
            withTemplate(customTemplate).
            withDescription(veryCustomDescription).
            collapse(true)
    );
    
    // the hierarchy must be locked prior to update
    
    doc.readLock();
    hierarchy.lock();
    try {
        operation.update(newInfos, null, null);
    } finally {
    }
</pre>

The <code>update()</code> operation performs a diff, creates new folds, discards old ones, and updates the folds, which
prevailed.

<h3>Accessing folds</h3>
Instead of keeping a copy of created folds, the FoldManager may call <code>operation.foldIterator</code>. The iterator
will enumerate all folds, including (recursively) blocked ones.

</answer>


No.
</answer>




<!--
        <question id="arch-where" when="impl">
            Where one can find sources for your module?
            <hint>
                Please provide link to the Hg web client at
                http://hg.netbeans.org/
                or just use tag defaultanswer generate='here'
            </hint>
        </question>
-->
 <answer id="arch-where">
  <defaultanswer generate='here' />
 </answer>



<!--
        <question id="compat-deprecation" when="init">
            How the introduction of your project influences functionality
            provided by previous version of the product?
            <hint>
            If you are planning to deprecate/remove/change any existing APIs,
            list them here accompanied with the reason explaining why you
            are doing so.
            </hint>
        </question>
-->
 <answer id="compat-deprecation">
  <p>
   XXX no answer for compat-deprecation
  </p>
 </answer>



<!--
        <question id="exec-ant-tasks" when="impl">
            Do you define or register any ant tasks that other can use?
            
            <hint>
            If you provide an ant task that users can use, you need to be very
            careful about its syntax and behaviour, as it most likely forms an
	          API for end users and as there is a lot of end users, their reaction
            when such API gets broken can be pretty strong.
            </hint>
        </question>
-->
 <answer id="exec-ant-tasks">
  <p>
   XXX no answer for exec-ant-tasks
  </p>
 </answer>



<!--
        <question id="resources-preferences" when="final">
            Does your module uses preferences via Preferences API? Does your module use NbPreferences or
            or regular JDK Preferences ? Does it read, write or both ? 
            Does it share preferences with other modules ? If so, then why ?
            <hint>
                You may use
                    &lt;api type="export" group="preferences"
                    name="preference node name" category="private"&gt;
                    description of individual keys, where it is used, what it
                    influences, whether the module reads/write it, etc.
                    &lt;/api&gt;
                Due to XML ID restrictions, rather than /org/netbeans/modules/foo give the "name" as org.netbeans.modules.foo.
                Note that if you use NbPreferences this name will then be the same as the code name base of the module.
            </hint>
        </question>
-->
 <answer id="resources-preferences">
  <p>
   XXX no answer for resources-preferences
  </p>
 </answer>

</api-answers>

Lines 1-5 Link Here

(-)a/editor.fold/nbproject/org-netbeans-modules-editor-fold.sig (-1 / +1 lines)
1	#Signature file v4.1	1	#Signature file v4.1
2	#Version 1.29.2	2	#Version 1.33.0
3		3
4	CLSS public abstract interface java.io.Serializable	4	CLSS public abstract interface java.io.Serializable
5		5

Lines 46-51 Link Here

(-)a/editor.fold/nbproject/project.properties (-1 / +1 lines)
46	#cp.extra=	46	#cp.extra=
47		47
48	javac.source=1.6	48	javac.source=1.6
49	spec.version.base=1.33.0	49	spec.version.base=1.34.0
50		50
51	test.config.stableBTD.includes=*/Test.class	51	test.config.stableBTD.includes=*/Test.class

Lines 50-55 Link Here

(-)a/editor.fold/nbproject/project.xml (-1 / +49 lines)
50	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>	50	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
51	<module-dependencies>	51	<module-dependencies>
52	<dependency>	52	<dependency>
		53	<code-name-base>org.netbeans.modules.editor.lib</code-name-base>
		54	<build-prerequisite/>
		55	<compile-dependency/>
		56	<run-dependency>
		57	<release-version>3</release-version>
		58	<specification-version>3.33</specification-version>
		59	</run-dependency>
		60	</dependency>
		61	<dependency>
53	<code-name-base>org.netbeans.modules.editor.lib2</code-name-base>	62	<code-name-base>org.netbeans.modules.editor.lib2</code-name-base>
54	<build-prerequisite/>	63	<build-prerequisite/>
55	<compile-dependency/>	64	<compile-dependency/>
Lines 64-70 Link Here
64	<compile-dependency/>	73	<compile-dependency/>
65	<run-dependency>	74	<run-dependency>
66	<release-version>1</release-version>	75	<release-version>1</release-version>
67	<specification-version>1.20</specification-version>	76	<specification-version>1.31</specification-version>
68	</run-dependency>	77	</run-dependency>
69	</dependency>	78	</dependency>
70	<dependency>	79	<dependency>
Lines 77-82 Link Here
77	</run-dependency>	86	</run-dependency>
78	</dependency>	87	</dependency>
79	<dependency>	88	<dependency>
		89	<code-name-base>org.netbeans.modules.editor.settings.storage</code-name-base>
		90	<build-prerequisite/>
		91	<compile-dependency/>
		92	<run-dependency>
		93	<release-version>1</release-version>
		94	<specification-version>1.38</specification-version>
		95	</run-dependency>
		96	</dependency>
		97	<dependency>
80	<code-name-base>org.netbeans.modules.editor.util</code-name-base>	98	<code-name-base>org.netbeans.modules.editor.util</code-name-base>
81	<build-prerequisite/>	99	<build-prerequisite/>
82	<compile-dependency/>	100	<compile-dependency/>
Lines 85-90 Link Here
85	</run-dependency>	103	</run-dependency>
86	</dependency>	104	</dependency>
87	<dependency>	105	<dependency>
		106	<code-name-base>org.netbeans.modules.lexer</code-name-base>
		107	<build-prerequisite/>
		108	<compile-dependency/>
		109	<run-dependency>
		110	<release-version>2</release-version>
		111	<specification-version>1.49</specification-version>
		112	</run-dependency>
		113	</dependency>
		114	<dependency>
		115	<code-name-base>org.netbeans.modules.options.api</code-name-base>
		116	<build-prerequisite/>
		117	<compile-dependency/>
		118	<run-dependency>
		119	<release-version>1</release-version>
		120	<specification-version>1.31</specification-version>
		121	</run-dependency>
		122	</dependency>
		123	<dependency>
		124	<code-name-base>org.openide.awt</code-name-base>
		125	<build-prerequisite/>
		126	<compile-dependency/>
		127	<run-dependency>
		128	<specification-version>7.55</specification-version>
		129	</run-dependency>
		130	</dependency>
		131	<dependency>
88	<code-name-base>org.openide.filesystems</code-name-base>	132	<code-name-base>org.openide.filesystems</code-name-base>
89	<build-prerequisite/>	133	<build-prerequisite/>
90	<compile-dependency/>	134	<compile-dependency/>
Lines 147-154 Link Here
147	</test-dependencies>	191	</test-dependencies>
148	<public-packages>	192	<public-packages>
149	<package>org.netbeans.api.editor.fold</package>	193	<package>org.netbeans.api.editor.fold</package>
		194	<package>org.netbeans.editor</package>
150	<package>org.netbeans.spi.editor.fold</package>	195	<package>org.netbeans.spi.editor.fold</package>
151	</public-packages>	196	</public-packages>
152	</data>	197	</data>
		198	<spellchecker-wordlist xmlns="http://www.netbeans.org/ns/spellchecker-wordlist/1">
		199	<word>initially</word>
		200	</spellchecker-wordlist>
153	</configuration>	201	</configuration>
154	</project>	202	</project>




import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.Position;
import org.netbeans.modules.editor.fold.ApiPackageAccessor;
import org.netbeans.modules.editor.fold.FoldOperationImpl;
import org.netbeans.modules.editor.fold.FoldChildren;
import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;

    
    private Object extraInfo;
    

    Fold(FoldOperationImpl operation,
    FoldType type, String description, boolean collapsed,
    Document doc, int startOffset, int endOffset,

    public int getFoldIndex(Fold child) {
        return (children != null) ? children.getFoldIndex(child) : -1;
    }

    /**
     * Start of the fold content past the guarded area.
     * For root fold, returns 0. For other folds, returns the offset
     * following the guarded start of the fold (typically a delimiter).
     * 
     * @return offset in document
     */
    public int getGuardedStart() {
        if (isRootFold()) {
            return 0;
        } else if (isZeroStartGuardedLength()) {
            return getStartOffset();
        } else {
            return getStartOffset() + startGuardedLength;
        }
    }
    
    /**
     * End of the fold content before the guarded area.
     * For root fold, returns 0. For other folds, returns the last offset
     * preceding the guarded start of the fold (typically a delimiter).
     * 
     * @return offset in document
     */
    public int getGuardedEnd() {
        if (isRootFold()) {
            return getEndOffset();
        } else if (isZeroStartGuardedLength()) {
            return getEndOffset();
        } else {
            return getEndOffset() - endGuardedLength;
        }
    }
    
    private void updateGuardedStartPos(Document doc, int startOffset) throws BadLocationException {
        if (!isRootFold()) {

        this.rawIndex += rawIndexDelta;
    }
    

    public String toString() {
        return FoldUtilitiesImpl.foldToString(this) + ", [" + getInnerStartOffset() // NOI18N
            + ", " + getInnerEndOffset() + "] {" // NOI18N

Lines 53-58 Link Here

(-)a/editor.fold/src/org/netbeans/api/editor/fold/FoldHierarchy.java (-1 / +6 lines)
53	import org.netbeans.modules.editor.fold.ApiPackageAccessor;	53	import org.netbeans.modules.editor.fold.ApiPackageAccessor;
54	import org.netbeans.modules.editor.fold.FoldHierarchyExecution;	54	import org.netbeans.modules.editor.fold.FoldHierarchyExecution;
55	import org.netbeans.modules.editor.fold.FoldOperationImpl;	55	import org.netbeans.modules.editor.fold.FoldOperationImpl;
		56	import org.netbeans.spi.editor.fold.FoldTypeProvider;
56		57
57	/**	58	/**
58	* Hierarchy of the folds for a single text component represents	59	* Hierarchy of the folds for a single text component represents
Lines 122-128 Link Here
122	static {	123	static {
123	ensureApiAccessorRegistered();	124	ensureApiAccessorRegistered();
124	}	125	}
125		126
126	private static void ensureApiAccessorRegistered() {	127	private static void ensureApiAccessorRegistered() {
127	if (!apiPackageAccessorRegistered) {	128	if (!apiPackageAccessorRegistered) {
128	apiPackageAccessorRegistered = true;	129	apiPackageAccessorRegistered = true;
Lines 458-463 Link Here
458	fsc.endOffsetChanged(originalEndOffset);	459	fsc.endOffsetChanged(originalEndOffset);
459	}	460	}
460		461
		462	public FoldHierarchyExecution foldGetExecution(FoldHierarchy h) {
		463	return h.execution;
		464	}
		465
461	}	466	}
462		467
463	}	468	}




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

import org.openide.util.NbBundle;

import static org.netbeans.api.editor.fold.Bundle.*;

/**
 * Template that describes how the fold should appear and interact with the
 * user. The FoldTemplate defines how many characters at the start (end) should
 * act as a fold guard: change to that area will remove the fold because it
 * becomes damaged. It also defines what placeholder should appear in place of the 
 * folded code.
 * <p/>
 * A template may be attached to a {@link FoldType} instance. Folds of that kind will
 * automatically use the attached Template, if not overriden explicitly.
 * <p/>
 * The string {@code "..."} ({@link #CONTENT_PLACEHOLDER}) is treated as a placeholder. If a 
 * ContentReader is available for the {@link FoldType}, the placeholder will be replaced by 
 * the product of the Reader. Otherwise the placeholder will remain in the displayText 
 * and will be presented.
 * 
 * @since 1.34
 * @author sdedic
 */
public final class FoldTemplate {
    /**
     * The default template for folded text: no markers before+after, ellipsis
     * shown.
     */
    @NbBundle.Messages("FT_DefaultTemplate=...")
    public static final FoldTemplate DEFAULT = new FoldTemplate(0, 0, FT_DefaultTemplate()); // NOI18N
    
    /**
     * A standard template, which represents a block of something.
     */
    @NbBundle.Messages("FT_DefaultBlockTemplate={...}")
    public static final FoldTemplate DEFAULT_BLOCK = new FoldTemplate(0, 0, FT_DefaultBlockTemplate()); // NOI18N
    
    /**
     * This string is interpreted as a placeholder for the infrastructure to inject 
     */
    public static final String CONTENT_PLACEHOLDER = FT_DefaultTemplate();
    
    /**
     * # of characters at the start of the fold, which serve as a marker that the fold
     * has been damaged/destroyed
     */
    private int     guardedStart;
    
    /**
     * The guarded portion at the end of the fold
     */
    private int     guardedEnd;
    
    /**
     * Description that appears in the folded area.
     */
    private String  displayText;
    
    /**
     * Creates a FoldTemplate with a fixed description.
     * 
     * @param guardedStart length of the start marker, or -1 if no start marker is present
     * @param guardedEnd length of the end marker, or -1 if no end marker is present
     * @param displayText text which should be displayed in place of the folded content
     */
    public FoldTemplate(int guardedStart, int guardedEnd, String displayText) {
        this.guardedStart = guardedStart;
        this.guardedEnd = guardedEnd;
        this.displayText = displayText;
    }

    public String getDescription() {
        return displayText;
    }

    public int getGuardedEnd() {
        return guardedEnd;
    }

    public int getGuardedStart() {
        return guardedStart;
    }
}





package org.netbeans.api.editor.fold;

import java.util.Collection;
import javax.swing.event.ChangeListener;
import org.openide.util.NbBundle;
import org.openide.util.Parameters;

import static org.netbeans.api.editor.fold.Bundle.*;

/**
 * Each {@link Fold} is identified by its fold type.
 * <br>
 * Each fold type presents a fold type acceptor as well
 * accepting just itself.
 *
 * <p/>
 * <strike>
 * As the <code>equals()</code> method is declared final
 * (delegating to <code>super</code>) the fold types
 * can directly be compared by using <code>==</code>
 * operator.
 * </strike>
  * <p/>
 * FoldTypes are MIME-type specific. Sets of FoldType, which apply
 * to a certain MIME type are collected in a {@link FoldType.Domain},
 * which can be obtained by {@link FoldUtilities#getFoldTypes}. FoldTypes for a MIME type are
 * collected with the help of {@link org.netbeans.spi.editor.fold.FoldTypeProvider}.
 * <p/>
 * Several generalized types of folds are defined in this class as constants. 
 * When creating custom FoldTypes, please check carefully whether the new FoldType is not, 
 * in fact, one of these general ones,
 * or is not a specialization of it. If a general action (e.g. auto-collapse all folds XXX) would
 * make sense for the new fold, consider to {@link #derive} it from an existing one. 
 * <p/>
 * Each FoldType has a specific FoldTemplate instance that controls how it is presented. If a
 * new Fold has same semantics as an existing one, but a different {@link FoldTemplate} is needed,
 * use {@link #override} to create a new FoldType with appropriate properties. FoldTypes
 * defined here can be <b>reused</b> in individual MIME types, if their configuration is appropriate.
 * In general, FoldTypes from more general MIME types (e.g. text/xml) can be reused in specialized ones
 * (e.g. text/x-ant+xml).
 * <p/>
 * FoldTypes can form a hierarchy of generalization. For example java Method fold can have a more general
 * 'parent', {@link #MEMBER}. 
 * <p/>
 * The generalization is designed to allow several kinds of the same concept operated separately at the
 * level of the language, but managed at once using general options or operations. 
 * If no settings are specified for Method folding, {@link #MEMBER} settings are
 * applied. Likewise, a general-purpose folding operation can work on {@link #MEMBER} fold type,
 * which will affect both FUNCTION in PHP or METHOD in java (and other fold types in other languages).
 * <p/>
 * Because of this, please be careful
 * to use {@link #isKindOf} to check whether a FoldType is of a specific type. This method respects the
 * generalization. == can be still used to check for exact type match. When using ==, javadoc comments
 * may be evaluated as different from general 'documentation' and yet different from PHP docs. Comparison using 
 * == are safe only when applied on FoldType instances defined for the same MIME type
* <p/>
 *
 * @author sdedic
 * Fold providers should export all the fold types
 * that they provide in their APIs so that the
 * clients can use these fold types in operations
 * with the fold hierarchy.
 *
 * @author Miloslav Metelka
 * @version 1.00
 */

public final class FoldType {
    /**
     * A generic code block. Note that other categories are defined that represent
     * method, class, member or nested symbol levels
     * @since 1.34
     */
    @NbBundle.Messages({
        "FT_Label_code-block=Code Blocks",
        "FT_display_code-block={...}",
        "FT_display_default=..."
    })
    public static final FoldType    CODE_BLOCK = create("code-block", FT_Label_code_block(), 
            new FoldTemplate(1, 1, FT_display_code_block()));

    /**
     * Documentation comment, as defined by the language
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_javadoc=Documentation")
    public static final FoldType    DOCUMENTATION = create("documentation", FT_Label_javadoc(), 
            FoldTemplate.DEFAULT);
    
    /**
     * Unspecified type of comment
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_comment=Comments")
    public static final FoldType    COMMENT = create("comment", FT_Label_comment(), 
            FoldTemplate.DEFAULT);
    
    /**
     * Initial file-level comment. Either documentation comment or comment containing
     * copyright. Defaults to 'comment'
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_initial-comment=Initial Comment")
    public static final FoldType    INITIAL_COMMENT = create("initial-comment", FT_Label_initial_comment(),
            FoldTemplate.DEFAULT);

    /**
     * Tag in markup languages
     * @since 1.34
     */
    @NbBundle.Messages({
        "FT_Label_tag=Tags and Markup",
        "FT_display_tag=<.../>"
    })
    public static final FoldType    TAG = create("tag", FT_Label_tag(), 
            new FoldTemplate(1, 2, FT_display_tag()));
    
    /**
     * Nested part; for example an embedded type, or nested namespace. Do not use
     * this category for top-level symbols. This type is different from a 'member',
     * as type may have many member types, nested types form worlds of their own
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_inner-class=Nested Blocks")
    public static final FoldType    NESTED = create("nested", FT_Label_inner_class(), 
            FoldTemplate.DEFAULT);
    
    /**
     * Member of a symbol (type, class, object)
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_member=Member")
    public static final FoldType    MEMBER = create("member", FT_Label_member(), 
            FoldTemplate.DEFAULT);

    /**
     * Various import, includes and references to sibling files.
     * 
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_import=Imports and Includes")
    public static final FoldType    IMPORT = create("import", FT_Label_import(), 
            FoldTemplate.DEFAULT);
    
    /**
     * User-defined fold, recoded using a special comment
     * @since 1.34
     */
    @NbBundle.Messages("FT_Label_user-defined=User defined")
    public static final FoldType    USER = create("user", FT_Label_user_defined(), null);

    /**
     * Construct fold type with the given description.
     *
     * @param description textual description of the fold type.
     *  Two fold types with the same description are not equal.
     * @deprecated Use the {link create} static method.
     */
    @Deprecated
    public FoldType(String description) {
        this(description, null, null, null);
    }
    
    private FoldType(String code, String label, FoldTemplate template, FoldType parent) {
        this.code = code;
        this.parent = parent;
        this.label = label;
        this.template = template != null ? template : FoldTemplate.DEFAULT;
    }

    /**
     * Creates an instance of FoldType.
     * The code, label and template parameters will be assigned to the FoldType's properties.
     * 
     * @param code code used to form, e.g. persistent keys for info related to the FoldType
     * @param label human-readable label that identifies the FoldType
     * @param template describes how the fold is presented
     * @return FoldType instance
     * @since 1.34
     */
    public static FoldType create(String code, String label, FoldTemplate template) {
        Parameters.notWhitespace("code", code);
        Parameters.notWhitespace("label", label);
        return new FoldType(code, label, template, null);
    }
    
    /**
     * Creates a FoldType, overriding its appearance.
     * The new FoldType will use the same code, but label and/or template can be changed.
     * 
     * @param label human-readable label that describes the FoldType
     * @param template human-readable label that describes the FoldType
     * @return an instance of FoldType initialized according to parameters
     * @since 1.34
     */
    public FoldType override(String label, FoldTemplate template) {
        return derive(code(), label, template);
    }
    
    /**
     * Derives a FoldType which acts as a child of this instance.
     * The FoldType will be treated as a special case of this instance. If A is the returned
     * instance and B is this instance, then A.isKindOf(B) will return true.
     * <p/>
     * 
     * @param code new code for the FoldType
     * @param label human-readable label that describes the FoldType
     * @param template human-readable label that describes the FoldType
     * @return an instance of child FoldType
     * @since 1.34
     */
    public FoldType derive(String code, String label, FoldTemplate template) {
        Parameters.notWhitespace("code", code);
        Parameters.notWhitespace("label", label);
        return new FoldType(code, label, template, this);
    }
    
    /**
     * @param type
     * @return
     * @deprecated Use {@link #isKindOf} 
     */
    @Deprecated
    public boolean accepts(FoldType type) {
        return isKindOf(type);
    }
    
    @Override
    public String toString() {
        return code();
    }
    
    /**
     * Provides human-readable label for the type
     * @return 
     * @since 1.34
     */
    public String getLabel() {
        return label;
    }
    
    /**
     * Provides FoldTemplate instance for this type.
     * The FoldTemplate is the default template used when creating a Fold. Specific FoldTemplate
     * may be provided when creating the Fold instance.
     * 
     * @return fold template for the type.
     */
    public FoldTemplate getTemplate() {
        return template;
    }
    
    /**
     * Checks whether the fold can act as the 'other' type.
     * This check respect parent relationship (see {@link #parent}). The method returns true,
     * if semantics, operations, settings,... applicable to 'other' could be also applied on
     * this FoldType.
     * 
     * @param other the type to check
     * @return true, if this FoldType should be affected
     * @since 1.34
     */
    public boolean isKindOf(FoldType other) {
        return other == this || parent != null && parent.isKindOf(other);
    }
    
    /**
     * Provides parent of this FoldType. Returns {@code null}, if no parent is defined.
     * The parent is a FoldType, which is more general and could be used as a fallback when no information
     * is provided/available on this FoldType instance.
     * 
     * @return parent instance or {@code null}
     * @since 1.34
     */
    public FoldType parent() {
        return parent;
    }
   
    /**
     * Persistable value of FoldType.
     * Use {@link FoldType.Domain#valueOf} to convert the value back to FoldType instance. The value
     * can (and is) used to compose preference setting keys.
     * 
     * @return value of FoldType.
     * @since 1.34
     */
    public String code() {
        return code;
    }

    /**
     * Represents a value set of {@link FoldType}s for one MIME type.
     * The instance collects all FoldTypes defined for a certain MIME type. "" mime type
     * represents 'global' FoldTypes.
     * <p/>
     * The instance will fire change events when the set of fold types change, e.g. as a result
     * of enabled/disabled modules (appearance of {@link FoldTypeProvider}).
     * @since 1.34
     */
    public interface Domain {
        /**
         * Enumerates FoldTypes. Returns empty collection, if no fold types are known.
         * @return fold types.
         */
        Collection<FoldType>    values();
        
        /**
         * Translates String code into FoldType. Returns null if the fold type is not found.
         * The String should have been obtained by a call to FoldType.code().
         * 
         * @param s code value
         * @return the FoldType instance.
         */
        FoldType                valueOf(String s);

        /**
         * Attaches listener to be notified when set of FoldTypes change.
         * 
         * @param l listener instance.
         */
        void addChangeListener(ChangeListener l);
        
        /**
         * Detaches the change listener
         * @param l listener instance.
         */
        void removeChangeListener(ChangeListener l);
    }
    
    private final String code;
    
    private final FoldType parent;

    /**
     * Display name for the fold type, for presentation in UI
     */
    private final String label;
    
    /**
     * The default fold template
     */
    private final FoldTemplate template;
}

Lines 48-53 Link Here

(-)a/editor.fold/src/org/netbeans/api/editor/fold/FoldUtilities.java (+39 lines)
48	import java.util.Collections;	48	import java.util.Collections;
49	import java.util.Iterator;	49	import java.util.Iterator;
50	import java.util.List;	50	import java.util.List;
		51	import org.netbeans.api.editor.mimelookup.MimePath;
		52	import org.netbeans.modules.editor.fold.FoldRegistry;
51	import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;	53	import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;
52		54
53	/**	55	/**
Lines 440-443 Link Here
440	return FoldUtilitiesImpl.collapsedFoldIterator(hierarchy, startOffset, endOffset);	442	return FoldUtilitiesImpl.collapsedFoldIterator(hierarchy, startOffset, endOffset);
441	}	443	}
442		444
		445	/**
		446	* Obtains available FoldType values for the specified MIME type.
		447	*
		448	* @param mimeType mime type of the content
		449	* @return available FoldTypes
		450	* @since 1.34
		451	*/
		452	public static FoldType.Domain getFoldTypes(String mimeType) {
		453	return FoldRegistry.get().getDomain(MimePath.parse(mimeType));
		454	}
		455
		456	/**
		457	* Determines whether folds of that type are should be initially collapsed.
		458	* The FoldType is evaluated in the context of a specific FoldHierarchy, that is a Component
		459	* with a content of a certain MIME type.
		460	*
		461	* @param ft FoldType to inspect
		462	* @param hierarchy context for evaluation
		463	* @return true, if folds of FoldType should be initially collapsed.
		464	* @since 1.34
		465	*/
		466	public static boolean isAutoCollapsed(FoldType ft, FoldHierarchy hierarchy) {
		467	return FoldUtilitiesImpl.isAutoCollapsed(ft, hierarchy);
		468	}
		469
		470	/**
		471	* Determines whether folding is enabled for a given MIME type.
		472	* Use {@link MimePath#EMPTY}.getMimeType() to query for the default (all languages)
		473	* setting.
		474	*
		475	* @param mimeType the MIME type of the content.
		476	* @return true, if folding is enabled, false otherwise.
		477	* @since 1.34
		478	*/
		479	public static boolean isFoldingEnabled(String mimeType) {
		480	return FoldUtilitiesImpl.isFoldingEnabled(mimeType);
		481	}
443	}	482	}




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

import java.util.Map;
import javax.swing.JComponent;
import javax.swing.text.JTextComponent;
import org.netbeans.editor.SideBarFactory;
import org.netbeans.modules.editor.fold.CustomFoldManager;
import org.netbeans.modules.editor.fold.JavadocReader;
import org.netbeans.modules.editor.fold.ui.CodeFoldingSideBar;
import org.netbeans.spi.editor.fold.ContentReader;
import org.netbeans.spi.editor.fold.FoldManager;
import org.netbeans.spi.editor.fold.FoldManagerFactory;
import org.openide.util.Parameters;

/**
 * This utility class collects APIs to create default implementations
 * of various pieces of infrastructure.
 * 
 * @author sdedic
 */
public final class FoldingSupport {
    private static SideBarFactory FACTORY = null;
    
    private FoldingSupport() {}

    /**
     * Creates a default implementation of {@link ContentReader}.
     * 
     * The default implementation is modeled to work with Javadoc-like comments. It will
     * ignore markers at line start (first non-whitespace) - 'start' parameter. If the reader
     * encounters the 'stop' regex pattern, it stops scanning and returns {@code null}. Typically
     * some tags are placed at the end of the doc comment, and they are not informative enough
     * to put them into folded preview.
     * <p/>
     * Finally, if a suitable content is found, and it contains the 'terminator' pattern,
     * the content is only returned up to (excluding) the terminator.
     * <p/>
     * Javadoc (PHPdoc) reader can be constructed as <code>defaultReader("*", "\\.", "@");</code>
     *
     * @param start character sequence, which will be ignored at the beginning of the line. Can be {@code null}
     * @param terminator pattern, which marks the end of the summary line/sentence. Can be {@code null}
     * @param stop content search stop at the 'stop' pattern. Can be {@code null}
     */
    public static ContentReader contentReader(String start, String terminator, String stop, String prefix) {
        return new JavadocReader(start, terminator, stop, prefix);
    }

    /**
     * A variant of {@link #defaultReader} usable from FS layer.
     * See {@link #defaultReader} documentation for parameter explanation. The 
     * method expects those parameters as keys in the Map (values are all Strings).
     * An additional entry (key: 'type') is required in the map, it identifies the
     * FoldType for which the reader should work.
     * 
     * @param m configuration parameters for the reader factory.
     * @see #contentReader
     */
    public static ContentReader.Factory contentReaderFactory(Map m) {
        final String start = (String) m.get("start"); // NOI18N
        final String terminator = (String) m.get("terminator"); // NOI18N
        final String stop = (String) m.get("stop"); // NOI18N
        final String foldType = (String) m.get("type"); // NOI18N
        final String prefix = (String)m.get("prefix"); // NOI18N
        return new ContentReader.Factory() {
            @Override
            public ContentReader createReader(FoldType ft) {
                if (foldType != null && foldType.equals(ft.code()) || (foldType == null && ft.isKindOf(FoldType.DOCUMENTATION))) {
                    return contentReader(start, terminator, stop, prefix);
                } else {
                    return null;
                }
            }
        };
    }

    /**
     * Creates a component for the code folding sidebar.
     * Returns a standard folding sidebar component, which displays code folds. This sidebar implementation 
     * can be created only once per text component.
     *
     * @param textComponent the text component which should work with the Sidebar
     * @return Sidebar instance.
     */
    public static JComponent sidebarComponent(JTextComponent textComponent) {
        return new CodeFoldingSideBar(textComponent);
    }

    /**
     * Creates a user-defined fold manager, that processes specific token type.
     * The manager tries to find start/end markers within the token text. If found,
     * a Fold is created. The manager only looks in tokens, whose {@code primaryCategory}
     * starts with a String, which is stored under 'tokenId' key in the params map.
     * <p/>
     * The method is designed to be called from the filesystem layer as follows:
     * <code><pre>
     * &lt;file name="my-custom-foldmanager.instance">
     * &lt;attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldUtilities.createUserFoldManager"/>
     * &lt;attr name="tokenid" stringvalue="comment"/>
     * &lt;/file>
     * </pre></code>
     *
     * @param map the configuration parameters.
     * @return FoldManagerFactory instance
     */
    public static FoldManagerFactory userFoldManagerFactory(Map params) {
        final String s = (String) params.get("tokenId");
        return new FoldManagerFactory() {
            @Override
            public FoldManager createFoldManager() {
                return userFoldManager(s);
            }
        };
    }
    
    /**
     * Creates a user-defined fold manager, that processes specific token type.
     * The manager tries to find start/end markers within the token text. If found,
     * a Fold is created. The manager only looks in tokens, whose {@code primaryCategory}
     * starts with tokenId string.
     * <p/>
     * {@code Null} value of 'tokenId' means the default "comment" will be used.
     *
     * @param tokenId filter for prefix of the token's primaryCategory.
     * @return FoldManager instance
     */
    public static FoldManager userFoldManager(String tokenId) {
        if (tokenId != null) {
            return new CustomFoldManager(tokenId);
        } else {
            return new CustomFoldManager();
        }
    }

    /**
     * Obtains an instance of folding sidebar factory. This method should
     * be used in layer, in the MIME lookup area, to register a sidebar with
     * an editor for a specific MIMEtype.
     * <p/>
     * There's a default sidebar instance registered for all MIME types. 
     *
     * @return shared sidebar factory instance
     */
    public static SideBarFactory foldingSidebarFactory() {
        if (FACTORY != null) {
            return FACTORY;
        }
        return FACTORY = new CodeFoldingSideBar.Factory();
    }

    public static void disableCodeFoldingSidebar(JTextComponent text) {
        text.putClientProperty(CodeFoldingSideBar.PROP_SIDEBAR_MARK, true);
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 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.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.accessibility.AccessibleRole;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
import org.netbeans.modules.editor.lib2.view.LockedViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ParagraphViewDescriptor;
import org.netbeans.modules.editor.lib2.view.ViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyEvent;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyListener;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;

/**
 *  Code Folding Side Bar. Component responsible for drawing folding signs and responding 
 *  on user fold/unfold action.
 *
 *  @author  Martin Roskanin
 *  @deprecated You should use {@link FoldUtilities#createSidebarComponent(javax.swing.text.JTextComponent)} or
 *  {@link FoldUtilities#getFoldingSidebarFactory()} instead. Subclassing CodeFoldingSidebar
 *  is no longer actively supported, though still working.
 */
@Deprecated
public class CodeFoldingSideBar extends JComponent implements Accessible {

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

    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color backColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color foreColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Font font;
    
    /** This field should be treated as final. Subclasses are forbidden to change it. */
    protected /*final*/ JTextComponent component;
    private volatile AttributeSet attribs;
    private Lookup.Result<? extends FontColorSettings> fcsLookupResult;
    private final LookupListener fcsTracker = new LookupListener() {
        public void resultChanged(LookupEvent ev) {
            attribs = null;
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    //EMI: This is needed as maybe the DEFAULT_COLORING is changed, the font is different
                    // and while getMarkSize() is used in paint() and will make the artifacts bigger,
                    // the component itself will be the same size and it must be changed.
                    // See http://www.netbeans.org/issues/show_bug.cgi?id=153316
                    updatePreferredSize();
                    CodeFoldingSideBar.this.repaint();
                }
            });
        }
    };
    private final Listener listener = new Listener();
    
    private boolean enabled = false;
    
    protected List<Mark> visibleMarks = new ArrayList<Mark>();
    
    /**
     * Mouse moved point, possibly {@code null}. Set from mouse-moved, mouse-entered
     * handlers, so that painting will paint this fold in bold. -1, if mouse is not
     * in the sidebar region. The value is used to compute highlighted portions of the 
     * folding outline.
     */
    private int   mousePoint = -1;
    
    /**
     * if true, the {@link #mousePoint} has been already used to make a PaintInfo active.
     * The flag is tested by {@link #traverseForward} and {@link #traverseBackward} after children
     * of the current fold are processed and cleared if the {@link #mousePoint} falls to the fold area -
     * fields of PaintInfo are set accordingly.
     * It's also used to compute (current) mouseBoundary, so mouse movement does not trigger 
     * refreshes eagerly
     */
    private boolean mousePointConsumed;
    
    /**
     * Boundaries of the current area under the mouse. Can be eiher the span of the
     * current fold (or part of it), or the span not occupied by any fold. Serves as an optimization
     * for mouse handler, which does not trigger painting (refresh) unless mouse 
     * leaves this region.
     */
    private Rectangle   mouseBoundary;
    
    /**
     * Y-end of the nearest fold that ends above the {@link #mousePoint}. Undefined if mousePoint is null.
     * These two variables are initialized at each level of folds, and help to compute {@link #mouseBoundary} for
     * the case the mousePointer is OUTSIDE all children (or outside all folds). 
     */
    private int lowestAboveMouse = -1;

    /**
     * Y-begin of the nearest fold, which starts below the {@link #mousePoint}. Undefined if mousePoint is null
     */
    private int topmostBelowMouse = Integer.MAX_VALUE;
    
    /** Paint operations */
    public static final int PAINT_NOOP             = 0;
    /**
     * Normal opening +- marker
     */
    public static final int PAINT_MARK             = 1;
    
    /**
     * Vertical line - typically at the end of the screen
     */
    public static final int PAINT_LINE             = 2;
    
    /**
     * End angled line, without a sign
     */
    public static final int PAINT_END_MARK         = 3;
    
    /**
     * Single-line marker, both start and end
     */
    public static final int SINGLE_PAINT_MARK      = 4;
    
    /**
     * Marker value for {@link #mousePoint} indicating that mouse is outside the Component.
     */
    private static final int NO_MOUSE_POINT = -1;
    
    /**
     * Stroke used to draw inactive (regular) fold outlines.
     */
    private static Stroke LINE_DASHED = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 
            1f, new float[] { 1f, 1f }, 0f);
    
    private boolean alreadyPresent;
    
    /**
     * Stroke used to draw outlines for 'active' fold
     */
    private static final Stroke LINE_BOLD = new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);
    
    private final Preferences prefs;
    private final PreferenceChangeListener prefsListener = new PreferenceChangeListener() {
        public void preferenceChange(PreferenceChangeEvent evt) {
            String key = evt == null ? null : evt.getKey();
            if (key == null || SimpleValueNames.CODE_FOLDING_ENABLE.equals(key)) {
                updateColors();
                
                boolean newEnabled = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, EditorPreferencesDefaults.defaultCodeFoldingEnable);
                if (enabled != newEnabled) {
                    enabled = newEnabled;
                    updatePreferredSize();
                }
            }
        }
    };
    
    private void checkRepaint(ViewHierarchyEvent vhe) {
        if (!vhe.isChangeY()) {
            // does not obscur sidebar graphics
            return;
        }
        
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updatePreferredSize();
                CodeFoldingSideBar.this.repaint();
            }
        });
    }
    
    /**
     * @deprecated Don't use this constructor, it does nothing!
     */
    public CodeFoldingSideBar() {
        component = null;
        prefs = null;
        throw new IllegalStateException("Do not use this constructor!"); //NOI18N
    }

    public CodeFoldingSideBar(JTextComponent component){
        super();
        this.component = component;

        if (component.getClientProperty("org.netbeans.editor.CodeFoldingSidebar") == null) {
            component.putClientProperty("org.netbeans.editor.CodeFoldingSidebar", Boolean.TRUE);
        } else {
            alreadyPresent = true;
        }

        addMouseListener(listener);
        addMouseMotionListener(listener);

        FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
        foldHierarchy.addFoldHierarchyListener(WeakListeners.create(FoldHierarchyListener.class, listener, foldHierarchy));

        Document doc = getDocument();
        doc.addDocumentListener(WeakListeners.document(listener, doc));
        setOpaque(true);
        
        prefs = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component)).lookup(Preferences.class);
        prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, prefsListener, prefs));
        prefsListener.preferenceChange(null);
        
        ViewHierarchy.get(component).addViewHierarchyListener(new ViewHierarchyListener() {

            @Override
            public void viewHierarchyChanged(ViewHierarchyEvent evt) {
                checkRepaint(evt);
            }
            
        });
    }
    
    private void updatePreferredSize() {
        if (enabled && !alreadyPresent) {
            setPreferredSize(new Dimension(getColoring().getFont().getSize(), component.getHeight()));
            setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
        }else{
            setPreferredSize(new Dimension(0,0));
            setMaximumSize(new Dimension(0,0));
        }
        revalidate();
    }

    private void updateColors() {
        Coloring c = getColoring();
        this.backColor = c.getBackColor();
        this.foreColor = c.getForeColor();
        this.font = c.getFont();
    }

    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The background color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getBackColor() {
        if (backColor == null) {
            updateColors();
        }
        return backColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The foreground color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getForeColor() {
        if (foreColor == null) {
            updateColors();
        }
        return foreColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The font used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Font getColoringFont() {
        if (font == null) {
            updateColors();
        }
        return font;
    }
    
    // overriding due to issue #60304
    public @Override void update(Graphics g) {
    }
    
    protected void collectPaintInfos(
        View rootView, Fold fold, Map<Integer, PaintInfo> map, int level, int startIndex, int endIndex
    ) throws BadLocationException {
        //never called
    }

    /**
     * Adjust lowest/topmost boundaries from the Fold range y1-y2.
     * @param y1
     * @param y2
     * @param level 
     */
    private void setMouseBoundaries(int y1, int y2, int level) {
        if (!hasMousePoint() || mousePointConsumed) {
            return;
        }
        int y = mousePoint;
        if (y2 < y && lowestAboveMouse < y2) {
            LOG.log(Level.FINEST, "lowestAbove at {1}: {0}", new Object[] { y2, level });
            lowestAboveMouse = y2;
        }
        if (y1 > y && topmostBelowMouse > y1) {
            LOG.log(Level.FINEST, "topmostBelow at {1}: {0}", new Object[] { y1, level });
            topmostBelowMouse = y1;
        }
    }
    
    /*
     * Even collapsed fold MAY contain a continuation line, IF one of folds on the same line is NOT collapsed. Such a fold should
     * then visually span multiple lines && be marked as collapsed.
     */

    protected List<? extends PaintInfo> getPaintInfo(Rectangle clip) throws BadLocationException {
        javax.swing.plaf.TextUI textUI = component.getUI();
        if (!(textUI instanceof BaseTextUI)) {
            return Collections.<PaintInfo>emptyList();
        }
        BaseTextUI baseTextUI = (BaseTextUI)textUI;
        BaseDocument bdoc = Utilities.getDocument(component);
        if (bdoc == null) {
            return Collections.<PaintInfo>emptyList();
        }
        mousePointConsumed = false;
        mouseBoundary = null;
        topmostBelowMouse = Integer.MAX_VALUE;
        lowestAboveMouse = -1;
        bdoc.readLock();
        try {
            int startPos = baseTextUI.getPosFromY(clip.y);
            int endPos = baseTextUI.viewToModel(component, Short.MAX_VALUE / 2, clip.y + clip.height);
            
            if (startPos < 0 || endPos < 0) {
                // editor window is not properly sized yet; return no infos
                return Collections.<PaintInfo>emptyList();
            }
            
            // #218282: if the view hierarchy is not yet updated, the Y coordinate may map to an incorrect offset outside
            // the document.
            int docLen = bdoc.getLength();
            if (startPos >= docLen || endPos > docLen) {
                return Collections.<PaintInfo>emptyList();
            }
            
            startPos = Utilities.getRowStart(bdoc, startPos);
            endPos = Utilities.getRowEnd(bdoc, endPos);
            
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                View rootView = Utilities.getDocumentView(component);
                if (rootView != null) {
                    Object [] arr = getFoldList(hierarchy.getRootFold(), startPos, endPos);
                    @SuppressWarnings("unchecked")
                    List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                    int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                    /*
                     * Note:
                     * 
                     * The Map is keyed by Y-VISUAL position of the fold mark, not the textual offset of line start.
                     * This is because several folds may occupy the same line, while only one + sign is displayed,
                     * and affect the last fold in the row.
                     */
                    NavigableMap<Integer, PaintInfo> map = new TreeMap<Integer, PaintInfo>();
                    // search backwards
                    for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                        Fold fold = foldList.get(i);
                        if (!traverseBackwards(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }

                    // search forward
                    for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                        Fold fold = foldList.get(i);
                        if (!traverseForward(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }
                    
                    if (map.isEmpty() && foldList.size() > 0) {
                        assert foldList.size() == 1;
                        PaintInfo pi = new PaintInfo(PAINT_LINE, 0, clip.y, clip.height, -1, -1);
                        mouseBoundary = new Rectangle(0, 0, 0, clip.height);
                        LOG.log(Level.FINEST, "Mouse boundary for full side line set to: {0}", mouseBoundary);
                        if (hasMousePoint()) {
                            pi.markActive(true, true, true);
                        }
                        return Collections.singletonList(pi);
                    } else {
                        if (mouseBoundary == null) {
                            mouseBoundary = makeMouseBoundary(clip.y, clip.y + clip.height);
                            LOG.log(Level.FINEST, "Mouse boundary not set, defaulting to: {0}", mouseBoundary);
                        }
                        return new ArrayList<PaintInfo>(map.values());
                    }
                } else {
                    return Collections.<PaintInfo>emptyList();
                }
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }
    }
    
    /**
     * Adds a paint info to the map. If a paintinfo already exists, it merges
     * the structures, so the painting process can just follow the instructions.
     * 
     * @param infos
     * @param yOffset
     * @param nextInfo 
     */
    private void addPaintInfo(Map<Integer, PaintInfo> infos, int yOffset, PaintInfo nextInfo) {
        PaintInfo prevInfo = infos.get(yOffset);
        nextInfo.mergeWith(prevInfo);
        infos.put(yOffset, nextInfo);
    }

    private boolean traverseForward(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary,int level,  NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseForward<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getStartOffset() > upperBoundary ? ", f.gSO > uB" : "")
//                + ", level=" + level);
        
        if (f.getStartOffset() > upperBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int y1 = btui.getYFromPos(lineStartOffset1);
        int h = btui.getEditorUI().getLineHeight();
        int y2 = btui.getYFromPos(lineStartOffset2);
         
        // the 'active' flags can be set only after children are processed; highlights
        // correspond to the innermost expanded child.
        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi;
        boolean activated;
        
        if (y1 == y2) {
            // whole fold is on a single line
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            // fold spans multiple lines
            spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y2 + h / 2)) {
                activeMark = true;
                activeOut = true;
            }
            addPaintInfo(infos, y1, spi);
        }

        setMouseBoundaries(y1, y2 + h / 2, level);

        // Handle end mark after possible inner folds were processed because
        // otherwise if there would be two nested folds both ending at the same line
        // then the end mark for outer one would be replaced by an end mark for inner one
        // (same key in infos map) and the painting code would continue to paint line marking a fold
        // until next fold is reached (or end of doc).
        PaintInfo epi = null;
        if (y1 != y2 && !f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
            epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
            addPaintInfo(infos, y2, epi);
        }

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h / 2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                spi.markActive(activeMark, activeIn, activeOut);
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                markDeepChildrenActive(infos, y1, y2, level);
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
     
    /**
     * Sets outlines of all children to 'active'. Assuming yFrom and yTo are from-to Y-coordinates of the parent
     * fold, it finds all nested folds (folds, which are in between yFrom and yTo) and changes their in/out lines
     * as active.
     * The method returns Y start coordinate of the 1st child found.
     * 
     * @param infos fold infos collected so far
     * @param yFrom upper Y-coordinate of the parent fold
     * @param yTo lower Y-coordinate of the parent fold
     * @param level level of the parent fold
     * @return Y-coordinate of the 1st child.
     */
    private int markDeepChildrenActive(NavigableMap<Integer, PaintInfo> infos, int yFrom, int yTo, int level) {
        int result = Integer.MAX_VALUE;
        Map<Integer, PaintInfo> m = infos.subMap(yFrom, yTo);
        for (Map.Entry<Integer, PaintInfo> me : m.entrySet()) {
            PaintInfo pi = me.getValue();
            int y = pi.getPaintY();
            if (y > yFrom && y < yTo) {
                if (LOG.isLoggable(Level.FINEST)) {
                    LOG.log(Level.FINEST, "Marking chind as active: {0}", pi);
                }
                pi.markActive(false, true, true);
                if (y < result) {
                    y = result;
                }
            }
        }
        return result;
    }
    
    /**
     * Returns stroke appropriate for painting (in)active outlines
     * @param s the default stroke
     * @param active true for active outlines
     * @return value of 's' or a Stroke which should be used to paint the outline.
     */
    private static Stroke getStroke(Stroke s, boolean active) {
        if (active) {
            return LINE_BOLD;
        } else {
            return s;
        }
    }
    
    private boolean traverseBackwards(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary, int level, NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseBackwards<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getEndOffset() < lowerBoundary ? ", f.gEO < lB" : "")
//                + ", level=" + level);

        if (f.getEndOffset() < lowerBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int h = btui.getEditorUI().getLineHeight();

        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi = null;
        PaintInfo epi = null;
        boolean activated = false;
        int y1 = 0;
        int y2 = 0;
        
        if (lineStartOffset1 == lineStartOffset2) {
            // whole fold is on a single line
            y2 = y1 = btui.getYFromPos(lineStartOffset1);
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset1);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            y2 = btui.getYFromPos(lineStartOffset2);
            // fold spans multiple lines
            y1 = btui.getYFromPos(lineStartOffset1);
            activated = isActivated(y1, y2 + h / 2);
            if (f.getStartOffset() >= upperBoundary) {
                spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
                if (activated) {
                    activeMark = true;
                    activeOut = true;
                }
                addPaintInfo(infos, y1, spi);
            }

            if (!f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
                activated |= isActivated(y1, y2 + h / 2);
                epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
                addPaintInfo(infos, y2, epi);
            }
        }
        
        setMouseBoundaries(y1, y2 + h / 2, level);

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h /2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                if (spi != null) {
                    spi.markActive(activeMark, activeIn, activeOut);
                }
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                int lowestChild = markDeepChildrenActive(infos, y1, y2, level);
                if (lowestChild < Integer.MAX_VALUE && lineStartOffset1 < upperBoundary) {
                    // the fold starts above the screen clip region, and is 'activated'. We need to setup instructions to draw activated line up to the
                    // 1st child marker.
                    epi = new PaintInfo(PAINT_LINE, level, y1, y2 - y1, false, lineStartOffset1, lineStartOffset2);
                    epi.markActive(true, true, false);
                    addPaintInfo(infos, y1, epi);
                }
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
    
    private Rectangle makeMouseBoundary(int y1, int y2) {
        if (!hasMousePoint()) {
            return null;
        }
        if (topmostBelowMouse < Integer.MAX_VALUE) {
            y2 = topmostBelowMouse;
        }
        if (lowestAboveMouse  > -1) {
            y1 = lowestAboveMouse;
        }
        return new Rectangle(0, y1, 0, y2 - y1);
    }
    
    protected EditorUI getEditorUI(){
        return Utilities.getEditorUI(component);
    }
    
    protected Document getDocument(){
        return component.getDocument();
    }


    private Fold getLastLineFold(FoldHierarchy hierarchy, int rowStart, int rowEnd, boolean shift){
        Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
        Fold prevFold = fold;
        while (fold != null && fold.getStartOffset()<rowEnd){
            Fold nextFold = FoldUtilities.findNearestFold(hierarchy, (fold.isCollapsed()) ? fold.getEndOffset() : fold.getStartOffset()+1);
            if (nextFold == fold) return fold;
            if (nextFold!=null && nextFold.getStartOffset() < rowEnd){
                prevFold = shift ? fold : nextFold;
                fold = nextFold;
            }else{
                return prevFold;
            }
        }
        return prevFold;
    }
    
    protected void performAction(Mark mark) {
        performAction(mark, false);
    }
    
    private void performActionAt(Mark mark, int mouseY) throws BadLocationException {
        if (mark != null) {
            return;
        }
        BaseDocument bdoc = Utilities.getDocument(component);
        BaseTextUI textUI = (BaseTextUI)component.getUI();

        View rootView = Utilities.getDocumentView(component);
        if (rootView == null) return;
        
        bdoc.readLock();
        try {
            int yOffset = textUI.getPosFromY(mouseY);
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                Fold f = FoldUtilities.findOffsetFold(hierarchy, yOffset);
                if (f == null) {
                    return;
                }
                if (f.isCollapsed()) {
                    LOG.log(Level.WARNING, "Clicked on a collapsed fold {0} at {1}", new Object[] { f, mouseY });
                    return;
                }
                int startOffset = f.getStartOffset();
                int endOffset = f.getEndOffset();
                
                int startY = textUI.getYFromPos(startOffset);
                int nextLineOffset = Utilities.getRowStart(bdoc, startOffset, 1);
                int nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    LOG.log(Level.FINEST, "Starting line clicked, ignoring. MouseY={0}, startY={1}, nextY={2}",
                            new Object[] { mouseY, startY, nextY });
                    return;
                }

                startY = textUI.getYFromPos(endOffset);
                nextLineOffset = Utilities.getRowStart(bdoc, endOffset, 1);
                nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    // the mouse can be positioned above the marker (the fold found above), or
                    // below it; in that case, the immediate enclosing fold should be used - should be the fold
                    // that corresponds to the nextLineOffset, if any
                    int h2 = (startY + nextY) / 2;
                    if (mouseY >= h2) {
                        Fold f2 = f;
                        
                        f = FoldUtilities.findOffsetFold(hierarchy, nextLineOffset);
                        if (f == null) {
                            // fold does not exist for the position below end-of-fold indicator
                            return;
                        }
                    }
                    
                }
                
                LOG.log(Level.FINEST, "Collapsing fold: {0}", f);
                hierarchy.collapse(f);
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }        
    }
    
    private void performAction(final Mark mark, final boolean shiftFold) {
        Document doc = component.getDocument();
        doc.render(new Runnable() {
            @Override
            public void run() {
                ViewHierarchy vh = ViewHierarchy.get(component);
                LockedViewHierarchy lockedVH = vh.lock();
                try {
                    int pViewIndex = lockedVH.yToParagraphViewIndex(mark.y + mark.size / 2);
                    if (pViewIndex >= 0) {
                        ParagraphViewDescriptor pViewDesc = lockedVH.getParagraphViewDescriptor(pViewIndex);
                        int pViewStartOffset = pViewDesc.getStartOffset();
                        int pViewEndOffset = pViewStartOffset + pViewDesc.getLength();
                        // Find corresponding fold
                        FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
                        foldHierarchy.lock();
                        try {
                            int rowStart = javax.swing.text.Utilities.getRowStart(component, pViewStartOffset);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(component, pViewStartOffset);
                            Fold clickedFold = getLastLineFold(foldHierarchy, rowStart, rowEnd, shiftFold);//FoldUtilities.findNearestFold(foldHierarchy, viewStartOffset);
                            if (clickedFold != null && clickedFold.getStartOffset() < pViewEndOffset) {
                                foldHierarchy.toggle(clickedFold);
                            }
                        } catch (BadLocationException ble) {
                            LOG.log(Level.WARNING, null, ble);
                        } finally {
                            foldHierarchy.unlock();
                        }
                    }
                } finally {
                    lockedVH.unlock();
                }
            }
        });
    }
    
    protected int getMarkSize(Graphics g){
        if (g != null){
            FontMetrics fm = g.getFontMetrics(getColoring().getFont());
            if (fm != null){
                int ret = fm.getAscent() - fm.getDescent();
                return ret - ret%2;
            }
        }
        return -1;
    }
    
    private boolean hasMousePoint() {
        return mousePoint >= 0;
    }
    
    private boolean isActivated(int y1, int y2) {
        return hasMousePoint() && 
               (mousePoint >= y1 && mousePoint < y2);
    }
    
    private void drawFoldLine(Graphics2D g2d, boolean active, int x1, int y1, int x2, int y2) {
        Stroke origStroke = g2d.getStroke();
        g2d.setStroke(getStroke(origStroke, active));
        g2d.drawLine(x1, y1, x2, y2);
        g2d.setStroke(origStroke);
    }
    
    protected @Override void paintComponent(Graphics g) {
        if (!enabled) {
            return;
        }
        
        Rectangle clip = getVisibleRect();//g.getClipBounds();
        visibleMarks.clear();
        
        Coloring coloring = getColoring();
        g.setColor(coloring.getBackColor());
        g.fillRect(clip.x, clip.y, clip.width, clip.height);
        g.setColor(coloring.getForeColor());

        AbstractDocument adoc = (AbstractDocument)component.getDocument();
        adoc.readLock();
        try {
            List<? extends PaintInfo> ps = getPaintInfo(clip);
            Font defFont = coloring.getFont();
            int markSize = getMarkSize(g);
            int halfMarkSize = markSize / 2;
            int markX = (defFont.getSize() - markSize) / 2; // x position of mark rectangle
            int plusGap = (int)Math.round(markSize / 3.8); // distance between mark rectangle vertical side and start/end of minus sign
            int lineX = markX + halfMarkSize; // x position of the centre of mark

            LOG.fine("CFSBar: PAINT START ------\n");
            int descent = g.getFontMetrics(defFont).getDescent();
            PaintInfo previousInfo = null;
            Graphics2D g2d = (Graphics2D)g;
            LOG.log(Level.FINEST, "MousePoint: {0}", mousePoint);

            for(PaintInfo paintInfo : ps) {
                boolean isFolded = paintInfo.isCollapsed();
                int y = paintInfo.getPaintY();
                int height = paintInfo.getPaintHeight();
                int markY = y + descent; // y position of mark rectangle
                int paintOperation = paintInfo.getPaintOperation();

                if (previousInfo == null) {
                    if (paintInfo.hasLineIn()) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("prevInfo=NULL; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, clip.y, lineX, y);
                    }
                } else {
                    if (previousInfo.hasLineOut() || paintInfo.hasLineIn()) {
                        // Draw middle vertical line
                        int prevY = previousInfo.getPaintY();
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.log(Level.FINE, "prevInfo={0}; y=" + y + ", PI:" + paintInfo + "\n", previousInfo); // NOI18N
                        }
                        drawFoldLine(g2d, previousInfo.lineOutActive || paintInfo.lineInActive, lineX, prevY + previousInfo.getPaintHeight(), lineX, y);
                    }
                }

                if (paintInfo.hasSign()) {
                    g.drawRect(markX, markY, markSize, markSize);
                    g.drawLine(plusGap + markX, markY + halfMarkSize, markSize + markX - plusGap, markY + halfMarkSize);
                    String opStr = (paintOperation == PAINT_MARK) ? "PAINT_MARK" : "SINGLE_PAINT_MARK"; // NOI18N
                    if (isFolded) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": folded; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        g.drawLine(lineX, markY + plusGap, lineX, markY + markSize - plusGap);
                    }
                    if (paintOperation != SINGLE_PAINT_MARK) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": non-single; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                    }
                    if (paintInfo.hasLineIn()) { //[PENDING]
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, markY);
                    }
                    if (paintInfo.hasLineOut()) {
                        // This is an error in case there's a next paint info at the same y which is an end mark
                        // for this mark (it must be cleared explicitly).
                        drawFoldLine(g2d, paintInfo.lineOutActive, lineX, markY + markSize, lineX, y + height);
                    }
                    visibleMarks.add(new Mark(markX, markY, markSize, isFolded));

                } else if (paintOperation == PAINT_LINE) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_LINE: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    // FIXME !!
                    drawFoldLine(g2d, paintInfo.signActive, lineX, y, lineX, y + height );
                } else if (paintOperation == PAINT_END_MARK) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_END_MARK: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    if (previousInfo == null || y != previousInfo.getPaintY()) {
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, y + height / 2);
                        drawFoldLine(g2d, paintInfo.signActive, lineX, y + height / 2, lineX + halfMarkSize, y + height / 2);
                        if (paintInfo.getInnerLevel() > 0) {//[PENDING]
                            if (LOG.isLoggable(Level.FINE)) {
                                LOG.fine("  PAINT middle-line\n"); // NOI18N
                            }
                            drawFoldLine(g2d, paintInfo.lineOutActive, lineX, y + height / 2, lineX, y + height);
                        }
                    }
                }

                previousInfo = paintInfo;
            }

            if (previousInfo != null &&
                (previousInfo.getInnerLevel() > 0 ||
                 (previousInfo.getPaintOperation() == PAINT_MARK && !previousInfo.isCollapsed()))
            ) {
                drawFoldLine(g2d, previousInfo.lineOutActive, 
                        lineX, previousInfo.getPaintY() + previousInfo.getPaintHeight(), lineX, clip.y + clip.height);
            }

        } catch (BadLocationException ble) {
            LOG.log(Level.WARNING, null, ble);
        } finally {
            LOG.fine("CFSBar: PAINT END ------\n\n");
            adoc.readUnlock();
        }
    }
    
    private static Object [] getFoldList(Fold parentFold, int start, int end) {
        List<Fold> ret = new ArrayList<Fold>();

        int index = FoldUtilities.findFoldEndIndex(parentFold, start);
        int foldCount = parentFold.getFoldCount();
        int idxOfFirstFoldStartingInside = -1;
        while (index < foldCount) {
            Fold f = parentFold.getFold(index);
            if (f.getStartOffset() <= end) {
                ret.add(f);
            } else {
                break; // no more relevant folds
            }
            if (idxOfFirstFoldStartingInside == -1 && f.getStartOffset() >= start) {
                idxOfFirstFoldStartingInside = ret.size() - 1;
            }
            index++;
        }

        return new Object [] { ret, idxOfFirstFoldStartingInside != -1 ? idxOfFirstFoldStartingInside : ret.size() };
    }

    /**
     * This class should be never used by other code; will be made private
     */
    public class PaintInfo {
        
        int paintOperation;
        /**
         * level of the 1st marker on the line
         */
        int innerLevel;
        
        /**
         * Y-coordinate of the cell
         */
        int paintY;
        
        /**
         * Height of the paint cell
         */
        int paintHeight;
        
        /**
         * State of the marker (+/-)
         */
        boolean isCollapsed;
        
        /**
         * all markers on the line are collapsed
         */
        boolean allCollapsed;
        int startOffset;
        int endOffset;
        /**
         * nesting level of the last marker on the line
         */
        int outgoingLevel;
        
        /**
         * Force incoming line (from above) to be present
         */
        boolean lineIn;
        
        /**
         * Force outgoing line (down from marker) to be present
         */
        boolean lineOut;
        
        /**
         * The 'incoming' (upper) line should be painted as active
         */
        boolean lineInActive;
        
        /**
         * The 'outgoing' (down) line should be painted as active
         */
        boolean lineOutActive;
        
        /**
         * The sign/marker itself should be painted as active
         */
        boolean signActive;
        
        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, boolean isCollapsed, int startOffset, int endOffset){
            this.paintOperation = paintOperation;
            this.innerLevel = this.outgoingLevel = innerLevel;
            this.paintY = paintY;
            this.paintHeight = paintHeight;
            this.isCollapsed = this.allCollapsed = isCollapsed;
            this.startOffset = startOffset;
            this.endOffset = endOffset;

            switch (paintOperation) {
                case PAINT_MARK:
                    lineIn = false;
                    lineOut = true;
                    outgoingLevel++;
                    break;
                case SINGLE_PAINT_MARK:
                    lineIn = false;
                    lineOut = false;
                    break;
                case PAINT_END_MARK:
                    lineIn = true;
                    lineOut = false;
                    isCollapsed = true;
                    allCollapsed = true;
                    break;
                case PAINT_LINE:
                    lineIn = lineOut = true;
                    break;
            }
        }
        
        /**
         * Sets active flags on inidivual parts of the mark
         * @param mark
         * @param lineIn
         * @param lineOut S
         */
        void markActive(boolean mark, boolean lineIn, boolean lineOut) {
            this.signActive |= mark;
            this.lineInActive |= lineIn;
            this.lineOutActive |= lineOut;
        }
        
        boolean hasLineIn() {
            return lineIn || innerLevel > 0;
        }
        
        boolean hasLineOut() {
            return lineOut || outgoingLevel > 0 || (paintOperation != SINGLE_PAINT_MARK && !isAllCollapsed());
        }

        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, int startOffset, int endOffset){
            this(paintOperation, innerLevel, paintY, paintHeight, false, startOffset, endOffset);
        }
        
        public int getPaintOperation(){
            return paintOperation;
        }
        
        public int getInnerLevel(){
            return innerLevel;
        }
        
        public int getPaintY(){
            return paintY;
        }
        
        public int getPaintHeight(){
            return paintHeight;
        }
        
        public boolean isCollapsed(){
            return isCollapsed;
        }
        
         boolean isAllCollapsed() {
            return allCollapsed;
        }
        
        public void setPaintOperation(int paintOperation){
            this.paintOperation = paintOperation;
        }
        
        public void setInnerLevel(int innerLevel){
            this.innerLevel = innerLevel;
        }
        
        public @Override String toString(){
            StringBuffer sb = new StringBuffer("");
            if (paintOperation == PAINT_MARK){
                sb.append("PAINT_MARK"); // NOI18N
            }else if (paintOperation == PAINT_LINE){
                sb.append("PAINT_LINE"); // NOI18N
            }else if (paintOperation == PAINT_END_MARK) {
                sb.append("PAINT_END_MARK"); // NOI18N
            }else if (paintOperation == SINGLE_PAINT_MARK) {
                sb.append("SINGLE_PAINT_MARK");
            }
            sb.append(",L:").append(innerLevel).append("/").append(outgoingLevel); // NOI18N
            sb.append(',').append(isCollapsed ? "C" : "E"); // NOI18N
            sb.append(", start=").append(startOffset).append(", end=").append(endOffset);
            sb.append(", lineIn=").append(lineIn).append(", lineOut=").append(lineOut);
            return sb.toString();
        }
        
        boolean hasSign() {
            return paintOperation == PAINT_MARK || paintOperation == SINGLE_PAINT_MARK;
        }
        
        
        void mergeWith(PaintInfo prevInfo) {
            if (prevInfo == null) {
                return;
            }

            int operation = this.paintOperation;
            boolean lineIn = prevInfo.lineIn;
            boolean lineOut = prevInfo.lineOut;
            
            LOG.log(Level.FINE, "Merging {0} with {1}: ", new Object[] { this, prevInfo });
            if (prevInfo.getPaintOperation() == PAINT_END_MARK) {
                // merge with start|single -> start mark + line-in
                lineIn = true;
            } else {
                operation = PAINT_MARK;
            }

            int level1 = Math.min(prevInfo.innerLevel, innerLevel);
            int level2 = prevInfo.outgoingLevel;

            if (getPaintOperation() == PAINT_END_MARK 
                && innerLevel == prevInfo.outgoingLevel) {
                // if merging end marker at the last level, update to the new outgoing level
                level2 = outgoingLevel;
            } else if (!isCollapsed) {
                level2 = Math.max(prevInfo.outgoingLevel, outgoingLevel);
            }

            if (prevInfo.getInnerLevel() < getInnerLevel()) {
                int paintFrom = Math.min(prevInfo.paintY, paintY);
                int paintTo = Math.max(prevInfo.paintY + prevInfo.paintHeight, paintY + paintHeight);
                // at least one collapsed -> paint plus sign
                boolean collapsed = prevInfo.isCollapsed() || isCollapsed();
                int offsetFrom = Math.min(prevInfo.startOffset, startOffset);
                int offsetTo = Math.max(prevInfo.endOffset, endOffset);
                
                this.paintY = paintFrom;
                this.paintHeight = paintTo - paintFrom;
                this.isCollapsed = collapsed;
                this.startOffset = offsetFrom;
                this.endOffset = offsetTo;
            }
            this.paintOperation = operation;
            this.allCollapsed = prevInfo.allCollapsed && allCollapsed;
            this.innerLevel = level1;
            this.outgoingLevel = level2;
            this.lineIn |= lineIn;
            this.lineOut |= lineOut;
            
            this.signActive |= prevInfo.signActive;
            this.lineInActive |= prevInfo.lineInActive;
            this.lineOutActive |= prevInfo.lineOutActive;
            
            LOG.log(Level.FINE, "Merged result: {0}", this);
        }
    }
    
    /** Keeps info of visible folding mark */
    public class Mark{
        public int x;
        public int y;
        public int size;
        public boolean isFolded;
        
        public Mark(int x, int y, int size, boolean isFolded){
            this.x = x;
            this.y = y;
            this.size = size;
            this.isFolded = isFolded;
        }
    }
    
    private final class Listener extends MouseAdapter implements FoldHierarchyListener, DocumentListener, Runnable {
    
        public Listener(){
        }

        // --------------------------------------------------------------------
        // FoldHierarchyListener implementation
        // --------------------------------------------------------------------

        public void foldHierarchyChanged(FoldHierarchyEvent evt) {
            refresh();
        }

        // --------------------------------------------------------------------
        // DocumentListener implementation
        // --------------------------------------------------------------------

        public void insertUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines inserted
                refresh();
            }
        }

        public void removeUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines removed
                refresh();
            }
        }

        public void changedUpdate(DocumentEvent evt) {
        }

        // --------------------------------------------------------------------
        // MouseListener implementation
        // --------------------------------------------------------------------

        @Override
        public void mousePressed (MouseEvent e) {
            Mark mark = getClickedMark(e);
            if (mark!=null){
                e.consume();
                performAction(mark, (e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) > 0);
            }
        }

        @Override
        public void mouseClicked(MouseEvent e) {
            // #102288 - missing event consuming caused quick doubleclicks to break
            // fold expanding/collapsing and move caret to the particular line
            if (e.getClickCount() > 1) {
                LOG.log(Level.FINEST, "Mouse {0}click at {1}", new Object[] { e.getClickCount(), e.getY()});
                Mark mark = getClickedMark(e);
                try {
                    performActionAt(mark, e.getY());
                } catch (BadLocationException ex) {
                    LOG.log(Level.WARNING, "Error during fold expansion using sideline", ex);
                }
            } else {
                e.consume();
            }
        }

        private void refreshIfMouseOutside(Point pt) {
            mousePoint = (int)pt.getY();
            if (LOG.isLoggable(Level.FINEST)) {
                if (mouseBoundary == null) {
                    LOG.log(Level.FINEST, "Mouse boundary not set, refreshing: {0}", mousePoint);
                } else {
                    LOG.log(Level.FINEST, "Mouse {0} inside known mouse boundary: {1}-{2}", 
                            new Object[] { mousePoint, mouseBoundary.y, mouseBoundary.getMaxY() });
                }
            }
            if (mouseBoundary == null || mousePoint < mouseBoundary.y || mousePoint > mouseBoundary.getMaxY()) {
                refresh();
            }
        }
        
        @Override
        public void mouseMoved(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseEntered(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseExited(MouseEvent e) {
            mousePoint = NO_MOUSE_POINT;
            refresh();
        }
        

        // --------------------------------------------------------------------
        // private implementation
        // --------------------------------------------------------------------

        private Mark getClickedMark(MouseEvent e){
            if (e == null || !SwingUtilities.isLeftMouseButton(e)) {
                return null;
            }
            
            int x = e.getX();
            int y = e.getY();
            for (Mark mark : visibleMarks) {
                if (x >= mark.x && x <= (mark.x + mark.size) && y >= mark.y && y <= (mark.y + mark.size)) {
                    return mark;
                }
            }
            return null;
        }

        private void refresh() {
            SwingUtilities.invokeLater(this);
        }

        @Override
        public void run() {
            repaint();
        }
    } // End of Listener class
    
    @Override
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJComponent() {
                public @Override AccessibleRole getAccessibleRole() {
                    return AccessibleRole.PANEL;
                }
            };
            accessibleContext.setAccessibleName(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSN_CodeFoldingSideBar")); //NOI18N
        accessibleContext.setAccessibleDescription(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSD_CodeFoldingSideBar")); //NOI18N
        }
        return accessibleContext;
    }

    private Coloring getColoring() {
        if (attribs == null) {
            if (fcsLookupResult == null) {
                fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component))
                        .lookupResult(FontColorSettings.class);
                fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
            }
            
            FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
            AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_BAR_COLORING);
            if (attr == null) {
                attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
            } else {
                attr = AttributesUtilities.createComposite(attr, fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
            }
            attribs = attr;
        }        
        return Coloring.fromAttributeSet(attribs);
    }
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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 org.netbeans.modules.editor.fold.*;
import javax.swing.text.Document;
import javax.swing.text.BadLocationException;
import javax.swing.text.Position;
import javax.swing.event.DocumentEvent;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenHierarchy;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;
import org.netbeans.spi.editor.fold.FoldManager;
import org.netbeans.spi.editor.fold.FoldManagerFactory;
import org.netbeans.spi.editor.fold.FoldOperation;
import org.openide.util.Parameters;
import org.openide.util.RequestProcessor;

/**
 * Fold maintainer that creates and updates custom folds.
 *
 * @author Dusan Balek, Miloslav Metelka
 * @version 1.00
 * @deprecated Please use {@link org.netbeans.api.editor.fold.FoldingSupport#userFoldManager} to create an instance of
 * the fold manager, or {@link org.netbeans.api.editor.fold.FoldingSupport#userFoldManagerFactory} to register factory
 * instance in a layer.
 */
@Deprecated
public final class CustomFoldManager implements FoldManager, Runnable {
    
    private static final Logger LOG = Logger.getLogger(CustomFoldManager.class.getName());
    
    public static final FoldType CUSTOM_FOLD_TYPE = new FoldType("custom-fold"); // NOI18N

    private FoldOperation operation;
    private Document doc;
    private org.netbeans.editor.GapObjectArray markArray = new org.netbeans.editor.GapObjectArray();
    private int minUpdateMarkOffset = Integer.MAX_VALUE;
    private int maxUpdateMarkOffset = -1;
    private List removedFoldList;
    private HashMap customFoldId = new HashMap();

    private static final RequestProcessor RP = new RequestProcessor(CustomFoldManager.class.getName(),
            1, false, false);
    private final RequestProcessor.Task task = RP.create(this);
    
    private final String tokenId;
    
    public CustomFoldManager() {
        this.tokenId = "comment";
    }

    public void init(FoldOperation operation) {
        this.operation = operation;
        if (LOG.isLoggable(Level.FINE)) {
            LOG.log(Level.FINE, "Initialized: {0}", System.identityHashCode(this));
        }
    }
    
    private FoldOperation getOperation() {
        return operation;
    }

    public void initFolds(FoldHierarchyTransaction transaction) {
        doc = getOperation().getHierarchy().getComponent().getDocument();
        task.schedule(300);
    }

    public void insertUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        processRemovedFolds(transaction);
        task.schedule(300);
    }

    public void removeUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        processRemovedFolds(transaction);
        removeAffectedMarks(evt, transaction);
        task.schedule(300);
    }
    
    public void changedUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
    }
    
    public void removeEmptyNotify(Fold emptyFold) {
        removeFoldNotify(emptyFold);
    }
    
    public void removeDamagedNotify(Fold damagedFold) {
        removeFoldNotify(damagedFold);
    }
    
    public void expandNotify(Fold expandedFold) {
        
    }

    public void release() {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.log(Level.FINE, "Released: {0}", System.identityHashCode(this));
        }
    }

    public void run() {
        if (operation.isReleased()) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.log(Level.FINE, "Update skipped, already relaesed: {0}", System.identityHashCode(this));
            }
            return;
        }
        ((BaseDocument) doc).readLock();
        try {
            TokenHierarchy th = TokenHierarchy.get(doc);
            if (th != null && th.isActive()) {
                FoldHierarchy hierarchy = getOperation().getHierarchy();
                hierarchy.lock();
                try {
                    if (operation.isReleased()) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.log(Level.FINE, "Update skipped, already relaesed: {0}", System.identityHashCode(this));
                        }
                        return;
                    }
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.log(Level.FINE, "Updating: {0}", System.identityHashCode(this));
                    }
                    FoldHierarchyTransaction transaction = getOperation().openTransaction();
                    try {
                        updateFolds(th.tokenSequence(), transaction);
                    } finally {
                        transaction.commit();
                    }
                } finally {
                    hierarchy.unlock();
                }
            }
        } finally {
            ((BaseDocument) doc).readUnlock();
        }
    }
    
    private void removeFoldNotify(Fold removedFold) {
        if (removedFoldList == null) {
            removedFoldList = new ArrayList(3);
        }
        removedFoldList.add(removedFold);
    }
    
    private void removeAffectedMarks(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        int removeOffset = evt.getOffset();
        int markIndex = findMarkIndex(removeOffset);
        if (markIndex < getMarkCount()) {
            FoldMarkInfo mark;
            while (markIndex >= 0 && (mark = getMark(markIndex)).getOffset() == removeOffset) {
                mark.release(false, transaction);
                removeMark(markIndex);
                markIndex--;
            }
        }
    }
    
    private void processRemovedFolds(FoldHierarchyTransaction transaction) {
        if (removedFoldList != null) {
            for (int i = removedFoldList.size() - 1; i >= 0; i--) {
                Fold removedFold = (Fold)removedFoldList.get(i);
                FoldMarkInfo startMark = (FoldMarkInfo)getOperation().getExtraInfo(removedFold);
                if (startMark.getId() != null)
                    customFoldId.put(startMark.getId(), Boolean.valueOf(removedFold.isCollapsed())); // remember the last fold's state before remove
                FoldMarkInfo endMark = startMark.getPairMark(); // get prior releasing
                if (getOperation().isStartDamaged(removedFold)) { // start mark area was damaged
                    startMark.release(true, transaction); // forced remove
                }
                if (getOperation().isEndDamaged(removedFold)) {
                    endMark.release(true, transaction);
                }
            }
        }
        removedFoldList = null;
    }

    private void markUpdate(FoldMarkInfo mark) {
        markUpdate(mark.getOffset());
    }
    
    private void markUpdate(int offset) {
        if (offset < minUpdateMarkOffset) {
            minUpdateMarkOffset = offset;
        }
        if (offset > maxUpdateMarkOffset) {
            maxUpdateMarkOffset = offset;
        }
    }
    
    private FoldMarkInfo getMark(int index) {
        return (FoldMarkInfo)markArray.getItem(index);
    }
    
    private int getMarkCount() {
        return markArray.getItemCount();
    }
    
    private void removeMark(int index) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Removing mark from ind=" + index + ": " + getMark(index)); // NOI18N
        }
        markArray.remove(index, 1);
    }
    
    private void insertMark(int index, FoldMarkInfo mark) {
        markArray.insertItem(index, mark);
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Inserted mark at ind=" + index + ": " + mark); // NOI18N
        }
    }

    private int findMarkIndex(int offset) {
        int markCount = getMarkCount();
        int low = 0;
        int high = markCount - 1;
        
        while (low <= high) {
            int mid = (low + high) / 2;
            int midMarkOffset = getMark(mid).getOffset();
            
            if (midMarkOffset < offset) {
                low = mid + 1;
            } else if (midMarkOffset > offset) {
                high = mid - 1;
            } else {
                // mark starting exactly at the given offset found
                // If multiple -> find the one with highest index
                mid++;
                while (mid < markCount && getMark(mid).getOffset() == offset) {
                    mid++;
                }
                mid--;
                return mid;
            }
        }
        return low; // return higher index (e.g. for insert)
    }
    
    private List<FoldMarkInfo> getMarkList(TokenSequence seq) {
        List<FoldMarkInfo> markList = null;
        
        for(seq.moveStart(); seq.moveNext(); ) {
            Token token = seq.token();
            FoldMarkInfo info;
            try {
                info = scanToken(token);
            } catch (BadLocationException e) {
                LOG.log(Level.WARNING, null, e);
                info = null;
            }

            if (info != null) {
                if (markList == null) {
                    markList = new ArrayList<FoldMarkInfo>();
                }
                markList.add(info);
            }
        }

        return markList;
    }
    
    private void processTokenList(TokenSequence seq, FoldHierarchyTransaction transaction) {
        List<FoldMarkInfo> markList = getMarkList(seq);
        int markListSize;
        if (markList != null && ((markListSize = markList.size()) > 0)) {
            // Find the index for insertion
            int offset = ((FoldMarkInfo)markList.get(0)).getOffset();
            int arrayMarkIndex = findMarkIndex(offset);
            // Remember the corresponding mark in the array as well
            FoldMarkInfo arrayMark;
            int arrayMarkOffset;
            if (arrayMarkIndex < getMarkCount()) {
                arrayMark = getMark(arrayMarkIndex);
                arrayMarkOffset = arrayMark.getOffset();
            } else { // at last mark
                arrayMark = null;
                arrayMarkOffset = Integer.MAX_VALUE;
            }

            for (int i = 0; i < markListSize; i++) {
                FoldMarkInfo listMark = (FoldMarkInfo)markList.get(i);
                int listMarkOffset = listMark.getOffset();
                if (i == 0 || i == markListSize - 1) {
                    // Update the update-offsets by the first and last marks in the list
                    markUpdate(listMarkOffset);
                }
                while (listMarkOffset >= arrayMarkOffset) {
                    if (listMarkOffset == arrayMarkOffset) {
                        // At the same offset - likely the same mark
                        //   -> retain the collapsed state
                        listMark.setCollapsed(arrayMark.isCollapsed());
                    }
                    if (!arrayMark.isReleased()) { // make sure that the mark is released
                        arrayMark.release(false, transaction); 
                    }
                    removeMark(arrayMarkIndex);
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Removed dup mark from ind=" + arrayMarkIndex + ": " + arrayMark); // NOI18N
                    }
                    if (arrayMarkIndex < getMarkCount()) {
                        arrayMark = getMark(arrayMarkIndex);
                        arrayMarkOffset = arrayMark.getOffset();
                    } else { // no more marks
                        arrayMark = null;
                        arrayMarkOffset = Integer.MAX_VALUE;
                    }
                }
                // Insert the listmark
                insertMark(arrayMarkIndex, listMark);
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Inserted mark at ind=" + arrayMarkIndex + ": " + listMark); // NOI18N
                }
                arrayMarkIndex++;
            }
        }
    }

    private void updateFolds(TokenSequence seq, FoldHierarchyTransaction transaction) {

        if (seq != null && !seq.isEmpty()) {
            processTokenList(seq, transaction);
        }

        if (maxUpdateMarkOffset == -1) { // no updates
            return;
        }
        
        // Find the first mark to update and init the prevMark and parentMark prior the loop
        int index = findMarkIndex(minUpdateMarkOffset);
        FoldMarkInfo prevMark;
        FoldMarkInfo parentMark;
        if (index == 0) { // start from begining
            prevMark = null;
            parentMark = null;
        } else {
            prevMark = getMark(index - 1);
            parentMark = prevMark.getParentMark();
        }
        
        // Iterate through the changed marks in the mark array 
        int markCount = getMarkCount();
        while (index < markCount) { // process the marks
            FoldMarkInfo mark = getMark(index);

            // If the mark was released then it must be removed
            if (mark.isReleased()) {
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Removing released mark at ind=" + index + ": " + mark); // NOI18N
                }
                removeMark(index);
                markCount--;
                continue;
            }

            // Update mark's status (folds, parentMark etc.)
            if (mark.isStartMark()) { // starting a new fold
                if (prevMark == null || prevMark.isStartMark()) { // new level
                    mark.setParentMark(prevMark); // prevMark == null means root level
                    parentMark = prevMark;

                } // same level => parent to the parent of the prevMark

            } else { // end mark
                if (prevMark != null) {
                    if (prevMark.isStartMark()) { // closing nearest fold
                        prevMark.setEndMark(mark, false, transaction);

                    } else { // prevMark is end mark - closing its parent fold
                        if (parentMark != null) {
                            // mark's parent gets set as well
                            parentMark.setEndMark(mark, false, transaction);
                            parentMark = parentMark.getParentMark();

                        } else { // prevMark's parentMark is null (top level)
                            mark.makeSolitaire(false, transaction);
                        }
                    }
                    
                } else { // prevMark is null
                    mark.makeSolitaire(false, transaction);
                }
            }

            // Set parent mark of the mark
            mark.setParentMark(parentMark);

            
            prevMark = mark;
            index++;
        }

        minUpdateMarkOffset = Integer.MAX_VALUE;
        maxUpdateMarkOffset = -1;
        
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("MARKS DUMP:\n" + this); //NOI18N
        }
    }
    
    public @Override String toString() {
        StringBuffer sb = new StringBuffer();
        int markCount = getMarkCount();
        int markCountDigitCount = Integer.toString(markCount).length();
        for (int i = 0; i < markCount; i++) {
            sb.append("["); // NOI18N
            String iStr = Integer.toString(i);
            appendSpaces(sb, markCountDigitCount - iStr.length());
            sb.append(iStr);
            sb.append("]:"); // NOI18N
            FoldMarkInfo mark = getMark(i);
            
            // Add extra indent regarding the depth in hierarchy
            int indent = 0;
            FoldMarkInfo parentMark = mark.getParentMark();
            while (parentMark != null) {
                indent += 4;
                parentMark = parentMark.getParentMark();
            }
            appendSpaces(sb, indent);

            sb.append(mark);
            sb.append('\n');
        }
        return sb.toString();
    }
    
    private static void appendSpaces(StringBuffer sb, int spaces) {
        while (--spaces >= 0) {
            sb.append(' ');
        }
    }

    private static Pattern pattern = Pattern.compile(
            "(<\\s*editor-fold" +
            // id="x"[opt] defaultstate="y"[opt] desc="z"[opt] defaultstate="a"[opt]
            // id must be first, the rest of attributes in random order
            "(?:(?:\\s+id=\"(\\S*)\")?(?:\\s+defaultstate=\"(\\S*?)\")?(?:\\s+desc=\"([\\S \\t]*?)\")?(?:\\s+defaultstate=\"(\\S*?)\")?)" +
            "\\s*>)|(?:</\\s*editor-fold\\s*>)"); // NOI18N

    private FoldMarkInfo scanToken(Token token) throws BadLocationException {
        // ignore any token that is not comment
        if (token.id().primaryCategory() != null && token.id().primaryCategory().startsWith(tokenId)) { //NOI18N
            Matcher matcher = pattern.matcher(token.text());
            if (matcher.find()) {
                if (matcher.group(1) != null) { // fold's start mark found
                    boolean state;
                    if (matcher.group(3) != null) {
                        state = "collapsed".equals(matcher.group(3)); // remember the defaultstate // NOI18N
                    } else {
                        state = "collapsed".equals(matcher.group(5));
                    }
                    
                    if (matcher.group(2) != null) { // fold's id exists
                        Boolean collapsed = (Boolean)customFoldId.get(matcher.group(2));
                        if (collapsed != null)
                            state = collapsed.booleanValue(); // fold's state is already known from the past
                        else
                            customFoldId.put(matcher.group(2), Boolean.valueOf(state));
                    }
                    return new FoldMarkInfo(true, token.offset(null), matcher.end(0), matcher.group(2), state, matcher.group(4)); // NOI18N
                } else { // fold's end mark found
                    return new FoldMarkInfo(false, token.offset(null), matcher.end(0), null, false, null);
                }
            }
        }
        return null;
    }

    private final class FoldMarkInfo {

        private boolean startMark;
        private Position pos;
        private int length;
        private String id;
        private boolean collapsed;
        private String description;

        /** Matching pair mark used for fold construction */
        private FoldMarkInfo pairMark;
        
        /** Parent mark defining nesting in the mark hierarchy. */
        private FoldMarkInfo parentMark;
        
        /**
         * Fold that corresponds to this mark (if it's start mark).
         * It can be null if this mark is end mark or if it currently
         * does not have the fold assigned.
         */
        private Fold fold;
        
        private boolean released;
        
        private FoldMarkInfo(boolean startMark, int offset,
                             int length, String id, boolean collapsed, String description)
        throws BadLocationException {

            this.startMark = startMark;
            this.pos = doc.createPosition(offset);
            this.length = length;
            this.id = id;
            this.collapsed = collapsed;
            this.description = description;
        }

        public String getId() {
            return id;
        }

        public String getDescription() {
            return description;
        }

        public boolean isStartMark() {
            return startMark;
        }

        public int getLength() {
            return length;
        }

        public int getOffset() {
            return pos.getOffset();
        }
        
        public int getEndOffset() {
            return getOffset() + getLength();
        }

        public boolean isCollapsed() {
            return (fold != null) ? fold.isCollapsed() : collapsed;
        }
        
        public boolean hasFold() {
            return (fold != null);
        }
        
        public void setCollapsed(boolean collapsed) {
            this.collapsed = collapsed;
        }
        
        public boolean isSolitaire() {
            return (pairMark == null);
        }
        
        public void makeSolitaire(boolean forced, FoldHierarchyTransaction transaction) {
            if (!isSolitaire()) {
                if (isStartMark()) {
                    setEndMark(null, forced, transaction);
                } else { // end mark
                    getPairMark().setEndMark(null, forced, transaction);
                }
            }
        }
        
        public boolean isReleased() {
            return released;
        }
        
        /**
         * Release this mark and mark for update.
         */
        public void release(boolean forced, FoldHierarchyTransaction transaction) {
            if (!released) {
                makeSolitaire(forced, transaction);
                released = true;
                markUpdate(this);
            }
        }
        
        public FoldMarkInfo getPairMark() {
            return pairMark;
        }
        
        private void setPairMark(FoldMarkInfo pairMark) {
            this.pairMark = pairMark;
        }

        public void setEndMark(FoldMarkInfo endMark, boolean forced,
        FoldHierarchyTransaction transaction) {
            if (!isStartMark()) {
                throw new IllegalStateException("Not start mark"); // NOI18N
            }
            if (pairMark == endMark) {
                return;
            }
            
            if (pairMark != null) { // is currently paired to an end mark
                releaseFold(forced, transaction);
                pairMark.setPairMark(null);
            }

            pairMark = endMark;
            if (endMark != null) {
                if (!endMark.isSolitaire()) { // make solitaire first
                    endMark.makeSolitaire(false, transaction); // not forced here
                }
                endMark.setPairMark(this);
                endMark.setParentMark(this.getParentMark());
                ensureFoldExists(transaction);
            }
        }
        
        public FoldMarkInfo getParentMark() {
            return parentMark;
        }
        
        public void setParentMark(FoldMarkInfo parentMark) {
            this.parentMark = parentMark;
        }
        
        private void releaseFold(boolean forced, FoldHierarchyTransaction transaction) {
            if (isSolitaire() || !isStartMark()) {
               throw new IllegalStateException();
            }

            if (fold != null) {
                setCollapsed(fold.isCollapsed()); // serialize the collapsed info
                if (!forced) {
                    getOperation().removeFromHierarchy(fold, transaction);
                }
                fold = null;
            }
        }

        public Fold getFold() {
            if (isSolitaire()) {
                return null;
            }
            if (!isStartMark()) {
                return pairMark.getFold();
            }
            return fold;
        }
        
        public void ensureFoldExists(FoldHierarchyTransaction transaction) {
            if (isSolitaire() || !isStartMark()) {
                throw new IllegalStateException();
            }

            if (fold == null) {
                try {
                    if (!startMark) {
                        throw new IllegalStateException("Not start mark: " + this); // NOI18N
                    }
                    if (pairMark == null) {
                        throw new IllegalStateException("No pairMark for mark:" + this); // NOI18N
                    }
                    int startOffset = getOffset();
                    int startGuardedLength = getLength();
                    int endGuardedLength = pairMark.getLength();
                    int endOffset = pairMark.getOffset() + endGuardedLength;
                    fold = getOperation().addToHierarchy(
                        CUSTOM_FOLD_TYPE, getDescription(), collapsed,
                        startOffset, endOffset,
                        startGuardedLength, endGuardedLength,
                        this,
                        transaction
                    );
                } catch (BadLocationException e) {
                    LOG.log(Level.WARNING, null, e);
                }
            }
        }
        
        public @Override String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append(isStartMark() ? 'S' : 'E');  // NOI18N
            
            // Check whether this mark (or its pair) has fold
            if (hasFold() || (!isSolitaire() && getPairMark().hasFold())) {
                sb.append("F"); // NOI18N
                
                // Check fold's status
                if (isStartMark() && (isSolitaire()
                        || getOffset() != fold.getStartOffset()
                        || getPairMark().getEndOffset() != fold.getEndOffset())
                ) {
                    sb.append("!!<"); // NOI18N
                    sb.append(fold.getStartOffset());
                    sb.append(","); // NOI18N
                    sb.append(fold.getEndOffset());
                    sb.append(">!!"); // NOI18N
                }
            }

            // Append mark's internal status
            sb.append(" ("); // NOI18N
            sb.append("o="); // NOI18N
            sb.append(pos.getOffset());
            sb.append(", l="); // NOI18N
            sb.append(length);
            sb.append(", d='"); // NOI18N
            sb.append(description);
            sb.append('\'');
            if (getPairMark() != null) {
                sb.append(", <->"); // NOI18N
                sb.append(getPairMark().getOffset());
            }
            if (getParentMark() != null) {
                sb.append(", ^"); // NOI18N
                sb.append(getParentMark().getOffset());
            }
            sb.append(')');
            
            return sb.toString();
        }

    }
        
    public static final class Factory implements FoldManagerFactory {

        public FoldManager createFoldManager() {
            return new CustomFoldManager();
        }
    }
}

Lines 44-49 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/ApiPackageAccessor.java (+3 lines)
44		44
45	package org.netbeans.modules.editor.fold;	45	package org.netbeans.modules.editor.fold;
46		46
		47	import org.netbeans.modules.editor.fold.ui.FoldViewFactory;
47	import javax.swing.event.DocumentEvent;	48	import javax.swing.event.DocumentEvent;
48	import javax.swing.text.BadLocationException;	49	import javax.swing.text.BadLocationException;
49	import javax.swing.text.Document;	50	import javax.swing.text.Document;
Lines 142-146 Link Here
142		143
143	public abstract void foldStateChangeEndOffsetChanged(FoldStateChange fsc,	144	public abstract void foldStateChangeEndOffsetChanged(FoldStateChange fsc,
144	int originalEndOffset);	145	int originalEndOffset);
		146
		147	public abstract FoldHierarchyExecution foldGetExecution(FoldHierarchy fh);
145		148
146	}	149	}




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

package org.netbeans.modules.editor.fold;

import javax.swing.text.Document;
import javax.swing.text.BadLocationException;

import org.netbeans.api.lexer.Token;
import org.netbeans.api.lexer.TokenHierarchy;
import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.editor.BaseDocument;
import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;
import org.netbeans.spi.editor.fold.FoldManager;
import org.netbeans.spi.editor.fold.FoldManagerFactory;
import org.netbeans.spi.editor.fold.FoldOperation;
import org.openide.util.Parameters;
import org.openide.util.RequestProcessor;

/**

 * @version 1.00
 */

public final class CustomFoldManager implements FoldManager, Runnable {
    
    private static final Logger LOG = Logger.getLogger(CustomFoldManager.class.getName());
    

    private static final RequestProcessor RP = new RequestProcessor(CustomFoldManager.class.getName(),
            1, false, false);
    private final RequestProcessor.Task task = RP.create(this);
    
    private final String tokenId;
    
    public CustomFoldManager() {
        this.tokenId = "comment";
    }

    public CustomFoldManager(String tokenId) {
        Parameters.notNull("tokenId", tokenId);
        this.tokenId = tokenId;
    }
    
    public void init(FoldOperation operation) {
        this.operation = operation;
        if (LOG.isLoggable(Level.FINE)) {


    private FoldMarkInfo scanToken(Token token) throws BadLocationException {
        // ignore any token that is not comment
        if (token.id().primaryCategory() != null && token.id().primaryCategory().startsWith(tokenId)) { //NOI18N
            Matcher matcher = pattern.matcher(token.text());
            if (matcher.find()) {
                if (matcher.group(1) != null) { // fold's start mark found




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

import java.util.ArrayList;
import java.util.Collection;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.spi.editor.fold.FoldTypeProvider;

/**
 * Default folds, provided by the infrastructure.
 * These fold types do not propagate to individual languages, only serve as
 * a common base for "all languages" configuration.
 * 
 * @author sdedic
 */
@MimeRegistration(mimeType = "", service = FoldTypeProvider.class)
public class DefaultFoldProvider implements FoldTypeProvider {
    private final Collection<FoldType>  defaultTypes;
    
    public DefaultFoldProvider() {
        defaultTypes = new ArrayList<FoldType>(7);
        defaultTypes.add(FoldType.CODE_BLOCK);
        defaultTypes.add(FoldType.COMMENT);
        defaultTypes.add(FoldType.DOCUMENTATION);
        defaultTypes.add(FoldType.INITIAL_COMMENT);
        defaultTypes.add(FoldType.MEMBER);
        defaultTypes.add(FoldType.NESTED);
        defaultTypes.add(FoldType.TAG);
        defaultTypes.add(FoldType.USER);
    }
    
    @Override
    public Collection getValues(Class type) {
        return type == FoldType.class ? defaultTypes : null;
    }
    
    @Override
    public boolean inheritable() {
        return false;
    }
    
}




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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.spi.editor.fold.ContentReader;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;

/**
 * Manages registered ContentReaders for individual Mime types.
 * The cache is flushed iff the set of ContentReader.Factory changes (e.g. during module (un)installation).
 *
 * @author sdedic
 */
public final class FoldContentReaders {
    private static FoldContentReaders INSTANCE = new FoldContentReaders();
    
    private volatile Map<String, N> mimeNodes = new HashMap<String, N>();
    
    public static FoldContentReaders get() {
        return INSTANCE;
    }
    
    public CharSequence readContent(String mime, Document d, Fold f, FoldTemplate ft) throws BadLocationException {
        List<ContentReader> readers = getReaders(mime, f.getType());
        for (ContentReader r : readers) {
            CharSequence chs = r.read(d, f, ft);
            if (chs != null) {
                return chs;
            }
        }
        return null;
    }

    private class N implements LookupListener {
        String  mime;
        Lookup.Result result;
        Map<FoldType, List<ContentReader>> readers = new HashMap<FoldType, List<ContentReader>>();

        public N(String mime, Lookup mimeLookup) {
            this.mime = mime;
            init(mimeLookup);
        }
        
        void clear() {
            result.removeLookupListener(this);
        }

        @Override
        public void resultChanged(LookupEvent ev) {
            flush();
        }
        
        private void init(Lookup mimeLookup) {
            Collection<? extends FoldType> types = 
                    new ArrayList<FoldType>((FoldUtilities.getFoldTypes(mime).values()));
            
            result = mimeLookup.lookupResult(ContentReader.Factory.class);
            Collection<? extends ContentReader.Factory> factories = result.allInstances();

            List<ContentReader> l;
            for (FoldType ft : types) {
                l = null;
                for (ContentReader.Factory f : factories) {
                    ContentReader cr = f.createReader(ft);
                    if (cr != null) {
                        if (l == null) {
                            l = new ArrayList<ContentReader>(3);
                        }
                        l.add(cr);
                    }
                }
                if (l != null) {
                    readers.put(ft, l);
                }
            }
            result.addLookupListener(this);
        }
        
        List<ContentReader> readers(FoldType ft) {
            List<ContentReader> r = readers.get(ft);
            return r == null ? Collections.<ContentReader>emptyList() : r;
        }
    }
    
    public List<ContentReader> getReaders(String mime, FoldType ft) {
        N node = mimeNodes.get(mime);
        if (node == null) {
            synchronized (mimeNodes) {
                node = mimeNodes.get(mime);
                if (node == null) {
                    node = new N(mime, MimeLookup.getLookup(mime));
                    mimeNodes.put(mime, node);
                }
            }
        }
        return node.readers(ft);
    }
    
    private void flush() {
        synchronized (mimeNodes) {
            for (N n : mimeNodes.values()) {
                n.clear();
            }
            mimeNodes.clear();
        }
    }
}

Lines 57-64 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/FoldHierarchyExecution.java (-4 / +118 lines)
57	import java.util.List;	57	import java.util.List;
58	import java.util.Map;	58	import java.util.Map;
59	import java.util.Set;	59	import java.util.Set;
60	import java.util.logging.Level;	60	import java.util.concurrent.TimeUnit;
61	import java.util.logging.Logger;	61	import java.util.logging.Logger;
		62	import java.util.prefs.PreferenceChangeEvent;
		63	import java.util.prefs.PreferenceChangeListener;
62	import java.util.prefs.Preferences;	64	import java.util.prefs.Preferences;
63	import javax.swing.SwingUtilities;	65	import javax.swing.SwingUtilities;
64	import javax.swing.event.DocumentEvent;	66	import javax.swing.event.DocumentEvent;
Lines 67-79 Link Here
67	import javax.swing.text.AbstractDocument;	69	import javax.swing.text.AbstractDocument;
68	import javax.swing.text.BadLocationException;	70	import javax.swing.text.BadLocationException;
69	import javax.swing.text.Document;	71	import javax.swing.text.Document;
		72	import javax.swing.text.EditorKit;
70	import javax.swing.text.JTextComponent;	73	import javax.swing.text.JTextComponent;
71	import org.netbeans.api.editor.fold.Fold;	74	import org.netbeans.api.editor.fold.Fold;
72	import org.netbeans.api.editor.fold.FoldHierarchy;	75	import org.netbeans.api.editor.fold.FoldHierarchy;
73	import org.netbeans.api.editor.fold.FoldHierarchyEvent;	76	import org.netbeans.api.editor.fold.FoldHierarchyEvent;
74	import org.netbeans.api.editor.fold.FoldHierarchyListener;	77	import org.netbeans.api.editor.fold.FoldHierarchyListener;
75	import org.netbeans.api.editor.fold.FoldStateChange;	78	import org.netbeans.api.editor.fold.FoldStateChange;
		79	import org.netbeans.api.editor.fold.FoldType;
		80	import org.netbeans.api.editor.fold.FoldUtilities;
76	import org.netbeans.api.editor.mimelookup.MimeLookup;	81	import org.netbeans.api.editor.mimelookup.MimeLookup;
		82	import org.netbeans.api.editor.mimelookup.MimePath;
77	import org.netbeans.lib.editor.util.swing.DocumentListenerPriority;	83	import org.netbeans.lib.editor.util.swing.DocumentListenerPriority;
78	import org.netbeans.lib.editor.util.swing.DocumentUtilities;	84	import org.netbeans.lib.editor.util.swing.DocumentUtilities;
79	import org.netbeans.spi.editor.fold.FoldManager;	85	import org.netbeans.spi.editor.fold.FoldManager;
Lines 83-88 Link Here
83	import org.openide.ErrorManager;	89	import org.openide.ErrorManager;
84	import org.openide.util.RequestProcessor;	90	import org.openide.util.RequestProcessor;
85	import org.openide.util.Task;	91	import org.openide.util.Task;
		92	import org.openide.util.WeakListeners;
86		93
87	/**	94	/**
88	* Class backing the <code>FoldHierarchy</code> in one-to-one relationship.	95	* Class backing the <code>FoldHierarchy</code> in one-to-one relationship.
Lines 117-123 Link Here
117		124
118	private static final String PROPERTY_FOLD_HIERARCHY_MUTEX = "foldHierarchyMutex"; //NOI18N	125	private static final String PROPERTY_FOLD_HIERARCHY_MUTEX = "foldHierarchyMutex"; //NOI18N
119		126
120	private static final String PROPERTY_FOLDING_ENABLED = "code-folding-enable"; //NOI18N	127	private static final String PROPERTY_FOLDING_ENABLED = FoldUtilitiesImpl.PREF_CODE_FOLDING_ENABLED; //NOI18N
121		128
122	private static final boolean debug	129	private static final boolean debug
123	= Boolean.getBoolean("netbeans.debug.editor.fold"); //NOI18N	130	= Boolean.getBoolean("netbeans.debug.editor.fold"); //NOI18N
Lines 174-179 Link Here
174		181
175	private Task initTask;	182	private Task initTask;
176		183
		184	private Preferences foldPreferences;
		185
		186	private FoldingEditorSupport editSupport;
		187
177	public static synchronized FoldHierarchy getOrCreateFoldHierarchy(JTextComponent component) {	188	public static synchronized FoldHierarchy getOrCreateFoldHierarchy(JTextComponent component) {
178	return getOrCreateFoldExecution(component).getHierarchy();	189	return getOrCreateFoldExecution(component).getHierarchy();
179	}	190	}
Lines 256-261 Link Here
256	} catch (BadLocationException e) {	267	} catch (BadLocationException e) {
257	ErrorManager.getDefault().notify(e);	268	ErrorManager.getDefault().notify(e);
258	}	269	}
		270
		271	editSupport = new FoldingEditorSupport(hierarchy, component);
		272
259	}	273	}
260		274
261	/* testing only */	275	/* testing only */
Lines 263-268 Link Here
263	getOrCreateFoldExecution(panel).getInitTask().waitFinished();	277	getOrCreateFoldExecution(panel).getInitTask().waitFinished();
264	}	278	}
265		279
		280	/* testing only */
		281	static boolean waitAllTasks() throws InterruptedException {
		282	return RP.awaitTermination(30, TimeUnit.SECONDS);
		283	}
		284
266	private Task getInitTask() {	285	private Task getInitTask() {
267	return initTask;	286	return initTask;
268	}	287	}
Lines 314-319 Link Here
314	mutex.lock();	333	mutex.lock();
315	}	334	}
316		335
		336	public final boolean isLockedByCaller() {
		337	return mutex.getLockThread() == Thread.currentThread();
		338	}
		339
317	/**	340	/**
318	* Unlock the hierarchy from exclusive use. This method must only	341	* Unlock the hierarchy from exclusive use. This method must only
319	* be used together with {@link #lock()} in <code>try..finally</code> block.	342	* be used together with {@link #lock()} in <code>try..finally</code> block.
Lines 454-459 Link Here
454	: null;	477	: null;
455	}	478	}
456		479
		480	Set<Fold> getBlockedFolds(Fold f) {
		481	return (Set<Fold>)block2blockedSet.get(f);
		482	}
		483
457	/**	484	/**
458	* Mark given fold as blocked by the block fold.	485	* Mark given fold as blocked by the block fold.
459	*/	486	*/
Lines 689-694 Link Here
689	}	716	}
690	}	717	}
691	}	718	}
		719
		720	private String getMimeType() {
		721	EditorKit ek = component.getUI().getEditorKit(component);
		722	String mimeType;
		723
		724	if (ek != null) {
		725	mimeType = ek.getContentType();
		726	} else {
		727	mimeType = "";
		728	}
		729	return mimeType;
		730	}
692		731
693	/**	732	/**
694	* Rebuild (or release) the root folds of the hierarchy in the event dispatch thread.	733	* Rebuild (or release) the root folds of the hierarchy in the event dispatch thread.
Lines 721-732 Link Here
721	boolean ok = false;	760	boolean ok = false;
722	try {	761	try {
723	operations = new FoldOperationImpl[factoryListLength];	762	operations = new FoldOperationImpl[factoryListLength];
724	for (int i = 0; i < factoryListLength; i++) {	763	int i;
		764	for (i = 0; i < factoryListLength; i++) {
725	FoldManagerFactory factory = (FoldManagerFactory)factoryList.get(i);	765	FoldManagerFactory factory = (FoldManagerFactory)factoryList.get(i);
726	FoldManager manager = factory.createFoldManager();	766	FoldManager manager = factory.createFoldManager();
		767	if (manager == null) {
		768	continue;
		769	}
727	operations[i] = new FoldOperationImpl(this, manager, priority);	770	operations[i] = new FoldOperationImpl(this, manager, priority);
728	priority--;	771	priority--;
729	}	772	}
		773	// trim the array in the unlikely case
		774	if (i < factoryListLength) {
		775	FoldOperationImpl[] ops = new FoldOperationImpl[i];
		776	System.arraycopy(operations, 0, ops, 0, i);
		777	operations = ops;
		778	}
730	ok = true;	779	ok = true;
731	} finally {	780	} finally {
732	if (!ok) {	781	if (!ok) {
Lines 878-884 Link Here
878	if (b == null && component.getDocument() != null) {	927	if (b == null && component.getDocument() != null) {
879	String mime = DocumentUtilities.getMimeType(component.getDocument());	928	String mime = DocumentUtilities.getMimeType(component.getDocument());
880	if (mime != null) {	929	if (mime != null) {
881	Preferences prefs = MimeLookup.getLookup(mime).lookup(Preferences.class);	930	Preferences prefs = getFoldPreferences();
882	b = prefs.getBoolean(PROPERTY_FOLDING_ENABLED, true);	931	b = prefs.getBoolean(PROPERTY_FOLDING_ENABLED, true);
883	}	932	}
884	}	933	}
Lines 996-1000 Link Here
996		1045
997	return sb.toString();	1046	return sb.toString();
998	}	1047	}
		1048
		1049	public boolean hasProviders() {
		1050	return operations.length > 0;
		1051	}
		1052
		1053	/**
		1054	* Cache for initial states for individual FoldTypes.
		1055	* The cache is invalidated iff the Preferences change in a key which starts with the collapse- prefix.
		1056	* The cache is NOT invalidated on the FoldType set change, as if the foldtype set changes, either new FoldTypes
		1057	* appear (they will enter the cache eventually), or the obsolete FoldTypes will not be used in the future,
		1058	* so they may rote in the cache until the Component is closed.
		1059	*/
		1060	private volatile Map<FoldType, Boolean> initialFoldState = new HashMap<FoldType, Boolean>();
		1061
		1062	/**
		1063	* Listener on fold preferences.
		1064	*/
		1065	private PreferenceChangeListener weakPrefL;
		1066
		1067	/**
		1068	* Returns the cached value for initial folding state of the specific type. The method may be only
		1069	* called under a lock, since it populates the cache; no concurrency is permitted.
		1070	*
		1071	* @param ft the FoldType to inspect
		1072	* @return true, if the fold should be collapsed initially.
		1073	*/
		1074	public boolean getInitialFoldState(FoldType ft) {
		1075	Boolean b = initialFoldState.get(ft);
		1076	if (b != null) {
		1077	return b;
		1078	}
		1079	b = FoldUtilities.isAutoCollapsed(ft, hierarchy);
		1080	initialFoldState.put(ft, b);
		1081	return b;
		1082	}
		1083
		1084	/**
		1085	* Obtains Preferences that control folding for this Hierarchy.
		1086	*
		1087	* @return Preferences object
		1088	*/
		1089	public Preferences getFoldPreferences() {
		1090	if (foldPreferences == null) {
		1091	String mimeType = getMimeType();
		1092	// internally does MimeLookup lookup(Preferences.class)
		1093	Preferences prefs = LegacySettingsSync.get().processMime(mimeType);
		1094	if ("".equals(mimeType)) {
		1095	// do not cache; typically the editor kit will be changed to something other
		1096	return prefs;
		1097	}
		1098	foldPreferences = prefs;
		1099	weakPrefL = WeakListeners.create(PreferenceChangeListener.class, new PreferenceChangeListener() {
		1100	@Override
		1101	public void preferenceChange(PreferenceChangeEvent evt) {
		1102	if (evt.getKey().startsWith(FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX)) {
		1103	if (!initialFoldState.isEmpty()) {
		1104	initialFoldState = new HashMap<FoldType, Boolean>();
		1105	}
		1106	}
		1107	}
		1108	}, foldPreferences);
		1109	foldPreferences.addPreferenceChangeListener(weakPrefL);
		1110	}
		1111	return foldPreferences;
1112	}
999		1113
1000	}	1114	}

Lines 242-248 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/FoldHierarchyTransactionImpl.java (-1 / +1 lines)
242	updateAffectedOffsets(fold);	242	updateAffectedOffsets(fold);
243	int startOffset = change.getOriginalStartOffset();	243	int startOffset = change.getOriginalStartOffset();
244	int endOffset = change.getOriginalEndOffset();	244	int endOffset = change.getOriginalEndOffset();
245	assert (startOffset <= endOffset) : "startOffset=" + startOffset + " > endOffset=" + endOffset; // NOI18N;	245	assert (endOffset < 0 \|\| startOffset <= endOffset) : "startOffset=" + startOffset + " > endOffset=" + endOffset; // NOI18N;
246	if (startOffset != -1) {	246	if (startOffset != -1) {
247	updateAffectedStartOffset(startOffset);	247	updateAffectedStartOffset(startOffset);
248	}	248	}

Lines 44-59 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/FoldOperationImpl.java (-1 / +477 lines)
44		44
45	package org.netbeans.modules.editor.fold;	45	package org.netbeans.modules.editor.fold;
46		46
		47	import java.util.ArrayList;
		48	import java.util.Collection;
		49	import java.util.Collections;
		50	import java.util.Comparator;
		51	import java.util.HashMap;
		52	import java.util.Iterator;
		53	import java.util.LinkedList;
		54	import java.util.List;
		55	import java.util.ListIterator;
		56	import java.util.Map;
		57	import java.util.NoSuchElementException;
		58	import java.util.Set;
		59	import java.util.Stack;
47	import java.util.logging.Level;	60	import java.util.logging.Level;
48	import java.util.logging.Logger;	61	import java.util.logging.Logger;
		62	import java.util.prefs.Preferences;
49	import javax.swing.event.DocumentEvent;	63	import javax.swing.event.DocumentEvent;
50	import javax.swing.text.BadLocationException;	64	import javax.swing.text.BadLocationException;
51	import javax.swing.text.Document;	65	import javax.swing.text.Document;
		66	import javax.swing.text.EditorKit;
		67	import javax.swing.text.JTextComponent;
52	import org.netbeans.spi.editor.fold.FoldManager;	68	import org.netbeans.spi.editor.fold.FoldManager;
53	import org.netbeans.api.editor.fold.Fold;	69	import org.netbeans.api.editor.fold.Fold;
54	import org.netbeans.api.editor.fold.FoldHierarchy;	70	import org.netbeans.api.editor.fold.FoldHierarchy;
		71	import org.netbeans.spi.editor.fold.FoldInfo;
		72	import org.netbeans.api.editor.fold.FoldStateChange;
		73	import org.netbeans.api.editor.fold.FoldTemplate;
55	import org.netbeans.spi.editor.fold.FoldOperation;	74	import org.netbeans.spi.editor.fold.FoldOperation;
56	import org.netbeans.api.editor.fold.FoldType;	75	import org.netbeans.api.editor.fold.FoldType;
		76	import org.netbeans.api.editor.mimelookup.MimeLookup;
		77	import org.netbeans.editor.BaseDocument;
		78	import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;
		79	import org.openide.util.Exceptions;
57		80
58		81
59	/**	82	/**
Lines 204-209 Link Here
204	throws BadLocationException {	227	throws BadLocationException {
205	checkFoldOperation(fold);	228	checkFoldOperation(fold);
206	int origEndOffset = fold.getEndOffset();	229	int origEndOffset = fold.getEndOffset();
		230	if (origEndOffset == endOffset) {
		231	return;
		232	}
207	ApiPackageAccessor api = getAccessor();	233	ApiPackageAccessor api = getAccessor();
208	api.foldSetEndOffset(fold, getDocument(), endOffset);	234	api.foldSetEndOffset(fold, getDocument(), endOffset);
209	api.foldStateChangeEndOffsetChanged(transaction.getFoldStateChange(fold), origEndOffset);	235	api.foldStateChangeEndOffsetChanged(transaction.getFoldStateChange(fold), origEndOffset);
Lines 235-241 Link Here
235	public boolean isReleased() {	261	public boolean isReleased() {
236	return released;	262	return released;
237	}	263	}
238		264
		265	/**
		266	* Enumerates all folds contributed by this Operation, whether blocked or active.
		267	*
		268	* @return
		269	*/
		270	public Iterator<Fold> foldIterator() {
		271	return new BI(new DFSI(execution.getRootFold()));
		272	}
		273
239	private void checkFoldOperation(Fold fold) {	274	private void checkFoldOperation(Fold fold) {
240	FoldOperationImpl foldOperation = getAccessor().foldGetOperation(fold);	275	FoldOperationImpl foldOperation = getAccessor().foldGetOperation(fold);
241	if (foldOperation != this) {	276	if (foldOperation != this) {
Lines 250-254 Link Here
250	private static ApiPackageAccessor getAccessor() {	285	private static ApiPackageAccessor getAccessor() {
251	return ApiPackageAccessor.get();	286	return ApiPackageAccessor.get();
252	}	287	}
		288
		289	/**
		290	* Compares two folds A, B. Fold "A" precedes "B", if and only if:
		291	* <ul>
		292	* <li>A fully encloses B, or
		293	* <li>A starts before B, or
		294	* <li>A and B occupy the same range, and A's priority is lower
		295	* </ul>
		296	*
		297	* @param a fold to compare
		298	* @param b fold to compare
		299	* @return -1, 1, 0 as appropriate for a Comparator
		300	*/
		301	private static final Comparator<Fold> FOLD_COMPARATOR = new Comparator<Fold>() {
		302	@Override
		303	public int compare(Fold a, Fold b) {
		304	int diff = a.getStartOffset() - b.getStartOffset();
		305	if (diff < 0) {
		306	return -1;
		307	}
		308	int diff2 = b.getEndOffset() - a.getEndOffset();
		309	if (diff2 != 0 \|\| diff != 0) {
		310	return 1;
		311	}
		312	ApiPackageAccessor accessor = getAccessor();
		313	return accessor.foldGetOperation(a).getPriority() - accessor.foldGetOperation(b).getPriority();
		314	}
		315	};
253		316
		317	/**
		318	* Level of depth-first traversal
		319	*/
		320	static class PS {
		321	private Fold parent;
		322	private int childIndex = -1;
		323	private PS next;
		324
		325	PS(Fold parent, PS next) {
		326	this.parent = parent;
		327	this.next = next;
		328	}
		329	}
		330
		331	/**
		332	* Implmentation of depth-first pre-order traversal through Fold hierarchy.
		333	* Each level is iterated in the fold order = start offset order.
		334	*/
		335	private class DFSI implements Iterator<Fold> {
		336	PS level;
		337
		338	private DFSI(Fold root) {
		339	level = new PS(root, null);
		340	}
		341
		342	@Override
		343	public Fold next() {
		344	if (!hasNext()) {
		345	throw new NoSuchElementException();
		346	}
		347	if (level.childIndex == -1) {
		348	level.childIndex++;
		349	return level.parent;
		350	}
		351	// note that hasNext also pops levels, as necessary, so there's a
		352	// level, which is not yet exhausted.
		353	Fold f = level.parent.getFold(level.childIndex++);
		354	if (f.getFoldCount() > 0) {
		355	level = new PS(f, level);
		356	level.childIndex++;
		357	return level.parent;
		358	}
		359	return f;
		360	}
		361
		362	@Override
		363	public boolean hasNext() {
		364	while (level != null) {
		365	if (level.childIndex == -1) {
		366	return true;
		367	} else if (level.childIndex >= level.parent.getFoldCount()) {
		368	level = level.next;
		369	} else {
		370	return true;
		371	}
		372	}
		373	return false;
		374	}
		375
		376	public void remove() {
		377	throw new IllegalArgumentException();
		378	}
		379	}
		380
381	/**
382	* Iterator, which processes all blocked folds along with their blocker.
383	* The blocker + blockers folds are ordered using the fold order. Results
384	* are filtered to contain just Folds produced by this Operation. Folds
385	* owned by other operations/executions are skipped.
386	* <p/>
387	* Note that blocked folds do not form a hierarchy; they were removed from
388	* the fold hierarchy when it was decided to block those folds. So prior to
389	* iterating further in FoldHierarchy, all (recursively) blocked folds must
390	* be processed.
391	*/
392	private class BI implements Iterator<Fold> {
393	private Iterator<Fold> dfsi;
394	private Iterator<Fold> blockedFolds;
395	private Fold ret;
396	private Stack<Object[]> blockStack = new Stack<Object[]>();
397	private Fold blocker;
398
399	public BI(Iterator<Fold> dfsi) {
400	this.dfsi = dfsi;
401	}
402
403	/**
404	* If fold 'f' blocks some other folds, those blocked folds will b processed
405	* instead of 'f'. f will be mixed among and ordered with its blocked folds, so the
406	* entire chain will be processed in the document order.
407	*
408	* @param f
409	* @return true, if blocked folds should be processed.
410	*/
411	private boolean processBlocked(Fold f) {
412	if (f == blocker) {
413	return false;
414	}
415	Collection<Fold> blocked = execution.getBlockedFolds(f);
416	if (blocked != null && !blocked.isEmpty()) {
417	List<Fold> blockedSorted = new ArrayList<Fold>(blocked.size() + 1);
418	blockedSorted.addAll(blocked);
419	// enumerate together with blocked ones
420	blockedSorted.add(f);
421	Collections.sort(blockedSorted, FOLD_COMPARATOR);
422	blockStack.push(new Object[] { blockedFolds, blocker});
423	blockedFolds = blockedSorted.iterator();
424	blocker = f;
425	return true;
426	} else {
427	return false;
428	}
429	}
430
431	@Override
432	public void remove() {
433	throw new UnsupportedOperationException();
434	}
435
436	@Override
437	public Fold next() {
438	if (!hasNext()) {
439	throw new NoSuchElementException();
440	}
441	Fold f = ret;
442	ret = null;
443	return f;
444	}
445
446	@Override
447	public boolean hasNext() {
448	if (ret != null) {
449	return true;
450	}
451	if (blockedFolds != null) {
452	while (blockedFolds.hasNext()) {
453	Fold f = blockedFolds.next();
454	if (processBlocked(f)) {
455	// continue with a different level of blocking
456	continue;
457	}
458	if (operation.owns(f)) {
459	ret = f;
460	return true;
461	}
462	}
463	blockedFolds = null;
464	}
465	if (!blockStack.isEmpty()) {
466	Object[] o = blockStack.pop();
467	blocker = (Fold)o[1];
468	blockedFolds = (Iterator<Fold>)o[0];
469	return hasNext();
470	}
471
472	while (dfsi.hasNext()) {
473	Fold f = dfsi.next();
474	if (processBlocked(f)) {
475	return hasNext();
476	}
477	if (operation.owns(f)) {
478	ret = f;
479	return true;
480	}
481	}
482	return false;
483	}
484	}
485
486	public Map<FoldInfo, Fold> update(Collection<FoldInfo> fi, Collection<Fold> removed, Collection<FoldInfo> created) throws BadLocationException {
487	Refresher r = new Refresher(fi);
488	if (!isReleased()) {
489	if (!execution.isLockedByCaller()) {
490	throw new IllegalStateException("Update must run under FoldHierarchy lock");
491	}
492	r.run();
493	} else {
494	return null;
495	}
496	if (removed != null) {
497	removed.addAll(r.toRemove);
498	}
499	if (created != null) {
500	created.addAll(r.toAdd);
501	}
502	return r.currentFolds;
503	}
504
505	public boolean getInitialState(FoldType ft) {
506	return execution.getInitialFoldState(ft);
507	}
508
509	private class Refresher implements Comparator<FoldInfo> {
510	private Collection<FoldInfo> foldInfos;
511	private Collection<Fold> toRemove = new ArrayList<Fold>();
512	private Collection<FoldInfo> toAdd = new ArrayList<FoldInfo>();
513	private Map<FoldInfo, Fold> currentFolds = new HashMap<FoldInfo, Fold>();
514
515	/**
516	* Transaction which covers the update
517	*/
518	private FoldHierarchyTransactionImpl tran;
519
520	public Refresher(Collection<FoldInfo> foldInfos) {
521	this.foldInfos = foldInfos;
522	}
523
524	@Override
525	public int compare(FoldInfo a, FoldInfo b) {
526	int diff = a.getStart() - b.getStart();
527	if (diff < 0) {
528	return -1;
529	}
530	int diff2 = b.getEnd() - a.getEnd();
531	if (diff2 != 0 \|\| diff != 0) {
532	return 1;
533	}
534	return 0;
535	}
536
537
538	private int compare(FoldInfo info, Fold f) {
539	if (info == null) {
540	if (f == null) {
541	return 0;
542	} else {
543	return 1;
544	}
545	} else if (f == null) {
546	return -1;
547	}
548
549	int diff = info.getStart() - f.getStartOffset();
550	if (diff != 0) {
551	return diff;
552	}
553	diff = f.getEndOffset() - info.getEnd();
554	if (diff != 0) {
555	return diff;
556	}
557	if (info.getType() == f.getType()) {
558	return 0;
559	}
560	return info.getType().code().compareToIgnoreCase(f.getType().code());
561	}
562
563	private Iterator<Fold> foldIt;
564	private Iterator<FoldInfo> infoIt;
565	private FoldInfo nextInfo;
566
567	private FoldInfo ni() {
568	if (nextInfo != null) {
569	FoldInfo f = nextInfo;
570	nextInfo = null;
571	return f;
572	}
573	return infoIt.hasNext() ? infoIt.next() : null;
574	}
575
576	private FoldInfo peek() {
577	FoldInfo f = ni();
578	nextInfo = f;
579	return f;
580	}
581
582	private boolean containsOneAnother(FoldInfo i, Fold f) {
583	int s1 = i.getStart();
584	int s2 = f.getStartOffset();
585	int e1 = i.getEnd();
586	int e2 = f.getEndOffset();
587
588	return ((s1 >= s2 && e2 >= e1) \|\|
589	(s2 >= s1 && e1 >= e2));
590	}
591
592	private boolean nextSameRange(FoldInfo i, Fold f) {
593	if (i == null \|\| f == null) {
594	return false;
595	}
596	if (i.getType() != f.getType() \|\| !containsOneAnother(i, f)) {
597	return false;
598	}
599	FoldInfo next = peek();
600	if (next == null) {
601	return true;
602	}
603	return next.getStart() != f.getStartOffset() \|\| next.getEnd() != f.getEndOffset();
604	}
605
606	private boolean containsSame(FoldInfo i, Fold f) {
607	if (i == null \|\| f == null \|\| i.getType() != f.getType()) {
608	return false;
609	}
610	return containsOneAnother(i, f);
611	}
612
613	public void run() throws BadLocationException {
614	// first order the supplied folds:
615	List ll = new ArrayList<FoldInfo>(foldInfos);
616	Collections.sort(ll, this);
617
618	foldIt = foldIterator();
619	infoIt = ll.iterator();
620
621	Fold f = foldIt.hasNext() ? foldIt.next() : null;
622	FoldInfo i = infoIt.hasNext() ? infoIt.next() : null;
623
624	tran = openTransaction();
625
626
627	try {
628	while (f != null \|\| i != null) {
629	if (LOG.isLoggable(Level.FINEST)) {
630	LOG.finest("Fold = " + f + ", FoldInfo = " + i);
631	}
632	int action = compare(i, f);
633	if (action < 0 && !nextSameRange(i, f)) {
634	// create a new fold from the FoldInfo
635	toAdd.add(i);
636	i = ni();
637	if (LOG.isLoggable(Level.FINEST)) {
638	LOG.finest("Advanced info, next = " + i);
639	}
640	continue;
641	} else if (action > 0 && !containsSame(i, f)) {
642	toRemove.add(f);
643	f = foldIt.hasNext() ? foldIt.next() : null;
644	if (LOG.isLoggable(Level.FINEST)) {
645	LOG.finest("Advanced fold, next = " + f);
646	}
647	continue;
648	}
649
650	update(f, i);
651	currentFolds.put(i, f);
652	i = ni();
653	f = foldIt.hasNext() ? foldIt.next() : null;
654	if (LOG.isLoggable(Level.FINEST)) {
655	LOG.finest("Advanced both info & fold");
656	}
657	}
658	for (Fold fold : toRemove) {
659	if (LOG.isLoggable(Level.FINEST)) {
660	LOG.finest("Removing: " + f);
661	}
662	if (fold.getParent() != null) {
663	removeFromHierarchy(fold, tran);
664	}
665	}
666	for (FoldInfo info : toAdd) {
667	try {
668	currentFolds.put(info, getOperation().addToHierarchy(
669	info.getType(),
670	info.getStart(), info.getEnd(),
671	info.getCollapsed(),
672	info.getTemplate(),
673	info.getDescriptionOverride(),
674	info.getExtraInfo(),
675	tran.getTransaction()));
676	if (LOG.isLoggable(Level.FINEST)) {
677	LOG.finest("Adding: " + i);
678	}
679	} catch (BadLocationException ex) {
680	Exceptions.printStackTrace(ex);
681	}
682	}
683	} finally {
684	tran.commit();
685	}
686	}
687
688	public Fold update(Fold f, FoldInfo info) throws BadLocationException {
689	this.fsch = null;
690	int offs = f.getStartOffset();
691	ApiPackageAccessor acc = getAccessor();
692	if (info.getStart() != offs) {
693	acc.foldSetStartOffset(f, getDocument(), info.getStart());
694	acc.foldStateChangeStartOffsetChanged(getFSCH(f), offs);
695	}
696	offs = f.getEndOffset();
697	if (info.getEnd() != offs) {
698	acc.foldSetEndOffset(f, getDocument(), info.getEnd());
699	acc.foldStateChangeEndOffsetChanged(getFSCH(f), offs);
700	}
701	String desc = info.getDescriptionOverride();
702	if (desc == null) {
703	desc = info.getTemplate().getDescription();
704	}
705	if (!f.getDescription().equals(desc)) {
706	acc.foldSetDescription(f, desc);
707	acc.foldStateChangeDescriptionChanged(getFSCH(f));
708	}
709	if (info.getCollapsed() != null && f.isCollapsed() != info.getCollapsed()) {
710	getAccessor().foldSetCollapsed(f, info.getCollapsed());
711	getAccessor().foldStateChangeCollapsedChanged(getFSCH(f));
712	}
713	return f;
714	}
715
716	/**
717	* FoldStateChange for the current fold being updated;
718	* just an optimization.
719	*/
720	private FoldStateChange fsch;
721
722	private FoldStateChange getFSCH(Fold f) {
723	if (fsch != null) {
724	return fsch;
725	}
726	return fsch = tran.getFoldStateChange(f);
727	}
728
729	}
254	}	730	}




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

import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.spi.editor.fold.FoldTypeProvider;
import org.openide.util.Lookup;
import org.openide.util.Lookup.Result;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.WeakListeners;

/**
 * MIMEtype specific registry, which collects values for a single enum type (enumType). 
 * It looks up
 * {@link ExtEnum.MimeEnumProvider} in the {@link MimeLookup}. It supports efficient
 * valueOf lookup and changes to the set of the values.
 * <p/>
 * Clients <b>must not cache</b> the set of values and treat it as
 * an universe. As modules are enabled / disabled,
 * the set of available values may change and further queries to {@link #valueSet}
 * may return different results.
 * 
 * <p/>
 * Note: this class was trimmed down from generic enum registry. When other extensible
 * enums are introduced, fold registry will just wrap the real enum. Some constructions may
 * be unnecessary general ;)
 *
 * @author sdedic
 */
public final class FoldRegistry  {
    private static final Logger LOG = Logger.getLogger(FoldRegistry.class.getName());

    /**
     * The enum type being registered
     */
    private Class  enumType;

    /**
     * For a MimePath, holds set of applicable enums and value-to-enum map
     */
    private final Map<MimePath, R>  enums = new HashMap<MimePath, R>();
    
    private FoldRegistry(Class enumType) {
        this.enumType = enumType;
    }
    
    private static volatile Reference<FoldRegistry>     INSTANCE = new WeakReference(null);
    
    public static FoldRegistry get() {
        FoldRegistry fr = INSTANCE.get();
        if (fr == null) {
            synchronized (FoldRegistry.class) {
                fr = INSTANCE.get();
                if (fr == null) {
                    fr = new FoldRegistry(FoldType.class);
                    INSTANCE = new SoftReference(fr);
                }
            }
        }
        return fr;
    }
    
    public Collection<FoldType> values(MimePath mime) {
        return get(mime).enums;
    }
    
    public FoldType valueOf(MimePath mime, String val) {
        return get(mime).valueOf(val);
    }
    
    public FoldType.Domain getDomain(MimePath mime) {
        return get(mime);
    }
    
    private R get(MimePath mime) {
        synchronized (enums) {
            R r = enums.get(mime);
            if (r != null) {
                return r;
            }
        }
        
        return refreshMime(mime, null);
    }
    
    /**
     * Representation of the domain for a specific MIMEtype. It listens on a Lookup.Result
     * and refreshes the contents iff lookup changes - that is if a module is (un)loaded,
     * or the value provider set changes.
     * <p/>
     * Updates to enums must occur under synchro
     * 
     */
    private static class R implements LookupListener, FoldType.Domain {
        final FoldRegistry      dom;
        final MimePath          mime;
        /**
         * Listens on mime lookup 
         */
        final Lookup.Result     result;
        /**
         * Listens on parent's mime lookup, possibly null
         */
        final Lookup.Result     result2;
        Collection<ChangeListener> listeners;
        
        /**
         * Set of all enum values
         */
        // @GuardedBy(this)
        private Set<FoldType>         enums;
        
        /**
         * Allows to faster map an enum to a value. Produced lazily by map(), cleared by reset().
         */
        volatile Map<String, FoldType>      valueMap;
        
        public R(FoldRegistry dom, MimePath mime, Result result, Result result2) {
            this.dom = dom;
            this.mime = mime;
            this.result = result;
            this.result2 = result2;
            result.addLookupListener(WeakListeners.create(LookupListener.class, 
                    this, result));
            if (result2 != null) {
                result2.addLookupListener(WeakListeners.create(LookupListener.class, 
                        this, result2));
            }
        }

        @Override
        public void resultChanged(LookupEvent ev) {
            dom.refreshMime(mime, this);
        }

        @Override
        public Collection<FoldType> values() {
            return Collections.unmodifiableCollection(map().values());
        }
        
        private Map<String, FoldType> map() {
            Map<String, FoldType> m;
            
            m = valueMap;
            if (m == null) {
                synchronized (this) {
                    if (valueMap != null) {
                        return valueMap;
                    }
                    Set<FoldType> vals = enums;
                    m = new LinkedHashMap<String, FoldType>();
                    for (FoldType e : vals) {
                        FoldType old = m.put(e.code(), e);
                        if (old != null) {
                            throw new IllegalArgumentException("Two fold types share the same code: " + old + " and " + e);
                        }
                    }
                    this.valueMap = m;
                }
            }
            return m;
        }
        
        @Override
        public FoldType  valueOf(String val) {
            return map().get(val);
        }

        @Override
        public void addChangeListener(ChangeListener l) {
            synchronized (this) {
                if (listeners == null) {
                    listeners = new ArrayList<ChangeListener>();
                }
                listeners.add(l);
            }
        }

        @Override
        public void removeChangeListener(ChangeListener l) {
            synchronized (this) {
                if (listeners != null) {
                    listeners.remove(l);
                }
            }
        }
        
        void reset(Set<FoldType> allValues) {
            ChangeListener[] ll;
            synchronized (this) {
                enums = allValues;
                valueMap = null;
                if (listeners == null) {
                    return;
                }
                ll = listeners.toArray(new ChangeListener[listeners.size()]);
            }
            ChangeEvent e = new ChangeEvent(this);
            for (int i = 0; i < ll.length; i++) {
                ll[i].stateChanged(e);
            }
        }
    }
    
    
    private R refreshMime(MimePath mime, R holder) {
        Lookup.Result<FoldTypeProvider> r;
        Lookup.Result<FoldTypeProvider> pr = null;

        if (holder == null) {
            r = MimeLookup.getLookup(mime).lookup(
                    new Lookup.Template(
                        FoldTypeProvider.class
                    )
            );
            // get the inherited MimePaths:
            String parentMime = mime.getInheritedType();
            if (LOG.isLoggable(Level.FINER)) {
                LOG.finer("Get providers for " + mime + ", parent " + parentMime);
            }
            if (parentMime != null) {
                pr = MimeLookup.getLookup(parentMime).lookup(
                        new Lookup.Template(
                            FoldTypeProvider.class
                        )
                );
            }
        } else {
            r = holder.result;
            pr = holder.result2;
        }
        
        
        Collection<? extends FoldTypeProvider> providers = r.allInstances();
        Collection<? extends FoldTypeProvider> parentProvs = pr == null ? Collections.<FoldTypeProvider>emptySet() : pr.allInstances();
        
        for (Iterator<? extends FoldTypeProvider> it = parentProvs.iterator(); it.hasNext(); ) {
            FoldTypeProvider p = it.next();
            if (p.inheritable()) {
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.log(Level.FINER, "Inheritable: " + p);
                }
                // leave only providers, which are !inheritable, so they'll be ignored.
                it.remove();
            }
        }
        
        Set<FoldType> allValues = new LinkedHashSet<FoldType>();
        
        for (FoldTypeProvider p : providers) {
            if (parentProvs.contains(p)) {
                if (LOG.isLoggable(Level.FINER)) {
                    LOG.log(Level.FINER, "Removing not inheritable: " + p);
                }
                // provider registered for parent, but inheritance is disallowed.
                continue;
            }
            
            Collection<FoldType> vals = p.getValues(enumType);
            if (vals != null) {
                // check that none enum overrides another one
                allValues.addAll(vals);
            }
        }
        
        boolean register = holder == null;
        if (holder == null) {
            holder = new R(this, mime, r, pr);
        }
        // sync
        holder.reset(allValues);

        if (register) {
            synchronized(enums) {
                R oldHolder = enums.put(mime, holder);
                if (oldHolder != null) {
                    // unlikely, but can happen.
                    enums.put(mime, oldHolder);
                    holder = oldHolder;
                }
            }
        }
        return holder;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.text.JTextComponent;
import org.netbeans.modules.editor.lib2.view.DocumentView;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;

/**
 * Component that displays a collapsed fold preview.
 *
 * @author Miloslav Metelka
 */
public class FoldToolTip extends JPanel {
    private int editorPaneWidth;

    public FoldToolTip(JEditorPane editorPane, final JEditorPane foldPreviewPane, Color borderColor) {
        setLayout(new BorderLayout());
        add(foldPreviewPane, BorderLayout.CENTER);
        putClientProperty("tooltip-type", "fold-preview"); // Checked in NbToolTip

        addGlyphGutter(foldPreviewPane);
        
        addAncestorListener(new AncestorListener() {
            @Override
            public void ancestorAdded(AncestorEvent event) {
            }

            @Override
            public void ancestorRemoved(AncestorEvent event) {
                // Deactivate the view hierarchy immediately for foldPreviewPane
                final DocumentView docView = DocumentView.get(foldPreviewPane);
                if (docView != null) {
                    docView.runTransaction(new Runnable() {
                        @Override
                        public void run() {
                            docView.updateLengthyAtomicEdit(+100); // Effectively disable any VH updates
                        }
                    });
                }
                // Remove the listener
                FoldToolTip.this.removeAncestorListener(this);
            }

            @Override
            public void ancestorMoved(AncestorEvent event) {
            }
        });

        editorPaneWidth = editorPane.getSize().width;

        setBorder(new LineBorder(borderColor));
        setOpaque(true);
    }
    
    private void addGlyphGutter(JTextComponent jtx) {
        ClassLoader cls = Lookup.getDefault().lookup(ClassLoader.class);
        Class clazz;
        Class editorUiClass;
        
        JComponent gutter = null;
        try {
            clazz = Class.forName("org.netbeans.editor.GlyphGutter", true, cls); // NOI18N
            editorUiClass = Class.forName("org.netbeans.editor.EditorUI", true, cls); // NOI18N
            // get the factory instance
            Object o = clazz.newInstance();
            Method m = clazz.getDeclaredMethod("createSideBar", JTextComponent.class); // NOI18N
            gutter = (JComponent)m.invoke(o, jtx);
        } catch (IllegalArgumentException ex) {
            Exceptions.printStackTrace(ex);
        } catch (InvocationTargetException ex) {
            Exceptions.printStackTrace(ex);
        } catch (NoSuchMethodException ex) {
            Exceptions.printStackTrace(ex);
        } catch (SecurityException ex) {
            Exceptions.printStackTrace(ex);
        } catch (InstantiationException ex) {
            Exceptions.printStackTrace(ex);
        } catch (IllegalAccessException ex) {
            Exceptions.printStackTrace(ex);
        } catch (ClassNotFoundException ex) {
            Exceptions.printStackTrace(ex);
        }
        if (gutter != null) {
            add(gutter, BorderLayout.WEST);
        }
    }

    @Override
    public Dimension getPreferredSize() {
        Dimension prefSize = super.getPreferredSize();
        // Return width like for editor pane which forces the PopupManager to display
        // the tooltip to align exacty with the text (below/above).
        prefSize.width = Math.min(prefSize.width, editorPaneWidth);
        return prefSize;
    }

}




import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.text.AbstractDocument;
import javax.swing.text.Document;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldStateChange;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;

/**
 * Implementations of methods from {@link org.netbeans.api.editor.fold.FoldUtilities}.

 */

public final class FoldUtilitiesImpl {
    /**
     * Prefix used for initial-collapse folding preferences.
     */
    public static final String PREF_COLLAPSE_PREFIX = "code-folding-collapse-";
    
    /**
     * Preference key name for "use defaults" (default: true)
     */
    public static final String PREF_OVERRIDE_DEFAULTS = "code-folding-use-defaults"; // NOI18N
    
    /**
     * Preference key name for enable code folding (default: true)
     */
    public static final String PREF_CODE_FOLDING_ENABLED = "code-folding-enable"; // NOI18N
    
    /**
     * Preference key for "Content preview" display option (default: true).
     */
    public static final String PREF_CONTENT_PREVIEW = "code-folding-content.preview"; // NOI18N

    /**
     * Preference key for "Show summary" display option (default: true).
     */
    public static final String PREF_CONTENT_SUMMARY = "code-folding-content.summary"; // NOI18N
    
    private FoldUtilitiesImpl() {
        // No instances
    }
    
    public static boolean isFoldingEnabled(String mime) {
        Preferences prefs = MimeLookup.getLookup(mime).lookup(Preferences.class);
        return prefs == null ? false : prefs.getBoolean(PREF_CODE_FOLDING_ENABLED, false);
    }
    
    public static boolean isFoldingEnabled(FoldHierarchy h) {
        Preferences p = ApiPackageAccessor.get().foldGetExecution(h).getFoldPreferences();
        return p.getBoolean(PREF_CODE_FOLDING_ENABLED, false);
    }

    public static boolean isAutoCollapsed(FoldType ft, FoldHierarchy h) {
        Preferences p = ApiPackageAccessor.get().foldGetExecution(h).getFoldPreferences();
        FoldType parent = ft.parent();
        return p.getBoolean(
            PREF_COLLAPSE_PREFIX + ft.code(),
            parent == null ? 
                false : 
                // search for the parent, if parent is defined.
                p.getBoolean(PREF_COLLAPSE_PREFIX + parent.code(), false)
        );
    }
    
    public static void collapseOrExpand(FoldHierarchy hierarchy, Collection foldTypes,
    boolean collapse) {





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold;

import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.font.FontRenderContext;
import java.awt.font.TextHitInfo;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
import java.util.logging.Logger;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import javax.swing.text.Position.Bias;
import javax.swing.text.StyleConstants;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.modules.editor.lib2.view.EditorView;
import org.netbeans.modules.editor.lib2.view.ViewRenderContext;
import org.netbeans.modules.editor.lib2.view.ViewUtils;

/**
 * View with highlights. This is the most used view.
 *
 * @author Miloslav Metelka
 */

public class FoldView extends EditorView {

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

    /**
     * Extra space added to each side of description text of a fold view.
     */
    private static final float EXTRA_MARGIN_WIDTH = 3;

    /** Raw end offset of this view. */
    private int rawEndOffset; // 24-super + 4 = 28 bytes

    /** Length of text occupied by this view. */
    private int length; // 28 + 4 = 32 bytes

    private final JTextComponent textComponent; // 32 + 4 = 36 bytes

    private final Fold fold; // 36 + 4 = 40 bytes
    
    private TextLayout collapsedTextLayout; // 40 + 4 = 44 bytes
    
    private AttributeSet    foldingColors;

    public FoldView(JTextComponent textComponent, Fold fold, FontColorSettings colorSettings) {
        super(null);
        int offset = fold.getStartOffset();
        int len = fold.getEndOffset() - offset;
        assert (len > 0) : "length=" + len + " <= 0"; // NOI18N
        this.length = len;
        this.textComponent = textComponent;
        this.fold = fold;
        this.foldingColors = colorSettings.getFontColors(FontColorNames.CODE_FOLDING_COLORING);
    }

    @Override
    public float getPreferredSpan(int axis) {
        TextLayout textLayout = getTextLayout();
        if (textLayout == null) {
            return 0f;
        }
        String desc = fold.getDescription(); // For empty desc a single-space text layout is returned
        if (axis == View.X_AXIS) {
            return ((desc.length() > 0) ? textLayout.getAdvance() : 0) 
                + (2 * EXTRA_MARGIN_WIDTH);
        } else {
            EditorView.Parent parent = (EditorView.Parent) getParent();
            return (parent != null) ? parent.getViewRenderContext().getDefaultRowHeight() : 0f;
        }
    }

    @Override
    public int getRawEndOffset() {
        return rawEndOffset;
    }

    @Override
    public void setRawEndOffset(int rawOffset) {
        this.rawEndOffset = rawOffset;
    }

    @Override
    public int getLength() {
        return length;
    }

    @Override
    public int getStartOffset() {
        return getEndOffset() - getLength();
    }

    @Override
    public int getEndOffset() {
        EditorView.Parent parent = (EditorView.Parent) getParent();
        return (parent != null) ? parent.getViewEndOffset(rawEndOffset) : rawEndOffset;
    }

    @Override
    public Document getDocument() {
        View parent = getParent();
        return (parent != null) ? parent.getDocument() : null;
    }

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

    private TextLayout getTextLayout() {
        if (collapsedTextLayout == null) {
            EditorView.Parent parent = (EditorView.Parent) getParent();
            ViewRenderContext context = parent.getViewRenderContext();
            FontRenderContext frc = context.getFontRenderContext();
            assert (frc != null) : "Null FontRenderContext"; // NOI18N
            Font font = context.getRenderFont(textComponent.getFont());
            String text = fold.getDescription();
            if (text.length() == 0) {
                text = " "; // Use single space (mainly for height measurement etc.
            }
            collapsedTextLayout = new TextLayout(text, font, frc);
        }
        return collapsedTextLayout;
    }

    @Override
    public Shape modelToViewChecked(int offset, Shape alloc, Position.Bias bias) {
//        TextLayout textLayout = getTextLayout();
//        if (textLayout == null) {
//            return alloc; // Leave given bounds
//        }
//        Rectangle2D.Double bounds = ViewUtils.shape2Bounds(alloc);
//        return bounds;
        return alloc;
    }

    @Override
    public int viewToModelChecked(double x, double y, Shape alloc, Position.Bias[] biasReturn) {
        int startOffset = getStartOffset();
        return startOffset;
    }

    static TextHitInfo x2RelOffset(TextLayout textLayout, float x) {
        TextHitInfo hit;
        x -= EXTRA_MARGIN_WIDTH;
        if (x >= textLayout.getAdvance()) {
            hit = TextHitInfo.trailing(textLayout.getCharacterCount());
        } else {
            hit = textLayout.hitTestChar(x, 0); // What about backward bias -> with higher offsets it may go back visually
        }
        return hit;

    }

    @Override
    public int getNextVisualPositionFromChecked(int offset, Bias bias, Shape alloc, int direction, Bias[] biasRet) {
        int startOffset = getStartOffset();
        int retOffset = -1;
        switch (direction) {
            case WEST:
                if (offset == -1) {
                    retOffset = startOffset;
                } else {
                    retOffset = -1;
                }
                break;

            case EAST:
                if (offset == -1) {
                    retOffset = startOffset;
                } else {
                    retOffset = -1;
                }
                break;

            case NORTH:
            case SOUTH:
                break;
            default:
                throw new IllegalArgumentException("Bad direction: " + direction);
        }
        return retOffset;
    }

    @Override
    public JComponent getToolTip(double x, double y, Shape allocation) {
        Container container = getContainer();
        if (container instanceof JEditorPane) {
            JEditorPane editorPane = (JEditorPane) getContainer();
            JEditorPane tooltipPane = new JEditorPane();
            EditorKit kit = editorPane.getEditorKit();
            Document doc = getDocument();
            if (kit != null && doc != null) {
                Element lineRootElement = doc.getDefaultRootElement();
                tooltipPane.putClientProperty(FoldViewFactory.VIEW_FOLDS_EXPANDED_PROPERTY, true);
                try {
                    // Start-offset of the fold => line start => position
                    int lineIndex = lineRootElement.getElementIndex(fold.getStartOffset());
                    Position pos = doc.createPosition(
                            lineRootElement.getElement(lineIndex).getStartOffset());
                    // DocumentView.START_POSITION_PROPERTY
                    tooltipPane.putClientProperty("document-view-start-position", pos);
                    // End-offset of the fold => line end => position
                    lineIndex = lineRootElement.getElementIndex(fold.getEndOffset());
                    pos = doc.createPosition(lineRootElement.getElement(lineIndex).getEndOffset());
                    // DocumentView.END_POSITION_PROPERTY
                    tooltipPane.putClientProperty("document-view-end-position", pos);
                    tooltipPane.putClientProperty("document-view-accurate-span", true);
                    // Set the same kit and document
                    tooltipPane.setEditorKit(kit);
                    tooltipPane.setDocument(doc);
                    tooltipPane.setEditable(false);
                    return new FoldToolTip(editorPane, tooltipPane, getForegroundColor());
                } catch (BadLocationException e) {
                    // => return null
                }
            }
        }
        return null;
    }
    
    private Color getForegroundColor() {
        if (foldingColors == null) {
            return textComponent.getForeground();
        }
        Object bgColorObj = foldingColors.getAttribute(StyleConstants.Foreground);
        if (bgColorObj instanceof Color) {
            return (Color)bgColorObj;
        } else {
            return textComponent.getForeground();
        }
    }

    private Color getBackgroundColor() {
        if (foldingColors == null) {
            return textComponent.getBackground();
        }
        Object bgColorObj = foldingColors.getAttribute(StyleConstants.Background);
        if (bgColorObj instanceof Color) {
            return (Color)bgColorObj;
        } else {
            return textComponent.getBackground();
        }
    }

    @Override
    public void paint(Graphics2D g, Shape alloc, Rectangle clipBounds) {
        Rectangle2D.Double allocBounds = ViewUtils.shape2Bounds(alloc);
        if (allocBounds.intersects(clipBounds)) {
            Font origFont = g.getFont();
            Color origColor = g.getColor();
            Color origBkColor = g.getBackground();
            Shape origClip = g.getClip();
            try {
                // Leave component font
                g.setColor(getForegroundColor());
                g.setBackground(getBackgroundColor());

                int xInt = (int) allocBounds.getX();
                int yInt = (int) allocBounds.getY();
                int endXInt = (int) (allocBounds.getX() + allocBounds.getWidth() - 1);
                int endYInt = (int) (allocBounds.getY() + allocBounds.getHeight() - 1);
                g.drawRect(xInt, yInt, endXInt - xInt, endYInt - yInt);
                g.clearRect(xInt + 1, yInt + 1, endXInt - xInt - 1, endYInt - yInt - 1);
                g.clip(alloc);
                TextLayout textLayout = getTextLayout();
                if (textLayout != null) {
                    EditorView.Parent parent = (EditorView.Parent) getParent();
                    float ascent = parent.getViewRenderContext().getDefaultAscent();
                    String desc = fold.getDescription(); // For empty desc a single-space text layout is returned
                    float x = (float) (allocBounds.getX() + EXTRA_MARGIN_WIDTH);
                    float y = (float) allocBounds.getY();
                    if (desc.length() > 0) {
                        
                        textLayout.draw(g, x, y + ascent);
                    }
                }
            } finally {
                g.setClip(origClip);
                g.setBackground(origBkColor);
                g.setColor(origColor);
                g.setFont(origFont);
            }
        }
    }

    @Override
    protected String getDumpName() {
        return "FV";
    }

    @Override
    public String toString() {
        return appendViewInfo(new StringBuilder(200), 0, "", -1).toString();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold;

import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.modules.editor.lib2.view.EditorView;
import org.netbeans.modules.editor.lib2.view.EditorViewFactory;
import org.netbeans.modules.editor.lib2.view.EditorViewFactoryChange;
import org.netbeans.modules.editor.lib2.view.ViewUtils;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.WeakListeners;

/**
 * View factory creating views for collapsed folds.
 *
 * @author Miloslav Metelka
 */

@SuppressWarnings("ClassWithMultipleLoggers")
public final class FoldViewFactory extends EditorViewFactory implements FoldHierarchyListener, LookupListener {

    /**
     * Component's client property which can be set to view folds expanded for tooltip fold preview.
     */
    static final String VIEW_FOLDS_EXPANDED_PROPERTY = "view-folds-expanded"; // NOI18N

    // -J-Dorg.netbeans.editor.view.change.level=FINE
    static final Logger CHANGE_LOG = Logger.getLogger("org.netbeans.editor.view.change");

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

    static void register() {
        EditorViewFactory.registerFactory(new FoldFactory());
    }

    private FoldHierarchy foldHierarchy;

    private boolean foldHierarchyLocked;

    private Fold fold;

    private int foldStartOffset;

    private Iterator<Fold> collapsedFoldIterator;

    private boolean viewFoldsExpanded;
    
    /**
     * Composite Color settings from MIME lookup
     */
    private FontColorSettings   colorSettings;

    /**
     * Lookup results for color settings, being listened for changes.
     */
    private Lookup.Result       colorSource;

    public FoldViewFactory(View documentView) {
        super(documentView);
        foldHierarchy = FoldHierarchy.get(textComponent());
        foldHierarchy.addFoldHierarchyListener(this);
        viewFoldsExpanded = Boolean.TRUE.equals(textComponent().getClientProperty(VIEW_FOLDS_EXPANDED_PROPERTY));
        
        String mime = DocumentUtilities.getMimeType(document());
        
        Lookup lkp = MimeLookup.getLookup(mime);
        colorSource = lkp.lookupResult(FontColorSettings.class);
        colorSource.addLookupListener(WeakListeners.create(LookupListener.class, this, colorSource));
        colorSettings = (FontColorSettings)colorSource.allInstances().iterator().next();
    }

    @Override
    public void resultChanged(LookupEvent ev) {
        refreshColors();
    }

    private void refreshColors() {
        colorSettings = (FontColorSettings)colorSource.allInstances().iterator().next();
        document().render(new Runnable() {
            @Override
            public void run() {
                int end = document().getLength();
                fireEvent(EditorViewFactoryChange.createList(0, end, EditorViewFactoryChange.Type.CHARACTER_CHANGE));
            }
        });
    }

    @Override
    public void restart(int startOffset, int endOffset, boolean createViews) {
        foldHierarchy.lock(); // this.finish() always called in try-finally
        foldHierarchyLocked = true;
        @SuppressWarnings("unchecked")
        Iterator<Fold> it = FoldUtilities.collapsedFoldIterator(foldHierarchy, startOffset, Integer.MAX_VALUE);
        collapsedFoldIterator = it;
        foldStartOffset = -1; // Make a next call to updateFold() to fetch a fold
    }

    private void updateFold(int offset) {
        if (foldStartOffset < offset) {
            while (collapsedFoldIterator.hasNext()) {
                fold = collapsedFoldIterator.next();
                foldStartOffset = fold.getStartOffset();
                if (foldStartOffset >= offset) {
                    return;
                }
            }
            fold = null;
            foldStartOffset = Integer.MAX_VALUE;
        }
    }

    @Override
    public int nextViewStartOffset(int offset) {
        if (!viewFoldsExpanded) {
            updateFold(offset);
            return foldStartOffset;
        }
        return Integer.MAX_VALUE;
    }

    @Override
    public EditorView createView(int startOffset, int limitOffset, boolean forcedLimit,
    EditorView origView, int nextOrigViewOffset) {
        assert (startOffset == foldStartOffset) : "startOffset=" + startOffset + " != foldStartOffset=" + foldStartOffset; // NOI18N
        if (fold.getEndOffset() <= limitOffset || !forcedLimit) {
            return new FoldView(textComponent(), fold, colorSettings);
        } else {
            return null;
        }
    }
    
    @Override
    public int viewEndOffset(int startOffset, int limitOffset, boolean forcedLimit) {
        int foldEndOffset = fold.getEndOffset();
        if (foldEndOffset <= limitOffset) {
            return foldEndOffset;
        } else {
            return -1;
        }
    }

    @Override
    public void continueCreation(int startOffset, int endOffset) {
    }

    @Override
    public void finishCreation() {
        fold = null;
        collapsedFoldIterator = null;
        if (foldHierarchyLocked) {
            foldHierarchy.unlock();
        }
    }

    @Override
    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
        // For fold state changes use a higher priority
        int startOffset = evt.getAffectedStartOffset();
        int endOffset = evt.getAffectedEndOffset();
        if (CHANGE_LOG.isLoggable(Level.FINE)) {
            ViewUtils.log(CHANGE_LOG, "CHANGE in FoldViewFactory: <" + // NOI18N
                    startOffset + "," + endOffset + ">\n"); // NOI18N
        }
        fireEvent(EditorViewFactoryChange.createList(startOffset, endOffset,
                EditorViewFactoryChange.Type.PARAGRAPH_CHANGE));
    }

    public static final class FoldFactory implements EditorViewFactory.Factory {

        @Override
        public EditorViewFactory createEditorViewFactory(View documentView) {
            return new FoldViewFactory(documentView);
        }

        @Override
        public int weight() {
            return 100;
        }

    }

}




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

import java.awt.Rectangle;
import java.util.concurrent.Callable;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldStateChange;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.editor.BaseCaret;

/**
 * Provides adjustments to functions of editor component
 * based on folding operations.
 * This code was originally part of editor.lib, in BaseCaret class.
 * 
 * @author sdedic
 */
class FoldingEditorSupport implements Callable, FoldHierarchyListener {
    private static final Logger LOG = Logger.getLogger(FoldingEditorSupport.class.getName());
    
    /**
     * Component where the folding takes place
     */
    private final JTextComponent component;
    
    /**
     * Fold hierarchy
     */
    private final FoldHierarchy foldHierarchy;
    
    FoldingEditorSupport(FoldHierarchy h, JTextComponent component) {
        this.component = component;
        this.foldHierarchy = h;
        component.putClientProperty("org.netbeans.api.fold.expander", this);
        foldHierarchy.addFoldHierarchyListener(this);
    }
    
    /**
     * Callable that autoexpands place with caret.
     * The Callable is called from the BaseCaret. Since 
     * @return 
     */
    public Boolean call() {
        final Document doc = component.getDocument();
        final Boolean[] res = new Boolean[] { false };
        doc.render(new Runnable() {
            public void run() {
                foldHierarchy.lock();
                try {
                    int offset = component.getCaret().getDot();
                    Fold f = FoldUtilities.findCollapsedFold(foldHierarchy, offset, offset);
                    if (f != null) {
                        foldHierarchy.expand(f);
                        res[0] = true;
                    }
                } finally {
                    foldHierarchy.unlock();
                }
            }
        });
        return res[0];
    }

    public @Override void foldHierarchyChanged(FoldHierarchyEvent evt) {
        if (!(component.getCaret() instanceof BaseCaret)) {
            return;
        }
        int caretOffset = component.getCaret().getDot();
        final int addedFoldCnt = evt.getAddedFoldCount();
        final boolean scrollToView;
        LOG.finest("Received fold hierarchy change");
        if (addedFoldCnt > 0) {
            FoldHierarchy hierarchy = (FoldHierarchy) evt.getSource();
            Fold collapsed = null;
            boolean wasExpanded = false;
            while ((collapsed = FoldUtilities.findCollapsedFold(hierarchy, caretOffset, caretOffset)) != null && collapsed.getStartOffset() < caretOffset &&
                    collapsed.getEndOffset() > caretOffset) {
                        hierarchy.expand(collapsed);
                        wasExpanded = true;
            }
            // prevent unneeded scrolling; the user may have scrolled out using mouse already
            // so scroll only if the added fold may affect Y axis. Actually it's unclear why
            // we should reveal the current position on fold events except when caret is positioned in now-collapsed fold
            scrollToView = wasExpanded;
        } else {
            int startOffset = Integer.MAX_VALUE;
            // Set the caret's offset to the end of just collapsed fold if necessary
            if (evt.getAffectedStartOffset() <= caretOffset && evt.getAffectedEndOffset() >= caretOffset) {
                for (int i = 0; i < evt.getFoldStateChangeCount(); i++) {
                    FoldStateChange change = evt.getFoldStateChange(i);
                    if (change.isCollapsedChanged()) {
                        Fold fold = change.getFold();
                        if (fold.isCollapsed() && fold.getStartOffset() <= caretOffset && fold.getEndOffset() >= caretOffset) {
                            if (fold.getStartOffset() < startOffset) {
                                startOffset = fold.getStartOffset();
                            }
                        }
                    }
                }
                if (startOffset != Integer.MAX_VALUE) {
                    ((BaseCaret)component.getCaret()).setDot(startOffset, false);
                }
            }
            scrollToView = false;
        }
        // Update caret's visual position
        // Post the caret update asynchronously since the fold hierarchy is updated before
        // the view hierarchy and the views so the dispatchUpdate() could be picking obsolete
        // view information.
        if (addedFoldCnt > 1 || scrollToView) {
            SwingUtilities.invokeLater(new Runnable() {
                public @Override void run() {
                    LOG.finest("Updating after fold hierarchy change");
                    if (component == null) {
                        return;
                    }
                    ((BaseCaret)component.getCaret()).refresh(addedFoldCnt > 1 && !scrollToView);
                }
            });
        }
    }
    
}




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

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Utilities;
import org.netbeans.lib.editor.util.CharSequenceUtilities;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.spi.editor.fold.ContentReader;

    
/**
 * The class will read the contents of the document starting after the fold's guarded start.
 * It will produce text found on the first non-blank line fully contained within the fold. During
 * the search, the Readed ignores leading whitespaces on a line followed by 'lineStartMarker' string.
 * <p/>
 * For example, if lineStartMarker is set to '*', it will ignore stars at the beginning of the Javadoc, 
 * so it will produce the overwiew sentence, although it typically starts at the 2nd javadoc line. If
 * the 'lineStartMarker' is set to "#", it will produce 1st line of a consecutive line comment block.
 * <p/>
 * The Reader will stop reading the content on line starting with a 'stopPattern'. For javadoc, lines 
 * that start with @tag will stop the reading.
 * <p/>
 * So, for Javadocs, the configuration will look like:
 * <code>
 * <pre>
 * ContentReader rd = new JavadocReader("*", "\.", "@");
 * </pre>
 * </code>
 * 
 * 
 */
public final class JavadocReader implements ContentReader {
    /**
     * The marker, which may (should!) be present at the start of the line
     */
    private final String lineStartMarker; 

    /**
     * Ignore contents after this pattern
     */
    private final Pattern stopPattern;
    
    private final Pattern termPattern;
    
    private final String prefix;
    
    public JavadocReader(String lineStartMarker, String terminator, String stopPattern, String prefix) {
        this.lineStartMarker = lineStartMarker;
        this.termPattern = terminator != null ? Pattern.compile(terminator) : null;
        this.stopPattern = stopPattern != null ? Pattern.compile(stopPattern, Pattern.CASE_INSENSITIVE) : null;
        this.prefix = prefix == null ? " " : prefix; // NOI18N
    }

    @Override
    public CharSequence read(Document d, Fold f, FoldTemplate ft) throws BadLocationException {
        int contentStart = f.getGuardedStart();
        int contentEnd = f.getGuardedEnd();
        BaseDocument bd = (BaseDocument)d;
        
        int rowStart = contentStart;

        while (rowStart < contentEnd) {
            int nextRow = Utilities.getRowStart(bd, rowStart, 1);
            if (nextRow == -1 || nextRow > contentEnd) {
                nextRow = contentEnd;
            }
            int nonWhite = Utilities.getFirstNonWhiteFwd(bd, rowStart, nextRow);
            // check if the nonwhite content matches the lineStartMarker
            if (nonWhite != -1 && 
                lineStartMarker != null &&
                CharSequenceUtilities.textEquals(DocumentUtilities.getText(d, nonWhite, lineStartMarker.length()), lineStartMarker)) {
                nonWhite = Utilities.getFirstNonWhiteFwd(bd, nonWhite + lineStartMarker.length(), nextRow);
            }
            if (nonWhite != -1) {
                // found a non-whitespace
                int endIndex = Utilities.getFirstNonWhiteBwd(bd, nextRow, nonWhite);
                if (endIndex < nextRow) {
                    endIndex++;
                }
                CharSequence ret = DocumentUtilities.getText(d, nonWhite, endIndex - nonWhite);
                if (stopPattern != null && stopPattern.matcher(ret).lookingAt()) {
                    return null;
                }
                int idx = -1;
                if (termPattern != null) {
                    Matcher m = termPattern.matcher(ret);
                    if (m.find()) {
                        idx = m.start();
                    }
                }
                if (idx > -1) {
                    return prefix + DocumentUtilities.getText(d, nonWhite, idx);
                } else {
                    return prefix + ret;
                }
            }
            rowStart = nextRow;
        }
        return null;
    }
}




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

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;

/**
 * The class is responsible for syncing legacy setting keys in the
 * default ("") mimetype. It is also responsible for erasing 
 * folds from a MIME, if the setting for 'override' is not set. This will
 * gradually clean up migrated settings.
 * 
 * @author sdedic
 */
class LegacySettingsSync implements PreferenceChangeListener {
    private static LegacySettingsSync INSTANCE;
    
    private Reference<Preferences> defaultMimePrefs;
    
    synchronized static LegacySettingsSync get() {
        if (INSTANCE == null) {
            INSTANCE = new LegacySettingsSync();
        }
        return INSTANCE;
    }
    
    synchronized Preferences processMime(String mime) {
        Preferences prefs = MimeLookup.getLookup(mime).lookup(Preferences.class);
        if ("".equals(mime)) { // NOI18N
            Preferences p = defaultMimePrefs == null ? null : defaultMimePrefs.get();
            if (p == prefs) {
                return prefs;
            } else if (p != null) {
                p.removePreferenceChangeListener(this);
            }
            // sync the default values for legacy code
            syncKey(FoldType.MEMBER.code(), prefs);
            syncKey(FoldType.NESTED.code(), prefs);
            syncKey(FoldType.DOCUMENTATION.code(), prefs);
            defaultMimePrefs = new WeakReference(prefs);
            // no weak listener, this instance lives forever, but the defaultMimePrefs
            // reference allows the pref to expire.
            prefs.addPreferenceChangeListener(this);
        } else {
            if (!((prefs instanceof OverridePreferences) && ((OverridePreferences)prefs).isOverriden(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS))) {
                return prefs;
            } 
            boolean state = prefs.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, false);
            if (!state) {
                cleanupPreferences(mime, prefs);
            } else {
                clonePreferences(mime, prefs);
            }
        }
        return prefs;
    }

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        if (evt.getKey() == null || !evt.getKey().startsWith(FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX)) {
            return;
        }
        String k = evt.getKey().substring(FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX.length());
        syncKey(k, evt.getNode());
    }
    
    private void syncKey(String k, Preferences pref) {
        String l;
        if (FoldType.MEMBER.code().equals(k)) {
            l = "method"; // NOI18N
        } else if (FoldType.NESTED.code().equals(k)) {
            l = "innerclass"; // NOI18N
        } else if (FoldType.DOCUMENTATION.code().equals(k)) {
            l = "javadoc"; // NOI18N
        } else {
            return;
        }
        String syncKey = FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + l;
        pref.putBoolean(syncKey, pref.getBoolean(
                FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + k, false));
    }
    
    private void clonePreferences(String mime, Preferences pref) {
        Collection<? extends FoldType> types = FoldUtilities.getFoldTypes(mime).values();
        for (FoldType ft : types) {
            String key = FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + ft.code();
            if (!isDefinedLocally(pref, key)) {
                boolean val = pref.getBoolean(key, 
                    ft.parent() == null ? false :
                    pref.getBoolean(FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + ft.parent().code(), false));
                pref.putBoolean(key, val);
            }
        }
    }
    
    private boolean isDefinedLocally(Preferences pref, String key) {
        return pref instanceof OverridePreferences && 
                ((OverridePreferences)pref).isOverriden(key);
    }
    
    private void cleanupPreferences(String mime, Preferences pref) {
        Collection<? extends FoldType> types = FoldUtilities.getFoldTypes(mime).values();
        for (FoldType ft : types) {
            String key = FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + ft.code();
            if (isDefinedLocally(pref, key)) {
                pref.remove(key);
            }
        }
    }
}




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

import java.awt.event.ActionEvent;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.editor.BaseAction;
import org.netbeans.editor.BaseKit;

/**
 * Factory for editor code folding actions.
 * Migrated from editor.lib module
 *
 * @author sdedic
 */
final class ActionFactory {
    
    /** Returns the fold that should be collapsed/expanded in the caret row
     *  @param hierarchy hierarchy under which all folds should be collapsed/expanded.
     *  @param dot caret position offset
     *  @param lineStart offset of the start of line
     *  @param lineEnd offset of the end of line
     *  @return the fold that meet common criteria in accordance with the caret position
     */
    private static Fold getLineFold(FoldHierarchy hierarchy, int dot, int lineStart, int lineEnd){
        Fold caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, dot);

        // beginning searching from the lineStart
        Fold fold = FoldUtilities.findNearestFold(hierarchy, lineStart);  
        
        while (fold!=null && 
                  (fold.getEndOffset()<=dot || // find next available fold if the 'fold' is one-line
                      // or it has children and the caret is in the fold body
                      // i.e. class A{ |public void method foo(){}}
                      (!fold.isCollapsed() && fold.getFoldCount() > 0  && fold.getStartOffset()+1<dot) 
                   )
               ){

                   // look for next fold in forward direction
                   Fold nextFold = FoldUtilities.findNearestFold(hierarchy,
                       (fold.getFoldCount()>0) ? fold.getStartOffset()+1 : fold.getEndOffset());
                   if (nextFold!=null && nextFold.getStartOffset()<lineEnd){
                       if (nextFold == fold) return fold;
                       fold = nextFold;
                   }else{
                       break;
                   }
        }

        
        // a fold on the next line was found, returning fold at offset (in most cases inner class)
        if (fold == null || fold.getStartOffset()>lineEnd) {

            // in the case:
            // class A{
            // }     |
            // try to find an offset fold on the offset of the line beginning
            if (caretOffsetFold == null){
                caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, lineStart);
            }
            
            return caretOffsetFold;
        }
        
        // no fold at offset found, in this case return the fold
        if (caretOffsetFold == null) return fold;
        
        // skip possible inner class members validating if the innerclass fold is collapsed
        if (caretOffsetFold.isCollapsed()) return caretOffsetFold;
        
        // in the case:
        // class A{
        // public vo|id foo(){} }
        // 'fold' (in this case fold of the method foo) will be returned
        if ( caretOffsetFold.getEndOffset()>fold.getEndOffset() && 
             fold.getEndOffset()>dot){
            return fold;
        }
        
        // class A{
        // |} public void method foo(){}
        // inner class fold will be returned
        if (fold.getStartOffset()>caretOffsetFold.getEndOffset()) return caretOffsetFold;
        
        // class A{
        // public void foo(){} |}
        // returning innerclass fold
        if (fold.getEndOffset()<dot) return caretOffsetFold;
        
        return fold;
    }
    
    /** Collapse a fold. Depends on the current caret position. */
    @EditorActionRegistration(name = BaseKit.collapseFoldAction,
            menuText = "#" + BaseKit.collapseFoldAction + "_menu_text")
    public static class CollapseFold extends LocalBaseAction {
        public CollapseFold(){
        }
        
        private boolean dotInFoldArea(JTextComponent target, Fold fold, int dot) throws BadLocationException{
            int foldStart = fold.getStartOffset();
            int foldEnd = fold.getEndOffset();
            int foldRowStart = javax.swing.text.Utilities.getRowStart(target, foldStart);
            int foldRowEnd = javax.swing.text.Utilities.getRowEnd(target, foldEnd);
            if (foldRowStart > dot || foldRowEnd < dot) return false; // it's not fold encapsulating dot
            return true;
            }

        
        public void actionPerformed(ActionEvent evt, final JTextComponent target) {
            Document doc = target.getDocument();
            doc.render(new Runnable() {
                @Override
                public void run() {
                    FoldHierarchy hierarchy = FoldHierarchy.get(target);
                    int dot = target.getCaret().getDot();
                    hierarchy.lock();
                    try{
                        try{
                            int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
                            Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
                            fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
                            if (fold==null){
                                return; // no success
                            }
                            // ensure we' got the right fold
                            if (dotInFoldArea(target, fold, dot)){
                                hierarchy.collapse(fold);
                            }
                        }catch(BadLocationException ble){
                            ble.printStackTrace();
                        }
                    }finally {
                        hierarchy.unlock();
                    }
                }
            });
        }
    }
    
    /** Expand a fold. Depends on the current caret position. */
    @EditorActionRegistration(name = BaseKit.expandFoldAction,
            menuText = "#" + BaseKit.expandFoldAction + "_menu_text")
    public static class ExpandFold extends LocalBaseAction {
        public ExpandFold(){
        }
        
        public void actionPerformed(ActionEvent evt, final JTextComponent target) {
            Document doc = target.getDocument();
            doc.render(new Runnable() {
                @Override
                public void run() {
                    FoldHierarchy hierarchy = FoldHierarchy.get(target);
                    int dot = target.getCaret().getDot();
                    hierarchy.lock();
                    try {
                        try {
                            int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
                            Fold fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
                            if (fold != null) {
                                hierarchy.expand(fold);
                            }
                        } catch (BadLocationException ble) {
                            ble.printStackTrace();
                        }
                    } finally {
                        hierarchy.unlock();
                    }
                }
            });
        }
    }
    
    /** Collapse all existing folds in the document. */
    @EditorActionRegistration(name = BaseKit.collapseAllFoldsAction,
            menuText = "#" + BaseKit.collapseAllFoldsAction + "_menu_text")
    public static class CollapseAllFolds extends LocalBaseAction {
        public CollapseAllFolds(){
        }
        
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            FoldHierarchy hierarchy = FoldHierarchy.get(target);
            // Hierarchy locking done in the utility method
            FoldUtilities.collapseAll(hierarchy);
        }
    }

    /** Expand all existing folds in the document. */
    @EditorActionRegistration(name = BaseKit.expandAllFoldsAction,
            menuText = "#" + BaseKit.expandAllFoldsAction + "_menu_text")
    public static class ExpandAllFolds extends LocalBaseAction {
        public ExpandAllFolds(){
        }
        
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            FoldHierarchy hierarchy = FoldHierarchy.get(target);
            // Hierarchy locking done in the utility method
            FoldUtilities.expandAll(hierarchy);
        }
    }


    private static abstract class LocalBaseAction extends BaseAction {
        public LocalBaseAction() {
            super();
        }

        @Override
        protected Class getShortDescriptionBundleClass() {
            return BaseKit.class;
        }

    }
}




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

# CodeFoldingSideBar
ACSN_CodeFoldingSideBar=Code folding side bar
ACSD_CodeFoldingSideBar=Code folding side bar shows text folds and allows their collapsing and expanding.

collapse-all-folds_menu_text=Co&llapse All
collapse-fold_menu_text=&Collapse Fold
expand-all-folds_menu_text=E&xpand All
expand-fold_menu_text=&Expand Fold
collapse-all-folds=Collapse All
collapse-fold=Collapse Fold
expand-all-folds=Expand All
expand-fold=Expand Fold

CTL_OptionsDisplayName=Folding
KW_Options=Fold
FoldOptionsPanel.langLabel.text=Language:
TITLE_ElementsToCollapse=Collapse by default
FoldOptionsPanel.enableFolds.text=Enable Code Folding
DefaultFoldingOptions.useDefaults.text=Override default settings
DefaultFoldingOptions.collapseContainer.border.title=Collapse by default
FoldOptionsPanel.contentPreview.text=Content preview
FoldOptionsPanel.foldedSummary.text=Show summary
Title_FoldDisplayOptions=Display Options
FMT_ContentPlaceholder_1={0}...
FMT_ContentPlaceholder_2=...{1} 
FMT_ContentPlaceholder_3={0} ...{1} 
FoldOptionsPanel.useDefaults.text=Use Default Settings




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

package org.netbeans.modules.editor.fold.ui;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.accessibility.AccessibleRole;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.BaseDocumentEvent;
import org.netbeans.editor.BaseTextUI;
import org.netbeans.editor.Coloring;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.SideBarFactory;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.fold.ApiPackageAccessor;
import org.netbeans.modules.editor.fold.FoldHierarchyExecution;
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
import org.netbeans.modules.editor.lib2.view.LockedViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ParagraphViewDescriptor;
import org.netbeans.modules.editor.lib2.view.ViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyEvent;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyListener;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;

/**
 *  Code Folding Side Bar. Component responsible for drawing folding signs and responding 
 *  on user fold/unfold action.
 * <p/>
 * The class was copied/hidden from org.netbeans.editor.CodeFoldingSidebar. If any error is fixed here,
 * please fix it as well in {@link org.netbeans.editor.CodeFoldingSidebar} in this module for backward
 * compatibility with potential users.
 *
 *  @author  Martin Roskanin
 */
public final class CodeFoldingSideBar extends JComponent implements Accessible {
    public static final String PROP_SIDEBAR_MARK = "org.netbeans.editor.CodeFoldingSidebar"; // NOI18N
    
    private static final Logger LOG = Logger.getLogger(CodeFoldingSideBar.class.getName());

    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color backColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color foreColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Font font;
    
    /** This field should be treated as final. Subclasses are forbidden to change it. */
    protected /*final*/ JTextComponent component;
    private volatile AttributeSet attribs;
    private Lookup.Result<? extends FontColorSettings> fcsLookupResult;
    private final LookupListener fcsTracker = new LookupListener() {
        public void resultChanged(LookupEvent ev) {
            attribs = null;
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    //EMI: This is needed as maybe the DEFAULT_COLORING is changed, the font is different
                    // and while getMarkSize() is used in paint() and will make the artifacts bigger,
                    // the component itself will be the same size and it must be changed.
                    // See http://www.netbeans.org/issues/show_bug.cgi?id=153316
                    updatePreferredSize();
                    CodeFoldingSideBar.this.repaint();
                }
            });
        }
    };
    private final Listener listener = new Listener();
    
    private boolean enabled = false;
    
    protected List<Mark> visibleMarks = new ArrayList<Mark>();
    
    /**
     * Mouse moved point, possibly {@code null}. Set from mouse-moved, mouse-entered
     * handlers, so that painting will paint this fold in bold. -1, if mouse is not
     * in the sidebar region. The value is used to compute highlighted portions of the 
     * folding outline.
     */
    private int   mousePoint = -1;
    
    /**
     * if true, the {@link #mousePoint} has been already used to make a PaintInfo active.
     * The flag is tested by {@link #traverseForward} and {@link #traverseBackward} after children
     * of the current fold are processed and cleared if the {@link #mousePoint} falls to the fold area -
     * fields of PaintInfo are set accordingly.
     * It's also used to compute (current) mouseBoundary, so mouse movement does not trigger 
     * refreshes eagerly
     */
    private boolean mousePointConsumed;
    
    /**
     * Boundaries of the current area under the mouse. Can be eiher the span of the
     * current fold (or part of it), or the span not occupied by any fold. Serves as an optimization
     * for mouse handler, which does not trigger painting (refresh) unless mouse 
     * leaves this region.
     */
    private Rectangle   mouseBoundary;
    
    /**
     * Y-end of the nearest fold that ends above the {@link #mousePoint}. Undefined if mousePoint is null.
     * These two variables are initialized at each level of folds, and help to compute {@link #mouseBoundary} for
     * the case the mousePointer is OUTSIDE all children (or outside all folds). 
     */
    private int lowestAboveMouse = -1;

    /**
     * Y-begin of the nearest fold, which starts below the {@link #mousePoint}. Undefined if mousePoint is null
     */
    private int topmostBelowMouse = Integer.MAX_VALUE;
    
    private boolean alreadyPresent;
    
    /** Paint operations */
    public static final int PAINT_NOOP             = 0;
    /**
     * Normal opening +- marker
     */
    public static final int PAINT_MARK             = 1;
    
    /**
     * Vertical line - typically at the end of the screen
     */
    public static final int PAINT_LINE             = 2;
    
    /**
     * End angled line, without a sign
     */
    public static final int PAINT_END_MARK         = 3;
    
    /**
     * Single-line marker, both start and end
     */
    public static final int SINGLE_PAINT_MARK      = 4;
    
    /**
     * Marker value for {@link #mousePoint} indicating that mouse is outside the Component.
     */
    private static final int NO_MOUSE_POINT = -1;
    
    /**
     * Stroke used to draw inactive (regular) fold outlines.
     */
    private static Stroke LINE_DASHED = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 
            1f, new float[] { 1f, 1f }, 0f);
    
    /**
     * Stroke used to draw outlines for 'active' fold
     */
    private static final Stroke LINE_BOLD = new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);
    
    private final Preferences prefs;
    private final PreferenceChangeListener prefsListener = new PreferenceChangeListener() {
        public void preferenceChange(PreferenceChangeEvent evt) {
            String key = evt == null ? null : evt.getKey();
            if (key == null || SimpleValueNames.CODE_FOLDING_ENABLE.equals(key)) {
                updateColors();
                
                boolean newEnabled = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, EditorPreferencesDefaults.defaultCodeFoldingEnable);
                if (enabled != newEnabled) {
                    enabled = newEnabled;
                    updatePreferredSize();
                }
            }
        }
    };
    
    private void checkRepaint(ViewHierarchyEvent vhe) {
        if (!vhe.isChangeY()) {
            // does not obscur sidebar graphics
            return;
        }
        
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updatePreferredSize();
                CodeFoldingSideBar.this.repaint();
            }
        });
    }
    
    /**
     * @deprecated Don't use this constructor, it does nothing!
     */
    public CodeFoldingSideBar() {
        component = null;
        prefs = null;
        throw new IllegalStateException("Do not use this constructor!"); //NOI18N
    }

    public CodeFoldingSideBar(final JTextComponent component){
        super();
        this.component = component;

        // prevent from display CF sidebar twice
        if (component.getClientProperty(PROP_SIDEBAR_MARK) == null) {
            component.putClientProperty("org.netbeans.editor.CodeFoldingSidebar", Boolean.TRUE);
        } else {
            alreadyPresent = true;
        }

        addMouseListener(listener);
        addMouseMotionListener(listener);

        final FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
        foldHierarchy.addFoldHierarchyListener(WeakListeners.create(FoldHierarchyListener.class, listener, foldHierarchy));

        final Document doc = getDocument();
        doc.addDocumentListener(WeakListeners.document(listener, doc));
        setOpaque(true);
        
        prefs = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component)).lookup(Preferences.class);
        prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, prefsListener, prefs));
        prefsListener.preferenceChange(null);
        
        ViewHierarchy.get(component).addViewHierarchyListener(new ViewHierarchyListener() {

            @Override
            public void viewHierarchyChanged(ViewHierarchyEvent evt) {
                checkRepaint(evt);
            }
            
        });
    }
    
    private boolean hasProviders() {
        final FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
        FoldHierarchyExecution exec = ApiPackageAccessor.get().foldGetExecution(foldHierarchy);
        exec.lock();
        try {
            return exec.hasProviders();
        } finally {
            exec.unlock();
        }
        
    }
    
    private void updatePreferredSize() {
        // do not show at all, if there are no providers registered.
        if (enabled && hasProviders() && !alreadyPresent) {
            setPreferredSize(new Dimension(getColoring().getFont().getSize(), component.getHeight()));
            setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
        }else{
            setPreferredSize(new Dimension(0,0));
            setMaximumSize(new Dimension(0,0));
        }
        revalidate();
    }

    private void updateColors() {
        Coloring c = getColoring();
        this.backColor = c.getBackColor();
        this.foreColor = c.getForeColor();
        this.font = c.getFont();
    }

    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The background color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getBackColor() {
        if (backColor == null) {
            updateColors();
        }
        return backColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The foreground color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getForeColor() {
        if (foreColor == null) {
            updateColors();
        }
        return foreColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The font used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Font getColoringFont() {
        if (font == null) {
            updateColors();
        }
        return font;
    }
    
    // overriding due to issue #60304
    public @Override void update(Graphics g) {
    }
    
    protected void collectPaintInfos(
        View rootView, Fold fold, Map<Integer, PaintInfo> map, int level, int startIndex, int endIndex
    ) throws BadLocationException {
        //never called
    }

    /**
     * Adjust lowest/topmost boundaries from the Fold range y1-y2.
     * @param y1
     * @param y2
     * @param level 
     */
    private void setMouseBoundaries(int y1, int y2, int level) {
        if (!hasMousePoint() || mousePointConsumed) {
            return;
        }
        int y = mousePoint;
        if (y2 < y && lowestAboveMouse < y2) {
            LOG.log(Level.FINEST, "lowestAbove at {1}: {0}", new Object[] { y2, level });
            lowestAboveMouse = y2;
        }
        if (y1 > y && topmostBelowMouse > y1) {
            LOG.log(Level.FINEST, "topmostBelow at {1}: {0}", new Object[] { y1, level });
            topmostBelowMouse = y1;
        }
    }
    
    /*
     * Even collapsed fold MAY contain a continuation line, IF one of folds on the same line is NOT collapsed. Such a fold should
     * then visually span multiple lines && be marked as collapsed.
     */

    protected List<? extends PaintInfo> getPaintInfo(Rectangle clip) throws BadLocationException {
        javax.swing.plaf.TextUI textUI = component.getUI();
        if (!(textUI instanceof BaseTextUI)) {
            return Collections.<PaintInfo>emptyList();
        }
        BaseTextUI baseTextUI = (BaseTextUI)textUI;
        BaseDocument bdoc = Utilities.getDocument(component);
        if (bdoc == null) {
            return Collections.<PaintInfo>emptyList();
        }
        mousePointConsumed = false;
        mouseBoundary = null;
        topmostBelowMouse = Integer.MAX_VALUE;
        lowestAboveMouse = -1;
        bdoc.readLock();
        try {
            int startPos = baseTextUI.getPosFromY(clip.y);
            int endPos = baseTextUI.viewToModel(component, Short.MAX_VALUE / 2, clip.y + clip.height);
            
            if (startPos < 0 || endPos < 0) {
                // editor window is not properly sized yet; return no infos
                return Collections.<PaintInfo>emptyList();
            }
            
            // #218282: if the view hierarchy is not yet updated, the Y coordinate may map to an incorrect offset outside
            // the document.
            int docLen = bdoc.getLength();
            if (startPos >= docLen || endPos > docLen) {
                return Collections.<PaintInfo>emptyList();
            }
            
            startPos = Utilities.getRowStart(bdoc, startPos);
            endPos = Utilities.getRowEnd(bdoc, endPos);
            
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                View rootView = Utilities.getDocumentView(component);
                if (rootView != null) {
                    Object [] arr = getFoldList(hierarchy.getRootFold(), startPos, endPos);
                    @SuppressWarnings("unchecked")
                    List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                    int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                    /*
                     * Note:
                     * 
                     * The Map is keyed by Y-VISUAL position of the fold mark, not the textual offset of line start.
                     * This is because several folds may occupy the same line, while only one + sign is displayed,
                     * and affect the last fold in the row.
                     */
                    NavigableMap<Integer, PaintInfo> map = new TreeMap<Integer, PaintInfo>();
                    // search backwards
                    for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                        Fold fold = foldList.get(i);
                        if (!traverseBackwards(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }

                    // search forward
                    for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                        Fold fold = foldList.get(i);
                        if (!traverseForward(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }
                    
                    if (map.isEmpty() && foldList.size() > 0) {
                        assert foldList.size() == 1;
                        PaintInfo pi = new PaintInfo(PAINT_LINE, 0, clip.y, clip.height, -1, -1);
                        mouseBoundary = new Rectangle(0, 0, 0, clip.height);
                        LOG.log(Level.FINEST, "Mouse boundary for full side line set to: {0}", mouseBoundary);
                        if (hasMousePoint()) {
                            pi.markActive(true, true, true);
                        }
                        return Collections.singletonList(pi);
                    } else {
                        if (mouseBoundary == null) {
                            mouseBoundary = makeMouseBoundary(clip.y, clip.y + clip.height);
                            LOG.log(Level.FINEST, "Mouse boundary not set, defaulting to: {0}", mouseBoundary);
                        }
                        return new ArrayList<PaintInfo>(map.values());
                    }
                } else {
                    return Collections.<PaintInfo>emptyList();
                }
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }
    }
    
    /**
     * Adds a paint info to the map. If a paintinfo already exists, it merges
     * the structures, so the painting process can just follow the instructions.
     * 
     * @param infos
     * @param yOffset
     * @param nextInfo 
     */
    private void addPaintInfo(Map<Integer, PaintInfo> infos, int yOffset, PaintInfo nextInfo) {
        PaintInfo prevInfo = infos.get(yOffset);
        nextInfo.mergeWith(prevInfo);
        infos.put(yOffset, nextInfo);
    }

    private boolean traverseForward(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary,int level,  NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseForward<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getStartOffset() > upperBoundary ? ", f.gSO > uB" : "")
//                + ", level=" + level);
        
        if (f.getStartOffset() > upperBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int y1 = btui.getYFromPos(lineStartOffset1);
        int h = btui.getEditorUI().getLineHeight();
        int y2 = btui.getYFromPos(lineStartOffset2);
         
        // the 'active' flags can be set only after children are processed; highlights
        // correspond to the innermost expanded child.
        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi;
        boolean activated;
        
        if (y1 == y2) {
            // whole fold is on a single line
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            // fold spans multiple lines
            spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y2 + h / 2)) {
                activeMark = true;
                activeOut = true;
            }
            addPaintInfo(infos, y1, spi);
        }

        setMouseBoundaries(y1, y2 + h / 2, level);

        // Handle end mark after possible inner folds were processed because
        // otherwise if there would be two nested folds both ending at the same line
        // then the end mark for outer one would be replaced by an end mark for inner one
        // (same key in infos map) and the painting code would continue to paint line marking a fold
        // until next fold is reached (or end of doc).
        PaintInfo epi = null;
        if (y1 != y2 && !f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
            epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
            addPaintInfo(infos, y2, epi);
        }

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h / 2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                spi.markActive(activeMark, activeIn, activeOut);
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                markDeepChildrenActive(infos, y1, y2, level);
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
     
    /**
     * Sets outlines of all children to 'active'. Assuming yFrom and yTo are from-to Y-coordinates of the parent
     * fold, it finds all nested folds (folds, which are in between yFrom and yTo) and changes their in/out lines
     * as active.
     * The method returns Y start coordinate of the 1st child found.
     * 
     * @param infos fold infos collected so far
     * @param yFrom upper Y-coordinate of the parent fold
     * @param yTo lower Y-coordinate of the parent fold
     * @param level level of the parent fold
     * @return Y-coordinate of the 1st child.
     */
    private int markDeepChildrenActive(NavigableMap<Integer, PaintInfo> infos, int yFrom, int yTo, int level) {
        int result = Integer.MAX_VALUE;
        Map<Integer, PaintInfo> m = infos.subMap(yFrom, yTo);
        for (Map.Entry<Integer, PaintInfo> me : m.entrySet()) {
            PaintInfo pi = me.getValue();
            int y = pi.getPaintY();
            if (y > yFrom && y < yTo) {
                if (LOG.isLoggable(Level.FINEST)) {
                    LOG.log(Level.FINEST, "Marking chind as active: {0}", pi);
                }
                pi.markActive(false, true, true);
                if (y < result) {
                    y = result;
                }
            }
        }
        return result;
    }
    
    /**
     * Returns stroke appropriate for painting (in)active outlines
     * @param s the default stroke
     * @param active true for active outlines
     * @return value of 's' or a Stroke which should be used to paint the outline.
     */
    private static Stroke getStroke(Stroke s, boolean active) {
        if (active) {
            return LINE_BOLD;
        } else {
            return s;
        }
    }
    
    private boolean traverseBackwards(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary, int level, NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseBackwards<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getEndOffset() < lowerBoundary ? ", f.gEO < lB" : "")
//                + ", level=" + level);

        if (f.getEndOffset() < lowerBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int h = btui.getEditorUI().getLineHeight();

        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi = null;
        PaintInfo epi = null;
        boolean activated = false;
        int y1 = 0;
        int y2 = 0;
        
        if (lineStartOffset1 == lineStartOffset2) {
            // whole fold is on a single line
            y2 = y1 = btui.getYFromPos(lineStartOffset1);
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset1);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            y2 = btui.getYFromPos(lineStartOffset2);
            // fold spans multiple lines
            y1 = btui.getYFromPos(lineStartOffset1);
            activated = isActivated(y1, y2 + h / 2);
            if (f.getStartOffset() >= upperBoundary) {
                spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
                if (activated) {
                    activeMark = true;
                    activeOut = true;
                }
                addPaintInfo(infos, y1, spi);
            }

            if (!f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
                activated |= isActivated(y1, y2 + h / 2);
                epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
                addPaintInfo(infos, y2, epi);
            }
        }
        
        setMouseBoundaries(y1, y2 + h / 2, level);

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h /2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                if (spi != null) {
                    spi.markActive(activeMark, activeIn, activeOut);
                }
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                int lowestChild = markDeepChildrenActive(infos, y1, y2, level);
                if (lowestChild < Integer.MAX_VALUE && lineStartOffset1 < upperBoundary) {
                    // the fold starts above the screen clip region, and is 'activated'. We need to setup instructions to draw activated line up to the
                    // 1st child marker.
                    epi = new PaintInfo(PAINT_LINE, level, y1, y2 - y1, false, lineStartOffset1, lineStartOffset2);
                    epi.markActive(true, true, false);
                    addPaintInfo(infos, y1, epi);
                }
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
    
    private Rectangle makeMouseBoundary(int y1, int y2) {
        if (!hasMousePoint()) {
            return null;
        }
        if (topmostBelowMouse < Integer.MAX_VALUE) {
            y2 = topmostBelowMouse;
        }
        if (lowestAboveMouse  > -1) {
            y1 = lowestAboveMouse;
        }
        return new Rectangle(0, y1, 0, y2 - y1);
    }
    
    protected EditorUI getEditorUI(){
        return Utilities.getEditorUI(component);
    }
    
    protected Document getDocument(){
        return component.getDocument();
    }


    private Fold getLastLineFold(FoldHierarchy hierarchy, int rowStart, int rowEnd, boolean shift){
        Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
        Fold prevFold = fold;
        while (fold != null && fold.getStartOffset()<rowEnd){
            Fold nextFold = FoldUtilities.findNearestFold(hierarchy, (fold.isCollapsed()) ? fold.getEndOffset() : fold.getStartOffset()+1);
            if (nextFold == fold) return fold;
            if (nextFold!=null && nextFold.getStartOffset() < rowEnd){
                prevFold = shift ? fold : nextFold;
                fold = nextFold;
            }else{
                return prevFold;
            }
        }
        return prevFold;
    }
    
    protected void performAction(Mark mark) {
        performAction(mark, false);
    }
    
    private void performActionAt(Mark mark, int mouseY) throws BadLocationException {
        if (mark != null) {
            return;
        }
        BaseDocument bdoc = Utilities.getDocument(component);
        BaseTextUI textUI = (BaseTextUI)component.getUI();

        View rootView = Utilities.getDocumentView(component);
        if (rootView == null) return;
        
        bdoc.readLock();
        try {
            int yOffset = textUI.getPosFromY(mouseY);
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                Fold f = FoldUtilities.findOffsetFold(hierarchy, yOffset);
                if (f == null) {
                    return;
                }
                if (f.isCollapsed()) {
                    LOG.log(Level.WARNING, "Clicked on a collapsed fold {0} at {1}", new Object[] { f, mouseY });
                    return;
                }
                int startOffset = f.getStartOffset();
                int endOffset = f.getEndOffset();
                
                int startY = textUI.getYFromPos(startOffset);
                int nextLineOffset = Utilities.getRowStart(bdoc, startOffset, 1);
                int nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    LOG.log(Level.FINEST, "Starting line clicked, ignoring. MouseY={0}, startY={1}, nextY={2}",
                            new Object[] { mouseY, startY, nextY });
                    return;
                }

                startY = textUI.getYFromPos(endOffset);
                nextLineOffset = Utilities.getRowStart(bdoc, endOffset, 1);
                nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    // the mouse can be positioned above the marker (the fold found above), or
                    // below it; in that case, the immediate enclosing fold should be used - should be the fold
                    // that corresponds to the nextLineOffset, if any
                    int h2 = (startY + nextY) / 2;
                    if (mouseY >= h2) {
                        Fold f2 = f;
                        
                        f = FoldUtilities.findOffsetFold(hierarchy, nextLineOffset);
                        if (f == null) {
                            // fold does not exist for the position below end-of-fold indicator
                            return;
                        }
                    }
                    
                }
                
                LOG.log(Level.FINEST, "Collapsing fold: {0}", f);
                hierarchy.collapse(f);
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }        
    }
    
    private void performAction(final Mark mark, final boolean shiftFold) {
        Document doc = component.getDocument();
        doc.render(new Runnable() {
            @Override
            public void run() {
                ViewHierarchy vh = ViewHierarchy.get(component);
                LockedViewHierarchy lockedVH = vh.lock();
                try {
                    int pViewIndex = lockedVH.yToParagraphViewIndex(mark.y + mark.size / 2);
                    if (pViewIndex >= 0) {
                        ParagraphViewDescriptor pViewDesc = lockedVH.getParagraphViewDescriptor(pViewIndex);
                        int pViewStartOffset = pViewDesc.getStartOffset();
                        int pViewEndOffset = pViewStartOffset + pViewDesc.getLength();
                        // Find corresponding fold
                        FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
                        foldHierarchy.lock();
                        try {
                            int rowStart = javax.swing.text.Utilities.getRowStart(component, pViewStartOffset);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(component, pViewStartOffset);
                            Fold clickedFold = getLastLineFold(foldHierarchy, rowStart, rowEnd, shiftFold);//FoldUtilities.findNearestFold(foldHierarchy, viewStartOffset);
                            if (clickedFold != null && clickedFold.getStartOffset() < pViewEndOffset) {
                                foldHierarchy.toggle(clickedFold);
                            }
                        } catch (BadLocationException ble) {
                            LOG.log(Level.WARNING, null, ble);
                        } finally {
                            foldHierarchy.unlock();
                        }
                    }
                } finally {
                    lockedVH.unlock();
                }
            }
        });
    }
    
    protected int getMarkSize(Graphics g){
        if (g != null){
            FontMetrics fm = g.getFontMetrics(getColoring().getFont());
            if (fm != null){
                int ret = fm.getAscent() - fm.getDescent();
                return ret - ret%2;
            }
        }
        return -1;
    }
    
    private boolean hasMousePoint() {
        return mousePoint >= 0;
    }
    
    private boolean isActivated(int y1, int y2) {
        return hasMousePoint() && 
               (mousePoint >= y1 && mousePoint < y2);
    }
    
    private void drawFoldLine(Graphics2D g2d, boolean active, int x1, int y1, int x2, int y2) {
        Stroke origStroke = g2d.getStroke();
        g2d.setStroke(getStroke(origStroke, active));
        g2d.drawLine(x1, y1, x2, y2);
        g2d.setStroke(origStroke);
    }
    
    protected @Override void paintComponent(Graphics g) {
        if (!enabled) {
            return;
        }
        
        Rectangle clip = getVisibleRect();//g.getClipBounds();
        visibleMarks.clear();
        
        Coloring coloring = getColoring();
        g.setColor(coloring.getBackColor());
        g.fillRect(clip.x, clip.y, clip.width, clip.height);
        g.setColor(coloring.getForeColor());

        AbstractDocument adoc = (AbstractDocument)component.getDocument();
        adoc.readLock();
        try {
            List<? extends PaintInfo> ps = getPaintInfo(clip);
            Font defFont = coloring.getFont();
            int markSize = getMarkSize(g);
            int halfMarkSize = markSize / 2;
            int markX = (defFont.getSize() - markSize) / 2; // x position of mark rectangle
            int plusGap = (int)Math.round(markSize / 3.8); // distance between mark rectangle vertical side and start/end of minus sign
            int lineX = markX + halfMarkSize; // x position of the centre of mark

            LOG.fine("CFSBar: PAINT START ------\n");
            int descent = g.getFontMetrics(defFont).getDescent();
            PaintInfo previousInfo = null;
            Graphics2D g2d = (Graphics2D)g;
            LOG.log(Level.FINEST, "MousePoint: {0}", mousePoint);

            for(PaintInfo paintInfo : ps) {
                boolean isFolded = paintInfo.isCollapsed();
                int y = paintInfo.getPaintY();
                int height = paintInfo.getPaintHeight();
                int markY = y + descent; // y position of mark rectangle
                int paintOperation = paintInfo.getPaintOperation();

                if (previousInfo == null) {
                    if (paintInfo.hasLineIn()) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("prevInfo=NULL; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, clip.y, lineX, y);
                    }
                } else {
                    if (previousInfo.hasLineOut() || paintInfo.hasLineIn()) {
                        // Draw middle vertical line
                        int prevY = previousInfo.getPaintY();
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.log(Level.FINE, "prevInfo={0}; y=" + y + ", PI:" + paintInfo + "\n", previousInfo); // NOI18N
                        }
                        drawFoldLine(g2d, previousInfo.lineOutActive || paintInfo.lineInActive, lineX, prevY + previousInfo.getPaintHeight(), lineX, y);
                    }
                }

                if (paintInfo.hasSign()) {
                    g.drawRect(markX, markY, markSize, markSize);
                    g.drawLine(plusGap + markX, markY + halfMarkSize, markSize + markX - plusGap, markY + halfMarkSize);
                    String opStr = (paintOperation == PAINT_MARK) ? "PAINT_MARK" : "SINGLE_PAINT_MARK"; // NOI18N
                    if (isFolded) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": folded; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        g.drawLine(lineX, markY + plusGap, lineX, markY + markSize - plusGap);
                    }
                    if (paintOperation != SINGLE_PAINT_MARK) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": non-single; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                    }
                    if (paintInfo.hasLineIn()) { //[PENDING]
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, markY);
                    }
                    if (paintInfo.hasLineOut()) {
                        // This is an error in case there's a next paint info at the same y which is an end mark
                        // for this mark (it must be cleared explicitly).
                        drawFoldLine(g2d, paintInfo.lineOutActive, lineX, markY + markSize, lineX, y + height);
                    }
                    visibleMarks.add(new Mark(markX, markY, markSize, isFolded));

                } else if (paintOperation == PAINT_LINE) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_LINE: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    // FIXME !!
                    drawFoldLine(g2d, paintInfo.signActive, lineX, y, lineX, y + height );
                } else if (paintOperation == PAINT_END_MARK) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_END_MARK: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    if (previousInfo == null || y != previousInfo.getPaintY()) {
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, y + height / 2);
                        drawFoldLine(g2d, paintInfo.signActive, lineX, y + height / 2, lineX + halfMarkSize, y + height / 2);
                        if (paintInfo.getInnerLevel() > 0) {//[PENDING]
                            if (LOG.isLoggable(Level.FINE)) {
                                LOG.fine("  PAINT middle-line\n"); // NOI18N
                            }
                            drawFoldLine(g2d, paintInfo.lineOutActive, lineX, y + height / 2, lineX, y + height);
                        }
                    }
                }

                previousInfo = paintInfo;
            }

            if (previousInfo != null &&
                (previousInfo.getInnerLevel() > 0 ||
                 (previousInfo.getPaintOperation() == PAINT_MARK && !previousInfo.isCollapsed()))
            ) {
                drawFoldLine(g2d, previousInfo.lineOutActive, 
                        lineX, previousInfo.getPaintY() + previousInfo.getPaintHeight(), lineX, clip.y + clip.height);
            }

        } catch (BadLocationException ble) {
            LOG.log(Level.WARNING, null, ble);
        } finally {
            LOG.fine("CFSBar: PAINT END ------\n\n");
            adoc.readUnlock();
        }
    }
    
    private static Object [] getFoldList(Fold parentFold, int start, int end) {
        List<Fold> ret = new ArrayList<Fold>();

        int index = FoldUtilities.findFoldEndIndex(parentFold, start);
        int foldCount = parentFold.getFoldCount();
        int idxOfFirstFoldStartingInside = -1;
        while (index < foldCount) {
            Fold f = parentFold.getFold(index);
            if (f.getStartOffset() <= end) {
                ret.add(f);
            } else {
                break; // no more relevant folds
            }
            if (idxOfFirstFoldStartingInside == -1 && f.getStartOffset() >= start) {
                idxOfFirstFoldStartingInside = ret.size() - 1;
            }
            index++;
        }

        return new Object [] { ret, idxOfFirstFoldStartingInside != -1 ? idxOfFirstFoldStartingInside : ret.size() };
    }

    /**
     * This class should be never used by other code; will be made private
     */
    public class PaintInfo {
        
        int paintOperation;
        /**
         * level of the 1st marker on the line
         */
        int innerLevel;
        
        /**
         * Y-coordinate of the cell
         */
        int paintY;
        
        /**
         * Height of the paint cell
         */
        int paintHeight;
        
        /**
         * State of the marker (+/-)
         */
        boolean isCollapsed;
        
        /**
         * all markers on the line are collapsed
         */
        boolean allCollapsed;
        int startOffset;
        int endOffset;
        /**
         * nesting level of the last marker on the line
         */
        int outgoingLevel;
        
        /**
         * Force incoming line (from above) to be present
         */
        boolean lineIn;
        
        /**
         * Force outgoing line (down from marker) to be present
         */
        boolean lineOut;
        
        /**
         * The 'incoming' (upper) line should be painted as active
         */
        boolean lineInActive;
        
        /**
         * The 'outgoing' (down) line should be painted as active
         */
        boolean lineOutActive;
        
        /**
         * The sign/marker itself should be painted as active
         */
        boolean signActive;
        
        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, boolean isCollapsed, int startOffset, int endOffset){
            this.paintOperation = paintOperation;
            this.innerLevel = this.outgoingLevel = innerLevel;
            this.paintY = paintY;
            this.paintHeight = paintHeight;
            this.isCollapsed = this.allCollapsed = isCollapsed;
            this.startOffset = startOffset;
            this.endOffset = endOffset;

            switch (paintOperation) {
                case PAINT_MARK:
                    lineIn = false;
                    lineOut = true;
                    outgoingLevel++;
                    break;
                case SINGLE_PAINT_MARK:
                    lineIn = false;
                    lineOut = false;
                    break;
                case PAINT_END_MARK:
                    lineIn = true;
                    lineOut = false;
                    isCollapsed = true;
                    allCollapsed = true;
                    break;
                case PAINT_LINE:
                    lineIn = lineOut = true;
                    break;
            }
        }
        
        /**
         * Sets active flags on inidivual parts of the mark
         * @param mark
         * @param lineIn
         * @param lineOut S
         */
        void markActive(boolean mark, boolean lineIn, boolean lineOut) {
            this.signActive |= mark;
            this.lineInActive |= lineIn;
            this.lineOutActive |= lineOut;
        }
        
        boolean hasLineIn() {
            return lineIn || innerLevel > 0;
        }
        
        boolean hasLineOut() {
            return lineOut || outgoingLevel > 0 || (paintOperation != SINGLE_PAINT_MARK && !isAllCollapsed());
        }

        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, int startOffset, int endOffset){
            this(paintOperation, innerLevel, paintY, paintHeight, false, startOffset, endOffset);
        }
        
        public int getPaintOperation(){
            return paintOperation;
        }
        
        public int getInnerLevel(){
            return innerLevel;
        }
        
        public int getPaintY(){
            return paintY;
        }
        
        public int getPaintHeight(){
            return paintHeight;
        }
        
        public boolean isCollapsed(){
            return isCollapsed;
        }
        
         boolean isAllCollapsed() {
            return allCollapsed;
        }
        
        public void setPaintOperation(int paintOperation){
            this.paintOperation = paintOperation;
        }
        
        public void setInnerLevel(int innerLevel){
            this.innerLevel = innerLevel;
        }
        
        public @Override String toString(){
            StringBuffer sb = new StringBuffer("");
            if (paintOperation == PAINT_MARK){
                sb.append("PAINT_MARK"); // NOI18N
            }else if (paintOperation == PAINT_LINE){
                sb.append("PAINT_LINE"); // NOI18N
            }else if (paintOperation == PAINT_END_MARK) {
                sb.append("PAINT_END_MARK"); // NOI18N
            }else if (paintOperation == SINGLE_PAINT_MARK) {
                sb.append("SINGLE_PAINT_MARK");
            }
            sb.append(",L:").append(innerLevel).append("/").append(outgoingLevel); // NOI18N
            sb.append(',').append(isCollapsed ? "C" : "E"); // NOI18N
            sb.append(", start=").append(startOffset).append(", end=").append(endOffset);
            sb.append(", lineIn=").append(lineIn).append(", lineOut=").append(lineOut);
            return sb.toString();
        }
        
        boolean hasSign() {
            return paintOperation == PAINT_MARK || paintOperation == SINGLE_PAINT_MARK;
        }
        
        
        void mergeWith(PaintInfo prevInfo) {
            if (prevInfo == null) {
                return;
            }

            int operation = this.paintOperation;
            boolean lineIn = prevInfo.lineIn;
            boolean lineOut = prevInfo.lineOut;
            
            LOG.log(Level.FINE, "Merging {0} with {1}: ", new Object[] { this, prevInfo });
            if (prevInfo.getPaintOperation() == PAINT_END_MARK) {
                // merge with start|single -> start mark + line-in
                lineIn = true;
            } else {
                operation = PAINT_MARK;
            }

            int level1 = Math.min(prevInfo.innerLevel, innerLevel);
            int level2 = prevInfo.outgoingLevel;

            if (getPaintOperation() == PAINT_END_MARK 
                && innerLevel == prevInfo.outgoingLevel) {
                // if merging end marker at the last level, update to the new outgoing level
                level2 = outgoingLevel;
            } else if (!isCollapsed) {
                level2 = Math.max(prevInfo.outgoingLevel, outgoingLevel);
            }

            if (prevInfo.getInnerLevel() < getInnerLevel()) {
                int paintFrom = Math.min(prevInfo.paintY, paintY);
                int paintTo = Math.max(prevInfo.paintY + prevInfo.paintHeight, paintY + paintHeight);
                // at least one collapsed -> paint plus sign
                boolean collapsed = prevInfo.isCollapsed() || isCollapsed();
                int offsetFrom = Math.min(prevInfo.startOffset, startOffset);
                int offsetTo = Math.max(prevInfo.endOffset, endOffset);
                
                this.paintY = paintFrom;
                this.paintHeight = paintTo - paintFrom;
                this.isCollapsed = collapsed;
                this.startOffset = offsetFrom;
                this.endOffset = offsetTo;
            }
            this.paintOperation = operation;
            this.allCollapsed = prevInfo.allCollapsed && allCollapsed;
            this.innerLevel = level1;
            this.outgoingLevel = level2;
            this.lineIn |= lineIn;
            this.lineOut |= lineOut;
            
            this.signActive |= prevInfo.signActive;
            this.lineInActive |= prevInfo.lineInActive;
            this.lineOutActive |= prevInfo.lineOutActive;
            
            LOG.log(Level.FINE, "Merged result: {0}", this);
        }
    }
    
    /** Keeps info of visible folding mark */
    public class Mark{
        public int x;
        public int y;
        public int size;
        public boolean isFolded;
        
        public Mark(int x, int y, int size, boolean isFolded){
            this.x = x;
            this.y = y;
            this.size = size;
            this.isFolded = isFolded;
        }
    }
    
    private final class Listener extends MouseAdapter implements FoldHierarchyListener, DocumentListener, Runnable {
    
        public Listener(){
        }

        // --------------------------------------------------------------------
        // FoldHierarchyListener implementation
        // --------------------------------------------------------------------

        public void foldHierarchyChanged(FoldHierarchyEvent evt) {
            refresh();
        }

        // --------------------------------------------------------------------
        // DocumentListener implementation
        // --------------------------------------------------------------------

        public void insertUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines inserted
                refresh();
            }
        }

        public void removeUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines removed
                refresh();
            }
        }

        public void changedUpdate(DocumentEvent evt) {
        }

        // --------------------------------------------------------------------
        // MouseListener implementation
        // --------------------------------------------------------------------

        @Override
        public void mousePressed (MouseEvent e) {
            Mark mark = getClickedMark(e);
            if (mark!=null){
                e.consume();
                performAction(mark, (e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) > 0);
            }
        }

        @Override
        public void mouseClicked(MouseEvent e) {
            // #102288 - missing event consuming caused quick doubleclicks to break
            // fold expanding/collapsing and move caret to the particular line
            if (e.getClickCount() > 1) {
                LOG.log(Level.FINEST, "Mouse {0}click at {1}", new Object[] { e.getClickCount(), e.getY()});
                Mark mark = getClickedMark(e);
                try {
                    performActionAt(mark, e.getY());
                } catch (BadLocationException ex) {
                    LOG.log(Level.WARNING, "Error during fold expansion using sideline", ex);
                }
            } else {
                e.consume();
            }
        }

        private void refreshIfMouseOutside(Point pt) {
            mousePoint = (int)pt.getY();
            if (LOG.isLoggable(Level.FINEST)) {
                if (mouseBoundary == null) {
                    LOG.log(Level.FINEST, "Mouse boundary not set, refreshing: {0}", mousePoint);
                } else {
                    LOG.log(Level.FINEST, "Mouse {0} inside known mouse boundary: {1}-{2}", 
                            new Object[] { mousePoint, mouseBoundary.y, mouseBoundary.getMaxY() });
                }
            }
            if (mouseBoundary == null || mousePoint < mouseBoundary.y || mousePoint > mouseBoundary.getMaxY()) {
                refresh();
            }
        }
        
        @Override
        public void mouseMoved(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseEntered(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseExited(MouseEvent e) {
            mousePoint = NO_MOUSE_POINT;
            refresh();
        }
        

        // --------------------------------------------------------------------
        // private implementation
        // --------------------------------------------------------------------

        private Mark getClickedMark(MouseEvent e){
            if (e == null || !SwingUtilities.isLeftMouseButton(e)) {
                return null;
            }
            
            int x = e.getX();
            int y = e.getY();
            for (Mark mark : visibleMarks) {
                if (x >= mark.x && x <= (mark.x + mark.size) && y >= mark.y && y <= (mark.y + mark.size)) {
                    return mark;
                }
            }
            return null;
        }

        private void refresh() {
            SwingUtilities.invokeLater(this);
        }

        @Override
        public void run() {
            if (getPreferredSize().width == 0 && enabled) {
                updatePreferredSize();
            }
            repaint();
        }
    } // End of Listener class
    
    @Override
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJComponent() {
                public @Override AccessibleRole getAccessibleRole() {
                    return AccessibleRole.PANEL;
                }
            };
            accessibleContext.setAccessibleName(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSN_CodeFoldingSideBar")); //NOI18N
        accessibleContext.setAccessibleDescription(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSD_CodeFoldingSideBar")); //NOI18N
        }
        return accessibleContext;
    }

    private Coloring getColoring() {
        if (attribs == null) {
            if (fcsLookupResult == null) {
                fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component))
                        .lookupResult(FontColorSettings.class);
                fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
            }
            
            FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
            AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_BAR_COLORING);
            if (attr == null) {
                attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
            } else {
                attr = AttributesUtilities.createComposite(attr, fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
            }
            attribs = attr;
        }        
        return Coloring.fromAttributeSet(attribs);
    }

    /**
     * Factory for the sidebars. Use {@link FoldUtilities#getFoldingSidebarFactory()} to
     * obtain an instance.
     */
    public static class Factory implements SideBarFactory {
        @Override
        public JComponent createSideBar(JTextComponent target) {
            return new CodeFoldingSideBar(target);
        }
    }
}




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

import java.util.prefs.Preferences;

/**
 * Mixin interface, that allows to configure a Customizer to be configured with parent preferences.
 * The parent preferences may be either defaults stored or predefined, or preferences for the parent Mime type.
 * The customizer <b>must not</b> write to the default preferences
 * 
 * @author sdedic
 */
public interface CustomizerWithDefaults {
    /**
     * Provides default preferences to the customizer. All language preferences,
     * or text/xml preferences are passed this way to the language customizer,
     * to serve as a basis. The default preferences 
     * 
     * @param pref default preferences
     */
    public void setDefaultPreferences(Preferences pref);
}




<?xml version="1.0" encoding="UTF-8" ?>

<Form version="1.5" maxVersion="1.8" type="org.netbeans.modules.form.forminfo.JPanelFormInfo">
  <AuxValues>
    <AuxValue name="FormSettings_autoResourcing" type="java.lang.Integer" value="1"/>
    <AuxValue name="FormSettings_autoSetComponentName" type="java.lang.Boolean" value="false"/>
    <AuxValue name="FormSettings_generateFQN" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_generateMnemonicsCode" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_i18nAutoMode" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_layoutCodeTarget" type="java.lang.Integer" value="1"/>
    <AuxValue name="FormSettings_listenerGenerationStyle" type="java.lang.Integer" value="0"/>
    <AuxValue name="FormSettings_variablesLocal" type="java.lang.Boolean" value="false"/>
    <AuxValue name="FormSettings_variablesModifier" type="java.lang.Integer" value="2"/>
  </AuxValues>

  <Layout>
    <DimensionLayout dim="0">
      <Group type="103" groupAlignment="0" attributes="0">
          <Component id="collapseContainer" pref="180" max="32767" attributes="0"/>
      </Group>
    </DimensionLayout>
    <DimensionLayout dim="1">
      <Group type="103" groupAlignment="0" attributes="0">
          <Component id="collapseContainer" alignment="0" pref="151" max="32767" attributes="0"/>
      </Group>
    </DimensionLayout>
  </Layout>
  <SubComponents>
    <Container class="javax.swing.JPanel" name="collapseContainer">
      <Properties>
        <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor">
          <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo">
            <TitledBorder title="Collapse by default">
              <ResourceString PropertyName="titleX" bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="DefaultFoldingOptions.collapseContainer.border.title" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
            </TitledBorder>
          </Border>
        </Property>
      </Properties>
      <AuxValues>
        <AuxValue name="designerSize" type="java.awt.Dimension" value="-84,-19,0,5,115,114,0,18,106,97,118,97,46,97,119,116,46,68,105,109,101,110,115,105,111,110,65,-114,-39,-41,-84,95,68,20,2,0,2,73,0,6,104,101,105,103,104,116,73,0,5,119,105,100,116,104,120,112,0,0,0,-105,0,0,0,-84"/>
      </AuxValues>

      <Layout class="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout"/>
      <SubComponents>
        <Container class="javax.swing.JPanel" name="localSwitchboard">
          <Constraints>
            <Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout" value="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout$BorderConstraintsDescription">
              <BorderConstraints direction="Center"/>
            </Constraint>
          </Constraints>

          <Layout class="org.netbeans.modules.form.compat2.layouts.DesignAbsoluteLayout">
            <Property name="useNullLayout" type="boolean" value="true"/>
          </Layout>
        </Container>
      </SubComponents>
    </Container>
  </SubComponents>
</Form>




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

import java.awt.GridLayout;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;
import org.netbeans.modules.editor.settings.storage.api.EditorSettings;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;
import org.openide.util.WeakListeners;

/**
 * Default implementation of folding options. The dialog will only display
 * checboxes, for each of the registered FoldTypes. FoldTypes are displayed
 * in same order, as they are enumerated by FoldUtilities.getFoldTypes().
 * <p/>
 * The dialog will read and set preference values {@code code-folding-collapse-X},
 * where X is obtained from {@link FoldType#code()}.
 *
 * @author sdedic
 */
public final class DefaultFoldingOptions extends javax.swing.JPanel 
implements PreferenceChangeListener, ChangeListener, CustomizerWithDefaults, ItemListener {
    
    private static final Logger LOG = Logger.getLogger(DefaultFoldingOptions.class.getName());
    
    public static final String COLLAPSE_PREFIX = FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX;
    
    public static final String PREF_OVERRIDE_DEFAULTS = FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS;
    
    private static final Set<FoldType> LEGACY_FOLD_TYPES = new HashSet<FoldType>();
    
    static {
        LEGACY_FOLD_TYPES.add(FoldType.CODE_BLOCK);
        LEGACY_FOLD_TYPES.add(FoldType.INITIAL_COMMENT);
        LEGACY_FOLD_TYPES.add(FoldType.DOCUMENTATION);
        LEGACY_FOLD_TYPES.add(FoldType.TAG);
        LEGACY_FOLD_TYPES.add(FoldType.MEMBER);
        LEGACY_FOLD_TYPES.add(FoldType.NESTED);
        LEGACY_FOLD_TYPES.add(FoldType.IMPORT);
    }
    
    /**
     * Mimetype for which these options work
     */
    private String mimeType;
    
    /**
     * Transient preferences, contains current values + defaults.
     */
    private Preferences preferences;

    /**
     * Preferences for the super mimetype (or "")
     */
    private Preferences defaultPrefs;
    
    /**
     * Fold types registered for this MIME type. For "" type, the fold types
     * are filtered for those, which are actually used by any of the registered MIME types
     */
    private Collection<? extends FoldType> types;
    
    /**
     * Checkbox controls for collapse-* options
     */
    private Collection<JCheckBox> controls = new ArrayList<JCheckBox>();

    private PreferenceChangeListener weakL;
    
    private Collection<String>    parentFoldTypes;
    
    /**
     * Creates new form DefaultFoldingOptions
     */
    public DefaultFoldingOptions(String mime, Preferences preferences) {
        initComponents();
	 
        VerticalFlowLayout vfl = new VerticalFlowLayout();
        localSwitchboard.setLayout(vfl);
        
        vfl = new VerticalFlowLayout();
        localSwitchboard.setLayout(vfl);

        this.mimeType = mime;
        this.preferences = preferences;
        
        String parentMime = MimePath.parse(mime).getInheritedType();
        if (parentMime != null) {
            parentFoldTypes = new HashSet<String>(13);
            for (FoldType ft : FoldUtilities.getFoldTypes(parentMime).values()) {
                parentFoldTypes.add(ft.code());
            }
        } else {
            parentFoldTypes = Collections.emptyList();
        }
    }

    @Override
    public void setDefaultPreferences(Preferences pref) {
        if (this.defaultPrefs != null) {
            defaultPrefs.removePreferenceChangeListener(weakL);
        }
        // anomaly: if the local Preference contains 'removedKey' for a preference
        // which has been turned to default, it blocks all change propagations.
        this.defaultPrefs = pref;
        if (pref != null) {
            weakL = WeakListeners.create(PreferenceChangeListener.class, this, pref);
            pref.addPreferenceChangeListener(weakL);
        }
    }
    
    private static String k(FoldType ft) {
        return COLLAPSE_PREFIX + ft.code();
    }
    
    private JCheckBox createCheckBox(FoldType ft) {
        return new JCheckBox();
    }
    
    /**
     * Filters types to contain only mimetypes, which are actually used in 
     * one or more mimetypes. Used only for "" mimetype (defaults).
     */
    private void filterUsedMimeTypes() {
        Set<String> mimeTypes = EditorSettings.getDefault().getAllMimeTypes();
        Set<String> codes = new HashSet<String>();
        for (String mt : mimeTypes) {
            Collection<? extends FoldType> fts = FoldUtilities.getFoldTypes(mt).values();
            for (FoldType ft : fts) {
                codes.add(ft.code());
                if (ft.parent() != null) {
                    codes.add(ft.parent().code());
                }
            }
        }
        for (Iterator<? extends FoldType> it = types.iterator(); it.hasNext();) {
            FoldType ft = it.next();
            if (LEGACY_FOLD_TYPES.contains(ft)) {
                continue;
            }
            if (!codes.contains(ft.code())) {
                it.remove();
            }
        }
    }
    
    private void load() {
        types = new ArrayList<FoldType>(FoldUtilities.getFoldTypes(mimeType).values());
        if ("".equals(mimeType)) { // NOI18N
            filterUsedMimeTypes();
        }

        boolean override = isCollapseRedefined();
        boolean useDefaultsState = 
                !(preferences.getBoolean(PREF_OVERRIDE_DEFAULTS, false) ||
                isDefinedLocally(PREF_OVERRIDE_DEFAULTS));
        if (override != useDefaultsState) {
            updateOverrideChanged();
        }
        
        for (FoldType ft : types) {
            String name = ft.getLabel();
            
            JCheckBox cb = createCheckBox(ft);
            cb.setText(name);
            cb.putClientProperty("id", ft.code()); // NOI18N
            cb.putClientProperty("type", ft); // NOI18N
            localSwitchboard.add(cb);
            controls.add(cb);
            cb.addItemListener(this);
        }
        
        // watch out for preferences
        this.preferences.addPreferenceChangeListener(this);
        updateEnabledState();
    }
    
    /**
     * Checks whether some of the collapse- options is redefined for this MIME type.
     * If so, the checkbox will be selected even though the override option is not
     * present.
     * 
     * @return 
     */
    private boolean isCollapseRedefined() {
        for (FoldType ft : types) {
            String pref = k(ft);
            if (((OverridePreferences)preferences).isOverriden(pref)) {
               if (defaultPrefs == null || 
                    (parentFoldTypes.contains(ft.code()) || (ft.parent() != null && parentFoldTypes.contains(ft.parent().code())))) {
                    return true;
               }
            }
        }
        return false;
    }
    
    private boolean loaded;

    @Override
    public void addNotify() {
        super.addNotify();
        if (!loaded) {
            load();
            updateEnabledState();
            updateValueState();
            loaded = true;
        }
    }

    @Override
    public void preferenceChange(final PreferenceChangeEvent evt) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updateCheckers(evt);
            }
        });
    }
    
    private void updateValueState() {
        ignoreStateChange = true;
        for (JCheckBox cb : controls) {
            FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
            String k = COLLAPSE_PREFIX + ft.code();
            boolean val = isCollapseEnabled(ft);
            cb.setSelected(val);
        }
        ignoreStateChange = false;
    }
    
    private void updateEnabledState() {
        boolean foldEnable = preferences.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, true);
        boolean useDefaults = preferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true);
        
        for (JComponent c : controls) {
            FoldType ft = (FoldType)c.getClientProperty("type"); // NOI18N
            boolean enable = foldEnable;
            if (defaultPrefs != null && useDefaults) {
                if (!parentFoldTypes.contains(ft.code())) {
                    if (ft.parent() == null || !parentFoldTypes.contains(ft.parent().code())) {
                        continue;
                    }
                }
                enable &= !isDefinedDefault(ft);
            }
            c.setEnabled(enable);
        }
    }
    
    private void updateCheckers(PreferenceChangeEvent evt) {
        String pk = evt.getKey();
        if (pk.equals(SimpleValueNames.CODE_FOLDING_ENABLE)) {
            updateEnabledState();
            return;
        }
        if (pk.equals(PREF_OVERRIDE_DEFAULTS)) {
            updateOverrideChanged();
        } else if (!pk.startsWith(COLLAPSE_PREFIX)) {
            return;
        }
        String c = pk.substring(COLLAPSE_PREFIX.length());
        for (JCheckBox cb : controls) {
            FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
            FoldType ftp = ft.parent();
            if (ft.code().equals(c) || (ftp != null && ftp.code().equals(c))) {
                updateChecker(pk, cb, ft);
                return;
            }
        }
    }
    
    private boolean isCollapseEnabled(FoldType ft) {
        if (defaultPrefs == null) {
            return preferences.getBoolean(k(ft),
                    ft.parent() == null ? false
                    : preferences.getBoolean(k(ft.parent()), false));
        } else {
            String k = k(ft);
            return preferences.getBoolean(k,
                    defaultPrefs.getBoolean(k,
                    ft.parent() == null ? false
                    : preferences.getBoolean(k(ft.parent()), false)));
        }
    }
    
    private void updateOverrideChanged() {
        boolean en = preferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true);
        if (defaultPrefs == null) {
            return;
        }
        if (en) {
            // persist all foldtype settings:
            for (FoldType ft : types) {
                preferences.putBoolean(k(ft), 
			   defaultPrefs.getBoolean(k(ft),
	                     ft.parent() == null ? false :
	                 defaultPrefs.getBoolean(k(ft.parent()), false))
		  );
            }
        } else {
            for (FoldType ft : types) {
                if (isDefinedDefault(ft)) {
                    preferences.remove(k(ft));
                }
            }
        }
        updateEnabledState();
        updateValueState();
    }
    
    private boolean isDefinedDefault(FoldType ft) {
        return parentFoldTypes.contains(ft.code()) ||
            (ft.parent() != null && parentFoldTypes.contains(ft.parent().code()));
    }
    
    private boolean isDefinedLocally(String prefKey) {
        return !(preferences instanceof OverridePreferences) ||
                ((OverridePreferences)preferences).isOverriden(prefKey);
    }
    
    private void updateChecker(String prefKey, JCheckBox cb, FoldType ft) {
        if (lastChangedCB == cb) {
            // ignore
            lastChangedCB = null;
            return;
        }
        boolean val = isCollapseEnabled(ft);
        ignoreStateChange = true;
        LOG.log(Level.INFO, "Updating checker: " + prefKey + ", setSelected " + val);
        cb.setSelected(val);
        ignoreStateChange = false;
    }
    
    private boolean ignoreStateChange;
    
    private JCheckBox lastChangedCB;

    @Override
    public void itemStateChanged(final ItemEvent e) {
        if (ignoreStateChange) {
            return;
        }
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updatePref(e);
            }
        });
    }
    
    private void updatePref(ItemEvent e) {
        JCheckBox cb = (JCheckBox)e.getSource();
        FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
        
        String prefKey = COLLAPSE_PREFIX + ft.code();
        lastChangedCB = cb;
        LOG.log(Level.INFO, "Updating preference: " + prefKey + ", value = " + cb.isSelected());
        preferences.putBoolean(prefKey, cb.isSelected());
    }
    
    @Override
    public void stateChanged(ChangeEvent e) {
        if (ignoreStateChange) {
            return;
        }
    }
    
    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        collapseContainer = new javax.swing.JPanel();
        localSwitchboard = new javax.swing.JPanel();

        collapseContainer.setBorder(javax.swing.BorderFactory.createTitledBorder(org.openide.util.NbBundle.getMessage(DefaultFoldingOptions.class, "DefaultFoldingOptions.collapseContainer.border.title"))); // NOI18N
        collapseContainer.setLayout(new java.awt.BorderLayout());

        localSwitchboard.setLayout(null);
        collapseContainer.add(localSwitchboard, java.awt.BorderLayout.CENTER);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(collapseContainer, javax.swing.GroupLayout.DEFAULT_SIZE, 180, Short.MAX_VALUE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(collapseContainer, javax.swing.GroupLayout.DEFAULT_SIZE, 151, Short.MAX_VALUE)
        );
    }// </editor-fold>//GEN-END:initComponents

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JPanel collapseContainer;
    private javax.swing.JPanel localSwitchboard;
    // End of variables declaration//GEN-END:variables
}




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

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.HashMap;
import java.util.Map;
import java.util.prefs.BackingStoreException;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.swing.JComponent;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.options.OptionsDisplayer;
import org.netbeans.modules.editor.settings.storage.api.EditorSettings;
import org.netbeans.modules.editor.settings.storage.api.MemoryPreferences;
import org.netbeans.spi.options.OptionsPanelController;
import org.openide.util.Exceptions;
import org.openide.util.HelpCtx;
import org.openide.util.Lookup;
import org.openide.util.WeakListeners;

/**
 * Controller for the Folding options tab.
 * The controller manages the MemoryPreferences storage, which is then passed to individual folding
 * customizer panels. It also tracks 'dirty' status of all the language panels: if one of them becomes dirty,
 * the whole page starts to report dirty = true.
 * <p/>
 * This class manages only the language switch + overall 'enable folding' setting. All settings
 * for a given language are handled by the language-specific panel.
 *
 * @author sdedic
 */
@OptionsPanelController.SubRegistration(
    displayName="org.netbeans.modules.editor.fold.ui.Bundle#CTL_OptionsDisplayName",
    keywords="org.netbeans.modules.editor.fold.ui.Bundle#KW_Options",
    keywordsCategory="Editor/Folding",
    id="Folding", // XXX used anywhere?
    location=OptionsDisplayer.EDITOR,
    position=110
//    toolTip="org.netbeans.modules.options.editor.Bundle#CTL_General_ToolTip"
)
public class FoldOptionsController extends OptionsPanelController implements PreferenceChangeListener {
    /**
     * The main panel.
     */
    private FoldOptionsPanel panel;
    
    /**
     * True, if some of the created panels became dirty
     */
    private boolean changed;
    
    /**
     * for firing PROP_DIRTY
     */
    private PropertyChangeSupport propSupport = new PropertyChangeSupport(this);

    /**
     * Preferences created for individual MIME types, as they are displaye by the user
     */
    private Map<String, MemoryPreferences>    preferences = new HashMap<String, MemoryPreferences>();
    
    @Override
    public void update() {
        clearContents();
        if (panel != null) {
            panel.update();
        }
    }
    
    @Override
    public void applyChanges() {
        for (MemoryPreferences p : preferences.values()) {
            try {
                p.getPreferences().flush();
            } catch (BackingStoreException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
        changed = false;
        propSupport.firePropertyChange(PROP_CHANGED, true, false);
    }

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        boolean ch = detectIsChanged();
        if (ch != changed) {
            changed = ch;
            propSupport.firePropertyChange(PROP_CHANGED, !ch, ch);
        }
    }
    
    private PreferenceChangeListener weakChangeL = WeakListeners.create(PreferenceChangeListener.class, this, null);
    
    void globalEnableFolding(boolean enable) {
        prefs("").putBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, enable);
        for (String mime : EditorSettings.getDefault().getAllMimeTypes()) {
            prefs(mime).remove(SimpleValueNames.CODE_FOLDING_ENABLE);
        }
    }
    
    /* called from the FoldOptionsPanel */
    Preferences prefs(String mime) {
        MemoryPreferences cached = preferences.get(mime);
        if (cached != null) {
            return cached.getPreferences();
        }
        MimePath path = MimePath.parse(mime);
        Preferences result = MimeLookup.getLookup(mime).lookup(Preferences.class);
        
        if (!mime.equals("")) {
            String parentMime = path.getInheritedType();
            /*
            result = new InheritedPreferences(
                    prefs(parentMime), result);
                    */
            cached = MemoryPreferences.getWithInherited(this, 
                prefs(parentMime),
                result);
        } else {
            cached = MemoryPreferences.get(this, result);
        }
        cached.getPreferences().addPreferenceChangeListener(weakChangeL);
        preferences.put(mime, cached);
        return cached.getPreferences();
    }
    
    private void clearContents() {
        // clear the old preference values and recreate the panel
        for (MemoryPreferences m : preferences.values()) {
            m.getPreferences().removePreferenceChangeListener(weakChangeL);
            m.destroy();
        }
        preferences.clear();
        if (panel != null) {
            panel.clear();
        }
        changed = false;
    }

    @Override
    public void cancel() {
        clearContents();
    }

    @Override
    public boolean isValid() {
        return true;
        
    }

    @Override
    public boolean isChanged() {
        return changed;
        
    }
    
    private boolean detectIsChanged() {
        for (MemoryPreferences cached : preferences.values()) {
            if (!cached.isDirty(cached.getPreferences())) {
                return true;
            }
        }
        return false;
    }

    @Override
    public JComponent getComponent(Lookup masterLookup) {
        return getPanel();
    }

    @Override
    public HelpCtx getHelpCtx() {
        return new HelpCtx ("netbeans.optionsDialog.editor.folding");
    }

    @Override
    public void addPropertyChangeListener(PropertyChangeListener l) {
        propSupport.addPropertyChangeListener(l);
    }

    @Override
    public void removePropertyChangeListener(PropertyChangeListener l) {
        propSupport.removePropertyChangeListener(l);
    }
    
    private FoldOptionsPanel getPanel() {
        if (panel == null) {
            panel = new FoldOptionsPanel(this);
        }
        return panel;
    }
    
}




<?xml version="1.0" encoding="UTF-8" ?>

<Form version="1.5" maxVersion="1.8" type="org.netbeans.modules.form.forminfo.JPanelFormInfo">
  <AuxValues>
    <AuxValue name="FormSettings_autoResourcing" type="java.lang.Integer" value="1"/>
    <AuxValue name="FormSettings_autoSetComponentName" type="java.lang.Boolean" value="false"/>
    <AuxValue name="FormSettings_generateFQN" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_generateMnemonicsCode" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_i18nAutoMode" type="java.lang.Boolean" value="true"/>
    <AuxValue name="FormSettings_layoutCodeTarget" type="java.lang.Integer" value="1"/>
    <AuxValue name="FormSettings_listenerGenerationStyle" type="java.lang.Integer" value="0"/>
    <AuxValue name="FormSettings_variablesLocal" type="java.lang.Boolean" value="false"/>
    <AuxValue name="FormSettings_variablesModifier" type="java.lang.Integer" value="2"/>
  </AuxValues>

  <Layout>
    <DimensionLayout dim="0">
      <Group type="103" groupAlignment="0" attributes="0">
          <Group type="102" alignment="0" attributes="0">
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="0" attributes="0">
                  <Component id="content" max="32767" attributes="0"/>
                  <Component id="jPanel1" alignment="0" max="32767" attributes="0"/>
                  <Group type="102" attributes="0">
                      <Group type="103" groupAlignment="0" attributes="0">
                          <Component id="useDefaults" min="-2" max="-2" attributes="0"/>
                          <Group type="102" attributes="0">
                              <Component id="langLabel" min="-2" max="-2" attributes="0"/>
                              <EmptySpace max="-2" attributes="0"/>
                              <Component id="langSelect" min="-2" pref="186" max="-2" attributes="0"/>
                              <EmptySpace type="unrelated" max="-2" attributes="0"/>
                              <Component id="enableFolds" min="-2" max="-2" attributes="0"/>
                          </Group>
                      </Group>
                      <EmptySpace min="0" pref="0" max="32767" attributes="0"/>
                  </Group>
              </Group>
              <EmptySpace max="-2" attributes="0"/>
          </Group>
      </Group>
    </DimensionLayout>
    <DimensionLayout dim="1">
      <Group type="103" groupAlignment="0" attributes="0">
          <Group type="102" alignment="0" attributes="0">
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="3" attributes="0">
                  <Component id="langSelect" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="langLabel" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="enableFolds" alignment="3" min="-2" max="-2" attributes="0"/>
              </Group>
              <EmptySpace type="unrelated" max="-2" attributes="0"/>
              <Component id="useDefaults" min="-2" max="-2" attributes="0"/>
              <EmptySpace min="-2" pref="12" max="-2" attributes="0"/>
              <Component id="content" pref="25" max="32767" attributes="0"/>
              <EmptySpace type="separate" max="-2" attributes="0"/>
              <Component id="jPanel1" min="-2" max="-2" attributes="0"/>
              <EmptySpace min="-2" max="-2" attributes="0"/>
          </Group>
      </Group>
    </DimensionLayout>
  </Layout>
  <SubComponents>
    <Component class="javax.swing.JComboBox" name="langSelect">
      <Properties>
        <Property name="model" type="javax.swing.ComboBoxModel" editor="org.netbeans.modules.form.editors2.ComboBoxModelEditor">
          <StringArray count="0"/>
        </Property>
      </Properties>
    </Component>
    <Component class="javax.swing.JLabel" name="langLabel">
      <Properties>
        <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">
          <ResourceString bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="FoldOptionsPanel.langLabel.text" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
        </Property>
      </Properties>
    </Component>
    <Container class="javax.swing.JPanel" name="content">

      <Layout class="org.netbeans.modules.form.compat2.layouts.DesignCardLayout"/>
    </Container>
    <Component class="javax.swing.JCheckBox" name="enableFolds">
      <Properties>
        <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">
          <ResourceString bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="FoldOptionsPanel.enableFolds.text" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
        </Property>
      </Properties>
      <Events>
        <EventHandler event="actionPerformed" listener="java.awt.event.ActionListener" parameters="java.awt.event.ActionEvent" handler="enableFoldsActionPerformed"/>
      </Events>
    </Component>
    <Container class="javax.swing.JPanel" name="jPanel1">
      <Properties>
        <Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor">
          <Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo">
            <TitledBorder title="Display Options">
              <ResourceString PropertyName="titleX" bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="Title_FoldDisplayOptions" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
            </TitledBorder>
          </Border>
        </Property>
      </Properties>

      <Layout>
        <DimensionLayout dim="0">
          <Group type="103" groupAlignment="0" attributes="0">
              <Group type="102" attributes="0">
                  <EmptySpace max="-2" attributes="0"/>
                  <Group type="103" groupAlignment="0" attributes="0">
                      <Component id="contentPreview" alignment="0" min="-2" max="-2" attributes="0"/>
                      <Component id="foldedSummary" alignment="0" min="-2" max="-2" attributes="0"/>
                  </Group>
                  <EmptySpace max="32767" attributes="0"/>
              </Group>
          </Group>
        </DimensionLayout>
        <DimensionLayout dim="1">
          <Group type="103" groupAlignment="0" attributes="0">
              <Group type="102" alignment="0" attributes="0">
                  <EmptySpace max="-2" attributes="0"/>
                  <Component id="contentPreview" min="-2" max="-2" attributes="0"/>
                  <EmptySpace max="-2" attributes="0"/>
                  <Component id="foldedSummary" min="-2" max="-2" attributes="0"/>
                  <EmptySpace max="32767" attributes="0"/>
              </Group>
          </Group>
        </DimensionLayout>
      </Layout>
      <SubComponents>
        <Component class="javax.swing.JCheckBox" name="contentPreview">
          <Properties>
            <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">
              <ResourceString bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="FoldOptionsPanel.contentPreview.text" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
            </Property>
          </Properties>
        </Component>
        <Component class="javax.swing.JCheckBox" name="foldedSummary">
          <Properties>
            <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">
              <ResourceString bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="FoldOptionsPanel.foldedSummary.text" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
            </Property>
          </Properties>
        </Component>
      </SubComponents>
    </Container>
    <Component class="javax.swing.JCheckBox" name="useDefaults">
      <Properties>
        <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">
          <ResourceString bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="FoldOptionsPanel.useDefaults.text" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, &quot;{key}&quot;)"/>
        </Property>
      </Properties>
      <Events>
        <EventHandler event="actionPerformed" listener="java.awt.event.ActionListener" parameters="java.awt.event.ActionEvent" handler="useDefaultsActionPerformed"/>
      </Events>
    </Component>
  </SubComponents>
</Form>




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

import java.awt.CardLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.swing.DefaultComboBoxModel;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComponent;
import javax.swing.JList;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.lexer.Language;
import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;
import org.netbeans.modules.editor.settings.storage.api.EditorSettings;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;

import static org.netbeans.modules.editor.fold.ui.Bundle.*;

/**
 * UI for the folding enable + language switch.
 * The panel contains a placeholder for language-specific contents. When language is selected, it replaces the
 * interior with a language-specific panel.
 *
 * @author sdedic
 */
final class FoldOptionsPanel extends javax.swing.JPanel implements ActionListener, PreferenceChangeListener {
    /**
     * All mime types presented in the selector
     */
    private List<String[]>  languageMimeTypes;
    
    /**
     * Our controller
     */
    private FoldOptionsController ctrl;
    
    private Preferences parentPrefs;
    
    /**
     * Creates new form FoldOptionsPanel
     */
    public FoldOptionsPanel(FoldOptionsController ctrl) {
        this.ctrl = ctrl;
        initComponents();
        
        langSelect.setRenderer(new DefaultListCellRenderer() {
            @Override
            public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
                if (value instanceof String[]) {
                    value = ((String[])value)[1];
                }
                return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); //To change body of generated methods, choose Tools | Templates.
            }
        });
        langSelect.addActionListener(this);
        contentPreview.addActionListener(this);
        foldedSummary.addActionListener(this);
        
        // preferences should be set as a reaction to index selection
    }
    
    /**
     * The preferences object for the currently selected language
     */
    private Preferences currentPreferences;
    
    /**
     * Panels created for individual Mime types
     */
    private Map<String, JComponent> panels = new HashMap<String, JComponent>();
    
    private PreferenceChangeListener wPrefL = WeakListeners.create(PreferenceChangeListener.class, this, null);
    
    private void languageSelected() {
        String[] sel = (String[])langSelect.getSelectedItem();
        if (sel == null) {
            return;
        }
        String mime = sel[0];
        if (currentPreferences != null) {
            currentPreferences.removePreferenceChangeListener(wPrefL);
        }
        currentPreferences = ctrl.prefs(mime);
        JComponent panel = panels.get(mime);
        String parentMime = MimePath.parse(mime).getInheritedType();
        if (parentMime != null) {
            parentPrefs = ctrl.prefs(parentMime);
        } else {
            parentPrefs = null;
        }
        if (panel == null) {
            panel = new DefaultFoldingOptions(mime, currentPreferences);
            if (panel instanceof CustomizerWithDefaults) {
                    ((CustomizerWithDefaults)panel).setDefaultPreferences(parentPrefs);
            }
            panels.put(mime, panel);
            content.add(panel, mime);
        }
        ((CardLayout)content.getLayout()).show(content, mime);
        currentPreferences.addPreferenceChangeListener(wPrefL);
        useDefaults.setVisible(!"".equals(mime)); // NOI18N
        preferenceChange(null);
    }
    
    private void previewChanged() {
        currentPreferences.putBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, contentPreview.isSelected());
    }
    
    private void summaryChanged() {
        currentPreferences.putBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, foldedSummary.isSelected());
    }
    
    @Override
    public void actionPerformed(ActionEvent e) {
        Object o = e.getSource();
        if (ignoreEnableTrigger) {
            return;
        }
        if (o == langSelect) {
            languageSelected();
        } else if (o == contentPreview) {
            previewChanged();
        } else if (o == foldedSummary) {
            summaryChanged();
        }
    }

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        String k = evt == null ? null : evt.getKey();
        ignoreEnableTrigger = true;
        try {
            if (k == null || k.equals(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS)) {
                useDefaults.setSelected(currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true));
            }
            if (k == null || k.equals(SimpleValueNames.CODE_FOLDING_ENABLE)) {
                boolean enabled = currentPreferences.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, true);
                enableFolds.setSelected(enabled);
                contentPreview.setEnabled(enabled);
                foldedSummary.setEnabled(enabled);
                useDefaults.setEnabled(enabled);
            } 
            if (k == null || FoldUtilitiesImpl.PREF_CONTENT_PREVIEW.equals(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW)) {
                contentPreview.setSelected(currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true));
            }
            if (k == null || FoldUtilitiesImpl.PREF_CONTENT_SUMMARY.equals(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY)) {
                foldedSummary.setSelected(currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true));
            } 
            if (k == null || FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS.equals(k)) {
                boolean b = parentPrefs == null || !currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true);
                if (parentPrefs != null) {
                    if (b) {
                        currentPreferences.putBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, 
                                parentPrefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true));
                        currentPreferences.putBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, 
                                parentPrefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true));
                    } else {
                        currentPreferences.remove(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW);
                        currentPreferences.remove(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY);
                    }
                }
                contentPreview.setEnabled(b);
                foldedSummary.setEnabled(b);
                contentPreview.setSelected(currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true));
                foldedSummary.setSelected(currentPreferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true));
            }
        } finally {
            ignoreEnableTrigger = false;
        }
    }
    
    void update() {
        initialize();
    }
    
    @NbBundle.Messages({
        "ITEM_AllLanguages=All Languages"
    })
    private void initialize() {
        Set<String> mimeTypes = EditorSettings.getDefault().getAllMimeTypes();
        List<String[]> langMimes = new ArrayList<String[]>(mimeTypes.size());
        langMimes.add(new String[] { "", ITEM_AllLanguages() }); // NOI18N
        for (String s : mimeTypes) {
            Language l = Language.find(s);
            if (l == null) {
                continue;
            }
            // filter out languages, whose author didn't name it - probably
            // unimportant && should not be displayed.
            String name = EditorSettings.getDefault().getLanguageName(s);
            if (name.equals(s)) {
                continue;
            }
            // last, discard everything that does not have any FoldTypes:
            if (FoldUtilities.getFoldTypes(s).values().isEmpty()) {
                continue;
            }
            langMimes.add(new String[] {
                s, EditorSettings.getDefault().getLanguageName(s)
            });
        }
        Collections.sort(langMimes, LANG_COMPARATOR);
        languageMimeTypes = langMimes;
        
        langSelect.setModel(new DefaultComboBoxModel(languageMimeTypes.toArray(new Object[languageMimeTypes.size()])));
        langSelect.setSelectedIndex(0);
    }
    
    void clear() {
        panels.clear();
    }

    /**
     * Special comparator, which sorts "" mime type first, other Mimetypes are then sorted based on the language names,
     * alphabetically. It is expected  that the 1st member of the String[]is a Mimetype string, the 2nd member is a 
     * human-readable language name.
     */
    private static final Comparator<String[]> LANG_COMPARATOR = new Comparator<String[]>() {
        @Override
        public int compare(String[] o1, String[] o2) {
            if (o1 == null) {
                return -1;
            } else if (o2 == null) {
                return 1;
            }
            if (o1[0].equals(o2[0])) {
                return 0;
            }
            // sort 'all languages' first
            if (o1[0].length() == 0) {
                return -1;
            } else if (o2[0].length() == 0) {
                return 1;
            }
            return o1[1].compareToIgnoreCase(o2[1]);
        }
    };
    
    private boolean ignoreEnableTrigger;

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        langSelect = new javax.swing.JComboBox();
        langLabel = new javax.swing.JLabel();
        content = new javax.swing.JPanel();
        enableFolds = new javax.swing.JCheckBox();
        jPanel1 = new javax.swing.JPanel();
        contentPreview = new javax.swing.JCheckBox();
        foldedSummary = new javax.swing.JCheckBox();
        useDefaults = new javax.swing.JCheckBox();

        org.openide.awt.Mnemonics.setLocalizedText(langLabel, org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "FoldOptionsPanel.langLabel.text")); // NOI18N

        content.setLayout(new java.awt.CardLayout());

        org.openide.awt.Mnemonics.setLocalizedText(enableFolds, org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "FoldOptionsPanel.enableFolds.text")); // NOI18N
        enableFolds.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                enableFoldsActionPerformed(evt);
            }
        });

        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder(org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "Title_FoldDisplayOptions"))); // NOI18N

        org.openide.awt.Mnemonics.setLocalizedText(contentPreview, org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "FoldOptionsPanel.contentPreview.text")); // NOI18N

        org.openide.awt.Mnemonics.setLocalizedText(foldedSummary, org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "FoldOptionsPanel.foldedSummary.text")); // NOI18N

        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
        jPanel1.setLayout(jPanel1Layout);
        jPanel1Layout.setHorizontalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel1Layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(contentPreview)
                    .addComponent(foldedSummary))
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        jPanel1Layout.setVerticalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel1Layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(contentPreview)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(foldedSummary)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        org.openide.awt.Mnemonics.setLocalizedText(useDefaults, org.openide.util.NbBundle.getMessage(FoldOptionsPanel.class, "FoldOptionsPanel.useDefaults.text")); // NOI18N
        useDefaults.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                useDefaultsActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(content, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                    .addGroup(layout.createSequentialGroup()
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(useDefaults)
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(langLabel)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(langSelect, javax.swing.GroupLayout.PREFERRED_SIZE, 186, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                                .addComponent(enableFolds)))
                        .addGap(0, 0, Short.MAX_VALUE)))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(langSelect, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(langLabel)
                    .addComponent(enableFolds))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addComponent(useDefaults)
                .addGap(12, 12, 12)
                .addComponent(content, javax.swing.GroupLayout.DEFAULT_SIZE, 25, Short.MAX_VALUE)
                .addGap(18, 18, 18)
                .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap())
        );
    }// </editor-fold>//GEN-END:initComponents

    private void enableFoldsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_enableFoldsActionPerformed
        if (ignoreEnableTrigger) {
            return;
        }
        boolean enable = enableFolds.isSelected();
        currentPreferences.putBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, enable);
        // visual feedback handled by listener.
    }//GEN-LAST:event_enableFoldsActionPerformed

    private void useDefaultsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_useDefaultsActionPerformed
        if (ignoreEnableTrigger) {
            return;
        }
        currentPreferences.putBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, 
                useDefaults.isSelected());
    }//GEN-LAST:event_useDefaultsActionPerformed

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JPanel content;
    private javax.swing.JCheckBox contentPreview;
    private javax.swing.JCheckBox enableFolds;
    private javax.swing.JCheckBox foldedSummary;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JLabel langLabel;
    private javax.swing.JComboBox langSelect;
    private javax.swing.JCheckBox useDefaults;
    // End of variables declaration//GEN-END:variables
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold.ui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
import javax.swing.event.AncestorEvent;
import javax.swing.event.AncestorListener;
import javax.swing.text.JTextComponent;
import org.netbeans.modules.editor.lib2.view.DocumentView;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;

/**
 * Component that displays a collapsed fold preview.
 *
 * @author Miloslav Metelka
 */
final class FoldToolTip extends JPanel {
    private int editorPaneWidth;

    public FoldToolTip(JEditorPane editorPane, final JEditorPane foldPreviewPane, Color borderColor) {
        setLayout(new BorderLayout());
        add(foldPreviewPane, BorderLayout.CENTER);
        putClientProperty("tooltip-type", "fold-preview"); // Checked in NbToolTip

        addGlyphGutter(foldPreviewPane);
        
        addAncestorListener(new AncestorListener() {
            @Override
            public void ancestorAdded(AncestorEvent event) {
            }

            @Override
            public void ancestorRemoved(AncestorEvent event) {
                // Deactivate the view hierarchy immediately for foldPreviewPane
                final DocumentView docView = DocumentView.get(foldPreviewPane);
                if (docView != null) {
                    docView.runTransaction(new Runnable() {
                        @Override
                        public void run() {
                            docView.updateLengthyAtomicEdit(+100); // Effectively disable any VH updates
                        }
                    });
                }
                // Remove the listener
                FoldToolTip.this.removeAncestorListener(this);
            }

            @Override
            public void ancestorMoved(AncestorEvent event) {
            }
        });

        editorPaneWidth = editorPane.getSize().width;

        setBorder(new LineBorder(borderColor));
        setOpaque(true);
    }
    
    private void addGlyphGutter(JTextComponent jtx) {
        ClassLoader cls = Lookup.getDefault().lookup(ClassLoader.class);
        Class clazz;
        Class editorUiClass;
        
        JComponent gutter = null;
        try {
            clazz = Class.forName("org.netbeans.editor.GlyphGutter", true, cls); // NOI18N
            editorUiClass = Class.forName("org.netbeans.editor.EditorUI", true, cls); // NOI18N
            // get the factory instance
            Object o = clazz.newInstance();
            Method m = clazz.getDeclaredMethod("createSideBar", JTextComponent.class); // NOI18N
            gutter = (JComponent)m.invoke(o, jtx);
        } catch (IllegalArgumentException ex) {
            Exceptions.printStackTrace(ex);
        } catch (InvocationTargetException ex) {
            Exceptions.printStackTrace(ex);
        } catch (NoSuchMethodException ex) {
            Exceptions.printStackTrace(ex);
        } catch (SecurityException ex) {
            Exceptions.printStackTrace(ex);
        } catch (InstantiationException ex) {
            Exceptions.printStackTrace(ex);
        } catch (IllegalAccessException ex) {
            Exceptions.printStackTrace(ex);
        } catch (ClassNotFoundException ex) {
            Exceptions.printStackTrace(ex);
        }
        if (gutter != null) {
            add(gutter, BorderLayout.WEST);
        }
    }

    @Override
    public Dimension getPreferredSize() {
        Dimension prefSize = super.getPreferredSize();
        // Return width like for editor pane which forces the PopupManager to display
        // the tooltip to align exacty with the text (below/above).
        prefSize.width = Math.min(prefSize.width, editorPaneWidth);
        return prefSize;
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold.ui;

import org.netbeans.modules.editor.fold.ui.FoldViewFactory;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.font.FontRenderContext;
import java.awt.font.TextHitInfo;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
import java.util.logging.Logger;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import javax.swing.text.Position.Bias;
import javax.swing.text.StyleConstants;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.fold.FoldContentReaders;
import org.netbeans.modules.editor.lib2.view.EditorView;
import org.netbeans.modules.editor.lib2.view.ViewRenderContext;
import org.netbeans.modules.editor.lib2.view.ViewUtils;
import org.openide.util.NbBundle;

import static org.netbeans.modules.editor.fold.ui.Bundle.*;


/**
 * View with highlights. This is the most used view.
 *
 * @author Miloslav Metelka
 */

final class FoldView extends EditorView {

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

    /**
     * Extra space added to each side of description text of a fold view.
     */
    private static final float EXTRA_MARGIN_WIDTH = 3;

    /** Raw end offset of this view. */
    private int rawEndOffset; // 24-super + 4 = 28 bytes

    /** Length of text occupied by this view. */
    private int length; // 28 + 4 = 32 bytes

    private final JTextComponent textComponent; // 32 + 4 = 36 bytes

    private final Fold fold; // 36 + 4 = 40 bytes
    
    private TextLayout collapsedTextLayout; // 40 + 4 = 44 bytes
    
    private AttributeSet    foldingColors;
    
    private int options;

    public FoldView(JTextComponent textComponent, Fold fold, FontColorSettings colorSettings, int options) {
        super(null);
        int offset = fold.getStartOffset();
        int len = fold.getEndOffset() - offset;
        assert (len > 0) : "length=" + len + " <= 0"; // NOI18N
        this.length = len;
        this.textComponent = textComponent;
        this.fold = fold;
        this.foldingColors = colorSettings.getFontColors(FontColorNames.CODE_FOLDING_COLORING);
        this.options = options;
    }

    @Override
    public float getPreferredSpan(int axis) {
        if (axis == View.X_AXIS) {
            String desc = fold.getDescription(); // For empty desc a single-space text layout is returned
            float advance = 0;
            if (desc.length() > 0) {
                TextLayout textLayout = getTextLayout();
                if (textLayout == null) {
                    return 0f;
                }
                advance = textLayout.getAdvance();
            }
            return advance + (2 * EXTRA_MARGIN_WIDTH);
        } else {
            EditorView.Parent parent = (EditorView.Parent) getParent();
            return (parent != null) ? parent.getViewRenderContext().getDefaultRowHeight() : 0f;
        }
    }

    @Override
    public int getRawEndOffset() {
        return rawEndOffset;
    }

    @Override
    public void setRawEndOffset(int rawOffset) {
        this.rawEndOffset = rawOffset;
    }

    @Override
    public int getLength() {
        return length;
    }

    @Override
    public int getStartOffset() {
        return getEndOffset() - getLength();
    }

    @Override
    public int getEndOffset() {
        EditorView.Parent parent = (EditorView.Parent) getParent();
        return (parent != null) ? parent.getViewEndOffset(rawEndOffset) : rawEndOffset;
    }

    @Override
    public Document getDocument() {
        View parent = getParent();
        return (parent != null) ? parent.getDocument() : null;
    }

    @Override
    public AttributeSet getAttributes() {
        return null;
    }
    
    @NbBundle.Messages({
        "# {0} - number of lines",
        "FMT_contentSummary={0} line(s)"
    })
    private String resolvePlaceholder(String text, int at) {
        if ((options & 3) == 0) {
            return text;
        }
        Document d = getDocument();
        if (!(d instanceof BaseDocument)) {
            return null;
        }
        BaseDocument bd = (BaseDocument)d;
        CharSequence contentSeq = ""; // NOI18N
        String summary = ""; // NOI18N
        
        int mask = options;
        try {
            if ((options & 1) > 0) {
                    contentSeq = FoldContentReaders.get().readContent(
                           org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(textComponent),
                           d, 
                           fold, 
                           fold.getType().getTemplate());
                    if (contentSeq == null) {
                        mask &= ~1;
                    }
            }
            if ((options & 2) > 0) {
                int start = fold.getStartOffset();
                int end = fold.getEndOffset();
                int startLine = Utilities.getLineOffset(bd, start);
                int endLine = Utilities.getLineOffset(bd, end) + 1;
                
                if (endLine <= startLine + 1) {
                    mask &= ~2;
                } else {
                    summary = FMT_contentSummary((endLine - startLine));
                }
            }
        } catch (BadLocationException ex) {
        }
        if (mask == 0) {
            return text;
        }
        String replacement = NbBundle.getMessage(FoldView.class, "FMT_ContentPlaceholder_" + (mask & 3), contentSeq, summary);
        StringBuilder sb = new StringBuilder(text.length() + replacement.length());
        sb.append(text.subSequence(0, at));
        sb.append(replacement);
        sb.append(text.subSequence(at + FoldTemplate.CONTENT_PLACEHOLDER.length(), text.length()));
        return sb.toString();
    }

    private TextLayout getTextLayout() {
        if (collapsedTextLayout == null) {
            EditorView.Parent parent = (EditorView.Parent) getParent();
            ViewRenderContext context = parent.getViewRenderContext();
            FontRenderContext frc = context.getFontRenderContext();
            assert (frc != null) : "Null FontRenderContext"; // NOI18N
            Font font = context.getRenderFont(textComponent.getFont());
            String text = fold.getDescription();
            if (text.length() == 0) {
                text = " "; // Use single space (mainly for height measurement etc.
            }
            int placeIndex = text.indexOf(FoldTemplate.CONTENT_PLACEHOLDER);
            if (placeIndex > -1) {
                text = resolvePlaceholder(text, placeIndex);
            }
            collapsedTextLayout = new TextLayout(text, font, frc);
        }
        return collapsedTextLayout;
    }

    @Override
    public Shape modelToViewChecked(int offset, Shape alloc, Position.Bias bias) {
//        TextLayout textLayout = getTextLayout();
//        if (textLayout == null) {
//            return alloc; // Leave given bounds
//        }
//        Rectangle2D.Double bounds = ViewUtils.shape2Bounds(alloc);
//        return bounds;
        return alloc;
    }

    @Override
    public int viewToModelChecked(double x, double y, Shape alloc, Position.Bias[] biasReturn) {
        int startOffset = getStartOffset();
        return startOffset;
    }

    static TextHitInfo x2RelOffset(TextLayout textLayout, float x) {
        TextHitInfo hit;
        x -= EXTRA_MARGIN_WIDTH;
        if (x >= textLayout.getAdvance()) {
            hit = TextHitInfo.trailing(textLayout.getCharacterCount());
        } else {
            hit = textLayout.hitTestChar(x, 0); // What about backward bias -> with higher offsets it may go back visually
        }
        return hit;

    }

    @Override
    public int getNextVisualPositionFromChecked(int offset, Bias bias, Shape alloc, int direction, Bias[] biasRet) {
        int startOffset = getStartOffset();
        int retOffset = -1;
        switch (direction) {
            case WEST:
                if (offset == -1) {
                    retOffset = startOffset;
                } else {
                    retOffset = -1;
                }
                break;

            case EAST:
                if (offset == -1) {
                    retOffset = startOffset;
                } else {
                    retOffset = -1;
                }
                break;

            case NORTH:
            case SOUTH:
                break;
            default:
                throw new IllegalArgumentException("Bad direction: " + direction);
        }
        return retOffset;
    }

    @Override
    public JComponent getToolTip(double x, double y, Shape allocation) {
        Container container = getContainer();
        if (container instanceof JEditorPane) {
            JEditorPane editorPane = (JEditorPane) getContainer();
            JEditorPane tooltipPane = new JEditorPane();
            EditorKit kit = editorPane.getEditorKit();
            Document doc = getDocument();
            if (kit != null && doc != null) {
                Element lineRootElement = doc.getDefaultRootElement();
                tooltipPane.putClientProperty(FoldViewFactory.VIEW_FOLDS_EXPANDED_PROPERTY, true);
                try {
                    // Start-offset of the fold => line start => position
                    int lineIndex = lineRootElement.getElementIndex(fold.getStartOffset());
                    Position pos = doc.createPosition(
                            lineRootElement.getElement(lineIndex).getStartOffset());
                    // DocumentView.START_POSITION_PROPERTY
                    tooltipPane.putClientProperty("document-view-start-position", pos);
                    // End-offset of the fold => line end => position
                    lineIndex = lineRootElement.getElementIndex(fold.getEndOffset());
                    pos = doc.createPosition(lineRootElement.getElement(lineIndex).getEndOffset());
                    // DocumentView.END_POSITION_PROPERTY
                    tooltipPane.putClientProperty("document-view-end-position", pos);
                    tooltipPane.putClientProperty("document-view-accurate-span", true);
                    // Set the same kit and document
                    tooltipPane.setEditorKit(kit);
                    tooltipPane.setDocument(doc);
                    tooltipPane.setEditable(false);
                    return new FoldToolTip(editorPane, tooltipPane, getForegroundColor());
                } catch (BadLocationException e) {
                    // => return null
                }
            }
        }
        return null;
    }
    
    private Color getForegroundColor() {
        if (foldingColors == null) {
            return textComponent.getForeground();
        }
        Object bgColorObj = foldingColors.getAttribute(StyleConstants.Foreground);
        if (bgColorObj instanceof Color) {
            return (Color)bgColorObj;
        } else {
            return textComponent.getForeground();
        }
    }

    private Color getBackgroundColor() {
        if (foldingColors == null) {
            return textComponent.getBackground();
        }
        Object bgColorObj = foldingColors.getAttribute(StyleConstants.Background);
        if (bgColorObj instanceof Color) {
            return (Color)bgColorObj;
        } else {
            return textComponent.getBackground();
        }
    }

    @Override
    public void paint(Graphics2D g, Shape alloc, Rectangle clipBounds) {
        Rectangle2D.Double allocBounds = ViewUtils.shape2Bounds(alloc);
        if (allocBounds.intersects(clipBounds)) {
            Font origFont = g.getFont();
            Color origColor = g.getColor();
            Color origBkColor = g.getBackground();
            Shape origClip = g.getClip();
            try {
                // Leave component font
                g.setColor(getForegroundColor());
                g.setBackground(getBackgroundColor());

                int xInt = (int) allocBounds.getX();
                int yInt = (int) allocBounds.getY();
                int endXInt = (int) (allocBounds.getX() + allocBounds.getWidth() - 1);
                int endYInt = (int) (allocBounds.getY() + allocBounds.getHeight() - 1);
                g.drawRect(xInt, yInt, endXInt - xInt, endYInt - yInt);
                g.clearRect(xInt + 1, yInt + 1, endXInt - xInt - 1, endYInt - yInt - 1);
                g.clip(alloc);
                TextLayout textLayout = getTextLayout();
                if (textLayout != null) {
                    EditorView.Parent parent = (EditorView.Parent) getParent();
                    float ascent = parent.getViewRenderContext().getDefaultAscent();
                    String desc = fold.getDescription(); // For empty desc a single-space text layout is returned
                    float x = (float) (allocBounds.getX() + EXTRA_MARGIN_WIDTH);
                    float y = (float) allocBounds.getY();
                    if (desc.length() > 0) {
                        
                        textLayout.draw(g, x, y + ascent);
                    }
                }
            } finally {
                g.setClip(origClip);
                g.setBackground(origBkColor);
                g.setColor(origColor);
                g.setFont(origFont);
            }
        }
    }

    @Override
    protected String getDumpName() {
        return "FV";
    }

    @Override
    public String toString() {
        return appendViewInfo(new StringBuilder(200), 0, "", -1).toString();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-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.editor.fold.ui;

import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.modules.editor.fold.FoldUtilitiesImpl;
import org.netbeans.modules.editor.lib2.view.EditorView;
import org.netbeans.modules.editor.lib2.view.EditorViewFactory;
import org.netbeans.modules.editor.lib2.view.EditorViewFactoryChange;
import org.netbeans.modules.editor.lib2.view.ViewUtils;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.WeakListeners;

/**
 * View factory creating views for collapsed folds.
 *
 * @author Miloslav Metelka
 */

@SuppressWarnings("ClassWithMultipleLoggers")
public final class FoldViewFactory extends EditorViewFactory implements FoldHierarchyListener, LookupListener, PreferenceChangeListener {

    /**
     * Component's client property which can be set to view folds expanded for tooltip fold preview.
     */
    static final String VIEW_FOLDS_EXPANDED_PROPERTY = "view-folds-expanded"; // NOI18N

    // -J-Dorg.netbeans.editor.view.change.level=FINE
    static final Logger CHANGE_LOG = Logger.getLogger("org.netbeans.editor.view.change");

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

    public static void register() {
        EditorViewFactory.registerFactory(new FoldFactory());
    }

    private FoldHierarchy foldHierarchy;

    private boolean foldHierarchyLocked;

    private Fold fold;

    private int foldStartOffset;

    private Iterator<Fold> collapsedFoldIterator;

    private boolean viewFoldsExpanded;
    
    /**
     * Composite Color settings from MIME lookup
     */
    private FontColorSettings   colorSettings;

    /**
     * Lookup results for color settings, being listened for changes.
     */
    private Lookup.Result       colorSource;
    
    private Preferences         prefs;
    
    private int viewFlags = 0;

    public FoldViewFactory(View documentView) {
        super(documentView);
        foldHierarchy = FoldHierarchy.get(textComponent());
        foldHierarchy.addFoldHierarchyListener(this);
        viewFoldsExpanded = Boolean.TRUE.equals(textComponent().getClientProperty(VIEW_FOLDS_EXPANDED_PROPERTY));
        
        String mime = DocumentUtilities.getMimeType(document());
        
        Lookup lkp = MimeLookup.getLookup(mime);
        colorSource = lkp.lookupResult(FontColorSettings.class);
        colorSource.addLookupListener(WeakListeners.create(LookupListener.class, this, colorSource));
        colorSettings = (FontColorSettings)colorSource.allInstances().iterator().next();
        prefs = lkp.lookup(Preferences.class);
        prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, this, prefs));
        
        initViewFlags();
    }
    
    private void initViewFlags() {
        viewFlags =
                (prefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true) ? 1 : 0) |
                (prefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true) ? 2 : 0);
    }

    @Override
    public void resultChanged(LookupEvent ev) {
        refreshColors();
    }

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        String k = evt.getKey();
        if (FoldUtilitiesImpl.PREF_CONTENT_PREVIEW.equals(k) ||
            FoldUtilitiesImpl.PREF_CONTENT_SUMMARY.equals(k)) {
            initViewFlags();
            document().render(new Runnable() {
                @Override
                public void run() {
                    int end = document().getLength();
                    fireEvent(EditorViewFactoryChange.createList(0, end, EditorViewFactoryChange.Type.CHARACTER_CHANGE));
                }
            });
        }
    }

    private void refreshColors() {
        colorSettings = (FontColorSettings)colorSource.allInstances().iterator().next();
        document().render(new Runnable() {
            @Override
            public void run() {
                int end = document().getLength();
                fireEvent(EditorViewFactoryChange.createList(0, end, EditorViewFactoryChange.Type.CHARACTER_CHANGE));
            }
        });
    }

    @Override
    public void restart(int startOffset, int endOffset, boolean createViews) {
        foldHierarchy.lock(); // this.finish() always called in try-finally
        foldHierarchyLocked = true;
        @SuppressWarnings("unchecked")
        Iterator<Fold> it = FoldUtilities.collapsedFoldIterator(foldHierarchy, startOffset, Integer.MAX_VALUE);
        collapsedFoldIterator = it;
        foldStartOffset = -1; // Make a next call to updateFold() to fetch a fold
    }

    private void updateFold(int offset) {
        if (foldStartOffset < offset) {
            while (collapsedFoldIterator.hasNext()) {
                fold = collapsedFoldIterator.next();
                foldStartOffset = fold.getStartOffset();
                if (foldStartOffset >= offset) {
                    return;
                }
            }
            fold = null;
            foldStartOffset = Integer.MAX_VALUE;
        }
    }

    @Override
    public int nextViewStartOffset(int offset) {
        if (!viewFoldsExpanded) {
            updateFold(offset);
            return foldStartOffset;
        }
        return Integer.MAX_VALUE;
    }

    @Override
    public EditorView createView(int startOffset, int limitOffset, boolean forcedLimit,
    EditorView origView, int nextOrigViewOffset) {
        assert (startOffset == foldStartOffset) : "startOffset=" + startOffset + " != foldStartOffset=" + foldStartOffset; // NOI18N
        if (fold.getEndOffset() <= limitOffset || !forcedLimit) {
            return new FoldView(textComponent(), fold, colorSettings, viewFlags);
        } else {
            return null;
        }
    }
    
    @Override
    public int viewEndOffset(int startOffset, int limitOffset, boolean forcedLimit) {
        int foldEndOffset = fold.getEndOffset();
        if (foldEndOffset <= limitOffset) {
            return foldEndOffset;
        } else {
            return -1;
        }
    }

    @Override
    public void continueCreation(int startOffset, int endOffset) {
    }

    @Override
    public void finishCreation() {
        fold = null;
        collapsedFoldIterator = null;
        if (foldHierarchyLocked) {
            foldHierarchy.unlock();
        }
    }

    @Override
    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
        // For fold state changes use a higher priority
        int startOffset = evt.getAffectedStartOffset();
        int endOffset = evt.getAffectedEndOffset();
        if (CHANGE_LOG.isLoggable(Level.FINE)) {
            ViewUtils.log(CHANGE_LOG, "CHANGE in FoldViewFactory: <" + // NOI18N
                    startOffset + "," + endOffset + ">\n"); // NOI18N
        }
        fireEvent(EditorViewFactoryChange.createList(startOffset, endOffset,
                EditorViewFactoryChange.Type.PARAGRAPH_CHANGE));
    }

    public static final class FoldFactory implements EditorViewFactory.Factory {

        @Override
        public EditorViewFactory createEditorViewFactory(View documentView) {
            return new FoldViewFactory(documentView);
        }

        @Override
        public int weight() {
            return 100;
        }

    }

}




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

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.prefs.AbstractPreferences;
import java.util.prefs.BackingStoreException;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;

/**
 * Support for inheriting Preferences, while still working with stored ones.
 * 
 * This class solves the 'diamond inheritance', which is present during editing:
 * a MIME-type preferences derive from BOTH its persistent values (preferred) and
 * from the parent, whose actual values are potentially transient, and also persistent.
 * <p/>
 * Let us assume the following assignment:
 * <ul>
 * <li>TC (this current) = currently added/changed/removed values
 * <li>TP (this persistent) = persistent values, the getLocal() part of the Mime PreferencesImpl object
 * <li>PC (parent current) = currently added/changed/removed values of the parent
 * <li>PP (parent persistent) = persistent values, the getLocal() part of the parent MimePreferences
 * </ul>
 * The desired priority to find a value is: TC, TP, PC, PP. Because of {@link MemoryPreferences}, the
 * PC, PP (and potentially fallback to a grandparent) we already have, if we use the parent's {@link MemoryPreferences}
 * preferences as 'inherited'. The "TC" is handled by ProxyPreferences for this Mime node. In InheritedPreferences,
 * we must only inject the TP in between TC and the parent's preferences (PC, PP, ...)
 * <p/>
 * The object is intended to act as a ProxyPreferences delegate, all writes go directly to the stored
 * Mime preferences.
 * 
 * @author sdedic
 */
public final class InheritedPreferences extends AbstractPreferences implements PreferenceChangeListener, OverridePreferences  {
    /**
     * Preferences inherited, ie from a parent Mime type
     */
    private Preferences inherited;
    
    /**
     * Stored preferences, 
     */
    private Preferences stored;
    
    public InheritedPreferences(Preferences inherited, Preferences stored) {
        super(null, ""); // NOI18N
        this.inherited = inherited;
        if (!(stored instanceof OverridePreferences)) {
            throw new IllegalArgumentException();
        }
        this.stored = stored;
        
        inherited.addPreferenceChangeListener(this);
    }
    
    @Override
    protected void putSpi(String key, String value) {
        // do nothing, the AbstractPref then just fires an event
    }

    @Override
    public void put(String key, String value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.put(key, value);
        }
        super.put(key, value);
    }

    @Override
    public void putInt(String key, int value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putInt(key, value);
        }
        super.putInt(key, value); 
    }

    @Override
    public void putLong(String key, long value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putLong(key, value);
        }
        super.putLong(key, value);
    }

    @Override
    public void putBoolean(String key, boolean value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putBoolean(key, value);
        }
        super.putBoolean(key, value);
    }

    @Override
    public void putFloat(String key, float value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putFloat(key, value);
        }
        super.putFloat(key, value); 
    }

    @Override
    public void putDouble(String key, double value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putDouble(key, value);
        }
        super.putDouble(key, value); 
    }

    @Override
    public void putByteArray(String key, byte[] value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putByteArray(key, value);
        }
        super.putByteArray(key, value);
    }
    
    private ThreadLocal<Boolean> ignorePut = new ThreadLocal<Boolean>();

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        if (!isOverriden(evt.getKey())) {
            // jusr refires an event
            ignorePut.set(true);
            try {
                put(evt.getKey(), evt.getNewValue());
            } finally {
                ignorePut.set(false);
            }
        }
    }
    
    /**
     * The value is defined locally, if the stored prefs define the value
     * locally. The parent definitions do not count. It is expected, that the
     * ProxyPreferences will report its local overrides as local in front of this
     * InheritedPreferences.
     * 
     * @param k
     * @return 
     */
    public @Override boolean isOverriden(String k) {
        if (stored instanceof OverridePreferences) {
            return ((OverridePreferences)stored).isOverriden(k);
        } else {
            return true;
        }
    }
    
    @Override
    protected String getSpi(String key) {
        // check the stored values
        OverridePreferences localStored = (OverridePreferences)stored;
        if (localStored.isOverriden(key)) {
            return stored.get(key, null);
        }
        // fall back to the inherited prefs, potentially its stored values etc.
        return inherited.get(key, null);
    }

    @Override
    protected void removeSpi(String key) {
        stored.remove(key);
    }

    @Override
    protected void removeNodeSpi() throws BackingStoreException {
        stored.removeNode();
    }

    @Override
    protected String[] keysSpi() throws BackingStoreException {
        Collection<String> names = new HashSet<String>();
        names.addAll(Arrays.asList(stored.keys()));
        names.addAll(Arrays.asList(inherited.keys()));
        return names.toArray(new String[names.size()]);
    }

    @Override
    protected String[] childrenNamesSpi() throws BackingStoreException {
        if (stored != null) {
            return stored.childrenNames();
        } else {
            return new String[0];
        }
    }

    @Override
    protected AbstractPreferences childSpi(String name) {
        Preferences storedNode = stored != null ? stored.node(name) : null;
        if (storedNode != null) {
            return new InheritedPreferences(null, storedNode);
        } else {
            return null;
        }
    }

    @Override
    protected void syncSpi() throws BackingStoreException {
        stored.sync();
    }

    @Override
    protected void flushSpi() throws BackingStoreException {
        stored.flush();
    }
    
    
}




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

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * Simple layout, which fills the space vertically, then overflows to the next column.
 *
 * @author sdedic
 */
final class VerticalFlowLayout implements LayoutManager2 {

    final private Set<Component> components = new LinkedHashSet<Component>();
    private int hgap = 0;
    private int vgap = 0;

    public void setHGap(int hgap) {
        this.hgap = hgap;
    }

    public void setVGap(int vgap) {
        this.vgap = vgap;
    }

    @Override
    public void addLayoutComponent(Component comp, Object constraints) {
        this.components.add(comp);
    }

    @Override
    public float getLayoutAlignmentX(Container target) {
        return 0;
    }

    @Override
    public float getLayoutAlignmentY(Container target) {
        return 0;
    }

    @Override
    public void invalidateLayout(Container target) {
    }

    @Override
    public void addLayoutComponent(String name, Component comp) {
        this.components.add(comp);
    }

    private Dimension computeDimension(Container parent, int type) {
        Insets insets = parent.getInsets();
        int x = insets.left;
        int y = insets.top;
        int columnWidth = 0;
        // int limitHeight = parent.getHeight() - insets.bottom;
        int maxY = 0;

        for (Component c : this.components) {
            if (c.isVisible()) {
                Dimension d;

                switch (type) {
                    case 0:
                        d = c.getPreferredSize();
                        break;
                    case 1:
                        d = c.getMinimumSize();
                        break;
                    default:
                        d = c.getMaximumSize();
                        break;
                }
                columnWidth = Math.max(columnWidth, d.width);
                /*
                if (limitHeight != 0 && y + d.height >= limitHeight) {
                    x += columnWidth + this.hgap;
                    y = insets.top;
                    columnWidth = d.width;
                }
                */
                y += d.height;
                maxY = Math.max(y, maxY);
                y += this.vgap;
            }
        }
        x += columnWidth;
        return new Dimension(x, maxY);
    }

    @Override
    public void layoutContainer(Container parent) {
        Insets insets = parent.getInsets();
        int x = insets.left;
        int y = insets.top;
        int columnWidth = 0;
        int limitHeight = parent.getHeight() - insets.bottom;
        for (Component c : this.components) {
            if (c.isVisible()) {
                Dimension d = c.getPreferredSize();
                columnWidth = Math.max(columnWidth, d.width);
                if (y + d.height >= limitHeight) {
                    x += columnWidth + this.hgap;
                    y = insets.top;
                }
                c.setBounds(x, y, d.width, d.height);
                y += d.height + this.vgap;
            }
        }
    }

    @Override
    public Dimension minimumLayoutSize(Container parent) {
        return computeDimension(parent, 1);
    }

    @Override
    public Dimension preferredLayoutSize(Container parent) {
        return computeDimension(parent, 1);
    }

    @Override
    public Dimension maximumLayoutSize(Container target) {
        return computeDimension(target, 2);
    }

    @Override
    public void removeLayoutComponent(Component comp) {
        this.components.remove(comp);
    }
}




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

import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.spi.editor.mimelookup.MimeLocation;

/**
 * Callback interface, which is called to extract description for a fold.
 * The Reader will be called to produce a preview text to be displayed in the
 * folded view. The reader will be called under document lock, although the fold
 * hierarchy will not be locked. You may query the fold properties, but may not
 * traverse the fold hierarchy.
 * <p/>
 * An instance of ContentReader is used repeatedly, i.e. if the same FoldTemplate
 * is assigned to multiple folds. It is advised that the implementation of ContentReader
 * is stateless.
 * 
 * @author sdedic
 */
public interface ContentReader {
    /**
     * Acquires text for fold content.
     * The method is executed under <i>read lock</i> on the Document. However, the Fold Hierarchy
     * is not locked. Accessing fold offsets should be safe, but relationships with other Folds
     * (parents, children, root) are not guarded.
     * <p/>
     * If the ContentReader cannot extract the contents (i.e. it does not want to handle the fold), 
     * {@code null} may be returned. If more ContentReaders are registered, some other instance might
     * handle the fold properly. If not, the placeholder will be retained and presented in the fold 
     * text.
     * 
     * @param d the document to read from
     * @param f fold, whose contents should be read
     * @param ft the original fold template, if available
     * @return content to be displayed in the folded view, or {@code null} if unwilling to retrieve the content.
     */
    public CharSequence read(Document d, Fold f, FoldTemplate ft) throws BadLocationException;

    /**
     * Factory, which produces ContentReader instance(s) appropriate for the fold type.
     * The returned instance may be used to read contents for all folds of the given type, in 
     * different documents (of the same mime type).
     */
    @MimeLocation(subfolderName = "FoldManager")
    public interface Factory {
        /**
         * @param ft the fold type
         * @return ContentReader instance or {@code null}, if content should not be presented in the fold preview.
         */
        public ContentReader    createReader(FoldType ft);
    }
}





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

import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.api.editor.fold.FoldType;
import org.openide.util.Parameters;

/**
 * The FoldInfo encapsulates the information passed to the
 * {@link FoldOperation#addToHierarchy(org.netbeans.api.editor.fold.FoldType, int, int, org.netbeans.api.editor.fold.FoldTemplate, boolean, java.lang.Object, org.netbeans.spi.editor.fold.FoldHierarchyTransaction).
 * Set of FoldInfos can be then applied to the FoldHieararchy, creating new, and removing obsolete Folds, so that 
 * Folds which prevail remain in the hierarchy. The mandatory information is start and end of the fold, and the {@link FoldType}.
 * If necessary, a {@link FoldTemplate} attached to the FoldType can be overriden for the specific Fold instance. Note though, that
 * if the FoldTemplate instance changes with the next fold update, the Fold may fire change events.
 * <p/>
 * Ultimately, it is possible to hand-override the Fold's description from the FoldTemplate provided value.
 * <p/>
 * If the FoldInfo is used to update an existing Fold, the or the FoldTemplate's properties 
 * collapsed state are  updated to the existing Fold instance. Appropriate fold change event is fired. It is not possible
 * to change the type of the fold.
 * <p/>
 * Initial folding state can be specified, for the case the fold will be created (it does not exist). If unspecified,
 * the infrastructure can assign an appropriate state based on e.g. user preferences. Collapsed state is never changed
 * for existing folds, even though FoldInfo specifies a value.
 * 
 * Use {@link FoldUtilities#update} to perform the process.
 * 
 * @author sdedic
 */
public final class FoldInfo {
    /**
     * Start of the folded region
     */
    private int start;
    
    /**
     * End of the folded region
     */
    private int end;
    
    /**
     * Tooltip contents and guarded areas of the fold. Defaults to the FoldTemplate present in the FoldType.
     */
    private FoldTemplate template;
    
    /**
     * The fold type of the fold
     */
    private FoldType type;
    
    /**
     * Determines whether the fold should be initially collapsed. Value of null means
     * the collapsed state should be computed by the infrastructure. Non-null value will
     * force the fold to expand or collapse.
     */
    private Boolean collapsed;
    
    /**
     * Extra information attached to a Fold
     */
    private Object  extraInfo;
    
    /**
     * Custom description, overriding the default one in the template
     */
    private String  description;
    
    /**
     * Creates a FoldInfo for the specified range.
     * 
     * @param start start offset
     * @param end end offset
     * @param type type of the fold
     * @return FoldInfo instance
     */
    public static FoldInfo range(int start, int end, FoldType type) {
        return new FoldInfo(start, end, type);
    }
    
    private FoldInfo(int start, int end, FoldType ft) {
        Parameters.notNull("ft", ft);
        if (start < 0) {
            throw new IllegalArgumentException("Invalid start offet: " + start);
        }
        if (end < start) {
            throw new IllegalArgumentException("Invalid end offset: " + end + ", start is: " + start);
        }
        this.type = ft;
        this.start = start;
        this.end = end;
        this.template = ft.getTemplate();
    }
    
    /**
     * Attaches FoldTemplate to the FoldInfo.
     * The instance will be used to configure or update the Fold instance in preference to {@link FoldType#getTemplate}.
     * 
     * @param t fold template
     * @return this instance
     */
    public FoldInfo withTemplate(FoldTemplate t) {
        Parameters.notNull("t", t);
        this.template = t;
        return this;
    }
    
    /**
     * Use to provide a custom description for the fold.
     * The description overrides all other ones taken from FoldTemplates. The description can use
     * content placeholder (see {@link FoldTemplate} for explanation. When {@code null} is set, the
     * description Fold reverts back to the one provided by FoldTemplates (the override is cleared).
     * 
     * @param desc description text.
     * @return this instance
     */
    public FoldInfo withDescription(String desc) {
        this.description = desc;
        return this;
    }
    
    /**
     * Attaches custom extra info to the fold.
     * The extra info will be available from {@link org.netbeans.api.editor.fold.Fold#getExtraInfo.
     * 
     * @param extraInfo custom data
     * @return this instance
     */
    public FoldInfo attach(Object extraInfo) {
        this.extraInfo = extraInfo;
        return this;
    }
    
    /**
     * Returns description override.
     * When {@code null}, information from FoldTemplates should be used.
     * 
     * @return explicit description, or {@code null}.
     */
    public String getDescriptionOverride() {
        return description;
    }
    
    /**
     * Returns the extra information attached to a fold.
     * 
     * @return data, or {@code null} if no data is present
     */
    public Object getExtraInfo() {
        return extraInfo;
    }
    
    /**
     * Records the desired collapsed state.
     * 
     * @param state the desired collapsed state
     * @return this instance.
     */
    public FoldInfo collapsed(boolean state) {
        this.collapsed = state;
        return this;
    }

    /**
     * Provides start offset of the folded content
     * @return offset into the document
     */
    public int getStart() {
        return start;
    }

    /**
     * Provides end offset of the folded content
     * @return offset into the document
     */
    public int getEnd() {
        return end;
    }

    /**
     * Provides FoldTemplate to be used with the Fold.
     * The template will be used in preference to {@link org.netbeans.api.editor.fold.FoldType#getTemplate}. 
     * {@code Null} return value means that the FoldTemplate from the FoldType is in effect.
     
     * @return FoldTemplate instance, or {@code null}
     */
    public FoldTemplate getTemplate() {
        return template;
    }

    /**
     * Provides FoldType for the fold.
     * The FoldType will be assigned to the new fold. If type of a fold (occupying the same range) changes during
     * {@link FoldOperation#update}, the fold will be destroyed and re-created. It is not possible to change FoldType
     * of a Fold.
     * 
     * @return FoldType instance, never {@code null}. 
     */
    public FoldType getType() {
        return type;
    }

    /**
     * Provides the desired collapsed state or {@code null}, if no specific
     * state is required.
     * When {@code null} is reported, the infrastructure can assign an an appropriate initial state to the fold,
     * e.g. based on user preferences. States of existing fold is never changed during update.
     * 
     * @return desired collapsed state or {@code null}
     */
    public Boolean getCollapsed() {
        return collapsed;
    }
    
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("FoldInfo[").append(start).append(" - ").append(end).
                append(", ").append(type).append(", desc = ").append(description == null ? template.getDescription() : description).
                append(" collapsed = ").append(collapsed).append("]");
        return sb.toString();
    }
}

Lines 44-57 Link Here

(-)a/editor.fold/src/org/netbeans/spi/editor/fold/FoldOperation.java (+134 lines)
44		44
45	package org.netbeans.spi.editor.fold;	45	package org.netbeans.spi.editor.fold;
46		46
		47	import java.util.Collection;
		48	import java.util.Iterator;
		49	import java.util.Map;
47	import javax.swing.text.BadLocationException;	50	import javax.swing.text.BadLocationException;
48	import org.netbeans.api.editor.fold.Fold;	51	import org.netbeans.api.editor.fold.Fold;
49	import org.netbeans.api.editor.fold.FoldHierarchy;	52	import org.netbeans.api.editor.fold.FoldHierarchy;
		53	import org.netbeans.api.editor.fold.FoldTemplate;
50	import org.netbeans.api.editor.fold.FoldType;	54	import org.netbeans.api.editor.fold.FoldType;
51	import org.netbeans.modules.editor.fold.ApiPackageAccessor;	55	import org.netbeans.modules.editor.fold.ApiPackageAccessor;
52	import org.netbeans.modules.editor.fold.FoldHierarchyTransactionImpl;	56	import org.netbeans.modules.editor.fold.FoldHierarchyTransactionImpl;
53	import org.netbeans.modules.editor.fold.FoldOperationImpl;	57	import org.netbeans.modules.editor.fold.FoldOperationImpl;
54	import org.netbeans.modules.editor.fold.SpiPackageAccessor;	58	import org.netbeans.modules.editor.fold.SpiPackageAccessor;
		59	import org.openide.util.Parameters;
55		60
56		61
57	/**	62	/**
Lines 128-133 Link Here
128	* {@link #getExtraInfo(org.netbeans.api.editor.fold.Fold)}.	133	* {@link #getExtraInfo(org.netbeans.api.editor.fold.Fold)}.
129	*	134	*
130	* @return new fold instance that was added to the hierarchy.	135	* @return new fold instance that was added to the hierarchy.
		136	* @deprecated please use {@link #addToHierarchy(org.netbeans.api.editor.fold.FoldType, int, int, java.lang.Boolean, org.netbeans.api.editor.fold.FoldTemplate, java.lang.String, java.lang.Object, org.netbeans.spi.editor.fold.FoldHierarchyTransaction)}.
		137	* This form of call does not support automatic state assignment and fold templates.
131	*/	138	*/
132	public Fold addToHierarchy(FoldType type, String description, boolean collapsed,	139	public Fold addToHierarchy(FoldType type, String description, boolean collapsed,
133	int startOffset, int endOffset, int startGuardedLength, int endGuardedLength,	140	int startOffset, int endOffset, int startGuardedLength, int endGuardedLength,
Lines 142-147 Link Here
142	}	149	}
143		150
144	/**	151	/**
		152	* Adds a fold to the hierarchy.
		153	* The description and the guarded start/end is taken from the 'template' FoldTemplate. As the fold template display
		154	* is the most common override, the override string can be passed in 'displayOverride' (and will be used instead
		155	* of template and instead of type's template).
		156	* <p/>
		157	* The collapsed state can be prescribed, but can {@code null} can be passed to indicate the infrastructure should
		158	* assign collapsed state based on e.g. user preferences. The exact assignment algorithm is left unspecified. Callers
		159	* are recommended not to assign collapsed/expanded state explicitly.
		160	* <p/>
		161	* Usually, it's OK to pass null for collapsed, template and possibly extraInfo.
		162	* <p/>
		163	* Events produced by this add- call will be fired when the 'transaction' is committed. However fold hierarch will
		164	* be changed immediately.
		165	*
		166	* @param type type of the fold, cannot be {@code null}
		167	* @param startOffset starting offset
		168	* @param endOffset end offset
		169	* @param collapsed the initial collapsed state; if {@code null}, the state will be assigned automatically.
		170	* @param template the FoldTemplate to use instead of default template of the type. {@code null}, if the type's template should be used.
		171	* @param extraInfo arbitrary extra information specific for the fold being created.
		172	* It's not touched or used by the folding infrastructure in any way.
		173	* <code>null<code> can be passed if there is no extra information.
		174	* <br>
		175	* The extra info of the existing fold can be obtained by
		176	* {@link #getExtraInfo(org.netbeans.api.editor.fold.Fold)}.
		177	* @param transaction the transaction that manages events, cannot be null.
		178	* @return the created Fold instance
		179	* @throws BadLocationException
		180	* @since 1.34
		181	*/
		182	public Fold addToHierarchy(
		183	FoldType type,
		184	int startOffset, int endOffset,
		185	Boolean collapsed,
		186	FoldTemplate template, String displayOverride,
		187	Object extraInfo, FoldHierarchyTransaction transaction)
		188	throws BadLocationException {
		189	Parameters.notNull("type", type);
		190	Parameters.notNull("transaction", transaction);
		191
		192	boolean c;
		193	if (collapsed == null) {
		194	c = impl.getInitialState(type);
		195	} else {
		196	c = collapsed;
		197	}
		198	if (template == null) {
		199	template = type.getTemplate();
		200	}
		201	if (displayOverride == null) {
		202	displayOverride = template.getDescription();
		203	}
		204	Fold fold = impl.createFold(type, displayOverride,
		205	c, startOffset, endOffset, template.getGuardedStart(),
		206	template.getGuardedEnd(), extraInfo);
		207	impl.addToHierarchy(fold, transaction.getImpl());
		208	return fold;
		209	}
		210
		211	/**
145	* This static method can be used to check whether the bounds	212	* This static method can be used to check whether the bounds
146	* of the fold that is planned to be added are valid.	213	* of the fold that is planned to be added are valid.
147	* <br>	214	* <br>
Lines 270-291 Link Here
270	return impl.getHierarchy();	337	return impl.getHierarchy();
271	}	338	}
272		339
		340	/**
		341	* Informs that the manager was released.
		342	* Use the method to check whether the {@link FoldManager} should be still operational.
		343	* Once released, the FoldManager (and its Operation) will not be used again by the infrastructure.
		344	*
		345	* @return true, if release() was called on the manager
		346	* @since 1.34
		347	*/
273	public boolean isReleased() {	348	public boolean isReleased() {
274	return impl.isReleased();	349	return impl.isReleased();
275	}	350	}
276		351
		352	/**
		353	* Enumerates all Folds defined by this Operation, in the document-range order.
		354	* Outer folds precede the inner ones. Folds, which overlap are enumerated strictly
		355	* in the order of their starting positions.
		356	* <p/>
		357	* The method may be only called under {@link FoldHierarchy#lock}. The Iterator may
		358	* be only used until that lock is released. After releasing the lock, the Iterator
		359	* may fail.
		360	*
		361	* @return readonly iterator for all folds defined through this FoldOperation
		362	* @since 1.34
		363	*/
		364	public Iterator<Fold> foldIterator() {
		365	return impl.foldIterator();
		366	}
		367
		368	/**
		369	* Performs refresh of folding information. The method will:
		370	* <ul>
		371	* <li>remove Folds, which do not appear among the supplied FoldInfos
		372	* <li>add Folds, which do not exist, but are described by some FoldInfo
		373	* <li>attempt to update Folds, which match the FoldInfos
		374	* </ul>
		375	* For each of the supplied FoldInfos, there should be at most 1 Fold either created or found existing, and no
		376	* Folds without a corresponding input FoldInfo should remain in the hierarchy after the call. The mapping from the
		377	* input FoldInfo to the corresponding Fold (created or found existing) is returned.
		378	* <p/>
		379	* Note that Folds, which are blocked (e.g. by a higher-priority manager) will be added/removed/updated and
		380	* returned as well. In order to find whether a specific Fold is blocked, please call {@link #isBlocked}.
		381	* <p/>
		382	* If the {@code removed} or {@code created} parameters are not null, the removed Fold instances, or the FoldInfos
		383	* that created new Folds will be put into those collection as a supplemental return value. The caller may then
		384	* update its own data with respect to the changes and the current Fold set.
		385	* <p/>
		386	* <b>Note:</b> The method may be only called under {@link FoldHierarchy#lock}. This implies the document is also read-locked.
		387	* The caller <b>must check</b> whether a modification happen in between the FoldInfos were produced at the
		388	* document + hierarchy lock. The method creates and commits its own {@link FoldTransaction} - they are not reentrant,
		389	* so do not call the method under a transaction.
		390	*
		391	* @param infos current state of folds that should be updated to the hierarchy
		392	* @param removed Collection that will receive Folds, which have been removed from the hierarchy, or {@code null}, if the caller
		393	* does not want to receive the information
		394	* @param created Collection that will receive FoldInfos that created new Folds in the hierarchy, {@code null} means
		395	* the caller is not interested in the creation information.
		396	*
		397	* @return the mapping from FoldInfos supplied as an input to current Folds. {@code null}, if the manager has been
		398	* released.
		399	* @since 1.34
		400	*/
		401	public Map<FoldInfo, Fold> update(
		402	Collection<FoldInfo> infos,
		403	Collection<Fold> removed,
		404	Collection<FoldInfo> created) throws BadLocationException {
		405	Parameters.notNull("infos", infos);
		406	return impl.update(infos, removed, created);
		407	}
277		408
278	private static final class SpiPackageAccessorImpl extends SpiPackageAccessor {	409	private static final class SpiPackageAccessorImpl extends SpiPackageAccessor {
279		410
		411	@Override
280	public FoldHierarchyTransaction createFoldHierarchyTransaction(	412	public FoldHierarchyTransaction createFoldHierarchyTransaction(
281	FoldHierarchyTransactionImpl impl) {	413	FoldHierarchyTransactionImpl impl) {
282	return new FoldHierarchyTransaction(impl);	414	return new FoldHierarchyTransaction(impl);
283	}	415	}
284		416
		417	@Override
285	public FoldHierarchyTransactionImpl getImpl(FoldHierarchyTransaction transaction) {	418	public FoldHierarchyTransactionImpl getImpl(FoldHierarchyTransaction transaction) {
286	return transaction.getImpl();	419	return transaction.getImpl();
287	}	420	}
288		421
		422	@Override
289	public FoldOperation createFoldOperation(FoldOperationImpl impl) {	423	public FoldOperation createFoldOperation(FoldOperationImpl impl) {
290	return new FoldOperation(impl);	424	return new FoldOperation(impl);
291	}	425	}




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

import java.util.Collection;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.spi.editor.mimelookup.MimeLocation;

/**
 * Provider of FoldType constants for the MimeType. 
 * The Provider should enumerate FoldTypes that apply to the given MIME type.
 * There can be multiple providers for a MIME type - some advanced constructions in
 * the language can be recognized / folded by extension modules. Consider Java vs.
 * Bean Patterns, or XML vs. Spring bean config.
 * <p/>
 * FoldTypes will be collected and some pieces of UI can present the folds, such 
 * as Auto-folding options.
 * <p/>
 * The Provider may specify inheritable=true; in that case the contributed FoldTypes
 * will become available for more specific MIME types, too. For example, if a FoldTypeProvider
 * for text/xml registers FoldTypes TAG and COMMENT with inheritable=true,
 * those FoldTypes will be listed also for text/x-ant+xml. This feature allows 
 * to "inject" Fold types and FoldManager on general MIME type ("") for all 
 * types of files.
 * 
 * @author sdedic
 * @since 1.34
 */
@MimeLocation(subfolderName = "FoldManager")
public interface FoldTypeProvider {
    /**
     * Enumerates values for the given type.
     * @return FoldType values.
     */
    public Collection getValues(Class type);
    
    /**
     * Determines whether the folds propagate to child mime types(paths).
     * If the method returns true, then more specific MIME types will also
     * list FoldTypes returned by this Provider. 
     * 
     * @return whether the provided FoldTypes should be inherited (true).
     */
    public boolean inheritable();
    
}

Lines 68-74 Link Here

(-)a/editor.fold/test/unit/src/org/netbeans/modules/editor/fold/FoldHierarchyTestEnv.java (-1 / +1 lines)
68	this(new FoldManagerFactory[] { factory });	68	this(new FoldManagerFactory[] { factory });
69	}	69	}
70		70
71	FoldHierarchyTestEnv(FoldManagerFactory[] factories) {	71	FoldHierarchyTestEnv(FoldManagerFactory... factories) {
72	pane = new JEditorPane();	72	pane = new JEditorPane();
73	assert (getMimeType() != null);	73	assert (getMimeType() != null);
74		74




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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
import javax.swing.text.AbstractDocument;
import javax.swing.text.BadLocationException;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertSame;
import static junit.framework.Assert.assertTrue;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldStateChange;
import org.netbeans.api.editor.fold.FoldTemplate;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.junit.NbTestCase;
import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;
import org.netbeans.spi.editor.fold.FoldInfo;
import org.netbeans.spi.editor.fold.FoldManager;
import org.netbeans.spi.editor.fold.FoldManagerFactory;
import org.netbeans.spi.editor.fold.FoldOperation;

/**
 *
 * @author sdedic
 */
public class FoldOperationTest extends NbTestCase {

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

    /*
     * update* tests use a simple fold manager, which defines several folds, some of them nested.
     * A[0,1]
     * B[2,7]
     *  C[3,4]
     *  D[5,6]
     * E[8,9]
     */
    
    private static int[][] foldRanges = new int[][] {
        {0, 1},
        {3,12},
            {5, 6},
            {9, 10},
        {14, 16}
    };
    
    /**
     * Checks that no changes (update with the same infos) will not fire events, remove or add any folds.
     * 
     * @throws Exception 
     */
    public void testUpdateNoChanges() throws Exception {
        final TestFoldManager[] mgr = new TestFoldManager[1];
        FoldHierarchyTestEnv env = new FoldHierarchyTestEnv(new FoldManagerFactory() {
            @Override
            public FoldManager createFoldManager() {
                return mgr[0] = new TestFoldManager();
            }
        });
        AbstractDocument doc = env.getDocument();
        doc.insertString(0, "12345678901234567890", null);

        FoldHierarchy hierarchy = env.getHierarchy();
        
        Collection<FoldInfo> infos = new ArrayList<FoldInfo>(10);
        infos.add(FoldInfo.range(0, 1, FoldType.MEMBER));
        infos.add(FoldInfo.range(9, 10, FoldType.MEMBER));
        infos.add(FoldInfo.range(14, 16, FoldType.MEMBER));
        // not sorted, check :)
        infos.add(FoldInfo.range(3, 12, FoldType.MEMBER));
        infos.add(FoldInfo.range(5, 6, FoldType.MEMBER));
        
        doc.readLock();
        try {
            hierarchy.lock();
            TestFoldManager m = mgr[0];
            try {
                Collection<Fold> remove = new ArrayList<Fold>();
                Collection<FoldInfo> create = new ArrayList<FoldInfo>();
                
                final boolean[] changed = new boolean[1];
                
                hierarchy.addFoldHierarchyListener(new FoldHierarchyListener() {

                    @Override
                    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
                        changed[0] = true;
                    }
                });
                
                Map<FoldInfo, Fold> mapping = m.operation.update(infos, remove, create);
                
                assertEquals(m.initFolds.size(), mapping.size());
                assertTrue(m.initFolds.containsAll(mapping.values()));
                assertFalse(changed[0]);
                
            } finally {
                hierarchy.unlock();
            }
        } finally {
            doc.readUnlock();
        }
    }
    
    private List<FoldInfo> createDefaultInfos() {
        List<FoldInfo> infos = new ArrayList<FoldInfo>(10);
        infos.add(FoldInfo.range(0, 1, FoldType.MEMBER));
        infos.add(FoldInfo.range(3, 12, FoldType.MEMBER));
        infos.add(FoldInfo.range(5, 6, FoldType.MEMBER));
        infos.add(FoldInfo.range(9, 10, FoldType.MEMBER));
        infos.add(FoldInfo.range(14, 16, FoldType.MEMBER));
        return infos;
    }
    
    /**
     * Checks that folds are created beween two folds, encapsulating existing folds.
     * 
     * @throws Exception 
     */
    public void testUpdateCreateFold() throws Exception {
        final TestFoldManager[] mgr = new TestFoldManager[1];
        FoldHierarchyTestEnv env = new FoldHierarchyTestEnv(new FoldManagerFactory() {
            @Override
            public FoldManager createFoldManager() {
                return mgr[0] = new TestFoldManager();
            }
        });
        AbstractDocument doc = env.getDocument();
        doc.insertString(0, "12345678901234567890", null);

        FoldHierarchy hierarchy = env.getHierarchy();
        
        List<FoldInfo> infos = createDefaultInfos();
        
        // add a new fold between #1 and #2
        infos.add(FoldInfo.range(2, 3, FoldType.MEMBER));
        
        // add a new fold at the end:
        infos.add(FoldInfo.range(19,20, FoldType.MEMBER));
        
        // add a fold, which encapsulates #2 - #5
        infos.add(FoldInfo.range(3, 18, FoldType.MEMBER));
        
        // add a fold, which encapsulates ##5
        infos.add(FoldInfo.range(13, 16, FoldType.MEMBER));
        
        doc.readLock();
        try {
            hierarchy.lock();
            TestFoldManager m = mgr[0];
            try {
                Collection<Fold> remove = new ArrayList<Fold>();
                Collection<FoldInfo> create = new ArrayList<FoldInfo>();
                
                final boolean[] changed = new boolean[1];
                
                hierarchy.addFoldHierarchyListener(new FoldHierarchyListener() {
                    @Override
                    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
                        changed[0] = true;
                    }
                });
                Map<FoldInfo, Fold> mapping = m.operation.update(infos, remove, create);
                
                // 3 folds added, no deleted:
                assertEquals(4, create.size());
                assertEquals(0, remove.size());
                
            } finally {
                hierarchy.unlock();
            }
        } finally {
            doc.readUnlock();
        }
    }
    
    /**
     * Checks that updated folds can SHIFT. If a fold should be replaced by a same-type fold, which 
     * fully contains the original one, or is fully contained by the original one, the original fold will
     * be updated rather than removed/created. This behaviour eliminates issues with collapsing imports.
     * 
     * @throws Exception 
     */
    public void testUpdateShiftFolds() throws Exception {
        final TestFoldManager[] mgr = new TestFoldManager[1];
        FoldHierarchyTestEnv env = new FoldHierarchyTestEnv(new FoldManagerFactory() {
            @Override
            public FoldManager createFoldManager() {
                return mgr[0] = new TestFoldManager();
            }
        });
        AbstractDocument doc = env.getDocument();
        doc.insertString(0, "12345678901234567890", null);

        FoldHierarchy hierarchy = env.getHierarchy();
        
        List<FoldInfo> infos = createDefaultInfos();
        
        // Fold #3 is not shifted, as the new fold does not intersect with the old one. Fold will be replaced.
        FoldInfo cInfo;
        infos.add(cInfo = FoldInfo.range(4, 5, FoldType.MEMBER));
        
        // Fold #4 is extended backwards
        infos.add(FoldInfo.range(8, 10, FoldType.MEMBER));
        
        // Fold #5 is extended in both directions
        infos.add(FoldInfo.range(13, 17, FoldType.MEMBER));
        
        infos.remove(4); infos.remove(3); infos.remove(2);
        
        TestFoldManager m = mgr[0];
        final Fold fold8 = FoldUtilities.findNearestFold(hierarchy, 8);
        final Fold fold13 = FoldUtilities.findNearestFold(hierarchy, 13);
        
        class FHL implements FoldHierarchyListener {
            boolean changed;
            
            @Override
            public void foldHierarchyChanged(FoldHierarchyEvent evt) {
                changed = true;
                assertEquals(2, evt.getFoldStateChangeCount());
                for (int i = evt.getFoldStateChangeCount() - 1; i >= 0; i--) {
                    FoldStateChange chg = evt.getFoldStateChange(i);
                    if (chg.getFold() == fold8) {
                        assertEquals(9, chg.getOriginalStartOffset());
                        assertEquals(-1, chg.getOriginalEndOffset());
                    } else if (chg.getFold() == fold13) {
                        assertEquals(14, chg.getOriginalStartOffset());
                        assertEquals(16, chg.getOriginalEndOffset());
                    } else {
                        fail("Unexpected change");
                    }
                }
            }
        }
        
        FHL fhl = new FHL();
        doc.readLock();
        try {
            hierarchy.lock();
            try {
                Collection<Fold> remove = new ArrayList<Fold>();
                Collection<FoldInfo> create = new ArrayList<FoldInfo>();
                
                hierarchy.addFoldHierarchyListener(fhl);
                Map<FoldInfo, Fold> mapping = m.operation.update(infos, remove, create);
                
                // 3 folds added, no deleted:
                assertEquals(1, create.size());
                assertEquals(1, remove.size());
                
                assertSame(cInfo, create.iterator().next());
                
                Fold f = remove.iterator().next();
                // old fold
                assertEquals(5, f.getStartOffset());
                
                // new fold
                FoldInfo newInfo = create.iterator().next();
                assertSame(cInfo, newInfo);
                f = mapping.get(cInfo);
                assertEquals(4, f.getStartOffset());
            } finally {
                hierarchy.unlock();
            }
        } finally {
            doc.readUnlock();
        }
    }
    
    /**
     * Checks that a released operation will not update anything
     * 
     * @throws Exception 
     */
    public void testNoUpdateAfterRelease() throws Exception {
        final TestFoldManager[] mgr = new TestFoldManager[1];
        final FoldHierarchyTestEnv env = new FoldHierarchyTestEnv(new FoldManagerFactory() {
            @Override
            public FoldManager createFoldManager() {
                return mgr[0] = new TestFoldManager();
            }
        });
        AbstractDocument doc = env.getDocument();
        doc.insertString(0, "12345678901234567890", null);

        FoldHierarchy hierarchy = env.getHierarchy();
        List<FoldInfo> infos = createDefaultInfos();
        
        // add a new fold between #1 and #2
        infos.add(FoldInfo.range(2, 3, FoldType.MEMBER));
        
        // add a new fold at the end:
        infos.add(FoldInfo.range(19,20, FoldType.MEMBER));
        
        // add a fold, which encapsulates #2 - #5
        infos.add(FoldInfo.range(3, 18, FoldType.MEMBER));
        
        infos.remove(4); infos.remove(3); infos.remove(2);
        
        SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                JPanel outer = new JPanel();
                // force parent change 
                outer.add(env.getPane());
            }
        });
        // listener is attached in between these events
        SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                // nothing, just wait for the delayed events to process.
            }
        });
        FoldHierarchyExecution.waitAllTasks();
        
        doc.readLock();
        try {
            hierarchy.lock();
            TestFoldManager m = mgr[0];
            try {
                
                Collection<Fold> remove = new ArrayList<Fold>();
                Collection<FoldInfo> create = new ArrayList<FoldInfo>();
                final boolean[] changed = new boolean[1];
                
                hierarchy.addFoldHierarchyListener(new FoldHierarchyListener() {
                    @Override
                    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
                        changed[0] = true;
                    }
                });
                Map<FoldInfo, Fold> mapping = m.operation.update(infos, remove, create);
                assertNull(mapping);
                // 3 folds added, no deleted:
                assertEquals(0, create.size());
                assertEquals(0, remove.size());
                assertFalse(changed[0]);
                
            } finally {
                hierarchy.unlock();
            }
        } finally {
            doc.readUnlock();
        }
    }
    
    
    /**
     * Checks that foldIterator() enumerates blocked folds, and blocked folds blocked by blocked folds
     * 
     * @throws Exception 
     */
    public void testFoldIterator() throws Exception {
        TestFoldManager baseFoldManager = new TestFoldManager(BASE_RANGE, FoldType.MEMBER);
        TestFoldManager overrideFoldManager = new TestFoldManager(OVERRIDE_RANGE, FoldType.NESTED);
        TestFoldManager uberFoldManager = new TestFoldManager(UBER_RANGE, FoldType.USER);
        
        class FMF implements FoldManagerFactory {
            private FoldManager fm;

            public FMF(FoldManager fm) {
                this.fm = fm;
            }

            @Override
            public FoldManager createFoldManager() {
                return fm;
            }
        }
        
        final FoldHierarchyTestEnv env = new FoldHierarchyTestEnv(
                new FMF(uberFoldManager), new FMF(overrideFoldManager), new FMF(baseFoldManager)
        );
        AbstractDocument doc = env.getDocument();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 20; i++) {
            sb.append("12345678901234567890");
        }
        doc.insertString(0, sb.toString(), null);
        
        FoldHierarchy hierarchy = env.getHierarchy();
        hierarchy.lock();
        // now update the uber-range, so that the new fold blocks the blocking fold:
        FoldOperation fo = uberFoldManager.operation;
        FoldHierarchyTransaction t = fo.openTransaction();
        fo.addToHierarchy(FoldType.USER, 110, 170, null, null, null, null, t);
        t.commit();
        
        // check that the hierarchy contains the proper overrides:
        Fold f = FoldUtilities.findOffsetFold(hierarchy, 2);
        assertNotNull(f);
        assertSame(FoldType.NESTED, f.getType());
        
        f = FoldUtilities.findOffsetFold(hierarchy, 122);
        assertNotNull(f);
        assertSame(FoldType.USER, f.getType());
        
        // enumerate all folds of the base iterator
        fo = baseFoldManager.operation;
        
        Iterator<Fold> folds = fo.foldIterator();
        for (int i = 0; i < BASE_RANGE.length; i++) {
            int[] rng = BASE_RANGE[i];
            f = folds.next();
            
            assertSame(FoldType.MEMBER, f.getType());
            assertEquals(rng[0], f.getStartOffset());
            assertEquals(rng[1], f.getEndOffset());
        }
        assertFalse(folds.hasNext());
    }
    
    private static int[][] BASE_RANGE = {
        { 2, 4 },
        { 7, 100},
            { 10, 30 },
            { 40, 50 },
        { 120, 200 },
            { 130, 140 },
            { 150, 160 }
    };

    private static int[][] OVERRIDE_RANGE = {
        { 1, 3 },   
        { 7, 100},  
            { 8, 20 }, // intersect at the beginning
            { 45, 60 }, // intersect at the end
        { 120, 200 },   // block
            { 125, 142 }, // fully contain
            { 155, 157 }  // proper child
    };
    
    private static int[][] UBER_RANGE = {
    };
    
    private class TestFoldManager implements FoldManager {
        FoldOperation operation;
        Collection<Fold> initFolds = new ArrayList<Fold>(6);
        int[][] ranges;
        FoldType type;
        
        public TestFoldManager() {
            ranges = foldRanges;
            type = FoldType.MEMBER;
        }
        
        public TestFoldManager(int[][] ranges, FoldType type) {
            this.ranges = ranges;
            this.type = type;
        }
        
        
        @Override
        public void init(FoldOperation operation) {
            this.operation = operation;
        }

        public void initFolds(FoldHierarchyTransaction transaction)  {
            for (int i = 0; i < ranges.length; i++) {
                int[] range = ranges[i];
                try {
                    initFolds.add(operation.addToHierarchy(
                            type, 
                            range[0], 
                            range[1], 
                            null, 
                            null, 
                            null, 
                            null, transaction
                    ));
                } catch (BadLocationException ex) {
                }
            }
        }

        @Override
        public void insertUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        }

        @Override
        public void removeUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        }

        @Override
        public void changedUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {
        }

        @Override
        public void removeEmptyNotify(Fold epmtyFold) {
        }

        @Override
        public void removeDamagedNotify(Fold damagedFold) {
        }

        @Override
        public void expandNotify(Fold expandedFold) {
        }

        @Override
        public void release() {
            // purposely ignore
        }
    }   
}




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

    <changes>
        <change id="caret-fold-cleanup">
            <summary>Removed dependencies on Folding</summary>
            <version major="3" minor="37"/>
            <date day="26" month="2" year="2013"/>
            <author login="sdedic"/>
            <compatibility binary="incompatible" source="incompatible" semantic="compatible" addition="yes"/>
            <description>
                <p>
                    Inheritance of FoldHierarchyListener was removed, as it was the last dependency on 
                    fold API from the editor.lib module. 
                </p>
            </description>
            <class name="BaseCaret" package="org.netbeans.editor"/>
            <issue number="226368"/>
        </change>
        <change id="caret-refresh">
            <summary>Allow to refresh editor view so that caret is visible</summary>
            <version major="3" minor="37"/>
            <date day="26" month="2" year="2013"/>
            <author login="sdedic"/>
            <compatibility binary="compatible" source="compatible" semantic="compatible" addition="yes"/>
            <description>
                <p>
                    The method helps to ensure that the caret, if it was originally visible on the screen,
                    will remain visible after some view hierarchy change (i.e. define a new fold).
                </p>
            </description>
            <class name="BaseCaret" package="org.netbeans.editor"/>
            <issue number="226368"/>
        </change>
        <change id="moving-find">
            <summary>Moving find implementations to module editor.search</summary>
            <version major="3" minor="36"/>

Lines 632-637 Link Here

(-)a/editor.lib/arch.xml (+9 lines)
632	To specify modifiers for which the hyperlinking should be enabled, or to switch the hyperlinking off.	632	To specify modifiers for which the hyperlinking should be enabled, or to switch the hyperlinking off.
633	Valid values are "[CSMA]+" (to specify combination of modifiers) or "off" (to switch hyperlinking off).	633	Valid values are "[CSMA]+" (to specify combination of modifiers) or "off" (to switch hyperlinking off).
634	</api>	634	</api>
		635	<api type="export" group="clientproperty" name="org.netbeans.api.fold.expander" category="friend">
		636	The client property must be defined on JTextComponent managed by the NetBeans editor.
		637	<p/>
		638	Mouse gestures require to determine whether the point at caret is folded or not. Plain text is then selected.
		639	The client property org.netbeans.api.fold.expander (if defined) should contains a Callable<Boolean> that
		640	returns false, if the point is a plaintext, true otherwise. Fold expansion should be handled by the Callable.
		641	<p/>
		642	editor.fold module uses this client property to hook into BaseCaret processing.
		643	</api>
635	</answer>	644	</answer>
636		645
637		646

Lines 62-66 Link Here

(-)a/editor.lib/module-auto-deps.xml (+10 lines)
62	</result>	62	</result>
63	</implies>	63	</implies>
64	</transformation>	64	</transformation>
		65	<transformation>
		66	<trigger-dependency type="older">
		67	<module-dependency codenamebase="org.netbeans.modules.editor.lib" major="1" spec="3.33"/>
		68	</trigger-dependency>
		69	<implies>
		70	<result>
		71	<module-dependency codenamebase="org.netbeans.modules.editor.fold" major="1" spec="1.33"/>
		72	</result>
		73	</implies>
		74	</transformation>
65	</transformationgroup>	75	</transformationgroup>
66	</transformations>	76	</transformations>

Lines 42-48 Link Here

(-)a/editor.lib/nbproject/project.properties (-1 / +1 lines)
42		42
43	javac.compilerargs=-Xlint:unchecked	43	javac.compilerargs=-Xlint:unchecked
44	javac.source=1.6	44	javac.source=1.6
45	spec.version.base=3.36.0	45	spec.version.base=3.37.0
46	is.autoload=true	46	is.autoload=true
47		47
48	javadoc.arch=${basedir}/arch.xml	48	javadoc.arch=${basedir}/arch.xml




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.editor.fold</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.editor.indent</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>




import org.netbeans.api.editor.EditorActionNames;
import org.netbeans.api.editor.EditorActionRegistration;
import org.netbeans.api.editor.EditorActionRegistrations;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.lexer.TokenHierarchy;
import org.netbeans.api.progress.ProgressUtils;
import org.netbeans.lib.editor.util.swing.DocumentUtilities;
import org.netbeans.lib.editor.util.swing.PositionRegion;

    }


    /** Returns the fold that should be collapsed/expanded in the caret row
     *  @param hierarchy hierarchy under which all folds should be collapsed/expanded.
     *  @param dot caret position offset
     *  @param lineStart offset of the start of line
     *  @param lineEnd offset of the end of line
     *  @return the fold that meet common criteria in accordance with the caret position
     */
    private static Fold getLineFold(FoldHierarchy hierarchy, int dot, int lineStart, int lineEnd){
        Fold caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, dot);

        // beginning searching from the lineStart
        Fold fold = FoldUtilities.findNearestFold(hierarchy, lineStart);  
        
        while (fold!=null && 
                  (fold.getEndOffset()<=dot || // find next available fold if the 'fold' is one-line
                      // or it has children and the caret is in the fold body
                      // i.e. class A{ |public void method foo(){}}
                      (!fold.isCollapsed() && fold.getFoldCount() > 0  && fold.getStartOffset()+1<dot) 
                   )
               ){

                   // look for next fold in forward direction
                   Fold nextFold = FoldUtilities.findNearestFold(hierarchy,
                       (fold.getFoldCount()>0) ? fold.getStartOffset()+1 : fold.getEndOffset());
                   if (nextFold!=null && nextFold.getStartOffset()<lineEnd){
                       if (nextFold == fold) return fold;
                       fold = nextFold;
                   }else{
                       break;
                   }
        }

        
        // a fold on the next line was found, returning fold at offset (in most cases inner class)
        if (fold == null || fold.getStartOffset()>lineEnd) {

            // in the case:
            // class A{
            // }     |
            // try to find an offset fold on the offset of the line beginning
            if (caretOffsetFold == null){
                caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, lineStart);
            }
            
            return caretOffsetFold;
        }
        
        // no fold at offset found, in this case return the fold
        if (caretOffsetFold == null) return fold;
        
        // skip possible inner class members validating if the innerclass fold is collapsed
        if (caretOffsetFold.isCollapsed()) return caretOffsetFold;
        
        // in the case:
        // class A{
        // public vo|id foo(){} }
        // 'fold' (in this case fold of the method foo) will be returned
        if ( caretOffsetFold.getEndOffset()>fold.getEndOffset() && 
             fold.getEndOffset()>dot){
            return fold;
        }
        
        // class A{
        // |} public void method foo(){}
        // inner class fold will be returned
        if (fold.getStartOffset()>caretOffsetFold.getEndOffset()) return caretOffsetFold;
        
        // class A{
        // public void foo(){} |}
        // returning innerclass fold
        if (fold.getEndOffset()<dot) return caretOffsetFold;
        
        return fold;
    }
    
    /** Collapse a fold. Depends on the current caret position. */
    @EditorActionRegistration(name = BaseKit.collapseFoldAction,
            menuText = "#" + BaseKit.collapseFoldAction + "_menu_text")
    public static class CollapseFold extends LocalBaseAction {
        public CollapseFold(){
        }
        
        private boolean dotInFoldArea(JTextComponent target, Fold fold, int dot) throws BadLocationException{
            int foldStart = fold.getStartOffset();
            int foldEnd = fold.getEndOffset();
            int foldRowStart = javax.swing.text.Utilities.getRowStart(target, foldStart);
            int foldRowEnd = javax.swing.text.Utilities.getRowEnd(target, foldEnd);
            if (foldRowStart > dot || foldRowEnd < dot) return false; // it's not fold encapsulating dot
            return true;
            }

        
        public void actionPerformed(ActionEvent evt, final JTextComponent target) {
            Document doc = target.getDocument();
            doc.render(new Runnable() {
                @Override
                public void run() {
                    FoldHierarchy hierarchy = FoldHierarchy.get(target);
                    int dot = target.getCaret().getDot();
                    hierarchy.lock();
                    try{
                        try{
                            int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
                            Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
                            fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
                            if (fold==null){
                                return; // no success
                            }
                            // ensure we' got the right fold
                            if (dotInFoldArea(target, fold, dot)){
                                hierarchy.collapse(fold);
                            }
                        }catch(BadLocationException ble){
                            ble.printStackTrace();
                        }
                    }finally {
                        hierarchy.unlock();
                    }
                }
            });
        }
    }
    
    /** Expand a fold. Depends on the current caret position. */
    @EditorActionRegistration(name = BaseKit.expandFoldAction,
            menuText = "#" + BaseKit.expandFoldAction + "_menu_text")
    public static class ExpandFold extends LocalBaseAction {
        public ExpandFold(){
        }
        
        public void actionPerformed(ActionEvent evt, final JTextComponent target) {
            Document doc = target.getDocument();
            doc.render(new Runnable() {
                @Override
                public void run() {
                    FoldHierarchy hierarchy = FoldHierarchy.get(target);
                    int dot = target.getCaret().getDot();
                    hierarchy.lock();
                    try {
                        try {
                            int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
                            Fold fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
                            if (fold != null) {
                                hierarchy.expand(fold);
                            }
                        } catch (BadLocationException ble) {
                            ble.printStackTrace();
                        }
                    } finally {
                        hierarchy.unlock();
                    }
                }
            });
        }
    }
    
    /** Collapse all existing folds in the document. */
    @EditorActionRegistration(name = BaseKit.collapseAllFoldsAction,
            menuText = "#" + BaseKit.collapseAllFoldsAction + "_menu_text")
    public static class CollapseAllFolds extends LocalBaseAction {
        public CollapseAllFolds(){
        }
        
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            FoldHierarchy hierarchy = FoldHierarchy.get(target);
            // Hierarchy locking done in the utility method
            FoldUtilities.collapseAll(hierarchy);
        }
    }

    /** Expand all existing folds in the document. */
    @EditorActionRegistration(name = BaseKit.expandAllFoldsAction,
            menuText = "#" + BaseKit.expandAllFoldsAction + "_menu_text")
    public static class ExpandAllFolds extends LocalBaseAction {
        public ExpandAllFolds(){
        }
        
        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            FoldHierarchy hierarchy = FoldHierarchy.get(target);
            // Hierarchy locking done in the utility method
            FoldUtilities.expandAll(hierarchy);
        }
    }

    /** Expand all existing folds in the document. */
    @EditorActionRegistration(name = "dump-view-hierarchy")
    public static class DumpViewHierarchyAction extends LocalBaseAction {

        public void actionPerformed(ActionEvent evt, JTextComponent target) {
            AbstractDocument adoc = (AbstractDocument)target.getDocument();

            /*
             * Folding has moved to editor.fold module. It must somehow hook
             * into this dump to provide the information.

            // Dump fold hierarchy
            FoldHierarchy hierarchy = FoldHierarchy.get(target);
            adoc.readLock();
            try {
                hierarchy.lock();
                try {
                    /*DEBUG* /System.err.println("FOLD HIERARCHY DUMP:\n" + hierarchy); // NOI18N
                    TokenHierarchy<?> th = TokenHierarchy.get(adoc);
                    /*DEBUG* /System.err.println("TOKEN HIERARCHY DUMP:\n" + (th != null ? th : "<NULL-TH>")); // NOI18N

                } finally {
                    hierarchy.unlock();

            } finally {
                adoc.readUnlock();
            }
            */
            View rootView = null;
            TextUI textUI = target.getUI();
            if (textUI != null) {




import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;

import javax.swing.text.AttributeSet;
import javax.swing.text.Position;
import javax.swing.text.StyleConstants;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldStateChange;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;

public class BaseCaret implements Caret,
MouseListener, MouseMotionListener, PropertyChangeListener,
DocumentListener, ActionListener, 
AtomicLockListener {

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

     * its relative visual position on the screen.
     */
    private boolean updateAfterFoldHierarchyChange;
    private FoldHierarchyListener weakFHListener;
    
    /**
     * Whether at least one typing change occurred during possibly several atomic operations.

        EditorUI editorUI = Utilities.getEditorUI(c);
        editorUI.removePropertyChangeListener(this);

        if (weakFHListener != null) {
            FoldHierarchy hierarchy = FoldHierarchy.get(c);
            if (hierarchy != null) {
                hierarchy.removeFoldHierarchyListener(weakFHListener);
            }
        }

        modelChanged(listenDoc, null);
    }


                        caretPos = doc.createPosition(offset);
                        markPos = doc.createPosition(offset);

                        Callable<Boolean> cc = (Callable<Boolean>)c.getClientProperty("org.netbeans.api.fold.expander");
                        if (cc != null) {
                            // the caretPos/markPos were already called.
                            // nothing except the document is locked at this moment.
                            try {
                                cc.call();
                            } catch (Exception ex) {
                                Exceptions.printStackTrace(ex);
                        hierarchy.lock();
                        try {
                            Fold collapsed = null;
                            while (expandFold && (collapsed = FoldUtilities.findCollapsedFold(hierarchy, offset, offset)) != null && collapsed.getStartOffset() < offset &&
                                collapsed.getEndOffset() > offset) {
                                hierarchy.expand(collapsed);
                            }
                        } finally {
                            hierarchy.unlock();
                        }
                        if (rectangularSelection) {
                            setRectangularSelectionToDotAndMark();
                        }
                        
                    } catch (BadLocationException e) {
                        throw new IllegalStateException(e.toString());
                        // setting the caret to wrong position leaves it at current position

                    // Disable drag which would otherwise occur when mouse would be over text
                    c.setDragEnabled(false);
                    // Check possible fold expansion
                    try {
                        // hack, to get knowledge of possible expansion. Editor depends on Folding, so it's not really possible
                        // to have Folding depend on BaseCaret (= a cycle). If BaseCaret moves to editor.lib2, this contract
                        // can be formalized as an interface.
                        Callable<Boolean> cc = (Callable<Boolean>)c.getClientProperty("org.netbeans.api.fold.expander");
                        if (cc == null || !cc.call()) {
                            if (selectWordAction == null) {
                                selectWordAction = ((BaseKit) c.getUI().getEditorKit(
                                        c)).getActionByName(BaseKit.selectWordAction);
                                        hierarchy, offset, offset);
                                if (collapsed != null && collapsed.getStartOffset() <= offset
                                        && collapsed.getEndOffset() >= offset) {
                                    hierarchy.expand(collapsed);
                                } else {
                                    if (selectWordAction == null) {
                                        selectWordAction = ((BaseKit) c.getUI().getEditorKit(
                                                c)).getActionByName(BaseKit.selectWordAction);
                                    }
                                    if (selectWordAction != null) {
                                        selectWordAction.actionPerformed(null);
                                    }
                                    // Select word action selects forward i.e. dot > mark
                                    minSelectionStartOffset = getMark();
                                    minSelectionEndOffset = getDot();
                                }
                            } finally {
                                hierarchy.unlock();
                            }
                            if (selectWordAction != null) {
                                selectWordAction.actionPerformed(null);
                            }
                            // Select word action selects forward i.e. dot > mark
                            minSelectionStartOffset = getMark();
                            minSelectionEndOffset = getDot();
                        }
                    } catch (Exception ex) {
                        Exceptions.printStackTrace(ex);
                    }
                    break;
                    

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

                    if (buffer == null) {
                        return;
                    }

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

                    final BaseDocument doc = (BaseDocument) c.getDocument();
                    if (doc == null) {
                        return;
                    }
                                    evt.getX(), evt.getY());

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

                    try {
                        final String pastingString = (String) trans.getTransferData(DataFlavor.stringFlavor);
                        if (pastingString == null) {
                            return;
                        }
                        doc.runAtomicAsUser(new Runnable() {
                            public @Override
                            void run() {
                                try {
                                    doc.insertString(offset, pastingString, null);
                                    setDot(offset + pastingString.length());
                                } catch (BadLocationException exc) {
                                }
                            }
                        });
                    } catch (UnsupportedFlavorException ufe) {
                    } catch (IOException ioe) {
                    }
                }
            }
        }
    }

        }
    }

    public @Override void foldHierarchyChanged(FoldHierarchyEvent evt) {
        int caretOffset = getDot();
        final int addedFoldCnt = evt.getAddedFoldCount();
        final boolean scrollToView;
        LOG.finest("Received fold hierarchy change");
        if (addedFoldCnt > 0) {
            FoldHierarchy hierarchy = (FoldHierarchy) evt.getSource();
            Fold collapsed = null;
            boolean wasExpanded = false;
            while ((collapsed = FoldUtilities.findCollapsedFold(hierarchy, caretOffset, caretOffset)) != null && collapsed.getStartOffset() < caretOffset &&
                    collapsed.getEndOffset() > caretOffset) {
                        hierarchy.expand(collapsed);
                        wasExpanded = true;
                    }
                    // prevent unneeded scrolling; the user may have scrolled out using mouse already
                    // so scroll only if the added fold may affect Y axis. Actually it's unclear why
                    // we should reveal the current position on fold events except when caret is positioned in now-collapsed fold
                    scrollToView = wasExpanded;
        } else {
            int startOffset = Integer.MAX_VALUE;
            // Set the caret's offset to the end of just collapsed fold if necessary
            if (evt.getAffectedStartOffset() <= caretOffset && evt.getAffectedEndOffset() >= caretOffset) {
                for (int i = 0; i < evt.getFoldStateChangeCount(); i++) {
                    FoldStateChange change = evt.getFoldStateChange(i);
                    if (change.isCollapsedChanged()) {
                        Fold fold = change.getFold();
                        if (fold.isCollapsed() && fold.getStartOffset() <= caretOffset && fold.getEndOffset() >= caretOffset) {
                            if (fold.getStartOffset() < startOffset) {
                                startOffset = fold.getStartOffset();
                            }
                        }
                    }
                }
                if (startOffset != Integer.MAX_VALUE) {
                    setDot(startOffset, false);
                }
            }
            scrollToView = false;
        }
        // Update caret's visual position
        // Post the caret update asynchronously since the fold hierarchy is updated before
        // the view hierarchy and the views so the dispatchUpdate() could be picking obsolete
        // view information.
        SwingUtilities.invokeLater(new Runnable() {
            public @Override void run() {
                LOG.finest("Updating after fold hierarchy change");
                if (component == null) {
                    return;
                }
                // see #217867
                Rectangle b = caretBounds;
                updateAfterFoldHierarchyChange = b != null;
                boolean wasInView = b != null && component.getVisibleRect().intersects(b);
                // scroll if:
                // a/ a fold was added and the caret was originally in the view
                // b/ scrollToView is true (= caret was positioned within a new now collapsed fold)
                dispatchUpdate((addedFoldCnt > 1 && wasInView) || scrollToView);
            }
        });
    }
    
    void scheduleCaretUpdate() {
        if (!caretUpdatePending) {
            caretUpdatePending = true;

        DRAG_SELECTION  // Drag is being done (text selection existed at the mouse press)
        
    }

    /**
     * Refreshes caret display on the screen.
     * Some height or view changes may result in the caret going off the screen. In some cases, this is not desirable,
     * as the user's work may be interrupted by e.g. an automatic refresh. This method repositions the view so the
     * caret remains visible.
     * <p/>
     * The method has two modes: it can reposition the view just if it originally displayed the caret and the caret became
     * invisible, and it can scroll the caret into view unconditionally.
     * @param retainInView true to scroll only if the caret was visible. False to refresh regardless of visibility.
     */
    public void refresh(boolean retainInView) {
        Rectangle b = caretBounds;
        updateAfterFoldHierarchyChange = b != null;
        boolean wasInView = b != null && component.getVisibleRect().intersects(b);
        update(!retainInView || wasInView);
    }

}




bracket-match=Match Bracket
build-popup-menu=Build Popup Menu
dump-view-hierarchy=Dump View Hierarchy
collapse-all-folds_menu_text=Co&llapse All
collapse-fold_menu_text=&Collapse Fold
expand-all-folds_menu_text=E&xpand All
expand-fold_menu_text=&Expand Fold
collapse-all-folds=Collapse All
collapse-fold=Collapse Fold
expand-all-folds=Expand All
expand-fold=Expand Fold
build-tool-tip=Build Tool Tip
caret-backward=Insertion Point Backward
caret-begin-line=Insertion Point to Beginning of Text on Line

## ext.Completion.java
ext.Completion.wait=Please wait...

# CodeFoldingSideBar
ACSN_CodeFoldingSideBar=Code folding side bar
ACSD_CodeFoldingSideBar=Code folding side bar shows text folds and allows their collapsing and expanding.

# Format Action
Format_in_progress=Formatting text, please wait...





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 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.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.accessibility.AccessibleRole;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.AttributesUtilities;
import org.netbeans.api.editor.settings.FontColorNames;
import org.netbeans.api.editor.settings.FontColorSettings;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.modules.editor.lib2.EditorPreferencesDefaults;
import org.netbeans.modules.editor.lib.SettingsConversions;
import org.netbeans.modules.editor.lib2.view.LockedViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ParagraphViewDescriptor;
import org.netbeans.modules.editor.lib2.view.ViewHierarchy;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyEvent;
import org.netbeans.modules.editor.lib2.view.ViewHierarchyListener;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;

/**
 *  Code Folding Side Bar. Component responsible for drawing folding signs and responding 
 *  on user fold/unfold action.
 *
 *  @author  Martin Roskanin
 */
public class CodeFoldingSideBar extends JComponent implements Accessible {

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

    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color backColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Color foreColor;
    /** This field should be treated as final. Subclasses are forbidden to change it. 
     * @deprecated Without any replacement.
     */
    protected Font font;
    
    /** This field should be treated as final. Subclasses are forbidden to change it. */
    protected /*final*/ JTextComponent component;
    private volatile AttributeSet attribs;
    private Lookup.Result<? extends FontColorSettings> fcsLookupResult;
    private final LookupListener fcsTracker = new LookupListener() {
        public void resultChanged(LookupEvent ev) {
            attribs = null;
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    //EMI: This is needed as maybe the DEFAULT_COLORING is changed, the font is different
                    // and while getMarkSize() is used in paint() and will make the artifacts bigger,
                    // the component itself will be the same size and it must be changed.
                    // See http://www.netbeans.org/issues/show_bug.cgi?id=153316
                    updatePreferredSize();
                    CodeFoldingSideBar.this.repaint();
                }
            });
        }
    };
    private final Listener listener = new Listener();
    
    private boolean enabled = false;
    
    protected List<Mark> visibleMarks = new ArrayList<Mark>();
    
    /**
     * Mouse moved point, possibly {@code null}. Set from mouse-moved, mouse-entered
     * handlers, so that painting will paint this fold in bold. -1, if mouse is not
     * in the sidebar region. The value is used to compute highlighted portions of the 
     * folding outline.
     */
    private int   mousePoint = -1;
    
    /**
     * if true, the {@link #mousePoint} has been already used to make a PaintInfo active.
     * The flag is tested by {@link #traverseForward} and {@link #traverseBackward} after children
     * of the current fold are processed and cleared if the {@link #mousePoint} falls to the fold area -
     * fields of PaintInfo are set accordingly.
     * It's also used to compute (current) mouseBoundary, so mouse movement does not trigger 
     * refreshes eagerly
     */
    private boolean mousePointConsumed;
    
    /**
     * Boundaries of the current area under the mouse. Can be eiher the span of the
     * current fold (or part of it), or the span not occupied by any fold. Serves as an optimization
     * for mouse handler, which does not trigger painting (refresh) unless mouse 
     * leaves this region.
     */
    private Rectangle   mouseBoundary;
    
    /**
     * Y-end of the nearest fold that ends above the {@link #mousePoint}. Undefined if mousePoint is null.
     * These two variables are initialized at each level of folds, and help to compute {@link #mouseBoundary} for
     * the case the mousePointer is OUTSIDE all children (or outside all folds). 
     */
    private int lowestAboveMouse = -1;

    /**
     * Y-begin of the nearest fold, which starts below the {@link #mousePoint}. Undefined if mousePoint is null
     */
    private int topmostBelowMouse = Integer.MAX_VALUE;
    
    /** Paint operations */
    public static final int PAINT_NOOP             = 0;
    /**
     * Normal opening +- marker
     */
    public static final int PAINT_MARK             = 1;
    
    /**
     * Vertical line - typically at the end of the screen
     */
    public static final int PAINT_LINE             = 2;
    
    /**
     * End angled line, without a sign
     */
    public static final int PAINT_END_MARK         = 3;
    
    /**
     * Single-line marker, both start and end
     */
    public static final int SINGLE_PAINT_MARK      = 4;
    
    /**
     * Marker value for {@link #mousePoint} indicating that mouse is outside the Component.
     */
    private static final int NO_MOUSE_POINT = -1;
    
    /**
     * Stroke used to draw inactive (regular) fold outlines.
     */
    private static Stroke LINE_DASHED = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 
            1f, new float[] { 1f, 1f }, 0f);
    
    /**
     * Stroke used to draw outlines for 'active' fold
     */
    private static final Stroke LINE_BOLD = new BasicStroke(2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);
    
    private final Preferences prefs;
    private final PreferenceChangeListener prefsListener = new PreferenceChangeListener() {
        public void preferenceChange(PreferenceChangeEvent evt) {
            String key = evt == null ? null : evt.getKey();
            if (key == null || SimpleValueNames.CODE_FOLDING_ENABLE.equals(key)) {
                updateColors();
                
                boolean newEnabled = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, EditorPreferencesDefaults.defaultCodeFoldingEnable);
                if (enabled != newEnabled) {
                    enabled = newEnabled;
                    updatePreferredSize();
                }
            }
            SettingsConversions.callSettingsChange(CodeFoldingSideBar.this);
        }
    };
    
    private void checkRepaint(ViewHierarchyEvent vhe) {
        if (!vhe.isChangeY()) {
            // does not obscur sidebar graphics
            return;
        }
        
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                updatePreferredSize();
                CodeFoldingSideBar.this.repaint();
            }
        });
    }
    
    /**
     * @deprecated Don't use this constructor, it does nothing!
     */
    public CodeFoldingSideBar() {
        component = null;
        prefs = null;
        throw new IllegalStateException("Do not use this constructor!"); //NOI18N
    }

    public CodeFoldingSideBar(JTextComponent component){
        super();
        this.component = component;

        addMouseListener(listener);
        addMouseMotionListener(listener);

        FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
        foldHierarchy.addFoldHierarchyListener(WeakListeners.create(FoldHierarchyListener.class, listener, foldHierarchy));

        Document doc = getDocument();
        doc.addDocumentListener(WeakListeners.document(listener, doc));
        setOpaque(true);
        
        prefs = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component)).lookup(Preferences.class);
        prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, prefsListener, prefs));
        prefsListener.preferenceChange(null);
        
        ViewHierarchy.get(component).addViewHierarchyListener(new ViewHierarchyListener() {

            @Override
            public void viewHierarchyChanged(ViewHierarchyEvent evt) {
                checkRepaint(evt);
            }
            
        });
    }
    
    private void updatePreferredSize() {
        if (enabled) {
            setPreferredSize(new Dimension(getColoring().getFont().getSize(), component.getHeight()));
            setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
        }else{
            setPreferredSize(new Dimension(0,0));
            setMaximumSize(new Dimension(0,0));
        }
        revalidate();
    }

    private void updateColors() {
        Coloring c = getColoring();
        this.backColor = c.getBackColor();
        this.foreColor = c.getForeColor();
        this.font = c.getFont();
    }

    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The background color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getBackColor() {
        if (backColor == null) {
            updateColors();
        }
        return backColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The foreground color used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Color getForeColor() {
        if (foreColor == null) {
            updateColors();
        }
        return foreColor;
    }
    
    /**
     * This method should be treated as final. Subclasses are forbidden to override it.
     * @return The font used for painting this component.
     * @deprecated Without any replacement.
     */
    protected Font getColoringFont() {
        if (font == null) {
            updateColors();
        }
        return font;
    }
    
    // overriding due to issue #60304
    public @Override void update(Graphics g) {
    }
    
    protected void collectPaintInfos(
        View rootView, Fold fold, Map<Integer, PaintInfo> map, int level, int startIndex, int endIndex
    ) throws BadLocationException {
        //never called
    }

    /**
     * Adjust lowest/topmost boundaries from the Fold range y1-y2.
     * @param y1
     * @param y2
     * @param level 
     */
    private void setMouseBoundaries(int y1, int y2, int level) {
        if (!hasMousePoint() || mousePointConsumed) {
            return;
        }
        int y = mousePoint;
        if (y2 < y && lowestAboveMouse < y2) {
            LOG.log(Level.FINEST, "lowestAbove at {1}: {0}", new Object[] { y2, level });
            lowestAboveMouse = y2;
        }
        if (y1 > y && topmostBelowMouse > y1) {
            LOG.log(Level.FINEST, "topmostBelow at {1}: {0}", new Object[] { y1, level });
            topmostBelowMouse = y1;
        }
    }
    
    /*
     * Even collapsed fold MAY contain a continuation line, IF one of folds on the same line is NOT collapsed. Such a fold should
     * then visually span multiple lines && be marked as collapsed.
     */

    protected List<? extends PaintInfo> getPaintInfo(Rectangle clip) throws BadLocationException {
        javax.swing.plaf.TextUI textUI = component.getUI();
        if (!(textUI instanceof BaseTextUI)) {
            return Collections.<PaintInfo>emptyList();
        }
        BaseTextUI baseTextUI = (BaseTextUI)textUI;
        BaseDocument bdoc = Utilities.getDocument(component);
        if (bdoc == null) {
            return Collections.<PaintInfo>emptyList();
        }
        mousePointConsumed = false;
        mouseBoundary = null;
        topmostBelowMouse = Integer.MAX_VALUE;
        lowestAboveMouse = -1;
        bdoc.readLock();
        try {
            int startPos = baseTextUI.getPosFromY(clip.y);
            int endPos = baseTextUI.viewToModel(component, Short.MAX_VALUE / 2, clip.y + clip.height);
            
            if (startPos < 0 || endPos < 0) {
                // editor window is not properly sized yet; return no infos
                return Collections.<PaintInfo>emptyList();
            }
            
            // #218282: if the view hierarchy is not yet updated, the Y coordinate may map to an incorrect offset outside
            // the document.
            int docLen = bdoc.getLength();
            if (startPos >= docLen || endPos > docLen) {
                return Collections.<PaintInfo>emptyList();
            }
            
            startPos = Utilities.getRowStart(bdoc, startPos);
            endPos = Utilities.getRowEnd(bdoc, endPos);
            
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                View rootView = Utilities.getDocumentView(component);
                if (rootView != null) {
                    Object [] arr = getFoldList(hierarchy.getRootFold(), startPos, endPos);
                    @SuppressWarnings("unchecked")
                    List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                    int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                    /*
                     * Note:
                     * 
                     * The Map is keyed by Y-VISUAL position of the fold mark, not the textual offset of line start.
                     * This is because several folds may occupy the same line, while only one + sign is displayed,
                     * and affect the last fold in the row.
                     */
                    NavigableMap<Integer, PaintInfo> map = new TreeMap<Integer, PaintInfo>();
                    // search backwards
                    for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                        Fold fold = foldList.get(i);
                        if (!traverseBackwards(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }

                    // search forward
                    for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                        Fold fold = foldList.get(i);
                        if (!traverseForward(fold, bdoc, baseTextUI, startPos, endPos, 0, map)) {
                            break;
                        }
                    }
                    
                    if (map.isEmpty() && foldList.size() > 0) {
                        assert foldList.size() == 1;
                        PaintInfo pi = new PaintInfo(PAINT_LINE, 0, clip.y, clip.height, -1, -1);
                        mouseBoundary = new Rectangle(0, 0, 0, clip.height);
                        LOG.log(Level.FINEST, "Mouse boundary for full side line set to: {0}", mouseBoundary);
                        if (hasMousePoint()) {
                            pi.markActive(true, true, true);
                        }
                        return Collections.singletonList(pi);
                    } else {
                        if (mouseBoundary == null) {
                            mouseBoundary = makeMouseBoundary(clip.y, clip.y + clip.height);
                            LOG.log(Level.FINEST, "Mouse boundary not set, defaulting to: {0}", mouseBoundary);
                        }
                        return new ArrayList<PaintInfo>(map.values());
                    }
                } else {
                    return Collections.<PaintInfo>emptyList();
                }
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }
    }
    
    /**
     * Adds a paint info to the map. If a paintinfo already exists, it merges
     * the structures, so the painting process can just follow the instructions.
     * 
     * @param infos
     * @param yOffset
     * @param nextInfo 
     */
    private void addPaintInfo(Map<Integer, PaintInfo> infos, int yOffset, PaintInfo nextInfo) {
        PaintInfo prevInfo = infos.get(yOffset);
        nextInfo.mergeWith(prevInfo);
        infos.put(yOffset, nextInfo);
    }

    private boolean traverseForward(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary,int level,  NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseForward<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getStartOffset() > upperBoundary ? ", f.gSO > uB" : "")
//                + ", level=" + level);
        
        if (f.getStartOffset() > upperBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int y1 = btui.getYFromPos(lineStartOffset1);
        int h = btui.getEditorUI().getLineHeight();
        int y2 = btui.getYFromPos(lineStartOffset2);
         
        // the 'active' flags can be set only after children are processed; highlights
        // correspond to the innermost expanded child.
        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi;
        boolean activated;
        
        if (y1 == y2) {
            // whole fold is on a single line
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            // fold spans multiple lines
            spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
            if (activated = isActivated(y1, y2 + h / 2)) {
                activeMark = true;
                activeOut = true;
            }
            addPaintInfo(infos, y1, spi);
        }

        setMouseBoundaries(y1, y2 + h / 2, level);

        // Handle end mark after possible inner folds were processed because
        // otherwise if there would be two nested folds both ending at the same line
        // then the end mark for outer one would be replaced by an end mark for inner one
        // (same key in infos map) and the painting code would continue to paint line marking a fold
        // until next fold is reached (or end of doc).
        PaintInfo epi = null;
        if (y1 != y2 && !f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
            epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
            addPaintInfo(infos, y2, epi);
        }

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h / 2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                spi.markActive(activeMark, activeIn, activeOut);
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                markDeepChildrenActive(infos, y1, y2, level);
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
     
    /**
     * Sets outlines of all children to 'active'. Assuming yFrom and yTo are from-to Y-coordinates of the parent
     * fold, it finds all nested folds (folds, which are in between yFrom and yTo) and changes their in/out lines
     * as active.
     * The method returns Y start coordinate of the 1st child found.
     * 
     * @param infos fold infos collected so far
     * @param yFrom upper Y-coordinate of the parent fold
     * @param yTo lower Y-coordinate of the parent fold
     * @param level level of the parent fold
     * @return Y-coordinate of the 1st child.
     */
    private int markDeepChildrenActive(NavigableMap<Integer, PaintInfo> infos, int yFrom, int yTo, int level) {
        int result = Integer.MAX_VALUE;
        Map<Integer, PaintInfo> m = infos.subMap(yFrom, yTo);
        for (Map.Entry<Integer, PaintInfo> me : m.entrySet()) {
            PaintInfo pi = me.getValue();
            int y = pi.getPaintY();
            if (y > yFrom && y < yTo) {
                if (LOG.isLoggable(Level.FINEST)) {
                    LOG.log(Level.FINEST, "Marking chind as active: {0}", pi);
                }
                pi.markActive(false, true, true);
                if (y < result) {
                    y = result;
                }
            }
        }
        return result;
    }
    
    /**
     * Returns stroke appropriate for painting (in)active outlines
     * @param s the default stroke
     * @param active true for active outlines
     * @return value of 's' or a Stroke which should be used to paint the outline.
     */
    private static Stroke getStroke(Stroke s, boolean active) {
        if (active) {
            return LINE_BOLD;
        } else {
            return s;
        }
    }
    
    private boolean traverseBackwards(Fold f, BaseDocument doc, BaseTextUI btui, int lowerBoundary, int upperBoundary, int level, NavigableMap<Integer, PaintInfo> infos) throws BadLocationException {
//        System.out.println("~~~ traverseBackwards<" + lowerBoundary + ", " + upperBoundary
//                + ">: fold=<" + f.getStartOffset() + ", " + f.getEndOffset() + "> "
//                + (f.getEndOffset() < lowerBoundary ? ", f.gEO < lB" : "")
//                + ", level=" + level);

        if (f.getEndOffset() < lowerBoundary) {
            return false;
        }

        int lineStartOffset1 = Utilities.getRowStart(doc, f.getStartOffset());
        int lineStartOffset2 = Utilities.getRowStart(doc, f.getEndOffset());
        int h = btui.getEditorUI().getLineHeight();

        boolean activeMark = false;
        boolean activeIn = false;
        boolean activeOut = false;
        PaintInfo spi = null;
        PaintInfo epi = null;
        boolean activated = false;
        int y1 = 0;
        int y2 = 0;
        
        if (lineStartOffset1 == lineStartOffset2) {
            // whole fold is on a single line
            y2 = y1 = btui.getYFromPos(lineStartOffset1);
            spi = new PaintInfo(SINGLE_PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset1);
            if (activated = isActivated(y1, y1 + h)) {
                activeMark = true;
            }
            addPaintInfo(infos, y1, spi);
        } else {
            y2 = btui.getYFromPos(lineStartOffset2);
            // fold spans multiple lines
            y1 = btui.getYFromPos(lineStartOffset1);
            activated = isActivated(y1, y2 + h / 2);
            if (f.getStartOffset() >= upperBoundary) {
                spi = new PaintInfo(PAINT_MARK, level, y1, h, f.isCollapsed(), lineStartOffset1, lineStartOffset2);
                if (activated) {
                    activeMark = true;
                    activeOut = true;
                }
                addPaintInfo(infos, y1, spi);
            }

            if (!f.isCollapsed() && f.getEndOffset() <= upperBoundary) {
                activated |= isActivated(y1, y2 + h / 2);
                epi = new PaintInfo(PAINT_END_MARK, level, y2, h, lineStartOffset1, lineStartOffset2);
                addPaintInfo(infos, y2, epi);
            }
        }
        
        setMouseBoundaries(y1, y2 + h / 2, level);

        // save the topmost/lowest information, reset for child processing
        int topmost = topmostBelowMouse;
        int lowest = lowestAboveMouse;
        topmostBelowMouse = y2 + h /2;
        lowestAboveMouse = y1;

        try {
            if (!f.isCollapsed()) {
                Object [] arr = getFoldList(f, lowerBoundary, upperBoundary);
                @SuppressWarnings("unchecked")
                List<? extends Fold> foldList = (List<? extends Fold>) arr[0];
                int idxOfFirstFoldStartingInsideClip = (Integer) arr[1];

                // search backwards
                for(int i = idxOfFirstFoldStartingInsideClip - 1; i >= 0; i--) {
                    Fold fold = foldList.get(i);
                    if (!traverseBackwards(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        return false;
                    }
                }

                // search forward
                for(int i = idxOfFirstFoldStartingInsideClip; i < foldList.size(); i++) {
                    Fold fold = foldList.get(i);
                    if (!traverseForward(fold, doc, btui, lowerBoundary, upperBoundary, level + 1, infos)) {
                        break;
                    }
                }
            }
            if (!mousePointConsumed && activated) {
                mousePointConsumed = true;
                mouseBoundary = makeMouseBoundary(y1, y2 + h);
                LOG.log(Level.FINEST, "Mouse boundary set to: {0}", mouseBoundary);
                if (spi != null) {
                    spi.markActive(activeMark, activeIn, activeOut);
                }
                if (epi != null) {
                    epi.markActive(true, true, false);
                }
                int lowestChild = markDeepChildrenActive(infos, y1, y2, level);
                if (lowestChild < Integer.MAX_VALUE && lineStartOffset1 < upperBoundary) {
                    // the fold starts above the screen clip region, and is 'activated'. We need to setup instructions to draw activated line up to the
                    // 1st child marker.
                    epi = new PaintInfo(PAINT_LINE, level, y1, y2 - y1, false, lineStartOffset1, lineStartOffset2);
                    epi.markActive(true, true, false);
                    addPaintInfo(infos, y1, epi);
                }
            }
        } finally {
            topmostBelowMouse = topmost;
            lowestAboveMouse = lowest;
        }
        return true;
    }
    
    private Rectangle makeMouseBoundary(int y1, int y2) {
        if (!hasMousePoint()) {
            return null;
        }
        if (topmostBelowMouse < Integer.MAX_VALUE) {
            y2 = topmostBelowMouse;
        }
        if (lowestAboveMouse  > -1) {
            y1 = lowestAboveMouse;
        }
        return new Rectangle(0, y1, 0, y2 - y1);
    }
    
    protected EditorUI getEditorUI(){
        return Utilities.getEditorUI(component);
    }
    
    protected Document getDocument(){
        return component.getDocument();
    }


    private Fold getLastLineFold(FoldHierarchy hierarchy, int rowStart, int rowEnd, boolean shift){
        Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
        Fold prevFold = fold;
        while (fold != null && fold.getStartOffset()<rowEnd){
            Fold nextFold = FoldUtilities.findNearestFold(hierarchy, (fold.isCollapsed()) ? fold.getEndOffset() : fold.getStartOffset()+1);
            if (nextFold == fold) return fold;
            if (nextFold!=null && nextFold.getStartOffset() < rowEnd){
                prevFold = shift ? fold : nextFold;
                fold = nextFold;
            }else{
                return prevFold;
            }
        }
        return prevFold;
    }
    
    protected void performAction(Mark mark) {
        performAction(mark, false);
    }
    
    private void performActionAt(Mark mark, int mouseY) throws BadLocationException {
        if (mark != null) {
            return;
        }
        BaseDocument bdoc = Utilities.getDocument(component);
        BaseTextUI textUI = (BaseTextUI)component.getUI();

        View rootView = Utilities.getDocumentView(component);
        if (rootView == null) return;
        
        bdoc.readLock();
        try {
            int yOffset = textUI.getPosFromY(mouseY);
            FoldHierarchy hierarchy = FoldHierarchy.get(component);
            hierarchy.lock();
            try {
                Fold f = FoldUtilities.findOffsetFold(hierarchy, yOffset);
                if (f == null) {
                    return;
                }
                if (f.isCollapsed()) {
                    LOG.log(Level.WARNING, "Clicked on a collapsed fold {0} at {1}", new Object[] { f, mouseY });
                    return;
                }
                int startOffset = f.getStartOffset();
                int endOffset = f.getEndOffset();
                
                int startY = textUI.getYFromPos(startOffset);
                int nextLineOffset = Utilities.getRowStart(bdoc, startOffset, 1);
                int nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    LOG.log(Level.FINEST, "Starting line clicked, ignoring. MouseY={0}, startY={1}, nextY={2}",
                            new Object[] { mouseY, startY, nextY });
                    return;
                }

                startY = textUI.getYFromPos(endOffset);
                nextLineOffset = Utilities.getRowStart(bdoc, endOffset, 1);
                nextY = textUI.getYFromPos(nextLineOffset);

                if (mouseY >= startY && mouseY <= nextY) {
                    // the mouse can be positioned above the marker (the fold found above), or
                    // below it; in that case, the immediate enclosing fold should be used - should be the fold
                    // that corresponds to the nextLineOffset, if any
                    int h2 = (startY + nextY) / 2;
                    if (mouseY >= h2) {
                        Fold f2 = f;
                        
                        f = FoldUtilities.findOffsetFold(hierarchy, nextLineOffset);
                        if (f == null) {
                            // fold does not exist for the position below end-of-fold indicator
                            return;
                        }
                    }
                    
                }
                
                LOG.log(Level.FINEST, "Collapsing fold: {0}", f);
                hierarchy.collapse(f);
            } finally {
                hierarchy.unlock();
            }
        } finally {
            bdoc.readUnlock();
        }        
    }
    
    private void performAction(final Mark mark, final boolean shiftFold) {
        Document doc = component.getDocument();
        doc.render(new Runnable() {
            @Override
            public void run() {
                ViewHierarchy vh = ViewHierarchy.get(component);
                LockedViewHierarchy lockedVH = vh.lock();
                try {
                    int pViewIndex = lockedVH.yToParagraphViewIndex(mark.y + mark.size / 2);
                    if (pViewIndex >= 0) {
                        ParagraphViewDescriptor pViewDesc = lockedVH.getParagraphViewDescriptor(pViewIndex);
                        int pViewStartOffset = pViewDesc.getStartOffset();
                        int pViewEndOffset = pViewStartOffset + pViewDesc.getLength();
                        // Find corresponding fold
                        FoldHierarchy foldHierarchy = FoldHierarchy.get(component);
                        foldHierarchy.lock();
                        try {
                            int rowStart = javax.swing.text.Utilities.getRowStart(component, pViewStartOffset);
                            int rowEnd = javax.swing.text.Utilities.getRowEnd(component, pViewStartOffset);
                            Fold clickedFold = getLastLineFold(foldHierarchy, rowStart, rowEnd, shiftFold);//FoldUtilities.findNearestFold(foldHierarchy, viewStartOffset);
                            if (clickedFold != null && clickedFold.getStartOffset() < pViewEndOffset) {
                                foldHierarchy.toggle(clickedFold);
                            }
                        } catch (BadLocationException ble) {
                            LOG.log(Level.WARNING, null, ble);
                        } finally {
                            foldHierarchy.unlock();
                        }
                    }
                } finally {
                    lockedVH.unlock();
                }
            }
        });
    }
    
    protected int getMarkSize(Graphics g){
        if (g != null){
            FontMetrics fm = g.getFontMetrics(getColoring().getFont());
            if (fm != null){
                int ret = fm.getAscent() - fm.getDescent();
                return ret - ret%2;
            }
        }
        return -1;
    }
    
    private boolean hasMousePoint() {
        return mousePoint >= 0;
    }
    
    private boolean isActivated(int y1, int y2) {
        return hasMousePoint() && 
               (mousePoint >= y1 && mousePoint < y2);
    }
    
    private void drawFoldLine(Graphics2D g2d, boolean active, int x1, int y1, int x2, int y2) {
        Stroke origStroke = g2d.getStroke();
        g2d.setStroke(getStroke(origStroke, active));
        g2d.drawLine(x1, y1, x2, y2);
        g2d.setStroke(origStroke);
    }
    
    protected @Override void paintComponent(Graphics g) {
        if (!enabled) {
            return;
        }
        
        Rectangle clip = getVisibleRect();//g.getClipBounds();
        visibleMarks.clear();
        
        Coloring coloring = getColoring();
        g.setColor(coloring.getBackColor());
        g.fillRect(clip.x, clip.y, clip.width, clip.height);
        g.setColor(coloring.getForeColor());

        AbstractDocument adoc = (AbstractDocument)component.getDocument();
        adoc.readLock();
        try {
            List<? extends PaintInfo> ps = getPaintInfo(clip);
            Font defFont = coloring.getFont();
            int markSize = getMarkSize(g);
            int halfMarkSize = markSize / 2;
            int markX = (defFont.getSize() - markSize) / 2; // x position of mark rectangle
            int plusGap = (int)Math.round(markSize / 3.8); // distance between mark rectangle vertical side and start/end of minus sign
            int lineX = markX + halfMarkSize; // x position of the centre of mark

            LOG.fine("CFSBar: PAINT START ------\n");
            int descent = g.getFontMetrics(defFont).getDescent();
            PaintInfo previousInfo = null;
            Graphics2D g2d = (Graphics2D)g;
            LOG.log(Level.FINEST, "MousePoint: {0}", mousePoint);

            for(PaintInfo paintInfo : ps) {
                boolean isFolded = paintInfo.isCollapsed();
                int y = paintInfo.getPaintY();
                int height = paintInfo.getPaintHeight();
                int markY = y + descent; // y position of mark rectangle
                int paintOperation = paintInfo.getPaintOperation();

                if (previousInfo == null) {
                    if (paintInfo.hasLineIn()) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("prevInfo=NULL; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, clip.y, lineX, y);
                    }
                } else {
                    if (previousInfo.hasLineOut() || paintInfo.hasLineIn()) {
                        // Draw middle vertical line
                        int prevY = previousInfo.getPaintY();
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.log(Level.FINE, "prevInfo={0}; y=" + y + ", PI:" + paintInfo + "\n", previousInfo); // NOI18N
                        }
                        drawFoldLine(g2d, previousInfo.lineOutActive || paintInfo.lineInActive, lineX, prevY + previousInfo.getPaintHeight(), lineX, y);
                    }
                }

                if (paintInfo.hasSign()) {
                    g.drawRect(markX, markY, markSize, markSize);
                    g.drawLine(plusGap + markX, markY + halfMarkSize, markSize + markX - plusGap, markY + halfMarkSize);
                    String opStr = (paintOperation == PAINT_MARK) ? "PAINT_MARK" : "SINGLE_PAINT_MARK"; // NOI18N
                    if (isFolded) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": folded; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                        g.drawLine(lineX, markY + plusGap, lineX, markY + markSize - plusGap);
                    }
                    if (paintOperation != SINGLE_PAINT_MARK) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine(opStr + ": non-single; y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                        }
                    }
                    if (paintInfo.hasLineIn()) { //[PENDING]
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, markY);
                    }
                    if (paintInfo.hasLineOut()) {
                        // This is an error in case there's a next paint info at the same y which is an end mark
                        // for this mark (it must be cleared explicitly).
                        drawFoldLine(g2d, paintInfo.lineOutActive, lineX, markY + markSize, lineX, y + height);
                    }
                    visibleMarks.add(new Mark(markX, markY, markSize, isFolded));

                } else if (paintOperation == PAINT_LINE) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_LINE: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    // FIXME !!
                    drawFoldLine(g2d, paintInfo.signActive, lineX, y, lineX, y + height );
                } else if (paintOperation == PAINT_END_MARK) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("PAINT_END_MARK: y=" + y + ", PI:" + paintInfo + "\n"); // NOI18N
                    }
                    if (previousInfo == null || y != previousInfo.getPaintY()) {
                        drawFoldLine(g2d, paintInfo.lineInActive, lineX, y, lineX, y + height / 2);
                        drawFoldLine(g2d, paintInfo.signActive, lineX, y + height / 2, lineX + halfMarkSize, y + height / 2);
                        if (paintInfo.getInnerLevel() > 0) {//[PENDING]
                            if (LOG.isLoggable(Level.FINE)) {
                                LOG.fine("  PAINT middle-line\n"); // NOI18N
                            }
                            drawFoldLine(g2d, paintInfo.lineOutActive, lineX, y + height / 2, lineX, y + height);
                        }
                    }
                }

                previousInfo = paintInfo;
            }

            if (previousInfo != null &&
                (previousInfo.getInnerLevel() > 0 ||
                 (previousInfo.getPaintOperation() == PAINT_MARK && !previousInfo.isCollapsed()))
            ) {
                drawFoldLine(g2d, previousInfo.lineOutActive, 
                        lineX, previousInfo.getPaintY() + previousInfo.getPaintHeight(), lineX, clip.y + clip.height);
            }

        } catch (BadLocationException ble) {
            LOG.log(Level.WARNING, null, ble);
        } finally {
            LOG.fine("CFSBar: PAINT END ------\n\n");
            adoc.readUnlock();
        }
    }
    
    private static Object [] getFoldList(Fold parentFold, int start, int end) {
        List<Fold> ret = new ArrayList<Fold>();

        int index = FoldUtilities.findFoldEndIndex(parentFold, start);
        int foldCount = parentFold.getFoldCount();
        int idxOfFirstFoldStartingInside = -1;
        while (index < foldCount) {
            Fold f = parentFold.getFold(index);
            if (f.getStartOffset() <= end) {
                ret.add(f);
            } else {
                break; // no more relevant folds
            }
            if (idxOfFirstFoldStartingInside == -1 && f.getStartOffset() >= start) {
                idxOfFirstFoldStartingInside = ret.size() - 1;
            }
            index++;
        }

        return new Object [] { ret, idxOfFirstFoldStartingInside != -1 ? idxOfFirstFoldStartingInside : ret.size() };
    }

    /**
     * This class should be never used by other code; will be made private
     */
    public class PaintInfo {
        
        int paintOperation;
        /**
         * level of the 1st marker on the line
         */
        int innerLevel;
        
        /**
         * Y-coordinate of the cell
         */
        int paintY;
        
        /**
         * Height of the paint cell
         */
        int paintHeight;
        
        /**
         * State of the marker (+/-)
         */
        boolean isCollapsed;
        
        /**
         * all markers on the line are collapsed
         */
        boolean allCollapsed;
        int startOffset;
        int endOffset;
        /**
         * nesting level of the last marker on the line
         */
        int outgoingLevel;
        
        /**
         * Force incoming line (from above) to be present
         */
        boolean lineIn;
        
        /**
         * Force outgoing line (down from marker) to be present
         */
        boolean lineOut;
        
        /**
         * The 'incoming' (upper) line should be painted as active
         */
        boolean lineInActive;
        
        /**
         * The 'outgoing' (down) line should be painted as active
         */
        boolean lineOutActive;
        
        /**
         * The sign/marker itself should be painted as active
         */
        boolean signActive;
        
        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, boolean isCollapsed, int startOffset, int endOffset){
            this.paintOperation = paintOperation;
            this.innerLevel = this.outgoingLevel = innerLevel;
            this.paintY = paintY;
            this.paintHeight = paintHeight;
            this.isCollapsed = this.allCollapsed = isCollapsed;
            this.startOffset = startOffset;
            this.endOffset = endOffset;

            switch (paintOperation) {
                case PAINT_MARK:
                    lineIn = false;
                    lineOut = true;
                    outgoingLevel++;
                    break;
                case SINGLE_PAINT_MARK:
                    lineIn = false;
                    lineOut = false;
                    break;
                case PAINT_END_MARK:
                    lineIn = true;
                    lineOut = false;
                    isCollapsed = true;
                    allCollapsed = true;
                    break;
                case PAINT_LINE:
                    lineIn = lineOut = true;
                    break;
            }
        }
        
        /**
         * Sets active flags on inidivual parts of the mark
         * @param mark
         * @param lineIn
         * @param lineOut S
         */
        void markActive(boolean mark, boolean lineIn, boolean lineOut) {
            this.signActive |= mark;
            this.lineInActive |= lineIn;
            this.lineOutActive |= lineOut;
        }
        
        boolean hasLineIn() {
            return lineIn || innerLevel > 0;
        }
        
        boolean hasLineOut() {
            return lineOut || outgoingLevel > 0 || (paintOperation != SINGLE_PAINT_MARK && !isAllCollapsed());
        }

        public PaintInfo(int paintOperation, int innerLevel, int paintY, int paintHeight, int startOffset, int endOffset){
            this(paintOperation, innerLevel, paintY, paintHeight, false, startOffset, endOffset);
        }
        
        public int getPaintOperation(){
            return paintOperation;
        }
        
        public int getInnerLevel(){
            return innerLevel;
        }
        
        public int getPaintY(){
            return paintY;
        }
        
        public int getPaintHeight(){
            return paintHeight;
        }
        
        public boolean isCollapsed(){
            return isCollapsed;
        }
        
         boolean isAllCollapsed() {
            return allCollapsed;
        }
        
        public void setPaintOperation(int paintOperation){
            this.paintOperation = paintOperation;
        }
        
        public void setInnerLevel(int innerLevel){
            this.innerLevel = innerLevel;
        }
        
        public @Override String toString(){
            StringBuffer sb = new StringBuffer("");
            if (paintOperation == PAINT_MARK){
                sb.append("PAINT_MARK"); // NOI18N
            }else if (paintOperation == PAINT_LINE){
                sb.append("PAINT_LINE"); // NOI18N
            }else if (paintOperation == PAINT_END_MARK) {
                sb.append("PAINT_END_MARK"); // NOI18N
            }else if (paintOperation == SINGLE_PAINT_MARK) {
                sb.append("SINGLE_PAINT_MARK");
            }
            sb.append(",L:").append(innerLevel).append("/").append(outgoingLevel); // NOI18N
            sb.append(',').append(isCollapsed ? "C" : "E"); // NOI18N
            sb.append(", start=").append(startOffset).append(", end=").append(endOffset);
            sb.append(", lineIn=").append(lineIn).append(", lineOut=").append(lineOut);
            return sb.toString();
        }
        
        boolean hasSign() {
            return paintOperation == PAINT_MARK || paintOperation == SINGLE_PAINT_MARK;
        }
        
        
        void mergeWith(PaintInfo prevInfo) {
            if (prevInfo == null) {
                return;
            }

            int operation = this.paintOperation;
            boolean lineIn = prevInfo.lineIn;
            boolean lineOut = prevInfo.lineOut;
            
            LOG.log(Level.FINE, "Merging {0} with {1}: ", new Object[] { this, prevInfo });
            if (prevInfo.getPaintOperation() == PAINT_END_MARK) {
                // merge with start|single -> start mark + line-in
                lineIn = true;
            } else {
                operation = PAINT_MARK;
            }

            int level1 = Math.min(prevInfo.innerLevel, innerLevel);
            int level2 = prevInfo.outgoingLevel;

            if (getPaintOperation() == PAINT_END_MARK 
                && innerLevel == prevInfo.outgoingLevel) {
                // if merging end marker at the last level, update to the new outgoing level
                level2 = outgoingLevel;
            } else if (!isCollapsed) {
                level2 = Math.max(prevInfo.outgoingLevel, outgoingLevel);
            }

            if (prevInfo.getInnerLevel() < getInnerLevel()) {
                int paintFrom = Math.min(prevInfo.paintY, paintY);
                int paintTo = Math.max(prevInfo.paintY + prevInfo.paintHeight, paintY + paintHeight);
                // at least one collapsed -> paint plus sign
                boolean collapsed = prevInfo.isCollapsed() || isCollapsed();
                int offsetFrom = Math.min(prevInfo.startOffset, startOffset);
                int offsetTo = Math.max(prevInfo.endOffset, endOffset);
                
                this.paintY = paintFrom;
                this.paintHeight = paintTo - paintFrom;
                this.isCollapsed = collapsed;
                this.startOffset = offsetFrom;
                this.endOffset = offsetTo;
            }
            this.paintOperation = operation;
            this.allCollapsed = prevInfo.allCollapsed && allCollapsed;
            this.innerLevel = level1;
            this.outgoingLevel = level2;
            this.lineIn |= lineIn;
            this.lineOut |= lineOut;
            
            this.signActive |= prevInfo.signActive;
            this.lineInActive |= prevInfo.lineInActive;
            this.lineOutActive |= prevInfo.lineOutActive;
            
            LOG.log(Level.FINE, "Merged result: {0}", this);
        }
    }
    
    /** Keeps info of visible folding mark */
    public class Mark{
        public int x;
        public int y;
        public int size;
        public boolean isFolded;
        
        public Mark(int x, int y, int size, boolean isFolded){
            this.x = x;
            this.y = y;
            this.size = size;
            this.isFolded = isFolded;
        }
    }
    
    private final class Listener extends MouseAdapter implements FoldHierarchyListener, DocumentListener, Runnable {
    
        public Listener(){
        }

        // --------------------------------------------------------------------
        // FoldHierarchyListener implementation
        // --------------------------------------------------------------------

        public void foldHierarchyChanged(FoldHierarchyEvent evt) {
            refresh();
        }

        // --------------------------------------------------------------------
        // DocumentListener implementation
        // --------------------------------------------------------------------

        public void insertUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines inserted
                refresh();
            }
        }

        public void removeUpdate(DocumentEvent evt) {
            if (!(evt instanceof BaseDocumentEvent)) return;

            BaseDocumentEvent bevt = (BaseDocumentEvent)evt;
            if (bevt.getLFCount() > 0) { // one or more lines removed
                refresh();
            }
        }

        public void changedUpdate(DocumentEvent evt) {
        }

        // --------------------------------------------------------------------
        // MouseListener implementation
        // --------------------------------------------------------------------

        @Override
        public void mousePressed (MouseEvent e) {
            Mark mark = getClickedMark(e);
            if (mark!=null){
                e.consume();
                performAction(mark, (e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) > 0);
            }
        }

        @Override
        public void mouseClicked(MouseEvent e) {
            // #102288 - missing event consuming caused quick doubleclicks to break
            // fold expanding/collapsing and move caret to the particular line
            if (e.getClickCount() > 1) {
                LOG.log(Level.FINEST, "Mouse {0}click at {1}", new Object[] { e.getClickCount(), e.getY()});
                Mark mark = getClickedMark(e);
                try {
                    performActionAt(mark, e.getY());
                } catch (BadLocationException ex) {
                    LOG.log(Level.WARNING, "Error during fold expansion using sideline", ex);
                }
            } else {
                e.consume();
            }
        }

        private void refreshIfMouseOutside(Point pt) {
            mousePoint = (int)pt.getY();
            if (LOG.isLoggable(Level.FINEST)) {
                if (mouseBoundary == null) {
                    LOG.log(Level.FINEST, "Mouse boundary not set, refreshing: {0}", mousePoint);
                } else {
                    LOG.log(Level.FINEST, "Mouse {0} inside known mouse boundary: {1}-{2}", 
                            new Object[] { mousePoint, mouseBoundary.y, mouseBoundary.getMaxY() });
                }
            }
            if (mouseBoundary == null || mousePoint < mouseBoundary.y || mousePoint > mouseBoundary.getMaxY()) {
                refresh();
            }
        }
        
        @Override
        public void mouseMoved(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseEntered(MouseEvent e) {
            refreshIfMouseOutside(e.getPoint());
        }
        
        public void mouseExited(MouseEvent e) {
            mousePoint = NO_MOUSE_POINT;
            refresh();
        }
        

        // --------------------------------------------------------------------
        // private implementation
        // --------------------------------------------------------------------

        private Mark getClickedMark(MouseEvent e){
            if (e == null || !SwingUtilities.isLeftMouseButton(e)) {
                return null;
            }
            
            int x = e.getX();
            int y = e.getY();
            for (Mark mark : visibleMarks) {
                if (x >= mark.x && x <= (mark.x + mark.size) && y >= mark.y && y <= (mark.y + mark.size)) {
                    return mark;
                }
            }
            return null;
        }

        private void refresh() {
            SwingUtilities.invokeLater(this);
        }

        @Override
        public void run() {
            repaint();
        }
    } // End of Listener class
    
    @Override
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJComponent() {
                public @Override AccessibleRole getAccessibleRole() {
                    return AccessibleRole.PANEL;
                }
            };
            accessibleContext.setAccessibleName(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSN_CodeFoldingSideBar")); //NOI18N
        accessibleContext.setAccessibleDescription(NbBundle.getMessage(CodeFoldingSideBar.class, "ACSD_CodeFoldingSideBar")); //NOI18N
        }
        return accessibleContext;
    }

    private Coloring getColoring() {
        if (attribs == null) {
            if (fcsLookupResult == null) {
                fcsLookupResult = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(component))
                        .lookupResult(FontColorSettings.class);
                fcsLookupResult.addLookupListener(WeakListeners.create(LookupListener.class, fcsTracker, fcsLookupResult));
            }
            
            FontColorSettings fcs = fcsLookupResult.allInstances().iterator().next();
            AttributeSet attr = fcs.getFontColors(FontColorNames.CODE_FOLDING_BAR_COLORING);
            if (attr == null) {
                attr = fcs.getFontColors(FontColorNames.DEFAULT_COLORING);
            } else {
                attr = AttributesUtilities.createComposite(attr, fcs.getFontColors(FontColorNames.DEFAULT_COLORING));
            }
            attribs = attr;
        }        
        return Coloring.fromAttributeSet(attribs);
    }
    
}




import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.EditorStyleConstants;
import org.netbeans.api.editor.settings.FontColorNames;

    /** Property change listener on AnnotationTypes changes */
    private PropertyChangeListener annoTypesListener;
    private PropertyChangeListener editorUIListener;
    private GlyphGutter.GlyphGutterFoldHierarchyListener glyphGutterFoldHierarchyListener;
    private GutterMouseListener gutterMouseListener;
    private FoldHierarchy foldHierarchy;

    private ColoringMap coloringMap;
    private final PropertyChangeListener coloringMapListener = new PropertyChangeListener() {

        init();
        update();
        setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
        foldHierarchy = FoldHierarchy.get(eui.getComponent());
        glyphGutterFoldHierarchyListener = new GlyphGutterFoldHierarchyListener();
        foldHierarchy.addFoldHierarchyListener(glyphGutterFoldHierarchyListener);
        editorUIListener = new EditorUIListener();
        eui.addPropertyChangeListener(editorUIListener);
        eui.getComponent().addPropertyChangeListener(editorUIListener);

        
    }

    class GlyphGutterFoldHierarchyListener implements FoldHierarchyListener, Runnable {
    
        public GlyphGutterFoldHierarchyListener(){
        }
        
        public @Override void foldHierarchyChanged(FoldHierarchyEvent evt) {
            // Do not react to fold changes since fold expanding/collapsing should trigger
            // corresponding view hierarchy changes covered by view hierarchy listener.

//            SwingUtilities.invokeLater(this);
        }

        @Override
        public void run() {
            repaint();
        }
    }
    
    /** Listening to EditorUI to properly deinstall attached listeners */
    class EditorUIListener implements PropertyChangeListener{
        public @Override void propertyChange (PropertyChangeEvent evt) {

                            ((JTextComponent) evt.getOldValue()).removePropertyChangeListener(this);
                        }
                        annos.removeAnnotationsListener(GlyphGutter.this);
                        foldHierarchy.removeFoldHierarchyListener(glyphGutterFoldHierarchyListener);
                        if (gutterMouseListener!=null){
                            removeMouseListener(gutterMouseListener);
                            removeMouseMotionListener(gutterMouseListener);

                        if (annoTypesListener !=null){
                            AnnotationTypes.getTypes().removePropertyChangeListener(annoTypesListener);
                        }
                        foldHierarchy.removeFoldHierarchyListener(glyphGutterFoldHierarchyListener);
                        foldHierarchy = null;
                        editorUI = null;
                        annos = null;
                    }




import java.awt.Rectangle;
import java.awt.Shape;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.swing.plaf.TextUI;
import javax.swing.text.AbstractDocument;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.View;
import javax.swing.text.ViewFactory;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.api.editor.fold.FoldHierarchy;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.fold.FoldHierarchyEvent;
import org.netbeans.api.editor.fold.FoldHierarchyListener;
import org.netbeans.editor.BaseTextUI;
import org.netbeans.editor.EditorUI;
import org.netbeans.lib.editor.view.GapDocumentView;

 * @author Miloslav Metelka
 */
public class DrawEngineDocView extends GapDocumentView
implements PropertyChangeListener {
    
    private static final boolean debugRebuild
        = Boolean.getBoolean("netbeans.debug.editor.view.rebuild"); // NOI18N

    private FoldHierarchy foldHierarchy;
    /** Editor UI listening to */
    private EditorUI editorUI;
    
    private Iterator collapsedFoldIterator;
    private Fold collapsedFold;
    private int collapsedFoldStartOffset;
    private int collapsedFoldEndOffset;
    
    private boolean collapsedFoldsInPresentViews;
    

    public @Override void setParent(View parent) {
        if (parent != null) { // start listening
            JTextComponent component = (JTextComponent)parent.getContainer();
            foldHierarchy = FoldHierarchy.get(component);
            foldHierarchy.addFoldHierarchyListener(this);
            TextUI tui = component.getUI();
            if (tui instanceof BaseTextUI){
                editorUI = ((BaseTextUI)tui).getEditorUI();

        super.setParent(parent);
        
        if (parent == null) {
            foldHierarchy.removeFoldHierarchyListener(this);
            foldHierarchy = null;
            if (editorUI!=null){
                editorUI.removePropertyChangeListener(this);
                editorUI = null;

    }
    
    protected void attachListeners(){
        if (foldHierarchy != null) {
        }
    }
    
    private FoldHierarchy getFoldHierarchy() {
        return foldHierarchy;
    }
    
    protected @Override boolean useCustomReloadChildren() {
        return true;
    }

    /**
     * Find next collapsed fold in the given offset range.
     * @param lastCollapsedFold last collapsed fold returned by this method.
     * @param startOffset starting offset of the area in which the collapsed folds
     *  should be searched.
     * @param endOffset ending offset of the area in which the collapsed folds
     *  should be searched.
     */
    protected Fold nextCollapsedFold() {
        while (true) {
            Fold fold = collapsedFoldIterator.hasNext() ? (Fold)collapsedFoldIterator.next() : null;

            // Check whether the fold is not past the doc
            if (fold != null) {
                collapsedFoldStartOffset = fold.getStartOffset();
                collapsedFoldEndOffset = fold.getEndOffset();
                /* Ignore the empty folds as they would make up
                 * no visible view anyway.
                 * Although the fold hierarchy removes the empty views
                 * automatically it may happen that the document listener
                 * that the fold hierarchy attaches may not be notified yet.
                 */
                if (collapsedFoldStartOffset == collapsedFoldEndOffset) {
                    if (debugRebuild) {
                        /*DEBUG*/System.err.println(
                            "GapBoxView.nextCollapsedFold(): ignored empty fold " // NOI18N
                            + fold
                        );
                    }
                    continue; // skip empty fold
                }

                if (collapsedFoldEndOffset > getDocument().getLength()) {
                    /* The fold is past the end of the document.
                     * If a document is going to be switched in the component
                     * the view hierarchy may be notified sooner
                     * than fold hierarchy about that change which
                     * can lead to this state.
                     * That fold is ignored together with the rest of the folds
                     * that would follow it.
                     */
                    fold = null;
                }
            }

            if (fold != null) {
                collapsedFoldsInPresentViews = true;
            }

            return fold;
        }
    }
    
    /**
     * Extra initialization for custom reload of children.
     */
    protected void initCustomReloadChildren(FoldHierarchy hierarchy,
    int startOffset, int endOffset) {
        collapsedFoldIterator = FoldUtilities.collapsedFoldIterator(hierarchy, startOffset, endOffset);
        collapsedFold = nextCollapsedFold();
    }

    /**
     * Free any resources required for custom reload of children.
     */
    protected void finishCustomReloadChildren(FoldHierarchy hierarchy) {
        collapsedFoldIterator = null;
        collapsedFold = null;
    }

    protected @Override void customReloadChildren(int index, int removeLength, int startOffset, int endOffset) {
        // if removing all the views reset the flag
        if (index == 0 && removeLength == getViewCount()) {
            collapsedFoldsInPresentViews = false; // suppose there will be no folds in line views
        }

        FoldHierarchy hierarchy = getFoldHierarchy();
        // Assuming the document lock was already acquired
        if (hierarchy != null) {
            hierarchy.lock();
            try {
                initCustomReloadChildren(hierarchy, startOffset, endOffset);

                super.customReloadChildren(index, removeLength, startOffset, endOffset);

                finishCustomReloadChildren(hierarchy);

            } finally {
                hierarchy.unlock();
            }
        }
    }
        
    protected @Override View createCustomView(ViewFactory f,
    int startOffset, int maxEndOffset, int elementIndex) {
        if (elementIndex == -1) {


        Element elem = getElement();
        Element lineElem = elem.getElement(elementIndex);
        view = f.create(lineElem);

        if (createCollapsed) { // collapsedFold != null
            int lineElemEndOffset = lineElem.getEndOffset();
            createCollapsed = (collapsedFoldStartOffset < lineElemEndOffset);
            if (createCollapsed) { // need to find end of collapsed area
                Element firstLineElem = lineElem;
                List foldAndEndLineElemList = new ArrayList();

                while (true) {
                    int _collapsedFoldEndOffset = collapsedFold.getEndOffset();
                    // Find line element index of the line in which the collapsed fold ends
                    while (_collapsedFoldEndOffset > lineElemEndOffset) {
                        elementIndex++;
                        lineElem = elem.getElement(elementIndex);
                        lineElemEndOffset = lineElem.getEndOffset();
                    }

                    foldAndEndLineElemList.add(collapsedFold);
                    foldAndEndLineElemList.add(lineElem);

                    collapsedFold = nextCollapsedFold();

                    // No more collapsed or next collapsed does not start on current line
                    if (collapsedFold == null || collapsedFoldStartOffset >= lineElemEndOffset) {
                        break;
                    }
                }
                
                // Create the multi-line-view with collapsed fold(s)
                view = new FoldMultiLineView(firstLineElem, foldAndEndLineElemList);
            }
        }
        
        if (!createCollapsed) {
            view = f.create(lineElem);
        }
     
        return view;
    }            

    public void foldHierarchyChanged(FoldHierarchyEvent evt) {
        LockView lockView = LockView.get(this);
        lockView.lock();
        try {
            layoutLock();
            try {
                FoldHierarchy hierarchy = (FoldHierarchy)evt.getSource();
                if (hierarchy.getComponent().getDocument() != lockView.getDocument()) {
                    // Comonent already has a different document assigned
                    // so this view will be abandoned anyway => do not rebuild
                    // the current chilren because of this change
                    return;
                }

                boolean rebuildViews = true;
                int affectedStartOffset = evt.getAffectedStartOffset();
                int affectedEndOffset = evt.getAffectedEndOffset();

                // Check whether it is not a case when there were
                // no collapsed folds before and no collapsed folds now
                if (!collapsedFoldsInPresentViews) { // no collapsed folds previously
                    // TODO Could Integer.MAX_VALUE be used?
                    if (FoldUtilities.findCollapsedFold(hierarchy,
                        affectedStartOffset, affectedEndOffset) == null
                    ) { // no collapsed folds => no need to rebuild
                        rebuildViews = false;
                    }
                }

                if (rebuildViews) {
                    /**
                     * Check the affected offsets against the current document boundaries
                     */
                    int docLength = getDocument().getLength();
                    int rebuildStartOffset = Math.min(affectedStartOffset, docLength);
                    int rebuildEndOffset = Math.min(affectedEndOffset, docLength);
                    offsetRebuild(rebuildStartOffset, rebuildEndOffset);
                }
            } finally {
                updateLayout();
                layoutUnlock();
            }
        } finally {
            lockView.unlock();
        }
    }

    public @Override void paint(Graphics g, Shape allocation) {
        java.awt.Component c = getContainer();
        if (c instanceof javax.swing.text.JTextComponent){




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

import javax.swing.text.Element;
import org.netbeans.api.editor.fold.Fold;

/**
 *  Fake view of the whole document supporting the code folding, operating from given startOffset

        }
        
        @Override
        protected Fold nextCollapsedFold() {
            return null; // simulate no collapsed folds
        }
        
        @Override
        protected void attachListeners(){
        }
    





import java.util.ArrayList;
import java.util.List;
import javax.swing.text.BadLocationException;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
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;

/**

            //   begining of the first line
            int lastViewEndOffset = lineElem.getStartOffset();

            int cnt = foldAndEndLineElemList.size();
            List childViews = new ArrayList();
            for (int i = 0; i < cnt; i++) {
                Fold fold = (Fold)foldAndEndLineElemList.get(i);
                int foldStartOffset = fold.getStartOffset();
                int foldEndOffset = fold.getEndOffset();

                BaseDocument doc = (BaseDocument) lineElem.getDocument();
                try {
                    if (foldStartOffset > lastViewEndOffset) { // need to insert intra-line fragment
                        View lineView = f.create(lineElem); // normal line view
                        View intraFrag = lineView.createFragment(lastViewEndOffset, foldStartOffset);
                        childViews.add(intraFrag);
                        lastViewEndOffset = foldStartOffset;
                    }

                    // Create collapsed view
                    Position viewStartPos = doc.createPosition(foldStartOffset);
                    Position viewEndPos = doc.createPosition(foldEndOffset);
                    CollapsedView collapsedView = new CollapsedView(lineElem,
                        viewStartPos, viewEndPos, fold.getDescription());
                    childViews.add(collapsedView);
                    lastViewEndOffset = foldEndOffset;

                } catch (BadLocationException e) {
                    throw new IllegalStateException("Failed to create view boundary positions"); // NOI18N
                }

                // Fetch line element where the fold ends
                i++;
                lineElem = (Element)foldAndEndLineElemList.get(i);
                lineElemEndOffset = lineElem.getEndOffset();
            }

            // Append ending fragment if necessary
            // asserted non-empty list => foldEndOffset populated
            if (lastViewEndOffset < lineElemEndOffset) { // need ending fragment

Lines 1-7 Link Here

(-)a/editor.mimelookup/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.editor.mimelookup/1	2	OpenIDE-Module: org.netbeans.modules.editor.mimelookup/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/mimelookup/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/mimelookup/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.30	4	OpenIDE-Module-Specification-Version: 1.31
5	OpenIDE-Module-Recommends: org.netbeans.spi.editor.mimelookup.MimeDataProvider	5	OpenIDE-Module-Recommends: org.netbeans.spi.editor.mimelookup.MimeDataProvider
6	AutoUpdate-Essential-Module: true	6	AutoUpdate-Essential-Module: true
7		7




#Signature file v4.1
#Version 1.30

CLSS public abstract interface !annotation java.lang.Deprecated
 anno 0 java.lang.annotation.Documented()
 anno 0 java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy value=RUNTIME)
 anno 0 java.lang.annotation.Target(java.lang.annotation.ElementType[] value=[CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE])
intf java.lang.annotation.Annotation

CLSS public java.lang.Object

meth public abstract <%0 extends java.lang.Object> {%%0} lookup(java.lang.Class<{%%0}>)
meth public static org.openide.util.Lookup getDefault()
supr java.lang.Object
hfds LOG,defaultLookup
hcls DefLookup,Empty





        return true;
    }
    
    /**
     * Returns the inherited Mime type.
     * For {@link #EMPTY}, returns {@code null}. For most other mime types, returns
     * {@code ""}. If the mime type derives from another one, such as text/ant+xml derives
     * from xml, the return value will be the base mime type (text/xml in the example case).
     * <p/>
     * For MimePaths that identified embedded content (more components on the MimePath),
     * the method returns the parent MIME of the last MIME type on the path
     * 
     * @return inherited mime type, or {@code null}, if no parent exists (for {@link #EMPTY})
     */
    public String getInheritedType() {
        if ("".equals(mimeType)) {
            return null;
        }
        MimePath lastType = (size() == 1) ? this : MimePath.parse(mimeType);
        List<String> inheritedPaths = lastType.getInheritedPaths(null, null);
        if (inheritedPaths.size() > 1) {
            return inheritedPaths.get(1);
        } else {
            return null;
        }
    }
    
    
    /**
     * Returns the included Mime paths.
     * For MimePath, which nests several MIME types (i.e. text/php/text/html/text/css), it enumerates
     * sub-paths so that a following element represents one level of nesting of the content.
     * For the example example, the return would be:
     * <ol>
     * <li>text/php/text/html/text/css -- the full path
     * <li>text/html/text/css -- outer content is removed
     * <li>text/css -- the mime type of the identified content itself
     * <li> (empty string)
     * </ol>
     * <p/>
     * If a MIME type on the path has a generic MIME type (i.e. text/x-ant+xml 
     * has a generic MIME type text/xml), that generic type will be inserted. For example,
     * for text/java/text/x-ant+xml/text/javascript, the result will list:
     * <ol>
     * <li>text/java/text/x-ant+xml/text/javascript, -- the full MimePath
     * <li>text/x-ant+xml/text/javascript -- a prefix
     * <li>text/xml/text/javascript -- ant+xml is generalized to xml
     * <li>text/javascript
     * <li>  (empty string)
     * </ol>
     * For all but {@link #EMPTY} MimePaths, the list contains at least one entry, and the last
     * entry is the {@link #EMPTY}. Note also, that the complete MimePath is always returned
     * as the 1st member of the list.
     * <p/>
     * The returned sequence of MimePaths is suitable for searching settings or services
     * for the (embedded) content whose type is described by MimePath as it is ordered from the
     * most specific to the least specific paths (including generalization) and always contains
     * the mime type of the identified contents. The last component ({@link ""}) represents 
     * default settings (services).
     * <p/>
     * Note that for MimePaths created from a mime type (not empty!) string, the 
     * <code>getInheritedPaths().get(1)</code> is a parent mime type. Either empty,
     * or the generalized MIME.
     * <p/>
     * The caller should not modify the returned List.
     * 
     * @return list of inherited Mime paths
     */
    public List<MimePath> getIncludedPaths() {
        List<String> paths = getInheritedPaths(null, null);
        List<MimePath> mpaths = new ArrayList<MimePath>(paths.size());
        for (String p : paths) {
            mpaths.add(MimePath.parse(p));
        }
        return mpaths;
    }
    
    // XXX: This is currently called from editor/settings/storage (SettingsProvider)
    // and editor/mimelookup/impl via reflection.
    // We will eventually make it friend API. In the meantime just




        // See also http://www.netbeans.org/issues/show_bug.cgi?id=118099

        // Add lookups from deprecated MimeLookupInitializers
        List<MimePath> paths = mimePath.getIncludedPaths();
        for(MimePath mp : paths) {
            Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
            m.setAccessible(true);
            @SuppressWarnings("unchecked")
            List<String> ret = (List<String>) m.invoke(mimePath, null, null);
            paths = ret;
        } catch (Exception e) {
            LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
            paths = Collections.singletonList(mimePath.getPath());
        }

        for(String path : paths) {
            MimePath mp = MimePath.parse(path);
            Collection<? extends MimeLookupInitializer> initializers = mimeInitializers.allInstances();

            for(int i = 0; i < mp.size(); i++) {


            for(MimeLookupInitializer mli : initializers) {
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("- Querying MimeLookupInitializer(" + mp.getPath() + "): " + mli); //NOI18N
                }
                Lookup mimePathLookup = mli.lookup();
                if (mimePathLookup != null) {

Lines 84-89 Link Here

(-)a/editor.mimelookup/test/unit/src/org/netbeans/api/editor/mimelookup/MimePathTest.java (+2 lines)
84	MimePath mpPrefix = mp.getPrefix(2);	84	MimePath mpPrefix = mp.getPrefix(2);
85	assertTrue("text/x-java/text/x-ant+xml".equals(mpPrefix.getPath()));	85	assertTrue("text/x-java/text/x-ant+xml".equals(mpPrefix.getPath()));
86		86
		87	List<String> ll = mp.getInheritedPaths(null, null);
		88
87	// Force exceed size of the internal LRU cache and release the created and cached MPs	89	// Force exceed size of the internal LRU cache and release the created and cached MPs
88	for (int op = 0; op < 2; op++) {	90	for (int op = 0; op < 2; op++) {
89	for (int i = 0; i < 10; i++) {	91	for (int i = 0; i < 10; i++) {

Lines 2-7 Link Here

(-)a/editor.settings.storage/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.editor.settings.storage/1	2	OpenIDE-Module: org.netbeans.modules.editor.settings.storage/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/settings/storage/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/settings/storage/Bundle.properties
4	OpenIDE-Module-Provides: org.netbeans.api.editor.settings.implementation	4	OpenIDE-Module-Provides: org.netbeans.api.editor.settings.implementation
5	OpenIDE-Module-Specification-Version: 1.37	5	OpenIDE-Module-Specification-Version: 1.38
6	OpenIDE-Module-Layer: org/netbeans/modules/editor/settings/storage/layer.xml	6	OpenIDE-Module-Layer: org/netbeans/modules/editor/settings/storage/layer.xml
7	AutoUpdate-Show-In-Client: false	7	AutoUpdate-Show-In-Client: false

Lines 55-61 Link Here

(-)a/editor.settings.storage/nbproject/project.xml (-1 / +2 lines)
55	<compile-dependency/>	55	<compile-dependency/>
56	<run-dependency>	56	<run-dependency>
57	<release-version>1</release-version>	57	<release-version>1</release-version>
58	<specification-version>1.0</specification-version>	58	<specification-version>1.31</specification-version>
59	</run-dependency>	59	</run-dependency>
60	</dependency>	60	</dependency>
61	<dependency>	61	<dependency>
Lines 176-181 Link Here
176	<friend>org.netbeans.modules.jvi</friend>	176	<friend>org.netbeans.modules.jvi</friend>
177	<friend>org.netbeans.modules.languages</friend>	177	<friend>org.netbeans.modules.languages</friend>
178	<friend>org.netbeans.modules.options.editor</friend>	178	<friend>org.netbeans.modules.options.editor</friend>
		179	<friend>org.netbeans.modules.editor.fold</friend>
179	<friend>org.netbeans.modules.parsing.api</friend>	180	<friend>org.netbeans.modules.parsing.api</friend>
180	<package>org.netbeans.modules.editor.settings.storage.api</package>	181	<package>org.netbeans.modules.editor.settings.storage.api</package>
181	<package>org.netbeans.modules.editor.settings.storage.spi</package>	182	<package>org.netbeans.modules.editor.settings.storage.spi</package>




import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.prefs.Preferences;
import javax.swing.text.AttributeSet;
import org.netbeans.modules.editor.settings.storage.EditorSettingsImpl;
import org.netbeans.modules.editor.settings.storage.MimeTypesTracker;

        String propertyName,
        PropertyChangeListener l
    );

    /**
     * Provides a temporary storage for Preferences, which can be
     * flushed to the delegate.
     * The returned object collects changes made through the {@link Preferences}
     * interface, but does not write them to the 'delegate' instance immediately.
     * It writes the changes (adds new keys, changes existing ones, removes the
     * obsolete keys) during {@link Preferences#flush}.
     * <p/>
     * The token controls the lifecycle of the Preferences tree. If left unattended,
     * it will be destroyed when the 'token' object becomes GCed. Each token instance 
     * has its own full Preferences tree.
     * 
     * @param token token to control lifecycle and separate instances
     * @param delegate the backing Preferences
     * @return Preferences with temporary storage.
     */
    // public abstract MemoryPreferences getProxyPreferences(Object token, Preferences delegate);
}




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

import java.util.prefs.Preferences;
import org.netbeans.modules.editor.settings.storage.preferences.InheritedPreferences;
import org.netbeans.modules.editor.settings.storage.preferences.ProxyPreferencesImpl;

/**
 * Preferences with a temporary storage, backed by another Preferences
 * object. The instance tracks modifications done through the
 * {@link Preferences} interface, but do not change the backing store
 * until {@link Preferences#flush} is called.
 * <p/>
 * The MemoryPreferences object serves as an accessor, and offers some
 * additional control for the Preferences tree. It should not be handed
 * away, only the creator who manages the lifecycle should possess
 * the MemoryPreferences instance. Other clients should be given just the
 * Preferences object from {@link #getPreferences}.
 * <p/>
 * The returned Preferences object implements {@link LocalPreferences} extension
 * interface.
 * <p/>
 * This implementation <b>does not support</b> sub-nodes.
 * 
 * @author sdedic
 * @author Vita Stejskal
 */
public final class MemoryPreferences  {
    /**
     * Returns an instance of Preferences backed by the delegate.
     * A token is used to identify the desired Preferences set. As long as {@link #destroy} is not called,
     * calls which use the same token & delegate will receive the same Preferences objects (though their
     * MemoryPreferences may differ). The returned object implements {@link LocalPreferences}
     * interface.
     * 
     * @param token token that determines the tree of Preferences.
     * @param delegate
     * @return MemoryPreferences accessor instance
     */
    public static MemoryPreferences get(Object token, Preferences delegate) {
        return new MemoryPreferences(ProxyPreferencesImpl.getProxyPreferences(token, delegate));
    }

    /**
     * Creates Preferences, which delegates to both persistent storage and parent (inherited) preferences.
     * The persistent storage takes precedence over the parent. The {@link Preferences#remove} call is redefined
     * for this case to just remove the key-value from the 'delegate', so that 'parent' value (if any) can become
     * effective. Before {@link Preferences#flush}, the returned Preferences object delegates to both 'parent'
     * and 'delegate' so that effective values can be seen. The returned object implements {@link LocalPreferences}
     * interface.
     * 
     * @param token 
     * @param parent
     * @param delegate
     * @return 
     */
    public static MemoryPreferences getWithInherited(Object token, Preferences parent, Preferences delegate) {
        if (parent == null) {
            return get(token, delegate);
        }
        InheritedPreferences inh = new InheritedPreferences(parent, delegate);
        return new MemoryPreferences(ProxyPreferencesImpl.getProxyPreferences(token, inh));
    }
    
    /**
     * Provides the Preferences instance.
     * The instance will collect writes in memory, as described in {@link MemoryPreferences} doc.
     * 
     * @return instance of Preferences
     */
    public Preferences  getPreferences() {
        return prefInstance;
    }
    
    /**
     * Destroys the whole tree this Preferences belongs to.
     * Individual Preferences node will not be flushed or cleared, but will become
     * inaccessible from their token
     * 
     * @see {@link EditorSettings#getProxyPreferences}
     */
    public void destroy() {
        prefInstance.destroy();
    }
    
    /**
     * Suppresses events from this Preferences node.
     * During the Runnable execution, the Preferences node will not
     * fire any events.
     * 
     * @param r runnable to execute
     */
    public void runWithoutEvents(Runnable r) {
        try {
            prefInstance.silence();
            r.run();
        } finally {
            prefInstance.noise();
        }
    }
    
    /**
     * Checks whether the Preferences node is changed. 
     * Only value provided by the {@link #getPreferences} and values derived by call to {@link Preferences#node}
     * on that instance are supported. In other words, Preferences object from the tree managed by this
     * MemoryPreferences object. IllegalArgumentException can be thrown when an incompatible Preferences object
     * is used.
     * <p/>
     * True will be returned, if the Preferences object is dirty and not flushed.
     * 
     * @param pref preferences node to check
     * @return true, if the preferences was modified, and not flushed
     * @throws IllegalArgumentException if the pref node is not from the managed tree.
     */
    public boolean isDirty(Preferences pref) {
        if (!(pref instanceof ProxyPreferencesImpl)) {
            throw new IllegalArgumentException("Incompatible PreferencesImpl");
        }
        ProxyPreferencesImpl impl = (ProxyPreferencesImpl)pref;
        if (impl.node(prefInstance.absolutePath()) != prefInstance) {
            throw new IllegalArgumentException("The preferences tree root is not reachable");
        }
        return impl.isDirty();
    }

    private ProxyPreferencesImpl prefInstance;
    
    private MemoryPreferences(ProxyPreferencesImpl delegate) {
        this.prefInstance = delegate;
    }
}




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

/**
 * Mixin interface to detect if a value is inherited (defaulted) or not.
 * The interface is to be implemented on Preferences objects (e.g. Mime Preferences),
 * which support some sort of fallback, inheritance or default. It allows
 * clients to determine whether a preference key is defined at the level represented
 * by the Preferences object, or whether the value produced by {@link java.util.prefs.Preferences#get}
 * originates in some form of default or inherited values.
 *
 * @author sdedic
 */
public interface OverridePreferences {
    /**
     * Determines whether the value is defined locally.
     * If the value comes from an inherited or default set of values,
     * the method returns {@code false}.
     * 
     * @param key key to check
     * @return true, if the value is defined locally, false if inherited.
     */
    public boolean      isOverriden(String key);
}




            mimePath = mimePath.getPrefix(mimePath.size() - 1);
        }

        List<MimePath> allPaths = mimePath.getIncludedPaths();
        assert allPaths.size() > 0 : "allPaths should always contain at least MimePath.EMPTY"; //NOI18N

        this.allFcsi = new FontColorSettingsImpl[allPaths.size()];
        for (int i = 0; i < allPaths.size(); i++) {
            allFcsi[i] = FontColorSettingsImpl.get(allPaths.get(i));
        }

        this.profile = profile;

        System.out.println(sb.toString());
    }

    private static MimePath[] computeInheritedMimePaths(MimePath mimePath) {
        List<String> paths = null;
        try {
            Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
            m.setAccessible(true);
            @SuppressWarnings("unchecked")
            List<String> ret = (List<String>) m.invoke(mimePath, null, null);
            paths = ret;
        } catch (Exception e) {
            LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
        }

        if (paths != null) {
            ArrayList<MimePath> mimePaths = new ArrayList<MimePath>(paths.size());

            for (String path : paths) {
                mimePaths.add(MimePath.parse(path));
            }

            return mimePaths.toArray(new MimePath[mimePaths.size()]);
        } else {
            return new MimePath[]{mimePath, MimePath.EMPTY};
        }
    }

    private Map<?, ?> getRenderingHints() {
        // This property was introduced in JDK1.6, see http://java.sun.com/javase/6/docs/api/java/awt/doc-files/DesktopProperties.html
        // We should probably also listen on the default toolkit for changes in this




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

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.prefs.AbstractPreferences;
import java.util.prefs.BackingStoreException;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;

/**
 * Support for inheriting Preferences, while still working with stored ones.
 * 
 * This class solves the 'diamond inheritance', which is present during editing:
 * a MIME-type preferences derive from BOTH its persistent values (preferred) and
 * from the parent, whose actual values are potentially transient, and also persistent.
 * <p/>
 * Let us assume the following assignment:
 * <ul>
 * <li>TC (this current) = currently added/changed/removed values
 * <li>TP (this persistent) = persistent values, the getLocal() part of the Mime PreferencesImpl object
 * <li>PC (parent current) = currently added/changed/removed values of the parent
 * <li>PP (parent persistent) = persistent values, the getLocal() part of the parent MimePreferences
 * </ul>
 * The desired priority to find a value is: TC, TP, PC, PP. Because of {@link MemoryPreferences}, the
 * PC, PP (and potentially fallback to a grandparent) we already have, if we use the parent's {@link MemoryPreferences}
 * preferences as 'inherited'. The "TC" is handled by ProxyPreferences for this Mime node. In InheritedPreferences,
 * we must only inject the TP in between TC and the parent's preferences (PC, PP, ...)
 * <p/>
 * The object is intended to act as a ProxyPreferences delegate, all writes go directly to the stored
 * Mime preferences.
 * 
 * @author sdedic
 */
public final class InheritedPreferences extends AbstractPreferences implements PreferenceChangeListener, OverridePreferences  {
    /**
     * Preferences inherited, ie from a parent Mime type
     */
    private Preferences inherited;
    
    /**
     * Stored preferences, 
     */
    private Preferences stored;
    
    public InheritedPreferences(Preferences inherited, Preferences stored) {
        super(null, ""); // NOI18N
        this.inherited = inherited;
        if (!(stored instanceof OverridePreferences)) {
            throw new IllegalArgumentException();
        }
        this.stored = stored;
        
        inherited.addPreferenceChangeListener(this);
    }

    /* package */ Preferences getParent() {
        return inherited;
    }

    @Override
    protected void putSpi(String key, String value) {
        // do nothing, the AbstractPref then just fires an event
    }

    @Override
    public void put(String key, String value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.put(key, value);
        }
        super.put(key, value);
    }

    @Override
    public void putInt(String key, int value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putInt(key, value);
        }
        super.putInt(key, value); 
    }

    @Override
    public void putLong(String key, long value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putLong(key, value);
        }
        super.putLong(key, value);
    }

    @Override
    public void putBoolean(String key, boolean value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putBoolean(key, value);
        }
        super.putBoolean(key, value);
    }

    @Override
    public void putFloat(String key, float value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putFloat(key, value);
        }
        super.putFloat(key, value); 
    }

    @Override
    public void putDouble(String key, double value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putDouble(key, value);
        }
        super.putDouble(key, value); 
    }

    @Override
    public void putByteArray(String key, byte[] value) {
        if (Boolean.TRUE != ignorePut.get()) {
            stored.putByteArray(key, value);
        }
        super.putByteArray(key, value);
    }
    
    private ThreadLocal<Boolean> ignorePut = new ThreadLocal<Boolean>();

    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        if (!isOverriden(evt.getKey())) {
            // jusr refires an event
            ignorePut.set(true);
            try {
                put(evt.getKey(), evt.getNewValue());
            } finally {
                ignorePut.set(false);
            }
        }
    }
    
    /**
     * The value is defined locally, if the stored prefs define the value
     * locally. The parent definitions do not count. It is expected, that the
     * ProxyPreferences will report its local overrides as local in front of this
     * InheritedPreferences.
     * 
     * @param k
     * @return 
     */
    public @Override boolean isOverriden(String k) {
        if (stored instanceof OverridePreferences) {
            return ((OverridePreferences)stored).isOverriden(k);
        } else {
            return true;
        }
    }
    
    @Override
    protected String getSpi(String key) {
        // check the stored values
        OverridePreferences localStored = (OverridePreferences)stored;
        if (localStored.isOverriden(key)) {
            return stored.get(key, null);
        }
        // fall back to the inherited prefs, potentially its stored values etc.
        return inherited.get(key, null);
    }

    @Override
    protected void removeSpi(String key) {
        stored.remove(key);
    }

    @Override
    protected void removeNodeSpi() throws BackingStoreException {
        stored.removeNode();
    }

    @Override
    protected String[] keysSpi() throws BackingStoreException {
        Collection<String> names = new HashSet<String>();
        names.addAll(Arrays.asList(stored.keys()));
        names.addAll(Arrays.asList(inherited.keys()));
        return names.toArray(new String[names.size()]);
    }

    @Override
    protected String[] childrenNamesSpi() throws BackingStoreException {
        if (stored != null) {
            return stored.childrenNames();
        } else {
            return new String[0];
        }
    }

    @Override
    protected AbstractPreferences childSpi(String name) {
        Preferences storedNode = stored != null ? stored.node(name) : null;
        if (storedNode != null) {
            return new InheritedPreferences(null, storedNode);
        } else {
            return null;
        }
    }

    @Override
    protected void syncSpi() throws BackingStoreException {
        stored.sync();
    }

    @Override
    protected void flushSpi() throws BackingStoreException {
        stored.flush();
    }
    
    
}




import java.util.prefs.Preferences;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.modules.editor.settings.storage.api.EditorSettingsStorage;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;
import org.netbeans.modules.editor.settings.storage.spi.TypedValue;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;

 *
 * @author vita
 */
public final class PreferencesImpl extends AbstractPreferences implements PreferenceChangeListener, OverridePreferences {

    // the constant bellow is used in o.n.e.Settings!!
    private static final String JAVATYPE_KEY_PREFIX = "nbeditor-javaType-for-legacy-setting_"; //NOI18N

            }
        }
    }
    
    public @Override boolean isOverriden(String key) {
        synchronized (lock) {
            String bareKey;
            if (key.startsWith(JAVATYPE_KEY_PREFIX)) {
                bareKey = key.substring(JAVATYPE_KEY_PREFIX.length());
            } else {
                bareKey = key;
            }
            return getLocal().containsKey(bareKey);
        }
    }

    public @Override void remove(String key) {
        synchronized(lock) {

    
    private Preferences getInherited() {
        if (inherited == null && mimePath.length() > 0) {
            String type = MimePath.parse(mimePath).getInheritedType();
            if (type != null) {
                inherited = get(MimePath.parse(type));
                m.setAccessible(true);
                @SuppressWarnings("unchecked")
                List<String> ret = (List<String>) m.invoke(MimePath.parse(mimePath), null, null);
                paths = ret;
            } catch (Exception e) {
                LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
            }
            
            if (paths != null) {
                assert paths.size() > 1 : "Wrong getInheritedPaths result size: " + paths.size(); //NOI18N
                inherited = get(MimePath.parse(paths.get(1)));
            } else {
                inherited = get(MimePath.EMPTY);
            }




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

package org.netbeans.modules.editor.settings.storage.preferences;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.BackingStoreException;
import java.util.prefs.NodeChangeEvent;
import java.util.prefs.NodeChangeListener;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import javax.xml.bind.DatatypeConverter;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;
import org.netbeans.modules.editor.settings.storage.spi.TypedValue;
import org.openide.util.WeakListeners;

/**
 * Preferences impl that stores changes locally, and propagates them upon flush().
 * The implementation is an adapted (former) implementation from org.netbeans.modules.options.indentation.ProxyPreferences.
 * The original was moved here, and adapted to work with 'diamond' double defaulting: 1st default is
 * the persistent Preferences object, where the changes will be finally propagated. The 2nd default
 * is the Preferences object for the MIMEtype parent (if it exists). Keys that do not exist
 * in the stored Preferences should delegate to the MIME parent. During editing, the MIME parent Preferences
 * may get also changed, so we cannot rely on delegation between stored Mime Preferences, but must
 * inject an additional path - see {@link InheritedPreferences}.
 *
 * @author sdedic
 * @author vita
 */
public final class ProxyPreferencesImpl extends Preferences implements PreferenceChangeListener, NodeChangeListener, 
        OverridePreferences {

    /**
     * Inherited preferences, for the case that key does not exist at our Node.
     * Special handling for diamond inheritance. 
     */
    private Preferences inheritedPrefs;
    
    public static ProxyPreferencesImpl getProxyPreferences(Object token, Preferences delegate) {
        return Tree.getTree(token, delegate).get(null, delegate.name(), delegate); //NOI18N
    }
    
    public boolean isDirty() {
        synchronized (tree.treeLock()) {
            return !(data.isEmpty() && removedKeys.isEmpty() && children.isEmpty() && removedChildren.isEmpty()) || removed;
        }
    }

    @Override
    public void put(String key, String value) {
        _put(key, value, String.class.getName());
    }

    @Override
    public String get(String key, String def) {
        synchronized (tree.treeLock()) {
            checkNotNull(key, "key"); //NOI18N
            checkRemoved();
            
            if (removedKeys.contains(key)) {
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Key '" + key + "' removed, using default '" + def + "'"); //NOI18N
                }
                // removes will be flushed to the preferences, but now we need to see the defaults
                // that WILL become effective after flush of this object.
                if (inheritedPrefs != null) {
                    return inheritedPrefs.get(key, def);
                } else {
                    return def;
                }
            } else {
                TypedValue typedValue = data.get(key);
                if (typedValue != null) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Key '" + key + "' modified, local value '" + typedValue.getValue() + "'"); //NOI18N
                    }
                    return typedValue.getValue();
                } else if (delegate != null) {
                    String value = delegate.get(key, def);
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Key '" + key + "' undefined, original value '" + value + "'"); //NOI18N
                    }
                    return value;
                } else {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Key '" + key + "' undefined, '" + name + "' is a new node, using default '" + def + "'"); //NOI18N
                    }
                    return def;
                }
            }
        }
    }

    @Override
    public void remove(String key) {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = null;
        
        synchronized (tree.treeLock()) {
            checkNotNull(key, "key"); //NOI18N
            checkRemoved();
            
            if (removedKeys.add(key)) {
                data.remove(key);
                bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
                bag.addListeners(prefListeners);
                if (inheritedPrefs != null) {
                    bag.addEvent(new PreferenceChangeEvent(this, key, 
                            inheritedPrefs.get(key, null)));
                } else {
                    bag.addEvent(new PreferenceChangeEvent(this, key, null));
                }
            }
        }

        if (bag != null) {
            firePrefEvents(Collections.singletonList(bag));
        }
    }

    @Override
    public void clear() throws BackingStoreException {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
        
        synchronized (tree.treeLock()) {
            checkRemoved();

            // Determine modified or added keys
            Set<String> keys = new HashSet<String>();
            keys.addAll(data.keySet());
            keys.removeAll(removedKeys);
            if (!keys.isEmpty()) {
                for(String key : keys) {
                    String value = delegate == null ? null : delegate.get(key, null);
                    bag.addEvent(new PreferenceChangeEvent(this, key, value));
                }
            }

            // Determine removed keys
            if (delegate != null) {
                for(String key : removedKeys) {
                    String value = delegate.get(key, null);
                    if (value != null) {
                        bag.addEvent(new PreferenceChangeEvent(this, key, value));
                    }
                }
            }

            // Initialize bag's listeners
            bag.addListeners(prefListeners);

            // Finally, remove the data
            data.clear();
            removedKeys.clear();
        }
        
        firePrefEvents(Collections.singletonList(bag));
    }

    @Override
    public void putInt(String key, int value) {
        _put(key, Integer.toString(value), Integer.class.getName());
    }

    @Override
    public int getInt(String key, int def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Integer.parseInt(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putLong(String key, long value) {
        _put(key, Long.toString(value), Long.class.getName());
    }

    @Override
    public long getLong(String key, long def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Long.parseLong(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putBoolean(String key, boolean value) {
        _put(key, Boolean.toString(value), Boolean.class.getName());
    }

    @Override
    public boolean getBoolean(String key, boolean def) {
        String value = get(key, null);
        if (value != null) {
            return Boolean.parseBoolean(value);
        } else {
            return def;
        }
    }

    @Override
    public void putFloat(String key, float value) {
        _put(key, Float.toString(value), Float.class.getName());
    }

    @Override
    public float getFloat(String key, float def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Float.parseFloat(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putDouble(String key, double value) {
        _put(key, Double.toString(value), Double.class.getName());
    }

    @Override
    public double getDouble(String key, double def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Double.parseDouble(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putByteArray(String key, byte[] value) {
        _put(key, DatatypeConverter.printBase64Binary(value), value.getClass().getName());
    }

    @Override
    public byte[] getByteArray(String key, byte[] def) {
        String value = get(key, null);
        if (value != null) {
            byte [] decoded = DatatypeConverter.parseBase64Binary(value);
            if (decoded != null) {
                return decoded;
            }
        }
        return def;
    }

    @Override
    public String[] keys() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            checkRemoved();
            HashSet<String> keys = new HashSet<String>();
            if (delegate != null) {
                keys.addAll(Arrays.asList(delegate.keys()));
            }
            keys.addAll(data.keySet());
            keys.removeAll(removedKeys);
            return keys.toArray(new String [keys.size()]);
        }
    }

    @Override
    public String[] childrenNames() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            checkRemoved();
            HashSet<String> names = new HashSet<String>();
            if (delegate != null) {
                names.addAll(Arrays.asList(delegate.childrenNames()));
            }
            names.addAll(children.keySet());
            names.removeAll(removedChildren);
            return names.toArray(new String [names.size()]);
        }
    }

    @Override
    public Preferences parent() {
        synchronized (tree.treeLock()) {
            checkRemoved();
            return parent;
        }
    }

    @Override
    public Preferences node(String pathName) {
        Preferences node;
        LinkedList<EventBag<NodeChangeListener, NodeChangeEvent>> events = new LinkedList<EventBag<NodeChangeListener, NodeChangeEvent>>();

        synchronized (tree.treeLock()) {
            checkNotNull(pathName, "pathName"); //NOI18N
            checkRemoved();
            node = node(pathName, true, events);
        }

        fireNodeEvents(events);
        return node;
    }

    @Override
    public boolean nodeExists(String pathName) throws BackingStoreException {
        synchronized (tree.treeLock()) {
            if (pathName.length() == 0) {
                return !removed;
            } else {
                checkRemoved();
                return node(pathName, false, null) != null;
            }
        }
    }

    @Override
    public void removeNode() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            checkRemoved();
            ProxyPreferencesImpl p = parent;
            if (p != null) {
                p.removeChild(this);
            } else {
                throw new UnsupportedOperationException("Can't remove the root."); //NOI18N
            }
        }
    }

    @Override
    public String name() {
        return name;
    }

    @Override
    public String absolutePath() {
        synchronized (tree.treeLock()) {
            ProxyPreferencesImpl pp = parent;
            if (pp != null) {
                if (pp.parent == null) {
                    // pp is the root, we don't want two consecutive slashes in the path
                    return "/" + name(); //NOI18N
                } else {
                    return pp.absolutePath() + "/" + name(); //NOI18N
                }
            } else {
                return "/"; //NOI18N
            }
        }
    }

    @Override
    public boolean isUserNode() {
        synchronized (tree.treeLock()) {
            if (delegate != null) {
                return delegate.isUserNode();
            } else {
                ProxyPreferencesImpl pp = parent;
                if (pp != null) {
                    return pp.isUserNode();
                } else {
                    return true;
                }
            }
        }
    }

    @Override
    public String toString() {
        return (isUserNode() ? "User" : "System") + " Preference Node: " + absolutePath(); //NOI18N
    }

    @Override
    public void flush() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Flushing " + absolutePath());
            }

            checkRemoved();
            for(ProxyPreferencesImpl pp : children.values()) {
                pp.flush();
            }

            if (delegate == null) {
                ProxyPreferencesImpl proxyRoot = parent.node("/", false, null); //NOI18N
                assert proxyRoot != null : "Root must always exist"; //NOI18N

                Preferences delegateRoot = proxyRoot.delegate;
                assert delegateRoot != null : "Root must always have its corresponding delegate"; //NOI18N

                Preferences nueDelegate = delegateRoot.node(absolutePath());
                changeDelegate(nueDelegate);
            }

            delegate.removeNodeChangeListener(weakNodeListener);
            delegate.removePreferenceChangeListener(weakPrefListener);
            try {
                // remove all removed children
                for(String childName : removedChildren) {
                    if (delegate.nodeExists(childName)) {
                        delegate.node(childName).removeNode();
                    }
                }

                // write all valid key-value pairs
                for(String key : data.keySet()) {
                    if (!removedKeys.contains(key)) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("Writing " + absolutePath() + "/" + key + "=" + data.get(key));
                        }
                        
                        TypedValue typedValue = data.get(key);
                        if (String.class.getName().equals(typedValue.getJavaType())) {
                            delegate.put(key, typedValue.getValue());

                        } else if (Integer.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putInt(key, Integer.parseInt(typedValue.getValue()));

                        } else if (Long.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putLong(key, Long.parseLong(typedValue.getValue()));

                        } else if (Boolean.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putBoolean(key, Boolean.parseBoolean(typedValue.getValue()));

                        } else if (Float.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putFloat(key, Float.parseFloat(typedValue.getValue()));

                        } else if (Double.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putDouble(key, Double.parseDouble(typedValue.getValue()));

                        } else {
                            delegate.putByteArray(key, DatatypeConverter.parseBase64Binary(typedValue.getValue()));
                        }
                    }
                }
                data.clear();

                // remove all removed keys
                for(String key : removedKeys) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Removing " + absolutePath() + "/" + key);
                    }
                    delegate.remove(key);
                }
                removedKeys.clear();
            } finally {
                delegate.addNodeChangeListener(weakNodeListener);
                delegate.addPreferenceChangeListener(weakPrefListener);
            }
        }        
    }

    @Override
    public void sync() throws BackingStoreException {
        ArrayList<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> prefEvents = new ArrayList<EventBag<PreferenceChangeListener, PreferenceChangeEvent>>();
        ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>> nodeEvents = new ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>>();

        synchronized (tree.treeLock()) {
            _sync(prefEvents, nodeEvents);
        }

        fireNodeEvents(nodeEvents);
        firePrefEvents(prefEvents);
    }

    @Override
    public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
        synchronized (tree.treeLock()) {
            prefListeners.add(pcl);
        }
    }

    @Override
    public void removePreferenceChangeListener(PreferenceChangeListener pcl) {
        synchronized (tree.treeLock()) {
            prefListeners.remove(pcl);
        }
    }

    @Override
    public void addNodeChangeListener(NodeChangeListener ncl) {
        synchronized (tree.treeLock()) {
            nodeListeners.add(ncl);
        }
    }

    @Override
    public void removeNodeChangeListener(NodeChangeListener ncl) {
        synchronized (tree.treeLock()) {
            nodeListeners.remove(ncl);
        }
    }

    @Override
    public void exportNode(OutputStream os) throws IOException, BackingStoreException {
        throw new UnsupportedOperationException("exportNode not supported");
    }

    @Override
    public void exportSubtree(OutputStream os) throws IOException, BackingStoreException {
        throw new UnsupportedOperationException("exportSubtree not supported");
    }

    // ------------------------------------------------------------------------
    // PreferenceChangeListener implementation
    // ------------------------------------------------------------------------

    public void preferenceChange(PreferenceChangeEvent evt) {
        PreferenceChangeListener [] listeners;
        String nValue = evt.getNewValue();
        String k = evt.getKey();
        synchronized (tree.treeLock()) {
            if (removed || data.containsKey(k)) {
                return;
            }
            if (removedKeys.contains(k)) {
                if (inheritedPrefs == null) {
                    return;
                } else {
                    // if removed && there are inherited preferences, we must report the 'new value'
                    // from the inherited prefs, as the override in our preferences is not in effect now.
                    nValue = inheritedPrefs.get(k, null);
                }
            }
            listeners = prefListeners.toArray(new PreferenceChangeListener[prefListeners.size()]);
        }

        PreferenceChangeEvent myEvt = null;
        for(PreferenceChangeListener l : listeners) {
            if (myEvt == null) {
                myEvt = new PreferenceChangeEvent(this, k, nValue);
            }
            l.preferenceChange(myEvt);
        }
    }

    // ------------------------------------------------------------------------
    // NodeChangeListener implementation
    // ------------------------------------------------------------------------

    public void childAdded(NodeChangeEvent evt) {
        NodeChangeListener [] listeners;
        Preferences childNode;

        synchronized (tree.treeLock()) {
            String childName = evt.getChild().name();
            if (removed || removedChildren.contains(childName)) {
                return;
            }

            childNode = children.get(childName);
            if (childNode != null) {
                // swap delegates
                ((ProxyPreferencesImpl) childNode).changeDelegate(evt.getChild());
            } else {
                childNode = node(evt.getChild().name());
            }
            
            listeners = nodeListeners.toArray(new NodeChangeListener[nodeListeners.size()]);
        }

        NodeChangeEvent myEvt = null;
        for(NodeChangeListener l : listeners) {
            if (myEvt == null) {
                myEvt = new NodeChangeEvent(this, childNode);
            }
            l.childAdded(evt);
        }
    }

    public void childRemoved(NodeChangeEvent evt) {
        NodeChangeListener [] listeners;
        Preferences childNode;

        synchronized (tree.treeLock()) {
            String childName = evt.getChild().name();
            if (removed || removedChildren.contains(childName)) {
                return;
            }

            childNode = children.get(childName);
            if (childNode != null) {
                // swap delegates
                ((ProxyPreferencesImpl) childNode).changeDelegate(null);
            } else {
                // nobody has accessed the child yet
                return;
            }
            
            listeners = nodeListeners.toArray(new NodeChangeListener[nodeListeners.size()]);
        }

        NodeChangeEvent myEvt = null;
        for(NodeChangeListener l : listeners) {
            if (myEvt == null) {
                myEvt = new NodeChangeEvent(this, childNode);
            }
            l.childAdded(evt);
        }
    }
    
    // ------------------------------------------------------------------------
    // Other public implementation
    // ------------------------------------------------------------------------

    /**
     * Destroys whole preferences tree as if called on the root.
     */
    public void destroy() {
        synchronized (tree.treeLock()) {
            tree.destroy();
        }
    }
    
    public void silence() {
        synchronized (tree.treeLock()) {
            noEvents = true;
        }
    }
    
    public void noise() {
        synchronized (tree.treeLock()) {
            noEvents = false;
        }
    }

    @Override
    public boolean isOverriden(String key) {
        return data.containsKey(key);
    }
    
    // ------------------------------------------------------------------------
    // private implementation
    // ------------------------------------------------------------------------

    private static final Logger LOG = Logger.getLogger(ProxyPreferencesImpl.class.getName());
    
    private final ProxyPreferencesImpl parent;
    private final String name;
    private Preferences delegate;
    private final Tree tree;
    private boolean removed;
    
    private final Map<String, TypedValue> data = new HashMap<String, TypedValue>();
    private final Set<String> removedKeys = new HashSet<String>();
    private final Map<String, ProxyPreferencesImpl> children = new HashMap<String, ProxyPreferencesImpl>();
    private final Set<String> removedChildren = new HashSet<String>();

    private boolean noEvents = false;
    private PreferenceChangeListener weakPrefListener;
    private final Set<PreferenceChangeListener> prefListeners = new HashSet<PreferenceChangeListener>();
    private NodeChangeListener weakNodeListener;
    private final Set<NodeChangeListener> nodeListeners = new HashSet<NodeChangeListener>();

    private ProxyPreferencesImpl(ProxyPreferencesImpl parent, String name, Preferences delegate, Tree tree) {
        assert name != null;
        
        this.parent = parent;
        this.name = name;
        this.delegate = delegate;
        if (delegate instanceof InheritedPreferences) {
            this.inheritedPrefs = ((InheritedPreferences)delegate).getParent();
        }
        if (delegate != null) {
            assert name.equals(delegate.name());

            weakPrefListener = WeakListeners.create(PreferenceChangeListener.class, this, delegate);
            delegate.addPreferenceChangeListener(weakPrefListener);
            
            weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
            delegate.addNodeChangeListener(weakNodeListener);
        }
        this.tree = tree;
    }

    private void _put(String key, String value, String javaType) {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = null;

        synchronized (tree.treeLock()) {
            checkNotNull(key, "key"); //NOI18N
            checkNotNull(value, "value"); //NOI18N
            checkRemoved();
            
            String orig = get(key, null);
            if (orig == null || !orig.equals(value)) {
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Overwriting '" + key + "' = '" + value + "'"); //NOI18N
                }
                
                data.put(key, new TypedValue(value, javaType));
                removedKeys.remove(key);
                
                bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
                bag.addListeners(prefListeners);
                bag.addEvent(new PreferenceChangeEvent(this, key, value));
            }
        }

        if (bag != null) {
            firePrefEvents(Collections.singletonList(bag));
        }
    }

    private ProxyPreferencesImpl node(String pathName, boolean create, List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
        if (pathName.length() > 0 && pathName.charAt(0) == '/') { //NOI18N
            // absolute path, if this is not the root then find the root
            // and pass the call to it
            if (parent != null) {
                Preferences root = this;
                while (root.parent() != null) {
                    root = root.parent();
                }
                return ((ProxyPreferencesImpl) root).node(pathName, create, events);
            } else {
                // this is the root, change the pathName to a relative path and proceed
                pathName = pathName.substring(1);
            }
        }

        if (pathName.length() > 0) {
            String childName;
            String pathFromChild;

            int idx = pathName.indexOf('/'); //NOI18N
            if (idx != -1) {
                childName = pathName.substring(0, idx);
                pathFromChild = pathName.substring(idx + 1);
            } else {
                childName = pathName;
                pathFromChild = null;
            }

            ProxyPreferencesImpl child = children.get(childName);
            if (child == null) {
                if (removedChildren.contains(childName) && !create) {
                    // this child has been removed
                    return null;
                }
                
                Preferences childDelegate = null;
                try {
                    if (delegate != null && delegate.nodeExists(childName)) {
                        childDelegate = delegate.node(childName);
                    }
                } catch (BackingStoreException bse) {
                    // ignore
                }

                if (childDelegate != null || create) {
                    child = tree.get(this, childName, childDelegate);
                    children.put(childName, child);
                    removedChildren.remove(childName);

                    // fire event if we really created the new child node
                    if (childDelegate == null) {
                        EventBag<NodeChangeListener, NodeChangeEvent> bag = new EventBag<NodeChangeListener, NodeChangeEvent>();
                        bag.addListeners(nodeListeners);
                        bag.addEvent(new NodeChangeEventExt(this, child, false));
                        events.add(bag);
                    }
                } else {
                    // childDelegate == null && !create
                    return null;
                }
            } else {
                assert !child.removed;
            }

            return pathFromChild != null ? child.node(pathFromChild, create, events) : child;
        } else {
            return this;
        }
    }

    private void addChild(ProxyPreferencesImpl child) {
        ProxyPreferencesImpl pp = children.get(child.name());
        if (pp == null) {
            children.put(child.name(), child);
        } else {
            assert pp == child;
        }
    }
    
    private void removeChild(ProxyPreferencesImpl child) {
        assert child != null;
        assert children.get(child.name()) == child;

        child.nodeRemoved();
        children.remove(child.name());
        removedChildren.add(child.name());
    }
    
    private void nodeRemoved() {
        for(ProxyPreferencesImpl pp : children.values()) {
            pp.nodeRemoved();
        }

        data.clear();
        removedKeys.clear();
        children.clear();
        removedChildren.clear();
        tree.removeNode(this);
        
        removed = true;
    }
    
    private void checkNotNull(Object paramValue, String paramName) {
        if (paramValue == null) {
            throw new NullPointerException("The " + paramName + " must not be null");
        }
    }

    private void checkRemoved() {
        if (removed) {
            throw new IllegalStateException("The node '" + this + " has already been removed."); //NOI18N
        }
    }

    private void changeDelegate(Preferences nueDelegate) {
        if (delegate != null) {
            try {
                if (delegate.nodeExists("")) { //NOI18N
                    assert weakPrefListener != null;
                    assert weakNodeListener != null;
                    delegate.removePreferenceChangeListener(weakPrefListener);
                    delegate.removeNodeChangeListener(weakNodeListener);
                }
            } catch (BackingStoreException bse) {
                LOG.log(Level.WARNING, null, bse);
            }
        }

        delegate = nueDelegate;
        weakPrefListener = null;
        weakNodeListener = null;
        
        if (delegate != null) {
            weakPrefListener = WeakListeners.create(PreferenceChangeListener.class, this, delegate);
            delegate.addPreferenceChangeListener(weakPrefListener);
            
            weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
            delegate.addNodeChangeListener(weakNodeListener);
        }
    }

    private void _sync(
        List<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> prefEvents, 
        List<EventBag<NodeChangeListener, NodeChangeEvent>> nodeEvents
    ) {
        // synchronize all children firts
        for(ProxyPreferencesImpl pp : children.values()) {
            pp._sync(prefEvents, nodeEvents);
        }

        // report all new children as removed
        EventBag<NodeChangeListener, NodeChangeEvent> nodeBag = new EventBag<NodeChangeListener, NodeChangeEvent>();
        nodeBag.addListeners(nodeListeners);

        for(ProxyPreferencesImpl pp : children.values()) {
            if (pp.delegate == null) {
                // new node that does not have corresponding node in the original hierarchy
                nodeBag.addEvent(new NodeChangeEventExt(this, pp, true));
            }
        }

        if (!nodeBag.getEvents().isEmpty()) {
            nodeEvents.add(nodeBag);
        }

        // report all modified keys
        if (delegate != null) {
            EventBag<PreferenceChangeListener, PreferenceChangeEvent> prefBag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
            prefBag.addListeners(prefListeners);
            prefEvents.add(prefBag);

            for(String key : data.keySet()) {
                prefBag.addEvent(new PreferenceChangeEvent(this, key, delegate.get(key, data.get(key).getValue())));
            }
        } // else there is no corresponding node in the orig hierarchy and this node
          // will be reported as removed

        // erase modified data
        for(NodeChangeEvent nce : nodeBag.getEvents()) {
            children.remove(nce.getChild().name());
        }
        data.clear();
    }

    private void firePrefEvents(List<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> events) {
        if (noEvents) {
            return;
        }
        
        for(EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag : events) {
            for(PreferenceChangeEvent event : bag.getEvents()) {
                for(PreferenceChangeListener l : bag.getListeners()) {
                    try {
                        l.preferenceChange(event);
                    } catch (Throwable t) {
                        LOG.log(Level.WARNING, null, t);
                    }
                }
            }
        }
    }

    private void fireNodeEvents(List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
        if (noEvents) {
            return;
        }
        
        for(EventBag<NodeChangeListener, NodeChangeEvent> bag : events) {
            for(NodeChangeEvent event : bag.getEvents()) {
                for(NodeChangeListener l : bag.getListeners()) {
                    try {
                        if ((event instanceof NodeChangeEventExt) && ((NodeChangeEventExt) event).isRemovalEvent()) {
                            l.childRemoved(event);
                        } else {
                            l.childAdded(event);
                        }
                    } catch (Throwable t) {
                        LOG.log(Level.WARNING, null, t);
                    }
                }
            }
        }
    }

    /* test */ static final class Tree {

        public static Tree getTree(Object token, Preferences prefs) {
            synchronized (trees) {
                // find all trees for the token
                Map<Preferences, Tree> forest = trees.get(token);
                if (forest == null) {
                    forest = new HashMap<Preferences, Tree>();
                    trees.put(token, forest);
                }

                // find the tree for the prefs' root
                Preferences root = prefs.node("/"); //NOI18N
                Tree tree = forest.get(root);
                if (tree == null) {
                    tree = new Tree(token, root);
                    forest.put(root, tree);
                }

                return tree;
            }
        }

        /* test */ static final Map<Object, Map<Preferences, Tree>> trees = new WeakHashMap<Object, Map<Preferences, Tree>>();

        private final Preferences root;
        private final Reference<?> tokenRef;
        private final Map<String, ProxyPreferencesImpl> nodes = new HashMap<String, ProxyPreferencesImpl>();
        
        private Tree(Object token, Preferences root) {
            this.root = root;
            this.tokenRef = new WeakReference<Object>(token);
        }

        public Object treeLock() {
            return this;
        }

        public ProxyPreferencesImpl get(ProxyPreferencesImpl parent, String name, Preferences delegate) {
            if (delegate != null) {
                assert name.equals(delegate.name());

                if (parent == null) {
                    Preferences parentDelegate = delegate.parent();
                    if (parentDelegate != null) {
                        parent = get(null, parentDelegate.name(), parentDelegate);
                    } // else delegate is the root
                } else {
                    // sanity check
                    assert parent.delegate == delegate.parent();
                }
            }

            String absolutePath;
            if (parent == null) {
                absolutePath = "/"; //NOI18N
            } else if (parent.parent() == null) {
                absolutePath = "/" + name; //NOI18N
            } else {
                absolutePath = parent.absolutePath() + "/" + name; //NOI18N
            }

            ProxyPreferencesImpl node = nodes.get(absolutePath);
            if (node == null) {
                node = new ProxyPreferencesImpl(parent, name, delegate, this);
                nodes.put(absolutePath, node);

                if (parent != null) {
                    parent.addChild(node);
                }
            } else {
                assert !node.removed;
            }

            return node;
        }

        public void removeNode(ProxyPreferencesImpl node) {
            String path = node.absolutePath();
            assert nodes.containsKey(path);
            ProxyPreferencesImpl pp = nodes.remove(path);
        }

        public void destroy() {
            synchronized (trees) {
                Object token = tokenRef.get();
                if (token != null) {
                    trees.remove(token);
                } // else the token has been GCed and therefore is not even in the trees map
            }
        }
    } // End of Tree class

    private static final class EventBag<L, E extends EventObject> {
        private final Set<L> listeners = new HashSet<L>();
        private final Set<E> events = new HashSet<E>();

        public EventBag() {
        }

        public Set<? extends L> getListeners() {
            return listeners;
        }

        public Set<? extends E> getEvents() {
            return events;
        }

        public void addListeners(Collection<? extends L> l) {
            listeners.addAll(l);
        }

        public void addEvent(E event) {
            events.add(event);
        }
    } // End of EventBag class

    private static final class NodeChangeEventExt extends NodeChangeEvent {
        private final boolean removal;
        public NodeChangeEventExt(Preferences parent, Preferences child, boolean removal) {
            super(parent, child);
            this.removal = removal;
        }

        public boolean isRemovalEvent() {
            return removal;
        }
    } // End of NodeChangeEventExt class
}




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

package org.netbeans.modules.editor.settings.storage.preferences;

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.prefs.AbstractPreferences;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;
import static junit.framework.Assert.assertEquals;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;
import org.netbeans.modules.editor.settings.storage.api.MemoryPreferences;

/**
 *
 * @author vita
 */
public class ProxyPreferencesImplTest extends NbTestCase {

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

    public void testSimpleRead() {
        Preferences orig = Preferences.userRoot().node(getName());
        orig.put("key-1", "value-1");

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        assertEquals("Wrong value", "value-1", test.get("key-1", null));
    }
    
    public void testSimpleWrite() {
        Preferences orig = Preferences.userRoot().node(getName());
        assertNull("Original contains value", orig.get("key-1", null));

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        test.put("key-1", "xyz");
        assertEquals("Wrong value", "xyz", test.get("key-1", null));
    }

    public void testBase64() {
        Preferences orig = Preferences.userRoot().node(getName());
        assertNull("Original contains value", orig.get("key-1", null));
        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        test.putByteArray("key-1", "however you like it".getBytes());
        assertEquals("Wrong value", "however you like it", new String(test.getByteArray("key-1", null)));
    }
    
    public void testSimpleSync() throws BackingStoreException {
        Preferences orig = Preferences.userRoot().node(getName());
        assertNull("Original contains value", orig.get("key-1", null));

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        assertNull("Test should not contains pair", orig.get("key-1", null));

        test.put("key-1", "xyz");
        assertEquals("Test doesn't contain new pair", "xyz", test.get("key-1", null));

        test.sync();
        assertNull("Test didn't rollback pair", test.get("key-1", null));
    }

    public void testSimpleFlush() throws BackingStoreException {
        Preferences orig = Preferences.userRoot().node(getName());
        assertNull("Original contains value", orig.get("key-1", null));

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        assertNull("Test should not contains pair", orig.get("key-1", null));

        test.put("key-1", "xyz");
        assertEquals("Test doesn't contain new pair", "xyz", test.get("key-1", null));

        test.flush();
        assertEquals("Test should still contain the pair", "xyz", test.get("key-1", null));
        assertEquals("Test didn't flush the pair", "xyz", orig.get("key-1", null));
    }
    
    public void testSyncTree1() throws BackingStoreException {
        String [] origTree = new String [] {
            "CodeStyle/profile=GLOBAL",
        };
        String [] newTree = new String [] {
            "CodeStyle/text/x-java/tab-size=2",
            "CodeStyle/text/x-java/override-global-settings=true",
            "CodeStyle/text/x-java/expand-tabs=true",
            "CodeStyle/profile=PROJECT",
        };

        Preferences orig = Preferences.userRoot().node(getName());
        write(orig, origTree);
        checkContains(orig, origTree, "Orig");
        checkNotContains(orig, newTree, "Orig");
        
        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        checkEquals("Test should be the same as Orig", orig, test);
        
        write(test, newTree);
        checkContains(test, newTree, "Test");

        test.sync();
        checkContains(orig, origTree, "Orig");
        checkNotContains(orig, newTree, "Orig");
        checkContains(test, origTree, "Test");
        checkNotContains(test, newTree, "Test");
    }

    public void testFlushTree1() throws BackingStoreException {
        String [] origTree = new String [] {
            "CodeStyle/profile=GLOBAL",
        };
        String [] newTree = new String [] {
            "CodeStyle/text/x-java/tab-size=2",
            "CodeStyle/text/x-java/override-global-settings=true",
            "CodeStyle/text/x-java/expand-tabs=true",
            "CodeStyle/profile=PROJECT",
        };

        Preferences orig = Preferences.userRoot().node(getName());
        write(orig, origTree);
        checkContains(orig, origTree, "Orig");
        checkNotContains(orig, newTree, "Orig");
        
        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        checkEquals("Test should be the same as Orig", orig, test);
        
        write(test, newTree);
        checkContains(test, newTree, "Test");

        test.flush();
        checkEquals("Test didn't flush to Orig", test, orig);
    }

    public void testRemoveKey() throws BackingStoreException {
        Preferences orig = Preferences.userRoot().node(getName());
        orig.put("key-2", "value-2");
        assertNull("Original contains value", orig.get("key-1", null));
        assertEquals("Original doesn't contain value", "value-2", orig.get("key-2", null));

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        test.put("key-1", "xyz");
        assertEquals("Wrong value", "xyz", test.get("key-1", null));
        
        test.remove("key-1");
        assertNull("Test contains removed key-1", test.get("key-1", null));
        
        test.remove("key-2");
        assertNull("Test contains removed key-2", test.get("key-2", null));

        test.flush();
        assertNull("Test flushed removed key-1", orig.get("key-1", null));
        assertNull("Test.flush did not remove removed key-2", orig.get("key-2", null));
    }

    public void testRemoveNode() throws BackingStoreException {
        Preferences orig = Preferences.userRoot().node(getName());
        Preferences origChild = orig.node("child");

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        assertTrue("Test child shoculd exist", test.nodeExists("child"));
        Preferences testChild = test.node("child");

        testChild.removeNode();
        assertFalse("Removed test child should not exist", testChild.nodeExists(""));
        assertFalse("Removed test child should not exist in parent", test.nodeExists("child"));

        test.flush();
        assertFalse("Test.flush did not remove orig child", origChild.nodeExists(""));
        assertFalse("Test.flush did not remove orig child from parent", orig.nodeExists("child"));
    }

    public void testRemoveNodeCreateItAgain() throws BackingStoreException {
        Preferences orig = Preferences.userRoot().node(getName());

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        Preferences testChild = test.node("child");

        testChild.removeNode();
        assertFalse("Removed test child should not exist", testChild.nodeExists(""));
        assertFalse("Removed test child should not exist in parent", test.nodeExists("child"));

        Preferences testChild2 = test.node("child");
        assertTrue("Recreated test child should exist", testChild2.nodeExists(""));
        assertTrue("Recreated test child should exist in parent", test.nodeExists("child"));
        assertNotSame("Recreated child must not be the same as the removed one", testChild2, testChild);
        assertEquals("Wrong childrenNames list", Arrays.asList(new String [] { "child" }), Arrays.asList(test.childrenNames()));

        try {
            testChild.get("key", null);
            fail("Removed test node should not be accessible");
        } catch (Exception e) {
        }

        try {
            testChild2.get("key", null);
        } catch (Exception e) {
            fail("Recreated test node should be accessible");
        }

    }

    public void testRemoveHierarchy() throws BackingStoreException {
        String [] origTree = new String [] {
            "R.CodeStyle.project.expand-tabs=true",
            "R.CodeStyle.project.indent-shift-width=6",
            "R.CodeStyle.project.spaces-per-tab=6",
            "R.CodeStyle.project.tab-size=7",
            "R.CodeStyle.project.text-limit-width=88",
            "R.CodeStyle.usedProfile=project",
            "R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
            "R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
            "R.text.x-ruby.CodeStyle.project.tab-size=2",
        };
        String [] newTree = new String [] {
            "R.CodeStyle.project.expand-tabs=true",
            "R.CodeStyle.project.indent-shift-width=3",
            "R.CodeStyle.project.spaces-per-tab=3",
            "R.CodeStyle.project.tab-size=5",
            "R.CodeStyle.project.text-limit-width=77",
            "R.CodeStyle.usedProfile=project",
            "R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
            "R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
            "R.text.x-ruby.CodeStyle.project.tab-size=2",
        };

        Preferences orig = Preferences.userRoot().node(getName());
        write(orig, origTree);

        checkContains(orig, origTree, "Orig");

        Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
        checkEquals("Test should be the same as Orig", orig, test);

        Preferences testRoot = test.node("R");
        removeAllKidsAndKeys(testRoot);
        
        write(test, newTree);
        checkContains(test, newTree, "Test");

        test.flush();
        checkEquals("Test didn't flush to Orig", test, orig);
    }

    public void testTreeGCed() throws BackingStoreException {
        String [] newTree = new String [] {
            "R.CodeStyle.project.expand-tabs=true",
            "R.CodeStyle.project.indent-shift-width=3",
            "R.CodeStyle.project.spaces-per-tab=3",
            "R.CodeStyle.project.tab-size=5",
            "R.CodeStyle.project.text-limit-width=77",
            "R.CodeStyle.usedProfile=project",
            "R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
            "R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
            "R.text.x-ruby.CodeStyle.project.tab-size=2",
        };

        Preferences orig = Preferences.userRoot().node(getName());

        Object treeToken = new Object();
        Preferences test = ProxyPreferencesImpl.getProxyPreferences(treeToken, orig);
        write(test, newTree);
        checkContains(test, newTree, "Test");

        Reference<Object> treeTokenRef = new WeakReference<Object>(treeToken);
        Reference<Preferences> testRef = new WeakReference<Preferences>(test);
        treeToken = null;
        test = null;
        assertGC("Tree token was not GCed", treeTokenRef, Collections.singleton(this));
        // touch the WeakHashMap to expungeStaleEntries
        Object dummyToken = new Object();
        ProxyPreferencesImpl dummyPrefs = ProxyPreferencesImpl.getProxyPreferences(dummyToken, orig);
        assertGC("Test preferences were not GCed", testRef, Collections.singleton(this));
        
    }
    
    /**
     * Checks that a value not defined in delegate can be read from the parent prefs.
     * Checks that if the parent prefs also do not define the value, the
     * default from parameter is used.
     * 
     * @throws Exception 
     */
    public void testInheritedRead() throws Exception {
        Preferences stored = new MapPreferences();
        Preferences inherited = new MapPreferences();
        
        stored.put("key-1", "value-1");
        stored.put("key-3", "override");
        inherited.put("key-2", "value-2");
        inherited.put("key-3", "base");

        MemoryPreferences mem = MemoryPreferences.getWithInherited(this, inherited, stored);
        Preferences test = mem.getPreferences();

        assertEquals("Wrong value 1", "value-1", test.get("key-1", null));
        assertEquals("Wrong value 2", "value-2", test.get("key-2", "a"));
        assertEquals("Wrong value 3", "override", test.get("key-3", "a"));
        assertEquals("Wrong value 4", "value-4", test.get("key-4", "value-4"));
    }
    
    /**
     * Asserts that if a value is remove()d during editing, the inherited value
     * will be seen through. Also checks that the Preferences key is actually
     * deleted on flush() and the inherited preferences is not altered.
     */
    public void testSeeInheritedThroughRemoves() throws Exception {
        Preferences stored = new MapPreferences();
        Preferences inherited = new MapPreferences();

        stored.put("key", "value");
        inherited.put("key", "parentValue");
        
        MemoryPreferences mem = MemoryPreferences.getWithInherited(this, inherited, stored);
        Preferences test = mem.getPreferences();

        assertEquals("Does not see local value", "value", test.get("key", null));
        test.remove("key");
        
        assertEquals("Stored value changed prematurely", "value", stored.get("key", null));
        assertEquals("Inherited not seen", "parentValue", test.get("key", null));
        
        test.flush();
        assertNull("Stored value not erased", stored.get("key", null));
        assertEquals("Inherited changed", "parentValue", test.get("key", null));
    }

    // -----------------------------------------------------------------------
    // private implementation
    // -----------------------------------------------------------------------
    
    private static class MapPreferences extends AbstractPreferences implements OverridePreferences {
        
        private Map<String,Object> map = new HashMap<String, Object>();

        public MapPreferences() {
            super(null, ""); // NOI18N
        }

        @Override
        public boolean isOverriden(String key) {
            return map.containsKey(key);
        }
        
        protected void putSpi(String key, String value) {
            map.put(key, value);            
        }

        protected String getSpi(String key) {
            return (String)map.get(key);                    
        }

        protected void removeSpi(String key) {
            map.remove(key);
        }

        protected void removeNodeSpi() throws BackingStoreException {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        protected String[] keysSpi() throws BackingStoreException {
            String array[] = new String[map.keySet().size()];
            return map.keySet().toArray( array );
        }

        protected String[] childrenNamesSpi() throws BackingStoreException {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        protected AbstractPreferences childSpi(String name) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        protected void syncSpi() throws BackingStoreException {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        protected void flushSpi() throws BackingStoreException {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }

    private void write(Preferences prefs, String[] tree) {
        for(String s : tree) {
            int equalIdx = s.lastIndexOf('=');
            assertTrue(equalIdx != -1);
            String value = s.substring(equalIdx + 1);

            String key;
            String nodePath;
            int slashIdx = s.lastIndexOf('/', equalIdx);
            if (slashIdx != -1) {
                key = s.substring(slashIdx + 1, equalIdx);
                nodePath = s.substring(0, slashIdx);
            } else {
                key = s.substring(0, equalIdx);
                nodePath = "";
            }

            Preferences node = prefs.node(nodePath);
            node.put(key, value);
        }
    }

    private void checkContains(Preferences prefs, String[] tree, String prefsId) throws BackingStoreException {
        for(String s : tree) {
            int equalIdx = s.lastIndexOf('=');
            assertTrue(equalIdx != -1);
            String value = s.substring(equalIdx + 1);

            String key;
            String nodePath;
            int slashIdx = s.lastIndexOf('/', equalIdx);
            if (slashIdx != -1) {
                key = s.substring(slashIdx + 1, equalIdx);
                nodePath = s.substring(0, slashIdx);
            } else {
                key = s.substring(0, equalIdx);
                nodePath = "";
            }

            assertTrue(prefsId + " doesn't contain node '" + nodePath + "'", prefs.nodeExists(nodePath));
            Preferences node = prefs.node(nodePath);

            String realValue = node.get(key, null);
            assertNotNull(prefsId + ", '" + nodePath + "' node doesn't contain key '" + key + "'", realValue);
            assertEquals(prefsId + ", '" + nodePath + "' node, '" + key + "' contains wrong value", value, realValue);
        }
    }

    private void checkNotContains(Preferences prefs, String[] tree, String prefsId) throws BackingStoreException {
        for(String s : tree) {
            int equalIdx = s.lastIndexOf('=');
            assertTrue(equalIdx != -1);
            String value = s.substring(equalIdx + 1);

            String key;
            String nodePath;
            int slashIdx = s.lastIndexOf('/', equalIdx);
            if (slashIdx != -1) {
                key = s.substring(slashIdx + 1, equalIdx);
                nodePath = s.substring(0, slashIdx);
            } else {
                key = s.substring(0, equalIdx);
                nodePath = "";
            }

            if (prefs.nodeExists(nodePath)) {
                Preferences node = prefs.node(nodePath);
                String realValue = node.get(key, null);
                if (realValue != null && realValue.equals(value)) {
                    fail(prefsId + ", '" + nodePath + "' node contains key '" + key + "' = '" + realValue + "'");
                }
            }
        }
    }

    private void dump(Preferences prefs, String prefsId) throws BackingStoreException {
        for(String key : prefs.keys()) {
            System.out.println(prefsId + ", " + prefs.absolutePath() + "/" + key + "=" + prefs.get(key, null));
        }
        for(String child : prefs.childrenNames()) {
            dump(prefs.node(child), prefsId);
        }
    }

    private void checkEquals(String msg, Preferences expected, Preferences test) throws BackingStoreException {
        assertEquals("Won't compare two Preferences with different absolutePath", expected.absolutePath(), test.absolutePath());
        
        // check the keys and their values
        for(String key : expected.keys()) {
            String expectedValue = expected.get(key, null);
            assertNotNull(msg + "; Expected:" + expected.absolutePath() + " has no '" + key + "'", expectedValue);
            
            String value = test.get(key, null);
            assertNotNull(msg + "; Test:" + test.absolutePath() + " has no '" + key + "'", value);
            assertEquals(msg + "; Test:" + test.absolutePath() + "/" + key + " has wrong value", expectedValue, value);
        }

        // check the children
        for(String child : expected.childrenNames()) {
            assertTrue(msg + "; Expected:" + expected.absolutePath() + " has no '" + child + "' subnode", expected.nodeExists(child));
            Preferences expectedChild = expected.node(child);

            assertTrue(msg + "; Test:" + test.absolutePath() + " has no '" + child + "' subnode", test.nodeExists(child));
            Preferences testChild = test.node(child);

            checkEquals(msg, expectedChild, testChild);
        }
    }

    private void removeAllKidsAndKeys(Preferences prefs) throws BackingStoreException {
        for(String kid : prefs.childrenNames()) {
            prefs.node(kid).removeNode();
        }
        for(String key : prefs.keys()) {
            prefs.remove(key);
        }
    }

}

Lines 251-256 Link Here

(-)a/editor/src/org/netbeans/modules/editor/resources/layer.xml (+7 lines)
251	<attr name="position" intvalue="6000"/>	251	<attr name="position" intvalue="6000"/>
252	<attr name="scrollable" boolvalue="false"/>	252	<attr name="scrollable" boolvalue="false"/>
253	</file>	253	</file>
		254	<file name="org-netbeans-modules-editor-fold-CodeFoldingSidebar.instance">
		255	<attr name="location" stringvalue="west"/>
		256	<!-- should be positioned after the current registrations, so they prevail -->
		257	<attr name="position" intvalue="1600"/>
		258	<attr name="instanceof" stringvalue="org.netbeans.editor.SideBarFactory"/>
		259	<attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.foldingSidebarFactory"/>
		260	</file>
254	</folder>	261	</folder>
255		262
256	<folder name="Toolbars">	263	<folder name="Toolbars">

Lines 123-128 Link Here

(-)a/html.editor/nbproject/project.xml (+4 lines)
123	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>	123	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
124	<build-prerequisite/>	124	<build-prerequisite/>
125	<compile-dependency/>	125	<compile-dependency/>
		126	<run-dependency>
		127	<release-version>1</release-version>
		128	<specification-version>1.34</specification-version>
		129	</run-dependency>
126	</dependency>	130	</dependency>
127	<dependency>	131	<dependency>
128	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>	132	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>




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

import java.util.Arrays;
import java.util.Collection;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.api.editor.mimelookup.MimeRegistrations;
import org.netbeans.spi.editor.fold.FoldTypeProvider;

/**
 * @author sdedic
 */
@MimeRegistrations({
        @MimeRegistration(mimeType = "text/html", service = FoldTypeProvider.class),
        @MimeRegistration(mimeType = "text/xhtml", service = FoldTypeProvider.class)
})
public class HtmlFoldTypeProvider  implements FoldTypeProvider {
    private Collection<FoldType> TYPES = Arrays.asList(new FoldType[] {
        HtmlStructureScanner.TYPE_TAG,
        HtmlStructureScanner.TYPE_COMMENT
    });

    @Override
    public Collection getValues(Class type) {
        return type == FoldType.class ? TYPES : null;
    }

    @Override
    public boolean inheritable() {
        return false;
    }
    
}

Lines 47-52 Link Here

(-)a/html.editor/src/org/netbeans/modules/html/editor/gsf/HtmlStructureScanner.java (-2 / +18 lines)
47	import java.util.logging.Level;	47	import java.util.logging.Level;
48	import java.util.logging.Logger;	48	import java.util.logging.Logger;
49	import javax.swing.text.BadLocationException;	49	import javax.swing.text.BadLocationException;
		50	import org.netbeans.api.editor.fold.FoldType;
50	import org.netbeans.editor.BaseDocument;	51	import org.netbeans.editor.BaseDocument;
51	import org.netbeans.editor.Utilities;	52	import org.netbeans.editor.Utilities;
52	import org.netbeans.modules.csl.api.OffsetRange;	53	import org.netbeans.modules.csl.api.OffsetRange;
Lines 58-69 Link Here
58	import org.netbeans.modules.parsing.api.Snapshot;	59	import org.netbeans.modules.parsing.api.Snapshot;
59	import org.netbeans.modules.web.common.api.Pair;	60	import org.netbeans.modules.web.common.api.Pair;
60	import org.openide.filesystems.FileObject;	61	import org.openide.filesystems.FileObject;
		62	import org.openide.util.Exceptions;
		63	import org.openide.util.NbBundle;
		64	import static org.netbeans.modules.html.editor.gsf.Bundle.*;
61		65
62	/**	66	/**
63	*	67	*
64	* @author mfukala@netbeans.org	68	* @author mfukala@netbeans.org
65	*/	69	*/
66	public class HtmlStructureScanner implements StructureScanner {	70	public class HtmlStructureScanner implements StructureScanner {
		71
		72	/**
		73	* Tag fold type. Overrides the default label.
		74	*/
		75	@NbBundle.Messages("FT_Tag=Tags")
		76	public static final FoldType TYPE_TAG = FoldType.TAG.override(
		77	FT_Tag(), FoldType.TAG.getTemplate());
		78
		79	/**
		80	* HTML comments
		81	*/
		82	public static final FoldType TYPE_COMMENT = FoldType.COMMENT;
67		83
68	private static final Logger LOGGER = Logger.getLogger(HtmlStructureScanner.class.getName());	84	private static final Logger LOGGER = Logger.getLogger(HtmlStructureScanner.class.getName());
69	private static final boolean LOG = LOGGER.isLoggable(Level.FINE);	85	private static final boolean LOG = LOGGER.isLoggable(Level.FINE);
Lines 187-194 Link Here
187	} finally {	203	} finally {
188	doc.readUnlock();	204	doc.readUnlock();
189	}	205	}
190	folds.put("tags", tags);	206	folds.put(TYPE_TAG.code(), tags);
191	folds.put("comments", comments);	207	folds.put(TYPE_COMMENT.code(), comments);
192		208
193	return folds;	209	return folds;
194	}	210	}

Lines 133-138 Link Here

(-)a/html.editor/src/org/netbeans/modules/html/editor/resources/layer.xml (+16 lines)
133		133
134	<folder name="FoldManager">	134	<folder name="FoldManager">
135	<file name="org-netbeans-modules-csl-editor-fold-GsfFoldManagerFactory.instance"/>	135	<file name="org-netbeans-modules-csl-editor-fold-GsfFoldManagerFactory.instance"/>
		136	<file name="HTMLDocReader.instance">
		137	<attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.ContentReader$Factory"/>
		138	<attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.contentReaderFactory"/>
		139	<attr name="start" stringvalue="<"/>
		140	<attr name="terminator" stringvalue="[\s/>]"/>
		141	<attr name="type" stringvalue="tag"/>
		142	<attr name="prefix" stringvalue=""/>
		143	</file>
136	</folder>	144	</folder>
137	<folder name="SideBar">	145	<folder name="SideBar">
138	<file name="org-netbeans-modules-csl-editor-GsfCodeFoldingSideBarFactory.instance">	146	<file name="org-netbeans-modules-csl-editor-GsfCodeFoldingSideBarFactory.instance">
Lines 268-273 Link Here
268		276
269	<folder name="FoldManager">	277	<folder name="FoldManager">
270	<file name="org-netbeans-modules-csl-editor-fold-GsfFoldManagerFactory.instance"/>	278	<file name="org-netbeans-modules-csl-editor-fold-GsfFoldManagerFactory.instance"/>
		279	<file name="HTMLDocReader.instance">
		280	<attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.ContentReader$Factory"/>
		281	<attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.contentReaderFactory"/>
		282	<attr name="start" stringvalue="<"/>
		283	<attr name="terminator" stringvalue="[\s/>]"/>
		284	<attr name="type" stringvalue="tag"/>
		285	<attr name="prefix" stringvalue=""/>
		286	</file>
271	</folder>	287	</folder>
272	<folder name="SideBar">	288	<folder name="SideBar">
273	<file name="org-netbeans-modules-csl-editor-GsfCodeFoldingSideBarFactory.instance">	289	<file name="org-netbeans-modules-csl-editor-GsfCodeFoldingSideBarFactory.instance">

Lines 1-5 Link Here

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

Lines 40-45 Link Here

(-)a/java.editor.lib/nbproject/project.properties (+2 lines)
40	# Version 2 license, then the option applies only if the new code is	40	# Version 2 license, then the option applies only if the new code is
41	# made subject to such option by the copyright holder.	41	# made subject to such option by the copyright holder.
42		42
		43	javac.compilerargs=-Xlint -Xlint:-serial
		44	javac.source=1.5
43	#javadoc.arch=${basedir}/arch/arch-java-editor-lib.xml	45	#javadoc.arch=${basedir}/arch/arch-java-editor-lib.xml
44	javadoc.title=Java Editor Library	46	javadoc.title=Java Editor Library
45	javadoc.apichanges=${basedir}/apichanges.xml	47	javadoc.apichanges=${basedir}/apichanges.xml

Lines 50-60 Link Here

(-)a/java.editor.lib/nbproject/project.xml (-9 / +19 lines)
50	<code-name-base>org.netbeans.modules.java.editor.lib</code-name-base>	50	<code-name-base>org.netbeans.modules.java.editor.lib</code-name-base>
51	<module-dependencies>	51	<module-dependencies>
52	<dependency>	52	<dependency>
		53	<code-name-base>org.netbeans.modules.editor.deprecated.pre65formatting</code-name-base>
		54	<build-prerequisite/>
		55	<compile-dependency/>
		56	<run-dependency>
		57	<release-version>0-1</release-version>
		58	<specification-version>1.0</specification-version>
		59	</run-dependency>
		60	</dependency>
		61	<dependency>
53	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>	62	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
54	<build-prerequisite/>	63	<build-prerequisite/>
55	<compile-dependency/>	64	<compile-dependency/>
56	<run-dependency>	65	<run-dependency>
57	<release-version>1</release-version>	66	<release-version>1</release-version>
		67	<specification-version>1.34</specification-version>
58	</run-dependency>	68	</run-dependency>
59	</dependency>	69	</dependency>
60	<dependency>	70	<dependency>
Lines 76-81 Link Here
76	</run-dependency>	86	</run-dependency>
77	</dependency>	87	</dependency>
78	<dependency>	88	<dependency>
		89	<code-name-base>org.netbeans.modules.editor.lib2</code-name-base>
		90	<build-prerequisite/>
		91	<compile-dependency/>
		92	<run-dependency>
		93	<release-version>1</release-version>
		94	<specification-version>1.71</specification-version>
		95	</run-dependency>
		96	</dependency>
		97	<dependency>
79	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>	98	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
80	<build-prerequisite/>	99	<build-prerequisite/>
81	<compile-dependency/>	100	<compile-dependency/>
Lines 108-122 Link Here
108	<specification-version>8.0</specification-version>	127	<specification-version>8.0</specification-version>
109	</run-dependency>	128	</run-dependency>
110	</dependency>	129	</dependency>
111	<dependency>
112	<code-name-base>org.netbeans.modules.editor.deprecated.pre65formatting</code-name-base>
113	<build-prerequisite/>
114	<compile-dependency/>
115	<run-dependency>
116	<release-version>0-1</release-version>
117	<specification-version>1.0</specification-version>
118	</run-dependency>
119	</dependency>
120	</module-dependencies>	130	</module-dependencies>
121	<public-packages>	131	<public-packages>
122	<package>org.netbeans.editor.ext.java</package>	132	<package>org.netbeans.editor.ext.java</package>

Lines 44-54 Link Here

(-)a/java.editor.lib/src/org/netbeans/editor/ext/java/JavaFoldManager.java (-7 / +26 lines)
44		44
45	package org.netbeans.editor.ext.java;	45	package org.netbeans.editor.ext.java;
46		46
47	import org.netbeans.api.editor.fold.Fold;
48	import org.netbeans.api.editor.fold.FoldHierarchy;
49	import org.netbeans.api.editor.fold.FoldType;	47	import org.netbeans.api.editor.fold.FoldType;
50	import org.netbeans.spi.editor.fold.FoldManager;	48	import org.netbeans.spi.editor.fold.FoldManager;
51		49
		50	import static org.netbeans.editor.ext.java.Bundle.*;
		51	import org.openide.util.NbBundle;
		52
52	/**	53	/**
53	* Java fold maintainer creates and updates folds for java sources.	54	* Java fold maintainer creates and updates folds for java sources.
54	*	55	*
Lines 58-70 Link Here
58		59
59	public abstract class JavaFoldManager implements FoldManager {	60	public abstract class JavaFoldManager implements FoldManager {
60		61
61	public static final FoldType INITIAL_COMMENT_FOLD_TYPE = new FoldType("initial-comment"); // NOI18N	62	public static final FoldType INITIAL_COMMENT_FOLD_TYPE = FoldType.INITIAL_COMMENT; // NOI18N
62		63
63	public static final FoldType IMPORTS_FOLD_TYPE = new FoldType("imports"); // NOI18N	64	@NbBundle.Messages("FoldType_Imports=Imports")
		65	public static final FoldType IMPORTS_FOLD_TYPE = FoldType.create("import", FoldType_Imports(),
		66	new org.netbeans.api.editor.fold.FoldTemplate(0, 0, "...")); // NOI18N
64		67
65	public static final FoldType JAVADOC_FOLD_TYPE = new FoldType("javadoc"); // NOI18N	68	@NbBundle.Messages("FoldType_Javadoc=Javadoc Comments")
		69	public static final FoldType JAVADOC_FOLD_TYPE = FoldType.DOCUMENTATION.derive("javadoc", FoldType_Javadoc(),
		70	new org.netbeans.api.editor.fold.FoldTemplate(3, 2, "/*.../")); // NOI18N
66		71
67	public static final FoldType CODE_BLOCK_FOLD_TYPE = new FoldType("code-block"); // NOI18N	72	@NbBundle.Messages("FoldType_Methods=Methods")
		73	public static final FoldType CODE_BLOCK_FOLD_TYPE = FoldType.MEMBER.derive("method", FoldType_Methods(),
		74	new org.netbeans.api.editor.fold.FoldTemplate(1, 1, "{...}")); // NOI18N
		75
		76	@NbBundle.Messages("FoldType_InnerClasses=Inner Classes")
		77	public static final FoldType INNERCLASS_TYPE = FoldType.NESTED.derive("innerclass", "Inner Classes",
		78	new org.netbeans.api.editor.fold.FoldTemplate(1, 1, "{...}")); // NOI18N
68		79
69	private static final String IMPORTS_FOLD_DESCRIPTION = "..."; // NOI18N	80	private static final String IMPORTS_FOLD_DESCRIPTION = "..."; // NOI18N
70		81
Lines 73-91 Link Here
73	private static final String JAVADOC_FOLD_DESCRIPTION = "/*.../"; // NOI18N	84	private static final String JAVADOC_FOLD_DESCRIPTION = "/*.../"; // NOI18N
74		85
75	private static final String CODE_BLOCK_FOLD_DESCRIPTION = "{...}"; // NOI18N	86	private static final String CODE_BLOCK_FOLD_DESCRIPTION = "{...}"; // NOI18N
76		87
		88	@Deprecated
77	public static final FoldTemplate INITIAL_COMMENT_FOLD_TEMPLATE	89	public static final FoldTemplate INITIAL_COMMENT_FOLD_TEMPLATE
78	= new FoldTemplate(INITIAL_COMMENT_FOLD_TYPE, COMMENT_FOLD_DESCRIPTION, 2, 2);	90	= new FoldTemplate(INITIAL_COMMENT_FOLD_TYPE, COMMENT_FOLD_DESCRIPTION, 2, 2);
79		91
		92	@Deprecated
80	public static final FoldTemplate IMPORTS_FOLD_TEMPLATE	93	public static final FoldTemplate IMPORTS_FOLD_TEMPLATE
81	= new FoldTemplate(IMPORTS_FOLD_TYPE, IMPORTS_FOLD_DESCRIPTION, 0, 0);	94	= new FoldTemplate(IMPORTS_FOLD_TYPE, IMPORTS_FOLD_DESCRIPTION, 0, 0);
82		95
		96	@Deprecated
83	public static final FoldTemplate JAVADOC_FOLD_TEMPLATE	97	public static final FoldTemplate JAVADOC_FOLD_TEMPLATE
84	= new FoldTemplate(JAVADOC_FOLD_TYPE, JAVADOC_FOLD_DESCRIPTION, 3, 2);	98	= new FoldTemplate(JAVADOC_FOLD_TYPE, JAVADOC_FOLD_DESCRIPTION, 3, 2);
85		99
		100	@Deprecated
86	public static final FoldTemplate CODE_BLOCK_FOLD_TEMPLATE	101	public static final FoldTemplate CODE_BLOCK_FOLD_TEMPLATE
87	= new FoldTemplate(CODE_BLOCK_FOLD_TYPE, CODE_BLOCK_FOLD_DESCRIPTION, 1, 1);	102	= new FoldTemplate(CODE_BLOCK_FOLD_TYPE, CODE_BLOCK_FOLD_DESCRIPTION, 1, 1);
88		103
		104	@Deprecated
		105	public static final FoldTemplate INNER_CLASS_FOLD_TEMPLATE
		106	= new FoldTemplate(INNERCLASS_TYPE, CODE_BLOCK_FOLD_DESCRIPTION, 1, 1);
		107
89		108
90	protected static final class FoldTemplate {	109	protected static final class FoldTemplate {
91		110

Lines 42-48 Link Here

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

Lines 143-148 Link Here

(-)a/java.editor/nbproject/project.xml (-1 / +2 lines)
143	<compile-dependency/>	143	<compile-dependency/>
144	<run-dependency>	144	<run-dependency>
145	<release-version>1</release-version>	145	<release-version>1</release-version>
		146	<specification-version>1.34</specification-version>
146	</run-dependency>	147	</run-dependency>
147	</dependency>	148	</dependency>
148	<dependency>	149	<dependency>
Lines 205-211 Link Here
205	<compile-dependency/>	206	<compile-dependency/>
206	<run-dependency>	207	<run-dependency>
207	<release-version>1</release-version>	208	<release-version>1</release-version>
208	<specification-version>1.9</specification-version>	209	<specification-version>1.29</specification-version>
209	</run-dependency>	210	</run-dependency>
210	</dependency>	211	</dependency>
211	<dependency>	212	<dependency>

Lines 50-57 Link Here

(-)a/java.editor/src/org/netbeans/modules/editor/java/NbJavaCodeFoldingSideBarFactory.java (+4 lines)
50	/**	50	/**
51	* Java Code Folding Side Bar Factory, responsible for creating CodeFoldingSideBar	51	* Java Code Folding Side Bar Factory, responsible for creating CodeFoldingSideBar
52	* Plugged via layer.xml	52	* Plugged via layer.xml
		53	* <p/>
		54	* As this factory does not provide any extra functionality over the standard factory,
		55	* it should be probably removed.
53	*	56	*
54	* @author Martin Roskanin	57	* @author Martin Roskanin
		58	* @Deprecated
55	*/	59	*/
56	public class NbJavaCodeFoldingSideBarFactory implements SideBarFactory{	60	public class NbJavaCodeFoldingSideBarFactory implements SideBarFactory{
57		61




import javax.swing.text.Document;
import javax.swing.text.Position;
import org.netbeans.api.editor.fold.Fold;
import org.netbeans.spi.editor.fold.FoldInfo;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.settings.SimpleValueNames;
import org.netbeans.api.java.lexer.JavaTokenId;

    private FileObject    file;
    private JavaElementFoldTask task;
    
    /**
     * Default folding of individual fold types. New instance is created
     * when a new FoldManager opens (= editor appears).
     */
    private static class Presets {
        // Folding presets
        private boolean foldImportsPreset = false;
        private boolean foldInnerClassesPreset = false;
        private boolean foldJavadocsPreset = false;
        private boolean foldCodeBlocksPreset = false;
        private boolean foldInitialCommentsPreset = false;

        public Presets() {
            Preferences prefs = MimeLookup.getLookup(JavaKit.JAVA_MIME_TYPE).lookup(Preferences.class);
            foldInitialCommentsPreset = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_COLLAPSE_INITIAL_COMMENT, foldInitialCommentsPreset);
            foldImportsPreset = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_COLLAPSE_IMPORT, foldImportsPreset);
            foldCodeBlocksPreset = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_COLLAPSE_METHOD, foldCodeBlocksPreset);
            foldInnerClassesPreset = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_COLLAPSE_INNERCLASS, foldInnerClassesPreset);
            foldJavadocsPreset = prefs.getBoolean(SimpleValueNames.CODE_FOLDING_COLLAPSE_JAVADOC, foldJavadocsPreset);
        }

        private static volatile Presets CURRENT;

        static void refresh() {
            CURRENT = null;
        }

        static Presets get() {
            Presets p = CURRENT;
            if (p != null) {
                return p;
            }
            return CURRENT = new Presets();
        }
    }

    public void init(FoldOperation operation) {
        this.operation = operation;
        Presets.refresh();
    }

    public synchronized void initFolds(FoldHierarchyTransaction transaction) {

        if (od instanceof DataObject) {
            FileObject file = ((DataObject)od).getPrimaryFile();

            currentFolds = new ArrayList<Fold>();
            task = JavaElementFoldTask.getTask(file);
            task.setJavaElementFoldManager(JavaElementFoldManager.this, file);
        }

    }

    public void removeDamagedNotify(Fold damagedFold) {
        currentFolds.remove(operation.getExtraInfo(damagedFold));
        if (importsFold == damagedFold) {
            importsFold = null;//not sure if this is correct...
        }

        
        task         = null;
        file         = null;
        currentFolds = null;
        importsFold  = null;
        initialCommentFold = null;
    }

            }
            
            final JavaElementFoldVisitor v = new JavaElementFoldVisitor(info, 
                    cu, info.getTrees().getSourcePositions(), doc);
            
            scan(v, cu, null);
            

            if (v.stopped || isCancelled())
                return ;

            Collections.sort(v.folds);
            if (mgrs instanceof JavaElementFoldManager) {
                SwingUtilities.invokeLater(((JavaElementFoldManager)mgrs).createCommit(doc, v));
            } else {
                SwingUtilities.invokeLater(new Runnable() {
                    Collection<JavaElementFoldManager> jefms = (Collection<JavaElementFoldManager>)mgrs;
                    public void run() {
                        for (JavaElementFoldManager jefm : jefms) {
                            jefm.createCommit(doc, v).run();
                        }
                }});
            }

        
    }
    
    private CommitFolds createCommit(Document doc, JavaElementFoldVisitor v) {
        return new CommitFolds(doc, v.folds, v.initialCommentInfo, v.importsInfo);
    }
    
    private class CommitFolds implements Runnable {
        
        private boolean insideRender;
        private Document doc;
        private List<FoldInfo> infos;
        private long startTime;
        private FoldInfo initComment;
        private FoldInfo imports;
        
        public CommitFolds(Document doc, List<FoldInfo> infos, FoldInfo initComment, FoldInfo imports) {
            this.doc = doc;
            this.infos = infos;
            this.imports = imports;
            this.initComment = initComment;
        }
        
        /**

         * ignores the default state, and takes it from the actual state of
         * existing fold.
         */
        private void setSpecialFoldState(FoldInfo info, Fold f) {
            if (info == null || f == null) {
                return;
                    return importsFold.isCollapsed();
                }
            } else if (fi.template == INITIAL_COMMENT_FOLD_TEMPLATE) {
                if (initialCommentFold != null) {
                    return initialCommentFold.isCollapsed();
                }
            }
            return fi.collapseByDefault;
        }
        
        private int flip(int order) {
            if (order > 0) {
                return -1;
            } else if (order < 0) {
                return 1;
            } else {
                info.collapsed(f.isCollapsed());
            }
        }
        

            if (!insideRender) {
                startTime = System.currentTimeMillis();
                insideRender = true;
                
                // retain import & initial comment states
                setSpecialFoldState(imports, importsFold);
                setSpecialFoldState(initComment, initialCommentFold);
                Document d = operation.getHierarchy().getComponent().getDocument();
                if (d != doc) {
                    return;

            }
            
            operation.getHierarchy().lock();
            
            try {
                Map<FoldInfo, Fold> folds = operation.update(infos, null, null);
                if (initComment != null) {
                    initialCommentFold = folds.get(initComment);
                } else {
                    initialCommentFold = null;

                    List<Fold> updatedFolds = new ArrayList<Fold>(infos.size());
                    Iterator<Fold> itExisting = currentFolds.iterator();
                    Iterator<FoldInfo> itNew = infos.iterator();
                    Fold currentExisting = itExisting.hasNext() ? itExisting.next() : null;
                    FoldInfo currentNew = itNew.hasNext() ? itNew.next() : null;

                    while (currentExisting != null || currentNew != null) {
                        int order = currentExisting != null && currentNew != null ? currentNew.compareTo(currentExisting) : currentExisting != null ? 1 : -1;

                        if (order > 0) {
                            //fold removed:
                            operation.removeFromHierarchy(currentExisting, tr);

                            if (importsFold == currentExisting) {
                                importsFold = null;
                            }

                            if (initialCommentFold == currentExisting) {
                                initialCommentFold = null;
                            }
                            
                            currentExisting = itExisting.hasNext() ? itExisting.next() : null;
                        } else {
                            //added or remains:
                            if (order < 0) {
                                //added:
                                int start = currentNew.start.getOffset();
                                int end   = currentNew.end.getOffset();

                                if (end > start &&
                                        (end - start) >= (currentNew.template.getStartGuardedLength() + currentNew.template.getEndGuardedLength())) {
                                    Fold f = operation.addToHierarchy(currentNew.template.getType(),
                                            currentNew.template.getDescription(),
                                            mergeSpecialFoldState(currentNew),
                                            start,
                                            end,
                                            currentNew.template.getStartGuardedLength(),
                                            currentNew.template.getEndGuardedLength(),
                                            currentNew,
                                            tr);
                                    
                                    if (currentNew.template == IMPORTS_FOLD_TEMPLATE) {
                                        importsFold = f;
                                    }
                                    
                                    if (currentNew.template == INITIAL_COMMENT_FOLD_TEMPLATE) {
                                        initialCommentFold = f;
                                    }

                                    updatedFolds.add(f);
                                }
                            } else {
                                updatedFolds.add(currentExisting);
                                currentExisting = itExisting.hasNext() ? itExisting.next() : null;
                            }

                            FoldInfo newNew = itNew.hasNext() ? itNew.next() : null;

                            // XXX: In some situations infos contains duplicate folds and we don't
                            // want to add the same multiple times. The situation that I came across
                            // was with having an empty enum subclass with javadoc. The javadoc fold
                            // was added twice - once from visitClass and second time from visitMethod
                            // for the <init> node, which for some reason has the same offset as the
                            // the enum inner class.
                            while (newNew != null && currentNew.compareTo(newNew) == 0) {
                                newNew = itNew.hasNext() ? itNew.next() : null;
                            }

                            currentNew = newNew;
                        }
                    }
                    
                    currentFolds = updatedFolds;
                } catch (BadLocationException e) {
                    Exceptions.printStackTrace(e);
                } finally {
                    tr.commit();
                }
                if (imports != null) {
                    importsFold = folds.get(imports);
                } else {
                    importsFold = null;
                }
            } catch (BadLocationException e) {
                Exceptions.printStackTrace(e);
            } finally {
                operation.getHierarchy().unlock();
            }

    }

    //@GuardedBy(FoldOperation.openTransaction())
    private List<Fold> currentFolds; //in natural order
    private Fold initialCommentFold;
    private Fold importsFold;
    
    private static final class JavaElementFoldVisitor extends CancellableTreePathScanner<Object, Object> {
        
        private List<FoldInfo> folds = new ArrayList<FoldInfo>();
        private CompilationInfo info;
        private CompilationUnitTree cu;
        private SourcePositions sp;
        private boolean stopped;
        private int initialCommentStopPos = Integer.MAX_VALUE;
        private Document doc;
        private FoldInfo    initialCommentInfo;
        private FoldInfo    importsInfo;
        
        public JavaElementFoldVisitor(CompilationInfo info, CompilationUnitTree cu, SourcePositions sp, Document doc) {
            this.info = info;
            this.cu = cu;
            this.sp = sp;
            this.doc = doc;
            this.presets = presets;
        }
        
        public void checkInitialFold() {

                    
                    if (token.id() == JavaTokenId.BLOCK_COMMENT || token.id() == JavaTokenId.JAVADOC_COMMENT) {
                        int startOffset = ts.offset();
                        folds.add(initialCommentInfo = FoldInfo.range(startOffset, startOffset + token.length(), INITIAL_COMMENT_FOLD_TYPE));

                        /*
                        if (initialCommentFold != null) {
                            collapsed = initialCommentFold.isCollapsed();
                        }
                        */
                        
                        folds.add(new FoldInfo(doc, startOffset, startOffset + token.length(), INITIAL_COMMENT_FOLD_TEMPLATE, collapsed));
                        break;
                    }
                }
            } catch (BadLocationException e) {
                //the document probably changed, stop
                stopped = true;
            } catch (ConcurrentModificationException e) {
                //from TokenSequence, document probably changed, stop
                stopped = true;

                
                if (token.id() == JavaTokenId.JAVADOC_COMMENT) {
                    int startOffset = ts.offset();
                    folds.add(FoldInfo.range(startOffset, startOffset + token.length(), JAVADOC_FOLD_TYPE));
                    if (startOffset < initialCommentStopPos)
                        initialCommentStopPos = startOffset;
                }

                    int start = (int)sp.getStartPosition(cu, node);
                    int end   = (int)sp.getEndPosition(cu, node);
                    
                    if (start != (-1) && end != (-1)) {
                        folds.add(FoldInfo.range(start, end, CODE_BLOCK_FOLD_TYPE));
                    }
                }
                
                handleJavadoc(javadocTree != null ? javadocTree : node);

                    int start = Utilities.findBodyStart(node, cu, sp, doc);
                    int end   = (int)sp.getEndPosition(cu, node);
                    
                    if (start != (-1) && end != (-1)) {
                        folds.add(FoldInfo.range(start, end, INNERCLASS_TYPE));
		      }
                }
                
                handleJavadoc(node);

            }
            
            if (importsEnd != (-1) && importsStart != (-1)) {
                if (importsStart < initialCommentStopPos) {
                    initialCommentStopPos = importsStart;
                }
                importsStart += 7/*"import ".length()*/;

                if (importsStart < importsEnd) {
                    folds.add(importsInfo = FoldInfo.range(importsStart , importsEnd, IMPORTS_FOLD_TYPE));
                    if (importsFold != null) {
                        collapsed = importsFold.isCollapsed();
                    }
                    */
                    
                    importsStart += 7/*"import ".length()*/;
                    
                    if (importsStart < importsEnd) {
                        folds.add(new FoldInfo(doc, importsStart , importsEnd, IMPORTS_FOLD_TEMPLATE, collapsed));
                    }
                } catch (BadLocationException e) {
                    //the document probably changed, stop
                    stopped = true;
                }
            }
            return super.visitCompilationUnit(node, p);
        }

    }
    
    protected static final class FoldInfo implements Comparable {
        
        private final Position start;
        private final Position end;
        private final FoldTemplate template;
        private final boolean collapseByDefault;
        //@GUardedBy(FoldOperation.openTransaction())
        
        public FoldInfo(Document doc, int start, int end, FoldTemplate template, boolean collapseByDefault) throws BadLocationException {
            this.start = doc.createPosition(start);
            this.end   = doc.createPosition(end);
            this.template = template;
            this.collapseByDefault = collapseByDefault;
        }
        
        public int compareTo(Fold remote) {
            if (start.getOffset() < remote.getStartOffset()) {
                return -1;
            }
            
            if (start.getOffset() > remote.getStartOffset()) {
                return 1;
            }
            
            if (end.getOffset() < remote.getEndOffset()) {
                return -1;
            }
            
            if (end.getOffset() > remote.getEndOffset()) {
                return 1;
            }
            
            //XXX: abusing the length of the fold description to implement ordering (the exact order does not matter in this case):
            return template.getDescription().length() - remote.getDescription().length();
        }
        
        public int compareTo(Object o) {
            if (o instanceof Fold) {
                return compareTo((Fold)o);
            }
            FoldInfo remote = (FoldInfo) o;
            
            if (start.getOffset() < remote.start.getOffset()) {
                return -1;
            }
            
            if (start.getOffset() > remote.start.getOffset()) {
                return 1;
            }
            
            if (end.getOffset() < remote.end.getOffset()) {
                return -1;
            }
            
            if (end.getOffset() > remote.end.getOffset()) {
                return 1;
            }
            
            //XXX: abusing the length of the fold description to implement ordering (the exact order does not matter in this case):
            return template.getDescription().length() - remote.template.getDescription().length();
        }

        @Override
        public String toString() {
            return "FoldInfo[" + start.getOffset() + ", " + end.getOffset() + ", " + template.getDescription() + "]";
        }
    }
    
}




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

import java.util.ArrayList;
import java.util.Collection;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.editor.ext.java.JavaFoldManager;
import org.netbeans.spi.editor.fold.FoldTypeProvider;

/**
 *
 * @author sdedic
 */
@MimeRegistration(mimeType = "text/x-java", service = FoldTypeProvider.class)
public class JavaFoldTypeProvider implements FoldTypeProvider {
    private Collection<FoldType>   types = new ArrayList<FoldType>(5);

    public JavaFoldTypeProvider() {
        types.add(JavaFoldManager.CODE_BLOCK_FOLD_TYPE);
        types.add(JavaFoldManager.INNERCLASS_TYPE);
        types.add(JavaFoldManager.IMPORTS_FOLD_TYPE);
        types.add(JavaFoldManager.JAVADOC_FOLD_TYPE);
        types.add(JavaFoldManager.INITIAL_COMMENT_FOLD_TYPE);
    }
    
    
    @Override
    public Collection getValues(Class type) {
        return types;
    }

    @Override
    public boolean inheritable() {
        return false;
    }
    
}




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

import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.fold.FoldUtilities;
import org.netbeans.api.editor.fold.FoldingSupport;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.spi.editor.fold.ContentReader;

/**
 *
 * @author sdedic
 */
@MimeRegistration(mimeType = "text/x-java", service = ContentReader.Factory.class)
public class JavadocReaderFactory implements ContentReader.Factory {
    @Override
    public ContentReader createReader(FoldType ft) {
        if (ft == JavaElementFoldManager.JAVADOC_FOLD_TYPE) {
            return FoldingSupport.contentReader("*", "\\.", "@", null);
        } else {
            return null;
        }
    }
}




                </folder>
                
                <folder name="SideBar">
                </folder>
                        <attr name="position" intvalue="1500"/>
                    </file>
                    </folder>
                
                <folder name="FoldManager">
                    <file name="CustomFoldManager.instance">
                        <attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.FoldManagerFactory"/>
                        <attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.userFoldManagerFactory"/>
                    </file>
                    <file name="org-netbeans-modules-java-editor-fold-JavaElementFoldManagerFactory.instance"/>
                </folder>
                

Lines 2-7 Link Here

(-)a/options.editor/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.options.editor/1	2	OpenIDE-Module: org.netbeans.modules.options.editor/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/options/editor/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/options/editor/Bundle.properties
4	OpenIDE-Module-Layer: org/netbeans/modules/options/editor/mf-layer.xml	4	OpenIDE-Module-Layer: org/netbeans/modules/options/editor/mf-layer.xml
5	OpenIDE-Module-Specification-Version: 1.39	5	OpenIDE-Module-Specification-Version: 1.40
6	AutoUpdate-Show-In-Client: false	6	AutoUpdate-Show-In-Client: false
7		7




          <Group type="102" attributes="0">
              <Group type="103" groupAlignment="0" attributes="0">
                  <Group type="102" alignment="0" attributes="0">
                      <EmptySpace min="-2" pref="163" max="-2" attributes="0"/>
                      <Component id="lCollapseByDefault" min="-2" max="-2" attributes="0"/>
                      <EmptySpace max="-2" attributes="0"/>
                      <Group type="103" groupAlignment="0" attributes="0">
                          <Component id="cbUseCodeFolding" alignment="0" min="-2" max="-2" attributes="0"/>
                          <Group type="102" alignment="0" attributes="0">
                              <EmptySpace min="-2" pref="175" max="-2" attributes="0"/>
                              <Component id="cbBraceTooltip" min="-2" max="-2" attributes="0"/>
                                  <Component id="cbFoldInnerClasses" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
                                  <Component id="cbFoldImports" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
                              </Group>
                              <EmptySpace type="separate" max="-2" attributes="0"/>
                              <Group type="103" groupAlignment="0" attributes="0">
                                  <Component id="cbFoldJavadocComments" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
                                  <Component id="cbFoldInitialComments" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
                                  <Component id="cbFoldTags" alignment="0" min="-2" max="-2" attributes="0"/>
                                  <Component id="cbBraceTooltip" min="-2" max="-2" attributes="0"/>
                              </Group>
                          </Group>
                          <Component id="cbCamelCaseBehavior" alignment="0" min="-2" max="-2" attributes="0"/>
                          <Group type="102" attributes="0">

                              <Component id="lCamelCaseBehaviorExample" min="-2" max="-2" attributes="0"/>
                          </Group>
                      </Group>
                      <EmptySpace min="-2" pref="26" max="-2" attributes="0"/>
                  <Group type="102" alignment="0" attributes="0">
                      <EmptySpace min="12" pref="12" max="-2" attributes="0"/>
                      <Component id="lUseCodeFolding" min="-2" max="-2" attributes="0"/>
                  </Group>
                  <Group type="102" alignment="0" attributes="0">
                      <EmptySpace max="-2" attributes="0"/>

              <EmptySpace min="0" pref="12" max="32767" attributes="0"/>
          </Group>
          <Group type="102" attributes="0">
              <Component id="lCodeFolding" min="-2" max="-2" attributes="0"/>
              <EmptySpace max="-2" attributes="0"/>
              <Component id="jSeparator1" max="32767" attributes="0"/>
          </Group>
          <Group type="102" attributes="0">
              <Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>
              <EmptySpace max="-2" attributes="0"/>
              <Component id="jSeparator6" max="32767" attributes="0"/>

    <DimensionLayout dim="1">
      <Group type="103" groupAlignment="0" attributes="0">
          <Group type="102" alignment="0" attributes="0">
              <EmptySpace min="-2" max="-2" attributes="0"/>
              <Group type="103" groupAlignment="1" attributes="0">
                  <Component id="lCodeFolding" min="-2" max="-2" attributes="1"/>
                  <Component id="jSeparator1" min="-2" pref="10" max="-2" attributes="0"/>
              </Group>
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="0" attributes="0">
                  <Component id="cbUseCodeFolding" alignment="0" min="-2" max="-2" attributes="0"/>
                  <Component id="lUseCodeFolding" min="-2" max="-2" attributes="0"/>
              </Group>
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="3" attributes="0">
                  <Component id="lCollapseByDefault" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="cbFoldMethods" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="cbFoldJavadocComments" alignment="3" min="-2" max="-2" attributes="0"/>
              </Group>
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="3" attributes="0">
                  <Component id="cbFoldInnerClasses" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="cbFoldInitialComments" alignment="3" min="-2" max="-2" attributes="0"/>
              </Group>
              <EmptySpace max="-2" attributes="0"/>
              <Group type="103" groupAlignment="3" attributes="0">
                  <Component id="cbFoldImports" alignment="3" min="-2" max="-2" attributes="0"/>
                  <Component id="cbFoldTags" alignment="3" min="-2" max="-2" attributes="0"/>
              </Group>
              <EmptySpace type="separate" max="-2" attributes="0"/>
              <Group type="103" groupAlignment="1" attributes="0">
                  <Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>
                  <Component id="jSeparator6" min="-2" pref="10" max="-2" attributes="0"/>

              </Group>
              <EmptySpace max="-2" attributes="0"/>
              <Component id="lSearchtypeTooltip" min="-2" max="-2" attributes="0"/>
              <EmptySpace min="0" pref="12" max="32767" attributes="0"/>
          </Group>
      </Group>
    </DimensionLayout>
  </Layout>
  <SubComponents>
    <Component class="javax.swing.JLabel" name="lCodeFolding">
      <Properties>
        <Property name="text" type="java.lang.String" value="Code Folding"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JLabel" name="lUseCodeFolding">
      <Properties>
        <Property name="labelFor" type="java.awt.Component" editor="org.netbeans.modules.form.ComponentChooserEditor">
          <ComponentRef name="cbUseCodeFolding"/>
        </Property>
        <Property name="text" type="java.lang.String" value="Use Code Folding:"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JLabel" name="lCollapseByDefault">
      <Properties>
        <Property name="text" type="java.lang.String" value="Collapse by Default:"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbUseCodeFolding">
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldMethods">
      <Properties>
        <Property name="text" type="java.lang.String" value="Methods"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldInnerClasses">
      <Properties>
        <Property name="text" type="java.lang.String" value="Inner Classes"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldImports">
      <Properties>
        <Property name="text" type="java.lang.String" value="Imports"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldJavadocComments">
      <Properties>
        <Property name="text" type="java.lang.String" value="Javadoc Comments"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldInitialComments">
      <Properties>
        <Property name="text" type="java.lang.String" value="Initial Comments"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JCheckBox" name="cbFoldTags">
      <Properties>
        <Property name="text" type="java.lang.String" value="Tags and Other Code Blocks"/>
      </Properties>
    </Component>
    <Component class="javax.swing.JSeparator" name="jSeparator1">
    </Component>
    <Component class="javax.swing.JLabel" name="lBracesMatching">
      <Properties>
        <Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">




    public GeneralEditorPanel () {
        initComponents ();

        loc (lCodeFolding, "Code_Folding");
        loc (lUseCodeFolding, "Code_Folding_Section");
        loc (lCollapseByDefault, "Fold_by_Default");
            
        loc (cbUseCodeFolding, "Use_Folding");
        loc (cbFoldMethods, "Fold_Methods");
        loc (cbFoldInnerClasses, "Fold_Classes");
        loc (cbFoldImports, "Fold_Imports");
        loc (cbFoldJavadocComments, "Fold_JavaDoc");
        loc (cbFoldInitialComments, "Fold_Licence");
        loc (cbFoldTags, "Fold_Tags");

        loc (lCamelCaseBehavior, "Camel_Case_Behavior");
        loc (cbCamelCaseBehavior, "Enable_Camel_Case_In_Java");
        loc (lCamelCaseBehaviorExample, "Camel_Case_Behavior_Example");

        loc (cbBraceTooltip, "Brace_First_Tooltip");
        loc (cbShowBraceOutline, "Brace_Show_Outline");
                
        cbUseCodeFolding.setMnemonic(NbBundle.getMessage (GeneralEditorPanel.class, "MNEMONIC_Use_Folding").charAt(0));
        cboEditorSearchType.setRenderer(new EditorSearchTypeRenderer(cboEditorSearchType.getRenderer()));
        cboEditorSearchType.setModel(new DefaultComboBoxModel(new Object [] { "default", "closing"})); //NOI18N
        cboEditorSearchType.addActionListener( new ActionListener() {

    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        lCodeFolding = new javax.swing.JLabel();
        lUseCodeFolding = new javax.swing.JLabel();
        lCollapseByDefault = new javax.swing.JLabel();
        cbUseCodeFolding = new javax.swing.JCheckBox();
        cbFoldMethods = new javax.swing.JCheckBox();
        cbFoldInnerClasses = new javax.swing.JCheckBox();
        cbFoldImports = new javax.swing.JCheckBox();
        cbFoldJavadocComments = new javax.swing.JCheckBox();
        cbFoldInitialComments = new javax.swing.JCheckBox();
        cbFoldTags = new javax.swing.JCheckBox();
        jSeparator1 = new javax.swing.JSeparator();
        lBracesMatching = new javax.swing.JLabel();
        cbShowBraceOutline = new javax.swing.JCheckBox();
        cbBraceTooltip = new javax.swing.JCheckBox();


        setForeground(new java.awt.Color(99, 130, 191));

        lCodeFolding.setText("Code Folding");

        lUseCodeFolding.setLabelFor(cbUseCodeFolding);
        lUseCodeFolding.setText("Use Code Folding:");

        lCollapseByDefault.setText("Collapse by Default:");

        cbFoldMethods.setText("Methods");

        cbFoldInnerClasses.setText("Inner Classes");

        cbFoldImports.setText("Imports");

        cbFoldJavadocComments.setText("Javadoc Comments");

        cbFoldInitialComments.setText("Initial Comments");

        cbFoldTags.setText("Tags and Other Code Blocks");

        lBracesMatching.setText(org.openide.util.NbBundle.getMessage(GeneralEditorPanel.class, "BRACES_MATCHING")); // NOI18N

        cbShowBraceOutline.setText("Show outline");

            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(163, 163, 163)
                        .addComponent(lCollapseByDefault)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(cbUseCodeFolding)
                            .addGroup(layout.createSequentialGroup()
                                .addGap(175, 175, 175)
                                .addComponent(cbBraceTooltip))
                                    .addComponent(cbFoldInnerClasses)
                                    .addComponent(cbFoldImports))
                                .addGap(18, 18, 18)
                                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                                    .addComponent(cbFoldJavadocComments)
                                    .addComponent(cbFoldInitialComments)
                                    .addComponent(cbFoldTags)
                                    .addComponent(cbBraceTooltip)))
                            .addComponent(cbCamelCaseBehavior)
                            .addGroup(layout.createSequentialGroup()
                                .addGap(21, 21, 21)
                                .addComponent(lCamelCaseBehaviorExample, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)))
                        .addGap(26, 26, 26))
                        .addGap(12, 12, 12)
                        .addComponent(lUseCodeFolding))
                    .addGroup(layout.createSequentialGroup()
                        .addContainerGap()
                        .addComponent(lEditorSearchType)

                            .addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addGap(0, 12, Short.MAX_VALUE))
            .addGroup(layout.createSequentialGroup()
                .addComponent(lCodeFolding)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jSeparator1))
            .addGroup(layout.createSequentialGroup()
                .addComponent(lBracesMatching)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jSeparator6))

                        .addGap(0, 0, Short.MAX_VALUE))
                    .addComponent(jSeparator3)))
        );

        layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {cbFoldImports, cbFoldInitialComments, cbFoldInnerClasses, cbFoldJavadocComments, cbFoldMethods});

        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(lCodeFolding)
                    .addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(cbUseCodeFolding)
                    .addComponent(lUseCodeFolding))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(lCollapseByDefault)
                    .addComponent(cbFoldMethods)
                    .addComponent(cbFoldJavadocComments))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(cbFoldInnerClasses)
                    .addComponent(cbFoldInitialComments))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(cbFoldImports)
                    .addComponent(cbFoldTags))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(lBracesMatching)
                    .addComponent(jSeparator6, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))

                    .addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(lSearchtypeTooltip, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 12, Short.MAX_VALUE))
        );
    }// </editor-fold>//GEN-END:initComponents
    

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JCheckBox cbBraceTooltip;
    private javax.swing.JCheckBox cbCamelCaseBehavior;
    private javax.swing.JCheckBox cbFoldImports;
    private javax.swing.JCheckBox cbFoldInitialComments;
    private javax.swing.JCheckBox cbFoldInnerClasses;
    private javax.swing.JCheckBox cbFoldJavadocComments;
    private javax.swing.JCheckBox cbFoldMethods;
    private javax.swing.JCheckBox cbFoldTags;
    private javax.swing.JCheckBox cbShowBraceOutline;
    private javax.swing.JCheckBox cbUseCodeFolding;
    private javax.swing.JComboBox cboEditorSearchType;
    private javax.swing.JSeparator jSeparator1;
    private javax.swing.JSeparator jSeparator3;
    private javax.swing.JSeparator jSeparator5;
    private javax.swing.JSeparator jSeparator6;
    private javax.swing.JLabel lBracesMatching;
    private javax.swing.JLabel lCamelCaseBehavior;
    private javax.swing.JLabel lCamelCaseBehaviorExample;
    private javax.swing.JLabel lCodeFolding;
    private javax.swing.JLabel lCollapseByDefault;
    private javax.swing.JLabel lEditorSearchType;
    private javax.swing.JLabel lSearch;
    private javax.swing.JLabel lSearchtypeTooltip;
    private javax.swing.JLabel lUseCodeFolding;
    // End of variables declaration//GEN-END:variables
    
    

        listen = false;
        if (model == null) {
            model = new Model ();
            cbUseCodeFolding.addActionListener (this);
            cbFoldMethods.addActionListener (this);
            cbFoldInnerClasses.addActionListener (this);
            cbFoldImports.addActionListener (this);
            cbFoldJavadocComments.addActionListener (this);
            cbFoldInitialComments.addActionListener (this);
            cbCamelCaseBehavior.addActionListener (this);
            cbFoldTags.addActionListener (this);
            cboEditorSearchType.addActionListener(this);
            cbBraceTooltip.addActionListener(this);
            cbShowBraceOutline.addActionListener(this);
        }
        
        // init code folding
        cbUseCodeFolding.setSelected (model.isShowCodeFolding ());
        cbFoldImports.setSelected (model.isFoldImports ());
        cbFoldInitialComments.setSelected (model.isFoldInitialComment ());
        cbFoldInnerClasses.setSelected (model.isFoldInnerClasses ());
        cbFoldJavadocComments.setSelected (model.isFoldJavaDocComments ());
        cbFoldMethods.setSelected (model.isFoldMethods ());
        cbFoldTags.setSelected (model.isFoldTag());

        // Java Camel Case Navigation
        Boolean ccJava = model.isCamelCaseJavaNavigation();
        if ( ccJava == null ) {

        cbBraceTooltip.setSelected(model.isBraceTooltip());
        cbShowBraceOutline.setSelected(model.isBraceOutline());

        updateEnabledState ();
        
        listen = true;
    }
    

        
        if (model == null || !changed) return;
        
        // code folding options
        model.setFoldingOptions (
            cbUseCodeFolding.isSelected (),
            cbFoldImports.isSelected (),
            cbFoldInitialComments.isSelected (),
            cbFoldInnerClasses.isSelected (),
            cbFoldJavadocComments.isSelected (),
            cbFoldMethods.isSelected (),
            cbFoldTags.isSelected ()
        );
        
        // java camel case navigation
        model.setCamelCaseNavigation(cbCamelCaseBehavior.isSelected());
        

    @Override
    public void actionPerformed (ActionEvent e) {
        if (!listen) return;
        if (e.getSource () == cbUseCodeFolding) {
            updateEnabledState ();
        }
        changed = true;
    }
    
    
    // other methods ...........................................................
    
    private void updateEnabledState () {
        boolean useCodeFolding = cbUseCodeFolding.isSelected ();
        cbFoldImports.setEnabled (useCodeFolding);
        cbFoldInitialComments.setEnabled (useCodeFolding);
        cbFoldInnerClasses.setEnabled (useCodeFolding);
        cbFoldJavadocComments.setEnabled (useCodeFolding);
        cbFoldMethods.setEnabled (useCodeFolding);
        cbFoldTags.setEnabled(useCodeFolding);
    }

    private static final class EditorSearchTypeRenderer implements ListCellRenderer {

        private final ListCellRenderer defaultRenderer;





import java.io.IOException;
import java.io.OutputStream;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.BackingStoreException;
import java.util.prefs.NodeChangeEvent;
import java.util.prefs.NodeChangeListener;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import java.util.prefs.Preferences;
import org.netbeans.modules.editor.settings.storage.api.MemoryPreferences;
import org.netbeans.modules.editor.settings.storage.spi.TypedValue;
import org.openide.util.WeakListeners;

/**
 * This class has been obsoleted by {@link MemoryPreferences}
 * 
 * @author vita
 * @deprecated Please use {@link MemoryPreferences} API instead
 */
public final class ProxyPreferences extends Preferences implements PreferenceChangeListener, NodeChangeListener {
    
    private final MemoryPreferences delegateRoot;
    private Preferences       delegate;
    private boolean noEvents;
    
    public static ProxyPreferences getProxyPreferences(Object token, Preferences delegate) {
        return new ProxyPreferences(null, MemoryPreferences.get(token, delegate), null);
    }

    public void silence() {
        synchronized (delegate) {
            this.noEvents = true;
        }
    }

    public void destroy() {
        delegateRoot.destroy();
    }

    @Override
    public void put(String key, String value) {
        delegate.put(key, value);
    }

    @Override
    public String get(String key, String def) {
        return delegate.get(key, def);
    }

    @Override
    public void remove(String key) {
        delegate.remove(key);
    }

    @Override
    public void clear() throws BackingStoreException {
        delegate.clear();
    }

    @Override
    public void putInt(String key, int value) {
        delegate.putInt(key, value);
    }

    @Override
    public int getInt(String key, int def) {
        return delegate.getInt(key, def);
    }

    @Override
    public void putLong(String key, long value) {
        delegate.putLong(key, value);
    }

    @Override
    public long getLong(String key, long def) {
        return delegate.getLong(key, def);
    }

    @Override
    public void putBoolean(String key, boolean value) {
        delegate.putBoolean(key, value);
    }

    @Override
    public boolean getBoolean(String key, boolean def) {
        return delegate.getBoolean(key, def);
    }

    @Override
    public void putFloat(String key, float value) {
        delegate.putFloat(key, value);
    }

    @Override
    public float getFloat(String key, float def) {
        return delegate.getFloat(key, def);
    }

    @Override
    public void putDouble(String key, double value) {
        delegate.putDouble(key, value);
    }

    @Override
    public double getDouble(String key, double def) {
        return delegate.getDouble(key, def);
    }

    @Override
    public void putByteArray(String key, byte[] value) {
        delegate.putByteArray(key, value);
    }

    @Override
    public byte[] getByteArray(String key, byte[] def) {
        return delegate.getByteArray(key, def);
    }

    @Override
    public String[] keys() throws BackingStoreException {
        return delegate.keys();
    }

    @Override
    public String[] childrenNames() throws BackingStoreException {
        return delegate.childrenNames();
    }

    @Override
    public Preferences parent() {
        return parent;
    }

    @Override
    public Preferences node(String pathName) {
        synchronized (this) {
            Preferences pref = children.get(pathName);
            if (pref != null) {
                return pref;
            }
        }
        Preferences pref = delegate.node(pathName);
        ProxyPreferences result;
        
        synchronized (this) {
            result = children.get(pathName);
            if (result != null) {
                return result;
            }
            result = new ProxyPreferences(this, delegateRoot, pref);
            children.put(pathName, result);
            return result;
        }
    }

    @Override
    public void remove(String key) {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = null;
        
        synchronized (tree.treeLock()) {
            checkNotNull(key, "key"); //NOI18N
            checkRemoved();
            
            if (removedKeys.add(key)) {
                data.remove(key);
                bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
                bag.addListeners(prefListeners);
                bag.addEvent(new PreferenceChangeEvent(this, key, null));
            }
        }

        if (bag != null) {
            firePrefEvents(Collections.singletonList(bag));
        }
    }

    @Override
    public void clear() throws BackingStoreException {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
        
        synchronized (tree.treeLock()) {
            checkRemoved();

            // Determine modified or added keys
            Set<String> keys = new HashSet<String>();
            keys.addAll(data.keySet());
            keys.removeAll(removedKeys);
            if (!keys.isEmpty()) {
                for(String key : keys) {
                    String value = delegate == null ? null : delegate.get(key, null);
                    bag.addEvent(new PreferenceChangeEvent(this, key, value));
                }
            }

            // Determine removed keys
            if (delegate != null) {
                for(String key : removedKeys) {
                    String value = delegate.get(key, null);
                    if (value != null) {
                        bag.addEvent(new PreferenceChangeEvent(this, key, value));
                    }
                }
            }

            // Initialize bag's listeners
            bag.addListeners(prefListeners);

            // Finally, remove the data
            data.clear();
            removedKeys.clear();
        }
        
        firePrefEvents(Collections.singletonList(bag));
    }

    @Override
    public void putInt(String key, int value) {
        _put(key, Integer.toString(value), Integer.class.getName());
    }

    @Override
    public int getInt(String key, int def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Integer.parseInt(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putLong(String key, long value) {
        _put(key, Long.toString(value), Long.class.getName());
    }

    @Override
    public long getLong(String key, long def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Long.parseLong(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putBoolean(String key, boolean value) {
        _put(key, Boolean.toString(value), Boolean.class.getName());
    }

    @Override
    public boolean getBoolean(String key, boolean def) {
        String value = get(key, null);
        if (value != null) {
            return Boolean.parseBoolean(value);
        } else {
            return def;
        }
    }

    @Override
    public void putFloat(String key, float value) {
        _put(key, Float.toString(value), Float.class.getName());
    }

    @Override
    public float getFloat(String key, float def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Float.parseFloat(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putDouble(String key, double value) {
        _put(key, Double.toString(value), Double.class.getName());
    }

    @Override
    public double getDouble(String key, double def) {
        String value = get(key, null);
        if (value != null) {
            try {
                return Double.parseDouble(value);
            } catch (NumberFormatException nfe) {
                // ignore
            }
        }
        return def;
    }

    @Override
    public void putByteArray(String key, byte[] value) {
        _put(key, DatatypeConverter.printBase64Binary(value), value.getClass().getName());
    }

    @Override
    public byte[] getByteArray(String key, byte[] def) {
        String value = get(key, null);
        if (value != null) {
            byte [] decoded = DatatypeConverter.parseBase64Binary(value);
            if (decoded != null) {
                return decoded;
            }
        }
        return def;
    }

    @Override
    public String[] keys() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            checkRemoved();
            HashSet<String> keys = new HashSet<String>();
            if (delegate != null) {
                keys.addAll(Arrays.asList(delegate.keys()));
            }
            keys.addAll(data.keySet());
            keys.removeAll(removedKeys);
            return keys.toArray(new String [keys.size()]);
        }
    }

    @Override
    public String[] childrenNames() throws BackingStoreException {
        synchronized (tree.treeLock()) {
            checkRemoved();
            HashSet<String> names = new HashSet<String>();
            if (delegate != null) {
                names.addAll(Arrays.asList(delegate.childrenNames()));
            }
            names.addAll(children.keySet());
            names.removeAll(removedChildren);
            return names.toArray(new String [names.size()]);
        }
    }

    @Override
    public Preferences parent() {
        synchronized (tree.treeLock()) {
            checkRemoved();
            return parent;
        }
    }

    @Override
    public Preferences node(String pathName) {
        Preferences node;
        LinkedList<EventBag<NodeChangeListener, NodeChangeEvent>> events = new LinkedList<EventBag<NodeChangeListener, NodeChangeEvent>>();

        synchronized (tree.treeLock()) {
            checkNotNull(pathName, "pathName"); //NOI18N
            checkRemoved();
            node = node(pathName, true, events);
        }

        fireNodeEvents(events);
        return node;
    }

    @Override
    public boolean nodeExists(String pathName) throws BackingStoreException {
        return delegate.nodeExists(pathName);
            if (pathName.length() == 0) {
                return !removed;
            } else {
                checkRemoved();
                return node(pathName, false, null) != null;
            }
        }
    }

    @Override
    public void removeNode() throws BackingStoreException {
        delegate.removeNode();
        if (parent != null) {
            parent.nodeRemoved(this);
            if (p != null) {
                p.removeChild(this);
            } else {
                throw new UnsupportedOperationException("Can't remove the root."); //NOI18N
            }
        }
    }

    @Override
    public String name() {
        return delegate.name();
    }

    @Override
    public String absolutePath() {
        return delegate.absolutePath();
            ProxyPreferences pp = parent;
            if (pp != null) {
                if (pp.parent == null) {
                    // pp is the root, we don't want two consecutive slashes in the path
                    return "/" + name(); //NOI18N
                } else {
                    return pp.absolutePath() + "/" + name(); //NOI18N
                }
            } else {
                return "/"; //NOI18N
            }
        }
    }

    @Override
    public boolean isUserNode() {
        return delegate.isUserNode();
            if (delegate != null) {
                return delegate.isUserNode();
            } else {
                ProxyPreferences pp = parent;
                if (pp != null) {
                    return pp.isUserNode();
                } else {
                    return true;
                }
            }
        }
    }

    @Override
    public String toString() {
        return delegate.toString();
    }

    @Override
    public void flush() throws BackingStoreException {
        delegate.flush();
            if (LOG.isLoggable(Level.FINE)) {
                LOG.fine("Flushing " + absolutePath());
            }

            checkRemoved();
            for(ProxyPreferences pp : children.values()) {
                pp.flush();
            }

            if (delegate == null) {
                ProxyPreferences proxyRoot = parent.node("/", false, null); //NOI18N
                assert proxyRoot != null : "Root must always exist"; //NOI18N

                Preferences delegateRoot = proxyRoot.delegate;
                assert delegateRoot != null : "Root must always have its corresponding delegate"; //NOI18N

                Preferences nueDelegate = delegateRoot.node(absolutePath());
                changeDelegate(nueDelegate);
            }

            delegate.removeNodeChangeListener(weakNodeListener);
            delegate.removePreferenceChangeListener(weakPrefListener);
            try {
                // remove all removed children
                for(String childName : removedChildren) {
                    if (delegate.nodeExists(childName)) {
                        delegate.node(childName).removeNode();
                    }
                }

                // write all valid key-value pairs
                for(String key : data.keySet()) {
                    if (!removedKeys.contains(key)) {
                        if (LOG.isLoggable(Level.FINE)) {
                            LOG.fine("Writing " + absolutePath() + "/" + key + "=" + data.get(key));
                        }
                        
                        TypedValue typedValue = data.get(key);
                        if (String.class.getName().equals(typedValue.getJavaType())) {
                            delegate.put(key, typedValue.getValue());

                        } else if (Integer.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putInt(key, Integer.parseInt(typedValue.getValue()));

                        } else if (Long.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putLong(key, Long.parseLong(typedValue.getValue()));

                        } else if (Boolean.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putBoolean(key, Boolean.parseBoolean(typedValue.getValue()));

                        } else if (Float.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putFloat(key, Float.parseFloat(typedValue.getValue()));

                        } else if (Double.class.getName().equals(typedValue.getJavaType())) {
                            delegate.putDouble(key, Double.parseDouble(typedValue.getValue()));

                        } else {
                            delegate.putByteArray(key, DatatypeConverter.parseBase64Binary(typedValue.getValue()));
                        }
                    }
                }
                data.clear();

                // remove all removed keys
                for(String key : removedKeys) {
                    if (LOG.isLoggable(Level.FINE)) {
                        LOG.fine("Removing " + absolutePath() + "/" + key);
                    }
                    delegate.remove(key);
                }
                removedKeys.clear();
            } finally {
                delegate.addNodeChangeListener(weakNodeListener);
                delegate.addPreferenceChangeListener(weakPrefListener);
            }
        }        
    }

    @Override
    public void sync() throws BackingStoreException {
        delegate.sync();
        ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>> nodeEvents = new ArrayList<EventBag<NodeChangeListener, NodeChangeEvent>>();

        synchronized (tree.treeLock()) {
            _sync(prefEvents, nodeEvents);
        }

        fireNodeEvents(nodeEvents);
        firePrefEvents(prefEvents);
    }
    
    @Override
    public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
        synchronized (this) {
            prefListeners.add(pcl);
        }
    }

    @Override
    public void removePreferenceChangeListener(PreferenceChangeListener pcl) {
        synchronized (this) {
            prefListeners.remove(pcl);
        }
    }

    @Override
    public void addNodeChangeListener(NodeChangeListener ncl) {
        synchronized (this) {
            nodeListeners.add(ncl);
        }
    }

    @Override
    public void removeNodeChangeListener(NodeChangeListener ncl) {
        synchronized (this) {
            nodeListeners.remove(ncl);
        }
    }


    public void preferenceChange(PreferenceChangeEvent evt) {
        PreferenceChangeListener [] listeners;
        synchronized (this) {
            if (!noEvents) {
                return;
            }

            listeners = prefListeners.toArray(new PreferenceChangeListener[prefListeners.size()]);
        }


            l.preferenceChange(myEvt);
        }
    }
    
    private synchronized void changeDelegate(Preferences del) {
        this.delegate = del;
    }
    
    private synchronized void nodeRemoved(ProxyPreferences child) {
        children.values().remove(child);
    }

    // ------------------------------------------------------------------------
    // NodeChangeListener implementation

        NodeChangeListener [] listeners;
        Preferences childNode;

        synchronized (this) {
            String childName = evt.getChild().name();
            if (removed || removedChildren.contains(childName)) {
                return;
            }

            childNode = children.get(childName);
            if (childNode != null) {
                // swap delegates

            } else {
                childNode = node(evt.getChild().name());
            }
            if (!noEvents) {
                return;
            }
            listeners = nodeListeners.toArray(new NodeChangeListener[nodeListeners.size()]);
        }


        NodeChangeListener [] listeners;
        Preferences childNode;

        synchronized (this) {
            String childName = evt.getChild().name();
            if (removed || removedChildren.contains(childName)) {
                return;
            }

            childNode = children.get(childName);
            if (childNode == null) {
                // swap delegates
                ((ProxyPreferences) childNode).changeDelegate(null);
            } else {
                // nobody has accessed the child yet
                return;
            }
            
            if (!noEvents) {
                return;
            }
            listeners = nodeListeners.toArray(new NodeChangeListener[nodeListeners.size()]);
        }


        }
    }
    
    private final ProxyPreferences parent;
    private final Map<String, ProxyPreferences> children = new HashMap<String, ProxyPreferences>();
    // ------------------------------------------------------------------------

    /**
     * Destroys whole preferences tree as if called on the root.
     */
    public void destroy() {
        synchronized (tree.treeLock()) {
            tree.destroy();
        }
    }
    
    public void silence() {
        synchronized (tree.treeLock()) {
            noEvents = true;
        }
    }
    
    // ------------------------------------------------------------------------
    // private implementation
    // ------------------------------------------------------------------------

    private static final Logger LOG = Logger.getLogger(ProxyPreferences.class.getName());
    
    private final ProxyPreferences parent;
    private final String name;
    private Preferences delegate;
    private final Tree tree;
    private boolean removed;
    
    private final Map<String, TypedValue> data = new HashMap<String, TypedValue>();
    private final Set<String> removedKeys = new HashSet<String>();
    private final Map<String, ProxyPreferences> children = new HashMap<String, ProxyPreferences>();
    private final Set<String> removedChildren = new HashSet<String>();

    private boolean noEvents = false;
    private PreferenceChangeListener weakPrefListener;
    private final Set<PreferenceChangeListener> prefListeners = new HashSet<PreferenceChangeListener>();
    private NodeChangeListener weakNodeListener;
    private final Set<NodeChangeListener> nodeListeners = new HashSet<NodeChangeListener>();

    private ProxyPreferences(ProxyPreferences parent, MemoryPreferences memoryPref, Preferences delegate) {
        assert name != null;
        
        this.parent = parent;
        this.delegateRoot = memoryPref;
        this.delegate = delegate == null ? memoryPref.getPreferences() : delegate;
        weakPrefListener = WeakListeners.create(PreferenceChangeListener.class, this, delegate);
        this.delegate.addPreferenceChangeListener(weakPrefListener);
        weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
        this.delegate.addNodeChangeListener(weakNodeListener);
            delegate.addPreferenceChangeListener(weakPrefListener);
            
            weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
            delegate.addNodeChangeListener(weakNodeListener);
        }
        this.tree = tree;
    }

    private void _put(String key, String value, String javaType) {
        EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag = null;

        synchronized (tree.treeLock()) {
            checkNotNull(key, "key"); //NOI18N
            checkNotNull(value, "value"); //NOI18N
            checkRemoved();
            
            String orig = get(key, null);
            if (orig == null || !orig.equals(value)) {
                if (LOG.isLoggable(Level.FINE)) {
                    LOG.fine("Overwriting '" + key + "' = '" + value + "'"); //NOI18N
                }
                
                data.put(key, new TypedValue(value, javaType));
                removedKeys.remove(key);
                
                bag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
                bag.addListeners(prefListeners);
                bag.addEvent(new PreferenceChangeEvent(this, key, value));
            }
        }

        if (bag != null) {
            firePrefEvents(Collections.singletonList(bag));
        }
    }

    private ProxyPreferences node(String pathName, boolean create, List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
        if (pathName.length() > 0 && pathName.charAt(0) == '/') { //NOI18N
            // absolute path, if this is not the root then find the root
            // and pass the call to it
            if (parent != null) {
                Preferences root = this;
                while (root.parent() != null) {
                    root = root.parent();
                }
                return ((ProxyPreferences) root).node(pathName, create, events);
            } else {
                // this is the root, change the pathName to a relative path and proceed
                pathName = pathName.substring(1);
            }
        }

        if (pathName.length() > 0) {
            String childName;
            String pathFromChild;

            int idx = pathName.indexOf('/'); //NOI18N
            if (idx != -1) {
                childName = pathName.substring(0, idx);
                pathFromChild = pathName.substring(idx + 1);
            } else {
                childName = pathName;
                pathFromChild = null;
            }

            ProxyPreferences child = children.get(childName);
            if (child == null) {
                if (removedChildren.contains(childName) && !create) {
                    // this child has been removed
                    return null;
                }
                
                Preferences childDelegate = null;
                try {
                    if (delegate != null && delegate.nodeExists(childName)) {
                        childDelegate = delegate.node(childName);
                    }
                } catch (BackingStoreException bse) {
                    // ignore
                }

                if (childDelegate != null || create) {
                    child = tree.get(this, childName, childDelegate);
                    children.put(childName, child);
                    removedChildren.remove(childName);

                    // fire event if we really created the new child node
                    if (childDelegate == null) {
                        EventBag<NodeChangeListener, NodeChangeEvent> bag = new EventBag<NodeChangeListener, NodeChangeEvent>();
                        bag.addListeners(nodeListeners);
                        bag.addEvent(new NodeChangeEventExt(this, child, false));
                        events.add(bag);
                    }
                } else {
                    // childDelegate == null && !create
                    return null;
                }
            } else {
                assert !child.removed;
            }

            return pathFromChild != null ? child.node(pathFromChild, create, events) : child;
        } else {
            return this;
        }
    }

    private void addChild(ProxyPreferences child) {
        ProxyPreferences pp = children.get(child.name());
        if (pp == null) {
            children.put(child.name(), child);
        } else {
            assert pp == child;
        }
    }
    
    private void removeChild(ProxyPreferences child) {
        assert child != null;
        assert children.get(child.name()) == child;

        child.nodeRemoved();
        children.remove(child.name());
        removedChildren.add(child.name());
    }
    
    private void nodeRemoved() {
        for(ProxyPreferences pp : children.values()) {
            pp.nodeRemoved();
        }

        data.clear();
        removedKeys.clear();
        children.clear();
        removedChildren.clear();
        tree.removeNode(this);
        
        removed = true;
    }
    
    private void checkNotNull(Object paramValue, String paramName) {
        if (paramValue == null) {
            throw new NullPointerException("The " + paramName + " must not be null");
        }
    }

    private void checkRemoved() {
        if (removed) {
            throw new IllegalStateException("The node '" + this + " has already been removed."); //NOI18N
        }
    }

    private void changeDelegate(Preferences nueDelegate) {
        if (delegate != null) {
            try {
                if (delegate.nodeExists("")) { //NOI18N
                    assert weakPrefListener != null;
                    assert weakNodeListener != null;
                    delegate.removePreferenceChangeListener(weakPrefListener);
                    delegate.removeNodeChangeListener(weakNodeListener);
                }
            } catch (BackingStoreException bse) {
                LOG.log(Level.WARNING, null, bse);
            }
        }

        delegate = nueDelegate;
        weakPrefListener = null;
        weakNodeListener = null;
        
        if (delegate != null) {
            weakPrefListener = WeakListeners.create(PreferenceChangeListener.class, this, delegate);
            delegate.addPreferenceChangeListener(weakPrefListener);
            
            weakNodeListener = WeakListeners.create(NodeChangeListener.class, this, delegate);
            delegate.addNodeChangeListener(weakNodeListener);
        }
    }

    private void _sync(
        List<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> prefEvents, 
        List<EventBag<NodeChangeListener, NodeChangeEvent>> nodeEvents
    ) {
        // synchronize all children firts
        for(ProxyPreferences pp : children.values()) {
            pp._sync(prefEvents, nodeEvents);
        }

        // report all new children as removed
        EventBag<NodeChangeListener, NodeChangeEvent> nodeBag = new EventBag<NodeChangeListener, NodeChangeEvent>();
        nodeBag.addListeners(nodeListeners);

        for(ProxyPreferences pp : children.values()) {
            if (pp.delegate == null) {
                // new node that does not have corresponding node in the original hierarchy
                nodeBag.addEvent(new NodeChangeEventExt(this, pp, true));
            }
        }

        if (!nodeBag.getEvents().isEmpty()) {
            nodeEvents.add(nodeBag);
        }

        // report all modified keys
        if (delegate != null) {
            EventBag<PreferenceChangeListener, PreferenceChangeEvent> prefBag = new EventBag<PreferenceChangeListener, PreferenceChangeEvent>();
            prefBag.addListeners(prefListeners);
            prefEvents.add(prefBag);

            for(String key : data.keySet()) {
                prefBag.addEvent(new PreferenceChangeEvent(this, key, delegate.get(key, data.get(key).getValue())));
            }
        } // else there is no corresponding node in the orig hierarchy and this node
          // will be reported as removed

        // erase modified data
        for(NodeChangeEvent nce : nodeBag.getEvents()) {
            children.remove(nce.getChild().name());
        }
        data.clear();
    }

    private void firePrefEvents(List<EventBag<PreferenceChangeListener, PreferenceChangeEvent>> events) {
        if (noEvents) {
            return;
        }
        
        for(EventBag<PreferenceChangeListener, PreferenceChangeEvent> bag : events) {
            for(PreferenceChangeEvent event : bag.getEvents()) {
                for(PreferenceChangeListener l : bag.getListeners()) {
                    try {
                        l.preferenceChange(event);
                    } catch (Throwable t) {
                        LOG.log(Level.WARNING, null, t);
                    }
                }
            }
        }
    }

    private void fireNodeEvents(List<EventBag<NodeChangeListener, NodeChangeEvent>> events) {
        if (noEvents) {
            return;
        }
        
        for(EventBag<NodeChangeListener, NodeChangeEvent> bag : events) {
            for(NodeChangeEvent event : bag.getEvents()) {
                for(NodeChangeListener l : bag.getListeners()) {
                    try {
                        if ((event instanceof NodeChangeEventExt) && ((NodeChangeEventExt) event).isRemovalEvent()) {
                            l.childRemoved(event);
                        } else {
                            l.childAdded(event);
                        }
                    } catch (Throwable t) {
                        LOG.log(Level.WARNING, null, t);
                    }
                }
            }
        }
    }

    /* test */ static final class Tree {

        public static Tree getTree(Object token, Preferences prefs) {
            synchronized (trees) {
                // find all trees for the token
                Map<Preferences, Tree> forest = trees.get(token);
                if (forest == null) {
                    forest = new HashMap<Preferences, Tree>();
                    trees.put(token, forest);
                }

                // find the tree for the prefs' root
                Preferences root = prefs.node("/"); //NOI18N
                Tree tree = forest.get(root);
                if (tree == null) {
                    tree = new Tree(token, root);
                    forest.put(root, tree);
                }

                return tree;
            }
        }

        /* test */ static final Map<Object, Map<Preferences, Tree>> trees = new WeakHashMap<Object, Map<Preferences, Tree>>();

        private final Preferences root;
        private final Reference<?> tokenRef;
        private final Map<String, ProxyPreferences> nodes = new HashMap<String, ProxyPreferences>();
        
        private Tree(Object token, Preferences root) {
            this.root = root;
            this.tokenRef = new WeakReference<Object>(token);
        }

        public Object treeLock() {
            return this;
        }

        public ProxyPreferences get(ProxyPreferences parent, String name, Preferences delegate) {
            if (delegate != null) {
                assert name.equals(delegate.name());

                if (parent == null) {
                    Preferences parentDelegate = delegate.parent();
                    if (parentDelegate != null) {
                        parent = get(null, parentDelegate.name(), parentDelegate);
                    } // else delegate is the root
                } else {
                    // sanity check
                    assert parent.delegate == delegate.parent();
                }
            }

            String absolutePath;
            if (parent == null) {
                absolutePath = "/"; //NOI18N
            } else if (parent.parent() == null) {
                absolutePath = "/" + name; //NOI18N
            } else {
                absolutePath = parent.absolutePath() + "/" + name; //NOI18N
            }

            ProxyPreferences node = nodes.get(absolutePath);
            if (node == null) {
                node = new ProxyPreferences(parent, name, delegate, this);
                nodes.put(absolutePath, node);

                if (parent != null) {
                    parent.addChild(node);
                }
            } else {
                assert !node.removed;
            }

            return node;
        }

        public void removeNode(ProxyPreferences node) {
            String path = node.absolutePath();
            assert nodes.containsKey(path);
            ProxyPreferences pp = nodes.remove(path);
        }

        public void destroy() {
            synchronized (trees) {
                Object token = tokenRef.get();
                if (token != null) {
                    trees.remove(token);
                } // else the token has been GCed and therefore is not even in the trees map
            }
        }
    } // End of Tree class

    private static final class EventBag<L, E extends EventObject> {
        private final Set<L> listeners = new HashSet<L>();
        private final Set<E> events = new HashSet<E>();

        public EventBag() {
        }

        public Set<? extends L> getListeners() {
            return listeners;
        }

        public Set<? extends E> getEvents() {
            return events;
        }

        public void addListeners(Collection<? extends L> l) {
            listeners.addAll(l);
        }

        public void addEvent(E event) {
            events.add(event);
        }
    } // End of EventBag class

    private static final class NodeChangeEventExt extends NodeChangeEvent {
        private final boolean removal;
        public NodeChangeEventExt(Preferences parent, Preferences child, boolean removal) {
            super(parent, child);
            this.removal = removal;
        }

        public boolean isRemovalEvent() {
            return removal;
        }
    } // End of NodeChangeEventExt class
}

Lines 305-311 Link Here

(-)a/options.editor/test/unit/src/org/netbeans/modules/options/indentation/ProxyPreferencesTest.java (-1 / +2 lines)
305	test = null;	305	test = null;
306	assertGC("Tree token was not GCed", treeTokenRef, Collections.singleton(this));	306	assertGC("Tree token was not GCed", treeTokenRef, Collections.singleton(this));
307	// touch the WeakHashMap to expungeStaleEntries	307	// touch the WeakHashMap to expungeStaleEntries
308	ProxyPreferences.Tree.trees.size();	308	Object dummyToken = new Object();
		309	ProxyPreferences dummyPrefs = ProxyPreferences.getProxyPreferences(dummyToken, orig);
309	assertGC("Test preferences were not GCed", testRef, Collections.singleton(this));	310	assertGC("Test preferences were not GCed", testRef, Collections.singleton(this));
310		311
311	}	312	}

Lines 113-118 Link Here

(-)a/php.editor/nbproject/project.xml (+9 lines)
113	</run-dependency>	113	</run-dependency>
114	</dependency>	114	</dependency>
115	<dependency>	115	<dependency>
		116	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
		117	<build-prerequisite/>
		118	<compile-dependency/>
		119	<run-dependency>
		120	<release-version>1</release-version>
		121	<specification-version>1.34</specification-version>
		122	</run-dependency>
		123	</dependency>
		124	<dependency>
116	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>	125	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>
117	<build-prerequisite/>	126	<build-prerequisite/>
118	<compile-dependency/>	127	<compile-dependency/>

Lines 47-52 Link Here

(-)a/php.editor/src/org/netbeans/modules/php/editor/nav/FoldingScanner.java (-14 / +47 lines)
47	import java.util.List;	47	import java.util.List;
48	import java.util.Map;	48	import java.util.Map;
49	import javax.swing.text.Document;	49	import javax.swing.text.Document;
		50	import org.netbeans.api.editor.fold.FoldTemplate;
		51	import org.netbeans.api.editor.fold.FoldType;
50	import org.netbeans.modules.csl.api.OffsetRange;	52	import org.netbeans.modules.csl.api.OffsetRange;
51	import org.netbeans.modules.csl.spi.ParserResult;	53	import org.netbeans.modules.csl.spi.ParserResult;
52	import org.netbeans.modules.parsing.api.Source;	54	import org.netbeans.modules.parsing.api.Source;
Lines 77-93 Link Here
77	import org.netbeans.modules.php.editor.parser.astnodes.WhileStatement;	79	import org.netbeans.modules.php.editor.parser.astnodes.WhileStatement;
78	import org.netbeans.modules.php.editor.parser.astnodes.visitors.DefaultVisitor;	80	import org.netbeans.modules.php.editor.parser.astnodes.visitors.DefaultVisitor;
79		81
		82	import org.openide.util.NbBundle;
		83	import static org.netbeans.modules.php.editor.nav.Bundle.*;
80	/**	84	/**
81	*	85	*
82	* @author Ondrej Brejla <obrejla@netbeans.org>	86	* @author Ondrej Brejla <obrejla@netbeans.org>
83	*/	87	*/
84	public final class FoldingScanner {	88	public final class FoldingScanner {
		89
		90	public static final FoldType TYPE_CODE_BLOCKS = FoldType.CODE_BLOCK;
		91
		92	/**
		93	* FoldType for the PHP class (either nested, or top-level)
		94	*/
		95	@NbBundle.Messages("FT_Classes=Classes")
		96	public static final FoldType TYPE_CLASS = FoldType.NESTED.derive(
		97	"class",
		98	FT_Classes(), FoldTemplate.DEFAULT_BLOCK);
85		99
86	private static final String FOLD_CODE_BLOCKS = "codeblocks"; //NOI18N	100	/**
87	private static final String FOLD_CLASS = "inner-classes"; //NOI18N	101	* PHP documentation comments
88	private static final String FOLD_PHPDOC = "comments"; //NOI18N	102	*/
89	private static final String FOLD_COMMENT = "initial-comment"; //NOI18N	103	@NbBundle.Messages("FT_PHPDoc=PHPDoc documentation")
90	private static final String FOLD_OTHER_CODE_BLOCKS = "othercodeblocks"; //NOI18N	104	public static final FoldType TYPE_PHPDOC = FoldType.DOCUMENTATION.override(
		105	FT_PHPDoc(), // NOI18N
		106	new FoldTemplate(3, 2, "/*.../")); // NOI18N
		107
		108	public static final FoldType TYPE_COMMENT = FoldType.COMMENT.override(
		109	FoldType.COMMENT.getLabel(),
		110	new FoldTemplate(2, 2, "/.../")); // NOI18N
		111
		112	/**
		113	*
		114	*/
		115	@NbBundle.Messages("FT_Functions=Functions and methods")
		116	public static final FoldType TYPE_FUNCTION = FoldType.MEMBER.derive("function",
		117	FT_Functions(),
		118	FoldTemplate.DEFAULT_BLOCK);
		119
91	private static final String LAST_CORRECT_FOLDING_PROPERTY = "LAST_CORRECT_FOLDING_PROPERY"; //NOI18N	120	private static final String LAST_CORRECT_FOLDING_PROPERTY = "LAST_CORRECT_FOLDING_PROPERY"; //NOI18N
92		121
93	public static FoldingScanner create() {	122	public static FoldingScanner create() {
Lines 120-129 Link Here
120	if (comments != null) {	149	if (comments != null) {
121	for (Comment comment : comments) {	150	for (Comment comment : comments) {
122	if (comment.getCommentType() == Comment.Type.TYPE_PHPDOC) {	151	if (comment.getCommentType() == Comment.Type.TYPE_PHPDOC) {
123	getRanges(folds, FOLD_PHPDOC).add(createOffsetRange(comment));	152	getRanges(folds, TYPE_PHPDOC).add(createOffsetRange(comment, -3));
124	} else {	153	} else {
125	if (comment.getCommentType() == Comment.Type.TYPE_MULTILINE) {	154	if (comment.getCommentType() == Comment.Type.TYPE_MULTILINE) {
126	getRanges(folds, FOLD_COMMENT).add(createOffsetRange(comment));	155	getRanges(folds, TYPE_COMMENT).add(createOffsetRange(comment));
127	}	156	}
128	}	157	}
129	}	158	}
Lines 138-147 Link Here
138	continue;	167	continue;
139	}	168	}
140	if (scope instanceof TypeScope) {	169	if (scope instanceof TypeScope) {
141	getRanges(folds, FOLD_CLASS).add(offsetRange);	170	getRanges(folds, TYPE_CLASS).add(offsetRange);
142	} else {	171	} else {
143	if (scope instanceof FunctionScope \|\| scope instanceof MethodScope) {	172	if (scope instanceof FunctionScope \|\| scope instanceof MethodScope) {
144	getRanges(folds, FOLD_CODE_BLOCKS).add(offsetRange);	173	getRanges(folds, TYPE_FUNCTION).add(offsetRange);
145	}	174	}
146	}	175	}
147	}	176	}
Lines 157-172 Link Here
157	}	186	}
158	return Collections.emptyMap();	187	return Collections.emptyMap();
159	}	188	}
		189
		190	private OffsetRange createOffsetRange(ASTNode node, int startShift) {
		191	return new OffsetRange(node.getStartOffset() + startShift, node.getEndOffset());
		192	}
160		193
161	private OffsetRange createOffsetRange(ASTNode node) {	194	private OffsetRange createOffsetRange(ASTNode node) {
162	return new OffsetRange(node.getStartOffset(), node.getEndOffset());	195	return createOffsetRange(node, 0);
163	}	196	}
164		197
165	private List<OffsetRange> getRanges(Map<String, List<OffsetRange>> folds, String kind) {	198	private List<OffsetRange> getRanges(Map<String, List<OffsetRange>> folds, FoldType kind) {
166	List<OffsetRange> ranges = folds.get(kind);	199	List<OffsetRange> ranges = folds.get(kind.code());
167	if (ranges == null) {	200	if (ranges == null) {
168	ranges = new ArrayList<OffsetRange>();	201	ranges = new ArrayList<OffsetRange>();
169	folds.put(kind, ranges);	202	folds.put(kind.code(), ranges);
170	}	203	}
171	return ranges;	204	return ranges;
172	}	205	}
Lines 290-296 Link Here
290	}	323	}
291		324
292	private void addFold(final OffsetRange offsetRange) {	325	private void addFold(final OffsetRange offsetRange) {
293	getRanges(folds, FOLD_OTHER_CODE_BLOCKS).add(offsetRange);	326	getRanges(folds, TYPE_CODE_BLOCKS).add(offsetRange);
294	}	327	}
295		328
296	}	329	}




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

import java.util.ArrayList;
import java.util.Collection;
import org.netbeans.api.editor.fold.FoldType;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.spi.editor.fold.FoldTypeProvider;

/**
 *
 * @author sdedic
 */
@MimeRegistration(mimeType = "text/x-php5", service = FoldTypeProvider.class)
public class PHPFoldingProvider implements FoldTypeProvider {
    private static final Collection<FoldType> TYPES = new ArrayList<FoldType>(5);
    
    static {
        TYPES.add(FoldingScanner.TYPE_CLASS);
        TYPES.add(FoldingScanner.TYPE_FUNCTION);
        TYPES.add(FoldingScanner.TYPE_CODE_BLOCKS);
        TYPES.add(FoldingScanner.TYPE_COMMENT);
        TYPES.add(FoldingScanner.TYPE_PHPDOC);
    }
    
    @Override
    public Collection getValues(Class type) {
        return type == FoldType.class ? TYPES : null;
    }

    @Override
    public boolean inheritable() {
        return false;
    }
}




                    <file name="org-netbeans-modules-php-editor-sql-PHPSQLCompletion.instance"/>
                </folder>
                <folder name="FoldManager">
                    <file name="CustomFoldManager.instance">
                        <attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.FoldManagerFactory"/>
                        <attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.userFoldManagerFactory"/>
                    </file>
                    <file name="PHPDocReader.instance">
                        <attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.ContentReader$Factory"/>
                        <attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.contentReaderFactory"/>
                        <attr name="start" stringvalue="*"/>
                        <attr name="terminator" stringvalue="\."/>
                        <attr name="stop" stringvalue="@"/>
                    </file>
                </folder>
                <!--issue #127161:-->
                <folder name="Popup">

Return to bug 226413

Lines 106-116 Link Here

(-)a/editor.codetemplates/src/org/netbeans/lib/editor/codetemplates/storage/SettingsProvider.java (-30 / +4 lines)
106	this.ic = ic;	106	this.ic = ic;
107		107
108	// Start listening	108	// Start listening
109	MimePath [] allPaths = computeInheritedMimePaths(mimePath);	109	List<MimePath> allPaths = mimePath.getIncludedPaths();
110	this.allCtsi = new CodeTemplateSettingsImpl[allPaths.length];	110	this.allCtsi = new CodeTemplateSettingsImpl[allPaths.size()];
111		111
112	for(int i = 0; i < allPaths.length; i++) {	112	for(int i = 0; i < allPaths.size(); i++) {
113	this.allCtsi[i] = CodeTemplateSettingsImpl.get(allPaths[i]);	113	this.allCtsi[i] = CodeTemplateSettingsImpl.get(allPaths.get(i));
114	this.allCtsi[i].addPropertyChangeListener(WeakListeners.propertyChange(this, this.allCtsi[i]));	114	this.allCtsi[i].addPropertyChangeListener(WeakListeners.propertyChange(this, this.allCtsi[i]));
115	}	115	}
116	}	116	}
Lines 170-199 Link Here
170	}	170	}
171		171
172	} // End of CompositeCTS class	172	} // End of CompositeCTS class
173
174	private static MimePath [] computeInheritedMimePaths(MimePath mimePath) {
175	List<String> paths = null;
176	try {
177	Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
178	m.setAccessible(true);
179	@SuppressWarnings("unchecked")
180	List<String> ret = (List<String>) m.invoke(mimePath, null, null);
181	paths = ret;
182	} catch (Exception e) {
183	LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
184	}
185
186	if (paths != null) {
187	ArrayList<MimePath> mimePaths = new ArrayList<MimePath>(paths.size());
188
189	for (String path : paths) {
190	mimePaths.add(MimePath.parse(path));
191	}
192
193	return mimePaths.toArray(new MimePath[mimePaths.size()]);
194	} else {
195	return new MimePath [] { mimePath, MimePath.EMPTY };
196	}
197	}
198
199	}	173	}

Lines 450-455 Link Here

(-)a/editor.fold/arch.xml (+116 lines)
450	}	450	}
451	</pre>	451	</pre>
452		452
		453	<h3>Updating Fold hierarchy</h3>
		454	In the preceding cases, maintaining Folds was the FoldManager's responsibility. The FoldManager typically
		455	held a copy of the Folds added to the hierarchy, and during the refresh, it compared them to the new data
		456	and decided what folds to remove.
		457	For simple cases, which only create/remove folds based on text positions, part of the work can be offloaded to the
		458	FoldOperation:
		459
		460	<pre>
		461	// create new fold positional information for all folds.
		462	Collection<FoldInfo> newInfos = ...;
		463
		464	// create FoldInfo for each of the fold
		465	newInfos.add(
		466	FoldInfo.range(start, end, type).
		467	withTemplate(customTemplate).
		468	withDescription(veryCustomDescription).
		469	collapse(true)
		470	);
		471
		472	// the hierarchy must be locked prior to update
		473
		474	doc.readLock();
		475	hierarchy.lock();
		476	try {
		477	operation.update(newInfos, null, null);
		478	} finally {
		479	}
		480	</pre>
		481
		482	The <code>update()</code> operation performs a diff, creates new folds, discards old ones, and updates the folds, which
		483	prevailed.
		484
		485	<h3>Accessing folds</h3>
		486	Instead of keeping a copy of created folds, the FoldManager may call <code>operation.foldIterator</code>. The iterator
		487	will enumerate all folds, including (recursively) blocked ones.
453		488
454	</answer>	489	</answer>
455		490
Lines 1204-1207 Link Here
1204	No.	1239	No.
1205	</answer>	1240	</answer>
1206		1241
		1242
		1243
		1244
		1245	<!--
		1246	<question id="arch-where" when="impl">
		1247	Where one can find sources for your module?
		1248	<hint>
		1249	Please provide link to the Hg web client at
		1250	http://hg.netbeans.org/
		1251	or just use tag defaultanswer generate='here'
		1252	</hint>
		1253	</question>
		1254	-->
		1255	<answer id="arch-where">
		1256	<defaultanswer generate='here' />
		1257	</answer>
		1258
		1259
		1260
		1261	<!--
		1262	<question id="compat-deprecation" when="init">
		1263	How the introduction of your project influences functionality
		1264	provided by previous version of the product?
		1265	<hint>
		1266	If you are planning to deprecate/remove/change any existing APIs,
		1267	list them here accompanied with the reason explaining why you
		1268	are doing so.
		1269	</hint>
		1270	</question>
		1271	-->
		1272	<answer id="compat-deprecation">
		1273	<p>
		1274	XXX no answer for compat-deprecation
		1275	</p>
		1276	</answer>
		1277
		1278
		1279
		1280	<!--
		1281	<question id="exec-ant-tasks" when="impl">
		1282	Do you define or register any ant tasks that other can use?
		1283
		1284	<hint>
		1285	If you provide an ant task that users can use, you need to be very
		1286	careful about its syntax and behaviour, as it most likely forms an
		1287	API for end users and as there is a lot of end users, their reaction
		1288	when such API gets broken can be pretty strong.
		1289	</hint>
		1290	</question>
		1291	-->
		1292	<answer id="exec-ant-tasks">
		1293	<p>
		1294	XXX no answer for exec-ant-tasks
		1295	</p>
		1296	</answer>
		1297
		1298
		1299
		1300	<!--
		1301	<question id="resources-preferences" when="final">
		1302	Does your module uses preferences via Preferences API? Does your module use NbPreferences or
		1303	or regular JDK Preferences ? Does it read, write or both ?
		1304	Does it share preferences with other modules ? If so, then why ?
		1305	<hint>
1306	You may use
1307	<api type="export" group="preferences"
1308	name="preference node name" category="private">
1309	description of individual keys, where it is used, what it
1310	influences, whether the module reads/write it, etc.
1311	</api>
1312	Due to XML ID restrictions, rather than /org/netbeans/modules/foo give the "name" as org.netbeans.modules.foo.
1313	Note that if you use NbPreferences this name will then be the same as the code name base of the module.
1314	</hint>
1315	</question>
1316	-->
1317	<answer id="resources-preferences">
1318	<p>
1319	XXX no answer for resources-preferences
1320	</p>
1321	</answer>
1322
1207	</api-answers>	1323	</api-answers>

Line 0 Link Here

(-)a/editor.fold/src/org/netbeans/api/editor/fold/FoldTemplate.java (+125 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.api.editor.fold;
		43
		44	import org.openide.util.NbBundle;
		45
		46	import static org.netbeans.api.editor.fold.Bundle.*;
		47
		48	/**
		49	* Template that describes how the fold should appear and interact with the
		50	* user. The FoldTemplate defines how many characters at the start (end) should
		51	* act as a fold guard: change to that area will remove the fold because it
		52	* becomes damaged. It also defines what placeholder should appear in place of the
		53	* folded code.
		54	* <p/>
		55	* A template may be attached to a {@link FoldType} instance. Folds of that kind will
		56	* automatically use the attached Template, if not overriden explicitly.
		57	* <p/>
		58	* The string {@code "..."} ({@link #CONTENT_PLACEHOLDER}) is treated as a placeholder. If a
		59	* ContentReader is available for the {@link FoldType}, the placeholder will be replaced by
		60	* the product of the Reader. Otherwise the placeholder will remain in the displayText
		61	* and will be presented.
		62	*
		63	* @since 1.34
		64	* @author sdedic
65	*/
66	public final class FoldTemplate {
67	/**
68	* The default template for folded text: no markers before+after, ellipsis
69	* shown.
70	*/
71	@NbBundle.Messages("FT_DefaultTemplate=...")
72	public static final FoldTemplate DEFAULT = new FoldTemplate(0, 0, FT_DefaultTemplate()); // NOI18N
73
74	/**
75	* A standard template, which represents a block of something.
76	*/
77	@NbBundle.Messages("FT_DefaultBlockTemplate={...}")
78	public static final FoldTemplate DEFAULT_BLOCK = new FoldTemplate(0, 0, FT_DefaultBlockTemplate()); // NOI18N
79
80	/**
81	* This string is interpreted as a placeholder for the infrastructure to inject
82	*/
83	public static final String CONTENT_PLACEHOLDER = FT_DefaultTemplate();
84
85	/**
86	* # of characters at the start of the fold, which serve as a marker that the fold
87	* has been damaged/destroyed
88	*/
89	private int guardedStart;
90
91	/**
92	* The guarded portion at the end of the fold
93	*/
94	private int guardedEnd;
95
96	/**
97	* Description that appears in the folded area.
98	*/
99	private String displayText;
100
101	/**
102	* Creates a FoldTemplate with a fixed description.
103	*
104	* @param guardedStart length of the start marker, or -1 if no start marker is present
105	* @param guardedEnd length of the end marker, or -1 if no end marker is present
106	* @param displayText text which should be displayed in place of the folded content
107	*/
108	public FoldTemplate(int guardedStart, int guardedEnd, String displayText) {
109	this.guardedStart = guardedStart;
110	this.guardedEnd = guardedEnd;
111	this.displayText = displayText;
112	}
113
114	public String getDescription() {
115	return displayText;
116	}
117
118	public int getGuardedEnd() {
119	return guardedEnd;
120	}
121
122	public int getGuardedStart() {
123	return guardedStart;
124	}
125	}

Line 0 Link Here

(-)a/editor.fold/src/org/netbeans/api/editor/fold/FoldingSupport.java (+194 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2013 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2013 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.api.editor.fold;
		43
		44	import java.util.Map;
		45	import javax.swing.JComponent;
		46	import javax.swing.text.JTextComponent;
		47	import org.netbeans.editor.SideBarFactory;
		48	import org.netbeans.modules.editor.fold.CustomFoldManager;
		49	import org.netbeans.modules.editor.fold.JavadocReader;
		50	import org.netbeans.modules.editor.fold.ui.CodeFoldingSideBar;
		51	import org.netbeans.spi.editor.fold.ContentReader;
		52	import org.netbeans.spi.editor.fold.FoldManager;
		53	import org.netbeans.spi.editor.fold.FoldManagerFactory;
		54	import org.openide.util.Parameters;
		55
		56	/**
		57	* This utility class collects APIs to create default implementations
		58	* of various pieces of infrastructure.
		59	*
		60	* @author sdedic
		61	*/
		62	public final class FoldingSupport {
		63	private static SideBarFactory FACTORY = null;
		64
65	private FoldingSupport() {}
66
67	/**
68	* Creates a default implementation of {@link ContentReader}.
69	*
70	* The default implementation is modeled to work with Javadoc-like comments. It will
71	* ignore markers at line start (first non-whitespace) - 'start' parameter. If the reader
72	* encounters the 'stop' regex pattern, it stops scanning and returns {@code null}. Typically
73	* some tags are placed at the end of the doc comment, and they are not informative enough
74	* to put them into folded preview.
75	* <p/>
76	* Finally, if a suitable content is found, and it contains the 'terminator' pattern,
77	* the content is only returned up to (excluding) the terminator.
78	* <p/>
79	* Javadoc (PHPdoc) reader can be constructed as <code>defaultReader("*", "\\.", "@");</code>
80	*
81	* @param start character sequence, which will be ignored at the beginning of the line. Can be {@code null}
82	* @param terminator pattern, which marks the end of the summary line/sentence. Can be {@code null}
83	* @param stop content search stop at the 'stop' pattern. Can be {@code null}
84	*/
85	public static ContentReader contentReader(String start, String terminator, String stop, String prefix) {
86	return new JavadocReader(start, terminator, stop, prefix);
87	}
88
89	/**
90	* A variant of {@link #defaultReader} usable from FS layer.
91	* See {@link #defaultReader} documentation for parameter explanation. The
92	* method expects those parameters as keys in the Map (values are all Strings).
93	* An additional entry (key: 'type') is required in the map, it identifies the
94	* FoldType for which the reader should work.
95	*
96	* @param m configuration parameters for the reader factory.
97	* @see #contentReader
98	*/
99	public static ContentReader.Factory contentReaderFactory(Map m) {
100	final String start = (String) m.get("start"); // NOI18N
101	final String terminator = (String) m.get("terminator"); // NOI18N
102	final String stop = (String) m.get("stop"); // NOI18N
103	final String foldType = (String) m.get("type"); // NOI18N
104	final String prefix = (String)m.get("prefix"); // NOI18N
105	return new ContentReader.Factory() {
106	@Override
107	public ContentReader createReader(FoldType ft) {
108	if (foldType != null && foldType.equals(ft.code()) \|\| (foldType == null && ft.isKindOf(FoldType.DOCUMENTATION))) {
109	return contentReader(start, terminator, stop, prefix);
110	} else {
111	return null;
112	}
113	}
114	};
115	}
116
117	/**
118	* Creates a component for the code folding sidebar.
119	* Returns a standard folding sidebar component, which displays code folds. This sidebar implementation
120	* can be created only once per text component.
121	*
122	* @param textComponent the text component which should work with the Sidebar
123	* @return Sidebar instance.
124	*/
125	public static JComponent sidebarComponent(JTextComponent textComponent) {
126	return new CodeFoldingSideBar(textComponent);
127	}
128
129	/**
130	* Creates a user-defined fold manager, that processes specific token type.
131	* The manager tries to find start/end markers within the token text. If found,
132	* a Fold is created. The manager only looks in tokens, whose {@code primaryCategory}
133	* starts with a String, which is stored under 'tokenId' key in the params map.
134	* <p/>
135	* The method is designed to be called from the filesystem layer as follows:
136	* <code><pre>
137	* <file name="my-custom-foldmanager.instance">
138	* <attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldUtilities.createUserFoldManager"/>
139	* <attr name="tokenid" stringvalue="comment"/>
140	* </file>
141	* </pre></code>
142	*
143	* @param map the configuration parameters.
144	* @return FoldManagerFactory instance
145	*/
146	public static FoldManagerFactory userFoldManagerFactory(Map params) {
147	final String s = (String) params.get("tokenId");
148	return new FoldManagerFactory() {
149	@Override
150	public FoldManager createFoldManager() {
151	return userFoldManager(s);
152	}
153	};
154	}
155
156	/**
157	* Creates a user-defined fold manager, that processes specific token type.
158	* The manager tries to find start/end markers within the token text. If found,
159	* a Fold is created. The manager only looks in tokens, whose {@code primaryCategory}
160	* starts with tokenId string.
161	* <p/>
162	* {@code Null} value of 'tokenId' means the default "comment" will be used.
163	*
164	* @param tokenId filter for prefix of the token's primaryCategory.
165	* @return FoldManager instance
166	*/
167	public static FoldManager userFoldManager(String tokenId) {
168	if (tokenId != null) {
169	return new CustomFoldManager(tokenId);
170	} else {
171	return new CustomFoldManager();
172	}
173	}
174
175	/**
176	* Obtains an instance of folding sidebar factory. This method should
177	* be used in layer, in the MIME lookup area, to register a sidebar with
178	* an editor for a specific MIMEtype.
179	* <p/>
180	* There's a default sidebar instance registered for all MIME types.
181	*
182	* @return shared sidebar factory instance
183	*/
184	public static SideBarFactory foldingSidebarFactory() {
185	if (FACTORY != null) {
186	return FACTORY;
187	}
188	return FACTORY = new CodeFoldingSideBar.Factory();
189	}
190
191	public static void disableCodeFoldingSidebar(JTextComponent text) {
192	text.putClientProperty(CodeFoldingSideBar.PROP_SIDEBAR_MARK, true);
193	}
194	}

Lines 42-48 Link Here

(-)a/editor.lib/src/org/netbeans/editor/CustomFoldManager.java (-3 / +16 lines)
42	* made subject to such option by the copyright holder.	42	* made subject to such option by the copyright holder.
43	*/	43	*/
44		44
45	package org.netbeans.editor;	45	package org.netbeans.modules.editor.fold;
46		46
47	import javax.swing.text.Document;	47	import javax.swing.text.Document;
48	import javax.swing.text.BadLocationException;	48	import javax.swing.text.BadLocationException;
Lines 59-68 Link Here
59	import org.netbeans.api.lexer.Token;	59	import org.netbeans.api.lexer.Token;
60	import org.netbeans.api.lexer.TokenHierarchy;	60	import org.netbeans.api.lexer.TokenHierarchy;
61	import org.netbeans.api.lexer.TokenSequence;	61	import org.netbeans.api.lexer.TokenSequence;
		62	import org.netbeans.editor.BaseDocument;
62	import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;	63	import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;
63	import org.netbeans.spi.editor.fold.FoldManager;	64	import org.netbeans.spi.editor.fold.FoldManager;
64	import org.netbeans.spi.editor.fold.FoldManagerFactory;	65	import org.netbeans.spi.editor.fold.FoldManagerFactory;
65	import org.netbeans.spi.editor.fold.FoldOperation;	66	import org.netbeans.spi.editor.fold.FoldOperation;
		67	import org.openide.util.Parameters;
66	import org.openide.util.RequestProcessor;	68	import org.openide.util.RequestProcessor;
67		69
68	/**	70	/**
Lines 72-78 Link Here
72	* @version 1.00	74	* @version 1.00
73	*/	75	*/
74		76
75	final class CustomFoldManager implements FoldManager, Runnable {	77	public final class CustomFoldManager implements FoldManager, Runnable {
76		78
77	private static final Logger LOG = Logger.getLogger(CustomFoldManager.class.getName());	79	private static final Logger LOG = Logger.getLogger(CustomFoldManager.class.getName());
78		80
Lines 89-95 Link Here
89	private static final RequestProcessor RP = new RequestProcessor(CustomFoldManager.class.getName(),	91	private static final RequestProcessor RP = new RequestProcessor(CustomFoldManager.class.getName(),
90	1, false, false);	92	1, false, false);
91	private final RequestProcessor.Task task = RP.create(this);	93	private final RequestProcessor.Task task = RP.create(this);
		94
		95	private final String tokenId;
		96
		97	public CustomFoldManager() {
		98	this.tokenId = "comment";
		99	}
92		100
		101	public CustomFoldManager(String tokenId) {
		102	Parameters.notNull("tokenId", tokenId);
		103	this.tokenId = tokenId;
		104	}
		105
93	public void init(FoldOperation operation) {	106	public void init(FoldOperation operation) {
94	this.operation = operation;	107	this.operation = operation;
95	if (LOG.isLoggable(Level.FINE)) {	108	if (LOG.isLoggable(Level.FINE)) {
Lines 481-487 Link Here
481		494
482	private FoldMarkInfo scanToken(Token token) throws BadLocationException {	495	private FoldMarkInfo scanToken(Token token) throws BadLocationException {
483	// ignore any token that is not comment	496	// ignore any token that is not comment
484	if (token.id().primaryCategory() != null && token.id().primaryCategory().startsWith("comment")) { //NOI18N	497	if (token.id().primaryCategory() != null && token.id().primaryCategory().startsWith(tokenId)) { //NOI18N
485	Matcher matcher = pattern.matcher(token.text());	498	Matcher matcher = pattern.matcher(token.text());
486	if (matcher.find()) {	499	if (matcher.find()) {
487	if (matcher.group(1) != null) { // fold's start mark found	500	if (matcher.group(1) != null) { // fold's start mark found

Lines 1-152 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/FoldToolTip.java (-152 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* Contributor(s):
28	*
29	* The Original Software is NetBeans. The Initial Developer of the Original
30	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
31	* Microsystems, Inc. All Rights Reserved.
32	*
33	* If you wish your version of this file to be governed by only the CDDL
34	* or only the GPL Version 2, indicate your decision by adding
35	* "[Contributor] elects to include this software in this distribution
36	* under the [CDDL or GPL Version 2] license." If you do not indicate a
37	* single choice of license, a recipient has the option to distribute
38	* your version of this file under either the CDDL, the GPL Version 2 or
39	* to extend the choice of license to its licensees as provided above.
40	* However, if you add GPL Version 2 code and therefore, elected the GPL
41	* Version 2 license, then the option applies only if the new code is
42	* made subject to such option by the copyright holder.
43	*/
44
45	package org.netbeans.modules.editor.fold;
46
47	import java.awt.BorderLayout;
48	import java.awt.Color;
49	import java.awt.Dimension;
50	import java.lang.reflect.InvocationTargetException;
51	import java.lang.reflect.Method;
52	import javax.swing.JComponent;
53	import javax.swing.JEditorPane;
54	import javax.swing.JPanel;
55	import javax.swing.border.LineBorder;
56	import javax.swing.event.AncestorEvent;
57	import javax.swing.event.AncestorListener;
58	import javax.swing.text.JTextComponent;
59	import org.netbeans.modules.editor.lib2.view.DocumentView;
60	import org.openide.util.Exceptions;
61	import org.openide.util.Lookup;
62
63	/**
64	* Component that displays a collapsed fold preview.
65	*
66	* @author Miloslav Metelka
67	*/
68	public class FoldToolTip extends JPanel {
69	private int editorPaneWidth;
70
71	public FoldToolTip(JEditorPane editorPane, final JEditorPane foldPreviewPane, Color borderColor) {
72	setLayout(new BorderLayout());
73	add(foldPreviewPane, BorderLayout.CENTER);
74	putClientProperty("tooltip-type", "fold-preview"); // Checked in NbToolTip
75
76	addGlyphGutter(foldPreviewPane);
77
78	addAncestorListener(new AncestorListener() {
79	@Override
80	public void ancestorAdded(AncestorEvent event) {
81	}
82
83	@Override
84	public void ancestorRemoved(AncestorEvent event) {
85	// Deactivate the view hierarchy immediately for foldPreviewPane
86	final DocumentView docView = DocumentView.get(foldPreviewPane);
87	if (docView != null) {
88	docView.runTransaction(new Runnable() {
89	@Override
90	public void run() {
91	docView.updateLengthyAtomicEdit(+100); // Effectively disable any VH updates
92	}
93	});
94	}
95	// Remove the listener
96	FoldToolTip.this.removeAncestorListener(this);
97	}
98
99	@Override
100	public void ancestorMoved(AncestorEvent event) {
101	}
102	});
103
104	editorPaneWidth = editorPane.getSize().width;
105
106	setBorder(new LineBorder(borderColor));
107	setOpaque(true);
108	}
109
110	private void addGlyphGutter(JTextComponent jtx) {
111	ClassLoader cls = Lookup.getDefault().lookup(ClassLoader.class);
112	Class clazz;
113	Class editorUiClass;
114
115	JComponent gutter = null;
116	try {
117	clazz = Class.forName("org.netbeans.editor.GlyphGutter", true, cls); // NOI18N
118	editorUiClass = Class.forName("org.netbeans.editor.EditorUI", true, cls); // NOI18N
119	// get the factory instance
120	Object o = clazz.newInstance();
121	Method m = clazz.getDeclaredMethod("createSideBar", JTextComponent.class); // NOI18N
122	gutter = (JComponent)m.invoke(o, jtx);
123	} catch (IllegalArgumentException ex) {
124	Exceptions.printStackTrace(ex);
125	} catch (InvocationTargetException ex) {
126	Exceptions.printStackTrace(ex);
127	} catch (NoSuchMethodException ex) {
128	Exceptions.printStackTrace(ex);
129	} catch (SecurityException ex) {
130	Exceptions.printStackTrace(ex);
131	} catch (InstantiationException ex) {
132	Exceptions.printStackTrace(ex);
133	} catch (IllegalAccessException ex) {
134	Exceptions.printStackTrace(ex);
135	} catch (ClassNotFoundException ex) {
136	Exceptions.printStackTrace(ex);
137	}
138	if (gutter != null) {
139	add(gutter, BorderLayout.WEST);
140	}
141	}
142
143	@Override
144	public Dimension getPreferredSize() {
145	Dimension prefSize = super.getPreferredSize();
146	// Return width like for editor pane which forces the PopupManager to display
147	// the tooltip to align exacty with the text (below/above).
148	prefSize.width = Math.min(prefSize.width, editorPaneWidth);
149	return prefSize;
150	}
151
152	}

Line 0 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/ui/Bundle.properties (+67 lines)
		1	# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		2	#
		3	# Copyright 2013 Oracle and/or its affiliates. All rights reserved.
		4	#
		5	# Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		6	# Other names may be trademarks of their respective owners.
		7	#
		8	# The contents of this file are subject to the terms of either the GNU
		9	# General Public License Version 2 only ("GPL") or the Common
		10	# Development and Distribution License("CDDL") (collectively, the
		11	# "License"). You may not use this file except in compliance with the
		12	# License. You can obtain a copy of the License at
		13	# http://www.netbeans.org/cddl-gplv2.html
		14	# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		15	# specific language governing permissions and limitations under the
		16	# License. When distributing the software, include this License Header
		17	# Notice in each file and include the License file at
		18	# nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		19	# particular file as subject to the "Classpath" exception as provided
		20	# by Oracle in the GPL Version 2 section of the License file that
		21	# accompanied this code. If applicable, add the following below the
		22	# License Header, with the fields enclosed by brackets [] replaced by
		23	# your own identifying information:
		24	# "Portions Copyrighted [year] [name of copyright owner]"
		25	#
		26	# If you wish your version of this file to be governed by only the CDDL
		27	# or only the GPL Version 2, indicate your decision by adding
		28	# "[Contributor] elects to include this software in this distribution
		29	# under the [CDDL or GPL Version 2] license." If you do not indicate a
		30	# single choice of license, a recipient has the option to distribute
		31	# your version of this file under either the CDDL, the GPL Version 2 or
		32	# to extend the choice of license to its licensees as provided above.
		33	# However, if you add GPL Version 2 code and therefore, elected the GPL
		34	# Version 2 license, then the option applies only if the new code is
		35	# made subject to such option by the copyright holder.
		36	#
		37	# Contributor(s):
		38	#
		39	# Portions Copyrighted 2013 Sun Microsystems, Inc.
		40
		41	# CodeFoldingSideBar
		42	ACSN_CodeFoldingSideBar=Code folding side bar
		43	ACSD_CodeFoldingSideBar=Code folding side bar shows text folds and allows their collapsing and expanding.
		44
		45	collapse-all-folds_menu_text=Co&llapse All
		46	collapse-fold_menu_text=&Collapse Fold
		47	expand-all-folds_menu_text=E&xpand All
		48	expand-fold_menu_text=&Expand Fold
		49	collapse-all-folds=Collapse All
		50	collapse-fold=Collapse Fold
		51	expand-all-folds=Expand All
		52	expand-fold=Expand Fold
		53
		54	CTL_OptionsDisplayName=Folding
		55	KW_Options=Fold
		56	FoldOptionsPanel.langLabel.text=Language:
		57	TITLE_ElementsToCollapse=Collapse by default
		58	FoldOptionsPanel.enableFolds.text=Enable Code Folding
		59	DefaultFoldingOptions.useDefaults.text=Override default settings
		60	DefaultFoldingOptions.collapseContainer.border.title=Collapse by default
		61	FoldOptionsPanel.contentPreview.text=Content preview
		62	FoldOptionsPanel.foldedSummary.text=Show summary
		63	Title_FoldDisplayOptions=Display Options
		64	FMT_ContentPlaceholder_1={0}...
65	FMT_ContentPlaceholder_2=...{1}
66	FMT_ContentPlaceholder_3={0} ...{1}
67	FoldOptionsPanel.useDefaults.text=Use Default Settings

Line 0 Link Here

(-)a/editor.fold/src/org/netbeans/modules/editor/fold/ui/DefaultFoldingOptions.form (+59 lines)
	1	<?xml version="1.0" encoding="UTF-8" ?>
	2
	3	<Form version="1.5" maxVersion="1.8" type="org.netbeans.modules.form.forminfo.JPanelFormInfo">
	4	<AuxValues>
	5	<AuxValue name="FormSettings_autoResourcing" type="java.lang.Integer" value="1"/>
	6	<AuxValue name="FormSettings_autoSetComponentName" type="java.lang.Boolean" value="false"/>
	7	<AuxValue name="FormSettings_generateFQN" type="java.lang.Boolean" value="true"/>
	8	<AuxValue name="FormSettings_generateMnemonicsCode" type="java.lang.Boolean" value="true"/>
	9	<AuxValue name="FormSettings_i18nAutoMode" type="java.lang.Boolean" value="true"/>
	10	<AuxValue name="FormSettings_layoutCodeTarget" type="java.lang.Integer" value="1"/>
	11	<AuxValue name="FormSettings_listenerGenerationStyle" type="java.lang.Integer" value="0"/>
	12	<AuxValue name="FormSettings_variablesLocal" type="java.lang.Boolean" value="false"/>
	13	<AuxValue name="FormSettings_variablesModifier" type="java.lang.Integer" value="2"/>
	14	</AuxValues>
	15
	16	<Layout>
	17	<DimensionLayout dim="0">
	18	<Group type="103" groupAlignment="0" attributes="0">
	19	<Component id="collapseContainer" pref="180" max="32767" attributes="0"/>
	20	</Group>
	21	</DimensionLayout>
	22	<DimensionLayout dim="1">
	23	<Group type="103" groupAlignment="0" attributes="0">
	24	<Component id="collapseContainer" alignment="0" pref="151" max="32767" attributes="0"/>
	25	</Group>
	26	</DimensionLayout>
	27	</Layout>
	28	<SubComponents>
	29	<Container class="javax.swing.JPanel" name="collapseContainer">
	30	<Properties>
	31	<Property name="border" type="javax.swing.border.Border" editor="org.netbeans.modules.form.editors2.BorderEditor">
	32	<Border info="org.netbeans.modules.form.compat2.border.TitledBorderInfo">
	33	<TitledBorder title="Collapse by default">
	34	<ResourceString PropertyName="titleX" bundle="org/netbeans/modules/editor/fold/ui/Bundle.properties" key="DefaultFoldingOptions.collapseContainer.border.title" replaceFormat="org.openide.util.NbBundle.getMessage({sourceFileName}.class, "{key}")"/>
	35	</TitledBorder>
	36	</Border>
	37	</Property>
	38	</Properties>
	39	<AuxValues>
	40	<AuxValue name="designerSize" type="java.awt.Dimension" value="-84,-19,0,5,115,114,0,18,106,97,118,97,46,97,119,116,46,68,105,109,101,110,115,105,111,110,65,-114,-39,-41,-84,95,68,20,2,0,2,73,0,6,104,101,105,103,104,116,73,0,5,119,105,100,116,104,120,112,0,0,0,-105,0,0,0,-84"/>
	41	</AuxValues>
	42
	43	<Layout class="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout"/>
	44	<SubComponents>
	45	<Container class="javax.swing.JPanel" name="localSwitchboard">
	46	<Constraints>
	47	<Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout" value="org.netbeans.modules.form.compat2.layouts.DesignBorderLayout$BorderConstraintsDescription">
	48	<BorderConstraints direction="Center"/>
	49	</Constraint>
	50	</Constraints>
	51
	52	<Layout class="org.netbeans.modules.form.compat2.layouts.DesignAbsoluteLayout">
	53	<Property name="useNullLayout" type="boolean" value="true"/>
	54	</Layout>
	55	</Container>
	56	</SubComponents>
	57	</Container>
	58	</SubComponents>
	59	</Form>

Line 0 Link Here

(-)a/editor.fold/src/org/netbeans/spi/editor/fold/FoldTypeProvider.java (+85 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.spi.editor.fold;
		43
		44	import java.util.Collection;
		45	import org.netbeans.api.editor.fold.FoldType;
		46	import org.netbeans.spi.editor.mimelookup.MimeLocation;
		47
		48	/**
		49	* Provider of FoldType constants for the MimeType.
		50	* The Provider should enumerate FoldTypes that apply to the given MIME type.
		51	* There can be multiple providers for a MIME type - some advanced constructions in
		52	* the language can be recognized / folded by extension modules. Consider Java vs.
		53	* Bean Patterns, or XML vs. Spring bean config.
		54	* <p/>
		55	* FoldTypes will be collected and some pieces of UI can present the folds, such
		56	* as Auto-folding options.
		57	* <p/>
		58	* The Provider may specify inheritable=true; in that case the contributed FoldTypes
		59	* will become available for more specific MIME types, too. For example, if a FoldTypeProvider
		60	* for text/xml registers FoldTypes TAG and COMMENT with inheritable=true,
		61	* those FoldTypes will be listed also for text/x-ant+xml. This feature allows
		62	* to "inject" Fold types and FoldManager on general MIME type ("") for all
		63	* types of files.
		64	*
65	* @author sdedic
66	* @since 1.34
67	*/
68	@MimeLocation(subfolderName = "FoldManager")
69	public interface FoldTypeProvider {
70	/**
71	* Enumerates values for the given type.
72	* @return FoldType values.
73	*/
74	public Collection getValues(Class type);
75
76	/**
77	* Determines whether the folds propagate to child mime types(paths).
78	* If the method returns true, then more specific MIME types will also
79	* list FoldTypes returned by this Provider.
80	*
81	* @return whether the provided FoldTypes should be inherited (true).
82	*/
83	public boolean inheritable();
84
85	}

Lines 107-112 Link Here

(-)a/editor.lib/apichanges.xml (+30 lines)
107	<!-- ACTUAL CHANGES BEGIN HERE: -->	107	<!-- ACTUAL CHANGES BEGIN HERE: -->
108		108
109	<changes>	109	<changes>
		110	<change id="caret-fold-cleanup">
		111	<summary>Removed dependencies on Folding</summary>
		112	<version major="3" minor="37"/>
		113	<date day="26" month="2" year="2013"/>
		114	<author login="sdedic"/>
		115	<compatibility binary="incompatible" source="incompatible" semantic="compatible" addition="yes"/>
		116	<description>
		117	<p>
		118	Inheritance of FoldHierarchyListener was removed, as it was the last dependency on
		119	fold API from the editor.lib module.
		120	</p>
		121	</description>
		122	<class name="BaseCaret" package="org.netbeans.editor"/>
		123	<issue number="226368"/>
		124	</change>
		125	<change id="caret-refresh">
		126	<summary>Allow to refresh editor view so that caret is visible</summary>
		127	<version major="3" minor="37"/>
		128	<date day="26" month="2" year="2013"/>
		129	<author login="sdedic"/>
		130	<compatibility binary="compatible" source="compatible" semantic="compatible" addition="yes"/>
		131	<description>
		132	<p>
		133	The method helps to ensure that the caret, if it was originally visible on the screen,
		134	will remain visible after some view hierarchy change (i.e. define a new fold).
		135	</p>
		136	</description>
		137	<class name="BaseCaret" package="org.netbeans.editor"/>
		138	<issue number="226368"/>
		139	</change>
110	<change id="moving-find">	140	<change id="moving-find">
111	<summary>Moving find implementations to module editor.search</summary>	141	<summary>Moving find implementations to module editor.search</summary>
112	<version major="3" minor="36"/>	142	<version major="3" minor="36"/>

Lines 59-72 Link Here

(-)a/editor.lib/nbproject/project.xml (-8 lines)
59	</run-dependency>	59	</run-dependency>
60	</dependency>	60	</dependency>
61	<dependency>	61	<dependency>
62	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
63	<build-prerequisite/>
64	<compile-dependency/>
65	<run-dependency>
66	<release-version>1</release-version>
67	</run-dependency>
68	</dependency>
69	<dependency>
70	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>	62	<code-name-base>org.netbeans.modules.editor.indent</code-name-base>
71	<build-prerequisite/>	63	<build-prerequisite/>
72	<compile-dependency/>	64	<compile-dependency/>

Lines 84-93 Link Here

(-)a/editor.lib/src/org/netbeans/editor/ActionFactory.java (-193 / +7 lines)
84	import org.netbeans.api.editor.EditorActionNames;	84	import org.netbeans.api.editor.EditorActionNames;
85	import org.netbeans.api.editor.EditorActionRegistration;	85	import org.netbeans.api.editor.EditorActionRegistration;
86	import org.netbeans.api.editor.EditorActionRegistrations;	86	import org.netbeans.api.editor.EditorActionRegistrations;
87	import org.netbeans.api.editor.fold.Fold;
88	import org.netbeans.api.editor.fold.FoldHierarchy;
89	import org.netbeans.api.editor.fold.FoldUtilities;
90	import org.netbeans.api.lexer.TokenHierarchy;
91	import org.netbeans.api.progress.ProgressUtils;	87	import org.netbeans.api.progress.ProgressUtils;
92	import org.netbeans.lib.editor.util.swing.DocumentUtilities;	88	import org.netbeans.lib.editor.util.swing.DocumentUtilities;
93	import org.netbeans.lib.editor.util.swing.PositionRegion;	89	import org.netbeans.lib.editor.util.swing.PositionRegion;
Lines 2106-2297 Link Here
2106	}	2102	}
2107		2103
2108		2104
2109	/** Returns the fold that should be collapsed/expanded in the caret row
2110	* @param hierarchy hierarchy under which all folds should be collapsed/expanded.
2111	* @param dot caret position offset
2112	* @param lineStart offset of the start of line
2113	* @param lineEnd offset of the end of line
2114	* @return the fold that meet common criteria in accordance with the caret position
2115	*/
2116	private static Fold getLineFold(FoldHierarchy hierarchy, int dot, int lineStart, int lineEnd){
2117	Fold caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, dot);
2118
2119	// beginning searching from the lineStart
2120	Fold fold = FoldUtilities.findNearestFold(hierarchy, lineStart);
2121
2122	while (fold!=null &&
2123	(fold.getEndOffset()<=dot \|\| // find next available fold if the 'fold' is one-line
2124	// or it has children and the caret is in the fold body
2125	// i.e. class A{ \|public void method foo(){}}
2126	(!fold.isCollapsed() && fold.getFoldCount() > 0 && fold.getStartOffset()+1<dot)
2127	)
2128	){
2129
2130	// look for next fold in forward direction
2131	Fold nextFold = FoldUtilities.findNearestFold(hierarchy,
2132	(fold.getFoldCount()>0) ? fold.getStartOffset()+1 : fold.getEndOffset());
2133	if (nextFold!=null && nextFold.getStartOffset()<lineEnd){
2134	if (nextFold == fold) return fold;
2135	fold = nextFold;
2136	}else{
2137	break;
2138	}
2139	}
2140
2141
2142	// a fold on the next line was found, returning fold at offset (in most cases inner class)
2143	if (fold == null \|\| fold.getStartOffset()>lineEnd) {
2144
2145	// in the case:
2146	// class A{
2147	// } \|
2148	// try to find an offset fold on the offset of the line beginning
2149	if (caretOffsetFold == null){
2150	caretOffsetFold = FoldUtilities.findOffsetFold(hierarchy, lineStart);
2151	}
2152
2153	return caretOffsetFold;
2154	}
2155
2156	// no fold at offset found, in this case return the fold
2157	if (caretOffsetFold == null) return fold;
2158
2159	// skip possible inner class members validating if the innerclass fold is collapsed
2160	if (caretOffsetFold.isCollapsed()) return caretOffsetFold;
2161
2162	// in the case:
2163	// class A{
2164	// public vo\|id foo(){} }
2165	// 'fold' (in this case fold of the method foo) will be returned
2166	if ( caretOffsetFold.getEndOffset()>fold.getEndOffset() &&
2167	fold.getEndOffset()>dot){
2168	return fold;
2169	}
2170
2171	// class A{
2172	// \|} public void method foo(){}
2173	// inner class fold will be returned
2174	if (fold.getStartOffset()>caretOffsetFold.getEndOffset()) return caretOffsetFold;
2175
2176	// class A{
2177	// public void foo(){} \|}
2178	// returning innerclass fold
2179	if (fold.getEndOffset()<dot) return caretOffsetFold;
2180
2181	return fold;
2182	}
2183
2184	/** Collapse a fold. Depends on the current caret position. */
2185	@EditorActionRegistration(name = BaseKit.collapseFoldAction,
2186	menuText = "#" + BaseKit.collapseFoldAction + "_menu_text")
2187	public static class CollapseFold extends LocalBaseAction {
2188	public CollapseFold(){
2189	}
2190
2191	private boolean dotInFoldArea(JTextComponent target, Fold fold, int dot) throws BadLocationException{
2192	int foldStart = fold.getStartOffset();
2193	int foldEnd = fold.getEndOffset();
2194	int foldRowStart = javax.swing.text.Utilities.getRowStart(target, foldStart);
2195	int foldRowEnd = javax.swing.text.Utilities.getRowEnd(target, foldEnd);
2196	if (foldRowStart > dot \|\| foldRowEnd < dot) return false; // it's not fold encapsulating dot
2197	return true;
2198	}
2199
2200
2201	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2202	Document doc = target.getDocument();
2203	doc.render(new Runnable() {
2204	@Override
2205	public void run() {
2206	FoldHierarchy hierarchy = FoldHierarchy.get(target);
2207	int dot = target.getCaret().getDot();
2208	hierarchy.lock();
2209	try{
2210	try{
2211	int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
2212	int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
2213	Fold fold = FoldUtilities.findNearestFold(hierarchy, rowStart);
2214	fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
2215	if (fold==null){
2216	return; // no success
2217	}
2218	// ensure we' got the right fold
2219	if (dotInFoldArea(target, fold, dot)){
2220	hierarchy.collapse(fold);
2221	}
2222	}catch(BadLocationException ble){
2223	ble.printStackTrace();
2224	}
2225	}finally {
2226	hierarchy.unlock();
2227	}
2228	}
2229	});
2230	}
2231	}
2232
2233	/** Expand a fold. Depends on the current caret position. */
2234	@EditorActionRegistration(name = BaseKit.expandFoldAction,
2235	menuText = "#" + BaseKit.expandFoldAction + "_menu_text")
2236	public static class ExpandFold extends LocalBaseAction {
2237	public ExpandFold(){
2238	}
2239
2240	public void actionPerformed(ActionEvent evt, final JTextComponent target) {
2241	Document doc = target.getDocument();
2242	doc.render(new Runnable() {
2243	@Override
2244	public void run() {
2245	FoldHierarchy hierarchy = FoldHierarchy.get(target);
2246	int dot = target.getCaret().getDot();
2247	hierarchy.lock();
2248	try {
2249	try {
2250	int rowStart = javax.swing.text.Utilities.getRowStart(target, dot);
2251	int rowEnd = javax.swing.text.Utilities.getRowEnd(target, dot);
2252	Fold fold = getLineFold(hierarchy, dot, rowStart, rowEnd);
2253	if (fold != null) {
2254	hierarchy.expand(fold);
2255	}
2256	} catch (BadLocationException ble) {
2257	ble.printStackTrace();
2258	}
2259	} finally {
2260	hierarchy.unlock();
2261	}
2262	}
2263	});
2264	}
2265	}
2266
2267	/** Collapse all existing folds in the document. */
2268	@EditorActionRegistration(name = BaseKit.collapseAllFoldsAction,
2269	menuText = "#" + BaseKit.collapseAllFoldsAction + "_menu_text")
2270	public static class CollapseAllFolds extends LocalBaseAction {
2271	public CollapseAllFolds(){
2272	}
2273
2274	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2275	FoldHierarchy hierarchy = FoldHierarchy.get(target);
2276	// Hierarchy locking done in the utility method
2277	FoldUtilities.collapseAll(hierarchy);
2278	}
2279	}
2280
2281	/** Expand all existing folds in the document. */
2282	@EditorActionRegistration(name = BaseKit.expandAllFoldsAction,
2283	menuText = "#" + BaseKit.expandAllFoldsAction + "_menu_text")
2284	public static class ExpandAllFolds extends LocalBaseAction {
2285	public ExpandAllFolds(){
2286	}
2287
2288	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2289	FoldHierarchy hierarchy = FoldHierarchy.get(target);
2290	// Hierarchy locking done in the utility method
2291	FoldUtilities.expandAll(hierarchy);
2292	}
2293	}
2294
2295	/** Expand all existing folds in the document. */	2105	/** Expand all existing folds in the document. */
2296	@EditorActionRegistration(name = "dump-view-hierarchy")	2106	@EditorActionRegistration(name = "dump-view-hierarchy")
2297	public static class DumpViewHierarchyAction extends LocalBaseAction {	2107	public static class DumpViewHierarchyAction extends LocalBaseAction {
Lines 2303-2317 Link Here
2303	public void actionPerformed(ActionEvent evt, JTextComponent target) {	2113	public void actionPerformed(ActionEvent evt, JTextComponent target) {
2304	AbstractDocument adoc = (AbstractDocument)target.getDocument();	2114	AbstractDocument adoc = (AbstractDocument)target.getDocument();
2305		2115
		2116	/*
		2117	* Folding has moved to editor.fold module. It must somehow hook
		2118	* into this dump to provide the information.
		2119
2306	// Dump fold hierarchy	2120	// Dump fold hierarchy
2307	FoldHierarchy hierarchy = FoldHierarchy.get(target);	2121	FoldHierarchy hierarchy = FoldHierarchy.get(target);
2308	adoc.readLock();	2122	adoc.readLock();
2309	try {	2123	try {
2310	hierarchy.lock();	2124	hierarchy.lock();
2311	try {	2125	try {
2312	/DEBUG/System.err.println("FOLD HIERARCHY DUMP:\n" + hierarchy); // NOI18N	2126	/DEBUG /System.err.println("FOLD HIERARCHY DUMP:\n" + hierarchy); // NOI18N
2313	TokenHierarchy<?> th = TokenHierarchy.get(adoc);	2127	TokenHierarchy<?> th = TokenHierarchy.get(adoc);
2314	/DEBUG/System.err.println("TOKEN HIERARCHY DUMP:\n" + (th != null ? th : "<NULL-TH>")); // NOI18N	2128	/DEBUG /System.err.println("TOKEN HIERARCHY DUMP:\n" + (th != null ? th : "<NULL-TH>")); // NOI18N
2315		2129
2316	} finally {	2130	} finally {
2317	hierarchy.unlock();	2131	hierarchy.unlock();
Lines 2319-2325 Link Here
2319	} finally {	2133	} finally {
2320	adoc.readUnlock();	2134	adoc.readUnlock();
2321	}	2135	}
2322		2136	*/
2323	View rootView = null;	2137	View rootView = null;
2324	TextUI textUI = target.getUI();	2138	TextUI textUI = target.getUI();
2325	if (textUI != null) {	2139	if (textUI != null) {

Lines 78-83 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseCaret.java (-145 / +80 lines)
78	import java.io.IOException;	78	import java.io.IOException;
79	import java.util.ArrayList;	79	import java.util.ArrayList;
80	import java.util.List;	80	import java.util.List;
		81	import java.util.concurrent.Callable;
81	import java.util.logging.Level;	82	import java.util.logging.Level;
82	import java.util.logging.Logger;	83	import java.util.logging.Logger;
83	import java.util.prefs.PreferenceChangeEvent;	84	import java.util.prefs.PreferenceChangeEvent;
Lines 105-116 Link Here
105	import javax.swing.text.AttributeSet;	106	import javax.swing.text.AttributeSet;
106	import javax.swing.text.Position;	107	import javax.swing.text.Position;
107	import javax.swing.text.StyleConstants;	108	import javax.swing.text.StyleConstants;
108	import org.netbeans.api.editor.fold.Fold;
109	import org.netbeans.api.editor.fold.FoldHierarchy;
110	import org.netbeans.api.editor.fold.FoldHierarchyEvent;
111	import org.netbeans.api.editor.fold.FoldHierarchyListener;
112	import org.netbeans.api.editor.fold.FoldStateChange;
113	import org.netbeans.api.editor.fold.FoldUtilities;
114	import org.netbeans.api.editor.mimelookup.MimeLookup;	109	import org.netbeans.api.editor.mimelookup.MimeLookup;
115	import org.netbeans.api.editor.settings.FontColorNames;	110	import org.netbeans.api.editor.settings.FontColorNames;
116	import org.netbeans.api.editor.settings.FontColorSettings;	111	import org.netbeans.api.editor.settings.FontColorSettings;
Lines 136-142 Link Here
136	public class BaseCaret implements Caret,	131	public class BaseCaret implements Caret,
137	MouseListener, MouseMotionListener, PropertyChangeListener,	132	MouseListener, MouseMotionListener, PropertyChangeListener,
138	DocumentListener, ActionListener,	133	DocumentListener, ActionListener,
139	AtomicLockListener, FoldHierarchyListener {	134	AtomicLockListener {
140		135
141	/** Caret type representing block covering current character */	136	/** Caret type representing block covering current character */
142	public static final String BLOCK_CARET = EditorPreferencesDefaults.BLOCK_CARET; // NOI18N	137	public static final String BLOCK_CARET = EditorPreferencesDefaults.BLOCK_CARET; // NOI18N
Lines 279-285 Link Here
279	* its relative visual position on the screen.	274	* its relative visual position on the screen.
280	*/	275	*/
281	private boolean updateAfterFoldHierarchyChange;	276	private boolean updateAfterFoldHierarchyChange;
282	private FoldHierarchyListener weakFHListener;
283		277
284	/**	278	/**
285	* Whether at least one typing change occurred during possibly several atomic operations.	279	* Whether at least one typing change occurred during possibly several atomic operations.
Lines 530-542 Link Here
530	EditorUI editorUI = Utilities.getEditorUI(c);	524	EditorUI editorUI = Utilities.getEditorUI(c);
531	editorUI.removePropertyChangeListener(this);	525	editorUI.removePropertyChangeListener(this);
532		526
533	if (weakFHListener != null) {
534	FoldHierarchy hierarchy = FoldHierarchy.get(c);
535	if (hierarchy != null) {
536	hierarchy.removeFoldHierarchyListener(weakFHListener);
537	}
538	}
539
540	modelChanged(listenDoc, null);	527	modelChanged(listenDoc, null);
541	}	528	}
542		529
Lines 1231-1257 Link Here
1231	caretPos = doc.createPosition(offset);	1218	caretPos = doc.createPosition(offset);
1232	markPos = doc.createPosition(offset);	1219	markPos = doc.createPosition(offset);
1233		1220
1234	FoldHierarchy hierarchy = FoldHierarchy.get(c);	1221	Callable<Boolean> cc = (Callable<Boolean>)c.getClientProperty("org.netbeans.api.fold.expander");
1235	// hook the listener if not already done	1222	if (cc != null) {
1236	if (weakFHListener == null) {	1223	// the caretPos/markPos were already called.
1237	weakFHListener = WeakListeners.create(FoldHierarchyListener.class, this, hierarchy);	1224	// nothing except the document is locked at this moment.
1238	hierarchy.addFoldHierarchyListener(weakFHListener);	1225	try {
1239	}	1226	cc.call();
1240		1227	} catch (Exception ex) {
1241	// Unfold fold	1228	Exceptions.printStackTrace(ex);
1242	hierarchy.lock();
1243	try {
1244	Fold collapsed = null;
1245	while (expandFold && (collapsed = FoldUtilities.findCollapsedFold(hierarchy, offset, offset)) != null && collapsed.getStartOffset() < offset &&
1246	collapsed.getEndOffset() > offset) {
1247	hierarchy.expand(collapsed);
1248	}	1229	}
1249	} finally {
1250	hierarchy.unlock();
1251	}	1230	}
1252	if (rectangularSelection) {	1231	if (rectangularSelection) {
1253	setRectangularSelectionToDotAndMark();	1232	setRectangularSelectionToDotAndMark();
1254	}	1233	}
		1234
1255	} catch (BadLocationException e) {	1235	} catch (BadLocationException e) {
1256	throw new IllegalStateException(e.toString());	1236	throw new IllegalStateException(e.toString());
1257	// setting the caret to wrong position leaves it at current position	1237	// setting the caret to wrong position leaves it at current position
Lines 1510-1546 Link Here
1510	// Disable drag which would otherwise occur when mouse would be over text	1490	// Disable drag which would otherwise occur when mouse would be over text
1511	c.setDragEnabled(false);	1491	c.setDragEnabled(false);
1512	// Check possible fold expansion	1492	// Check possible fold expansion
1513	FoldHierarchy hierarchy = FoldHierarchy.get(c);	1493	try {
1514	Document doc = c.getDocument();	1494	// hack, to get knowledge of possible expansion. Editor depends on Folding, so it's not really possible
1515	if (doc instanceof AbstractDocument) {	1495	// to have Folding depend on BaseCaret (= a cycle). If BaseCaret moves to editor.lib2, this contract
1516	AbstractDocument adoc = (AbstractDocument) doc;	1496	// can be formalized as an interface.
1517	adoc.readLock();	1497	Callable<Boolean> cc = (Callable<Boolean>)c.getClientProperty("org.netbeans.api.fold.expander");
1518	try {	1498	if (cc == null \|\| !cc.call()) {
1519	hierarchy.lock();	1499	if (selectWordAction == null) {
1520	try {	1500	selectWordAction = ((BaseKit) c.getUI().getEditorKit(
1521	Fold collapsed = FoldUtilities.findCollapsedFold(	1501	c)).getActionByName(BaseKit.selectWordAction);
1522	hierarchy, offset, offset);
1523	if (collapsed != null && collapsed.getStartOffset() <= offset
1524	&& collapsed.getEndOffset() >= offset) {
1525	hierarchy.expand(collapsed);
1526	} else {
1527	if (selectWordAction == null) {
1528	selectWordAction = ((BaseKit) c.getUI().getEditorKit(
1529	c)).getActionByName(BaseKit.selectWordAction);
1530	}
1531	if (selectWordAction != null) {
1532	selectWordAction.actionPerformed(null);
1533	}
1534	// Select word action selects forward i.e. dot > mark
1535	minSelectionStartOffset = getMark();
1536	minSelectionEndOffset = getDot();
1537	}
1538	} finally {
1539	hierarchy.unlock();
1540	}	1502	}
1541	} finally {	1503	if (selectWordAction != null) {
1542	adoc.readUnlock();	1504	selectWordAction.actionPerformed(null);
		1505	}
		1506	// Select word action selects forward i.e. dot > mark
		1507	minSelectionStartOffset = getMark();
		1508	minSelectionEndOffset = getDot();
1543	}	1509	}
		1510	} catch (Exception ex) {
		1511	Exceptions.printStackTrace(ex);
1544	}	1512	}
1545	break;	1513	break;
1546		1514
Lines 1617-1653 Link Here
1617	JTextComponent c = component;	1585	JTextComponent c = component;
1618	if (c != null) {	1586	if (c != null) {
1619	if (isMiddleMouseButtonExt(evt)) {	1587	if (isMiddleMouseButtonExt(evt)) {
1620	if (evt.getClickCount() == 1) {	1588	if (evt.getClickCount() == 1) {
1621	if (c == null) return;	1589	if (c == null) {
		1590	return;
		1591	}
1622	Clipboard buffer = getSystemSelection();	1592	Clipboard buffer = getSystemSelection();
1623		1593
1624	if (buffer == null) return;	1594	if (buffer == null) {
		1595	return;
		1596	}
1625		1597
1626	Transferable trans = buffer.getContents(null);	1598	Transferable trans = buffer.getContents(null);
1627	if (trans == null) return;	1599	if (trans == null) {
		1600	return;
		1601	}
1628		1602
1629	final BaseDocument doc = (BaseDocument)c.getDocument();	1603	final BaseDocument doc = (BaseDocument) c.getDocument();
1630	if (doc == null) return;	1604	if (doc == null) {
1631		1605	return;
1632	final int offset = ((BaseTextUI)c.getUI()).viewToModel(c,	1606	}
1633	evt.getX(), evt.getY());
1634		1607
1635	try{	1608	final int offset = ((BaseTextUI) c.getUI()).viewToModel(c,
1636	final String pastingString = (String)trans.getTransferData(DataFlavor.stringFlavor);	1609	evt.getX(), evt.getY());
1637	if (pastingString == null) return;	1610
1638	doc.runAtomicAsUser (new Runnable () {	1611	try {
1639	public @Override void run () {	1612	final String pastingString = (String) trans.getTransferData(DataFlavor.stringFlavor);
1640	try {	1613	if (pastingString == null) {
1641	doc.insertString(offset, pastingString, null);	1614	return;
1642	setDot(offset+pastingString.length());	1615	}
1643	} catch( BadLocationException exc ) {	1616	doc.runAtomicAsUser(new Runnable() {
1644	}	1617	public @Override
		1618	void run() {
		1619	try {
		1620	doc.insertString(offset, pastingString, null);
		1621	setDot(offset + pastingString.length());
		1622	} catch (BadLocationException exc) {
		1623	}
1645	}	1624	}
1646	});	1625	});
1647	}catch(UnsupportedFlavorException ufe){	1626	} catch (UnsupportedFlavorException ufe) {
1648	}catch(IOException ioe){	1627	} catch (IOException ioe) {
1649	}	1628	}
1650	}	1629	}
1651	}	1630	}
1652	}	1631	}
1653	}	1632	}
Lines 2110-2176 Link Here
2110	}	2089	}
2111	}	2090	}
2112		2091
2113	public @Override void foldHierarchyChanged(FoldHierarchyEvent evt) {
2114	int caretOffset = getDot();
2115	final int addedFoldCnt = evt.getAddedFoldCount();
2116	final boolean scrollToView;
2117	LOG.finest("Received fold hierarchy change");
2118	if (addedFoldCnt > 0) {
2119	FoldHierarchy hierarchy = (FoldHierarchy) evt.getSource();
2120	Fold collapsed = null;
2121	boolean wasExpanded = false;
2122	while ((collapsed = FoldUtilities.findCollapsedFold(hierarchy, caretOffset, caretOffset)) != null && collapsed.getStartOffset() < caretOffset &&
2123	collapsed.getEndOffset() > caretOffset) {
2124	hierarchy.expand(collapsed);
2125	wasExpanded = true;
2126	}
2127	// prevent unneeded scrolling; the user may have scrolled out using mouse already
2128	// so scroll only if the added fold may affect Y axis. Actually it's unclear why
2129	// we should reveal the current position on fold events except when caret is positioned in now-collapsed fold
2130	scrollToView = wasExpanded;
2131	} else {
2132	int startOffset = Integer.MAX_VALUE;
2133	// Set the caret's offset to the end of just collapsed fold if necessary
2134	if (evt.getAffectedStartOffset() <= caretOffset && evt.getAffectedEndOffset() >= caretOffset) {
2135	for (int i = 0; i < evt.getFoldStateChangeCount(); i++) {
2136	FoldStateChange change = evt.getFoldStateChange(i);
2137	if (change.isCollapsedChanged()) {
2138	Fold fold = change.getFold();
2139	if (fold.isCollapsed() && fold.getStartOffset() <= caretOffset && fold.getEndOffset() >= caretOffset) {
2140	if (fold.getStartOffset() < startOffset) {
2141	startOffset = fold.getStartOffset();
2142	}
2143	}
2144	}
2145	}
2146	if (startOffset != Integer.MAX_VALUE) {
2147	setDot(startOffset, false);
2148	}
2149	}
2150	scrollToView = false;
2151	}
2152	// Update caret's visual position
2153	// Post the caret update asynchronously since the fold hierarchy is updated before
2154	// the view hierarchy and the views so the dispatchUpdate() could be picking obsolete
2155	// view information.
2156	SwingUtilities.invokeLater(new Runnable() {
2157	public @Override void run() {
2158	LOG.finest("Updating after fold hierarchy change");
2159	if (component == null) {
2160	return;
2161	}
2162	// see #217867
2163	Rectangle b = caretBounds;
2164	updateAfterFoldHierarchyChange = b != null;
2165	boolean wasInView = b != null && component.getVisibleRect().intersects(b);
2166	// scroll if:
2167	// a/ a fold was added and the caret was originally in the view
2168	// b/ scrollToView is true (= caret was positioned within a new now collapsed fold)
2169	dispatchUpdate((addedFoldCnt > 1 && wasInView) \|\| scrollToView);
2170	}
2171	});
2172	}
2173
2174	void scheduleCaretUpdate() {	2092	void scheduleCaretUpdate() {
2175	if (!caretUpdatePending) {	2093	if (!caretUpdatePending) {
2176	caretUpdatePending = true;	2094	caretUpdatePending = true;
Lines 2304-2308 Link Here
2304	DRAG_SELECTION // Drag is being done (text selection existed at the mouse press)	2222	DRAG_SELECTION // Drag is being done (text selection existed at the mouse press)
2305		2223
2306	}	2224	}
2307		2225
		2226	/**
		2227	* Refreshes caret display on the screen.
		2228	* Some height or view changes may result in the caret going off the screen. In some cases, this is not desirable,
		2229	* as the user's work may be interrupted by e.g. an automatic refresh. This method repositions the view so the
		2230	* caret remains visible.
		2231	* <p/>
		2232	* The method has two modes: it can reposition the view just if it originally displayed the caret and the caret became
		2233	* invisible, and it can scroll the caret into view unconditionally.
		2234	* @param retainInView true to scroll only if the caret was visible. False to refresh regardless of visibility.
		2235	*/
		2236	public void refresh(boolean retainInView) {
		2237	Rectangle b = caretBounds;
		2238	updateAfterFoldHierarchyChange = b != null;
		2239	boolean wasInView = b != null && component.getVisibleRect().intersects(b);
		2240	update(!retainInView \|\| wasInView);
		2241	}
		2242
2308	}	2243	}

Lines 59-72 Link Here

(-)a/editor.lib/src/org/netbeans/editor/Bundle.properties (-12 lines)
59	bracket-match=Match Bracket	59	bracket-match=Match Bracket
60	build-popup-menu=Build Popup Menu	60	build-popup-menu=Build Popup Menu
61	dump-view-hierarchy=Dump View Hierarchy	61	dump-view-hierarchy=Dump View Hierarchy
62	collapse-all-folds_menu_text=Co&llapse All
63	collapse-fold_menu_text=&Collapse Fold
64	expand-all-folds_menu_text=E&xpand All
65	expand-fold_menu_text=&Expand Fold
66	collapse-all-folds=Collapse All
67	collapse-fold=Collapse Fold
68	expand-all-folds=Expand All
69	expand-fold=Expand Fold
70	build-tool-tip=Build Tool Tip	62	build-tool-tip=Build Tool Tip
71	caret-backward=Insertion Point Backward	63	caret-backward=Insertion Point Backward
72	caret-begin-line=Insertion Point to Beginning of Text on Line	64	caret-begin-line=Insertion Point to Beginning of Text on Line
Lines 311-320 Link Here
311	## ext.Completion.java	303	## ext.Completion.java
312	ext.Completion.wait=Please wait...	304	ext.Completion.wait=Please wait...
313		305
314	# CodeFoldingSideBar
315	ACSN_CodeFoldingSideBar=Code folding side bar
316	ACSD_CodeFoldingSideBar=Code folding side bar shows text folds and allows their collapsing and expanding.
317
318	# Format Action	306	# Format Action
319	Format_in_progress=Formatting text, please wait...	307	Format_in_progress=Formatting text, please wait...
320		308

Lines 88-96 Link Here

(-)a/editor.lib/src/org/netbeans/editor/GlyphGutter.java (-29 lines)
88	import javax.swing.text.Element;	88	import javax.swing.text.Element;
89	import javax.swing.text.JTextComponent;	89	import javax.swing.text.JTextComponent;
90	import javax.swing.text.View;	90	import javax.swing.text.View;
91	import org.netbeans.api.editor.fold.FoldHierarchy;
92	import org.netbeans.api.editor.fold.FoldHierarchyEvent;
93	import org.netbeans.api.editor.fold.FoldHierarchyListener;
94	import org.netbeans.api.editor.mimelookup.MimeLookup;	91	import org.netbeans.api.editor.mimelookup.MimeLookup;
95	import org.netbeans.api.editor.settings.EditorStyleConstants;	92	import org.netbeans.api.editor.settings.EditorStyleConstants;
96	import org.netbeans.api.editor.settings.FontColorNames;	93	import org.netbeans.api.editor.settings.FontColorNames;
Lines 182-190 Link Here
182	/** Property change listener on AnnotationTypes changes */	179	/** Property change listener on AnnotationTypes changes */
183	private PropertyChangeListener annoTypesListener;	180	private PropertyChangeListener annoTypesListener;
184	private PropertyChangeListener editorUIListener;	181	private PropertyChangeListener editorUIListener;
185	private GlyphGutter.GlyphGutterFoldHierarchyListener glyphGutterFoldHierarchyListener;
186	private GutterMouseListener gutterMouseListener;	182	private GutterMouseListener gutterMouseListener;
187	private FoldHierarchy foldHierarchy;
188		183
189	private ColoringMap coloringMap;	184	private ColoringMap coloringMap;
190	private final PropertyChangeListener coloringMapListener = new PropertyChangeListener() {	185	private final PropertyChangeListener coloringMapListener = new PropertyChangeListener() {
Lines 234-242 Link Here
234	init();	229	init();
235	update();	230	update();
236	setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));	231	setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
237	foldHierarchy = FoldHierarchy.get(eui.getComponent());
238	glyphGutterFoldHierarchyListener = new GlyphGutterFoldHierarchyListener();
239	foldHierarchy.addFoldHierarchyListener(glyphGutterFoldHierarchyListener);
240	editorUIListener = new EditorUIListener();	232	editorUIListener = new EditorUIListener();
241	eui.addPropertyChangeListener(editorUIListener);	233	eui.addPropertyChangeListener(editorUIListener);
242	eui.getComponent().addPropertyChangeListener(editorUIListener);	234	eui.getComponent().addPropertyChangeListener(editorUIListener);
Lines 1096-1119 Link Here
1096		1088
1097	}	1089	}
1098		1090
1099	class GlyphGutterFoldHierarchyListener implements FoldHierarchyListener, Runnable {
1100
1101	public GlyphGutterFoldHierarchyListener(){
1102	}
1103
1104	public @Override void foldHierarchyChanged(FoldHierarchyEvent evt) {
1105	// Do not react to fold changes since fold expanding/collapsing should trigger
1106	// corresponding view hierarchy changes covered by view hierarchy listener.
1107
1108	// SwingUtilities.invokeLater(this);
1109	}
1110
1111	@Override
1112	public void run() {
1113	repaint();
1114	}
1115	}
1116
1117	/** Listening to EditorUI to properly deinstall attached listeners */	1091	/** Listening to EditorUI to properly deinstall attached listeners */
1118	class EditorUIListener implements PropertyChangeListener{	1092	class EditorUIListener implements PropertyChangeListener{
1119	public @Override void propertyChange (PropertyChangeEvent evt) {	1093	public @Override void propertyChange (PropertyChangeEvent evt) {
Lines 1126-1132 Link Here
1126	((JTextComponent) evt.getOldValue()).removePropertyChangeListener(this);	1100	((JTextComponent) evt.getOldValue()).removePropertyChangeListener(this);
1127	}	1101	}
1128	annos.removeAnnotationsListener(GlyphGutter.this);	1102	annos.removeAnnotationsListener(GlyphGutter.this);
1129	foldHierarchy.removeFoldHierarchyListener(glyphGutterFoldHierarchyListener);
1130	if (gutterMouseListener!=null){	1103	if (gutterMouseListener!=null){
1131	removeMouseListener(gutterMouseListener);	1104	removeMouseListener(gutterMouseListener);
1132	removeMouseMotionListener(gutterMouseListener);	1105	removeMouseMotionListener(gutterMouseListener);
Lines 1134-1141 Link Here
1134	if (annoTypesListener !=null){	1107	if (annoTypesListener !=null){
1135	AnnotationTypes.getTypes().removePropertyChangeListener(annoTypesListener);	1108	AnnotationTypes.getTypes().removePropertyChangeListener(annoTypesListener);
1136	}	1109	}
1137	foldHierarchy.removeFoldHierarchyListener(glyphGutterFoldHierarchyListener);
1138	foldHierarchy = null;
1139	editorUI = null;	1110	editorUI = null;
1140	annos = null;	1111	annos = null;
1141	}	1112	}

Lines 48-67 Link Here

(-)a/editor.lib/src/org/netbeans/modules/editor/lib/drawing/DrawEngineDocView.java (-201 / +2 lines)
48	import java.awt.Rectangle;	48	import java.awt.Rectangle;
49	import java.awt.Shape;	49	import java.awt.Shape;
50	import java.beans.PropertyChangeListener;	50	import java.beans.PropertyChangeListener;
51	import java.util.ArrayList;
52	import java.util.Iterator;
53	import java.util.List;
54	import javax.swing.plaf.TextUI;	51	import javax.swing.plaf.TextUI;
55	import javax.swing.text.AbstractDocument;	52	import javax.swing.text.AbstractDocument;
56	import javax.swing.text.Element;	53	import javax.swing.text.Element;
57	import javax.swing.text.JTextComponent;	54	import javax.swing.text.JTextComponent;
58	import javax.swing.text.View;	55	import javax.swing.text.View;
59	import javax.swing.text.ViewFactory;	56	import javax.swing.text.ViewFactory;
60	import org.netbeans.api.editor.fold.Fold;
61	import org.netbeans.api.editor.fold.FoldHierarchy;
62	import org.netbeans.api.editor.fold.FoldUtilities;
63	import org.netbeans.api.editor.fold.FoldHierarchyEvent;
64	import org.netbeans.api.editor.fold.FoldHierarchyListener;
65	import org.netbeans.editor.BaseTextUI;	57	import org.netbeans.editor.BaseTextUI;
66	import org.netbeans.editor.EditorUI;	58	import org.netbeans.editor.EditorUI;
67	import org.netbeans.lib.editor.view.GapDocumentView;	59	import org.netbeans.lib.editor.view.GapDocumentView;
Lines 73-91 Link Here
73	* @author Miloslav Metelka	65	* @author Miloslav Metelka
74	*/	66	*/
75	public class DrawEngineDocView extends GapDocumentView	67	public class DrawEngineDocView extends GapDocumentView
76	implements FoldHierarchyListener, PropertyChangeListener {	68	implements PropertyChangeListener {
77		69
78	private static final boolean debugRebuild	70	private static final boolean debugRebuild
79	= Boolean.getBoolean("netbeans.debug.editor.view.rebuild"); // NOI18N	71	= Boolean.getBoolean("netbeans.debug.editor.view.rebuild"); // NOI18N
80		72
81	private FoldHierarchy foldHierarchy;
82	/** Editor UI listening to */	73	/** Editor UI listening to */
83	private EditorUI editorUI;	74	private EditorUI editorUI;
84		75
85	private Iterator collapsedFoldIterator;
86	private Fold collapsedFold;
87	private int collapsedFoldStartOffset;	76	private int collapsedFoldStartOffset;
88	private int collapsedFoldEndOffset;
89		77
90	private boolean collapsedFoldsInPresentViews;	78	private boolean collapsedFoldsInPresentViews;
91		79
Lines 104-111 Link Here
104	public @Override void setParent(View parent) {	92	public @Override void setParent(View parent) {
105	if (parent != null) { // start listening	93	if (parent != null) { // start listening
106	JTextComponent component = (JTextComponent)parent.getContainer();	94	JTextComponent component = (JTextComponent)parent.getContainer();
107	foldHierarchy = FoldHierarchy.get(component);
108	foldHierarchy.addFoldHierarchyListener(this);
109	TextUI tui = component.getUI();	95	TextUI tui = component.getUI();
110	if (tui instanceof BaseTextUI){	96	if (tui instanceof BaseTextUI){
111	editorUI = ((BaseTextUI)tui).getEditorUI();	97	editorUI = ((BaseTextUI)tui).getEditorUI();
Lines 118-125 Link Here
118	super.setParent(parent);	104	super.setParent(parent);
119		105
120	if (parent == null) {	106	if (parent == null) {
121	foldHierarchy.removeFoldHierarchyListener(this);
122	foldHierarchy = null;
123	if (editorUI!=null){	107	if (editorUI!=null){
124	editorUI.removePropertyChangeListener(this);	108	editorUI.removePropertyChangeListener(this);
125	editorUI = null;	109	editorUI = null;
Lines 128-238 Link Here
128	}	112	}
129		113
130	protected void attachListeners(){	114	protected void attachListeners(){
131	if (foldHierarchy != null) {
132	}
133	}
134
135	private FoldHierarchy getFoldHierarchy() {
136	return foldHierarchy;
137	}	115	}
138		116
139	protected @Override boolean useCustomReloadChildren() {	117	protected @Override boolean useCustomReloadChildren() {
140	return true;	118	return true;
141	}	119	}
142		120
143	/**
144	* Find next collapsed fold in the given offset range.
145	* @param lastCollapsedFold last collapsed fold returned by this method.
146	* @param startOffset starting offset of the area in which the collapsed folds
147	* should be searched.
148	* @param endOffset ending offset of the area in which the collapsed folds
149	* should be searched.
150	*/
151	protected Fold nextCollapsedFold() {
152	while (true) {
153	Fold fold = collapsedFoldIterator.hasNext() ? (Fold)collapsedFoldIterator.next() : null;
154
155	// Check whether the fold is not past the doc
156	if (fold != null) {
157	collapsedFoldStartOffset = fold.getStartOffset();
158	collapsedFoldEndOffset = fold.getEndOffset();
159	/* Ignore the empty folds as they would make up
160	* no visible view anyway.
161	* Although the fold hierarchy removes the empty views
162	* automatically it may happen that the document listener
163	* that the fold hierarchy attaches may not be notified yet.
164	*/
165	if (collapsedFoldStartOffset == collapsedFoldEndOffset) {
166	if (debugRebuild) {
167	/DEBUG/System.err.println(
168	"GapBoxView.nextCollapsedFold(): ignored empty fold " // NOI18N
169	+ fold
170	);
171	}
172	continue; // skip empty fold
173	}
174
175	if (collapsedFoldEndOffset > getDocument().getLength()) {
176	/* The fold is past the end of the document.
177	* If a document is going to be switched in the component
178	* the view hierarchy may be notified sooner
179	* than fold hierarchy about that change which
180	* can lead to this state.
181	* That fold is ignored together with the rest of the folds
182	* that would follow it.
183	*/
184	fold = null;
185	}
186	}
187
188	if (fold != null) {
189	collapsedFoldsInPresentViews = true;
190	}
191
192	return fold;
193	}
194	}
195
196	/**
197	* Extra initialization for custom reload of children.
198	*/
199	protected void initCustomReloadChildren(FoldHierarchy hierarchy,
200	int startOffset, int endOffset) {
201	collapsedFoldIterator = FoldUtilities.collapsedFoldIterator(hierarchy, startOffset, endOffset);
202	collapsedFold = nextCollapsedFold();
203	}
204
205	/**
206	* Free any resources required for custom reload of children.
207	*/
208	protected void finishCustomReloadChildren(FoldHierarchy hierarchy) {
209	collapsedFoldIterator = null;
210	collapsedFold = null;
211	}
212
213	protected @Override void customReloadChildren(int index, int removeLength, int startOffset, int endOffset) {
214	// if removing all the views reset the flag
215	if (index == 0 && removeLength == getViewCount()) {
216	collapsedFoldsInPresentViews = false; // suppose there will be no folds in line views
217	}
218
219	FoldHierarchy hierarchy = getFoldHierarchy();
220	// Assuming the document lock was already acquired
221	if (hierarchy != null) {
222	hierarchy.lock();
223	try {
224	initCustomReloadChildren(hierarchy, startOffset, endOffset);
225
226	super.customReloadChildren(index, removeLength, startOffset, endOffset);
227
228	finishCustomReloadChildren(hierarchy);
229
230	} finally {
231	hierarchy.unlock();
232	}
233	}
234	}
235
236	protected @Override View createCustomView(ViewFactory f,	121	protected @Override View createCustomView(ViewFactory f,
237	int startOffset, int maxEndOffset, int elementIndex) {	122	int startOffset, int maxEndOffset, int elementIndex) {
238	if (elementIndex == -1) {	123	if (elementIndex == -1) {
Lines 243-336 Link Here
243		128
244	Element elem = getElement();	129	Element elem = getElement();
245	Element lineElem = elem.getElement(elementIndex);	130	Element lineElem = elem.getElement(elementIndex);
246	boolean createCollapsed = (collapsedFold != null);	131	view = f.create(lineElem);
247
248	if (createCollapsed) { // collapsedFold != null
249	int lineElemEndOffset = lineElem.getEndOffset();
250	createCollapsed = (collapsedFoldStartOffset < lineElemEndOffset);
251	if (createCollapsed) { // need to find end of collapsed area
252	Element firstLineElem = lineElem;
253	List foldAndEndLineElemList = new ArrayList();
254
255	while (true) {
256	int _collapsedFoldEndOffset = collapsedFold.getEndOffset();
257	// Find line element index of the line in which the collapsed fold ends
258	while (_collapsedFoldEndOffset > lineElemEndOffset) {
259	elementIndex++;
260	lineElem = elem.getElement(elementIndex);
261	lineElemEndOffset = lineElem.getEndOffset();
262	}
263
264	foldAndEndLineElemList.add(collapsedFold);
265	foldAndEndLineElemList.add(lineElem);
266
267	collapsedFold = nextCollapsedFold();
268
269	// No more collapsed or next collapsed does not start on current line
270	if (collapsedFold == null \|\| collapsedFoldStartOffset >= lineElemEndOffset) {
271	break;
272	}
273	}
274
275	// Create the multi-line-view with collapsed fold(s)
276	view = new FoldMultiLineView(firstLineElem, foldAndEndLineElemList);
277	}
278	}
279
280	if (!createCollapsed) {
281	view = f.create(lineElem);
282	}
283
284	return view;	132	return view;
285	}	133	}
286		134
287	public void foldHierarchyChanged(FoldHierarchyEvent evt) {
288	LockView lockView = LockView.get(this);
289	lockView.lock();
290	try {
291	layoutLock();
292	try {
293	FoldHierarchy hierarchy = (FoldHierarchy)evt.getSource();
294	if (hierarchy.getComponent().getDocument() != lockView.getDocument()) {
295	// Comonent already has a different document assigned
296	// so this view will be abandoned anyway => do not rebuild
297	// the current chilren because of this change
298	return;
299	}
300
301	boolean rebuildViews = true;
302	int affectedStartOffset = evt.getAffectedStartOffset();
303	int affectedEndOffset = evt.getAffectedEndOffset();
304
305	// Check whether it is not a case when there were
306	// no collapsed folds before and no collapsed folds now
307	if (!collapsedFoldsInPresentViews) { // no collapsed folds previously
308	// TODO Could Integer.MAX_VALUE be used?
309	if (FoldUtilities.findCollapsedFold(hierarchy,
310	affectedStartOffset, affectedEndOffset) == null
311	) { // no collapsed folds => no need to rebuild
312	rebuildViews = false;
313	}
314	}
315
316	if (rebuildViews) {
317	/**
318	* Check the affected offsets against the current document boundaries
319	*/
320	int docLength = getDocument().getLength();
321	int rebuildStartOffset = Math.min(affectedStartOffset, docLength);
322	int rebuildEndOffset = Math.min(affectedEndOffset, docLength);
323	offsetRebuild(rebuildStartOffset, rebuildEndOffset);
324	}
325	} finally {
326	updateLayout();
327	layoutUnlock();
328	}
329	} finally {
330	lockView.unlock();
331	}
332	}
333
334	public @Override void paint(Graphics g, Shape allocation) {	135	public @Override void paint(Graphics g, Shape allocation) {
335	java.awt.Component c = getContainer();	136	java.awt.Component c = getContainer();
336	if (c instanceof javax.swing.text.JTextComponent){	137	if (c instanceof javax.swing.text.JTextComponent){

Lines 45-51 Link Here

(-)a/editor.lib/src/org/netbeans/modules/editor/lib/drawing/DrawEngineFakeDocView.java (-6 lines)
45	package org.netbeans.modules.editor.lib.drawing;	45	package org.netbeans.modules.editor.lib.drawing;
46		46
47	import javax.swing.text.Element;	47	import javax.swing.text.Element;
48	import org.netbeans.api.editor.fold.Fold;
49		48
50	/**	49	/**
51	* Fake view of the whole document supporting the code folding, operating from given startOffset	50	* Fake view of the whole document supporting the code folding, operating from given startOffset
Lines 83-93 Link Here
83	}	82	}
84		83
85	@Override	84	@Override
86	protected Fold nextCollapsedFold() {
87	return null; // simulate no collapsed folds
88	}
89
90	@Override
91	protected void attachListeners(){	85	protected void attachListeners(){
92	}	86	}
93		87

Lines 1-9 Link Here

(-)a/editor.mimelookup/nbproject/org-netbeans-modules-editor-mimelookup.sig (-2 / +3 lines)
1	#Signature file v4.1	1	#Signature file v4.1
2	#Version 1.26.1	2	#Version 1.30
3		3
4	CLSS public abstract interface !annotation java.lang.Deprecated	4	CLSS public abstract interface !annotation java.lang.Deprecated
5	anno 0 java.lang.annotation.Documented()	5	anno 0 java.lang.annotation.Documented()
6	anno 0 java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy value=RUNTIME)	6	anno 0 java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy value=RUNTIME)
		7	anno 0 java.lang.annotation.Target(java.lang.annotation.ElementType[] value=[CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE])
7	intf java.lang.annotation.Annotation	8	intf java.lang.annotation.Annotation
8		9
9	CLSS public java.lang.Object	10	CLSS public java.lang.Object
Lines 124-129 Link Here
124	meth public abstract <%0 extends java.lang.Object> {%%0} lookup(java.lang.Class<{%%0}>)	125	meth public abstract <%0 extends java.lang.Object> {%%0} lookup(java.lang.Class<{%%0}>)
125	meth public static org.openide.util.Lookup getDefault()	126	meth public static org.openide.util.Lookup getDefault()
126	supr java.lang.Object	127	supr java.lang.Object
127	hfds defaultLookup	128	hfds LOG,defaultLookup
128	hcls DefLookup,Empty	129	hcls DefLookup,Empty
129		130

Lines 532-537 Link Here

(-)a/editor.mimelookup/src/org/netbeans/api/editor/mimelookup/MimePath.java (+74 lines)
532	return true;	532	return true;
533	}	533	}
534		534
		535	/**
		536	* Returns the inherited Mime type.
		537	* For {@link #EMPTY}, returns {@code null}. For most other mime types, returns
		538	* {@code ""}. If the mime type derives from another one, such as text/ant+xml derives
		539	* from xml, the return value will be the base mime type (text/xml in the example case).
		540	* <p/>
		541	* For MimePaths that identified embedded content (more components on the MimePath),
		542	* the method returns the parent MIME of the last MIME type on the path
		543	*
		544	* @return inherited mime type, or {@code null}, if no parent exists (for {@link #EMPTY})
		545	*/
		546	public String getInheritedType() {
		547	if ("".equals(mimeType)) {
		548	return null;
		549	}
		550	MimePath lastType = (size() == 1) ? this : MimePath.parse(mimeType);
		551	List<String> inheritedPaths = lastType.getInheritedPaths(null, null);
		552	if (inheritedPaths.size() > 1) {
		553	return inheritedPaths.get(1);
		554	} else {
		555	return null;
		556	}
		557	}
		558
		559
		560	/**
		561	* Returns the included Mime paths.
		562	* For MimePath, which nests several MIME types (i.e. text/php/text/html/text/css), it enumerates
		563	* sub-paths so that a following element represents one level of nesting of the content.
		564	* For the example example, the return would be:
		565	* <ol>
		566	* <li>text/php/text/html/text/css -- the full path
		567	* <li>text/html/text/css -- outer content is removed
		568	* <li>text/css -- the mime type of the identified content itself
		569	* <li> (empty string)
		570	* </ol>
		571	* <p/>
		572	* If a MIME type on the path has a generic MIME type (i.e. text/x-ant+xml
		573	* has a generic MIME type text/xml), that generic type will be inserted. For example,
		574	* for text/java/text/x-ant+xml/text/javascript, the result will list:
		575	* <ol>
		576	* <li>text/java/text/x-ant+xml/text/javascript, -- the full MimePath
		577	* <li>text/x-ant+xml/text/javascript -- a prefix
		578	* <li>text/xml/text/javascript -- ant+xml is generalized to xml
		579	* <li>text/javascript
		580	* <li> (empty string)
		581	* </ol>
		582	* For all but {@link #EMPTY} MimePaths, the list contains at least one entry, and the last
		583	* entry is the {@link #EMPTY}. Note also, that the complete MimePath is always returned
		584	* as the 1st member of the list.
		585	* <p/>
		586	* The returned sequence of MimePaths is suitable for searching settings or services
		587	* for the (embedded) content whose type is described by MimePath as it is ordered from the
		588	* most specific to the least specific paths (including generalization) and always contains
		589	* the mime type of the identified contents. The last component ({@link ""}) represents
		590	* default settings (services).
		591	* <p/>
		592	* Note that for MimePaths created from a mime type (not empty!) string, the
		593	* <code>getInheritedPaths().get(1)</code> is a parent mime type. Either empty,
		594	* or the generalized MIME.
		595	* <p/>
		596	* The caller should not modify the returned List.
		597	*
		598	* @return list of inherited Mime paths
599	*/
600	public List<MimePath> getIncludedPaths() {
601	List<String> paths = getInheritedPaths(null, null);
602	List<MimePath> mpaths = new ArrayList<MimePath>(paths.size());
603	for (String p : paths) {
604	mpaths.add(MimePath.parse(p));
605	}
606	return mpaths;
607	}
608
535	// XXX: This is currently called from editor/settings/storage (SettingsProvider)	609	// XXX: This is currently called from editor/settings/storage (SettingsProvider)
536	// and editor/mimelookup/impl via reflection.	610	// and editor/mimelookup/impl via reflection.
537	// We will eventually make it friend API. In the meantime just	611	// We will eventually make it friend API. In the meantime just

Lines 138-157 Link Here

(-)a/editor.mimelookup/src/org/netbeans/modules/editor/mimelookup/MimePathLookup.java (-15 / +3 lines)
138	// See also http://www.netbeans.org/issues/show_bug.cgi?id=118099	138	// See also http://www.netbeans.org/issues/show_bug.cgi?id=118099
139		139
140	// Add lookups from deprecated MimeLookupInitializers	140	// Add lookups from deprecated MimeLookupInitializers
141	List<String> paths;	141	List<MimePath> paths = mimePath.getIncludedPaths();
142	try {	142	for(MimePath mp : paths) {
143	Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
144	m.setAccessible(true);
145	@SuppressWarnings("unchecked")
146	List<String> ret = (List<String>) m.invoke(mimePath, null, null);
147	paths = ret;
148	} catch (Exception e) {
149	LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
150	paths = Collections.singletonList(mimePath.getPath());
151	}
152
153	for(String path : paths) {
154	MimePath mp = MimePath.parse(path);
155	Collection<? extends MimeLookupInitializer> initializers = mimeInitializers.allInstances();	143	Collection<? extends MimeLookupInitializer> initializers = mimeInitializers.allInstances();
156		144
157	for(int i = 0; i < mp.size(); i++) {	145	for(int i = 0; i < mp.size(); i++) {
Lines 166-172 Link Here
166		154
167	for(MimeLookupInitializer mli : initializers) {	155	for(MimeLookupInitializer mli : initializers) {
168	if (LOG.isLoggable(Level.FINE)) {	156	if (LOG.isLoggable(Level.FINE)) {
169	LOG.fine("- Querying MimeLookupInitializer(" + path + "): " + mli); //NOI18N	157	LOG.fine("- Querying MimeLookupInitializer(" + mp.getPath() + "): " + mli); //NOI18N
170	}	158	}
171	Lookup mimePathLookup = mli.lookup();	159	Lookup mimePathLookup = mli.lookup();
172	if (mimePathLookup != null) {	160	if (mimePathLookup != null) {

Lines 48-53 Link Here

(-)a/editor.settings.storage/src/org/netbeans/modules/editor/settings/storage/api/EditorSettings.java (+19 lines)
48	import java.util.Collection;	48	import java.util.Collection;
49	import java.util.Map;	49	import java.util.Map;
50	import java.util.Set;	50	import java.util.Set;
		51	import java.util.prefs.Preferences;
51	import javax.swing.text.AttributeSet;	52	import javax.swing.text.AttributeSet;
52	import org.netbeans.modules.editor.settings.storage.EditorSettingsImpl;	53	import org.netbeans.modules.editor.settings.storage.EditorSettingsImpl;
53	import org.netbeans.modules.editor.settings.storage.MimeTypesTracker;	54	import org.netbeans.modules.editor.settings.storage.MimeTypesTracker;
Lines 321-324 Link Here
321	String propertyName,	322	String propertyName,
322	PropertyChangeListener l	323	PropertyChangeListener l
323	);	324	);
		325
		326	/**
		327	* Provides a temporary storage for Preferences, which can be
		328	* flushed to the delegate.
		329	* The returned object collects changes made through the {@link Preferences}
		330	* interface, but does not write them to the 'delegate' instance immediately.
		331	* It writes the changes (adds new keys, changes existing ones, removes the
		332	* obsolete keys) during {@link Preferences#flush}.
		333	* <p/>
		334	* The token controls the lifecycle of the Preferences tree. If left unattended,
		335	* it will be destroyed when the 'token' object becomes GCed. Each token instance
		336	* has its own full Preferences tree.
		337	*
		338	* @param token token to control lifecycle and separate instances
		339	* @param delegate the backing Preferences
		340	* @return Preferences with temporary storage.
		341	*/
		342	// public abstract MemoryPreferences getProxyPreferences(Object token, Preferences delegate);
324	}	343	}

Lines 113-124 Link Here

(-)a/editor.settings.storage/src/org/netbeans/modules/editor/settings/storage/fontscolors/CompositeFCS.java (-30 / +5 lines)
113	mimePath = mimePath.getPrefix(mimePath.size() - 1);	113	mimePath = mimePath.getPrefix(mimePath.size() - 1);
114	}	114	}
115		115
116	MimePath[] allPaths = computeInheritedMimePaths(mimePath);	116	List<MimePath> allPaths = mimePath.getIncludedPaths();
117	assert allPaths.length > 0 : "allPaths should always contain at least MimePath.EMPTY"; //NOI18N	117	assert allPaths.size() > 0 : "allPaths should always contain at least MimePath.EMPTY"; //NOI18N
118		118
119	this.allFcsi = new FontColorSettingsImpl[allPaths.length];	119	this.allFcsi = new FontColorSettingsImpl[allPaths.size()];
120	for (int i = 0; i < allPaths.length; i++) {	120	for (int i = 0; i < allPaths.size(); i++) {
121	allFcsi[i] = FontColorSettingsImpl.get(allPaths[i]);	121	allFcsi[i] = FontColorSettingsImpl.get(allPaths.get(i));
122	}	122	}
123		123
124	this.profile = profile;	124	this.profile = profile;
Lines 275-305 Link Here
275	System.out.println(sb.toString());	275	System.out.println(sb.toString());
276	}	276	}
277		277
278	private static MimePath[] computeInheritedMimePaths(MimePath mimePath) {
279	List<String> paths = null;
280	try {
281	Method m = MimePath.class.getDeclaredMethod("getInheritedPaths", String.class, String.class); //NOI18N
282	m.setAccessible(true);
283	@SuppressWarnings("unchecked")
284	List<String> ret = (List<String>) m.invoke(mimePath, null, null);
285	paths = ret;
286	} catch (Exception e) {
287	LOG.log(Level.WARNING, "Can't call org.netbeans.api.editor.mimelookup.MimePath.getInheritedPaths method.", e); //NOI18N
288	}
289
290	if (paths != null) {
291	ArrayList<MimePath> mimePaths = new ArrayList<MimePath>(paths.size());
292
293	for (String path : paths) {
294	mimePaths.add(MimePath.parse(path));
295	}
296
297	return mimePaths.toArray(new MimePath[mimePaths.size()]);
298	} else {
299	return new MimePath[]{mimePath, MimePath.EMPTY};
300	}
301	}
302
303	private Map<?, ?> getRenderingHints() {	278	private Map<?, ?> getRenderingHints() {
304	// This property was introduced in JDK1.6, see http://java.sun.com/javase/6/docs/api/java/awt/doc-files/DesktopProperties.html	279	// This property was introduced in JDK1.6, see http://java.sun.com/javase/6/docs/api/java/awt/doc-files/DesktopProperties.html
305	// We should probably also listen on the default toolkit for changes in this	280	// We should probably also listen on the default toolkit for changes in this

Line 0 Link Here

(-)a/editor.settings.storage/test/unit/src/org/netbeans/modules/editor/settings/storage/preferences/ProxyPreferencesImplTest.java (+544 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
		41	*/
		42
		43	package org.netbeans.modules.editor.settings.storage.preferences;
		44
		45	import java.lang.ref.Reference;
		46	import java.lang.ref.WeakReference;
		47	import java.util.Arrays;
		48	import java.util.Collections;
		49	import java.util.HashMap;
		50	import java.util.Map;
		51	import java.util.prefs.AbstractPreferences;
		52	import java.util.prefs.BackingStoreException;
		53	import java.util.prefs.Preferences;
		54	import static junit.framework.Assert.assertEquals;
		55	import org.netbeans.junit.NbTestCase;
		56	import org.netbeans.modules.editor.settings.storage.api.OverridePreferences;
		57	import org.netbeans.modules.editor.settings.storage.api.MemoryPreferences;
		58
		59	/**
		60	*
		61	* @author vita
		62	*/
		63	public class ProxyPreferencesImplTest extends NbTestCase {
		64
65	public ProxyPreferencesImplTest(String name) {
66	super(name);
67	}
68
69	public void testSimpleRead() {
70	Preferences orig = Preferences.userRoot().node(getName());
71	orig.put("key-1", "value-1");
72
73	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
74	assertEquals("Wrong value", "value-1", test.get("key-1", null));
75	}
76
77	public void testSimpleWrite() {
78	Preferences orig = Preferences.userRoot().node(getName());
79	assertNull("Original contains value", orig.get("key-1", null));
80
81	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
82	test.put("key-1", "xyz");
83	assertEquals("Wrong value", "xyz", test.get("key-1", null));
84	}
85
86	public void testBase64() {
87	Preferences orig = Preferences.userRoot().node(getName());
88	assertNull("Original contains value", orig.get("key-1", null));
89	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
90	test.putByteArray("key-1", "however you like it".getBytes());
91	assertEquals("Wrong value", "however you like it", new String(test.getByteArray("key-1", null)));
92	}
93
94	public void testSimpleSync() throws BackingStoreException {
95	Preferences orig = Preferences.userRoot().node(getName());
96	assertNull("Original contains value", orig.get("key-1", null));
97
98	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
99	assertNull("Test should not contains pair", orig.get("key-1", null));
100
101	test.put("key-1", "xyz");
102	assertEquals("Test doesn't contain new pair", "xyz", test.get("key-1", null));
103
104	test.sync();
105	assertNull("Test didn't rollback pair", test.get("key-1", null));
106	}
107
108	public void testSimpleFlush() throws BackingStoreException {
109	Preferences orig = Preferences.userRoot().node(getName());
110	assertNull("Original contains value", orig.get("key-1", null));
111
112	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
113	assertNull("Test should not contains pair", orig.get("key-1", null));
114
115	test.put("key-1", "xyz");
116	assertEquals("Test doesn't contain new pair", "xyz", test.get("key-1", null));
117
118	test.flush();
119	assertEquals("Test should still contain the pair", "xyz", test.get("key-1", null));
120	assertEquals("Test didn't flush the pair", "xyz", orig.get("key-1", null));
121	}
122
123	public void testSyncTree1() throws BackingStoreException {
124	String [] origTree = new String [] {
125	"CodeStyle/profile=GLOBAL",
126	};
127	String [] newTree = new String [] {
128	"CodeStyle/text/x-java/tab-size=2",
129	"CodeStyle/text/x-java/override-global-settings=true",
130	"CodeStyle/text/x-java/expand-tabs=true",
131	"CodeStyle/profile=PROJECT",
132	};
133
134	Preferences orig = Preferences.userRoot().node(getName());
135	write(orig, origTree);
136	checkContains(orig, origTree, "Orig");
137	checkNotContains(orig, newTree, "Orig");
138
139	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
140	checkEquals("Test should be the same as Orig", orig, test);
141
142	write(test, newTree);
143	checkContains(test, newTree, "Test");
144
145	test.sync();
146	checkContains(orig, origTree, "Orig");
147	checkNotContains(orig, newTree, "Orig");
148	checkContains(test, origTree, "Test");
149	checkNotContains(test, newTree, "Test");
150	}
151
152	public void testFlushTree1() throws BackingStoreException {
153	String [] origTree = new String [] {
154	"CodeStyle/profile=GLOBAL",
155	};
156	String [] newTree = new String [] {
157	"CodeStyle/text/x-java/tab-size=2",
158	"CodeStyle/text/x-java/override-global-settings=true",
159	"CodeStyle/text/x-java/expand-tabs=true",
160	"CodeStyle/profile=PROJECT",
161	};
162
163	Preferences orig = Preferences.userRoot().node(getName());
164	write(orig, origTree);
165	checkContains(orig, origTree, "Orig");
166	checkNotContains(orig, newTree, "Orig");
167
168	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
169	checkEquals("Test should be the same as Orig", orig, test);
170
171	write(test, newTree);
172	checkContains(test, newTree, "Test");
173
174	test.flush();
175	checkEquals("Test didn't flush to Orig", test, orig);
176	}
177
178	public void testRemoveKey() throws BackingStoreException {
179	Preferences orig = Preferences.userRoot().node(getName());
180	orig.put("key-2", "value-2");
181	assertNull("Original contains value", orig.get("key-1", null));
182	assertEquals("Original doesn't contain value", "value-2", orig.get("key-2", null));
183
184	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
185	test.put("key-1", "xyz");
186	assertEquals("Wrong value", "xyz", test.get("key-1", null));
187
188	test.remove("key-1");
189	assertNull("Test contains removed key-1", test.get("key-1", null));
190
191	test.remove("key-2");
192	assertNull("Test contains removed key-2", test.get("key-2", null));
193
194	test.flush();
195	assertNull("Test flushed removed key-1", orig.get("key-1", null));
196	assertNull("Test.flush did not remove removed key-2", orig.get("key-2", null));
197	}
198
199	public void testRemoveNode() throws BackingStoreException {
200	Preferences orig = Preferences.userRoot().node(getName());
201	Preferences origChild = orig.node("child");
202
203	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
204	assertTrue("Test child shoculd exist", test.nodeExists("child"));
205	Preferences testChild = test.node("child");
206
207	testChild.removeNode();
208	assertFalse("Removed test child should not exist", testChild.nodeExists(""));
209	assertFalse("Removed test child should not exist in parent", test.nodeExists("child"));
210
211	test.flush();
212	assertFalse("Test.flush did not remove orig child", origChild.nodeExists(""));
213	assertFalse("Test.flush did not remove orig child from parent", orig.nodeExists("child"));
214	}
215
216	public void testRemoveNodeCreateItAgain() throws BackingStoreException {
217	Preferences orig = Preferences.userRoot().node(getName());
218
219	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
220	Preferences testChild = test.node("child");
221
222	testChild.removeNode();
223	assertFalse("Removed test child should not exist", testChild.nodeExists(""));
224	assertFalse("Removed test child should not exist in parent", test.nodeExists("child"));
225
226	Preferences testChild2 = test.node("child");
227	assertTrue("Recreated test child should exist", testChild2.nodeExists(""));
228	assertTrue("Recreated test child should exist in parent", test.nodeExists("child"));
229	assertNotSame("Recreated child must not be the same as the removed one", testChild2, testChild);
230	assertEquals("Wrong childrenNames list", Arrays.asList(new String [] { "child" }), Arrays.asList(test.childrenNames()));
231
232	try {
233	testChild.get("key", null);
234	fail("Removed test node should not be accessible");
235	} catch (Exception e) {
236	}
237
238	try {
239	testChild2.get("key", null);
240	} catch (Exception e) {
241	fail("Recreated test node should be accessible");
242	}
243
244	}
245
246	public void testRemoveHierarchy() throws BackingStoreException {
247	String [] origTree = new String [] {
248	"R.CodeStyle.project.expand-tabs=true",
249	"R.CodeStyle.project.indent-shift-width=6",
250	"R.CodeStyle.project.spaces-per-tab=6",
251	"R.CodeStyle.project.tab-size=7",
252	"R.CodeStyle.project.text-limit-width=88",
253	"R.CodeStyle.usedProfile=project",
254	"R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
255	"R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
256	"R.text.x-ruby.CodeStyle.project.tab-size=2",
257	};
258	String [] newTree = new String [] {
259	"R.CodeStyle.project.expand-tabs=true",
260	"R.CodeStyle.project.indent-shift-width=3",
261	"R.CodeStyle.project.spaces-per-tab=3",
262	"R.CodeStyle.project.tab-size=5",
263	"R.CodeStyle.project.text-limit-width=77",
264	"R.CodeStyle.usedProfile=project",
265	"R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
266	"R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
267	"R.text.x-ruby.CodeStyle.project.tab-size=2",
268	};
269
270	Preferences orig = Preferences.userRoot().node(getName());
271	write(orig, origTree);
272
273	checkContains(orig, origTree, "Orig");
274
275	Preferences test = ProxyPreferencesImpl.getProxyPreferences(this, orig);
276	checkEquals("Test should be the same as Orig", orig, test);
277
278	Preferences testRoot = test.node("R");
279	removeAllKidsAndKeys(testRoot);
280
281	write(test, newTree);
282	checkContains(test, newTree, "Test");
283
284	test.flush();
285	checkEquals("Test didn't flush to Orig", test, orig);
286	}
287
288	public void testTreeGCed() throws BackingStoreException {
289	String [] newTree = new String [] {
290	"R.CodeStyle.project.expand-tabs=true",
291	"R.CodeStyle.project.indent-shift-width=3",
292	"R.CodeStyle.project.spaces-per-tab=3",
293	"R.CodeStyle.project.tab-size=5",
294	"R.CodeStyle.project.text-limit-width=77",
295	"R.CodeStyle.usedProfile=project",
296	"R.text.x-ruby.CodeStyle.project.indent-shift-width=2",
297	"R.text.x-ruby.CodeStyle.project.spaces-per-tab=2",
298	"R.text.x-ruby.CodeStyle.project.tab-size=2",
299	};
300
301	Preferences orig = Preferences.userRoot().node(getName());
302
303	Object treeToken = new Object();
304	Preferences test = ProxyPreferencesImpl.getProxyPreferences(treeToken, orig);
305	write(test, newTree);
306	checkContains(test, newTree, "Test");
307
308	Reference<Object> treeTokenRef = new WeakReference<Object>(treeToken);
309	Reference<Preferences> testRef = new WeakReference<Preferences>(test);
310	treeToken = null;
311	test = null;
312	assertGC("Tree token was not GCed", treeTokenRef, Collections.singleton(this));
313	// touch the WeakHashMap to expungeStaleEntries
314	Object dummyToken = new Object();
315	ProxyPreferencesImpl dummyPrefs = ProxyPreferencesImpl.getProxyPreferences(dummyToken, orig);
316	assertGC("Test preferences were not GCed", testRef, Collections.singleton(this));
317
318	}
319
320	/**
321	* Checks that a value not defined in delegate can be read from the parent prefs.
322	* Checks that if the parent prefs also do not define the value, the
323	* default from parameter is used.
324	*
325	* @throws Exception
326	*/
327	public void testInheritedRead() throws Exception {
328	Preferences stored = new MapPreferences();
329	Preferences inherited = new MapPreferences();
330
331	stored.put("key-1", "value-1");
332	stored.put("key-3", "override");
333	inherited.put("key-2", "value-2");
334	inherited.put("key-3", "base");
335
336	MemoryPreferences mem = MemoryPreferences.getWithInherited(this, inherited, stored);
337	Preferences test = mem.getPreferences();
338
339	assertEquals("Wrong value 1", "value-1", test.get("key-1", null));
340	assertEquals("Wrong value 2", "value-2", test.get("key-2", "a"));
341	assertEquals("Wrong value 3", "override", test.get("key-3", "a"));
342	assertEquals("Wrong value 4", "value-4", test.get("key-4", "value-4"));
343	}
344
345	/**
346	* Asserts that if a value is remove()d during editing, the inherited value
347	* will be seen through. Also checks that the Preferences key is actually
348	* deleted on flush() and the inherited preferences is not altered.
349	*/
350	public void testSeeInheritedThroughRemoves() throws Exception {
351	Preferences stored = new MapPreferences();
352	Preferences inherited = new MapPreferences();
353
354	stored.put("key", "value");
355	inherited.put("key", "parentValue");
356
357	MemoryPreferences mem = MemoryPreferences.getWithInherited(this, inherited, stored);
358	Preferences test = mem.getPreferences();
359
360	assertEquals("Does not see local value", "value", test.get("key", null));
361	test.remove("key");
362
363	assertEquals("Stored value changed prematurely", "value", stored.get("key", null));
364	assertEquals("Inherited not seen", "parentValue", test.get("key", null));
365
366	test.flush();
367	assertNull("Stored value not erased", stored.get("key", null));
368	assertEquals("Inherited changed", "parentValue", test.get("key", null));
369	}
370
371	// -----------------------------------------------------------------------
372	// private implementation
373	// -----------------------------------------------------------------------
374
375	private static class MapPreferences extends AbstractPreferences implements OverridePreferences {
376
377	private Map<String,Object> map = new HashMap<String, Object>();
378
379	public MapPreferences() {
380	super(null, ""); // NOI18N
381	}
382
383	@Override
384	public boolean isOverriden(String key) {
385	return map.containsKey(key);
386	}
387
388	protected void putSpi(String key, String value) {
389	map.put(key, value);
390	}
391
392	protected String getSpi(String key) {
393	return (String)map.get(key);
394	}
395
396	protected void removeSpi(String key) {
397	map.remove(key);
398	}
399
400	protected void removeNodeSpi() throws BackingStoreException {
401	throw new UnsupportedOperationException("Not supported yet.");
402	}
403
404	protected String[] keysSpi() throws BackingStoreException {
405	String array[] = new String[map.keySet().size()];
406	return map.keySet().toArray( array );
407	}
408
409	protected String[] childrenNamesSpi() throws BackingStoreException {
410	throw new UnsupportedOperationException("Not supported yet.");
411	}
412
413	protected AbstractPreferences childSpi(String name) {
414	throw new UnsupportedOperationException("Not supported yet.");
415	}
416
417	protected void syncSpi() throws BackingStoreException {
418	throw new UnsupportedOperationException("Not supported yet.");
419	}
420
421	protected void flushSpi() throws BackingStoreException {
422	throw new UnsupportedOperationException("Not supported yet.");
423	}
424	}
425
426	private void write(Preferences prefs, String[] tree) {
427	for(String s : tree) {
428	int equalIdx = s.lastIndexOf('=');
429	assertTrue(equalIdx != -1);
430	String value = s.substring(equalIdx + 1);
431
432	String key;
433	String nodePath;
434	int slashIdx = s.lastIndexOf('/', equalIdx);
435	if (slashIdx != -1) {
436	key = s.substring(slashIdx + 1, equalIdx);
437	nodePath = s.substring(0, slashIdx);
438	} else {
439	key = s.substring(0, equalIdx);
440	nodePath = "";
441	}
442
443	Preferences node = prefs.node(nodePath);
444	node.put(key, value);
445	}
446	}
447
448	private void checkContains(Preferences prefs, String[] tree, String prefsId) throws BackingStoreException {
449	for(String s : tree) {
450	int equalIdx = s.lastIndexOf('=');
451	assertTrue(equalIdx != -1);
452	String value = s.substring(equalIdx + 1);
453
454	String key;
455	String nodePath;
456	int slashIdx = s.lastIndexOf('/', equalIdx);
457	if (slashIdx != -1) {
458	key = s.substring(slashIdx + 1, equalIdx);
459	nodePath = s.substring(0, slashIdx);
460	} else {
461	key = s.substring(0, equalIdx);
462	nodePath = "";
463	}
464
465	assertTrue(prefsId + " doesn't contain node '" + nodePath + "'", prefs.nodeExists(nodePath));
466	Preferences node = prefs.node(nodePath);
467
468	String realValue = node.get(key, null);
469	assertNotNull(prefsId + ", '" + nodePath + "' node doesn't contain key '" + key + "'", realValue);
470	assertEquals(prefsId + ", '" + nodePath + "' node, '" + key + "' contains wrong value", value, realValue);
471	}
472	}
473
474	private void checkNotContains(Preferences prefs, String[] tree, String prefsId) throws BackingStoreException {
475	for(String s : tree) {
476	int equalIdx = s.lastIndexOf('=');
477	assertTrue(equalIdx != -1);
478	String value = s.substring(equalIdx + 1);
479
480	String key;
481	String nodePath;
482	int slashIdx = s.lastIndexOf('/', equalIdx);
483	if (slashIdx != -1) {
484	key = s.substring(slashIdx + 1, equalIdx);
485	nodePath = s.substring(0, slashIdx);
486	} else {
487	key = s.substring(0, equalIdx);
488	nodePath = "";
489	}
490
491	if (prefs.nodeExists(nodePath)) {
492	Preferences node = prefs.node(nodePath);
493	String realValue = node.get(key, null);
494	if (realValue != null && realValue.equals(value)) {
495	fail(prefsId + ", '" + nodePath + "' node contains key '" + key + "' = '" + realValue + "'");
496	}
497	}
498	}
499	}
500
501	private void dump(Preferences prefs, String prefsId) throws BackingStoreException {
502	for(String key : prefs.keys()) {
503	System.out.println(prefsId + ", " + prefs.absolutePath() + "/" + key + "=" + prefs.get(key, null));
504	}
505	for(String child : prefs.childrenNames()) {
506	dump(prefs.node(child), prefsId);
507	}
508	}
509
510	private void checkEquals(String msg, Preferences expected, Preferences test) throws BackingStoreException {
511	assertEquals("Won't compare two Preferences with different absolutePath", expected.absolutePath(), test.absolutePath());
512
513	// check the keys and their values
514	for(String key : expected.keys()) {
515	String expectedValue = expected.get(key, null);
516	assertNotNull(msg + "; Expected:" + expected.absolutePath() + " has no '" + key + "'", expectedValue);
517
518	String value = test.get(key, null);
519	assertNotNull(msg + "; Test:" + test.absolutePath() + " has no '" + key + "'", value);
520	assertEquals(msg + "; Test:" + test.absolutePath() + "/" + key + " has wrong value", expectedValue, value);
521	}
522
523	// check the children
524	for(String child : expected.childrenNames()) {
525	assertTrue(msg + "; Expected:" + expected.absolutePath() + " has no '" + child + "' subnode", expected.nodeExists(child));
526	Preferences expectedChild = expected.node(child);
527
528	assertTrue(msg + "; Test:" + test.absolutePath() + " has no '" + child + "' subnode", test.nodeExists(child));
529	Preferences testChild = test.node(child);
530
531	checkEquals(msg, expectedChild, testChild);
532	}
533	}
534
535	private void removeAllKidsAndKeys(Preferences prefs) throws BackingStoreException {
536	for(String kid : prefs.childrenNames()) {
537	prefs.node(kid).removeNode();
538	}
539	for(String key : prefs.keys()) {
540	prefs.remove(key);
541	}
542	}
543
544	}

Lines 29-52 Link Here

(-)a/options.editor/src/org/netbeans/modules/options/generaleditor/GeneralEditorPanel.form (-105 / +5 lines)
29	<Group type="102" attributes="0">	29	<Group type="102" attributes="0">
30	<Group type="103" groupAlignment="0" attributes="0">	30	<Group type="103" groupAlignment="0" attributes="0">
31	<Group type="102" alignment="0" attributes="0">	31	<Group type="102" alignment="0" attributes="0">
32	<EmptySpace max="-2" attributes="0"/>	32	<EmptySpace min="-2" pref="163" max="-2" attributes="0"/>
33	<Component id="lCollapseByDefault" min="-2" max="-2" attributes="0"/>
34	<EmptySpace max="-2" attributes="0"/>
35	<Group type="103" groupAlignment="0" attributes="0">	33	<Group type="103" groupAlignment="0" attributes="0">
36	<Component id="cbUseCodeFolding" alignment="0" min="-2" max="-2" attributes="0"/>
37	<Group type="102" alignment="0" attributes="0">	34	<Group type="102" alignment="0" attributes="0">
38	<Group type="103" groupAlignment="0" attributes="0">	35	<EmptySpace min="-2" pref="175" max="-2" attributes="0"/>
39	<Component id="cbFoldMethods" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>	36	<Component id="cbBraceTooltip" min="-2" max="-2" attributes="0"/>
40	<Component id="cbFoldInnerClasses" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
41	<Component id="cbFoldImports" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
42	</Group>
43	<EmptySpace type="separate" max="-2" attributes="0"/>
44	<Group type="103" groupAlignment="0" attributes="0">
45	<Component id="cbFoldJavadocComments" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
46	<Component id="cbFoldInitialComments" linkSize="1" alignment="0" min="-2" max="-2" attributes="0"/>
47	<Component id="cbFoldTags" alignment="0" min="-2" max="-2" attributes="0"/>
48	<Component id="cbBraceTooltip" min="-2" max="-2" attributes="0"/>
49	</Group>
50	</Group>	37	</Group>
51	<Component id="cbCamelCaseBehavior" alignment="0" min="-2" max="-2" attributes="0"/>	38	<Component id="cbCamelCaseBehavior" alignment="0" min="-2" max="-2" attributes="0"/>
52	<Group type="102" attributes="0">	39	<Group type="102" attributes="0">
Lines 54-63 Link Here
54	<Component id="lCamelCaseBehaviorExample" min="-2" max="-2" attributes="0"/>	41	<Component id="lCamelCaseBehaviorExample" min="-2" max="-2" attributes="0"/>
55	</Group>	42	</Group>
56	</Group>	43	</Group>
57	</Group>	44	<EmptySpace min="-2" pref="26" max="-2" attributes="0"/>
58	<Group type="102" alignment="0" attributes="0">
59	<EmptySpace min="12" pref="12" max="-2" attributes="0"/>
60	<Component id="lUseCodeFolding" min="-2" max="-2" attributes="0"/>
61	</Group>	45	</Group>
62	<Group type="102" alignment="0" attributes="0">	46	<Group type="102" alignment="0" attributes="0">
63	<EmptySpace max="-2" attributes="0"/>	47	<EmptySpace max="-2" attributes="0"/>
Lines 72-82 Link Here
72	<EmptySpace min="0" pref="12" max="32767" attributes="0"/>	56	<EmptySpace min="0" pref="12" max="32767" attributes="0"/>
73	</Group>	57	</Group>
74	<Group type="102" attributes="0">	58	<Group type="102" attributes="0">
75	<Component id="lCodeFolding" min="-2" max="-2" attributes="0"/>
76	<EmptySpace max="-2" attributes="0"/>
77	<Component id="jSeparator1" max="32767" attributes="0"/>
78	</Group>
79	<Group type="102" attributes="0">
80	<Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>	59	<Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>
81	<EmptySpace max="-2" attributes="0"/>	60	<EmptySpace max="-2" attributes="0"/>
82	<Component id="jSeparator6" max="32767" attributes="0"/>	61	<Component id="jSeparator6" max="32767" attributes="0"/>
Lines 97-129 Link Here
97	<DimensionLayout dim="1">	76	<DimensionLayout dim="1">
98	<Group type="103" groupAlignment="0" attributes="0">	77	<Group type="103" groupAlignment="0" attributes="0">
99	<Group type="102" alignment="0" attributes="0">	78	<Group type="102" alignment="0" attributes="0">
100	<EmptySpace min="-2" max="-2" attributes="0"/>
101	<Group type="103" groupAlignment="1" attributes="0">
102	<Component id="lCodeFolding" min="-2" max="-2" attributes="1"/>
103	<Component id="jSeparator1" min="-2" pref="10" max="-2" attributes="0"/>
104	</Group>
105	<EmptySpace max="-2" attributes="0"/>
106	<Group type="103" groupAlignment="0" attributes="0">
107	<Component id="cbUseCodeFolding" alignment="0" min="-2" max="-2" attributes="0"/>
108	<Component id="lUseCodeFolding" min="-2" max="-2" attributes="0"/>
109	</Group>
110	<EmptySpace max="-2" attributes="0"/>
111	<Group type="103" groupAlignment="3" attributes="0">
112	<Component id="lCollapseByDefault" alignment="3" min="-2" max="-2" attributes="0"/>
113	<Component id="cbFoldMethods" alignment="3" min="-2" max="-2" attributes="0"/>
114	<Component id="cbFoldJavadocComments" alignment="3" min="-2" max="-2" attributes="0"/>
115	</Group>
116	<EmptySpace max="-2" attributes="0"/>
117	<Group type="103" groupAlignment="3" attributes="0">
118	<Component id="cbFoldInnerClasses" alignment="3" min="-2" max="-2" attributes="0"/>
119	<Component id="cbFoldInitialComments" alignment="3" min="-2" max="-2" attributes="0"/>
120	</Group>
121	<EmptySpace max="-2" attributes="0"/>
122	<Group type="103" groupAlignment="3" attributes="0">
123	<Component id="cbFoldImports" alignment="3" min="-2" max="-2" attributes="0"/>
124	<Component id="cbFoldTags" alignment="3" min="-2" max="-2" attributes="0"/>
125	</Group>
126	<EmptySpace type="separate" max="-2" attributes="0"/>
127	<Group type="103" groupAlignment="1" attributes="0">	79	<Group type="103" groupAlignment="1" attributes="0">
128	<Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>	80	<Component id="lBracesMatching" min="-2" max="-2" attributes="0"/>
129	<Component id="jSeparator6" min="-2" pref="10" max="-2" attributes="0"/>	81	<Component id="jSeparator6" min="-2" pref="10" max="-2" attributes="0"/>
Lines 154-217 Link Here
154	</Group>	106	</Group>
155	<EmptySpace max="-2" attributes="0"/>	107	<EmptySpace max="-2" attributes="0"/>
156	<Component id="lSearchtypeTooltip" min="-2" max="-2" attributes="0"/>	108	<Component id="lSearchtypeTooltip" min="-2" max="-2" attributes="0"/>
157	<EmptySpace max="-2" attributes="0"/>	109	<EmptySpace min="0" pref="12" max="32767" attributes="0"/>
158	</Group>	110	</Group>
159	</Group>	111	</Group>
160	</DimensionLayout>	112	</DimensionLayout>
161	</Layout>	113	</Layout>
162	<SubComponents>	114	<SubComponents>
163	<Component class="javax.swing.JLabel" name="lCodeFolding">
164	<Properties>
165	<Property name="text" type="java.lang.String" value="Code Folding"/>
166	</Properties>
167	</Component>
168	<Component class="javax.swing.JLabel" name="lUseCodeFolding">
169	<Properties>
170	<Property name="labelFor" type="java.awt.Component" editor="org.netbeans.modules.form.ComponentChooserEditor">
171	<ComponentRef name="cbUseCodeFolding"/>
172	</Property>
173	<Property name="text" type="java.lang.String" value="Use Code Folding:"/>
174	</Properties>
175	</Component>
176	<Component class="javax.swing.JLabel" name="lCollapseByDefault">
177	<Properties>
178	<Property name="text" type="java.lang.String" value="Collapse by Default:"/>
179	</Properties>
180	</Component>
181	<Component class="javax.swing.JCheckBox" name="cbUseCodeFolding">
182	</Component>
183	<Component class="javax.swing.JCheckBox" name="cbFoldMethods">
184	<Properties>
185	<Property name="text" type="java.lang.String" value="Methods"/>
186	</Properties>
187	</Component>
188	<Component class="javax.swing.JCheckBox" name="cbFoldInnerClasses">
189	<Properties>
190	<Property name="text" type="java.lang.String" value="Inner Classes"/>
191	</Properties>
192	</Component>
193	<Component class="javax.swing.JCheckBox" name="cbFoldImports">
194	<Properties>
195	<Property name="text" type="java.lang.String" value="Imports"/>
196	</Properties>
197	</Component>
198	<Component class="javax.swing.JCheckBox" name="cbFoldJavadocComments">
199	<Properties>
200	<Property name="text" type="java.lang.String" value="Javadoc Comments"/>
201	</Properties>
202	</Component>
203	<Component class="javax.swing.JCheckBox" name="cbFoldInitialComments">
204	<Properties>
205	<Property name="text" type="java.lang.String" value="Initial Comments"/>
206	</Properties>
207	</Component>
208	<Component class="javax.swing.JCheckBox" name="cbFoldTags">
209	<Properties>
210	<Property name="text" type="java.lang.String" value="Tags and Other Code Blocks"/>
211	</Properties>
212	</Component>
213	<Component class="javax.swing.JSeparator" name="jSeparator1">
214	</Component>
215	<Component class="javax.swing.JLabel" name="lBracesMatching">	115	<Component class="javax.swing.JLabel" name="lBracesMatching">
216	<Properties>	116	<Properties>
217	<Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">	117	<Property name="text" type="java.lang.String" editor="org.netbeans.modules.i18n.form.FormI18nStringEditor">

Lines 76-93 Link Here

(-)a/options.editor/src/org/netbeans/modules/options/generaleditor/GeneralEditorPanel.java (-144 / +6 lines)
76	public GeneralEditorPanel () {	76	public GeneralEditorPanel () {
77	initComponents ();	77	initComponents ();
78		78
79	loc (lCodeFolding, "Code_Folding");
80	loc (lUseCodeFolding, "Code_Folding_Section");
81	loc (lCollapseByDefault, "Fold_by_Default");
82
83	loc (cbUseCodeFolding, "Use_Folding");
84	loc (cbFoldMethods, "Fold_Methods");
85	loc (cbFoldInnerClasses, "Fold_Classes");
86	loc (cbFoldImports, "Fold_Imports");
87	loc (cbFoldJavadocComments, "Fold_JavaDoc");
88	loc (cbFoldInitialComments, "Fold_Licence");
89	loc (cbFoldTags, "Fold_Tags");
90
91	loc (lCamelCaseBehavior, "Camel_Case_Behavior");	79	loc (lCamelCaseBehavior, "Camel_Case_Behavior");
92	loc (cbCamelCaseBehavior, "Enable_Camel_Case_In_Java");	80	loc (cbCamelCaseBehavior, "Enable_Camel_Case_In_Java");
93	loc (lCamelCaseBehaviorExample, "Camel_Case_Behavior_Example");	81	loc (lCamelCaseBehaviorExample, "Camel_Case_Behavior_Example");
Lines 99-105 Link Here
99	loc (cbBraceTooltip, "Brace_First_Tooltip");	87	loc (cbBraceTooltip, "Brace_First_Tooltip");
100	loc (cbShowBraceOutline, "Brace_Show_Outline");	88	loc (cbShowBraceOutline, "Brace_Show_Outline");
101		89
102	cbUseCodeFolding.setMnemonic(NbBundle.getMessage (GeneralEditorPanel.class, "MNEMONIC_Use_Folding").charAt(0));
103	cboEditorSearchType.setRenderer(new EditorSearchTypeRenderer(cboEditorSearchType.getRenderer()));	90	cboEditorSearchType.setRenderer(new EditorSearchTypeRenderer(cboEditorSearchType.getRenderer()));
104	cboEditorSearchType.setModel(new DefaultComboBoxModel(new Object [] { "default", "closing"})); //NOI18N	91	cboEditorSearchType.setModel(new DefaultComboBoxModel(new Object [] { "default", "closing"})); //NOI18N
105	cboEditorSearchType.addActionListener( new ActionListener() {	92	cboEditorSearchType.addActionListener( new ActionListener() {
Lines 123-139 Link Here
123	// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents	110	// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
124	private void initComponents() {	111	private void initComponents() {
125		112
126	lCodeFolding = new javax.swing.JLabel();
127	lUseCodeFolding = new javax.swing.JLabel();
128	lCollapseByDefault = new javax.swing.JLabel();
129	cbUseCodeFolding = new javax.swing.JCheckBox();
130	cbFoldMethods = new javax.swing.JCheckBox();
131	cbFoldInnerClasses = new javax.swing.JCheckBox();
132	cbFoldImports = new javax.swing.JCheckBox();
133	cbFoldJavadocComments = new javax.swing.JCheckBox();
134	cbFoldInitialComments = new javax.swing.JCheckBox();
135	cbFoldTags = new javax.swing.JCheckBox();
136	jSeparator1 = new javax.swing.JSeparator();
137	lBracesMatching = new javax.swing.JLabel();	113	lBracesMatching = new javax.swing.JLabel();
138	cbShowBraceOutline = new javax.swing.JCheckBox();	114	cbShowBraceOutline = new javax.swing.JCheckBox();
139	cbBraceTooltip = new javax.swing.JCheckBox();	115	cbBraceTooltip = new javax.swing.JCheckBox();
Lines 150-174 Link Here
150		126
151	setForeground(new java.awt.Color(99, 130, 191));	127	setForeground(new java.awt.Color(99, 130, 191));
152		128
153	lCodeFolding.setText("Code Folding");
154
155	lUseCodeFolding.setLabelFor(cbUseCodeFolding);
156	lUseCodeFolding.setText("Use Code Folding:");
157
158	lCollapseByDefault.setText("Collapse by Default:");
159
160	cbFoldMethods.setText("Methods");
161
162	cbFoldInnerClasses.setText("Inner Classes");
163
164	cbFoldImports.setText("Imports");
165
166	cbFoldJavadocComments.setText("Javadoc Comments");
167
168	cbFoldInitialComments.setText("Initial Comments");
169
170	cbFoldTags.setText("Tags and Other Code Blocks");
171
172	lBracesMatching.setText(org.openide.util.NbBundle.getMessage(GeneralEditorPanel.class, "BRACES_MATCHING")); // NOI18N	129	lBracesMatching.setText(org.openide.util.NbBundle.getMessage(GeneralEditorPanel.class, "BRACES_MATCHING")); // NOI18N
173		130
174	cbShowBraceOutline.setText("Show outline");	131	cbShowBraceOutline.setText("Show outline");
Lines 200-228 Link Here
200	.addGroup(layout.createSequentialGroup()	157	.addGroup(layout.createSequentialGroup()
201	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)	158	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
202	.addGroup(layout.createSequentialGroup()	159	.addGroup(layout.createSequentialGroup()
203	.addContainerGap()	160	.addGap(163, 163, 163)
204	.addComponent(lCollapseByDefault)
205	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
206	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)	161	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
207	.addComponent(cbUseCodeFolding)
208	.addGroup(layout.createSequentialGroup()	162	.addGroup(layout.createSequentialGroup()
209	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)	163	.addGap(175, 175, 175)
210	.addComponent(cbFoldMethods)	164	.addComponent(cbBraceTooltip))
211	.addComponent(cbFoldInnerClasses)
212	.addComponent(cbFoldImports))
213	.addGap(18, 18, 18)
214	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
215	.addComponent(cbFoldJavadocComments)
216	.addComponent(cbFoldInitialComments)
217	.addComponent(cbFoldTags)
218	.addComponent(cbBraceTooltip)))
219	.addComponent(cbCamelCaseBehavior)	165	.addComponent(cbCamelCaseBehavior)
220	.addGroup(layout.createSequentialGroup()	166	.addGroup(layout.createSequentialGroup()
221	.addGap(21, 21, 21)	167	.addGap(21, 21, 21)
222	.addComponent(lCamelCaseBehaviorExample, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))))	168	.addComponent(lCamelCaseBehaviorExample, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)))
223	.addGroup(layout.createSequentialGroup()	169	.addGap(26, 26, 26))
224	.addGap(12, 12, 12)
225	.addComponent(lUseCodeFolding))
226	.addGroup(layout.createSequentialGroup()	170	.addGroup(layout.createSequentialGroup()
227	.addContainerGap()	171	.addContainerGap()
228	.addComponent(lEditorSearchType)	172	.addComponent(lEditorSearchType)
Lines 232-241 Link Here
232	.addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))))	176	.addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))))
233	.addGap(0, 12, Short.MAX_VALUE))	177	.addGap(0, 12, Short.MAX_VALUE))
234	.addGroup(layout.createSequentialGroup()	178	.addGroup(layout.createSequentialGroup()
235	.addComponent(lCodeFolding)
236	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
237	.addComponent(jSeparator1))
238	.addGroup(layout.createSequentialGroup()
239	.addComponent(lBracesMatching)	179	.addComponent(lBracesMatching)
240	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)	180	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
241	.addComponent(jSeparator6))	181	.addComponent(jSeparator6))
Lines 248-281 Link Here
248	.addGap(0, 0, Short.MAX_VALUE))	188	.addGap(0, 0, Short.MAX_VALUE))
249	.addComponent(jSeparator3)))	189	.addComponent(jSeparator3)))
250	);	190	);
251
252	layout.linkSize(javax.swing.SwingConstants.HORIZONTAL, new java.awt.Component[] {cbFoldImports, cbFoldInitialComments, cbFoldInnerClasses, cbFoldJavadocComments, cbFoldMethods});
253
254	layout.setVerticalGroup(	191	layout.setVerticalGroup(
255	layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)	192	layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
256	.addGroup(layout.createSequentialGroup()	193	.addGroup(layout.createSequentialGroup()
257	.addContainerGap()
258	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
259	.addComponent(lCodeFolding)
260	.addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))
261	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
262	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
263	.addComponent(cbUseCodeFolding)
264	.addComponent(lUseCodeFolding))
265	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
266	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
267	.addComponent(lCollapseByDefault)
268	.addComponent(cbFoldMethods)
269	.addComponent(cbFoldJavadocComments))
270	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
271	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
272	.addComponent(cbFoldInnerClasses)
273	.addComponent(cbFoldInitialComments))
274	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
275	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
276	.addComponent(cbFoldImports)
277	.addComponent(cbFoldTags))
278	.addGap(18, 18, 18)
279	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)	194	.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
280	.addComponent(lBracesMatching)	195	.addComponent(lBracesMatching)
281	.addComponent(jSeparator6, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))	196	.addComponent(jSeparator6, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))
Lines 301-307 Link Here
301	.addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))	216	.addComponent(cboEditorSearchType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
302	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)	217	.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
303	.addComponent(lSearchtypeTooltip, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)	218	.addComponent(lSearchtypeTooltip, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
304	.addContainerGap())	219	.addGap(0, 12, Short.MAX_VALUE))
305	);	220	);
306	}// </editor-fold>//GEN-END:initComponents	221	}// </editor-fold>//GEN-END:initComponents
307		222
Lines 309-336 Link Here
309	// Variables declaration - do not modify//GEN-BEGIN:variables	224	// Variables declaration - do not modify//GEN-BEGIN:variables
310	private javax.swing.JCheckBox cbBraceTooltip;	225	private javax.swing.JCheckBox cbBraceTooltip;
311	private javax.swing.JCheckBox cbCamelCaseBehavior;	226	private javax.swing.JCheckBox cbCamelCaseBehavior;
312	private javax.swing.JCheckBox cbFoldImports;
313	private javax.swing.JCheckBox cbFoldInitialComments;
314	private javax.swing.JCheckBox cbFoldInnerClasses;
315	private javax.swing.JCheckBox cbFoldJavadocComments;
316	private javax.swing.JCheckBox cbFoldMethods;
317	private javax.swing.JCheckBox cbFoldTags;
318	private javax.swing.JCheckBox cbShowBraceOutline;	227	private javax.swing.JCheckBox cbShowBraceOutline;
319	private javax.swing.JCheckBox cbUseCodeFolding;
320	private javax.swing.JComboBox cboEditorSearchType;	228	private javax.swing.JComboBox cboEditorSearchType;
321	private javax.swing.JSeparator jSeparator1;
322	private javax.swing.JSeparator jSeparator3;	229	private javax.swing.JSeparator jSeparator3;
323	private javax.swing.JSeparator jSeparator5;	230	private javax.swing.JSeparator jSeparator5;
324	private javax.swing.JSeparator jSeparator6;	231	private javax.swing.JSeparator jSeparator6;
325	private javax.swing.JLabel lBracesMatching;	232	private javax.swing.JLabel lBracesMatching;
326	private javax.swing.JLabel lCamelCaseBehavior;	233	private javax.swing.JLabel lCamelCaseBehavior;
327	private javax.swing.JLabel lCamelCaseBehaviorExample;	234	private javax.swing.JLabel lCamelCaseBehaviorExample;
328	private javax.swing.JLabel lCodeFolding;
329	private javax.swing.JLabel lCollapseByDefault;
330	private javax.swing.JLabel lEditorSearchType;	235	private javax.swing.JLabel lEditorSearchType;
331	private javax.swing.JLabel lSearch;	236	private javax.swing.JLabel lSearch;
332	private javax.swing.JLabel lSearchtypeTooltip;	237	private javax.swing.JLabel lSearchtypeTooltip;
333	private javax.swing.JLabel lUseCodeFolding;
334	// End of variables declaration//GEN-END:variables	238	// End of variables declaration//GEN-END:variables
335		239
336		240
Lines 362-389 Link Here
362	listen = false;	266	listen = false;
363	if (model == null) {	267	if (model == null) {
364	model = new Model ();	268	model = new Model ();
365	cbUseCodeFolding.addActionListener (this);
366	cbFoldMethods.addActionListener (this);
367	cbFoldInnerClasses.addActionListener (this);
368	cbFoldImports.addActionListener (this);
369	cbFoldJavadocComments.addActionListener (this);
370	cbFoldInitialComments.addActionListener (this);
371	cbCamelCaseBehavior.addActionListener (this);	269	cbCamelCaseBehavior.addActionListener (this);
372	cbFoldTags.addActionListener (this);
373	cboEditorSearchType.addActionListener(this);	270	cboEditorSearchType.addActionListener(this);
374	cbBraceTooltip.addActionListener(this);	271	cbBraceTooltip.addActionListener(this);
375	cbShowBraceOutline.addActionListener(this);	272	cbShowBraceOutline.addActionListener(this);
376	}	273	}
377		274
378	// init code folding
379	cbUseCodeFolding.setSelected (model.isShowCodeFolding ());
380	cbFoldImports.setSelected (model.isFoldImports ());
381	cbFoldInitialComments.setSelected (model.isFoldInitialComment ());
382	cbFoldInnerClasses.setSelected (model.isFoldInnerClasses ());
383	cbFoldJavadocComments.setSelected (model.isFoldJavaDocComments ());
384	cbFoldMethods.setSelected (model.isFoldMethods ());
385	cbFoldTags.setSelected (model.isFoldTag());
386
387	// Java Camel Case Navigation	275	// Java Camel Case Navigation
388	Boolean ccJava = model.isCamelCaseJavaNavigation();	276	Boolean ccJava = model.isCamelCaseJavaNavigation();
389	if ( ccJava == null ) {	277	if ( ccJava == null ) {
Lines 400-407 Link Here
400	cbBraceTooltip.setSelected(model.isBraceTooltip());	288	cbBraceTooltip.setSelected(model.isBraceTooltip());
401	cbShowBraceOutline.setSelected(model.isBraceOutline());	289	cbShowBraceOutline.setSelected(model.isBraceOutline());
402		290
403	updateEnabledState ();
404
405	listen = true;	291	listen = true;
406	}	292	}
407		293
Lines 409-425 Link Here
409		295
410	if (model == null \|\| !changed) return;	296	if (model == null \|\| !changed) return;
411		297
412	// code folding options
413	model.setFoldingOptions (
414	cbUseCodeFolding.isSelected (),
415	cbFoldImports.isSelected (),
416	cbFoldInitialComments.isSelected (),
417	cbFoldInnerClasses.isSelected (),
418	cbFoldJavadocComments.isSelected (),
419	cbFoldMethods.isSelected (),
420	cbFoldTags.isSelected ()
421	);
422
423	// java camel case navigation	298	// java camel case navigation
424	model.setCamelCaseNavigation(cbCamelCaseBehavior.isSelected());	299	model.setCamelCaseNavigation(cbCamelCaseBehavior.isSelected());
425		300
Lines 446-470 Link Here
446	@Override	321	@Override
447	public void actionPerformed (ActionEvent e) {	322	public void actionPerformed (ActionEvent e) {
448	if (!listen) return;	323	if (!listen) return;
449	if (e.getSource () == cbUseCodeFolding) {
450	updateEnabledState ();
451	}
452	changed = true;	324	changed = true;
453	}	325	}
454		326
455		327
456	// other methods ...........................................................	328	// other methods ...........................................................
457		329
458	private void updateEnabledState () {
459	boolean useCodeFolding = cbUseCodeFolding.isSelected ();
460	cbFoldImports.setEnabled (useCodeFolding);
461	cbFoldInitialComments.setEnabled (useCodeFolding);
462	cbFoldInnerClasses.setEnabled (useCodeFolding);
463	cbFoldJavadocComments.setEnabled (useCodeFolding);
464	cbFoldMethods.setEnabled (useCodeFolding);
465	cbFoldTags.setEnabled(useCodeFolding);
466	}
467
468	private static final class EditorSearchTypeRenderer implements ListCellRenderer {	330	private static final class EditorSearchTypeRenderer implements ListCellRenderer {
469		331
470	private final ListCellRenderer defaultRenderer;	332	private final ListCellRenderer defaultRenderer;

Lines 116-122 Link Here

(-)a/php.editor/src/org/netbeans/modules/php/editor/resources/layer.xml (-1 / +11 lines)
116	<file name="org-netbeans-modules-php-editor-sql-PHPSQLCompletion.instance"/>	116	<file name="org-netbeans-modules-php-editor-sql-PHPSQLCompletion.instance"/>
117	</folder>	117	</folder>
118	<folder name="FoldManager">	118	<folder name="FoldManager">
119	<file name="org-netbeans-editor-CustomFoldManager$Factory.instance"/>	119	<file name="CustomFoldManager.instance">
		120	<attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.FoldManagerFactory"/>
		121	<attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.userFoldManagerFactory"/>
		122	</file>
		123	<file name="PHPDocReader.instance">
		124	<attr name="instanceOf" stringvalue="org.netbeans.spi.editor.fold.ContentReader$Factory"/>
		125	<attr name="instanceCreate" methodvalue="org.netbeans.api.editor.fold.FoldingSupport.contentReaderFactory"/>
		126	<attr name="start" stringvalue="*"/>
		127	<attr name="terminator" stringvalue="\."/>
		128	<attr name="stop" stringvalue="@"/>
		129	</file>
120	</folder>	130	</folder>
121	<!--issue #127161:-->	131	<!--issue #127161:-->
122	<folder name="Popup">	132	<folder name="Popup">